# Best multi-tenant backend, sorted by who maintains the isolation policy

> Multi-tenant backend options compared by who keeps tenant isolation correct after launch - a row-level security policy you write, or a workspace model that ships it.

- Source: https://www.buildbase.app/compare/best-multi-tenant-backend
- Section: Comparisons
- Author: Dharmendra Jagodana
- Published: 2026-09-05
- Updated: 2026-11-09

## In short

Multi-tenant backend comparisons usually stop at shared schema versus database-per-tenant. The real cost is who maintains the isolation policy: Supabase hands you row-level security and the ongoing upkeep, while BuildBase's workspace module ships tenant isolation as a feature you don't write.

Every multi-tenant backend comparison turns into the same argument: row-level security in a shared schema, or a separate database per tenant. That's a real decision, and [shared schema versus database-per-tenant](/blog/database-per-tenant-vs-shared-schema) already works through it in detail. What it skips is the question that actually costs you time after launch - once you've picked a model, who keeps the isolation policy correct as you add tables, ship features, and onboard tenant number two hundred?

## The one-paragraph answer

If you want tenancy enforced by a database you already know, and you're fine writing, testing and re-verifying a row-level security policy for every table you add, Supabase or a self-managed Postgres instance is the honest pick - especially if raw SQL and extensions like pgvector matter to you. If you'd rather isolation ship as a feature you don't maintain, with per-workspace quotas and billing built in and no policy of your own to get wrong, BuildBase's workspaces module is built for exactly that trade, at the cost of never touching the database directly. Appwrite sits in between: its Teams primitive gets you a tenant boundary without hand-rolled RLS, but you're still running or paying for the surrounding infrastructure yourself, and there is no billing or per-tenant subscription layer in it.

## Row-level security is a primitive, not a finished layer

Ask anyone who has shipped multi-tenant SaaS on Supabase what breaks first, and the answer is usually a query that forgot the tenant filter. RLS pushes authorization into Postgres itself: you write a policy and Postgres appends it to every query as an implicit `WHERE` clause.

Two states get confused here, and the difference decides how bad a mistake is. Turn RLS **on** and write no policy, and the table is closed: "no data is accessible through the API when using a publishable key, until you create policies." That is the safe failure. The dangerous one is a table where RLS was never enabled at all, sitting in a schema the API exposes. Supabase's own wording: such a table is "readable and writable by any role with a grant on it." And on an existing project, "a new table in `public` starts with every privilege already granted to all three roles" - `anon`, `authenticated` and `service_role`. So the grant is usually already there. Not just your authenticated users, and not just reads.

There is a subtler version that survives even a correct policy. Grants and policies are separate mechanisms, and a table "protected only by policies still hands `anon` an insert path if you never revoke the grant." Writing the policy is the famous half of the job. Revoking the grant is the half people skip.

Supabase has closed most of this gap, and the honest version of the argument has to say so. Create a table through the dashboard and the Table Editor enables RLS for you. Miss one anyway and Security Advisor raises `0013_rls_disabled_in_public` at ERROR level, in plain language: "Anyone with your project URL can read, edit, and delete all data in this table because Row-Level Security is not enabled." It surfaces in Studio, in `supabase db advisors`, through the Management API and over MCP. An earlier version of this post said the database won't warn you. It does now.

What is left is narrower again, and this part is our reading rather than anything Supabase states. The advisor is a report you have to go and read, not a build that fails. The Table Editor's default covers tables created in the dashboard, which used to leave anything created by a migration or a raw `CREATE TABLE` out in the open. Supabase now documents an event trigger that turns RLS on for every new table however it was made, with a one-click setup in the dashboard. So that gap closes, if you know to switch it on. The un-revoked grant is the one still sitting outside: lint `0013` only looks at whether RLS is off, and on that table it is on, so the table reports clean. Two newer lints, `0026` and `0027`, catch the part of it where pg_graphql exposes a table to `anon` or `authenticated`, which is the read side. We found nothing covering the insert path.

