Jump to

Nov 20, 2026
Multi-tenant vs single-tenant: when the cheaper option costs more
Multi-tenant vs single-tenant is usually framed as cheap versus safe, and that framing is wrong in both directions: one shared system is the right start for most young platforms, and it turns into the expensive option at a few specific, nameable moments. this article is about those moments. studio ubique is a web design and SEO agency from Zwolle, active since 2012, building custom websites, webshops and applications for dutch smes and international clients, and this question lands on the table in almost every platform project we scope.
Shared is cheap until one customer is bigger than the rest of your customers put together, and then shared becomes the most expensive decision you made.
What multi-tenant vs single-tenant means for your bill
A tenant is one customer organisation using your platform. In a multi-tenant setup, all tenants share one running application and usually one database, with a tenant ID on every row telling the system whose data is whose. In a single-tenant setup, each customer gets its own copy: own database, often own server, own deployment.
That sounds like a database question. It is a bill question. Shared means you pay for one set of servers, run one migration, ship one security patch, and watch one set of logs. Separate means all of that times the number of customers, plus the scripts to keep the copies in step. The Microsoft Azure Architecture Center guide to multitenant solutions lays out the models neutrally, and it is worth reading before anyone draws boxes on a whiteboard.
SaaS, software as a service, is where this bites hardest, because the whole business model assumes the hundredth customer costs almost nothing to add. Single-tenant quietly breaks that assumption. Studio Ubique works from Zwolle since 2012.
Why shared is the right default for most
For a platform with a few dozen customers of roughly equal size, multi-tenant architecture is simply the right call, and paying for separation you do not need is waste dressed up as caution.
Here is the part that costs us something to say. A single-tenant build bills more hours, for us as well as for everyone else, and Studio Ubique rates are 60 to 65 euro per hour. Most early platforms do not need it. Our view, which plenty of security consultants will dispute, is that per-customer databases sold to teams under fifty customers are mostly bought to calm a procurement questionnaire, not to protect anyone’s data. Good tenant filtering with tests does that job.
Cheap is fine here.
Decision box
- Best if: you have many customers of similar size, one codebase, and no contract demanding its own data location.
- Not ideal if: one customer already generates most of your load, or a sector rule forces physical data separation.
- Likely overkill when: you are pre-launch, under about fifty customers, and the “security” argument comes from a template questionnaire.

The signals that the cheap option is turning
The shared setup starts costing more the moment your customers stop being alike. It depends on four things, and they are checkable, which is more than most architecture advice can say.
- One tenant is more than about a third of your database load, so their busy hour is everyone’s slow hour.
- A contract arrives asking for its own database, an EU-only region, or its own encryption keys.
- Customers want different release timing, because one of them tests every update for two weeks first.
- You cannot say what a single customer costs you to run, so your prices are guesses.
Studio Ubique builds custom websites in WordPress, Vue.js, Node.js, Next.js, NestJS and Laravel. The stack rarely changes these signals. Laravel or NestJS will happily run a shared setup that is quietly turning against you.
How a shared setup fails, in order
Monday, nine o’clock. Your largest customer starts a full-year export, and every other customer’s pages take eight seconds to load. This is the noisy neighbour problem: one tenant using so much of a shared resource that the others feel it.
The support inbox fills first. Then someone adds caching to hide it. Then a hurried query, written under pressure, forgets the tenant ID filter, and customer A sees one of customer B’s invoices. That is a data breach under GDPR, with a notification clock attached. Then the large customer asks, reasonably, for their own database. Now you are retrofitting separation through every table, every background job and every report, which runs into weeks, not days.
The opposite failure is quieter, and we have built it. Studio Ubique once shipped a booking platform where each new client got its own copy, because it felt tidy. By client nine, one security patch meant nine deploys and nine database migrations, and one of those migrations failed silently on a single copy that nobody checked for a month. We merged them into one shared system the following year. Tidy is not cheap.
The middle routes nobody pitches
You do not have to choose between everyone in one table and everyone on their own server. There are three middle routes, and most platforms end up on one of them.
Row-level security lets the database itself refuse to return rows from another tenant, so a forgotten filter in code does not become a leak. Schema per tenant keeps one database but gives each customer its own set of tables, which makes exports and deletion clean. And the hybrid route keeps small customers shared while moving the one or two heavy ones onto their own database, billed accordingly. That last one is what we recommend most often in web application development, because it matches cost to the customer who causes it.
The catch: hybrid only works if tenant ID was there from day one. Bolted on later, it is the expensive retrofit from the previous section.

Choosing, then living with it
Start shared, put a tenant ID on everything, switch on row-level security, and write down the threshold at which you will move a heavy customer out. That is the whole decision for most teams. The rest is watching whether you are getting close.
The written threshold matters more than the architecture. Without it, nobody owns the moment, and the switch happens during an outage instead of during a planned sprint.
What to monitor monthly
- Share of database load from your single largest tenant.
- Slowest page times per tenant, not averaged across everyone.
- Any query or report in review that skips the tenant ID filter.
- Running cost per tenant, set against what that tenant pays.
- Number of open contract requests for separate data or regions.

Multi-tenant vs single-tenant is not cheap versus safe. A shared multi-tenant setup is the right default for platforms with many similar customers, and it turns expensive when one tenant dominates the load or a contract demands separate data. Studio Ubique, working from Zwolle since 2012, advises starting shared with a tenant ID on every row and a written threshold for moving heavy customers out.
FAQs
Is single-tenant always more secure than multi-tenant?
No, a well-built multi-tenant setup with tenant filtering, row-level security and tests is safe for most platforms, while badly maintained single-tenant copies drift out of date and miss patches.
When should a SaaS move from multi-tenant to single-tenant?
Usually when one customer causes more than about a third of your load, or a contract requires its own database or data region, and then often only for that customer.
What is the noisy neighbour problem?
It is when one tenant uses so much of a shared database or server that every other tenant on the same system gets slower.
Can i switch architectures later?
Yes, but it is far cheaper if every table had a tenant ID from the start; adding it afterwards touches every query, job and report.
Does the framework decide which model i use?
Not really, Laravel, NestJS and most modern stacks support both, so the choice depends on your customers and contracts rather than your code.
The retrofit gets dearer
Every month without a tenant ID on your tables adds rows, jobs and reports that all need rewriting later. Not urgent. Just more expensive each time you look.

