Last weekend I built a personal finance app. It took a few hours. I used an AI coding assistant, talked through what I wanted, and by Sunday evening I had something that covers about 90% of what I’d been paying a SaaS product to do.
I’m not writing this to brag about a side project. I’m writing it because the experience crystallized something I’ve been turning over for months: if I can replace a paid SaaS product in an afternoon, what does that mean for the companies selling enterprise software?
The short answer: a lot. And the playbook the big vendors are reaching for is older than most people realize.
What the vendors are actually going to do
Let’s start with the obvious. If the cost to ship software drops by 90% (and it’s heading there), every SaaS company has a problem. Their customers can now build the thing they used to buy. Not all of them will. But enough will that it changes the math.
So what do you do if you’re Salesforce, Microsoft, SAP, or ServiceNow right now?
I count roughly 10 strategic options. Some are smart. Some are desperate. A few are both.
Sell data gravity. Stop caring about the app layer. Become the system of record that everything connects to. It doesn’t matter who builds the apps if the data lives with you. This is where Salesforce’s Data Cloud push is aimed, and it’s Snowflake’s implicit strategy.
Sell connectivity. In a world where everyone builds bespoke tools, the integration problem explodes. Someone has to maintain the connectors. That someone charges rent. Informatica, MuleSoft, Workato, Boomi — this is their bet. Hence, why Salesforce owns two of those.
Own the toolchain. Don’t build the apps. Own the tools people use to build them. GitHub already did this with Copilot. The enterprise version is an AI development platform purpose-built for business applications. If everyone’s building, be the pickaxe vendor.
Go vertical. Give up horizontal ambitions and become the definitive platform for one industry. Veeva did this in pharma. Epic did it in healthcare. In a world of AI-powered generalists, deep domain specialization might actually become more valuable.
Sell managed complexity. Concede the build argument entirely. “Great, build whatever you want. We’ll run it, secure it, keep it compliant, and be on-call at 3am so your team doesn’t have to.” The cloud platform play, pushed up the stack.
Become a marketplace. Stop building software and start curating it. If thousands of teams are generating custom tools, someone needs to aggregate, vet, and distribute them. Take a cut and provide the trust layer.
Pivot to services. This is what IBM effectively became. “We’ve been building enterprise software for 20 years. Let us design your custom stack.” Margin compression, but survivable.
Sell compliance. When anyone can build software fast, the bottleneck shifts to trust. Who certifies an AI-generated app meets regulatory requirements? Who provides the audit trail? Boring. Very defensible.
Do nothing. Keep selling the same product with AI sprinkled on top as a feature. Hope enterprise inertia buys you runway. This is slow death, and it’s what most mid-tier SaaS companies will actually do.
Or — and this is the one worth spending time on — you try to become the Personalized Monolith.
The personalized monolith
This is the option that should genuinely worry anyone who believes in building over buying.
Here’s the old version of the monolith pitch: “We cover your entire enterprise.” The problem was it never really worked. Software was expensive to build, so every new module was a massive investment, and the result was always uneven. Good CRM, terrible analytics. Solid ERP, embarrassing customer portal. Everyone tolerated best-of-breed because the monolith was always compromised somewhere.
AI changes that. If your cost to ship a new module drops by 80-90%, you can suddenly cover the whole enterprise with stuff that’s genuinely good enough.
But that’s not even the interesting part.
The interesting part is customization. The old monolith was generic. The new one is personalized. The vendor doesn’t hand you a one-size-fits-all module. They ask what you need and generate a bespoke version overnight, on their platform, integrated by default, maintained by them.
The pitch to a CFO: “Why are you managing fourteen vendors, fourteen contracts, fourteen security reviews, and fourteen integration points when we can cover all of it — customized to your specs — on one platform, one bill?”
That’s hard to argue with. I know, because I’ve been on the other side of that argument.
For decades, vendors have been assembling the pieces. Microsoft with Dynamics, Power Platform, Fabric, Copilot, Azure, and Salesforce is pushing the same direction with Data Cloud and Agentforce. Now — anyone who’s actually tried to run a real business process end-to-end across the Microsoft stack knows the truth (or for that matter Oracle). These products are still basically five acquisitions wearing a trench coat. The integration story is mostly marketing at this point.
But the intent is clear. And AI is closing gaps faster than organic engineering ever could.
We’ve seen this before
If the personalized monolith sounds familiar, it should.
In the 1960s and 70s, IBM didn’t sell software. They sold IBM. The whole stack — hardware, OS, applications, custom dev, maintenance, training, the people who ran it. You told IBM what your business needed and they built it for you, on their platform, maintained by their team. You didn’t have a “tech stack.” You had an IBM relationship.
EDS ran the same playbook as a services layer. Ross Perot’s whole pitch was “tell me your problems and I’ll handle the technology.”
Then the industry spent 40 years taking that model apart. Minicomputers broke the hardware lock. PCs broke the client dependency. Open source broke the licensing. SaaS broke the deployment. Cloud broke the infrastructure. Every wave was about freedom, choice, specialization. The whole arc from 1975 to 2020 was one long unbundling of what IBM built.
Now AI is making the rebundling economically rational again.
“Tell us what you need, we’ll build it on our platform, we’ll run it, we’ll maintain it” — that’s the IBM pitch from 1975 with a cloud login screen.
There is one important difference though. In the mainframe era, only the vendor could build. IBM had the capability and you didn’t. That asymmetry is what made the relationship so sticky and eventually so extractive.
Today, both sides can build. I can ship a working app in a weekend. A vendor can generate a custom module overnight. The power imbalance is gone. Any reconsolidation that happens is a choice, not a constraint.
And choices can be reversed.
The carrier wars are coming to enterprise software
Once two or three personalized monoliths compete for the same customer base, feature differentiation collapses. If Salesforce can generate a custom module and Microsoft can do the same thing, the product isn’t the competitive axis anymore. What’s left? Price, experience, switching cost.
And some hungry number-two player will run the T-Mobile playbook.
Think about how the carrier wars played out. AT&T and Verizon had everyone locked into two-year contracts with early termination fees. Then T-Mobile came along: we’ll pay off your old contract, unlock your phone, port your number in an hour. They didn’t win by having a better network. They won by making leaving frictionless.
The enterprise version of that: “Bring us your Salesforce configuration and we’ll replicate your entire environment on our platform in a week. All your custom modules, all your business logic — AI-generated on our stack. Cheaper.”
If the cost to build drops to near zero, the cost to replicate also drops to near zero. Your bespoke Salesforce environment isn’t defensible anymore. A competitor can reverse-engineer the whole thing from your schema and API specs.
The vendors know this, by the way. It’s why Salesforce doesn’t use standard SQL. Why Apex is a language that exists nowhere else. Why every custom module built on their platform only runs on Salesforce. That’s not an engineering decision. That’s a moat. The modern equivalent of AT&T locking your phone to their network.
But AI undermines that too. If an AI can write Apex, it can also read Apex and translate it to whatever the other platform runs. The proprietary language lock-in that’s been enterprise software’s main defense for 20 years becomes a speed bump instead of a wall.
Add data portability regulation — the enterprise equivalent of number portability in telecom — and the switching cost effectively disappears. GDPR already points in this direction. It’s a matter of when, not if.
The endgame looks a lot like wireless carriers today. Three or four players. Aggressive switching offers. Commoditized pricing. Compressing margins. The “enterprise operating system” becomes about as interchangeable as your cell plan.
So who actually wins?
In the carrier wars, the answer wasn’t any carrier.
It was the smartphone. Apple and Google built the layer above the commodity infrastructure, and the carriers became dumb pipes underneath. AT&T and Verizon spent billions competing with each other. Apple took the margin.
There’s an enterprise equivalent to the smartphone in this story: your data platform.
If you own your data layer — if your business logic, your proprietary models, your cross-domain insights live in architecture you control — then the personalized monoliths become what the carriers became. Interchangeable infrastructure underneath the thing that actually matters. You plug into whichever one is cheapest, switch when someone offers a better deal, or skip them entirely.
The vendors fight each other on price. You keep the leverage. Because the actual asset — your data, your logic, your IP — never left your hands.
That’s the real argument for building. Not “we can build better tools than vendors.” You probably can’t, at scale, forever. Not “vendor products are bad.” They’ll be good enough for most things.
The argument is simpler: in a world where the vendor layer will commoditize — and it will, because it always does — the only durable advantage is owning the layer above it.
The carriers learned this the hard way. The enterprise software vendors are about to learn it too.
What I’d actually do if I were a software vendor
I’ll be blunt. If I were running product strategy at a major SaaS company right now, here’s what I’d be doing — roughly in order of urgency.
Gut your product and rewrite it. I’m not joking. The same AI that threatens your business model is also the fastest path to fixing the technical debt, the clunky UX, and the duct-taped integrations that make customers want to leave. Most enterprise software is 2+ decades of acquired code held together by fear of regression. AI lets you rewrite it in months, not years. The vendors who do this first get a real integration story. The ones who keep bolting AI onto legacy architecture are just adding a chatbot to a burning building.
Stop selling software. Start selling outcomes. The product-as-deliverable era is ending. Nobody wants your module. They want the problem solved. Restructure your pricing and delivery around business outcomes, not seat licenses and feature tiers. If you can generate custom solutions on demand, charge for the result, not the tooling.
Make switching easy — to you. Don’t wait for a competitor to run the T-Mobile play. Run it yourself. Build migration tooling that ingests a competitor’s data model and recreates the environment on your platform. Make onboarding so frictionless that the CFO’s objection disappears. Yes, this is a weapon your competitors can eventually turn around on you. That’s fine. The first mover advantage in migration tooling is worth more than the defensive moat you’re trying to protect.
Own a layer, not a surface. Pick one: data gravity, integration fabric, compliance infrastructure, or vertical domain expertise. Go deep. The vendors trying to be everything to everyone will lose to the personalized monolith players who have more resources. The ones who own an indispensable layer will survive the commoditization because they’re not competing on the same axis.
Open up before regulation forces you to. Data portability mandates are coming. If you open your APIs and export formats voluntarily, you control the narrative and the implementation. If you wait for regulators to force it, you get a compliance deadline and hostile customers. This is counterintuitive — it feels like dismantling your moat. But the moat is already leaking. Better to drain it on your terms and compete on value than to have it breached on someone else’s.
Hire builders, not maintainers. Your engineering org is probably optimized for maintaining a legacy codebase. That’s the wrong skill set for what’s coming. You need people who can ship fast, think in terms of generated code, and are comfortable rebuilding from scratch. This is a cultural shift as much as a hiring one, and it takes longer than most leaders think.
None of this is easy. Most of it requires cannibalizing revenue streams that are still profitable today. That’s exactly why most vendors won’t do it — and exactly why the ones who do will be the only ones left standing in five years.
The mainframe is calling. You don’t have to answer.