Convex vs the alternatives

Convex ships fastest but is among the hardest to leave; Supabase, Nhost and Neon keep your data in ordinary Postgres.

Providers
11
Fields compared
26
Source confidence
42%
Last verified
2026-07-20 (2mo ago)
Re-verified
every 30 days
Data confidence0% of 266 figures verified in the last 30d
113sourced of 266107stale, oldest 2mo ago
11 tools · verified 2mo ago
Supabase logoSupabaseManaged Postgres with auth, storage, realtime and edge functions around it.74.6

Features

Reactivity
push
TS inference
Partial
Transactions
mvcc
Local-first sync
No
Optimistic writes
No
Cron & scheduling
Yes
File storage
Yes
Vector search
Yes
Full-text search
Yes
Auth
built-in
Hard limits
Postgres limits apply: about 1 GB per field, no vendor row cap. The real ceilings are connection count and the compute tier you pay for.
Cold start (ms)
250ms
Function timeout (ms)
2.5min

Portability & exit

Exit cost
2
Self-hostable
Yes
Bulk export
Yes
Raw SQL
Yes
Schema changes
sql-migrations

Agentic

MCP server
Yes
Agent fit
4

Pricing

Pricing model
flat per org + compute + usage
Entry price (/mo)
$25/mo
Egress metered
Yes

Traction

GitHub stars
90,000
Backing
venture-backed

Positioning

Positioning
The Postgres development platform, the open-source Firebase alternative.
Nhost logoNhostPostgres plus Hasura GraphQL, auth, storage and serverless functions.72.0

Features

Reactivity
push
TS inference
Partial
Transactions
mvcc
Local-first sync
No
Optimistic writes
No
Cron & scheduling
Yes
File storage
Yes
Vector search
Yes
Full-text search
Yes
Auth
built-in
Hard limits
Postgres limits, plus Hasura's own query-depth and rate limiting on the managed tiers.
Cold start (ms)
Function timeout (ms)
·

Portability & exit

Exit cost
2
Self-hostable
Yes
Bulk export
Yes
Raw SQL
Yes
Schema changes
sql-migrations

Agentic

MCP server
Yes
Agent fit
3

Pricing

Pricing model
flat per project + usage
Entry price (/mo)
$25/mo
Egress metered
Yes

Traction

GitHub stars
8,000
Backing
venture-backed

Positioning

Positioning
The open-source Firebase alternative, with GraphQL.
Zero logoZeroSync engine that puts a queryable client cache in front of your own Postgres.70.9

Features

Reactivity
push
TS inference
Yes
Transactions
mvcc
Local-first sync
Yes
Optimistic writes
Yes
Cron & scheduling
No
File storage
No
Vector search
Partial
Full-text search
Partial
Auth
bring-your-own
Hard limits
Client cache size is the practical ceiling, the query set you sync has to fit on the device.
Cold start (ms)
Function timeout (ms)

Portability & exit

Exit cost
3
Self-hostable
Yes
Bulk export
Yes
Raw SQL
Yes
Schema changes
sql-migrations

Agentic

MCP server
No
Agent fit
3

Pricing

Pricing model
free (self-host)
Entry price (/mo)
$0/mo
Egress metered
No

Traction

GitHub stars
3,000
Backing
venture-backed

Positioning

Positioning
A general-purpose sync engine for the web.
PocketBase logoPocketBaseOne Go binary: SQLite database, auth, file storage, realtime and an admin UI.66.6

Features

Reactivity
push
TS inference
Partial
Transactions
serialisable
Local-first sync
No
Optimistic writes
No
Cron & scheduling
Partial
File storage
Yes
Vector search
No
Full-text search
Partial
Auth
built-in
Hard limits
One machine. SQLite tops out near a billion bytes per value and a single concurrent writer; everything else is your disk and RAM.
Cold start (ms)
0ms
Function timeout (ms)

Portability & exit

Exit cost
3
Self-hostable
Yes
Bulk export
Yes
Raw SQL
Yes
Schema changes
declarative-push

Agentic

MCP server
No
Agent fit
3

