Supabase alternatives in 2026: 8 backends compared

The main Supabase alternatives in 2026 are instancez, self-hosted Supabase, Firebase, Appwrite, PocketBase, Nhost, Convex and Neon. They split along two lines: how much you have to run (one binary, a container stack, or nothing because it’s managed) and how you define the backend (a file, SQL migrations, TypeScript or a dashboard).

We build instancez, so it’s listed first. We kept every other entry to what each project’s own site and docs say, and linked those pages inline so you can check them. Facts were checked on October 31, 2026.

How did we judge them?

We asked two questions, because they’re the ones that matter once you’re past the first weekend. First, ops weight: what do you have to run to self-host it, and can you self-host it at all? Second, developer experience: where does the backend’s definition live, and can you read it, diff it and hand it to a coding agent?

We also noted license, database, realtime and client SDK, since one of those usually forces the decision.

Supabase alternatives at a glance

	Open source	Self-hosting	Database	Realtime	Client SDK	Backend defined in
instancez	Apache-2.0	One binary + your Postgres	Postgres	Not yet	@supabase/supabase-js	One instancez.yaml
Supabase (self-hosted)	Apache-2.0 / MIT	Docker Compose stack, community-supported	Postgres	Yes	@supabase/supabase-js	SQL migrations or declarative SQL schemas
Firebase	SDKs and CLI only	No (emulators are dev-only)	Firestore (NoSQL); Postgres via SQL Connect	Yes	Firebase SDKs	firebase.json + .rules files
Appwrite	BSD-3-Clause	Docker or Helm	Postgres (default), MariaDB or MongoDB	Yes (WebSockets)	Appwrite SDKs	appwrite.config.json
PocketBase	MIT	One executable	SQLite	Yes (SSE)	JS and Dart SDKs	Dashboard + JS migrations
Nhost	MIT	Docker Compose example	Postgres	GraphQL subscriptions	@nhost/nhost-js	nhost.toml
Convex	FSL Apache 2.0	Docker	Self-hosted: SQLite (default), Postgres or MySQL	Yes (reactive queries)	convex	TypeScript (convex/schema.ts)
Neon	Storage engine Apache-2.0	Managed only	Postgres	Not among its core capabilities	Per-capability packages	neon.ts

1. instancez

instancez is an open-source (Apache-2.0) backend written in Go. It’s one binary, inz, in front of Postgres. Tables, row-level security, auth, storage buckets, SQL RPC and JavaScript functions all live in one instancez.yaml:

version: 1

tables:
  todos:
    rls_enabled: true
    fields:
      - name: id
        type: bigserial
        primary_key: true
      - name: user_id
        foreign_key:
          references: auth.users.id
          on_delete: cascade
      - name: title
        type: text
        required: true
    rls:
      - operations: [select, insert, update, delete]
        using: "user_id = auth.uid()"
        with_check: "user_id = auth.uid()"

inz dev --embedded-pg runs it locally with an embedded Postgres and no Docker. instancez diffs the file against the database and applies only the change, so there are no migration files (how that works). It serves the Supabase HTTP API, so this is ordinary supabase-js:

import { createClient } from '@supabase/supabase-js'

const supabase = createClient('http://localhost:8080', process.env.INSTANCEZ_PUBLISHABLE_KEY)

const { data: { user } } = await supabase.auth.signUp({ email: '[email protected]', password: 'correct-horse-9' })
await supabase.from('todos').insert({ title: 'Ship it', user_id: user.id })
const { data } = await supabase.from('todos').select('id, title')

The same binary runs locally, in Docker, on a VM, on Kubernetes or on AWS Lambda (deploy docs). For production you bring Postgres and set INSTANCEZ_DATABASE_URL. There’s also instancez Cloud (inz cloud deploy), which runs the same software (pricing).

What it doesn’t do yet: Realtime and websockets, phone/SMS login, OAuth beyond Google, GitHub and Apple, image resizing beyond JPEG and PNG, and database branching. Functions run on Node.js, so Deno Edge Functions need porting. The full list is on /compare.

Good fit if you want Postgres, RLS and the supabase-js client with the whole backend in one reviewable file, and you’d like to self-host one process. If you’re coming from Supabase, see why teams switch and the migration guide.

2. Self-hosted Supabase

You can run Supabase itself on your own servers. The self-hosting docs call Docker “the fastest and recommended way”, using a Docker Compose file that starts Studio, the API gateway, auth, PostgREST, Realtime, storage, Postgres and more. It’s community-supported, runs a single project, and leaves out hosted features such as branching, managed backups and point-in-time recovery.

Schema changes go through SQL migration files from the CLI, or declarative schemas: SQL files under supabase/schemas/ that the CLI turns into migration files.

Good fit if you need the full Supabase feature set, Realtime included, on your own hardware, and you’re comfortable operating a multi-container stack. Our self-hosting comparison puts the two footprints side by side.

3. Firebase

Firebase is Google’s managed app platform. Its core database, Cloud Firestore, is a NoSQL document store, and clients get live updates with listeners: “You can listen to a document with the onSnapshot() method” (docs). For relational data there’s Firebase SQL Connect, formerly Data Connect, backed by Cloud SQL for PostgreSQL with a schema written in GraphQL (docs).

