How do you survive the SaaSpocalypse?

How Do You Survive the SaaSpocalypse?

If AI is going to automate everything, what's left for a data platform like ours? It's a fair question. Here's my honest answer.

"How do you survive the SaaSpocalypse?"

I get some version of this question constantly — from investors, from customers, from friends, from family at dinner. The premise is reasonable: if foundation models are about to automate everything, why does a data company like Narrative get to keep existing? Won't the next model just... do all of it?

I want to take the premise seriously, because it deserves it. AI is going to automate a staggering amount of work. The models keep getting better, faster than most people expected, and I think that's great — we've bet on it. But for us, the SaaSpocalypse isn't a near-term existential worry. Not because we're special, but because of what we actually built, and when we built it.

Here's how I think about it.

We didn't start with the model. We started with the primitives.

Years before the LLM revolution, we spent a long time building the unglamorous foundations: the Rosetta Stone catalog, NQL (our query language), data-plane-agnostic operators. None of it was flashy. All of it was the point.

Because the heart of what our platform does is not writing one-off ETL jobs. Anyone — and now any model — can write you a one-off transformation. The hard part, the part that actually matters inside a company, is encoding that work in a governed, repeatable way. Turning a clever answer into a durable part of your data infrastructure.

That's the distinction the SaaSpocalypse framing misses.

An LLM gives you an answer. Infrastructure gives you the same answer tomorrow — with the lineage to prove it, the permissions to defend it, and the repeatability to build on it.

A model is extraordinary at the first part. It does not, on its own, do the second.

A model that lives in one place can't normalize data that lives in two.

This is the one I'd put real money on.

Say a model gets so good it can perfectly normalize any messy dataset you hand it. Great. Now answer the actual question: whose data, sitting where?

Real data collaboration happens across organizations. And normalization has to happen on both sides of that collaboration — your schema and mine both have to resolve to a shared language before any of it lines up. But for perfectly good governance reasons, I may not want to hand you access to my data warehouse, and you may not want to hand me yours.

No agent that lives in just one place can do that work. A model sitting in your environment can't reach into mine. A model sitting in mine can't reach into yours. The problem was never "can a model normalize a table." The problem is: who is allowed to see what, where does the work run, and how do two parties agree on a shared shape without either one giving up control?

That's not a modeling problem. It's an infrastructure-and-governance problem. It's the problem we built the company around.

Data wants to be governed — not thrown at a model and forgotten.

There's a real temptation right now to just pipe everything into an LLM and ask it questions. For ad-hoc exploration, fine — it's genuinely useful.

But a one-off answer from a model is exactly that: one-off. Can you reproduce it? Can you show how you got there six months from now when someone asks? Where did the model live when it touched the data — and what crossed the boundary to get there?

Those aren't pedantic questions. They're the difference between a fun demo and something you can run a business on. Governed data — with lineage, with access controls, with reproducibility — is what survives an audit, a personnel change, a regulator, and a Tuesday.

The value isn't the answer. It's that the answer is repeatable, defensible, and yours.

So where does AI fit? Everywhere — as a component, not the foundation.

None of this is AI-skepticism. We think AI is great, and we've baked it into the platform in a dozen places — Rosetta Stone's normalization is itself AI-powered. We just don't think the model is the moat.

That's why our whole approach is composable AI: bring your own AI. Pick your model, pick your harness — our MCP server lets Claude or any other agent drive Narrative directly. We supply the data and the tools; you supply the intelligence. OpenAI, Anthropic, and Google are building genuinely extraordinary engines, and every time they ship a better one, our customers get a better one too, for free.

But a better engine doesn't pave the roads. It doesn't decide who's allowed to drive on them, or keep a record of where everyone went.

The honest answer

Foundation models are going to eat a lot of software. They'll eat the thin wrappers — the products whose entire value was doing one thing a model can now do in a single prompt. If that's all your SaaS ever was, the SaaSpocalypse is real, and it's coming.

They are not going to eat infrastructure.

The composable primitives — normalization across boundaries, governance, reproducibility, the ability for two organizations to collaborate without either surrendering control — don't get easier because the model got smarter. They get *more* valuable, because now there's a powerful new engine that needs somewhere governed to run.

That's how you survive the SaaSpocalypse. You don't compete with the model. You become the thing it plugs into.

Curious what composable, model-agnostic data infrastructure looks like in practice? Book a demo and see Narrative run inside your own environment.

‍