cheapstack
RSSBrowse stacks
comparison / 10 — updated may 2026

Firebase vs Supabase vs Appwrite vs PocketBase vs Convex

Leaving Firebase? Here's how Supabase, Appwrite, PocketBase, and Convex stack up — open-source options with self-hosting, generous free tiers, and prices that don't surprise you at scale.

cheapstack editorialMethodologyPrices verified May 2026
entry tier
Firebasefree Spark · pay-as-you-go Blaze
Supabasefree · $25/mo Pro
Appwritefree 75k req · $25/mo Pro
PocketBaseself-host only · $5-10 VPS
Convexfree · $25/dev/mo Pro
open source
Firebaseno · proprietary
Supabaseyes · Apache 2.0
Appwriteyes · BSD-3
PocketBaseyes · MIT
Convexyes · FSL Apache 2.0
database
FirebaseFirestore / Realtime DB · NoSQL
SupabasePostgres · SQL
AppwriteMariaDB · SQL
PocketBaseSQLite · embedded
ConvexConvex DB · reactive
updated
May 2026
Skip to verdictSee pricing →
verdict.txt — comparisons/firebase-alternatives.mdhonest
$cat verdict.txt

Supabase if you want the closest open-source equivalent (Postgres + auth + storage + functions). PocketBase if a single self-hostable binary is the dream. Appwrite if you want multi-platform SDKs with a polished UI. Convex if real-time reactive queries are the deciding feature. Firebase still wins for tightest Google Cloud integration if cost predictability isn't the issue.

Updated May 2026read the full reasoning →
scoreboard / at a glance

At a glance

One row per dimension, the values side-by-side. The olive dot marks the clear winner for that dimension when there is one — most rows are a wash, and that’s the point.

Google

Firebase

Google's backend-as-a-service. NoSQL databases (Firestore, Realtime DB), auth, storage, functions, hosting — all bundled. The incumbent everyone leaves or stays with.

Supabase

Supabase

Open-source Firebase alternative built on Postgres. Auth, storage, edge functions, realtime — all included. The Postgres-first choice.

Appwrite

Appwrite

Open-source backend with multi-platform SDKs (web, mobile, server). MariaDB-backed, BSD-3 licensed, self-hostable. Polished console UI.

PocketBase

PocketBase

Single Go binary with embedded SQLite. Auth, realtime, storage, admin UI — all in one file you run on a $5 VPS. The radically simple pick.

Convex

Convex

TypeScript-native reactive backend. Functions, queries, and mutations are real-time by default. Vector search, scheduled jobs, file storage built in.

Free tierAll five have a usable free tier. Firebase Spark and Convex's 1M calls are the most generous for hobby projects; Supabase's pause-after-7-days inactivity penalty hurts side projects.
Spark · 50k reads/day · 10k MAU
500MB DB · 50k MAU · pauses after 7d idle
75k requests/mo · per project
self-host · forever
1M function calls/mo · 0.5GB
Cheapest paid tierPocketBase self-host wins on absolute cost — just a VPS. Among hosted, all three converge at $25/mo entry tier. Firebase Blaze can be cheaper or much more expensive depending on usage shape.
Blaze · pay-as-you-go
$25/mo Pro + usage
$25/mo Pro · 2TB bandwidth
free OSS · ~$5 VPS
$25/dev/mo Pro
Open sourcePocketBase MIT is the most permissive. Supabase Apache 2.0 and Appwrite BSD-3 are unrestricted. Convex's FSL adds a non-compete clause but otherwise Apache-equivalent. Firebase is closed source.
no · proprietary
yes · Apache 2.0
yes · BSD-3-Clause
yes · MIT
yes · FSL Apache 2.0 (non-compete)
Self-hostablePocketBase wins on simplicity — one binary, no Docker required. Supabase and Appwrite self-host via Docker Compose. Convex added self-host in late 2024.
no · cloud only
yes · Docker
yes · Docker
yes · single binary
yes · Docker (since 2024)
DatabaseSupabase exposes raw Postgres — full SQL, direct connections, no abstraction. PocketBase's SQLite is similarly accessible. Firestore's NoSQL is the biggest conceptual shift if you're SQL-shaped.
Firestore / Realtime DB · NoSQL document
Postgres · SQL · full SQL access
MariaDB · SQL · abstracted via SDK
SQLite · embedded · file-based
Convex DB · reactive · transactional
Realtime / reactiveConvex is built realtime-first — every query auto-subscribes to updates. Firebase invented this category. The others all support realtime but you opt in explicitly.
yes · Firestore listeners + Realtime DB
yes · Postgres replication
yes · WebSockets
yes · WebSockets
yes · reactive queries by default
Beyond databaseFirebase has the widest surface area (hosting, analytics, crashlytics, A/B testing all built in). Supabase, Appwrite, and Convex cover the core trio (auth/storage/functions). PocketBase intentionally stays smaller.
auth + storage + functions + hosting + analytics
auth + storage + edge functions + realtime
auth + storage + functions + multi-platform SDKs
auth + storage + admin UI
auth + storage + functions + cron + vector search
pricing / three scenarios

