The mandate at every company right now: building software got cheap, so you don't need to buy as much of it. Make everyone a builder. Bring the saas in-house.
And honestly, it's not wrong. The economics really did shift.
Run that mandate through every team in your company. A year in, your stack is a pile of homegrown tools.
For a lot of stuff, that's the right call. The non load-bearing workflows. The internal dashboard. The little admin tool. The Slack bot one team needs and nobody else touches. The bespoke logic specific to how your business actually works. Buying a saas seat for that used to make sense because building was expensive. Now it isn't. So people build.
Fine. Good, even.
But here's what nobody's talking about.
You don't get one homegrown tool. You get fifty.
When building gets that cheap, the math doesn't stop at "build instead of buy." It runs to its logical conclusion. Every team spins up their own thing. Every workflow gets its own little app. Marketing has a script. Sales has a tool someone built in an afternoon. Ops has three.
None of them talk to each other. None of them are documented. None of them have an owner once the person who built it moves teams or leaves the company.
We didn't kill saas sprawl. We just moved it in-house. And we took away the vendor who at least kept the lights on.
The old problem was paying for too many tools. The new problem is owning too many tools.
And owning is so much worse than paying.
Owning is the hidden cost
A tool you bought has a company behind it. Updates. Bug fixes. A support line. A roadmap. Compliance reviews. Someone whose actual job it is to keep the thing alive.
A tool you built has whoever built it. Until they don't.
The day Sarah moves to a different team, that workflow goes from "internal tool" to "tribal knowledge in a private repo." The day she leaves the company, it goes from "tribal knowledge" to "a thing nobody touches because nobody knows what it does." And the day it breaks, you find out that the workflow it ran was actually load-bearing after all.
The drag isn't visible the way a saas invoice is. There's no renewal email. No procurement review. No line item to argue about in a budget meeting. It just sort of becomes part of the landscape. And then one day the landscape costs more than anyone realized.
The question inverted
So the build vs. buy question didn't go away. It flipped.
It used to be: can we build this instead of paying for it?
Now it's: can we afford to own this forever, just because it was cheap to make once?
Those are very different questions. The first one is about cost. The second one is about commitment.
Building a thing in an afternoon is a one-time act. Owning a thing is a forever decision. You're signing up to be its support team, its product manager, its security reviewer, its on-call rotation, every time someone clicks the button. Forever.
Cheap to build was never the hard part. Cheap to maintain doesn't exist. It never has.
Buy comes back
Stranded solutions get rewritten or replaced. Some get swapped out for vendor software, because buying becomes the path of least resistance for the workflows nobody wanted to own anyway.
And buying itself gets easier. The same forces that made it cheap to build an internal tool make it cheap to evaluate, integrate, and adopt vendor software too. The 90-day RFP becomes a weekend trial.
But the saas that comes back isn't the saas we remember. It comes back as point solutions: narrow, single-purpose tools, or sets of tools, that plug directly into agentic platforms. Agents do the integration work buyers used to. The categories look familiar. The shape of the product doesn't.
So buy comes back. Not as saas, but as Services as Software.
But the endpoint isn't fewer tools
The owned stack doesn't shrink back. Once a workflow has been built around how your team actually works, swapping it for a generic vendor tool feels like a downgrade. We'll get better at running what we own. Internal platforms mature. Maintenance becomes a real practice, not a side quest.
But buying comes back, and the case for it gets sharper. The systems worth paying for are the ones whose workflows never stop shifting, because the business shifts, the way people work shifts, and the rules around all of it shift. DevOps. Code review. Customer support. Marketing ops. You're not buying the product. You're buying a team whose only job is to keep adapting it. That's not overhead. That's leverage you can't manufacture.
You build a lot. You don't build everything.
That's a structural shift, not a fad you can wait out.
Owning well, buying well
I used to think the answer was discipline. Don't let teams build things they can't own.
I don't think that's quite right anymore.
The owned layer is going to grow regardless. The right response is to build muscle for both sides.
Owning well: ownership that transfers, documentation that survives, operational practices to match.
Buying well: knowing what's worth handing back to a vendor, and what isn't.
What comes next is the saas revival. Most of the homegrown pile won't outlast it. The pieces that do are the ones you treated like real software, not weekend projects.