SaaS is Dead. Long Live SaS: Why Service as Software is the Future

Service as Software — and why the SaaS bargain stopped making sense.

---

For twenty years, SaaS was the deal: pay monthly, get access to software that someone else built for a million companies just like yours. Except they weren't just like yours. They were sort of like yours. Close enough. You learned to live with the 70% fit, configured around the gaps, hired an admin to manage the workarounds, and integrated three other tools to cover what the first one couldn't do.

That deal made sense when software was expensive to build. It doesn't anymore.

The cost collapse changes everything

AI has done something structural to the economics of software development, and it's happening now, not in five years. The cost of producing working software has dropped enough that the core SaaS value proposition — amortize development cost across thousands of customers — is losing its hold.

When building is cheap, you stop renting. You start commissioning.

This is the shift from SaaS to SaS: Service as Software. Instead of buying access to a product that was designed for everyone and therefore fits no one particularly well, you engage a service that builds your software — shaped around how your business actually operates on a Tuesday morning.

"Custom software" doesn't mean what it used to

The old objection writes itself: custom software is expensive and impossible to maintain. That was true when every project started from a blank IDE. That picture changes when you're assembling from a library of production-proven components, with AI handling the composition and humans handling the judgment.

This is the part that gets lost in the AI hype. The vibe-coding tools — the ones that generate a full app from a prompt — produce great demos. They produce terrible systems. A demo works when you show it to your cofounder. A system works in January when your accountant needs to close the books and three people are on PTO.

The difference is that components built from real operational experience have already absorbed the edge cases. They've handled the vendor who sends malformed invoices and the employee who needs access to two departments simultaneously. AI that assembles from these components produces predictable results instead of hallucinated architectures that look right and break under load.

The human-AI relay

The pure-AI-build crowd frames this as full automation. AI writes the code, ship it, done.

In practice, the valuable pattern is a relay. AI assembles a first pass. A human inspects it, adjusts for business reality, extends where needed. AI picks up the next iteration. This back-and-forth works because each side handles what it's good at — AI covers speed and consistency, humans cover context and the fact that the warehouse manager won't use anything requiring more than two clicks.

The relay is the product.

The digital sherpa problem

Most AI-tool companies build the platform and assume adoption. This misses something fundamental about the SMB market.

A company with 40 employees doesn't have a CTO. They have an ops manager who's also doing HR, and a founder who knows their process cold but can't translate it into software requirements.

These companies need what I'd call a digital sherpa — not a consultant who delivers a slide deck and disappears, but a guide who sits alongside the business, understands how it actually runs, and stays through the build.

The sherpa isn't overhead. The sherpa is the reason the fit actually happens. Without that translation layer, the platform ends up solving the wrong problem.

Two sides of the same offering

This creates a natural two-sided model:

The platform side — a component-based architecture where AI produces repeatable, inspectable results from proven building blocks. The AI isn't generating code from scratch; it's composing from a library that's been refined across dozens of real implementations. A human can pick up where the AI left off, and vice versa. The relay works because the components are designed for it.

The sherpa side — domain-literate guides who work with SMBs to discover what they actually need, which is often different from what they think they need or what a vendor's feature list suggests. They use the platform and translate business reality into working software.

Each side makes the other stronger. Every sherpa engagement teaches the platform what SMBs encounter in practice, which grows the component library and makes the AI more accurate. That in turn makes the sherpa's job faster and brings delivery cost down.

The SaaS vendor response (and why it's not the same thing)

The large SaaS vendors will respond to this shift by wrapping AI around their existing products. "Let AI configure our platform for you." You'll see it marketed as AI-powered workflows and natural language setup.

That's a better SaaS experience. It's not SaS.

The difference is the starting point. SaaS-with-AI still starts from the vendor's architecture and works backward toward the customer. SaS starts from the customer's process and works forward toward software. The direction matters because it determines who compromises — and in the SaaS model, it's still the customer.

You can see this concretely in the first week of use, when the customer discovers the things their business does that the platform doesn't support. In SaaS, they file a feature request. In SaS, they get it built.

The question worth asking

SaaS was organized around a specific question: how do we get millions of users onto our software? SaS reframes it: how do we shape software around each user?

But underneath both is a more practical concern — who holds the map? Speed without direction doesn't get you anywhere useful. Domain expertise without speed can't keep up with how fast the market moves. The companies that figure out how to pair a repeatable platform with human expertise that ensures the right thing gets built — those are the ones that will reshape what "buying software" looks like.

The SaaS bargain was good while it lasted. But the economics shifted, and the deal doesn't pencil out the way it used to. Not when you can have software that actually fits.