Pricing at three scales

Three receipts, three scales. The line items are the same; the prices move. Every number is from the public May 2026 pricing page — we round to the nearest dollar but don’t invent.

hobby.txt — personal project · ~100-500 users · low trafficmonthly
LINE ITEMFirebaseSupabaseAppwritePocketBaseConvex
BackendSpark · free tierfreeFree · 2 projects (with idle pause)freeFree · 75k req/mofree$5 VPS · self-host$5Free · 1M function callsfree
TOTAL · monthlyfreefreefree$5/mofree
>All hosted options are free at hobby scale. PocketBase's $5 VPS is the only direct cost but you get persistent uptime (no Supabase idle pause). For most personal projects with under 500 users, every option here costs $0-5/mo.
side project.txt — paying customers · ~5k MAU · production trafficmonthly
LINE ITEMFirebaseSupabaseAppwritePocketBaseConvex
BackendBlaze · pay-as-you-go (~$5-20)$15Pro + usage$25Pro · 2TB bandwidth$25$10 VPS · self-host$10Pro · 25M function calls$25
TOTAL · monthly$15/mo$25/mo$25/mo$10/mo$25/mo
>PocketBase self-host on a $10 VPS is the cheapest path at this scale. Firebase Blaze typically lands at $5-20/mo for 5k MAU but is harder to predict. The three hosted alternatives converge at $25/mo entry tier — they're priced for indie SaaS specifically.
scale.txt — production · ~50k MAU · marketing site + productmonthly
LINE ITEMFirebaseSupabaseAppwritePocketBaseConvex
BackendBlaze · usage-based (~$50-150)$100Pro + usage (~$35-75)$55Pro · 2TB covers most$25$20 VPS · self-host$20Pro · usage scaling$50
TOTAL · monthly$100/mo$55/mo$25/mo$20/mo$50/mo
>At 50k MAU scale Firebase Blaze costs become real ($50-150/mo typical, easily $300+ with heavy Firestore usage). Appwrite Pro's flat $25/mo plus 2TB bandwidth is the cheapest hosted option at this volume — generous resource limits for indie SaaS. PocketBase remains cheapest overall via self-host but needs more VPS resources.
verdict / pick one

When to pick which

pick / firebase

Pick Firebase if…

  • You're deep in Google Cloud already (GCP, Workspace, Analytics) and want everything in one bill.
  • Real-time mobile/web sync at hobbyist scale — Firestore listeners are still the gold standard.
  • You want the widest service surface (Crashlytics, A/B testing, Remote Config, App Check, ML Kit) without integration work.
  • Cost predictability isn't the top concern and you want enterprise reliability backing the service.
  • Your team is Android/iOS-first — Firebase's mobile SDKs are best-in-class.
Try Firebase →
pick / supabase

Pick Supabase if…

  • Postgres is the deciding factor — you want raw SQL, foreign keys, transactions, and full query power.
  • Open-source is non-negotiable — Apache 2.0 self-host gives you the full exit ramp.
  • Row Level Security is your auth model — Postgres RLS + Supabase Auth is genuinely productive.
  • Real-time over Postgres replication is sufficient — you don't need reactive-by-default queries.
  • You'd rather pay a flat $25 + usage than be surprised by Firebase's per-operation bills.
Try Supabase →
pick / appwrite

Pick Appwrite if…

  • Multi-platform SDKs matter — Appwrite ships polished SDKs for web, iOS, Android, Flutter, React Native, Unity, and more.
  • BSD-3-Clause license is your shape — more permissive than AGPL, equivalent to MIT in practice.
  • $25/mo Pro with 2TB bandwidth is generous for media-heavy apps that would overage on competitors.
  • Console UX is your priority — Appwrite's admin dashboard is widely considered the most polished in this set.
  • Self-host on Docker Compose is the deployment path.
pick / pocketbase

Pick PocketBase if…

  • Radical simplicity is the deciding feature — a single Go binary, no Docker required, no database server to configure.
  • Cost matters most — $5-10/mo VPS is the entire infrastructure bill.
  • Your project fits within SQLite's strengths (a single-server workload up to millions of records).
  • MIT license + Go binary = maximum portability and minimum operational complexity.
  • Your team can manage a VPS — there's no cloud-managed PocketBase option.
