Service · Web development

Custom multi-tenant platform development.

One codebase, many clients or brands: cleanly separated, manageable at scale and customisable per tenant. We build multi-tenant platforms for SaaS companies, franchise organisations and groups that want to run several business units in one system.

Data isolationTenant onboardingBranding per tenantFeature flags

Multi-tenancy is an architectural decision, not a feature.

A multi-tenant platform runs a single application instance on which multiple customers, known as "tenants", work separately from one another. Each tenant sees only its own data, its own branding and its own feature set, while your operations team maintains one codebase, one deployment and one management cycle. That distinction is fundamental to any SaaS business model.

The topic is often confused with multi-tenancy in property (a building with several tenants). That is a different domain, and for that we refer you to application management and facility solutions. On this page we are talking about multi-tenant software architecture: how you build one platform that serves ten, a hundred or a thousand customers at the same time without data, performance or branding ending up in each other's way.

We build custom multi-tenant platforms. Not a white-label SaaS template, but an architecture that suits your growth path, your compliance requirements and the way your tenants actually work. With over ten years of experience in bespoke business software, we know the pitfalls: query leakage between tenants, noisy-neighbour incidents, an unmanageable jungle of feature flags, or an onboarding flow that fails to keep pace with your commercial growth.

We work for clients in SaaS, financial services, healthcare, e-commerce and the public sector. For every type of tenant base, from a handful of enterprise customers to thousands of self-service accounts, a different answer is right. The first conversation is therefore not about technology but about your tenant reality: who your tenants are, how many there will be, and how they differ from one another.

Three multi-tenant architectures.

The fundamental choice that shapes your platform is how far you isolate data between tenants. Each option has its own trade-offs in cost, compliance and scalability. We advise on which approach fits during the first architecture conversation.

Lightest isolation · most scalable

Shared schema

All tenants share one database and one schema; separation is achieved through a tenant_id column in every table. The cheapest to build and manage, and it scales easily to thousands of tenants. It does, however, require strict row-level security, disciplined query practice and good monitoring to rule out data leakage.

tenant_id columnRow-level securitySingle deploymentBest for SaaS
Middle ground · good balance

Schema-per-tenant

One database server, one schema per tenant. Data is physically separated, queries need not carry a tenant_id, and backup or restore works per tenant. A good approach for a few dozen up to several hundred tenants; beyond that, managing the schemas becomes heavy going.

Strong isolationBackup per tenantMigration orchestrationConnection pooling
Maximum isolation · compliance-grade

Database-per-tenant

Each tenant runs on its own database, sometimes even its own cloud account. Maximum isolation, straightforward data residency by country, and demanding compliance requirements become achievable. The most expensive to operate and relatively limited in scaling to a large number of tenants, but the right model for banks, insurers and sensitive medical data.

Data residencyOwn encryption keysHeavy compliancePer-tenant tuning

What a multi-tenant platform must be able to do.

Architecture is one layer; the operational reality is broader. A multi-tenant platform lives or dies by the details around onboarding, isolation and the noisy-neighbour problem. Here are the building blocks that recur in every platform.

For billing, subscriptions and invoicing we work by default with our subscription management approach. For the wider infrastructure we align with cloud-native platform development.

  • Tenant onboardingSelf-service sign-up or an internal admin flow to create tenants, including seed data, default settings and welcome emails.
  • Data isolationRow-level security, encryption keys per tenant where required, and query middleware that prevents a developer from accidentally working across tenants.
  • Branding and themingEach tenant can have its own logo, colour palette, email templates and, optionally, a custom domain, without requiring a separate deployment.
  • Feature flags per tenantWhich functionality does each tenant see? A good feature-flag layer lets you show new features to one pilot tenant first, before rolling them out more widely.
  • Performance isolationThe noisy-neighbour problem: one heavy tenant must not slow down the rest. Per-tenant rate limits, query quotas and, optionally, dedicated workers.
  • Backup and restore per tenantA customer must be able to restore their own data to yesterday without affecting anyone else. A shared backup file doesn't meet this need.
  • Audit trail per tenantWho did what within which tenant? Verifiable logging for compliance and for your own support team.
  • GDPR and data residencyRight to erasure per tenant, data export in a machine-readable format and, where European data residency is required, firm guarantees that data never leaves the EU.
  • Tenant-aware logging and monitoringLogs and metrics are filtered by tenant, so an incident affecting one tenant doesn't get lost in the noise of the rest.
  • Custom domain supportA tenant wants to run under its own domain (portal.yourbrand.nl). We handle DNS validation, TLS certificates and routing automatically.
  • Multi-tenant application managementThe operations layer around it: testing deployments against multiple tenants, schema migrations without downtime and a control panel for your management team.
  • Integrations per tenantEach tenant can activate its own integrations with external systems, such as its own CRM, email provider or accounting software. See also our smart API integrations.