Pricing

Pricing model
free (self-host only)
Entry price (/mo)
$0/mo
Egress metered
No

Traction

GitHub stars
48,000
Backing
solo-maintainer

Positioning

Positioning
Open-source backend in one file.
Convex logoConvexReactive TypeScript backend: database, functions and live queries in one project.65.5

Features

Reactivity
push
TS inference
Yes
Transactions
occ
Local-first sync
No
Optimistic writes
Yes
Cron & scheduling
Yes
File storage
Yes
Vector search
Yes
Full-text search
Yes
Auth
first-party-addon
Hard limits
1 MiB per document; roughly 16k documents or 8 MiB scanned per query; queries and mutations capped near 1s of compute.
Cold start (ms)
0ms
Function timeout (ms)
10min

Portability & exit

Exit cost
4
Self-hostable
Yes
Bulk export
Yes
Raw SQL
No
Schema changes
declarative-push

Agentic

MCP server
Yes
Agent fit
5

Pricing

Pricing model
per-seat + usage
Entry price (/mo)
$25/mo
Egress metered
Yes

Traction

GitHub stars
8,000
Backing
venture-backed

Positioning

Positioning
The open-source reactive database for app developers.
ElectricSQL logoElectricSQLPostgres read-path sync: stream subsets of your own database to clients over HTTP.62.0

Features

Reactivity
push
TS inference
Partial
Transactions
mvcc
Local-first sync
Partial
Optimistic writes
Partial
Cron & scheduling
No
File storage
No
Vector search
Partial
Full-text search
Partial
Auth
bring-your-own
Hard limits
Shape size, a shape has to be small enough to hold on the client and cheap enough to re-materialise on the server.
Cold start (ms)
Function timeout (ms)

Portability & exit

Exit cost
2
Self-hostable
Yes
Bulk export
Yes
Raw SQL
Yes
Schema changes
sql-migrations

Agentic

MCP server
No
Agent fit
2

Pricing

Pricing model
free (self-host) + optional cloud
Entry price (/mo)
Egress metered
Partial

Traction

GitHub stars
8,000
Backing
venture-backed

Positioning

Positioning
Postgres sync engine, sync little subsets of your data into local apps.
Neon + Drizzle logoNeon + DrizzleThe DIY baseline: serverless Postgres, a typed SQL query builder, nothing else.60.5

Features

Reactivity
manual
TS inference
Yes
Transactions
mvcc
Local-first sync
No
Optimistic writes
No
Cron & scheduling
No
File storage
No
Vector search
Yes
Full-text search
Yes
Auth
bring-your-own
Hard limits
Postgres limits. The operational ceiling is your compute size and connection count, both dials you control.
Cold start (ms)
500ms
Function timeout (ms)

Portability & exit

Exit cost
1
Self-hostable
Partial
Bulk export
Yes
Raw SQL
Yes
Schema changes
sql-migrations

Agentic

MCP server
Yes
Agent fit
4

Pricing

Pricing model
flat + compute-hours + storage
Entry price (/mo)
$19/mo
Egress metered
Partial

Traction

GitHub stars
18,000
Backing
big-tech

Positioning

Positioning
Serverless Postgres with branching, paired with a typed SQL query builder.
InstantDB logoInstantDBClient-side reactive database with a relational graph model and instant sync.57.8

Features

Reactivity
push
TS inference
Yes
Transactions
occ
Local-first sync
Yes
Optimistic writes
Yes
Cron & scheduling
No
File storage
Yes
Vector search
No
Full-text search
No
Auth
built-in
Hard limits
Cold start (ms)
Function timeout (ms)

Portability & exit

Exit cost
4
Self-hostable
Partial
Bulk export
Partial
Raw SQL
No
Schema changes
declarative-push

Agentic

MCP server
Yes
Agent fit
4

Pricing

Pricing model
flat + usage
Entry price (/mo)
$30/mo
Egress metered
Unknown

Traction

GitHub stars
9,000
Backing
venture-backed

Positioning

