Custom Is Making a Comeback

The advice was right for forty years: stop building your own software. That advice is about to be wrong — and it is the same fact that made it correct that now reverses it.

Software was expensive to build. So the industry spent decades engineering the expense away: it moved you off systems you built and onto systems you bought, then onto systems you merely rent. Each step was rational. Each solved a real problem. And each one quietly asked for something in return — until the thing you were left renting was the one thing that was ever worth owning.

That trade is now reversing, because the single force underneath all of it — the cost of building — just collapsed. This is the story of how we came to be entangled with our vendors, why the entanglement made sense at the time, and why the one moment to reconsider it is the transition almost every company is about to attempt anyway.

The single force underneath all of it, the cost of building, just collapsed. Every reason to rent weakens at once.

In the beginning, everything was custom

Software started bespoke. If you wanted a system, you built it — for your company, by people who understood your company. The result was a mirror of how the business actually ran: its logic, its exceptions, the hard-won rules about how this business, specifically, made money. It was expensive. It was slow. And it was entirely yours.

Then the model broke — not the software, the way of making it. Fred Brooks named the mechanism in 1975, watching IBM’s OS/360 collapse under its own weight: adding people to a late project makes it later. Every new person multiplied the communication overhead faster than they added output. Building didn’t scale with headcount; it drowned in coordination. And what you managed to build, you then had to keep alive — as the people who wrote it left with the context in their heads, as maintenance came to require specialists, as the system ossified until changing it got risky, and as evolving it fast enough became something no one could afford.

Custom software didn’t fail because it was a bad idea. It failed because it was unsustainable at the price of the day. The problem was never fit. It was cost — the cost of building, and the far larger cost of keeping what you built alive.

Custom didn’t fail because it was a bad idea. It failed because it was unsustainable at the price of the day.

So we standardized — and the trade was a fair one

The answer was to stop building and start buying. Packaged software arrived with a genuinely good bargain: let someone else absorb the cost of building and maintaining, get proven practice out of the box, reach value faster, and spread the risk across every other company that bought the same thing. SAP shipped its first end-to-end package in 1979; by 1990 Gartner had a name for the category — ERP — and the promise of one integrated system as a single source of truth. The pendulum swung from build to buy, and for most companies it was the right swing.

But notice how the bargain worked, because this is the part everyone forgets when they later feel stuck. Standardization solved the maintenance problem by design — and the design was to standardize your workflow and pool your data into the vendor’s model. That entanglement wasn’t a flaw in the deal. It was the mechanism that made the deal work. You accepted that your business would conform to the software, because conformance was exactly what let someone else carry the maintenance you could no longer afford.

So the entanglement was, at first, the fix. That is the honest version of this history, and it matters: nobody was foolish and nobody was tricked. A real problem — custom was unsustainable — was solved by a real trade, entered in good faith on both sides. The price was conformance: you reshaped the business to fit the software instead of the reverse, and your differentiation slowly stopped living in your systems. At the time, a fair price to pay.

Then SaaS deepened it

SaaS extended the same logic one step further. Salesforce launched in 1999 on a one-word idea — No Software — and the meaning underneath it was that you would no longer own the code, or even the running instance. You would subscribe to it. Through the 2000s and 2010s the whole enterprise stack followed, and the model delivered a great deal of real value: no servers to run, continuous updates, elastic scale.

It also completed a quiet shift in where your competitive edge lived. The architecture that makes SaaS efficient — one system serving every customer — is the same architecture that means every company on it gets the same capabilities, the same constraints, the same roadmap. The layer that was once where you might differentiate became, for most companies, a layer where everyone was largely identical. That was an acceptable trade for functions where you want to be standard. It was a subtler cost for the functions that are supposed to make you different.

And underneath the subscription, the same two things that standardization introduced kept deepening, a little more every day the system ran. Your workflow conformed to the software until the vendor’s assumptions quietly became your operating procedure — not written down anywhere as yours, just how the screens flow. And your data accumulated inside the vendor’s model, meaning what it means because of the workflow that produced it. Neither of these is a scheme. They are the natural result of using a system well, for years. But together they are why leaving stops being a product decision and becomes a risk decision.

The moat moved — and the vendors will tell you so

Here is the part that a fair reading has to get right, because the cheap version of this argument is wrong. The incumbents did not survive by trapping anyone. They survived by building something genuinely valuable, and they’ll describe it to you plainly if you ask.

