⚡
SelfHostStackOpen-Source Directory

Why Migrate Away from Firebase & Supabase Cloud?

Firebase locks your core backend logic into Google Cloud infrastructure with proprietary NoSQL APIs (Firestore / Realtime Database). As your application scales, document reads and cold-start Cloud Functions create unpredictable monthly bills. Self-hosting an open-source BaaS gives you standard PostgreSQL under the hood, predictable fixed hardware pricing, zero read/write metering penalties, and full control over database indexing and raw SQL migrations.

Technical Architecture & Migration Analysis

Proprietary Firebase abstracts database operations behind proprietary gRPC and HTTP streaming endpoints, storing records in Google Cloud Spanner and Firestore NoSQL engines, then meters every read, write, Cloud Function cold-start, and storage egress separately. When self-hosting modern BaaS alternatives, your stack shifts to a standard relational or document architecture with predictable fixed-cost hardware. Supabase runs real PostgreSQL 15+ paired with PostgREST (for instant REST APIs), GoTrue (Go-based authentication), Realtime (Elixir-based WebSocket pub/sub for database changes), and Kong/Traefik as the API gateway. PocketBase consolidates everything into a single compiled Go binary running an embedded SQLite engine with WAL (Write-Ahead Logging), delivering single-digit millisecond query latency without cold starts. Appwrite uses Docker microservices with MariaDB/Postgres persistence, Redis caching, and OpenRuntimes for polyglot serverless execution (Node, Python, PHP, Ruby, Dart, Go). Nhost deploys Hasura GraphQL Engine fronting PostgreSQL 15+, with GoTrue auth, S3-compatible storage, and serverless Functions — replacing Firestore triggers with Hasura event triggers. Parse Server runs as a Node.js application persisting to MongoDB or PostgreSQL via the database adapter, with LiveQuery reading from the database oplog for real-time events. All five eliminate the per-read billing that drives Firebase bills unpredictably upward.

⚠️

When NOT to Migrate (When Staying on Firebase & Supabase Cloud Makes Sense)

Self-hosting is not universally the right move. Keep paying for SaaS if your team hits any of these constraints:

  • ▸You rely heavily on Google-managed zero-config mobile services like Firebase Dynamic Links, Firebase ML Kit, or integrated Google Play In-App Purchase server verification.
  • ▸Your engineering team has zero Linux sysadmin experience and no bandwidth to monitor PostgreSQL WAL archiving, disk space alerts, or automated offsite database backups.
  • ▸You have an unpredictable, hyper-bursty consumer mobile launch where traffic swings from zero to 500,000 concurrent requests in 5 minutes and you cannot afford 15 minutes to scale VPS nodes.

Real-World Cost Comparison: Firebase & Supabase Cloud vs Self-Hosted

Comparing vendor cloud billings against standard Hetzner / DigitalOcean infrastructure costs at scale.

Tier / ScaleFirebase & Supabase Cloud CostSelf-Hosted VPS CostEstimated Annual SavingsTechnical Breakdown
Early MVP / Side Project
5,000 MAU, 2M document reads/mo, 5GB storage
$0 - $25/month (Spark / Blaze Plan)€3.79/month (Hetzner CX22 2 vCPU, 4GB RAM)$250 - $300/yearPocketBase or lightweight Supabase handles this workload comfortably on a single 4GB VPS with < 10% CPU utilization.
Production SaaS App
75,000 MAU, 45M reads/writes, 80GB asset storage, auth & real-time
$450 - $1,100/month (Document read overages + Cloud Function invocations)€14.28/month (Hetzner CPX31 4 vCPU, 8GB RAM + Hetzner S3 €5/mo)$5,200 - $13,000/yearSelf-hosted Supabase with Postgres connection pooling (PgBouncer/Supavisor) processes all database transactions at zero per-read surcharge.
High-Volume Mobile & Web
500,000 MAU, 400M operations/mo, 1TB storage, heavy WebSockets
$3,200 - $8,500+/month (Firestore bandwidth + storage egress)€64.00/month (Dedicated Hetzner AX42 8-core AMD, 64GB DDR5 ECC + S3 storage)$37,000 - $100,000+/yearDedicated NVMe drives handle tens of thousands of raw Postgres transactions per second with sub-5ms response times.