Positioning
A modern Firebase, a client-side database that syncs.
Appwrite logoAppwriteOpen-source backend platform: databases, auth, storage, functions, self-hostable.54.6

Features

Reactivity
push
TS inference
Partial
Transactions
none
Local-first sync
No
Optimistic writes
No
Cron & scheduling
Yes
File storage
Yes
Vector search
No
Full-text search
Partial
Auth
built-in
Hard limits
Attribute count per collection is bounded by the underlying MariaDB row width, wide documents fail at creation time rather than at scale.
Cold start (ms)
1s
Function timeout (ms)
15min

Portability & exit

Exit cost
3
Self-hostable
Yes
Bulk export
Partial
Raw SQL
No
Schema changes
declarative-push

Agentic

MCP server
Yes
Agent fit
3

Pricing

Pricing model
per-seat + usage
Entry price (/mo)
$15/mo
Egress metered
Yes

Traction

GitHub stars
52,000
Backing
venture-backed

Positioning

Positioning
Build like a team of hundreds, an open-source backend platform.
Firebase logoFirebaseGoogle's app platform: Firestore documents, auth, functions, deep mobile SDKs.51.2

Features

Reactivity
push
TS inference
No
Transactions
occ
Local-first sync
Partial
Optimistic writes
Yes
Cron & scheduling
Yes
File storage
Yes
Vector search
Yes
Full-text search
No
Auth
built-in
Hard limits
1 MiB per document; about one sustained write per second per document; 500 operations per transaction; no joins.
Cold start (ms)
2s
Function timeout (ms)
60min

Portability & exit

Exit cost
5
Self-hostable
No
Bulk export
Partial
Raw SQL
No
Schema changes
schemaless

Agentic

MCP server
Yes
Agent fit
2

Pricing

Pricing model
usage only (Blaze pay-as-you-go)
Entry price (/mo)
$0/mo
Egress metered
Yes

Traction

GitHub stars
Backing
big-tech

Positioning

Positioning
Google's platform for building and running app backends.
TriplitFull-stack database that syncs: local cache, server, relational queries, offline.50.4

Features

Reactivity
push
TS inference
Yes
Transactions
occ
Local-first sync
Yes
Optimistic writes
Yes
Cron & scheduling
No
File storage
No
Vector search
No
Full-text search
No
Auth
bring-your-own
Hard limits
Cold start (ms)
Function timeout (ms)
·

Portability & exit

Exit cost
4
Self-hostable
Yes
Bulk export
Partial
Raw SQL
No
Schema changes
declarative-push

Agentic

MCP server
No
Agent fit
3

Pricing

Pricing model
Entry price (/mo)
Egress metered
Unknown

Traction

GitHub stars
4,000
Backing
venture-backed

Positioning

Positioning
The full-stack database that syncs.
yespartialnounknown
Sources shown beside each value · Learn how sourcing works
measured vendor-claimed community inferredExpand any row for the source, verification date, and caveat behind every cell.

Where each one wins

  • Teams that need raw SQL, BI tooling or a third-party ORM against the same data
  • Anyone who wants a credible migration path off the platform from day one
  • Projects already comfortable with Postgres row-level security

Managed convenience without giving up your database; the seams show, but pg_dump is a complete exit.

Nhost

72.0
  • Teams already committed to GraphQL and Hasura
  • Projects wanting managed convenience with a fully open stack underneath
  • Anyone who wants Supabase's portability but prefers subscriptions to change feeds

An underrated exit: Postgres plus open-source Hasura both survive leaving, if you like GraphQL and quiet projects.

Zero

70.9
  • Teams with an existing Postgres who want a UI that feels local
  • Apps where snappy reads matter but ownership of the data model is non-negotiable
  • Adding sync incrementally rather than rewriting onto a backend platform

Instant local reads without surrendering the database; a layer, not a platform, that you operate yourself.

  • Internal tools and side projects where one VPS is plenty
  • Anyone who wants the entire backend to be a file they can copy
  • Air-gapped or on-premises deployments

Absurd value for single-machine workloads with the easiest extraction here; the ceiling is one writer, one box.

Convex

