Self-Hosted Alternatives to Supabase

Why Replace Supabase?

Supabase’s free tier pauses your database after one week of inactivity. The Pro plan costs $25/month per project. If you run 3 projects, that’s $75/month before any usage charges. Exceed the included 8 GB database space, 250 MB file storage, or 50,000 monthly active users, and per-unit charges add up fast.

Supabase is itself built on open-source tools — PostgreSQL, PostgREST, GoTrue, Kong — which means you can run the same stack on your own server. But Supabase’s self-hosted option is complex (10+ containers, limited documentation, no Studio dashboard support until recently). Simpler alternatives exist that cover the same use cases with fewer moving parts.

Factor	Supabase Pro	Supabase Self-Hosted	PocketBase	Appwrite
Monthly cost	$25/project	$0 + server	$0 + server	$0 + server
3 projects/year	$900	~$120 (VPS)	~$60 (VPS)	~$120 (VPS)
Database	PostgreSQL	PostgreSQL	SQLite	MariaDB
Auth	GoTrue	GoTrue	Built-in	Built-in
Storage	S3-backed	S3-backed	Local filesystem	Local/S3
Real-time	PostgreSQL CDC	PostgreSQL CDC	SSE	WebSocket
Serverless functions	Deno Edge Functions	Limited	Go hooks	Multi-language
Deployment complexity	Managed	High (10+ containers)	Minimal (1 binary)	Medium (15+ containers)

Best Alternatives

PocketBase — Best Lightweight Replacement

PocketBase replaces Supabase’s core features — auth, database, real-time subscriptions, file storage — with a single Go binary. No PostgreSQL, no PostgREST, no separate auth service. One file, one process, 50 MB RAM. It uses SQLite instead of PostgreSQL, which means simpler backups (copy one file) but less raw query power for complex analytical queries.

PocketBase’s admin dashboard is clean and functional. Define collections (tables), set up field types, configure auth providers (Google, GitHub, Apple, OIDC), and manage files — all from the browser. The JavaScript and Dart SDKs provide real-time subscriptions via Server-Sent Events.

If you chose Supabase because PostgreSQL + real-time + auth “just works,” PocketBase provides the same developer experience with dramatically less infrastructure.

[Read our full guide: How to Self-Host PocketBase]

Appwrite — Best Feature-Complete Replacement

Appwrite matches more of Supabase’s feature surface: authentication with 30+ OAuth providers, document databases, file storage with image transformations, serverless functions in 10+ languages, real-time subscriptions, and a messaging service. The admin console is more polished than Supabase’s self-hosted Studio.

The trade-off is deployment size — Appwrite runs 15-20 containers versus Supabase’s 10+ containers. Both are heavy deployments, but Appwrite’s documentation for self-hosting is more complete and the setup is more battle-tested.

[Read our full guide: How to Self-Host Appwrite]

Supabase Self-Hosted — If You Need PostgreSQL Specifically

If your application relies on PostgreSQL features (PostGIS, pg_vector, advanced SQL, existing PostgreSQL extensions), running Supabase’s own open-source stack may be the best fit. Clone the supabase/supabase Docker setup, configure the .env, and bring up the stack. You get the exact same PostgREST API, GoTrue auth, and (recently) the Studio dashboard.

The challenge: Supabase’s self-hosted documentation is sparse compared to Appwrite or PocketBase. Edge Functions have limited self-hosted support. And managing 10+ containers (PostgreSQL, PostgREST, GoTrue, Kong, Realtime, Storage, Studio, Meta, etc.) adds operational overhead.

Migration Guide

From Supabase Cloud to PocketBase

1. Export your PostgreSQL database using Supabase’s dashboard or pg_dump
2. Transform your schema — Supabase tables map to PocketBase collections. Standard columns (text, number, boolean, date) transfer directly. PostgreSQL-specific types (JSONB, arrays, enums) need conversion.
3. Export auth users — Supabase stores users in auth.users. Export and import into PocketBase’s user collection. Users will need to reset passwords.
4. Download storage files — export from Supabase Storage and upload to PocketBase’s file storage
5. Rewrite queries — Supabase client uses PostgREST syntax (.from('table').select('*')); PocketBase SDK uses a similar but different syntax (.collection('table').getList())
6. Update real-time subscriptions — Supabase uses PostgreSQL CDC; PocketBase uses SSE. The subscription API is similar but the transport differs.

From Supabase Cloud to Appwrite

1. Export PostgreSQL — same as above
2. Import into Appwrite — create databases and collections in Appwrite’s console, import data via the API
3. Migrate auth — export Supabase users, create them in Appwrite via the Server SDK
4. Migrate storage — download files from Supabase Storage, upload to Appwrite Storage
5. Rewrite functions — Supabase Edge Functions (Deno) need conversion to Appwrite Functions (Node.js/Python/etc.)