Top 5 Recommended Open-Source Replacements

Tested, self-contained, and production-ready. Click any tool to inspect verified docker-compose configurations, hardware sizing, and deployment guides.

Supabase

Apache-2.0⭐ 110.8k+

The open-source Firebase alternative powered by real PostgreSQL, PostgREST, and Elixir Realtime.

Min RAM4 GB
Min CPU2 vCPU
GitHub Repo ↗

✅ Advantages

  • 100% standard PostgreSQL — zero proprietary database lock-in
  • Row Level Security (RLS) lets client apps query DB directly with full safety
  • Built-in pgvector extension turns Supabase into an AI embeddings database
  • Vibrant ecosystem and multi-language client libraries (JS, Python, Flutter, Swift)

⚠️ Trade-offs / Limitations

  • Multi-container docker compose stack requires at least 4GB RAM
  • Self-hosting lacks the managed Web UI one-click upgrades of the cloud platform
  • Edge Functions require Deno runtime setup on your host

Core Features

▸Full PostgreSQL database with pgvector, PostGIS, and custom extensions
▸Real-time WebSocket subscriptions on database row inserts, updates, and deletes
▸Built-in JWT authentication with Row Level Security (RLS) policies
▸S3-compatible file storage engine with image transformation hooks
▸Auto-generated TypeScript definitions matching your database schema

Architecture Notes

Runs standard PostgreSQL 15+, Kong API Gateway, PostgREST for instant auto-generated REST endpoints, GoTrue for JWT authentication, and Phoenix/Elixir WebSockets for real-time broadcasts.

Known Limitations

Heavy container footprint (~12 services); requires at least 4GB RAM to run comfortably with connection pooling.