65.5
  • Small teams shipping realtime-shaped product fast
  • Codebases where a coding agent does most of the plumbing
  • Apps whose lifespan is short enough that the exit never arrives

Fastest empty-repo-to-realtime path here, but a 4 on exit cost with no SQL escape hatch.

  • Existing Postgres apps that need live read data without a rewrite
  • Teams that already have a write API they are happy with
  • Anyone who wants sync without adopting a backend platform

The narrowest, best-behaved tool: read-path sync over your own Postgres with an exit close to free.

  • Teams that already know what backend they want to build
  • Applications expected to outlive several vendor relationships
  • Anyone whose realtime requirement is smaller than it first appeared

Not a competitor, the yardstick: you build everything yourself, but nothing you build is owned by anyone else.

  • Multiplayer or collaborative UIs where every interaction must feel local
  • Front-end-heavy teams with no appetite for backend infrastructure
  • Prototypes that need presence, cursors and live editing on day one

The most pleasant DX for instant collaborative UIs; the missing server-side runtime is the constraint people hit.

  • Teams that must run the whole backend on their own infrastructure
  • Apps with many client platforms, the SDK matrix is the broadest here
  • Products where auth provider breadth matters more than query power

The most complete self-hostable option, held back by console-first schema and the weakest transaction story here.

  • Consumer mobile apps where offline behaviour is the product
  • Teams already inside Google Cloud with the operational habits to match
  • Prototypes that will be thrown away rather than migrated

Best offline story and mobile SDKs, worst exit on the page; fine only if you never migrate.

  • Offline-first apps that need relational queries rather than document blobs
  • Teams happy to supply their own auth and file handling
  • Projects where sync correctness matters more than ecosystem size

The most elegant local-first model here, but the smallest team, with no storage, auth or functions.

What are the best alternatives to Convex, and how hard is each one to leave?

  • ConvexConvex logo wins the thing it claims: fastest path to a working realtime feature
  • One TypeScript project holds schema, server functions and client types
  • Queries reactive by default, no subscription plumbing
  • Mutations transactional, no connection pool to manage
  • Best fit for a coding agent: whole surface is typed and in-repo
  • Optimistic concurrency with automatic retries makes serialisable writes the boring default
  • The cost is not price or limits, it is total lock-in
  • Every read and write goes through ConvexConvex logo's query builder, runtime and reactivity
  • There is no SQL to port
  • Leaving means rewriting the data layer plus the render model on top
  • Self-hosting bounds vendor risk, not exit cost, self-hosted ConvexConvex logo is still ConvexConvex logo
  • Score the exit honestly before you start
  • SupabaseSupabase logo gets most of the productivity for a fraction of the exit cost
  • Data is PostgresPostgreSQL logo, queries are SQL or PostgREST, pg_dump is a complete escape hatch
  • Trade-off is coherence: auth, storage, realtime and edge functions are four stitched products
  • Realtime is a change feed, not a reactive query, and types come from a CLI step
  • NhostNhost logo is the same trade with Hasura GraphQL instead of PostgREST, worth a look if GraphQL is in your stack
  • The interesting movement is at the sync layer
  • ElectricSQLElectricSQL logo and Zero both refuse to own your database
  • Electric streams read shapes out of PostgresPostgreSQL logo over HTTP, leaving writes to your API
  • Zero puts a query-shaped client cache in front of PostgresPostgreSQL logo with server-side mutators
  • You adopt a sync engine, not a backend, so they score 2 and 3 on exit cost
  • They deliver local-first behaviour ConvexConvex logo lacks entirely
  • But they are younger, thinner on batteries (no storage, auth or cron)
  • FirebaseFirebase logo is the cautionary tale at the other end
  • Only entry with no self-host path and a proprietary rules language
  • Export format only Firestore can read
  • Document model quietly shapes your schema around its query limits
  • Still the deepest mobile SDKs and Google's operational record
  • Defensible for a consumer mobile app that will never migrate
  • The worst deal for anything you expect to change in five years

