The choice shapes almost everything that follows: the cost of serving each customer, how fast you can release updates, how you answer an enterprise buyer's security questionnaire and how hard it is to customize the product for one account. Many teams make it by accident, by deploying a copy for each new customer until upgrades take a week, or by putting everyone in one database without thinking about isolation until a large customer asks.
Most B2B products are best served by a multi-tenant core with strong data isolation, plus the option to give specific customers dedicated components, such as their own database or deployment, when regulation, contracts or scale require it.
This article compares single-tenant and multi-tenant architecture, explains the isolation models in between, sets out the data layer options, gives a decision checklist and shows how real platforms made the choice. It does not cover infrastructure tenancy inside cloud providers.
Key takeaways
- Single-tenant means one instance per customer. Multi-tenant means one shared instance for many customers.
- Multi-tenant products cost less to run per customer and release updates once for everyone. Single-tenant products offer stronger isolation and easier customization.
- Most products end up in between: shared application code, with some components shared and some dedicated. AWS calls these silo, pool and bridge models.
- In the data layer, the main options are shared tables with a tenant ID, a schema per tenant and a database per tenant.
- In a shared design, tenant isolation must be enforced in the data layer and tested, never left to the interface alone.
- Regulation can decide the question outright: a telecom operator's voice AI had to run on dedicated infrastructure inside its own data center.
Single-tenant vs multi-tenant at a glance
| Single-tenant | Multi-tenant | |
|---|---|---|
| What each customer gets | Its own application instance and data store | A share of one application and its infrastructure |
| Cost per customer | Higher, each instance has a fixed base cost | Lower, infrastructure is shared |
| Updates | Rolled out instance by instance | Released once for all customers |
| Data isolation | Physical separation | Logical separation, enforced in code and the database |
| Customization | Easier to adapt one customer's instance | Done through configuration and feature flags |
| Noisy neighbors | None, one customer's load stays on its own resources | Possible, one tenant's load can slow others |
| Compliance and residency | Easier to place data in a specific region or network | Needs region-aware design for residency requirements |
| Onboarding a new customer | Provision a new environment | Create a tenant record and configuration |
| Operations | Many environments to monitor, patch and back up | One environment, with tenant-aware monitoring |
The isolation spectrum: silo, pool and bridge
Real systems rarely sit at either extreme. The AWS SaaS Lens describes three models.
- Silo. Tenants get dedicated resources, such as a separate stack or database, while still sharing identity, onboarding and operations. Regulatory requirements and noisy-neighbor concerns push components toward this model.
- Pool. Tenants share compute, storage and messaging. This is classic multi-tenancy, chosen for cost efficiency and agility.
- Bridge. Some components are siloed and others pooled. One service might give each tenant its own database, while another serves everyone from shared tables.
The bridge model is where most growing B2B products land. It lets you offer a standard plan on pooled infrastructure and an enterprise plan with dedicated data storage, without maintaining two different products.

