The SaaS-pocalypse: What the Narrative Gets Wrong

The tech sector is bleeding. SaaS valuations have cratered, and the consensus is clear: AI will make software so easy to build that nobody will need to pay for it anymore. Every founder with a subscription model is supposedly living on borrowed time.

It’s a compelling story, but it’s built on a faulty conclusion.

Yes, AI has made building software dramatically cheaper and faster. But the people predicting the death of SaaS are confusing the commoditisation of code with the commoditisation of everything code sits on top of. Those are very different things, and the distinction matters.

The Compliance Blind Spot

Here's what the "everyone will just build their own tools" crowd consistently overlooks: software isn't just code. It's ongoing regulatory exposure. It's data governance. It's uptime guarantees and audit trails and breach liability and a dozen other things that have nothing to do with whether an AI can generate a CRUD app in thirty seconds.

Enterprise customers don't pay Salesforce or Workday because they can't figure out how to build a database. They pay because they don't want to own the compliance surface area. They don't want to be the ones answering to regulators when something goes wrong with their HR data pipeline. They're buying delegation of liability, maintenance, and the entire operational burden that sits beneath the interface.

The assumption that every company will spin up its own internal tools because AI makes it easy is like assuming every restaurant will mill its own flour because flour mills got cheaper. The cost of the raw material was never the bottleneck. The cost of everything around it was.

What Actually Changes

So if SaaS doesn't die, what happens to it?

It evolves. And the evolution is more interesting than the obituary.

When the cost of building software collapses, the barrier to entry disappears. That means more products competing for the same attention. And when everyone can build, the question stops being "can you ship something that works" and starts being "can you ship something people actually choose."

This is where it gets interesting. Now that the execution layer has been commoditised, anyone can build a functional tool. The differentiation shifts upstream, to strategy and taste. It used to be a game of checkers... now we've moved on to chess.

The Return of Taste

For years, enterprise software has operated on a simple bargain: it does the job, and you tolerate everything else. The interfaces are forgettable. The experiences are adequate.

Nobody chose their project management tool because it felt good to use—they chose it because it integrated with their existing stack or because procurement approved it.

That era is ending. When building software is cheap, there's no excuse for software that merely functions. We should start seeing—and I believe we will—a new generation of tools that solve problems with intentionality.

Software that instills trust not just through reliability but through craft. Software that respects the person using it.

It sounds like idealism but it's just market logic. When creation costs approach zero, the surviving differentiators are the ones that can't be cheaply replicated: design judgment, strategic positioning, and the kind of coherent product vision that no prompt can generate.

Distribution Becomes Strategy

The same dynamic plays out in how software reaches its users. When everyone can build, everyone can also market. So distribution itself becomes a strategic problem rather than an operational one.

If every competitor is running AI-generated ad campaigns, the output converges. Similar copy, similar targeting, similar creative. The returns flatten, and everyone gets the same result. The companies that break through will be the ones treating distribution as a design problem—understanding which demographics are underserved, which channels are underleveraged, which messages resonate on a level that generic optimisation can't reach.

This is, frankly, the part I find most exciting. It's a genuine strategic contest. The playbook hasn't been written yet, and the winning moves won't be obvious until someone executes them and everyone else explains them in hindsight.

This Isn't New: The MS-DOS Precedent

If the idea that distribution matters more than technical superiority sounds like a modern insight, it isn't. The most consequential example played out over four decades ago.

In 1980, IBM approached a small company called Microsoft to provide an operating system for its upcoming personal computer. Microsoft didn't have one. What they did have was $50,000 and the awareness that a company called Seattle Computer Products had built an OS called 86-DOS. Microsoft bought it, renamed it MS-DOS, and licensed it to IBM.

But the deal that changed everything wasn't the one with Seattle Computer Products. It was a clause in the IBM contract; one that allowed Microsoft to license MS-DOS to other companies. IBM apparently believed it had exclusive rights. It didn't.

When competitors began cloning IBM's hardware, every single one of them needed an operating system, and Microsoft was ready.

