Firebase Alternatives In 2026

Firebase makes the first week of a project effortless and the third year expensive, and the part that traps you is not the invoice. Firestore's data model, security rules and SDK map onto nothing else, so "we should move off Firebase" becomes a rewrite rather than a migration.

Two numbers from this comparison are worth knowing before you shortlist anything. Priced on the same app, a 20-developer team pays $500 a month on Convex against $26.50 on Supabase, because one bills per developer and the other bills per project. And only three of the four alternatives here are open source in the license sense: Convex ships under the Functional Source License, which GitHub labels simply "Other". Every license, version and price below was read off each project's own repository or pricing page on September 20, 2026.

What Teams Actually Run

The license is the first thing to check, because the entire argument for leaving Firebase is not wanting to be locked in again. As of September 20, 2026: Supabase is Apache 2.0 with 110,389 GitHub stars, PocketBase is MIT with 61,110 stars, Appwrite is BSD 3-Clause with 57,422 stars, and Nhost is MIT with 9,296 stars.

Convex is the exception. The convex-backend repository, which carries 12,584 stars, ships under the Functional Source License Version 1.1 with an Apache 2.0 future grant. That is source-available, not open source: you can self-host it, competing commercial use is restricted, and each release converts to Apache 2.0 two years after publication. GitHub's API reports it as "Other", so the repo page will not tell you. It is a reasonable license and not the same promise Supabase or PocketBase make.

Firebase itself is proprietary and, per its own homepage, now positions as "a platform of services to help you and AI agents build and run intelligent apps." Every platform on this list has added agent-facing tooling in the past year.

What the Same App Costs on Each Platform

I priced one app across every platform that publishes rates: 50,000 monthly active users, a 20 GB database and 200 GB of egress, at three team sizes. The script uses only published numbers and computes Supabase's usage overage from its own per-unit rates.

js
Copy
// price-baas.mjs - rates read from each vendor's pricing page, September 20, 2026
const APP = { mau: 50_000, dbGB: 20, egressGB: 200 };

// Supabase Pro: $25/mo first project. 100k MAU then $0.00325/MAU,
// 8 GB disk then $0.125/GB, 250 GB egress then $0.09/GB.
const supabase = () => 25
  + Math.max(0, APP.mau - 100_000) * 0.00325
  + Math.max(0, APP.dbGB - 8) * 0.125
  + Math.max(0, APP.egressGB - 250) * 0.09;

const rows = [
  { name: "Supabase Pro",        axis: "per project",      at: () => supabase() },
  { name: "Nhost Pro",           axis: "per project",      at: () => 25 },
  { name: "Appwrite (Micro)",    axis: "per compute tier", at: () => 10 },
  { name: "Convex Professional", axis: "per developer",    at: (d) => 25 * d },
  { name: "Firebase Blaze",      axis: "metered only",     at: () => 0 },
  { name: "PocketBase",          axis: "self-hosted",      at: () => 0 },
];
for (const r of rows)
  console.log(r.name.padEnd(22), r.axis.padEnd(17),
    ...[3, 10, 20].map(d => `$${r.at(d).toFixed(2)}`.padStart(9)));

text
Copy
App: 50,000 MAU, 20 GB database, 200 GB egress

Platform               Billing axis         3 devs   10 devs   20 devs
---------------------- ----------------- --------- --------- ---------
Supabase Pro           per project          $26.50    $26.50    $26.50
Nhost Pro              per project          $25.00    $25.00    $25.00
Appwrite (Micro)       per compute tier     $10.00    $10.00    $10.00
Convex Professional    per developer        $75.00   $250.00   $500.00
Firebase Blaze         metered only          $0.00     $0.00     $0.00
PocketBase             self-hosted           $0.00     $0.00     $0.00

The billing axis is the whole story, and a pricing page comparison hides it. Supabase, Nhost and Appwrite charge for infrastructure, so the bill is flat as the team grows. Convex charges $25 per developer per month, so the same app costs 19 times more at 20 engineers. Neither model is wrong, but a 30-person org evaluating Convex on a two-person prototype is looking at the wrong number.

The $0.00 rows are honest and incomplete. Firebase Blaze has no seat or base fee and bills purely on usage; PocketBase has no vendor bill because you run it yourself, which costs a server and your time instead.

Firebase

Firebase is still the fastest way to get an authenticated, realtime, cross-platform app in front of users, and that has not changed.

Its two plans are Spark, no-cost with no payment method required, and Blaze, pay as you go with $300 in credit for eligible new billing accounts. The client SDKs, offline persistence and Google identity integration are hard to match.

What it does not do is let you leave cheaply. Firestore's query model, security rules and SDK have no equivalent on this list, so migrating is an application rewrite. Blaze's per-operation billing also means a bad query loop arrives as a bill, not a slow endpoint.

Pricing: Spark no-cost, Blaze pay as you go, $300 credit for eligible new accounts.

License: proprietary, operated by Google.

Supabase

Supabase is the closest thing to a default answer, because underneath it is just Postgres.

That is the argument in one sentence: your data lives in a database you already know how to query, back up and move. Auth, storage, realtime and edge functions sit around it. The free tier gives 50,000 monthly active users, a 500 MB database and 5 GB of egress, a real tier rather than a demo.

What it does not do is stay free quietly. Free projects pause after one week of inactivity and you get two, which surprises anyone who parked a side project. Pro starts at $25 a month with the first project included and more from $10 a month, so several environments means paying per environment.

Pricing: Free $0 · Pro from $25/month · Team from $599/month · Enterprise custom. Overage at $0.00325 per MAU above 100,000, $0.125 per GB of disk above 8 GB, $0.09 per GB of egress above 250 GB.