Cost Comparison

	Supabase Pro (3 projects)	PocketBase	Appwrite
Annual cost	$900	~$60 (VPS)	~$120 (VPS)
3-year cost	$2,700	~$180	~$360
Database size limit	8 GB (then $0.125/GB)	Disk capacity	Disk capacity
Storage limit	100 GB (then $0.021/GB)	Disk capacity	Disk capacity
Bandwidth limit	250 GB (then $0.09/GB)	VPS bandwidth	VPS bandwidth
MAU limit	50,000 (then $0.00325/MAU)	Unlimited	Unlimited

What You Give Up

• PostgreSQL ecosystem — PocketBase uses SQLite (no PostGIS, pg_vector, or PostgreSQL extensions). Appwrite uses MariaDB. If you need PostgreSQL specifically, use self-hosted Supabase.
• Edge Functions — Supabase’s Deno-based edge functions run globally on Deno Deploy. Self-hosted alternatives run functions on your single server.
• Supabase CLI and local development — tight integration between local dev and cloud deployment. Self-hosted platforms have their own CLIs but less polish.
• Managed backups — Supabase Pro includes daily backups with point-in-time recovery. Self-hosted requires configuring your own backup strategy.
• Database branching — Supabase’s preview branches create database copies per Git branch. No self-hosted equivalent.
• Global CDN — Supabase serves assets through a CDN. Self-hosted storage serves from your server.
• Supabase Studio — the web dashboard is polished and deeply integrated. Appwrite’s console is comparable; PocketBase’s is simpler.

Frequently Asked Questions

Can PocketBase handle production traffic or is it just for prototyping?

PocketBase handles moderate production traffic well. SQLite with WAL mode supports hundreds of concurrent reads. The single-binary architecture actually improves reliability — fewer moving parts means fewer failure points. For apps under ~10,000 daily active users, PocketBase performs comparably to Supabase. Beyond that, SQLite’s single-writer limitation becomes the bottleneck, and you’d want Appwrite or self-hosted Supabase.

How do I handle real-time subscriptions without Supabase’s CDC?

PocketBase uses Server-Sent Events (SSE) for real-time updates. Subscribe to collection changes with pb.collection('posts').subscribe('*', callback). Appwrite uses WebSockets. Both deliver real-time events within milliseconds. The main difference from Supabase CDC: you subscribe per-collection rather than per-table-row, and there’s no database-level change capture — the application layer emits events.

Can I use PostgreSQL extensions like pg_vector with self-hosted alternatives?

Only with self-hosted Supabase, which runs actual PostgreSQL. PocketBase uses SQLite (no extensions), and Appwrite uses MariaDB. If your app relies on PostGIS, pg_vector, full-text search with tsvector, or other PostgreSQL-specific features, self-hosted Supabase is your only option among these three. For vector search specifically, consider pairing PocketBase with a dedicated vector database like Qdrant.

What’s the backup strategy for each alternative?

PocketBase: copy the single pb_data directory (SQLite + uploaded files). A cron job with sqlite3 .backup creates a consistent snapshot. Appwrite: use docker exec appwrite backup or back up the Docker volumes. Self-hosted Supabase: standard pg_dump for the database plus S3-compatible storage backup. PocketBase’s backup simplicity is its strongest operational advantage.

How do I migrate authentication users from Supabase?

Export users from Supabase’s auth.users table via pg_dump or the Management API. For PocketBase, create users via the Admin API — passwords need resetting since Supabase uses bcrypt with specific salt rounds. For Appwrite, use the Server SDK’s users.create() endpoint. OAuth connections (Google, GitHub) need re-linking in all cases since tokens aren’t transferable.

Is Appwrite’s 15+ container deployment manageable for small teams?

Appwrite’s Docker setup is a single docker compose up -d command — the container count is high but the management complexity is low. Automatic updates, health checks, and inter-container networking are handled by the Compose file. Resource usage is ~2-3 GB RAM total. For teams comfortable with Docker, the operational burden is comparable to running any multi-service application.

Can I run serverless functions without Supabase Edge Functions?

Appwrite supports serverless functions in Node.js, Python, PHP, Ruby, Dart, and more — executed on your server, not at the edge. PocketBase supports Go-based hooks that run inside the binary. For edge-like distribution, pair your self-hosted backend with Cloudflare Workers or Deno Deploy for the function layer while keeping data on your server.

Related

• PocketBase vs Supabase Comparison
• PocketBase vs Appwrite Comparison
• How to Self-Host PocketBase
• How to Self-Host Appwrite
• Self-Hosted Alternatives to Firebase
• Best Self-Hosted Low-Code Platforms