From SaaS apps to a SaaS OS

Most people still think about development in terms of individual applications. You start with an idea, then build from scratch, wire up the basics, and solve the same problems over and over again. Even with AI, this hasn’t fundamentally changed. Writing code is faster, but the structure remains the same. Every time, you are rebuilding the foundation.

I didn’t go in the direction of building another app. Instead, I built a core system that behaves more like an operating system for SaaS. Everything runs on a single multi-tenant backend, where applications are not separate codebases, but different tenants running on the same core. Data is isolated, but logic is shared. That means you are no longer building each application independently, but using one system that scales across multiple use cases.

Instead of developing features from scratch, everything is structured as modules. Booking systems, payments, analytics, email, AI functionality — these are not rebuilt each time. They exist as independent units that can be activated. A module is not a template, but working functionality already connected to the system. When activated, it becomes part of a live application.

The real shift is not just modularity, but orchestration. AI is not used to generate code from zero, but to assemble systems. The user describes what they want, the system finds the right modules, installs them, and connects everything into a working structure. Instead of writing code line by line, the system composes applications from existing parts.

On top of this sits what I call the studio. This is not just a builder interface. It is the layer where applications are actually created for real users. Instead of every client building their own app from scratch, the system allows us to create applications centrally and assign them as tenants. Each client gets their own isolated instance, already configured, already functional, running on the same core.

This changes the delivery model. You are not just building software, you are deploying systems. A client does not receive code they need to figure out, but a working application already running as their own environment.

From this approach, multiple applications can be created without separate development cycles. A booking app, a CRM, an AI tool, or a vertical solution are not independent builds, but different configurations of the same system. The difference lies in which modules are active and how they are connected.

On top of everything, there is a marketplace layer. This is where modules and systems become accessible beyond internal use. Instead of building functionality, users can activate it. Instead of starting from zero, they extend what already exists. This shifts the focus from development to composition.

When you look at the full structure, this is not about writing code faster. It is about removing coding as the starting point. Instead of building up from nothing, you begin with a working system and adapt it. This removes the biggest inefficiency in SaaS development, rebuilding the same components again and again.

The biggest change is conceptual. Applications are no longer something you build from scratch. They are something you assemble, deploy, and scale across tenants. At that point, AI stops being a coding assistant and becomes the system that actually builds and deploys software.