License and version: Apache 2.0, 110,389 stars.

Appwrite

Appwrite is the one that sells compute tiers instead of seats or users, and it now describes itself as an agent-first platform.

Its pricing has two shapes: serverless, with a $0 fixed monthly compute fee and quota-then-overage billing, or dedicated compute with published tiers running from Micro at $10 a month for 2 shared cores and 1 GB of memory up to 4XL at $960 a month for 16 dedicated cores and 64 GB. Every plan includes $10 of monthly compute credits. It also supports more database engines than anything else here: TablesDB, DocumentsDB, VectorsDB, PostgreSQL and MySQL.

What it does not do is match Supabase's gravity. The community is smaller, its Postgres option is newer than Supabase's entire premise, and point-in-time recovery costs 20 percent of your base.

Pricing: serverless $0 fixed fee plus overage, or dedicated compute from $10/month (Micro) to $960/month (4XL), $10 monthly compute credits included.

License and version: BSD 3-Clause, 57,422 stars, v2.2.0 as of September 15, 2026.

Convex

Convex is the most opinionated option here and the only one that is not open source.

Its pitch is a reactive backend where queries are TypeScript functions that re-run when data changes, with database, workflow, sync, search and file storage in one system. For a collaborative real-time product this removes a real pile of glue code, and it is the platform most obviously designed for agent-written code.

What it does not do is bill like infrastructure. Professional is $25 per developer per month, which is why the same app costs $500 a month at 20 engineers in the table above. The Functional Source License also means self-hosting is possible but competing commercial use is restricted until each release converts to Apache 2.0 two years after publication.

Pricing: Free and Starter $0 plus pay as you go for 1 to 6 developers · Professional $25 per developer per month for up to 20 developers.

License and version: Functional Source License 1.1 with Apache 2.0 future grant, 12,584 stars on convex-backend.

PocketBase

PocketBase is the one you run yourself, and it is a single file.

One Go binary gives you a SQLite database, realtime subscriptions, OAuth authentication, file storage and an admin dashboard. No account, no vendor, no bill. For an internal tool or an app that runs on a box in a closet in Ohio, it is the least ceremony here.

What it does not do is scale horizontally. SQLite on one machine is the design, not a limitation to configure away, and there is no managed offering, no multi-region story and no SLA. You own backups, uptime and upgrades.

Pricing: free. You pay for whatever server you put it on.

License and version: MIT, 61,110 stars, v0.40.4 as of September 12, 2026.

Side by Side

How to Choose Without Migrating Twice

1. Count your engineers before you price anything. Run the numbers above with your real headcount. A per-developer platform and a per-project platform cross over fast, and the crossover is the single biggest number in this decision.
2. Read the actual LICENSE file, not the GitHub badge. GitHub reported Convex as "Other", which tells you nothing. If escaping lock-in is why you are here, an OSI license is the thing you came for.
3. Pick the data model you can leave. Postgres and SQLite both export to something every other tool reads. Firestore and Convex's engine do not.
4. Check what the free tier does when you ignore it. Supabase pauses free projects after a week of inactivity and caps you at two, and Nhost pauses after a week too. That is fine for production and annoying for side projects.
5. Price the environments, not the app. Supabase includes one project and charges from $10 a month for each additional one, so staging and preview environments are a line item, not a rounding error.

Which One Should You Actually Use?

Leaving Firebase and you want the least risk: Supabase. Postgres means your data is portable on day one, the Apache 2.0 license means the platform is too, and 110,389 stars means most of your problems are already answered somewhere.

Small team, real-time or collaborative product: Convex, with the seat math done first. The reactive model genuinely removes work, and at 3 developers it is $75 a month, which is cheap. At 20 it is $500.

You want compute you can size, or a database that is not Postgres: Appwrite. It is the only one here selling explicit compute tiers from $10 to $960 a month, and the only one offering TablesDB, Postgres and MySQL behind one API.

Internal tool, prototype, or an app that must run on your own hardware: PocketBase. One MIT-licensed binary, no vendor, no bill, and no horizontal scaling story. Know which of those you are signing up for.

Already deep in Firebase and shipping fine: stay. Migration is a rewrite, not a config change, and an $80 Blaze bill is not worth a quarter of engineering.

Conclusion

The thing that actually changed this year is that these platforms stopped competing on features. Auth, realtime, storage and functions are table stakes now, and all five have shipped agent-facing tooling. What separates them is the license and the billing axis, which are the two things a feature matrix never shows.

Before you commit, ask what it costs to leave. On Postgres or SQLite the answer is a pg_dump and a weekend. On Firestore or Convex's engine it is a rewrite, and that number belongs in the evaluation alongside the monthly price.

Related DevToolLab Tools

• SQL CREATE TABLE Generator - sketch the Postgres schema you are about to run on Supabase before you click through a dashboard.
• env to JSON Converter - turn the environment variables these platforms hand you into structured config your app can validate.
• UUIDv7 Generator - time-sortable primary keys that behave better than random UUIDs in a synced backend.
• JSON to SQL Converter - turn exported Firestore documents into insert statements when you move to a relational backend.

Related Guides

• Best Serverless Postgres in 2026: Neon, Supabase and What Scale-to-Zero Actually Saves - the database layer on its own, priced the same way.
• Best Authentication Providers in 2026: Auth0 vs Clerk vs WorkOS - when you want to unbundle auth from the backend platform.
• Best Heroku Alternatives in 2026 - where to run the app if the backend is only part of the problem.
• Best Authorization and Permissions Tools in 2026 - what to use when row-level security stops being enough.