Wall & Fifth

SaaS MVP Architecture: Get These Decisions Right First

The SaaS architecture decisions that are load-bearing from day one — multi-tenancy, data isolation, auth, and billing — and what sound choices look like in practice.

By William · Updated 30 October 2026 · 12 min read

The architecture of a SaaS MVP is not a detail to sort out once the product feels validated. Several decisions — how you handle multiple customers, how you isolate their data, how billing connects to access — are structurally load-bearing from day one. Made well, they become invisible foundations. Made poorly, they become the reason a later rebuild costs more than the original build. This guide covers which decisions fall into each category, and what sound choices look like in practice.

Why architecture choices made at MVP stage are so hard to undo

Most software decisions are reversible with effort. You can swap a UI framework, redesign a dashboard, or change a pricing page in days. Architectural decisions sit in a different category: they shape how every other part of the system is built, and untangling them later means rewriting code that has already accumulated six months of logic on top of it.

The concept of Minimum Viable Architecture is useful here. An MVA consists of a minimal set of technical decisions tested and evolved empirically over time — specifically, the decisions that, if not made early, would make the product uneconomic, impractical, or impossible to change later. [1] For SaaS specifically, the decisions in that category are tenancy model, data isolation approach, authentication and role structure, and how billing state connects to access. Everything else can wait.

This is also why MVPs are not intended to be thrown away. [1] If the product is going to evolve into the real thing — which is the point — then the foundation it is built on has to be designed with that in mind from the start. A prototype can ignore this. A SaaS MVP cannot.

For broader context on what a SaaS MVP has to prove and what it requires before launch, the complete guide to building subscription software as an MVP covers the full picture.

The tenancy model: the highest-stakes call in SaaS architecture

Multi-tenancy is the practice of serving multiple customers — tenants — from one running instance of your software, while keeping their data completely separate. It is the defining structural characteristic of SaaS, and it is the decision that is most expensive to retrofit.

If you build a single-tenant system at MVP stage — one database per customer, one deployment per customer — you can move faster in week one. But the moment you want to onboard a second customer without manual infrastructure work, or close a deal with a buyer who expects shared infrastructure economics, you face a rewrite of the data layer that touches every table, every query, and every piece of access logic in the system.

For most B2B SaaS products intended to serve more than a handful of customers, building multi-tenant from the start is the right call. In our experience, the incremental effort at build time is modest compared to the cost of retrofitting it later — when real customers and real data are already in the system. The only legitimate reason to defer it is if the code is genuinely going to be discarded after customer discovery. If the MVP is going to become the product, build multi-tenant from sprint one.

The three canonical data isolation models

There are three standard ways to implement multi-tenancy in a SaaS product. Each involves a different trade-off between isolation, cost, and operational complexity.

ModelHow it worksIsolation levelOperational costBest for
Pool (shared schema) All tenants share one database; every table has a tenant_id column; row-level security enforces isolation Logical Lowest Early-stage SaaS, price-sensitive markets, self-serve products
Silo (separate databases) Each tenant gets their own database or schema, fully isolated at the infrastructure level Physical Highest Enterprise buyers with data residency requirements, regulated industries
Bridge (hybrid) Self-serve tenants share a pool; high-value or enterprise tenants get silo treatment Mixed Medium to high Products serving both self-serve and enterprise tiers from one platform

For the vast majority of SaaS MVPs, the pool model is the right starting point. It is the least expensive to operate, the fastest to build correctly, and the most common foundation for products that later scale. The rule of thumb: choose pool unless a specific customer's procurement process requires physical data separation. If that buyer exists at MVP stage, use silo for them. If they do not yet exist, build pool and document the path to bridge later.

The risk of starting single-tenant and planning to add multi-tenancy later is real and consistent. A single-tenant MVP can win early customers. It can also become the precise reason a promising enterprise deal cannot close, because the buyer's security questionnaire asks where their data physically lives and the honest answer is that it lives next to everyone else's data in a system that was never designed to separate it cleanly.

Monolith versus microservices: start simpler than you think

The instinct on many early SaaS builds is to architect for scale before the product has any users. Microservices feel rigorous. Separate services for auth, billing, notifications, and core logic feel like good engineering discipline. In practice, they dramatically increase the operational surface area of a product that needs to ship and learn quickly.

The recommended pattern for a SaaS MVP is a modular monolith: one deployable application, broken into clean internal modules by domain, built on a mainstream stack that any competent developer can read. This keeps deployment simple, debugging straightforward, and onboarding fast — all of which matter when the product is changing weekly based on user feedback.