The client SDKs (Apache-2.0) and the CLI (MIT) are open source. The service itself isn’t something you self-host. The Local Emulator Suite is for development and is “not appropriate to use in production” (docs). Access control lives in .rules files tied to databases in firebase.json and deployed with the CLI (docs).

Good fit if you want a fully managed platform with document data and live listeners, and running servers isn’t something you want to own.

4. Appwrite

Appwrite is open source under BSD-3-Clause. It self-hosts with Docker, or on Kubernetes with an official Helm chart (docs). Since Appwrite 2.0, new installs default to PostgreSQL (announcement), with MariaDB and MongoDB as options picked at install time and fixed afterwards (docs). Realtime runs over WebSockets for client SDKs (docs).

The CLI keeps “project settings and resource definitions in one appwrite.config.json file”: tables, functions, teams, topics and buckets, optionally split across files (docs).

Good fit if you want a broad, self-hostable platform with realtime and official SDKs, and a Docker-based deployment suits you.

5. PocketBase

PocketBase (MIT) is one executable: download it and run ./pocketbase serve. It embeds SQLite, ships an admin dashboard, and can also be used as a Go framework (docs). Realtime uses Server-Sent Events for create, update and delete (docs). There are JavaScript and Dart SDKs.

Collections are usually defined in the dashboard. With --automigrate, on by default, “every collection configuration change from the Dashboard (or Web API) will generate the related migration file” in pb_migrations (docs).

Good fit if you want the lightest possible setup and SQLite fits your data, and you’re fine using PocketBase’s own API and SDKs.

6. Nhost

Nhost (MIT) pairs Postgres with a GraphQL API, auth, storage and Node.js functions. The GraphQL engine generates “queries, mutations, and live subscriptions” from your database, with row and column permissions, and it’s configured “through nhost.toml” (docs). Nhost’s own engine, Constellation, is in alpha as an opt-in that runs alongside Hasura (docs). The README says you can self-host the whole stack and points to an example docker-compose file. The JS SDK is @nhost/nhost-js.

Good fit if you want Postgres behind a GraphQL API with subscriptions, and you’d like to self-host or use their cloud.

7. Convex

Convex is a reactive backend. Queries are “automatically realtime”: Convex tracks what each query reads and pushes updates to subscribed clients (docs). Schemas are TypeScript, in convex/schema.ts (docs), and the client is the convex npm package (docs).

The backend is under the FSL Apache 2.0 license, a fair source license. Each release becomes Apache-2.0 two years after it’s published (docs). Self-hosting runs with Docker Compose and stores state in SQLite by default, or in Postgres or MySQL (guide).

Good fit if your team works in TypeScript end to end and live-updating queries are central to the app.

8. Neon

Neon is a managed Postgres company that now offers a backend: Postgres, object storage, functions, an AI gateway, managed Better Auth and a PostgREST-compatible Data API. They’re toggled in neon.ts, “your backend as code”, and deployed with neon deploy (docs). Each capability has its own package. Realtime isn’t one of the six capabilities; the docs list “Live SQL” as a next step. Neon’s storage engine is Apache-2.0, but the platform is a managed cloud.

Neon’s strength is branching: copy-on-write branches that include auth data and storage (docs).

Good fit if you want managed Postgres with per-branch preview environments and usage-based compute.

How do you narrow it down?

Start with the constraint you can’t move:

• If you must stay on Postgres and supabase-js, that’s instancez and self-hosted Supabase. The trade is breadth (Supabase has Realtime and more auth providers) against footprint (one binary versus a container stack).
• If you must self-host, instancez, Supabase, Appwrite, PocketBase, Nhost and Convex all can. Firebase and Neon are managed.
• Realtime ships today in Supabase, Firebase, Appwrite, PocketBase, Nhost and Convex. It’s on the instancez roadmap.
• If you want the backend reviewable as code, instancez (instancez.yaml), Appwrite (appwrite.config.json), Nhost (nhost.toml), Convex (TypeScript) and Neon (neon.ts) each keep part or all of it in code. How much of the backend that covers differs a lot. We go deeper in your whole backend in one YAML file.

If ops weight is the deciding factor, see how instancez self-hosts on a VPS, Docker or Kubernetes.

FAQ

Is there an open-source Supabase alternative that works with supabase-js? Yes. instancez serves the Supabase HTTP API (auth, PostgREST-style REST, RPC and storage), so @supabase/supabase-js works unchanged against it. It’s Apache-2.0.

Which Supabase alternatives can I self-host? instancez, Supabase itself, Appwrite, PocketBase, Nhost and Convex. Firebase and Neon are managed services.

Which alternatives use Postgres? instancez, Supabase, Nhost and Neon are built on Postgres. Appwrite defaults to it since 2.0, Convex can store its data in it when self-hosted, and Firebase offers it through SQL Connect.

Does instancez support Realtime? Not yet. It covers REST, auth, storage, RPC and functions. Realtime is on our roadmap.