There’s a narrative going around that AI is about to make SaaS businesses worthless. The argument goes something like this: why pay for software when anyone can spin up their own version using Claude Code or Cursor in a weekend? SaaS is just an expensive database with a UI on top. The moat is gone.

I’ve been thinking about this a lot, partly because I co-founded AppSignal and have skin in the game, but also because the argument is both partially right and dangerously incomplete.

The Part That’s True

If your SaaS product is essentially a form that writes to a database and a dashboard that reads from it, you should be worried. Not tomorrow, but soon. AI-assisted development has gotten good enough that a competent developer can build a functional CRUD app in a day. The kind of thing that would have taken a small team a few weeks just a couple of years ago.

Think simple project trackers, basic CRMs, and straightforward survey tools. These are the products that are genuinely vulnerable. Their value was never really in the software itself; it was in the convenience of not having to build it yourself. That convenience is getting cheaper by the month.

The Part That’s Nonsense

Here’s where the narrative falls apart: it treats all SaaS as if it’s the same thing. As if there’s no meaningful difference between a Typeform competitor and an application performance monitoring platform that processes billions of data points in real time.

At AppSignal, we ingest telemetry data from thousands of applications simultaneously. We process it in real time. We aggregate metrics, detect anomalies, group errors intelligently, and store time-series data in a way that doesn’t collapse under write pressure. Our collection agent is built in Rust and optimized to add virtually zero overhead to the applications it monitors. We support multiple programming languages, each with framework-specific instrumentation that took years to build and refine.

Could someone use Claude Code to build a dashboard that shows error counts from a Postgres table? Absolutely. But that’s not APM. The gap between “I built a thing that shows errors” and “I built a system that reliably monitors production applications at scale” is enormous, and it’s not a gap that AI-assisted coding closes anytime soon.

Three Layers of SaaS

The way I see it, SaaS products exist on a spectrum of complexity, and their vulnerability to AI disruption depends almost entirely on where they sit.

The first layer is storage and UI. This is the “expensive database” that people are talking about. Forms, tables, basic workflows. If your product lives here, AI-assisted development is a direct threat. Not because the AI is smarter than your engineers, but because the problem you’re solving was never that hard to begin with.

The second layer is domain logic. Business rules, complex workflows, integrations with dozens of third-party services, years of edge cases discovered and handled. Products at this layer have more breathing room. AI compresses the timeline for building these things, but it doesn’t eliminate the need to understand the domain deeply. You still need to know what to build, not just how to build it.

The third layer is infrastructure and systems. Real-time data processing at scale. Performance-sensitive native code. Reliability engineering where five nines isn’t a marketing term but an operational requirement. This is where AppSignal lives. The challenge isn’t writing the code. It’s designing systems that work under pressure, at scale, without failure.

More Code Means More Need for Monitoring, Not Less

Here’s the thing that the “SaaS is dead” crowd seems to miss entirely: if AI helps developers ship more code, faster, that doesn’t reduce the need for tools like AppSignal. It increases it.

More applications in production means more things to monitor. Faster deployment cycles mean more chances for regressions to slip through. Code that was generated rather than carefully crafted is, if anything, more likely to have subtle (or not so subtle) performance issues that only surface under load.

The very trend that people claim will kill SaaS is the same trend that makes infrastructure-level SaaS more valuable.

The “I Can Build That” Trap

Every developer has looked at a product and thought “I could build that in a weekend.” I’ve done it myself. We all have. AI makes that feeling even stronger, because now you probably can get a working prototype in a weekend.

But a prototype isn’t a product. A product is the prototype plus error handling, plus security, plus compliance, plus scaling, plus monitoring, plus on-call rotations, plus support, plus years of edge cases you haven’t encountered yet. Every hour you spend maintaining your homegrown tool is an hour you’re not spending on your actual product.

For simple tools, the build-it-yourself math might work out. For anything with real complexity behind it, you’re trading a subscription fee for an ever-growing maintenance burden. That’s not saving money. That’s a hiring decision disguised as a cost-cutting exercise.

So, Is SaaS Being Devalued?

Some of it, yes. The simple stuff. The tools that were always one ambitious weekend away from being replaced. AI just made that weekend shorter.

But for SaaS that does genuine heavy lifting (processing data at scale, running critical infrastructure, solving problems that require deep systems engineering) the value proposition hasn’t changed. If anything, it’s gotten stronger.

The question isn’t whether AI will disrupt SaaS. It’s which layer your product sits on. And if you’re deep in the infrastructure layer, you’re not the one who should be worried. At least not yet.