Clean internal boundaries matter here. If the billing module, the user module, and the core product logic are tangled together, separating them later becomes genuinely hard. If they are distinct domains inside the same codebase — with clear interfaces between them — the monolith can be split selectively once the product is large enough to justify the operational overhead. That is a decision that should be driven by real scaling constraints, not engineering ambition at MVP stage.

What to defer, and what that looks like in practice

The following patterns are worth deferring until there is clear evidence the product needs them:

  • Container orchestration (Kubernetes): adds meaningful operational complexity with no benefit until you are managing dozens of services or have significant horizontal scaling requirements
  • Multi-region deployments: justified by latency requirements or data residency obligations, not by ambition
  • Event-driven microservices: powerful for large engineering teams maintaining independent services; a liability for a small team in early product-market fit
  • Complex caching hierarchies: Redis for session storage is fine; elaborate cache invalidation logic across multiple layers is not an MVP problem

The principle of delaying architectural complexity until it is genuinely needed applies directly here. Adding infrastructure before real scaling constraints emerge does not reduce future risk — it increases it, because it ties the team to maintaining that infrastructure before the product has been validated.

Authentication and access control: build it correctly, once

Authentication is one of the areas where buying a mature solution is almost always better than building from scratch. Managed services and established libraries handle the security-critical implementation details that are genuinely difficult to get right: token rotation, password hashing, session management, email verification flows, and the edge cases that only surface when real users are doing unexpected things. On every SaaS build at Wall & Fifth, auth is treated as a buy decision — the time saved goes into the product logic that is actually specific to the business. The MVP pricing page lists authentication — registration, login, session management, password recovery, and role-based access control — as a standard deliverable on every build.

Role-based access control from day one

Authentication answers the question who is this person? Authorisation answers the question what are they allowed to do? In a SaaS product, you need both, and they need to be separated from the start.

The most common mistake is building an auth layer with a binary admin/non-admin distinction and planning to add proper roles later. In B2B SaaS, that moment arrives faster than expected. The first fifty-seat customer will ask whether a manager can see reports but not billing, whether a viewer role can be created without a seat cost, or whether SAML-based single sign-on is on the roadmap. All of those questions require a real RBAC model scoped to each tenant.

The practical requirement at MVP stage: each user has a role, each role is scoped to a tenant, and the authorisation check happens at the data layer rather than just in the UI. Hiding a button in the interface is not access control. Preventing the API from returning data the user is not permitted to see is. Security decisions that belong in the architecture are covered in the Wall & Fifth approach to secure development.

Billing architecture: wiring Stripe to access state

Subscription billing is infrastructure, not a feature. The integration between a payment provider and the product's access control layer determines whether the product actually behaves like a SaaS business or like a free tool with a payment page bolted on the side.

The core requirement is straightforward: the subscription state held in Stripe must be the source of truth for what a user can access in the product. When a subscription is active, access is open. When it lapses, access changes. When a plan is upgraded, new capabilities unlock. That connection has to be synchronised reliably, which means listening to webhook events from Stripe rather than checking payment state only at login.

What the billing integration needs to handle at MVP

  • Plan selection and checkout: customers choose a plan and pay; Stripe Checkout or Stripe Elements handles card collection securely
  • Trial periods: if offered, trial state must be reflected in the access layer so the product behaves correctly throughout and at trial end
  • Subscription status webhooks: customer.subscription.updated, invoice.payment_failed, and customer.subscription.deleted must be handled and reflected in access state
  • Customer portal: Stripe's hosted portal handles plan changes, cancellations, and invoice history without custom development
  • Proration: if you offer multiple tiers, mid-cycle plan changes need a clear policy; Stripe handles the maths, but you have to decide the behaviour

At MVP stage, one plan and one price point is often the right scope. The billing architecture should be set up correctly for that one plan, with the data model designed to accommodate additional plans later without structural changes.

Hypothetical example: a B2B SaaS reporting tool

Suppose a founder is building a reporting dashboard for small accountancy practices. At MVP, there is one plan at £49/month per workspace. The correct architecture: each accountancy practice is a tenant in a pool multi-tenant database; each practice has a workspace record linked to a Stripe customer ID; subscription state is stored on the workspace record and updated via webhook; users within a workspace have roles (owner, member, viewer); access to the dashboard is gated on workspace subscription status. When a practice's card fails, the webhook fires, the workspace subscription status updates to past_due, and the UI reflects restricted access until payment is resolved. None of this requires multiple plans — it just requires the right model from the start.

The stateless API and why it matters for scale