Data layer options
| Option | How it works | Fits | Watch out for |
|---|---|---|---|
| Shared tables with a tenant ID | Every row carries a tenant ID, and every query filters on it | Thousands of small tenants, lowest cost | One missing filter exposes another tenant's data |
| Shared tables with row-level security | The database enforces the tenant filter on every query | Same as above, with a database-level safety net | Connection and session handling must set the tenant correctly |
| Schema per tenant | Each tenant has its own set of tables in a shared database | Tens to hundreds of tenants, some per-tenant changes | Migrations must run across many schemas |
| Database per tenant | Each tenant has its own database, on shared or separate servers | Enterprise customers, residency requirements, per-tenant backup and restore | Higher cost, many databases to manage |
| Full instance per tenant | Separate application and data stack | Regulated or on-premise customers, heavy customization | Highest cost, slow upgrades across instances |
PostgreSQL's row-level security lets the database itself restrict which rows a session can see, which turns tenant isolation into a rule the database enforces even when a query forgets the filter.
How to choose: a decision checklist
Lean toward multi-tenant when:
- You expect many customers, especially small and mid-size ones.
- Customers use the same product with configuration differences, not code differences.
- You want to release often and keep every customer on the same version.
- Cost per customer matters to your pricing.
Lean toward single-tenant, or dedicated components, when:
- Regulation or contracts require data to stay in a specific region, network or data center.
- A few large customers each need heavy customization or their own release schedule.
- One customer's load would affect everyone else.
- Customers require their own encryption keys, backups or penetration test scope.
Choose a hybrid when both lists apply: a shared core for most customers, and dedicated databases or deployments for the few that need them, priced accordingly.
A worked cost comparison
Consider a B2B product with 200 customers. The figures are illustrative.
- Single-tenant. Each customer runs on its own small environment costing about $400 a month in infrastructure, or $80,000 a month in total. Every release is deployed and checked 200 times, and every security patch is applied 200 times.
- Multi-tenant. All customers share a scaled environment costing about $8,000 a month. Each release is deployed once, and monitoring and patching cover one system.
The infrastructure difference is large, and the operational difference is often larger, because engineering time spent on 200 deployments is time not spent on the product. The trade-off is that the multi-tenant design needs stronger isolation engineering from the start, and a few customers may still need dedicated components.
Deciding how to serve many customers from one product? We design tenancy models, data isolation and enterprise options that fit your market.
Explore IT outsourcingTenant isolation essentials for shared systems
- Resolve the tenant once, from a trusted source. Take the tenant from the authenticated session or token, never from a parameter the client can change.
- Enforce it in the data layer. Use a repository layer that always applies the tenant filter, or row-level security in the database, so a forgotten filter cannot leak data.
- Test for cross-tenant access. Automated tests should try to read and change another tenant's records and confirm every attempt fails.
- Scope caches, files and search indexes. Cache keys, storage paths and search queries all need the tenant ID too.
- Limit each tenant's share of resources. Rate limits and queue quotas per tenant keep one heavy customer from slowing the others.
- Make logs and metrics tenant-aware. Support teams need to see one tenant's activity, and the system needs to spot a tenant whose usage spikes.
- Plan per-tenant backup and restore. Restoring one customer's data without rolling back everyone else is a common enterprise requirement.
Permissions inside each tenant are a separate layer. Our comparison of RBAC and ABAC covers how to model them.
How real platforms made the choice
One CMS for many law firm websites
A US law firm runs several marketing websites on Verba, a custom content management system. Instead of a separate installation per site, the platform serves multiple sites from one system. Hard-coded roles had blocked growth across sites, so a .wrk team introduced a policy-based permission model of resources and actions, and moved shared interface components into a versioned package with theming, so new firm sites launch faster from shared building blocks. Read the Verba CMS case study.
A shared framework across a network of media sites
HIMSS runs several healthcare media sites, including Health Care IT News and MobiHealthNews, each with about 50,000 daily users. .wrk built a shared Drupal framework in a separate repository, so new sites extend the framework instead of starting from scratch. HIMSS now runs a multi-site model on a shared codebase, and annual redesigns that took months now take one developer one week. Read the HIMSS case study.
A tenant hierarchy for a franchise network
A US quick-service restaurant franchise network runs its daily operations on a task platform with several levels: administrators create task templates, network managers adapt and assign them for their locations, and staff complete tasks on mobile. The template hierarchy reflects how franchises actually run shifts, a reminder that tenancy often has several levels. Read the franchise operations case study.
Single-tenant by regulation
A regional telecom operator needed voice AI for its contact centers, but regulation required subscriber voice data to stay inside its perimeter. The platform runs single-tenant on a two-node cluster in the operator's own data center, with no external speech services. Read the on-premise voice AI case study.

Converting a single-tenant product to multi-tenant
- Add a tenant ID everywhere. Add it to every table, cache key, file path and queue message, even while each tenant still runs separately.
- Centralize tenant resolution. Make one piece of code responsible for knowing which tenant a request belongs to.
- Enforce isolation in the data layer and write cross-tenant tests before merging any data.
- Turn customizations into configuration. Code that differs per customer becomes settings, feature flags or extension points.
- Migrate tenants in groups. Move small tenants first, verify their data and behavior, then move larger ones. Keep dedicated options for customers who need them.
For the security and audit side of serving many customers, see our guides to SOC 2 for startups and on-premise AI.
Frequently asked questions
What is the difference between single-tenant and multi-tenant?
In a single-tenant architecture, each customer has its own instance of the application and its own data store. In a multi-tenant architecture, many customers share one instance and infrastructure, with their data kept separate by the application and the database.
Is multi-tenant less secure than single-tenant?
Not inherently. Multi-tenant systems rely on logical isolation, so they need tenant enforcement in the data layer, cross-tenant testing and careful handling of caches and files. Single-tenant systems isolate data physically, which some regulations and contracts require.
What is multi-tenant architecture in SaaS?
In SaaS, multi-tenant architecture means one application serves many customer organizations, sharing code and infrastructure while keeping each organization's data, users and settings separate. It lets providers release updates once and serve customers at lower cost.
When should you choose single-tenant architecture?
Choose single-tenant, or dedicated components, when data must stay in a specific region or network, when a few large customers need heavy customization or their own release schedules, or when contracts require dedicated resources.
Can a product offer both single-tenant and multi-tenant options?
Yes. Many B2B products run a multi-tenant core for most customers and offer dedicated databases or deployments for enterprise customers, often as a higher-priced plan. This hybrid approach is sometimes called the bridge model.
To sum up
Single-tenant gives each customer its own instance, and multi-tenant serves everyone from one. Most B2B products do best with a multi-tenant core, strong isolation enforced in the data layer and dedicated components for the customers who truly need them. Decide early, because tenancy affects cost, release speed, security reviews and every table in the database.
.wrk designs and builds B2B platforms for companies in the US and Europe, including multi-site and multi-tenant systems, tenant-aware permissions and single-tenant deployments for regulated customers.
Planning a SaaS product or rethinking how you serve customers? Tell us about your customers and requirements, and we will propose a tenancy model and data design.
Explore IT outsourcing