The first two pieces in this series argued that monolithic SaaS quietly hands operational decisions to vendors who’ve never seen your operation, and that the cost of doing so shows up as workarounds, integration overhead, and an organization that learns to think inside someone else’s UI. People read those and assumed the conclusion was simple: stop using SaaS, build everything yourself.
That’s the wrong conclusion.
The subscription model is one of the best things to happen to enterprise software. Predictable. Ongoing. Aligned to a continuous relationship instead of a once-every-five-years capital project. The problem isn’t how you pay. It’s what you’re paying for.
Bundling capability into a one-size-fits-all platform is what creates the lock-in, the hidden costs, and the constrained thinking. Unbundle the delivery and the subscription model becomes the right answer, not the wrong one.
Here’s an analogy that might help.
What if subscriptions worked like insurance?
Nobody buys “one-size-fits-all” insurance. You buy coverage shaped to your specific risks. Your business, your assets, your geography, your liability exposure. A broker who knows the market assembles the right combination from many carriers — health, property, cyber, professional, umbrella. You pay an ongoing premium, and as your situation changes, the policy changes with it.
That’s a subscription. Just not a platform subscription.
Now picture software the same way. Capability shaped to your operation. Assembled by people who understand both your business and the available technology. Paid as an ongoing subscription that funds continuous fit, not a license fee that funds a vendor’s product roadmap. The system evolves as the business does.
That’s the model. The subscription model — applied to software the way insurance applies it to risk: tailored, brokered, ongoing. The thing you’re subscribing to is the relationship and the fit, not the platform.
I’m not pushing the metaphor further than it goes. Insurance has its own dysfunctions. The point is structural: you can pay an ongoing premium for something that’s yours, not for a generic product everyone else is paying for too.
Why custom software meant something different ten years ago
Anyone who’s been in enterprise tech for a while has a reflex when they hear “custom software.” Eighteen-month build. Six-figure consultants. A requirements doc that’s obsolete the day it’s signed. A vendor who delivers something close to what was specified, then disappears. The system goes live, becomes load-bearing, and slowly drifts out of date. By year three it’s a maintenance liability. By year five you’re rewriting it.
That reflex is earned. The math really did work that way.
When the choice was that version of custom software versus a SaaS platform that ships continuously, integrates with other things, and gets better while you sleep, no rational CFO picked custom. SaaS won the decade because it deserved to win the decade. Custom was expensive, slow, brittle, and a hiring problem on top of everything else.
I’ve watched plenty of organizations make exactly that calculation. They weren’t wrong. They were rational about the constraints they were under.
But the constraints changed.
The economics flipped
Three things shifted, and they shifted faster than most enterprise software conversations have caught up with.
First, the integration tax dropped dramatically. It did not disappear, but it is no longer the automatic veto it used to be. This was the monolithic platform’s only real moat. The argument against composable systems was always “integration is hard — you’ll spend more on glue than you save on flexibility.” That was true when integration meant middleware licenses, custom APIs, and a dedicated team keeping them alive. It’s not true anymore. AI agents can orchestrate across purpose-built systems, map data between tools, and handle the kind of cross-system workflows that used to require a platform’s “everything in one database” promise. The advantage SaaS got from being a single source of truth is evaporating.
Second, the build timeline collapsed. What used to take eighteen months now takes eight to twelve weeks for a meaningful first cut. This isn’t a marketing claim. AI-assisted development genuinely changed the cost curve of writing software shaped to a specific operation. The architectural work still requires people who understand both the operation and the system — that part hasn’t been automated away — but the implementation labor has compressed by an order of magnitude.
Third, continuous evolution is now cheaper than periodic rewrites. This is the quietest of the three changes and the most important. Software that adapts as the business adapts doesn’t go stale. It doesn’t accumulate the kind of debt that triggers a rewrite cycle. The maintenance liability that made custom software a bad bet ten years ago becomes manageable when small, focused changes are routine instead of expensive.
The result: custom software is no longer a capital-project phase. It’s an ongoing relationship. And subscription pricing — predictable, monthly, renewable — matches that reality far better than it ever matched a platform license.
What this looks like in practice
Here’s what I’ve watched happen lately.
A logistics operator running a national fulfillment operation. Two hundred thousand a year for the core platform license. Two integration consultants on retainer, billed monthly, just to keep the platform talking to the WMS and the carrier APIs. A six-month vendor feature backlog, with the most-requested fix sitting at position fourteen and a quarterly steering call that wasn’t moving it. And — the part nobody had on the budget — a shadow system in Excel that the ops team maintained for the parts the platform couldn’t handle. Manual entry. Reconciliation passes. The kind of work that doesn’t show up as a software cost because it’s distributed across people.
They replaced the platform with a custom system over eight weeks. Same monthly spend. Different shape.
The platform line item went away. The integration consultants went away. The shadow Excel went away. The team’s process improvement proposals stopped dying in planning meetings, because “the system doesn’t support that” stopped being a sentence anyone needed to say. Changes that used to take a quarter of vendor escalation took a week of conversation with the people who’d built the system in the first place.
This does not mean every SaaS platform should be replaced. Payroll, commodity CRM, email, collaboration, accounting, and other standardized functions often belong on mature platforms. The point is different for workflows that encode how the business actually operates.
I want to be honest about what’s hard about this. It is not a no-code DIY pitch. You need someone — usually a small team — who understands both the operation and software architecture deeply enough to translate one into the other. That’s not a commodity skill. The cost moved from “license + workarounds + integration consultants” to “the people who build and maintain software shaped to your business.” That’s not zero. It’s just the right kind of cost: an investment in fit, not a tax on misfit.
The companies that win at this aren’t the ones with the biggest engineering org. They’re the ones who treat that small team — internal, contracted, or some mix — as a long-term operating partner rather than a project resource.
What you’re actually buying
If you map out a healthy enterprise software stack in 2026, the layers separate cleanly:
Compute. Rent it. Cloud or on-prem, doesn’t matter. This is commodity. Don’t try to differentiate here.
Data infrastructure. Rent it. Databases, warehouses, search, queues, observability. All commodity. The vendors are good and the alternatives are good and the cost of switching is bounded.
AI models. Rent them. They’re improving faster than any in-house team can keep up with, and the per-call economics are getting better, not worse.
The logic layer. Own it. This is the part that encodes how your business works. Your rules, your workflows, your decisions, your data shapes. This isn’t commodity. It is the thing that differentiates you from every competitor who’s running the same SaaS stack as you. Outsource it to a vendor and you’ve outsourced the part that was supposed to be your edge.
The people maintaining it. Subscribe to them. This is where the subscription model actually belongs — not “we license you a platform and you accommodate it” but “we build, run, and continuously evolve software shaped to your operation, and you pay us a monthly rate to keep doing that.”
A healthy software relationship in 2026 isn’t “platform vendor versus internal IT.” It’s a small set of people on retainer — internal, partner firm, or hybrid — who know your operation deeply and shape the software to it as the business changes. That’s what subscriptions were always supposed to fund. The platform model just got there first and held the spot for a decade.
The question worth asking
The first piece in this series asked who’s actually making your operational decisions. The second one quantified what that costs. This one is the answer the first two implied.
Subscribe to the relationship, not the platform. Pay an ongoing premium for software that keeps fitting your business — not a license fee for software your business has to fit.
If you could redesign your core operational software from scratch — knowing what your team actually does, day to day — what’s the first thing you’d build differently? That question used to be theoretical, because the answer was “we can’t, the build cost is too high.” It isn’t anymore.
This series argued for unbundling SaaS. The next question is what you build once the platform is no longer the center of gravity: agentic workflows, automation, and systems that bend around the operation instead of the other way around.