When multi-tenant is the right choice.

We typically see six patterns in which a multi-tenant platform genuinely adds value. If you recognise one of these situations, we'd be happy to talk further.

SaaS

One codebase, many customers

You're building a SaaS product and don't want to deploy, monitor and update a separate instance for every customer. One platform with N tenants is the entire business model.

Franchise

Central system, local autonomy

A franchise chain where each branch wants its own workspace, its own reports and its own branding, but head office wants to manage one platform with consolidated data.

Group

Subsidiaries under one umbrella

A holding company or group with subsidiaries that each have their own brand and processes, but share one HR, finance or operations platform. Consolidated reporting suddenly becomes straightforward.

White-label

Reselling to customers

You supply software that your customers resell to their own customers. Each reseller has its own branded portal, its own pricing and its own sub-tenants beneath it.

Marketplace

Sellers on one marketplace

A platform where different suppliers, makers or service providers offer their wares. Each seller has its own products, orders and dashboards, while the marketplace governs the whole.

Multi-brand

A portfolio of brands on one platform

Banks, insurers and consumer brands with several labels that run the same internal processes but present themselves differently to the outside world. One application layer, multiple customer-facing identities.

Multi-tenant application management is a specialism in its own right.

Building a multi-tenant platform is one thing; keeping it running in production for dozens or hundreds of tenants is another. Multi-tenant application management covers the operational layer that ensures a new release doesn't break a single tenant, that a database migration rolls out across all tenants without downtime, and that a fault affecting tenant A doesn't go unnoticed amid the noise of tenant B through to Z.

In practice this means tenant-aware monitoring (which tenant is experiencing latency issues?), per-tenant deployment strategies (canary releases where you first put one pilot tenant on the new version before rolling out more widely), schema migrations with version skipping (old and new code versions can temporarily run side by side), and a control panel through which your operations team can intervene ad hoc per tenant — temporarily switching features off, adjusting rate limits or starting a data export.

For the broader topic of outsourcing application management, please see the dedicated page, but in a multi-tenant context there is an additional layer that generic application management lacks. We build that layer in as standard and can carry out the management for you, or hand it over to your own ops team with the accompanying runbooks.

Not yet sure about a large project?

Test your idea first: a working prototype in 1 day

With OneDayBuild, we turn your idea into something tangible in one day for €1,150, so you can see whether further development is worth the investment. Decide to go ahead with the full build? Then we credit the full cost.

Explore OneDayBuild →

How a multi-tenant project works.

1

Architecture consultation

We map out how many tenants you expect, which compliance requirements apply, how sensitive the data is and how you wish to onboard tenants. At the end you receive a reasoned recommendation for shared schema, schema-per-tenant or database-per-tenant.

2

Scope and pilot tenant

We define a first workable scope: which core functionality must be in place, and which pilot tenant will go live first. We would rather give one tenant a platform that makes them genuinely productive than deliver a half-finished solution for ten.

3

Building in sprints

A working build every few weeks, with the onboarding, isolation and branding layers added step by step. We test early with several test tenants to rule out noisy-neighbour issues and data leakage before going live.

4

Rollout per tenant

A phased rollout — first the pilot, then a second and third tenant, then broadly. This keeps incidents small and lets your operations team learn along the way. Thereafter ongoing management, further development and adding new tenants become routine work.

The technology we build with.

We are not dogmatic about a single stack. The choice of framework, database and cloud platform depends on what your team already has experience with, which compliance requirements apply and what scale we anticipate. That said, we do have preferences — the combinations below have proven themselves in multi-tenant contexts.