Within a year, Microsoft had licensed MS-DOS to over 70 manufacturers. The operating system eventually powered over 1.4 billion PCs worldwide. Microsoft didn't win because MS-DOS was the best operating system available. They won because they secured the distribution channel before anyone else understood what the game actually was.

The parallel to today is direct. In a market where AI makes it trivially easy to build software, the product itself is no longer the moat. The companies that win will be the ones that secure distribution—through strategic partnerships, through platform positioning, through the kind of deals that seem like footnotes at the time and look like inevitabilities in hindsight.

While the SaaS-pocalypse narrative fixates on who can build, history suggests the better question is who can distribute.

What Happens to Builders

The implications for the people who write software are significant but not catastrophic. Programming doesn't become obsolete—it just becomes table stakes. You can't walk into a job interview with a notes app anymore, because a notes app is now three lines of code and a prompt. The bar has moved.

What's valued now and increasingly will be, is the layer above code generation. Can you architect systems that handle competing constraints? Do you understand the trade-offs between multiple complex subsystems? Can you reason about incentive structures and failure modes? The skills that matter are shifting from syntax to systems thinking, from competency to cognition.

Case in Point: The Nigerian Tech Ecosystem

Everything I've described above plays out in sharp relief in Nigeria—with an additional variable that makes it harder to ignore.

The Nigerian economy is experiencing a sustained erosion of purchasing power. Inflation is aggressive, infrastructure is deteriorating, and a growing share of the population simply cannot afford what they could a few years ago. The consumer market is contracting in real terms, and founders have noticed. The prevailing response has been a migration from B2C to B2B with the logic being that if consumers can't pay, sell to the businesses instead.

This is not a solution. It's a deferral.

The businesses you're selling to in a B2B model are operating in the same economy. Their customers are the same consumers whose purchasing power is collapsing. Their margins are under the same pressure. And when those margins get squeezed hard enough—and they will—one of the first line items to get cut is the software subscription that seemed essential six months ago.

Your B2B client will not absorb indefinitely rising costs for tools when their own revenue is declining. They will look for cheaper alternatives, build something internally, or simply go without. The macro doesn't care about your business model.

This creates a specific and uncomfortable challenge for Nigerian SaaS: you cannot price as though you're operating in a healthy economy. Founders who raise capital on projections that assume stable or growing willingness to pay without accounting for the structural decline in what their customers can actually afford, are building on a foundation that the macro environment is actively eroding.

We are going to see startups raise money and lose it because they failed to respect this simple fact of reality. The pitch deck might look good on paper, but you cannot will away the macro economy.

The realistic path—and I say this as observation, not prescription—looks like a hybrid model that acknowledges the squeeze on both sides.

Consumers need to spend less. Businesses need to spend less. The founders who build with that constraint as a design principle rather than treating it as an inconvenience to be papered over with investor capital are the ones positioned to survive.

Cutting costs for both parties is the only math that works when an entire market is contracting.

This isn't a political statement. It's a reading of current conditions. People who are fighting to survive cannot be taxed more aggressively for using essential software.

If someone proves that wrong, and the market turns out to support premium SaaS pricing through a period of sustained inflation and declining purchasing power, that would be a genuinely remarkable outcome.

I just wouldn't bet on it.

The Bottom Line

The SaaS-pocalypse narrative gets the direction of change right and the destination wrong. Software isn't dying. The low end of it—the tools that justified their existence solely by doing something that was previously hard to do—those are in trouble. But the managed platforms, the compliance-bearing services, the products built with genuine craft and strategic intent? They're not going anywhere. If anything, the ones that survive this shakeout will be stronger for it.

And in markets like Nigeria, where the macro environment is already doing what AI threatens to do globally—compressing margins and forcing hard choices about what's worth paying for—the lesson is even clearer.

The software that survives isn't the software that's cheapest to build. It's the one that delivers enough real value to justify its cost to people who are watching every naira.

Software can no longer coast on scarcity. It has to be good—and in some markets, it has to be good and affordable, simultaneously.