Supabase combines PostgreSQL, authentication, file storage, generated APIs, functions and realtime services. Choosing an alternative in Europe starts with deciding how much of that integration you want to keep. Moving only the database is a different project from replacing the application platform.
This guide compares five routes: self-hosted Supabase, Appwrite, Nhost, PocketBase and a deliberately assembled PostgreSQL-based stack. It then gives a dependency-aware migration plan. DanubeData is our own service. Infrastructure location, contractual responsibilities and the application security model all need review; no provider choice makes every workload automatically GDPR compliant.
Reviewed 2 November 2026. A synthetic PostgreSQL archive/RLS fixture was run in isolated local containers. No hosted Supabase export, full self-hosted Supabase restore, Auth migration, Storage transfer or production cutover was run for this article.
What Supabase actually gives you
- PostgreSQL: your schema and data, plus selected extensions and platform-managed schemas.
- Generated APIs: PostgREST and other API components expose configured data with roles and row policies.
- Auth: identities, sessions, password and OAuth flows, signing configuration, email delivery and redirect settings.
- Storage: object bytes plus bucket/object metadata, access policies and a service API.
- Edge Functions: deployed function code, runtime assumptions, configuration and secrets.
- Realtime: authorized subscriptions, channels, presence and change-delivery behavior.
- Management: console, deployment, backup and operational services around those components.
The integration is the product. A JWT that works at one service must produce the intended authorization at the next. A database archive alone does not reconstruct that relationship. Supabase's self-hosting documentation also distinguishes a production deployment from the local CLI development stack and lists managed-platform features that are not part of self-hosting.
Why European teams evaluate alternatives
Supplier and processing requirements
Document the contracting entity, selected region, backups, subprocessors, support access and data transfers. Evaluate those alongside your own application, authentication and retention controls. The original article overstated EU hosting as a universal legal solution. A region label is useful evidence, not a compliance conclusion.
Total cost and responsibility
Compare an actual workload and support requirement using current Supabase pricing and the alternative's current plans. Include database capacity, object storage, transfer, identity/email, functions, backups, replicas, monitoring and staff time. The old €30–€50 versus $599 claim did not compare equivalent managed service scope and has been removed.
Control over the application architecture
Some teams want ordinary SQL access and their own API; others value the integrated SDK more than component control. Both are reasonable. Inventory the Supabase APIs in use before assuming that open-source components imply a no-rewrite migration.
The five realistic alternatives
Option 1: Self-host Supabase in your chosen European region
This keeps the closest application API surface. Start with the official production Docker deployment, pin component versions, and follow the platform-to-self-hosted restore procedure for those versions. Operate authentication, gateway, database, Storage, Realtime, functions, secrets, TLS and monitoring together.
Best fit: a team that needs Supabase APIs and can own production upgrades and recovery. The trade-off is operational responsibility; a single VPS is not automatically redundant, and a development CLI stack must not be exposed as a production service. Size from measured load and recovery requirements rather than a universal memory or user-count threshold.
Option 2: Appwrite
Appwrite provides an application backend with authentication, data, storage, functions and realtime capabilities. It has its own API and permission model. Treat it as an application migration: map data types, relationships, identities, file references and SDK calls. PostgreSQL policies cannot simply be copied into another platform's rules.
Best fit: a project that actively wants Appwrite's development model and is prepared to port integration code. Check current self-hosting guidance, deployment requirements and selected hosting location directly.
Option 3: Nhost
Nhost combines PostgreSQL with a GraphQL-oriented backend and related authentication/storage services. Evaluate it when GraphQL is a deliberate choice. Authorization expressed in API-layer permissions must be tested separately from database row security, even when both systems use PostgreSQL underneath.
Best fit: a team that prefers the Nhost/GraphQL workflow and can validate the new API contract. Verify current deployment regions, subprocessors, recovery scope and pricing rather than relying on the old article's company/region summary.
Option 4: PocketBase
PocketBase combines a database-backed API, authentication, file handling and realtime features in a compact application. Its SQLite-based data and access model are different from Supabase's PostgreSQL model. A simple deployment can suit some projects, but user count alone does not establish capacity or suitability.
Best fit: a smaller application whose team accepts its documented maturity, update and compatibility constraints. Test your actual concurrency and backup/restore requirements. Port SQL, migrations and row policies rather than assuming a dump import.
Option 5: Compose a stack on DanubeData
Use Managed PostgreSQL for the database, S3-compatible Object Storage for files, and your own API/authentication layer on a VPS or container service. This is a set of infrastructure components, not a managed Supabase-compatible service.
Best fit: an application that already owns its backend or intentionally wants to replace Supabase APIs. You own identity integration, authorization, signing, storage metadata and function/realtime behavior. Confirm current product capacity, supported extensions and recovery configuration; the historical combined-stack prices and throughput claims were not reliable.
Comparison by migration surface
| Route | What can remain familiar | What needs deliberate work |
|---|---|---|
| Self-hosted Supabase | Many application API patterns | Version compatibility, service configuration, keys, object bytes, upgrades and recovery |
| Appwrite | Integrated backend concept | Data model, API calls, identities and permission rules |
| Nhost | PostgreSQL underneath | GraphQL/API permissions, auth/storage contracts and deployment |
| PocketBase | Compact backend experience | Database conversion, SDK/API, rules and operational limits |
| Own PostgreSQL/API stack | Selected SQL schema/data and business logic | Everything Supabase previously integrated above the database |
Building a PostgreSQL-based backend responsibly
Choose the authorization boundary first
If you use PostgREST, configure the exposed schemas, connection role, anonymous role, JWT verification and role mapping using its current documentation. If you use an application API, validate identity there and enforce ownership consistently. Neither route should place a database owner credential in a browser.
Authentik or Keycloak can provide identity, but neither is a drop-in copy of Supabase Auth. Validate issuer, audience, signing algorithms, key rotation, subject identity mapping and expiry. Accepting a caller-controlled claim without validating its signature would let the caller choose its own authority. Do not hand privileged role selection to a user-editable claim.
Preserve RLS with its dependencies
Policies may reference auth.uid(), other functions, schemas, roles, memberships and grants. A helper function with the same name is not sufficient evidence that behavior is equivalent. The gateway must validate the token and set the right trusted session context; the application database role must not accidentally own the table or bypass row security.
The PostgreSQL row-security manual explains the owner/superuser bypass and the distinction between row filtering and write checks. Test reads and every write operation using the actual application roles and two independent identities. Add negative tests for absent, expired and malformed credentials at the API layer.
Treat file storage as an API and data migration
S3-compatible object storage does not implement Supabase Storage's authorization and metadata API. You need a mapping from old bucket/object paths to new keys, an authenticated server that authorizes each operation, and a transfer process that preserves content and required metadata. Sign short-lived URLs only after authorization. Keep S3 credentials on the server; CORS is not access control.
For a custom API, the private S3/presigned upload guide is a practical example of the storage boundary. It does not make the Supabase Storage SDK compatible with a generic S3 endpoint.
Plan functions and realtime separately
Inventory every function's runtime, authentication behavior, environment variables, webhook signatures, cron schedule and network dependency. A container can run application code, but deployment names and an HTTP endpoint alone do not preserve Edge Function behavior. Check request/response shapes, streaming and timeout assumptions.
For realtime, preserve authorization, reconnect, ordering, presence and missed-event semantics required by the application. LISTEN/NOTIFY plus SSE can be useful for a custom design, but it is not a universal replacement for Supabase channels. A durable event requirement needs durable storage and replay behavior, not just a live connection.
Migrating from Supabase: choose one of two paths
Path A: Keep the Supabase service stack
Follow Supabase's platform-to-self-hosted restore guide with a new compatible Supabase deployment. Its database workflow exports roles, schema and data separately, then requires additional service configuration. Rehearse on an isolated instance before scheduling any final move. Review the exact CLI and component versions, extension support and source/destination schema differences.
# Reference export shape from Supabase's CLI guide.
# SUPABASE_SOURCE_URL is the approved direct or session connection.
# Supply it using your protected local credential workflow; do not paste it into logs.
umask 077
supabase --version
supabase db dump --db-url "$SUPABASE_SOURCE_URL" --role-only -f roles.sql
supabase db dump --db-url "$SUPABASE_SOURCE_URL" -f schema.sql
supabase db dump --db-url "$SUPABASE_SOURCE_URL" --data-only --use-copy -f data.sql
Check the current CLI backup procedure for version-specific exclusions and connection requirements. Prefer direct access; the documented session pooler is an option when direct IPv6 access is unavailable. Do not use a transaction-pooler endpoint for a migration by assumption. The CLI requires its documented container tooling, and a source export is not a full service backup.
Correction: the previous article used --data-only --schema=public and then claimed RLS policies moved with it. Data-only exports do not create table definitions, functions, roles or policies. A public-only export can also miss dependencies in auth, storage or another application schema. Keep schema and role exports and inspect their coverage.
Restore according to the selected Supabase version's official instructions, with stop-on-error behavior. Do not copy a privileged session_replication_role workaround into a plain managed PostgreSQL service; it changes trigger behavior and may be unsupported. A partial restore with ignored errors is a failed rehearsal.
Path B: Replace Supabase with ordinary PostgreSQL and your own services
There is no universal one-command import. Select the application schemas you need, identify every referenced function/type/schema, and remove or deliberately replace platform dependencies in a reviewed migration. Rebuild login roles and least-privilege grants for the new service. Preserve the intended authorization semantics, not just policy names.
Test the new application API before moving production data. In particular, port supabase.auth, storage, functions and channel calls or retain compatible services. Changing only the base URL and anonymous key is not a complete migration to managed PostgreSQL plus S3.
Auth, Storage and service checks that a SQL restore cannot prove
- Auth: validate the supported user export/import route, password-hash compatibility, sessions and signing keys. Test new login, existing-user login, password reset, email confirmation, OAuth callbacks and logout. Plan whether existing sessions must be invalidated. Secrets and API-key configuration do not simply travel in
auth.users. - Storage: copy actual object bytes separately using a supported export route. Use copy to an empty destination, compare counts, sizes and content hashes, and test public/private access, signed URLs and upload authorization. A database backup's storage metadata is not the file content. Avoid an unreviewed destructive sync.
- Functions: redeploy versioned code and configuration through the new platform's documented mechanism. Test signatures, secrets and execution outcomes.
- Realtime: test subscription authorization and two different users, reconnect behavior and the business events that matter.
- Operational settings: restore SMTP, domains, provider callbacks, environment configuration, schedules and monitoring separately. Document backups and recovery for every component.
Download the RLS and archive validation fixture
Download the local PostgreSQL/RLS rehearsal. Run python3 lab.py with Docker and Python 3. The script uses two disposable PostgreSQL 18 containers, no host ports and no real credentials. It restores a synthetic schema/data archive containing an extension, identity sequence and tenant policy.
The recorded run verifies that missing target roles fail, an ordered row digest matches, the extension and policy exist, Alice sees two rows and Bob one, a cross-tenant insert is rejected, and the identity sequence continues. This validates ordinary PostgreSQL archive and RLS behavior. It deliberately does not claim to test Supabase Auth JWTs, auth.uid(), Storage, Edge Functions, Realtime or a hosted project. Add the corresponding application tests before a real migration.
Cutover and rollback
- Finish a full isolated restore rehearsal and every application/service check above. Record duration and remaining failures.
- Stop all writers, including workers, functions, schedules, external webhooks and direct uploads. Coordinate the database snapshot and final object copy so the selected recovery point is coherent.
- Take the final export, restore the destination, reconcile exact data totals and object hashes, and verify access for independent users.
- Update client endpoints, trusted domains, OAuth callbacks and secrets; restart long-lived processes. Run read-only checks before opening destination writes.
- Release one write authority. Monitor real login, upload, function and realtime journeys with an explicit rollback owner.
Before destination writes, you can abort and return to the unchanged source. After destination writes, the source is stale. Freeze again and reconcile or reverse-migrate changed data and objects before returning. A week of uncoordinated dual writes is not a safe generic migration strategy. Keep source exports and service configuration until the destination's independent restore has passed.
When Supabase is still the right answer
Stay when the integrated services are valuable, your supplier review is satisfied and the cost fits. A managed platform can save substantial engineering work. Choosing a custom stack solely for a low VM price can transfer that work to a small team without reducing total cost.
Frequently asked questions
Can I keep supabase-js?
Potentially with a compatible self-hosted Supabase stack, after checking component versions, keys, endpoints and all APIs used. Plain PostgreSQL, PostgREST alone or an S3 bucket does not provide the entire SDK contract.
Do row policies move with a database dump?
A schema-inclusive export can contain policies. Their functions, roles, grants, schema dependencies and trusted identity context must also exist. A data-only export cannot create them. Test negative authorization with real application identities.
Will existing users keep their passwords and sessions?
That depends on the supported Auth migration route, compatible hash formats, schema versions and signing/session configuration. Preserve no session assumption without testing it. Plan re-authentication or a safe reset flow when needed.
Can I replace Realtime with an SSE endpoint?
Only if the application's required behavior is satisfied and the client is ported. Presence, broadcasts, authorization and durable missed-event handling are separate requirements. No connection-count promise is made here.
Does a European deployment guarantee GDPR compliance?
No. Review the whole processing arrangement, contracts, access and controls. The same applies to your self-hosted identity, mail, monitoring and backup providers.
What about extensions and recovery?
Confirm the exact PostgreSQL and extension versions, required privileges and recovery scope with the destination. A snapshot, a logical dump and point-in-time recovery have different properties. Prove the complete application can be recovered.
Plan a reversible migration
Start with a dependency inventory and a local rehearsal. If you intentionally want infrastructure components, use the PostgreSQL and Storage product pages for current scope and pricing. The PostgreSQL cutover checklist and encrypted backup/restore guide explain the underlying data boundary. A successful SQL restore is the start of verification, not the end of a Supabase migration.