The death of SaaS (as we know it) and what it means for customer data

AI agents aren't just changing how we build software. They're changing what software even is.

Everyone is talking about the death of SaaS. And honestly? They're right, but for the wrong reasons.

The hot take version goes something like this: AI will let enterprises vibe-code Salesforce replicas overnight, incumbents die, curtains close. That's too simplistic. Nobody is going to vibe-code their way to a production-grade CRM with enterprise security, SOC2 compliance, and 15 years of edge-case-handling baked in.

But that misses the actual argument. Two structural shifts are happening simultaneously, and together they make the SaaS business model genuinely fragile for the first time.

Shift 1: The cost of building software is collapsing

What took SaaS companies a decade and hundreds of engineers to build can now be replicated by a small team at a fraction of the cost. Not because the code writes itself (yet), but because the marginal cost of software development is falling toward zero.

This isn't theoretical. Early-stage startups are shipping products in weeks that would have taken years in 2018. The moat of "we have 200 engineers who've been hardening this product for 10 years" is real, but it's slowly eroding.

The consequence isn't sudden death. It's price compression. When a credible competitor can be built at 1/100th the cost, the pricing power that SaaS companies have relied on-–the "we charge $50K/year because switching costs are brutal" logic-–starts to buckle. Expect more alternatives, more competition, and relentless downward pressure on price.

Shift 2: The SaaS moat was always the UI. And that moat is disappearing

This is the more interesting argument.

SaaS companies aren't just selling software. They're selling workflow interfaces, or opinionated views of how business processes should be structured. Salesforce's real product isn't a database of contacts. It's a carefully designed surface through which salespeople navigate their day.

That UI complexity was a moat. It was hard to replicate, it locked in users through muscle memory, and it justified the feature bloat that accumulated over years of chasing enterprise contracts. Every weird edge case, every obscure configuration option, every integration that nobody asked for but a Fortune 500 required—all of it became part of the product.

But here's the thing: Agentic workflows dissolve that moat.

When an AI agent is mediating between a user's intent and the underlying data, you don't need a 47-tab settings panel. You don't need a drag-and-drop workflow builder with 200 node types. You just need the infrastructure layer that the agent can actually operate on.

The feature bloat that differentiated SaaS products becomes friction. The complex UI that keeps users locked in becomes an obstacle.

What this means for customer data platforms

CDPs sit at an interesting intersection here. They've always been infrastructure-adjacent, the plumbing that connects customer data to the tools that actually act on it. But they've also accumulated significant UI surface: audience builders, journey designers, connector configuration screens.

The agentic future looks quite different.

Today's reality

A growth team wants to run a re-engagement campaign for high-value users who haven't purchased in 90 days. They need an analyst to define and extract the segment in the CDP, a marketer to build the journey in a marketing automation tool, a separate analytics platform to measure results, and probably a data engineer to make sure the right events are flowing in the first place. Four tools. Multiple handoffs. Significant latency between insight and action.

The agentic alternative looks less like a single command and more like a thinking session with a very capable analyst.

That same growth team starts with the same problem: re-engage high-value users who haven't purchased in 90 days. But instead of filing a request with a data analyst, the marketer opens a conversation.

The agent pulls the segment, but then pushes back: "The 90-day window captures 2,400 users, but purchase frequency varies a lot by category. Customers in your enterprise tier typically have 120-day cycles. You might be flagging people who are actually on track."

The marketer didn't know that. They refine: "Okay, let's adjust the window by tier and only flag users who are meaningfully behind their own historical cadence."

Now the segment is 800 users. Smaller, but sharper.

They dig deeper. "What's different about the ones who came back after a lapse vs. the ones who churned permanently?"

The agent finds a pattern: Returned customers had almost always opened at least one product update email in the interim. That shapes the intervention. They're not writing a discount email anymore. They're writing a product update that happens to include a reason to come back.

The agent drafts three versions. The marketer reacts, gives feedback, and iterates on tone. They debate whether to include a discount at all. They decide to run a holdout group. The agent sets it up.

By the end of the session, they understand their lapsed customers in a way they didn't an hour ago. The campaign is better because the thinking behind it was better.

And crucially, the agent could do all of this because it had access to context that would have taken a human analyst weeks to accumulate.

When the marketer asked "What does a high-value customer actually look like in our data?" The agent didn't just query a user_tier field. It read the codebase to understand how purchase events are actually instrumented, checked the data model to know that account_id is the reliable join key (not user_id, which has a known duplication issue from a 2022 migration), and pulled the product catalog to correctly classify enterprise vs. mid-market by SKU, not just by the contract value field that sales sometimes leaves blank.

This is a context that usually lives in a Notion doc or a Slack thread from 18 months ago. Agents that can read across these sources—codebase, schemas, business logic, institutional knowledge—close the gap between what the data says and what it actually means.

The practical output of this isn't incremental improvement. It's qualitatively different analysis:

• Segment identification that goes beyond demographic slicing to behavioral propensity, finding users who look like churners based on product usage signals, not just age-of-account
• Journey logic that adapts in real time rather than executing a pre-built decision tree
• One-off analytics that would previously require a custom SQL query and a data engineer—written, executed, and interpreted on demand
• Anomaly detection across data pipelines that currently require manual monitoring

The implication: Infrastructure wins

Here's what this means for companies building in the customer data space.

The interface layer commoditizes. The question of "which CDP has the best audience builder" becomes less relevant when the audience builder is an agent that can operate across multiple data sources. The question of "which marketing automation platform has the best journey designer" becomes less relevant when the journey is the agent's output.

What doesn't commoditize is the infrastructure that agents actually run on:

• Data collection and reliability: Garbage in, garbage out. If the event stream is unreliable, the agent's outputs will be unreliable. The boring work of ensuring data quality at the source becomes more valuable, not less.
• Identity resolution: Knowing that the user who browsed on mobile last week is the same person who purchased on desktop today. This is hard, unsexy infrastructure work, and it becomes the foundation everything else runs on.
• Activation connectivity: The agent needs to be able to actually do something with its conclusions: push to an ad platform, trigger an email, update a CRM record. The breadth and reliability of that connectivity matters.
• Governance and access control: When agents are autonomously operating on customer data, the question of what data they can access, and under what conditions, becomes critical from both a compliance and a trust perspective.

The companies that will win in this environment aren't the ones with the most features in their UI. They're the ones with the strongest data infrastructure that agents can actually reason over and operate on.

Where this leaves us

The SaaS playbook (e.g., build a complex product, create switching costs through UI familiarity, charge premium prices, defend against competition through feature surface area) is under genuine pressure.

For CDPs specifically, the opportunity is significant. Customer data is the raw material that makes agentic marketing workflows possible. A CDP that positions itself as infrastructure for AI agents—with clean data models, reliable pipelines, strong identity resolution, and broad activation connectivity—is building for the world that's coming.

The companies that treat this as "let's add an AI chatbot to our existing product" will lose. The ones that genuinely rethink what the product is—from a UI for humans to navigate, to a substrate for agents to operate on—have a real shot at coming out ahead.

It's an interesting time to be building in this space.