What exit cost actually measures

  • Every vendor says your data is yours; that is true and not the question
  • Data extraction is a weekend for nine of these eleven
  • Rewriting the two thousand call sites that read that data is not
  • The ladder is about code, not bytes
  • Rung 1: standard SQL over the wire, leaving is a connection string
  • Rung 2: standard engine behind a vendor SDK, schema and queries port but auth, storage and realtime call sites get rewritten
  • Rung 3: proprietary API over an open self-hostable engine, data leaves cleanly but every read and write is vendor-shaped
  • Rung 4: adds a proprietary function runtime, so queries, mutations, subscriptions and the render model all go
  • Rung 5: rung 4 with no self-host and no self-serve export, making even the data a project
  • Open source does not lower the score by itself
  • AppwriteAppwrite logo, PocketBasePocketBase logo and ConvexConvex logo are all open source and all sit at 3 or 4
  • The licence governs who may run the server, not who rewrites the client
  • Sync engines score unusually well for their age, sitting beside a PostgresPostgreSQL logo you already control

Where the pricing hides

  • Sticker prices cluster between $15 and $30 a month and tell you almost nothing
  • Three mechanics decide the real bill
  • Per-seat pricing: ConvexConvex logo and AppwriteAppwrite logo charge per member on top of usage
  • A five-person team starts at five times the headline before a function runs
  • SupabaseSupabase logo charges per organisation; FirebaseFirebase logo charges nothing up front
  • On small teams this is usually the largest line and does not shrink when you optimise
  • Bandwidth: ConvexConvex logo, SupabaseSupabase logo, FirebaseFirebase logo, AppwriteAppwrite logo and NhostNhost logo meter egress separately
  • Reactive backends push on every change, so a chatty subscription is a bandwidth line, not a CPU one
  • Easy to miss when modelling costs against requests per second
  • Check what live queries re-send when one row changes
  • Idle: FirebaseFirebase logo, ConvexConvex logo and Neon cost approximately nothing when unused
  • A SupabaseSupabase logo Pro project bills compute by the hour regardless of traffic
  • Anything self-hosted bills you for the machine
  • For side projects and staging this dominates everything else

Realistic migration paths

  • ConvexConvex logo to PostgresPostgreSQL logo is the hard one, plan it before you need it
  • npx convex export gives a zip of JSONL per table that loads into PostgresPostgreSQL logo cleanly enough
  • The work is in the application
  • Put a repository layer between your components and ConvexConvex logo early, so reactive queries become one seam not hundreds
  • Do it while the app is small; retrofitting later is most of the migration cost
  • FirebaseFirebase logo to anything starts with the export format, the one genuinely closed artefact here
  • The managed Firestore export writes a format only Firestore imports
  • In practice you paginate collections through the Admin SDK and write your own JSON
  • Fine at gigabytes, painful at terabytes
  • Budget separately for translating security rules into row-level security or middleware
  • SupabaseSupabase logo to plain PostgresPostgreSQL logo is the easy case and the reference point
  • pg_dump, restore anywhere, replace supabase-js with your query builder, replace GoTrue with an auth provider
  • Weeks, not quarters, and that gap is the entire content of the exit-cost column
  • Adding a sync engine later is the underrated option
  • Electric and Zero sit beside PostgresPostgreSQL logo rather than replacing it
  • "Start on Neon and Drizzle, add Zero when the UI needs to feel instant" is a real sequence, not a rewrite
  • None of the all-in-one platforms support that shape

What is convex vs alternatives: reactive backend platforms compared?

Convex vs alternatives: reactive backend platforms compared

On toolweight, ConvexConvex logo vs alternatives: reactive backend platforms compared means the 11 tools benchmarked on this page, ConvexConvex logo, SupabaseSupabase logo, FirebaseFirebase logo, AppwriteAppwrite logo, PocketBasePocketBase logo, InstantDBInstantDB logo, NhostNhost logo, Triplit, Zero, ElectricSQLElectricSQL logo, Neon + DrizzleNeon + Drizzle logo, judged on the same 26 fields, from the same sources, on the same date. The question it exists to answer: What are the best alternatives to ConvexConvex logo, and how hard is each one to leave?