For hosting we usually work with the three major providers (AWS, GCP, Azure), or with a Dutch provider such as TransIP or Hostnet where data residency requires it. For the wider infrastructure we align with cloud-native platform development.

  • BackendNode.js (NestJS, Express), Python (Django, FastAPI), .NET or Java — depending on your team. For multi-tenancy we build tenant context in as a first-class concept via middleware.
  • DatabasePostgreSQL (with row-level security for shared schema, or native schema isolation), MySQL or MongoDB for specific use cases. Per-tenant encryption keys via AWS KMS or Azure Key Vault.
  • FrontendReact, Vue or Svelte — with a theming layer that adapts CSS variables, logo and email templates per tenant without redeployment.
  • Authentication and identityAuth0, Keycloak, Cognito or a bespoke identity server. Per-tenant SSO (Azure AD, Google Workspace, Okta) alongside custom accounts, if required.
  • ObservabilityOpenTelemetry, Grafana, Datadog or Sentry — always with a tenant label on metrics, traces and errors so that filtering by tenant is possible by default.
  • Feature flag layerLaunchDarkly, Unleash or a lightweight in-house solution in the database. For B2B SaaS, a bespoke solution is often preferred so that features can be switched on or off per pricing tier and per individual tenant.
  • Billing integrationStripe, Mollie or a bespoke billing layer, linked to the tenant and to the feature tier. See also the subscription management platform.
  • CI/CD and deploymentsGitHub Actions or GitLab CI, with canary releases per tenant, automatic rollback when error rates rise, and zero-downtime database migrations.

Frequently asked questions.

What clients want to know before we start building a multi-tenant platform.

Which architecture should we choose: shared, schema-per-tenant or database-per-tenant?
That depends on three things: how many tenants you expect (ten or thousands), how sensitive the data is (standard B2B or medical/financial data), and how strict the compliance requirements are (GDPR alone, or also NEN 7510 / DNB supervision). For classic SaaS with many small tenants, we almost always choose a shared schema. For banks, insurers and healthcare, we tend to recommend database-per-tenant. Schema-per-tenant is the pragmatic middle ground for a few dozen to a few hundred business tenants.
How do you guarantee data isolation between tenants?
On several layers at once. At database level, through row-level security or physical separation, depending on the chosen architecture. At application level, through query middleware that automatically scopes every database operation to the tenant. And during code review, via an internal checklist: every new query and every new API route must demonstrably be tenant-aware. We close off the engagement with a targeted security test focused precisely on this point.
How do you deal with the noisy neighbour problem?
Through rate limits, query quotas and, where necessary, dedicated background workers per tenant or per tenant tier. For heavy tenants we can isolate job queues or provide a dedicated database replica. From day one we build tenant-aware monitoring, so we can see early when a single tenant is consuming a disproportionate share of resources and intervene in a targeted way before other tenants are affected.
What is the difference with a multi-tenant building?
Nothing, apart from the word "tenant". A multi-tenant building is a property term for a premises with several occupants. Multi-tenant software refers to a single application instance serving multiple customers. If you are looking for facilities management or building management, Appfront does not build solutions for that field, but we do build the software layer behind it, such as tenant portals and service platforms.
What determines the cost of a multi-tenant platform?
The chosen architecture is an important factor: database-per-tenant carries higher hosting and maintenance costs than a shared schema. Beyond that, the scope (which modules), the number of integrations, the compliance requirements (DPIA, penetration test, audit process) and the expected number of tenants all shape the total. We work in fixed sprints with budget certainty, not open-ended hourly billing, and we start with a pilot tenant so you can see what works before committing further.
When is multi-tenant overkill?
If you have two or three clients who each need a fundamentally different product, multi-tenant is rarely the right choice. You would effectively be building three products in one codebase, and all the complexity (feature flags, branding, isolation) would deliver little value. Multi-tenant only pays off with a larger number of tenants or a clearly shared product. You will get honest advice in the first conversation; sometimes a bespoke platform is smarter than a multi-tenant one.
Do you work together with our internal IT department?
Almost always. We carry out knowledge transfer in the final sprint, deliver architecture documentation and an operations runbook, and agree clear responsibilities for maintenance. For the operations layer you can choose ongoing maintenance with us, handover to your own team, or a combination in which we handle further development and your team handles day-to-day operations. See also our page on enterprise software for the broader context.

Talk to us about your multi-tenant platform.

A free, no-obligation half-hour introductory call. We listen to what you want to build, dig into the architectural trade-offs that matter, and give you direction you can act on, even if that means advising against building multi-tenant.

Edit content