Official Documentation ↗
📄 docker-compose.yml
Production Ready
version: '3.8'
services:
  studio:
    image: supabase/studio:latest
    restart: unless-stopped
    ports:
      - "3000:3000"
    environment:
      STUDIO_PG_META_URL: http://meta:8080
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:-SuperSecretPassword123}
      DEFAULT_ORGANIZATION_NAME: Default
      DEFAULT_PROJECT_NAME: Production
  kong:
    image: kong:2.8.1-alpine
    restart: unless-stopped
    ports:
      - "8000:8000"
      - "8443:8443"
    environment:
      KONG_DATABASE: "off"
      KONG_DECLARATIVE_CONFIG: /var/lib/kong/kong.yml
    volumes:
      - ./kong.yml:/var/lib/kong/kong.yml:ro
  auth:
    image: supabase/gotrue:v2.158.0
    restart: unless-stopped
    environment:
      GOTRUE_API_HOST: 0.0.0.0
      GOTRUE_API_PORT: 9999
      API_EXTERNAL_URL: ${API_EXTERNAL_URL:-http://localhost:8000}
      GOTRUE_DB_DRIVER: postgres
      GOTRUE_DB_DATABASE_URL: postgres://supabase_auth_admin:${POSTGRES_PASSWORD}@db:5432/postgres
      GOTRUE_SITE_URL: ${SITE_URL:-http://localhost:3000}
      GOTRUE_JWT_SECRET: ${JWT_SECRET:-super-secret-jwt-token-at-least-32-chars}
  rest:
    image: postgrest/postgrest:v12.0.2
    restart: unless-stopped
    environment:
      PGRST_DB_URI: postgres://authenticator:${POSTGRES_PASSWORD}@db:5432/postgres
      PGRST_DB_SCHEMAS: public,storage
      PGRST_DB_ANON_ROLE: anon
      PGRST_JWT_SECRET: ${JWT_SECRET:-super-secret-jwt-token-at-least-32-chars}
  db:
    image: supabase/postgres:15.1.1.78
    restart: unless-stopped
    ports:
      - "5432:5432"
    environment:
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:-SuperSecretPassword123}
    volumes:
      - db-data:/var/lib/postgresql/data
volumes:
  db-data:

🚀 5-Minute Deployment Guide

  1. 1Provision a VPS with at least 4GB RAM and 2 vCPUs (e.g. Hetzner CX22 or DigitalOcean Droplet).
  2. 2Install Docker and Docker Compose plugin: `curl -fsSL https://get.docker.com | sh`.
  3. 3Clone the official self-hosting template: `git clone --depth 1 https://github.com/supabase/supabase`.
  4. 4Navigate to `cd supabase/docker` and copy the environment template: `cp .env.example .env`.
  5. 5Generate secure JWT secrets and strong database passwords with `openssl rand -hex 32`.
  6. 6Launch all backend microservices: `docker compose up -d`.
  7. 7Expose port 8000 (Kong Gateway) and port 3000 (Studio) behind Caddy or Nginx with Let's Encrypt SSL.

Recommended Cloud VPS for Supabase

Compare all VPS hosts →
Hetzner Cloud€3.79/mo

CX22 (2 vCPU, 4GB RAM, 40GB NVMe)

Best value for running the full Supabase Docker stack.

Deploy on Hetzner →
DigitalOcean$24.00/mo

Regular Droplet (2 vCPU, 4GB RAM, 80GB SSD)

Includes $200 in free trial credits for new accounts.

Claim $200 DO Credit →
Vultr$20.00/mo

High Performance (2 vCPU, 4GB RAM, 64GB NVMe)

Worldwide deployment with low-latency NVMe drives.

Deploy on Vultr →

PocketBase

MIT⭐ 61.2k+

Single-binary open-source backend with embedded SQLite, real-time subscriptions, and admin dashboard.

Min RAM256 MB
Min CPU1 vCPU
GitHub Repo ↗

✅ Advantages

  • Tiny footprint: runs on a 512MB RAM / $3.50/mo server effortlessly
  • Zero microservice complexity: single binary file, no external DB daemon needed
  • Instant deployment with single command and automatic SQLite schema management
  • Built-in file storage with automatic image thumbnail creation

⚠️ Trade-offs / Limitations

  • Single-node vertical scaling (SQLite WAL model)
  • No native SQL query editor in the UI (uses collection filter syntax)

Core Features

▸Instant REST and Server-Sent Events (SSE) realtime API
▸Embedded SQLite with WAL mode handling thousands of concurrent read requests
▸Built-in JWT auth, OAuth2 providers, and fine-grained collection access rules
▸Clean web-based administrative dashboard with zero setup
▸Extensible as a Go framework or via JavaScript hooks

Architecture Notes

Written in pure Go. Embeds SQLite directly with WAL mode enabled. Everything (DB, Auth, File Storage, Admin UI, REST & SSE API) runs inside a single 25MB standalone binary.

Known Limitations

SQLite architecture is optimized for single-node vertical scaling; not designed for multi-region active-active write clusters.

Official Documentation ↗
📄 docker-compose.yml
Production Ready
version: '3.8'
services:
  pocketbase:
    image: ghcr.io/muchobien/pocketbase:latest
    restart: unless-stopped
    ports:
      - "8090:8090"
    volumes:
      - pb_data:/pb_data
    command:
      - --dir=/pb_data
      - --http=0.0.0.0:8090
volumes:
  pb_data:

🚀 5-Minute Deployment Guide

  1. 1Launch an entry-level VPS (512MB - 1GB RAM) running Ubuntu 24.04 or Debian 12.
  2. 2Install Docker or run the PocketBase binary directly using `systemd`.
  3. 3Create a data directory `mkdir -p /opt/pocketbase/pb_data`.
  4. 4Start PocketBase via Docker Compose or run `./pocketbase serve --http=0.0.0.0:8090`.
  5. 5Open `http://your-server-ip:8090/_/` in your browser to create the initial admin account.
  6. 6Configure reverse proxy (Caddy or Nginx) for HTTPS on your custom domain.

Recommended Cloud VPS for PocketBase

Compare all VPS hosts →
Hetzner Cloud€3.79/mo

CX22 (2 vCPU, 4GB RAM)

Supercharged performance for PocketBase SQLite.

Deploy on Hetzner →
DigitalOcean$6.00/mo

Basic Droplet (1 vCPU, 1GB RAM)

Perfect for micro-SaaS and side projects.

Claim $200 DO Credit →

Appwrite

BSD-3-Clause⭐ 57.5k+

Secure end-to-end BaaS with multi-database support, serverless functions, and rich SDKs.

Min RAM2 GB
Min CPU1 vCPU
GitHub Repo ↗

✅ Advantages

  • Polished, intuitive administration console
  • Comprehensive multi-platform SDKs (Flutter, React Native, Apple, Android, Web)
  • Built-in serverless runtime out of the box

⚠️ Trade-offs / Limitations

  • Document DB abstraction layer over relational storage
  • Requires 2GB+ RAM for stable multi-container execution

Core Features

▸Complete user authentication with 30+ OAuth providers and Teams management
▸Flexible JSON document database with query indexing and permissions
▸Polyglot cloud functions supporting 12+ programming runtimes
▸Storage buckets with automatic file chunking and antivirus scanning
▸Webhooks, scheduled CRON tasks, and real-time WebSockets

Architecture Notes

Built using Docker microservices, MariaDB/Postgres persistence, Redis caching, and OpenRuntimes for polyglot serverless execution (Node, Python, PHP, Ruby, Dart, Go).

Known Limitations

Docker deployment uses multiple interconnected containers requiring at least 2GB of memory.

Official Documentation ↗
📄 docker-compose.yml
Production Ready
version: '3'
services:
  appwrite:
    image: appwrite/appwrite:1.5.8
    restart: unless-stopped
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - appwrite-uploads:/storage/uploads:rw
      - appwrite-data:/storage/data:rw
      - appwrite-config:/storage/config:rw
    environment:
      - _APP_ENV=production
      - _APP_OPENSSL_KEY_V1=your-secret-openssl-key-here
      - _APP_DOMAIN=appwrite.yourdomain.com
volumes:
  appwrite-uploads:
  appwrite-data:
  appwrite-config:

🚀 5-Minute Deployment Guide

  1. 1Provision a 2GB RAM VPS on Hetzner or DigitalOcean.
  2. 2Install Docker: `curl -fsSL https://get.docker.com | sh`.
  3. 3Run official installer: `docker run -it --rm -v /var/run/docker.sock:/var/run/docker.sock -v $(pwd)/appwrite:/usr/src/code/appwrite:rw --entrypoint="install" appwrite/appwrite:1.5.8`.
  4. 4Answer setup prompts for hostname and HTTP/HTTPS ports.
  5. 5Navigate to your domain to complete initial admin setup.

Recommended Cloud VPS for Appwrite

Compare all VPS hosts →
Hetzner Cloud€3.79/mo

CX22 (2 vCPU, 4GB RAM)

Affordable hardware with ample RAM for Appwrite.

Deploy on Hetzner →

Nhost

MIT⭐ 9.3k+

Open-source Firebase alternative built on Hasura GraphQL, PostgreSQL, and S3-compatible storage with managed migrations.

Min RAM2 GB
Min CPU2 vCPU
GitHub Repo ↗

✅ Advantages

  • GraphQL-first API eliminates REST boilerplate and under-fetching
  • Real-time subscriptions via GraphQL on any table without extra wiring
  • Schema migrations and Hasura metadata are version-controlled in a single source of truth
  • Drop-in replacement for Firestore when client apps already use GraphQL

⚠️ Trade-offs / Limitations

  • GraphQL permission model is more rigid than Supabase Row Level Security for ad-hoc queries
  • Self-hosted Hasura requires Hasura-specific operational knowledge (metadata, migrations)
  • Hasura Cloud dependency removed but version upgrades occasionally break metadata

Core Features

▸Instant auto-generated GraphQL API with role-based row-level permissions via Hasura
▸PostgreSQL 15+ with native schema migrations, event triggers, and scheduled triggers
▸Built-in authentication (email/password, magic links, SMS, 20+ OAuth providers) via GoTrue
▸S3-compatible storage buckets with image transformations and CDN integration
▸Serverless Functions runtime for custom JavaScript/TypeScript business logic
▸Local CLI (`nhost`) provisions complete stack via Docker for development parity

Architecture Notes

Production-grade Hasura GraphQL Engine fronting PostgreSQL 15+, with GoTrue for JWT/OAuth authentication, S3-compatible storage (MinIO or Hasura Storage), and serverless Functions runtime. Self-hosted deploys the same open-source stack the managed Nhost Cloud uses.

Known Limitations

Hasura permissions and GraphQL relationships require careful modeling for multi-tenant apps; permissions editor is web-UI-driven and steeper learning curve than PostgREST.

Official Documentation ↗
📄 docker-compose.yml
Production Ready
version: '3.8'
services:
  postgres:
    image: postgres:15-alpine
    container_name: nhost-postgres
    restart: always
    environment:
      POSTGRES_DB: nhost
      POSTGRES_USER: nhost
      POSTGRES_PASSWORD: nhost_secure_pass_2026
    volumes:
      - nhost_pg_data:/var/lib/postgresql/data
    networks:
      - selfhost_net
  hasura:
    image: hasura/graphql-engine:v2.44.0
    container_name: nhost-hasura
    restart: always
    ports:
      - "8080:8080"
    environment:
      HASURA_GRAPHQL_DATABASE_URL: postgres://nhost:nhost_secure_pass_2026@postgres:5432/nhost
      HASURA_GRAPHQL_ENABLE_CONSOLE: "true"
      HASURA_GRAPHQL_DEV_MODE: "false"
      HASURA_GRAPHQL_ADMIN_SECRET: nhost_admin_secret_change_me
      HASURA_GRAPHQL_UNAUTHORIZED_ROLE: anonymous
    depends_on:
      - postgres
    networks:
      - selfhost_net
  auth:
    image: nhost/hasura-auth:0.33.0
    container_name: nhost-auth
    restart: always
    ports:
      - "4000:4000"
    environment:
      HASURA_GRAPHQL_DATABASE_URL: postgres://nhost:nhost_secure_pass_2026@postgres:5432/nhost
      HASURA_GRAPHQL_ADMIN_SECRET: nhost_admin_secret_change_me
      AUTH_PROVIDER_EMAILS_ENABLED: "true"
    depends_on:
      - postgres
    networks:
      - selfhost_net
  storage:
    image: nhost/hasura-storage:0.6.0
    container_name: nhost-storage
    restart: always
    ports:
      - "5000:5000"
    environment:
      HASURA_GRAPHQL_DATABASE_URL: postgres://nhost:nhost_secure_pass_2026@postgres:5432/nhost
      HASURA_GRAPHQL_ADMIN_SECRET: nhost_admin_secret_change_me
    depends_on:
      - postgres
    networks:
      - selfhost_net
volumes:
  nhost_pg_data:
networks:
  selfhost_net:
    external: true

🚀 5-Minute Deployment Guide

  1. 1Provision Hetzner CX22 (2 vCPU 4GB RAM) or CPX11 (2 vCPU 2GB RAM) running Ubuntu 24.04.
  2. 2Install Docker: `curl -fsSL https://get.docker.com | sh`.
  3. 3Create `/opt/nhost` and save the docker-compose.yml above.
  4. 4Generate a strong admin secret with `openssl rand -hex 32` and replace `HASURA_GRAPHQL_ADMIN_SECRET`.
  5. 5Launch the stack with `docker compose up -d`.
  6. 6Access the Hasura Console at `http://your-server-ip:8080/console` and connect tables.
  7. 7Put Caddy or Nginx in front of port 8080 for HTTPS on `hasura.yourdomain.com`.

Recommended Cloud VPS for Nhost

Compare all VPS hosts →
Hetzner Cloud€3.79/mo

CX22 (2 vCPU, 4GB RAM, 40GB NVMe)

Plenty of headroom for Hasura + Postgres + Auth + Storage on a single 4GB node.

Deploy on Hetzner →
DigitalOcean$24.00/mo

Regular Droplet (2 vCPU, 4GB RAM, 80GB SSD)

Comfortable for Nhost production stack with $200 in 60-day trial credits.

Claim $200 DO Credit →

Parse Server

Apache-2.0⭐ 21.4k+

Mature open-source BaaS from Facebook with MongoDB or PostgreSQL backend, push notifications, and LiveQuery real-time.

Min RAM1 GB
Min CPU1 vCPU
GitHub Repo ↗

✅ Advantages

  • Largest mobile SDK ecosystem in self-hosted BaaS (iOS, Android, Flutter, React Native, Unity)
  • Battle-tested by Facebook for years before they open-sourced it in 2016
  • Schema migration tooling and dashboard UI bundled via parse-dashboard
  • No proprietary query language — REST and GraphQL both available out of the box

⚠️ Trade-offs / Limitations

  • No built-in row-level security like Supabase RLS — must enforce in Cloud Code
  • Real-time requires MongoDB replica set (oplog) or extra PostgreSQL trigger setup
  • Project velocity has slowed since 2020 — community-maintained rather than full-time BaaS vendor

Core Features

▸Drop-in replacement for the original Parse.com backend, full client SDK compatibility
▸MongoDB or PostgreSQL storage adapters — choose your database engine
▸Built-in push notifications via APNs, FCM, and web push providers
▸Cloud Code functions (Node.js) executed server-side for business logic and webhooks
▸LiveQuery real-time subscriptions via separate websocket server
▸GraphQL endpoint alongside the REST API for modern clients

Architecture Notes

Node.js application server that speaks the Parse Client protocol (compatible with the original Parse.com SDKs). Persists data to MongoDB or PostgreSQL via the database adapter. LiveQuery uses a separate websocket server reading from the database oplog/changelog for real-time event streams.

Known Limitations

LiveQuery requires MongoDB replica set (oplog tailing) or PostgreSQL LISTEN/NOTIFY setup; single-node MongoDB works for queries but disables real-time.

Official Documentation ↗
📄 docker-compose.yml
Production Ready
version: '3.8'
services:
  mongo:
    image: mongo:7
    container_name: parse-mongo
    restart: always
    ports:
      - "27017:27017"
    environment:
      MONGO_INITDB_ROOT_USERNAME: parse
      MONGO_INITDB_ROOT_PASSWORD: parse_secure_pass_2026
    volumes:
      - parse_mongo_data:/data/db
    networks:
      - selfhost_net
  parse-server:
    image: parseplatform/parse-server:7.0.0
    container_name: parse-server
    restart: always
    depends_on:
      - mongo
    ports:
      - "1337:1337"
    environment:
      DATABASE_URI: mongodb://parse:parse_secure_pass_2026@mongo:27017/parse?authSource=admin
      APPLICATION_ID: parse-app-id-change-me
      MASTER_KEY: parse-master-key-change-me
      SERVER_URL: http://your-server-ip:1337/parse
    networks:
      - selfhost_net
  parse-dashboard:
    image: parseplatform/parse-dashboard:6.0.0
    container_name: parse-dashboard
    restart: always
    depends_on:
      - parse-server
    ports:
      - "4040:4040"
    environment:
      PARSE_DASHBOARD_CONFIG: |
        {
          "apps": [
            {
              "appId": "parse-app-id-change-me",
              "masterKey": "parse-master-key-change-me",
              "serverURL": "http://parse-server:1337/parse",
              "appName": "Parse Self-Hosted"
            }
          ],
          "users": [
            {
              "user": "admin",
              "pass": "admin_secure_pass_2026"
            }
          ]
        }
    networks:
      - selfhost_net
volumes:
  parse_mongo_data:
networks:
  selfhost_net:
    external: true

🚀 5-Minute Deployment Guide

  1. 1Provision a 2GB RAM VPS on Hetzner (CX22 €3.79/mo) or DigitalOcean ($12/mo).
  2. 2Install Docker: `curl -fsSL https://get.docker.com | sh`.
  3. 3Create `/opt/parse-server` directory and save the docker-compose.yml above.
  4. 4Generate strong APPLICATION_ID, MASTER_KEY, and dashboard credentials with `openssl rand -hex 32`.
  5. 5Launch with `docker compose up -d` — Parse API on 1337, Dashboard on 4040.
  6. 6Update `SERVER_URL` to your HTTPS endpoint and put Caddy/Nginx in front for SSL.
  7. 7Optionally enable MongoDB replica set for LiveQuery real-time subscriptions.

Recommended Cloud VPS for Parse Server

Compare all VPS hosts →
Hetzner Cloud€3.79/mo

CX22 (2 vCPU, 4GB RAM, 40GB NVMe)

Single-node host for Parse Server + MongoDB + Dashboard comfortably under 2GB RAM.

Deploy on Hetzner →
Vultr$12.00/mo

High Performance (1 vCPU, 2GB RAM, 55GB NVMe)

Affordable NVMe-backed host ideal for Parse Server with low-latency MongoDB.

Deploy on Vultr →

Quick Specification Matrix

ToolLicenseMin RAMMin CPUGitHub RepoPrimary Advantage
Firebase & Supabase Cloud (Proprietary)Proprietary ClosedManaged CloudManaged CloudN/ATurnkey onboarding with vendor lock-in & paywalls
SupabaseApache-2.04 GB2 vCPUsupabase/supabase100% standard PostgreSQL — zero proprietary database lock-in
PocketBaseMIT256 MB1 vCPUpocketbase/pocketbaseTiny footprint: runs on a 512MB RAM / $3.50/mo server effortlessly
AppwriteBSD-3-Clause2 GB1 vCPUappwrite/appwritePolished, intuitive administration console
NhostMIT2 GB2 vCPUnhost/nhostGraphQL-first API eliminates REST boilerplate and under-fetching
Parse ServerApache-2.01 GB1 vCPUparse-community/parse-serverLargest mobile SDK ecosystem in self-hosted BaaS (iOS, Android, Flutter, React Native, Unity)

Performance Benchmarks & Hard Operational Limits

Real-world operational trade-offs, resource consumption limits, and measured throughput.

Benchmark MetricFirebase & Supabase Cloud BaselineSelf-Hosted Alternative MetricOperational Bottleneck / LimitSource
Database Read Latency (p95)35ms - 85ms (Firestore multi-region cloud overhead)3ms - 8ms (Direct local Postgres / SQLite query)Network hops between app servers and multi-tenant cloud datacenters.Supabase Performance Docs
Realtime WebSocket Message Concurrency100,000 connections (hard limit per Firestore database)50,000 - 250,000 concurrent sockets per 8GB VPS node (Elixir engine)Linux file descriptor limits (`ulimit -n`) and available RAM per socket.Supabase Realtime Benchmarks
Cold Start Latency (Auth / API)450ms - 2,500ms (Firebase Cloud Functions cold starts)0ms (Always-on compiled Go / Node daemon processes)Serverless container spin-up vs persistent daemon processes.Production Test

Frequently Asked Questions

Practical deployment, migration, and maintenance answers.

How do I handle automated daily database backups for self-hosted Supabase?▾

Supabase stores all application state in PostgreSQL. You can configure a daily cron job that executes `pg_dump` or uses tools like pgBackRest / Wal-G to stream WAL logs directly to an S3-compatible bucket (such as Cloudflare R2 or Hetzner Object Storage). Combine this with VPS snapshot policies for full disaster recovery.

Can I use standard Firebase client SDKs with self-hosted alternatives?▾

No. Self-hosted alternatives have their own open-source client SDKs (for JavaScript, Flutter, Swift, Kotlin, Python). Supabase provides an API surface modeled around PostgreSQL queries with TypeScript generation, while PocketBase offers lightweight SDKs with built-in reactive subscriptions.

Is PocketBase suitable for high-traffic production workloads?▾

Yes, for applications up to tens of thousands of concurrent users. PocketBase uses SQLite in WAL mode, capable of handling 10,000+ read queries per second on a $5/mo VPS. If your application requires horizontal multi-node scaling with active-active write distribution, Supabase with PostgreSQL is the recommended choice.

How does self-hosted Supabase handle user authentication and social OAuth logins?▾

Supabase uses GoTrue, an open-source Go authentication service that supports email/password, magic links, phone OTP, and 20+ OAuth providers (GitHub, Google, Apple, Discord, etc.). You configure OAuth client IDs and secrets directly in your `docker-compose.yml` or `.env` file.

What are the minimum hardware requirements to self-host Supabase in production?▾

Supabase consists of several interconnected containers (Postgres, Kong, GoTrue, PostgREST, Realtime, Storage). A minimum of 2 vCPU and 4GB RAM is required for stable production operations. For low-resource setups (< 1GB RAM), PocketBase or Appwrite are significantly lighter alternatives.

When should I pick Nhost over Supabase if I'm coming from Firebase Firestore?▾

Pick Nhost if your client apps already speak GraphQL or you want auto-generated GraphQL queries with row-level permissions modelled in Hasura instead of PostgREST. Hasura compiles GraphQL directly from your PostgreSQL schema with subscriptions built-in, which maps cleanly to Firestore's real-time listener model. Pick Supabase if you prefer a REST-first API, want Row Level Security in PostgreSQL itself (more flexible than Hasura's permission editor), or need mature pgvector/PostGIS extensions. Both run the same underlying PostgreSQL — the difference is API surface and permission model.