How does toolweight compare these?

  • Every cell written from vendor docs, pricing pages and hands-on SDK knowledge, then tagged with provenance
  • vendor-claimed cells come off a specific docs or pricing URL, dated to when last plausibly true
  • inferred cells are judgement calls or values reasoned from adjacent facts
  • Where a fact is genuinely unpublished, the cell is null and renders as an em dash rather than a guess
  • Prices are the lowest paid tier, monthly, in USD, excluding usage
  • Exit cost is the field this page exists for
  • A 1-5 judgement score, lower is better
  • Measures one thing: how much application code you rewrite to leave, assuming data is already extracted
  • Deliberately ignores how good, how cheap, or how likely to survive the platform is
  • A high score is not a verdict against a tool, it is the size of the bet you are placing
  • The five rungs are defined in the column tooltip; each score's reasoning sits in that tool's cell note
Full methodology and sourcing policy →
Cite this comparisonCC-BY-4.0 · verified 2026-07-20

Convex ships fastest but is among the hardest to leave; Supabase, Nhost and Neon keep your data in ordinary Postgres. — toolweight, https://toolweight.com/compare/convex-alternatives, verified 2026-07-20. Data from toolweight (https://toolweight.com), licensed CC-BY-4.0.

Frequently asked questions

Is Convex a good idea if I might need to leave later?

  • Only if you price the exit now
  • No SQL surface, so every query, mutation and subscription is rewritten on the way out
  • The reactive render model has no drop-in equivalent
  • Scores 4 of 5 on our exit-cost ladder
  • If the codebase may outlive the decision and you are unsure, start on PostgresPostgreSQL logo

Does self-hosting Convex remove the lock-in?

  • No, it removes vendor risk, a different problem
  • convex-backend is open under FSL-1.1-Apache-2.0 with documented self-hosting, so ConvexConvex logo disappearing cannot strand you
  • But self-hosted ConvexConvex logo still speaks the ConvexConvex logo query API
  • The cost of moving to something that is not ConvexConvex logo is unchanged
  • Exit cost and vendor risk are separate columns for a reason

Supabase or Convex for a new TypeScript app?

  • ConvexConvex logo if the app is realtime-shaped and the team is small: faster first version, no subscription plumbing
  • SupabaseSupabase logo if you want data in PostgresPostgreSQL logo, need raw SQL, or expect BI tools to read the same database
  • The productivity gap is real but narrowing
  • The portability gap is not narrowing at all

What is the actual difference between Zero and ElectricSQL?

  • Direction and scope
  • Electric streams read-only shapes out of PostgresPostgreSQL logo over HTTP, says nothing about writes, you keep your own API
  • Zero syncs queries into a client cache and handles writes through custom mutators against your PostgresPostgreSQL logo
  • Zero owns more of the loop
  • Electric is the smaller commitment; Zero gives more in return

Is Firebase still a reasonable default in 2026?

  • For consumer mobile apps that will never migrate, yes: SDKs, offline persistence and Google's operations are hard to beat
  • For anything else it is the worst exit on this page
  • No self-host, a proprietary rules language, an export format only Firestore reads
  • A document model that shapes your schema around its query engine
  • Choose it deliberately, not by habit

Which of these is genuinely local-first?

  • InstantDBInstantDB logo, Triplit and Zero, with ElectricSQLElectricSQL logo covering the read half
  • All four keep a real client-side store, resolve queries locally and reconcile with the server
  • FirebaseFirebase logo's offline persistence gets close for simple cases
  • ConvexConvex logo and SupabaseSupabase logo are not local-first: fast realtime backends with optimistic-update helpers
  • That is a different guarantee once the network is gone

How should a small team weight exit cost against speed?

  • By expected lifespan
  • Under twelve months and pre-product-market-fit, exit cost is nearly free and speed is everything: take ConvexConvex logo or Instant
  • Past that, rewriting a data layer costs engineer-months and the PostgresPostgreSQL logo options claw it back
  • ConvexConvex logo charges its fee at the end, in one payment, and you cannot pay it early