A stateless API — one that does not hold session state on the server between requests, relying instead on tokens passed with each request — is the standard approach for SaaS backends and the right default at MVP stage. It simplifies horizontal scaling (any server can handle any request), makes load balancing straightforward, and avoids the session-stickiness problems that emerge when you later need to run more than one instance of your application.

This does not mean there is no state in the system. Database state, subscription state, and user records all persist. It means the API layer itself does not hold in-memory session data between requests. JWTs or equivalent token-based auth, validated on each request against the data layer, are the standard implementation.

At MVP stage the practical impact is limited — you are unlikely to need multiple application instances in the first six months. But building stateless from the start means you never have to rearchitect for it later, and it is not a meaningful incremental cost during the initial build.

How Wall & Fifth approaches SaaS architecture before a build starts

Before a line of code is written on a SaaS build, the architecture conversation covers four things: tenancy model and data isolation approach; authentication provider and role structure; billing integration design and webhook handling; and the API design pattern. These decisions are documented as part of the scoping work — not because documentation is bureaucratic process, but because making architectural decisions transparent is what allows a team to make better decisions later as the product evolves.

SaaS products built at Wall & Fifth use the pool multi-tenant model for standard B2B products, Stripe for subscription billing, managed auth providers rather than custom implementations, and a modular monolith architecture on a mainstream stack. The SellYourBoat.io platform — a multi-tenant yacht listing system with a public marketplace layered on top — is a live example of how one codebase serves multiple tenant types from a single, coherently structured build.

Once those foundation decisions are made and the MVP is live, the product faces a different set of questions: what the signals from real users mean, and what has to change before the product is ready to scale. That is covered in detail in the guide on what changes when a SaaS MVP moves toward a funded product.

Frequently asked questions

Can I start with a single-tenant architecture and add multi-tenancy later?

Technically yes. In practice, it means rewriting how every table in the database is queried and how every piece of access logic works — at a point when the product has real customers and real data. In our experience, the incremental effort of building multi-tenant correctly from the start is modest compared to retrofitting it later, though the exact difference depends on your stack, team, and product complexity. The exception is a genuine throwaway proof of concept: if the code will be discarded after customer discovery, single-tenant is fine. If the MVP is going to become the product, build multi-tenant from sprint one.

What is the right database choice for a SaaS MVP?

PostgreSQL is the standard choice for good reasons: it has robust row-level security (which enforces tenant isolation at the database layer in the pool model), mature tooling, strong hosted options, and a straightforward path to scaling. NoSQL databases can be appropriate for specific use cases, but the relational model with proper foreign keys suits the structured, multi-tenant data model of most B2B SaaS products. The decision should be driven by the data shape, not by what seems technically interesting.

Does a SaaS MVP need an admin panel?

If there are multiple user types — and most B2B SaaS products have at least an owner and a member — some form of administration is necessary from day one. At MVP stage this does not need to be elaborate: a basic workspace settings page, user invitation and removal, and plan management are usually enough. A full-featured admin panel with analytics, bulk operations, and support tooling can wait. What cannot wait is the data model that makes those features possible later without structural changes.

How much of the billing integration do I need to build at MVP?

Enough to charge real money and gate access correctly. That means: a working checkout flow using Stripe, subscription state stored on the tenant record and updated via webhook, and the UI reflecting access state accurately. You do not need multiple plans, usage-based billing, complex proration logic, or a custom invoice system at MVP. Stripe's hosted customer portal handles cancellations and plan management for self-serve users without custom development. Build the minimum that makes billing real, and design the data model to extend it later.

When should I start thinking about microservices?

When a specific, identifiable scaling constraint makes a monolith genuinely limiting — not before. Common triggers include a team large enough that different parts of the codebase need to be owned and deployed independently, a specific service with significantly different scaling characteristics from the rest of the application, or a compliance requirement that mandates physical separation of certain functions. None of those conditions typically apply during MVP validation. Starting with microservices before they are necessary adds operational complexity and slows iteration without providing meaningful benefit at that stage.

What should I ask a build partner about SaaS architecture before signing?

Ask specifically: how will they handle multi-tenancy and tenant isolation? What authentication provider do they recommend and why? How will subscription state connect to access control — where is that logic enforced? What is the monolith versus services decision and what drives it? A studio that can answer these questions precisely, before the build starts, is demonstrating the kind of structural thinking that protects you later. A studio that deflects these questions until after the contract is signed is telling you something important about how they work.

Back to SaaS MVP Development: The Complete Guide for Founders Building Subscription Software

Sources

  1. A Minimum Viable Product Needs a Minimum Viable Architecture - InfoQ

Work with Wall & Fifth

Have something to build? Let’s talk it through.

Start a conversationSee our work