The Short Answer on Supabase Alternatives
The right Supabase alternative depends on why you want to leave. Pick Convex for a collaborative app that needs a reactive database, Firebase for a mobile app that needs offline sync, PocketBase or Appwrite if you want to self-host, and Neon with Clerk or Better Auth if you want plain Postgres with no tie to Supabase Auth. Plenty of products should stay on Supabase, and I will tell you which ones.
This post is the view from the other side: what to use instead, organized by the reason you are looking. If you are still choosing between the two big names for the first time, our Supabase vs Firebase comparison covers that decision head to head.
Every price below comes from the vendor's own pricing page, checked in November 2026. Pricing in this category changes a few times a year, so treat anything older than a couple of months as a draft and check it again before you sign.
Why Founders Leave Supabase
Name your reason before you compare tools. Each reason points at a different replacement, and two of them are fixed without leaving at all.
- The bill grows in steps. Supabase Pro is $25 a month and includes $10 of compute credits, which covers one Micro instance. Every extra project runs its own instance, so a staging copy costs money too. Moving up a size is a jump: Small is $15 a month, Medium $60, Large $110. Past 100,000 monthly active users you pay $0.00325 per user, and past 250 GB of egress you pay $0.09 per GB.
- Row Level Security gets hard to reason about. RLS is great for a simple app where users see only their own rows. Once you have teams, roles, shared documents and an admin view, the policies spread across dozens of tables and one wrong policy leaks data quietly. Some teams would rather put permission checks in plain server code they can test.
- Realtime has limits. Supabase Realtime is metered by connections and messages, and Postgres Changes checks permissions for every subscriber on every change. Supabase's own docs steer heavy use toward Broadcast. If live state is the core of the product, you end up building sync logic yourself.
- You want a reactive database. Some founders do not want to subscribe to changes at all. They want queries that update the screen on their own, the way Convex works.
- You want to self-host. Supabase can be self-hosted, but it is a set of services (Postgres, GoTrue, PostgREST, Realtime, Storage, Kong) that you now operate. Some teams want one binary instead.
- Your users live in Supabase Auth. Password hashes, sessions and OAuth links sit in the auth schema of your project. Moving them later is a project of its own, so some teams pick an auth provider that is independent from day one.
The first two complaints often come from setup rather than from Supabase. A project on the wrong compute size, or RLS policies written without a plan, can be fixed in a week. The last four are real reasons to move.
Firebase for Mobile Apps and Offline Sync
Firebase is Google's backend for apps: Firestore as a document database, Authentication, Cloud Functions, Storage, Hosting, plus push notifications, Crashlytics and Remote Config in the same console. That last group is the reason mobile teams pick it.
What it is good for
Firestore's client SDKs cache data on the device and sync writes when the phone comes back online. You get that for free on iOS, Android and the web. If your app is used in a warehouse, on a job site or on a subway, this matters more than anything else in this post. Push messaging and crash reporting live in the same project, so a small mobile team has one console to watch.
What to watch for
Firestore is a document store, so joins, reports and anything that looks like SQL get awkward. You denormalize data and keep copies in sync with functions. Security Rules are their own language, which is the same problem as RLS in a different shape. And you are tied to Google Cloud. Getting off Firestore later means rewriting your data layer.
What it costs (November 2026)
- Spark: $0. Firestore gives you 50,000 reads, 20,000 writes and 20,000 deletes a day and 1 GiB stored. Auth includes 50,000 monthly active users.
- Blaze: pay as you go, with the same free amounts. Firestore Standard in us-central1 is $0.03 per 100,000 reads, $0.09 per 100,000 writes and $0.01 per 100,000 deletes. Storage is $0.00020 per GiB-hour, about $0.15 per GiB a month.
The Firebase bill follows reads, and a chatty screen that re-reads a list every time it opens can cost more than you expect. Budget alerts on day one are not optional.
Convex for a Reactive Database
Convex is a TypeScript backend where your queries, mutations and server functions live in your repo as plain TypeScript. The client subscribes to a query, and when any data the query read changes, the new result is pushed to the screen. You do not write subscription code or cache invalidation.
What it is good for
Collaborative tools, multiplayer features, live dashboards, chat and AI apps that stream results into a shared view. Permission checks are ordinary TypeScript inside each function, which many developers find easier to test than RLS. Types flow from the schema to the React hooks, so a renamed field breaks the build instead of breaking production.
What to watch for
It is not SQL. Analytics and ad hoc reporting need an export to a warehouse. Your backend logic is written against Convex's APIs, so moving off it later is a rewrite of that layer. Convex has open-sourced its backend and documents self-hosting, which lowers that risk, but most teams use the cloud.
What it costs (November 2026)
- Free and Starter: $0 with 1 million function calls, 0.5 GB of database storage and 1 GB of egress a month. Past that, $2.20 per million calls.
- Professional: $25 per developer a month, with 25 million calls, 50 GB of storage and 50 GB of egress. Overage is $2 per million calls and $0.20 per GB stored.
- Business and Enterprise: a $2,500 monthly minimum.
Note the per-developer pricing. A team of four on Professional starts at $100 a month before usage.
Appwrite and PocketBase if You Want to Self-Host
Both are open source and both run on your own server. They sit at very different sizes.
Appwrite
Appwrite gives you a database, auth, storage, functions, messaging and realtime behind one API, with SDKs for web, Flutter, iOS and Android. It runs as a set of Docker containers you can host yourself, or on Appwrite Cloud. It suits a team that wants the full Supabase feature set without Postgres, and teams building in Flutter, where its SDK is strong.
Watch for this: it is not SQL either, so relational queries are more limited than in Postgres, and self-hosting it means running and upgrading several containers. Cloud pricing as of November 2026:
- Free: $0. 75,000 monthly active users, 2 GB of storage, 5 GB of bandwidth, 750,000 function executions and 2 projects. Free projects pause after a week of inactivity.
- Start: from $10 a month for one project with 100,000 users and 80 GB of bandwidth.
- Pro: from $25 a month for one project with 200,000 users, 150 GB of storage, 2 TB of bandwidth and 3.5 million executions. Extra projects are $15 each. Dedicated database compute starts at $10 a month.
PocketBase
PocketBase is one Go binary with SQLite inside, plus auth, file storage, realtime subscriptions and an admin UI. You copy one file to a server and run it. It is MIT licensed and free. A small VPS at $5 to $10 a month runs it for a first version with thousands of users.
The catch is in its own README: it is still under active development and full backward compatibility is not guaranteed before v1.0.0. The current release is v0.42.3. It also runs on one machine, so there is no horizontal scaling and you own the backups. For an internal tool or a prototype that is fine. For a product you expect to raise money on, I would plan the move before you need it. Our PocketBase vs Supabase guide for MVPs walks through that migration path.
Managed Postgres Plus Your Own Auth and API
This is the option founders forget. Supabase is Postgres with services around it. You can keep Postgres and choose each service yourself: a managed database like Neon, an auth provider like Clerk or Better Auth, and your own API in Next.js, Hono or Express with an ORM like Drizzle or Prisma.
What it is good for
You get plain SQL, permission checks in code you can test, and no single vendor holding your users and your data at once. Swapping the database host later is a pg_dump and a connection string. This is the setup I would pick for a B2B SaaS with organizations, roles and a lot of business logic.
We work this way often. Fake Friends runs on Next.js with Clerk for email-code sign-in and MongoDB Atlas for data, and it went from first commit to production in two days. You can read how in the Fake Friends case study. The database there is not Postgres, but the pattern is the same: managed data, separate auth, your own API.
What to watch for
You write the API layer yourself. There is no auto-generated REST endpoint and no storage bucket in the same dashboard, so you add S3 or Cloudflare R2 for files. Realtime needs a separate tool too. Plan for a few extra days of setup compared with Supabase.
What it costs (November 2026)
- Neon Free: $0, with 100 compute-hours per project, scale to zero after 5 minutes, and Managed Better Auth for up to 60,000 monthly active users per project.
- Neon Launch: usage based with no minimum. Compute is $0.106 per CU-hour and storage $0.35 per GB a month. Scale is $0.222 per CU-hour. A small production app idling most of the night often lands between $15 and $40 a month.
- Clerk: Hobby is free up to 50,000 monthly retained users per app. Pro is $25 a month, or $20 billed yearly, then $0.02 per user from 50,001 to 100,000, dropping in tiers after that. Business is $300 a month.
- Better Auth: an open-source TypeScript library that stores users in your own database. Free to run, with organizations and two-factor auth as plugins.
Clerk is the faster start and has the nicer prebuilt screens. Better Auth keeps your user table in your own Postgres, which is the point if leaving Supabase Auth was the reason you started reading.
Nhost and AWS Amplify
Nhost
Nhost is the closest thing to Supabase with GraphQL in front. It gives you Postgres, Hasura for an instant GraphQL API with permissions, auth, storage and functions. If your team already likes GraphQL and Hasura's permission model, it is a short move from Supabase because the data is still Postgres.
Pricing in November 2026: Starter is $0 with a 1 GB database, 1 GB of storage and 5 GB of egress, and free projects pause after a week of inactivity. Pro starts at $25 a month with $15 of compute credits, a 10 GB database, 50 GB of storage and 50 GB of egress. Nhost lists users as unlimited on every plan, so you do not pay per active user. The community is much smaller than Supabase's, which shows when you search for an answer at 11pm.
AWS Amplify
Amplify is AWS's front door for app teams. Gen 2 lets you define data, auth and functions in TypeScript, and it provisions DynamoDB, AppSync, Cognito, Lambda and S3 in your AWS account. It fits a company that already runs on AWS, needs its data in that account for compliance, or has an enterprise customer who asks for it.
Watch for the bill shape. Amplify Hosting has a 12-month free tier, then build minutes are $0.01, data served is $0.15 per GB, stored data is $0.023 per GB a month and server-side rendering is $0.30 per million requests. The backend services are billed separately at their own AWS rates. That is cheap at small sizes and hard to predict, and Cognito and DynamoDB both take real AWS knowledge to run well. I would not pick Amplify for a first product unless AWS is already a requirement.
Supabase Alternatives Side by Side
Entry prices are from each vendor's pricing page in November 2026. Paid start means the first paid tier, before usage.
- Supabase: Postgres. Free tier yes. Paid start $25 a month with one Micro compute. Self-host possible but heavy. Best at SQL plus everything in one dashboard.
- Firebase: Firestore documents. Free tier yes. Paid start is pay as you go on Blaze. No self-hosting. Best at mobile, offline sync and push.
- Convex: reactive document database. Free tier yes. Paid start $25 per developer a month. Open-source backend you can self-host. Best at live, collaborative screens.
- Appwrite: document database with relations. Free tier yes. Paid start $10 a month (Start) or $25 (Pro) per project. Self-host with Docker. Best at an all-in-one backend you can run yourself.
- PocketBase: SQLite. Free and open source. You pay for a server, often $5 to $10 a month. Self-host only. Best at prototypes and internal tools.
- Neon plus Clerk or Better Auth: Postgres. Free tiers on both. Paid start is usage based on Neon and $25 a month on Clerk Pro, or $0 with Better Auth. Postgres is portable to any host. Best at SaaS with complex permissions and no lock-in.
- Nhost: Postgres with Hasura GraphQL. Free tier yes. Paid start $25 a month. Open source and self-hostable. Best at GraphQL teams.
- AWS Amplify: DynamoDB through AppSync. AWS free tier for 12 months. Pay as you go with no minimum. Runs only on AWS. Best at companies already on AWS.
Reasons to Stay on Supabase
Most apps that come to us asking about Supabase alternatives should stay. Supabase gives you real Postgres, auth, storage, edge functions, vector search through pgvector and realtime in one place, at $25 a month for most early products. Nothing else on this list gives you all of that with SQL underneath.
Stay if your problem is one of these:
- The bill. Check your compute size and how many projects you run before you move. Many teams pay for a Medium instance they do not need, or for an old project nobody deleted.
- RLS policies. Write a policy plan, use helper functions with security definer for team membership, and add tests that try to read another tenant's rows. Or move permission checks into your own API and keep Supabase as the database.
- Auth lock-in. Supabase now accepts third-party auth from providers such as Clerk and Firebase Auth, and on November 17 it added custom OIDC providers from the dashboard. You can put Clerk in front and keep the database.
The tooling keeps moving too. On November 4 Supabase released CLI v3, which targets your local stack by default and asks for confirmation before it changes a hosted project. That is a breaking change, so pin v2 in CI until you have updated your scripts.
The honest test: if you can name the feature Supabase is stopping you from building, move. If you cannot, fix the setup and keep shipping.
Which One for Your Product
Here is how I would match real products to a pick.
- A collaborative app with live cursors and shared documents: Convex.
- A field service app that has to work with no signal: Firebase, for Firestore's offline cache.
- A B2B SaaS with organizations, roles and audit logs: Neon with Better Auth or Clerk, and your own API with Drizzle.
- An internal tool for a team of 30: PocketBase on a small VPS.
- A Flutter app where the client wants the backend on its own servers: Appwrite, self-hosted.
- A product sold to an enterprise that requires everything in its AWS account: Amplify Gen 2, or Postgres on RDS with Cognito if your team prefers SQL.
- A team that already writes GraphQL against Hasura: Nhost.
- A marketplace, a booking app or a typical SaaS MVP: stay on Supabase.
The backend is one decision in a longer list. If you are planning the whole product, our guide on how to build a SaaS platform covers the rest of the stack, the build order and the timeline.
Kanopy helps founders pick a stack and build the product on it. If you want a second opinion on your backend before you commit, bring it to the call. Book a free strategy call


