Techbanq

Software · SaaS platforms

The second tenant is what makes it a SaaS product, not the first

Building an application for one organisation and building a SaaS product look similar until the second customer arrives. Then the questions that never came up — how one tenant's data stays invisible to another, how a new customer signs up and starts without you, how usage becomes a bill — turn out to be the product. These are hard to add to a single-tenant build after the fact, which is why the second tenant has to be a design assumption from the first.

Serving Saudi Arabia from our Riyadh office and our engineering hubs in Lahore and Karachi

Software team working together at desks in an open office
  1. 01

    Market

    Saudi Arabia

  2. 02

    Written for

    Founder, CTO

  3. 03

    Decision

    Build a multi-tenant SaaS product that can take on customers without rework

  4. 04

    Languages

    EN · AR

Information security for software delivery

  • ISO

    ISO/IEC 27001

    ISO/IEC 27001 certified

Certifications & registrations

A tenant's life

What a new customer sets in motion the moment they sign up

In a SaaS product, one signup triggers a sequence a single-tenant app never runs. Each stage has to happen without you in the loop, and the branch is the guarantee everything else rests on: a tenant's data must never reach another tenant.

A flow of a tenant's life — sign up and provision, isolate the tenant, onboard to first value, then meter, bill and renew — resting on one branch: the isolation guarantee that no tenant may reach another's data.

  1. 01

    Sign up and provision

    A new customer creates an account and the platform sets up their tenant automatically, so onboarding a hundredth customer costs no more of your time than the first.

  2. 02

    Isolate the tenant

    Their data is separated from every other tenant's from the first record, so isolation is a property of the design rather than a filter someone must remember to apply.

  3. 03

    Onboard to first value

    The product guides the customer to the first useful thing without a call, because a self-serve product that needs a human to set up every account does not scale as one.

  4. 04

    Meter, bill and renew

    Usage is measured and turned into an accurate charge, and renewals and plan changes run on their own, so revenue does not depend on someone reconciling a spreadsheet each month.

Always available

The isolation guarantee

Underneath every stage sits one non-negotiable rule: no query, no export and no bug may let one tenant see another's data. It is enforced in the architecture and tested continuously, because a single cross-tenant leak is the failure a SaaS business rarely recovers its trust from.

The costly shortcut

The single-tenant app that could not become a product

A common and expensive path starts with building for the first customer as if they were the only one. It is faster, it demos well, and the first customer is happy. Then a second wants the product, and the assumptions baked in everywhere — one set of data, one configuration, one implicit owner — have to be unpicked. Multi-tenancy is not a feature you add to a screen; it is a property of how data is stored, how every query is written and how access is checked. Retrofitting it means revisiting almost everything, usually while the first customer is live and cannot be disrupted.

The opposite mistake is to over-build: to spend the first year on scale a product without customers does not need, and never ship. The honest middle is to make multi-tenancy and a clean isolation boundary a design assumption from the start — cheap to decide early, ruinous to add late — while keeping everything else as small as a first version should be. You do not need elaborate billing for one customer, but you do need a data model that will not have to be torn apart when the second arrives. That distinction, between what must be right now and what can wait, is most of the design work.

The machinery

The parts of a SaaS product that have nothing to do with your feature

Your differentiating idea is only part of a SaaS product. These are the parts every SaaS shares, that a single-tenant build skips, and that decide whether you can actually take on customers.

Tenancy and isolation

Keep every tenant's data and configuration separate and unreachable from any other, by design rather than by a filter.

Why a single-tenant build lacks it: A single-tenant app has one owner, so it never had to ask the question.

Self-serve onboarding

Let a customer sign up, provision and reach first value without a person setting up their account.

Why a single-tenant build lacks it: For one customer, a human did the setup once and it never needed automating.

Metering and billing

Measure usage and turn it into an accurate, auditable charge, with plans, renewals and changes handled automatically.

Why a single-tenant build lacks it: A single contract is invoiced by hand; a product cannot bill hundreds that way.

Per-tenant configuration

Let each customer differ within limits — branding, settings, roles — without forking the code for each of them.

Why a single-tenant build lacks it: One customer's needs were simply the requirements; a product must vary them in data, not code.

Our role

What we build into the platform and what your product team runs on it

  1. 01

    The tenancy model, decided early

    We settle how tenants are isolated and how far they may be configured before the product takes on a second customer, because these are the decisions that are cheap now and a rebuild later.

  2. 02

    A first version, not an over-build

    We keep the feature scope as small as a first product should be while making the platform assumptions right, so you ship to real customers without spending a year on scale you do not yet have.

  3. 03

    A product your team owns

    We build so your team can add tenants, plans and features without us, because a SaaS product only its builder can operate is a bottleneck between you and every new customer.

What the product does and who it is for are your bets to make; we build the tenancy, the isolation, the onboarding and the billing that let those bets be tested on real customers, and keep the first version small enough to reach them while the machinery underneath is built to hold the hundredth.

Common questions

What buyers ask

What is the difference between building an application and building a SaaS product?+

An application serves one organisation; a SaaS product serves many at once, and that difference lives mostly in parts a user never sees. A product has to keep each customer's data isolated from every other's, let a new customer sign up and start without your involvement, vary its configuration per customer without a separate copy of the code, and turn usage into a bill automatically. None of these matter for a single organisation, so an application built for one customer usually assumes exactly the things a product cannot. The visible feature can be identical; the machinery around it is what separates the two, and it is the machinery that decides whether you can take on the second customer without a rebuild.

How do you stop one customer's data from ever reaching another?+

By making isolation a property of the architecture rather than a filter the code has to remember to apply. Every piece of data is tied to its tenant at the point it is stored, and every query, export and background job is bound to a single tenant by the platform, not by a developer adding a condition each time. The riskier design is one where all tenants share a table and correctness depends on never forgetting a "where tenant equals" clause, because the day one query forgets it, one customer sees another's records. We enforce the boundary structurally, test it continuously with cases that deliberately try to cross tenants, and treat a cross-tenant leak as the most serious defect class a SaaS product has, because it is the failure customers do not forgive.

Should billing and metering be built early, or once we have customers?+

Build the ability to measure usage early and the elaborate billing late. The two are often confused. Metering — knowing accurately what each tenant used — is hard to reconstruct after the fact, because you cannot bill for usage you never recorded, so the events that will one day become charges are worth capturing from the start even if you invoice the first few customers by hand. The billing engine itself — plans, proration, tax, dunning, self-serve upgrades — is genuine work that a product with three customers does not yet need, and building it before you know your pricing is a common way to waste the first year. The rule that holds is: record usage now so nothing is lost, automate the invoicing when the number of customers makes doing it by hand the bottleneck.

Next step

Design the platform

A design session that decides the tenancy model, the isolation guarantee and how billing works, before the product takes on a second customer.