ServiceNow calls the workflow data accumulating on its platform a knowledge gravity advantage — a deep record of not just what an enterprise did but the why behind past decisions, the kind of institutional memory a brand-new competitor simply doesn’t have. That is real, and it is earned. An investment write-up puts the mechanism in neutral terms: the more business processes run through the platform, the greater the switching costs, the data advantage, and the room to cross-sell. Said without judgment, that is simply a well-run strategy — and every major platform, Salesforce and SAP and Microsoft among them, is running a version of it.

That is why the most interesting move of the last two years has been incumbents repositioning themselves as the layer that orchestrates AI agents and holds the workflow data, rather than the interface you log into, and it is happening just as AI coding assistants, now used by the vast majority of developers, up from about a third two years ago, make the interface itself cheap to reproduce. One of Salesforce’s own founders said out loud that customers may reach a point where they never log into the application at all. Read that as what it is: a clear-eyed company defending the durable asset, the data and the workflow, now that the product alone no longer holds anyone. This is not a criticism of these companies. It is an observation about where the value sits. And it sets up the honest question every buyer now faces.

The greenfield test

Ask it this way. If you were starting your company today — no installed base, no history, no migration to fear — would you buy the incumbent suite for the workflow that makes you different?

Almost no one would. They would build it, or take an open-source foundation and shape it to how they actually work, because the thing that once made buying obviously correct is no longer true: building was ruinously expensive, and it isn’t anymore. The product’s pull, on its own merits, for a company with no history, is weak.

And yet those same companies have enormous staying power. Not because anyone would choose them fresh, but because almost no one is fresh. The existing customer is entangled: data in the vendor’s model, workflow shaped to the vendor’s software, and unwinding that mid-flight is a risk most C-suites, reasonably, will not take on. The market has started to price exactly this gap: through 2026, several large software companies saw their valuations fall not because revenue dropped but because net-new customer growth slowed and, in at least one case, enterprise seat count declined for the first time in the company’s history. The base stays. The newcomers don’t arrive. The distance between “nobody would choose this today” and “everybody who has it stays” is the whole story, and that distance is measured in data and workflow, not in features.

SaaS isn’t dying. It’s reinventing — and the entanglement is why it can

It would be easy, and wrong, to call this the death of SaaS. It isn’t. Global SaaS spending is still projected to climb toward $576 billion by 2029; Forrester, hardly a hype shop, has said plainly that the “death of the core” narrative is overstated. The category is healthy. It is reinventing itself — into agent-orchestration platforms, into governed data layers, into the control tower for the very AI that was supposed to displace it. ServiceNow’s AI business alone crossed a billion dollars in annual contract value.

But sit with why the reinvention works. A business that had to compete for its core customers purely on product merit, every renewal, could not reinvent itself this calmly. These companies can pivot into the agentic era from a position of stability precisely because their retention no longer depends on being the best choice — it depends on the entanglement they’ve earned. That is not a knock. It is the mechanism. Reinvention is what a business does gracefully when its customers are staying for reasons that sit underneath the product. The software isn’t dying because the software was never really the thing holding you. Your data and your process are — and they’re still exactly where they’ve been for years.

There’s a historical rhyme worth naming. The ERP switching costs of the 1990s were at least visible: a migration was a multi-year project with a defined price tag and explicit board approval. The switching costs accruing now are invisible — embedded in data pipelines, workflow automations, and the daily habits of the people who use the tools. You can see the old chains. The new ones you mostly feel only when you try to move.

The one input that changed

Every step of this forty-year migration was a response to a single fact: software was too expensive to build and too costly to keep alive. Standardizing was how you afforded maintenance. Renting was how you afforded it further. Remove that fact, and every reason to rent weakens at once.

AI removed that fact.

In 2026 the fifty-year-old constraint Brooks named broke in public. Writing in Fortune, Martin Casado and Abhishek Nagaraj documented AI-native companies running close to three times the revenue per employee of traditional software firms — because building had stopped scaling with headcount and started scaling with compute. Naval Ravikant put the same shift in plainer language: if the computer was a bicycle for the mind, AI is a motorcycle. The coordination tax that made custom unsustainable didn’t get cheaper. It stopped being the binding constraint.

And it isn’t only the building. The deeper reversal is that AI undoes, one for one, each of the four things that killed custom the first time:

• Maintenance was expensive. The cost of changing a system now falls with the cost of building it.
• Builders left and took the context. The context can live in the system now — in code that can be read back, explained, and understood on demand, not locked in heads that moved on.
• Systems ossified. Evolution can be continuous instead of episodic — improved constantly, not frozen until the next ruinous rewrite.
• Nobody could afford to keep evolving them. The system can now help maintain and improve itself.

Every structural reason custom was abandoned has been undercut by the same technology at the same time. That is not a trend; it is a reversal — and the market has begun to move on it.

Which means the entanglement has outlived its reason

Here is the pivot the whole history turns on. Maintenance was the entire justification for the trade. You accepted conformance, and later lock-in, because they were the price of not having to keep your own software alive. AI just made keeping your own software alive affordable. The justification is gone. The entanglement remains — but it now holds you to a bargain whose terms have quietly expired.

This reframes the build-versus-buy question that has governed the decision for a generation. It was never really build or buy. It was own or rent — and you rented because owning was unaffordable. When owning costs what renting used to, renting your own core logic stops making sense.

It was never build or buy. It was own or rent — and you rented because owning was unaffordable.

It also explains a failure a lot of companies are currently misdiagnosing. Enterprise AI is stalling in most organizations, and the reflex is to blame the model. The reflex is wrong, and the vendors themselves say so: as ServiceNow put it, the models were never the real constraint — what holds companies back is everything underneath, the data fragmented across disconnected systems and ungoverned at the exact points where an agent needs to act. Salim Ismail makes the same structural case in The Organizational Singularity: enterprise AI fails at the data layer, not the model, and the constraint is architectural. The entanglement you accepted for maintainability is now the thing blocking the intelligence you’re trying to add. It isn’t just costing you differentiation anymore. It’s costing you the future you’re paying to build.

The rebuild is the opening

So why doesn’t everyone simply move? Because you can’t unwind your core workflow and your data store while running the business. There’s rarely a safe moment. The entanglement holds not because it’s unbreakable but because there’s almost never a point at which taking it apart is worth the risk.

Except there is one, and it’s arriving now for nearly every company: becoming an AI-native organization is itself a workflow rebuild. It already means redesigning how work flows, already means deciding what agents do and what people govern, already means confronting the data layer. The disruption you would never accept on its own is one you’re about to undertake anyway.

That is the moment. You are going to rebuild your workflows for the agentic era regardless. The only question is whether you rebuild them into another vendor’s model — re-entangling, one more time, with a roadmap you don’t control — or whether you rebuild them as your own, with your data back in your house and your process encoded as yours again. Erik Brynjolfsson has spent his career measuring why the gains from a general-purpose technology arrive only when organizations redesign around it rather than bolt it on; the productivity shows up after the rebuild, not after the purchase. The rebuild is coming either way. The question is only what you own when it’s done.

A word on honesty, because the argument fails without it. This does not mean building everything, and it does not mean the incumbents’ warning is empty. ServiceNow calls doing it yourself the build-it-yourself trap, the place where integration, security, compliance, identity, audit, and governance quietly pile up beneath the surface, and they are not wrong that this is real work. Which is exactly why you don’t do it casually, and why method matters more than enthusiasm. Keep buying the genuine commodities — payroll, email, the systems where being standard is fine; they were never your edge. What comes home is the core: the workflow that encodes how you actually win, the logic no vendor sells because no other company works quite the way you do. Buy the commodity. Build the differentiator. The discipline is being honest about which is which, and carrying the build-it-yourself load with real engineering and governance rather than pretending it isn’t there.

A note for the companies that never left

There is a category of company that kept building and owning its core the entire time. They ran systems they controlled — their own logic, their own data, decades of encoded judgment about how their business works — and for those same decades they were told this was a liability. Legacy. Behind. A migration waiting to happen.

That narrative is inverting in real time. The companies that never surrendered their core logic didn’t miss the era everyone else lived through — they held onto the exact asset that era taught everyone else to give away. AI doesn’t rescue them. It vindicates them. They were sitting on a moat and being told it was a moat’s worth of debt, and now the rest of the industry is spending enormous effort trying to get back to where they already are. If that’s you, the work ahead isn’t catching up. It’s recognizing you were early, and moving before the market finishes discovering what you already have.

Own your source. Own your intelligence.