So the maintenance job survives, just smaller than it was: someone owns writing a policy for every new table, testing it as two different tenants, revoking the grants policies don't cover, and reading the advisor often enough for it to count. That doesn't go away. It moves from a backend module to your own team's checklist.

> **Key takeaway:** Row-level security is enforcement Postgres runs once you've written the
> policy. Supabase now flags the table you forgot - at ERROR level, in Studio
> and on the CLI - so the old "silent by default" story is out of date. What
> that lint does not look at, as far as we can tell, is a table whose policy
> looks right and whose grants were never revoked. Two newer lints reach part of
> that case, on the read side only.

## Where each one fits

**Supabase - Postgres, plus the responsibility.** Supabase pairs a managed Postgres database with auth, storage and edge functions, and RLS is the standard way to isolate tenants inside it. You get direct SQL, the full range of Postgres extensions, and a free tier to build against before you pay anything. What you don't get is a tenancy primitive - "tenant" is a column and a policy you design yourself, and whether that boundary is the user or the organization is a decision Supabase leaves entirely to you.

**Appwrite - Teams, which Appwrite now documents as the tenant boundary.** Appwrite's Teams feature gets you a tenant boundary without writing RLS-equivalent policies by hand: a team per tenant, roles on the membership, and `Role.team(<TEAM_ID>)` to grant every member access to a resource. Reading Teams as a multi-tenancy layer used to be our inference rather than their framing, and this post said so. It isn't ours any more. Appwrite ships a "Multi-tenancy with Teams" guide that opens by telling you to create a team per tenant, and the Teams page links straight to it. There is a second, partner-facing guide that answers the same question with one Appwrite project per tenant instead, so you now get two vendor answers where there were none.

Appwrite is BSD 3-Clause licensed, and self-hosting is documented as running "the same features found on Appwrite Cloud" - with the caveat they add themselves, that compliance features and dedicated support route to an enterprise conversation. What it doesn't ship is the billing half: no subscriptions, no per-tenant plans, no workspace-level quotas you can charge against. Its product surface is wider than data and auth, though. Functions, Messaging, Sites, Domains and a firewall are all in there.

**Self-managed Postgres - the same trade as Supabase, without the managed layer.** If you're running your own Postgres instance rather than Supabase's hosted one, the isolation story is identical: RLS policies you write and maintain. You also take on the database operations Supabase would otherwise run for you - backups, upgrades, connection pooling - which is exactly the ops load [database-per-tenant cost math](/blog/database-per-tenant-cost) puts a number on once you're managing more than a handful of instances.

**BuildBase - isolation as a module, not a policy.** The [workspaces module](/guides/multi-tenant-workspaces-in-an-afternoon) isolates data, feature flags, billing and members per workspace as a shipped feature: `bb.workspace.create()` gives you the boundary, and every read the SDK makes is already scoped to it. Per-plan workspace limits are published rather than architectural guesswork - 50 on Free, 1,000 on Launch, 25,000 on Grow, 100,000 on Scale - and role permissions run through the separate RBAC module at both the org and workspace level. AgentCenter, one of the six products built on BuildBase, runs its multi-project tenancy on this exact module rather than a hand-rolled RLS layer. The trade is real: there's no SQL console and no direct database connection. There is a free plan, at $0 with 10,000 monthly active users and 50 workspaces, and the paid plans open at $19 a month on Launch, each carrying a 7-day trial that doesn't ask for a card.

| Feature | BuildBase | Supabase |
| --- | --- | --- |
| Isolation model | Isolated per workspace, shipped as a feature | Shared Postgres tables, enforced by your own RLS policy |
| Tenant limits | 50 to 100,000 workspaces by plan, published | No tenant primitive - defined entirely by your schema |
| Database access | None - API and SDK only | Full Postgres, SQL, extensions like pgvector |
| Pricing | Free plan, then $19/mo (Launch) plus three metered quotas, published | Plan fee, plus hourly per-project compute, plus overages |
| Scope | 20 modules: auth, billing, RBAC, workflows, one instance | Database, auth, storage, functions - no billing layer |