Can I migrate an existing Parse.com or Firebase app to self-hosted Parse Server without losing data?▾

Yes. Parse Server speaks the original Parse.com protocol, so existing Parse client SDKs (iOS, Android, Flutter, React Native, Unity, JavaScript) connect without code changes. For data migration, use the official `parse-cli` export/import commands to move classes and rows between Parse Server instances, or run the legacy Parse.com mongodb dump directly into the new MongoDB storage adapter. For Firebase, the standard path is: (1) export Firestore collections to JSON via the Firebase CLI `firestore:export`, (2) write a Node.js script that creates Parse objects via the REST API, and (3) migrate Firebase Auth users by hashing passwords with the same bcrypt cost factor Parse expects.

Starter Stack Pack — $29

Skip the setup: get the production-ready stack

Don't stitch together configs from five different READMEs. Get all 5 production-hardened Docker Compose stacks — Postgres, Redis, SSL auto-renewal, and backup scripts — ready to deploy in minutes.

⚡n8nVisual workflow automation
📊UmamiPrivacy-first web analytics
🛡️Uptime KumaUptime monitoring & alerts
🔐VaultwardenBitwarden-compatible vault
☁️NextcloudDropbox/Drive replacement
Get the Stack Pack — $29 →

One-time purchase · Instant download · Production-ready

esc
↑↓ navigate↵ open