pick / convex

Pick Convex if…

  • Reactive queries by default is the killer feature — every query auto-subscribes to data changes, no listener wiring.
  • TypeScript-native — your functions, schema, and client code are all typed end-to-end.
  • Vector search is a real requirement (AI-shaped products) and you'd rather not bolt on Pinecone or pgvector.
  • Cron jobs, scheduled functions, and durable workflows are part of your shape.
  • You're comfortable with FSL's non-compete clause (you can self-host, just can't sell competing cloud).
Try Convex →
gotchas / observed

Gotchas, both directions

Common pitfalls visible in public docs and community discussion. None of these will stop you shipping; all of them will cost you an afternoon if you don’t know about them.

  • Firebase / cost predictability

    Blaze bills can spike with no warning

    Firebase Blaze is pay-as-you-go with no built-in spending cap. A traffic spike, recursive Firestore query, or misconfigured Cloud Function can run up $1000+ overnight bills. Set GCP budget alerts the day you switch from Spark to Blaze; many teams have learned this the hard way.

  • Supabase / project pause

    Free tier projects pause after 7 days idle

    Supabase Free tier auto-pauses projects after 7 days without activity. For weekend hobby projects this is fine; for low-traffic indie SaaS that only gets requests sporadically, your users will hit a cold-start delay or paused project. Upgrade to Pro ($25/mo) or set up a cron ping to keep projects warm.

  • Appwrite / pricing change

    Pro plan went from $15 to $25 in Sep 2025

    Appwrite raised the Pro plan from $15/mo to $25/mo starting September 1, 2025, alongside switching from per-organization to per-project resources. Existing customers were grandfathered; new signups pay the new rate. Older comparison articles may quote the old $15 price.

  • PocketBase / single-server limit

    No horizontal scaling — vertical only

    PocketBase runs as a single binary with embedded SQLite. You scale by giving the VPS more CPU/RAM, not by adding nodes. For most indie SaaS up to ~100k MAU this is fine, but if your shape genuinely needs horizontal scaling (multi-region, sharded), PocketBase isn't the right tool.

  • Convex / FSL non-compete

    Self-host is permitted but cloud-resale is not

    Convex's Functional Source License is Apache 2.0-equivalent for almost everything — except you cannot create a competing hosted Convex service. Self-hosting for your own app or on internal infrastructure is fully permitted. Most teams never hit this clause, but it's not Apache 2.0 strict.

  • Firebase migration / lock-in

    Migrating off Firebase is real work

    Firestore's document model doesn't map cleanly to SQL. Cloud Functions runtime, Firebase Auth claims, Realtime Database trees — all are Firebase-specific shapes. Plan 2-6 weeks for a non-trivial migration depending on app complexity. Don't underestimate the auth migration in particular.

migration / observed patterns

Migrating between them

Editorial framing only — we have not migrated either way ourselves. What follows is the pattern visible in public post-mortems, GitHub issue threads, and conference talks. Take it as observed-pattern, not lived experience.

Firebase ━▶ Supabase

The most common migration in this space. Firestore (NoSQL document) → Postgres (SQL with JSONB columns for unstructured fields). Firebase Auth → Supabase Auth (both support email/password, OAuth, magic links). Cloud Functions → Edge Functions (both Deno-based). Cloud Storage → Supabase Storage (compatible S3-shape API).

Plan 2-4 weeks for a non-trivial app. The hardest piece is usually re-modeling Firestore documents into Postgres tables — denormalization decisions made for Firestore often don't carry over. Run both backends in parallel for a week before flipping DNS.

Firebase ━▶ PocketBase

Steeper migration than Supabase because the architecture is more different — single binary + SQLite vs cloud-managed multi-service. But for small projects ready to consolidate, the simplicity payoff is real.

Approach: spin up PocketBase on a $5 VPS, manually export Firestore via the admin SDK, transform documents into PocketBase collections (similar JSON schema model), import via the admin UI or API. Auth migration uses PocketBase's import endpoint. Most projects under 10k records can migrate in a weekend.

Firebase ━▶ Convex

If you're moving off Firebase specifically for the reactive query experience (Firestore real-time listeners were the original draw), Convex is the natural successor. The reactive model is conceptually similar — queries auto-subscribe to data changes — but TypeScript-native and transactional by default.

The migration is mostly a rewrite, not a port. Convex's schema-first approach (TypeScript schema files) and function-based mutations are different enough that you're rebuilding the data layer. Budget 3-6 weeks. The upside: you delete a lot of Firebase-specific glue code.