> **Where Supabase wins:** **You can assert an RLS policy in CI. You cannot assert our isolation.** Because a policy is just SQL, it is testable: `supabase test new` scaffolds a pgTAP test, `supabase test db` runs it, and their docs ship a GitHub Actions workflow that runs it on pushes and pull requests targeting `main`. So you can write a test that authenticates as an owner, a non-member and an outsider, and fail the build the day someone widens the boundary. We have no equivalent. Our isolation is enforced inside the module, which means you cannot write an assertion against it that breaks your build - you are trusting our tests rather than running your own. If proving the isolation boundary is the thing you need, to an auditor or to yourself, that is a real argument for the policy you maintain.
>
> **Raw SQL and extensions.** Supabase wins both and it isn't close. Our workspace isolation is enforced partly by never exposing the database at all, so you can't query it directly, run your own migrations against it, or reach for an extension we don't support. That's the same decision that removes the policy-maintenance job.

## How to actually decide

Start with who is going to own the isolation policy once you ship. If that's a team that already knows Postgres and wants direct SQL access badly enough to write and maintain RLS policies as the schema grows, Supabase is the right tool and the free tier means you can try it before committing to anything. If nobody on the team wants that job, or you'd rather it not exist, a workspace model where isolation, quotas and billing already ship together removes it - at the cost of database access you'll never get back without migrating off.

Tenant count matters too. Under a few hundred tenants, either model works fine on its own merits. Past roughly 1,000 tenants, the constraint that decides it stops being which backend you picked and starts being the connection-pool ceiling both [what database-per-tenant actually costs](/blog/database-per-tenant-cost) and [buy vs build for SaaS infrastructure](/blog/buy-vs-build-saas-infrastructure) already put a number on.

If the actual gap is auth and workspace roles rather than the database layer itself, [Supabase alternatives](/compare/supabase-alternatives) covers Firebase, Appwrite, Nhost and PocketBase as direct database-first swaps, none of which add billing or tenancy roles either.

A note on sourcing, since roundups are where stale numbers sneak in. Every BuildBase figure above - workspace limits, plan prices, the trial terms - comes from `PLANS` and `PLAN_FACTS` in `packages/shared/src/constants/platform-stats.ts`, re-read 31 October 2026, and the workspaces module entry in `modules.ts`. The Supabase claims - the free tier and the plan-plus-compute pricing shape - came off supabase.com/pricing, and the RLS behavior with and without a policy, the Security Advisor lints, the event trigger and the pgTAP workflow off the Supabase row-level-security, database-linter, tables and local-testing docs. The Appwrite claims - Teams roles, the multi-tenancy guides, the absent billing layer and self-hosted parity - came off the Appwrite Teams, multi-tenancy, partner, billing and self-hosting docs, and the BSD 3-Clause licence off their repository. All verified 9 November 2026. Appwrite's pricing page renders again, after a spell when it would not, but nothing above rests on it. No competitor dollar figure appears above on purpose: neither vendor's price decides this comparison, and a number that nobody re-checks is exactly how a roundup goes stale.

Earlier passes corrected two things rather than just moving the date. The post used to say an unprotected table is open to any authenticated user, which conflated RLS-on-no-policy with RLS-never-enabled and understated the second case. And it used to say nothing warns you, which stopped being true when Security Advisor started flagging it at ERROR level.

This pass corrected three more, all of them in the competitors' favour. Appwrite now documents Teams as a multi-tenancy layer, so the line saying you would not find a vendor guide to follow is gone. Supabase now documents an event trigger that enables RLS on every new table whatever created it, which closes the migration gap this post used to leave open. And two newer lints reach part of the un-revoked grant case.

A fourth correction went the other way, against us. Our own pricing line said there was no free plan and put Launch at $49, when there is a Free plan and Launch is $19. Recording the corrections rather than quietly editing them is the point of carrying a verification date at all.
