Convex Alternatives: SQL and Realtime Without Per-Seat Pricing

The main Convex alternatives are Postgres backends with realtime (StitchDB and Supabase), document backends (Firebase and Appwrite) and self-hosted PocketBase. People usually switch from Convex for one of three reasons: they want plain SQL access to their data, they want pricing that does not scale with the number of developers, or they want to use the backend from languages and tools outside the TypeScript world. Each Convex alternative below handles reactivity differently, so that is the lens of this comparison.

#What Convex does well

It is worth being precise about what you would give up. Convex stores documents in tables with an optional schema, and you write queries and mutations as TypeScript functions that run next to the data. The client does not subscribe to tables; it subscribes to a query function. Convex tracks which data each query read and pushes a new result when that data changes, and its docs say every subscription is updated to the same database snapshot at the same time. That consistency is genuinely hard to rebuild yourself.

Convex pricing (as of November 2026): Free & Starter includes 1M function calls, 0.5 GB of database storage, 1 GB of bandwidth and 1 GB of file storage, with pay-as-you-go above that. Professional is $25 per developer per month with 25M function calls and 50 GB of database storage. Business & Enterprise has a $2,500 monthly minimum. Source: convex.dev/pricing. The backend is open source under FSL Apache 2.0 and can be self-hosted.

#Convex alternatives at a glance

#How you rebuild "reactive queries" on Postgres

On a Postgres backend, the database publishes row changes and the client listens. The difference from Convex is that you subscribe to a table (optionally filtered), not to a query result, so you update your local state yourself.

Here is the StitchDB version, which is the same API as supabase-js:

import { createClient } from 'stitchdb-js'

const stitchdb = createClient('https://<project-ref>.p.stitchdb.com', '<anon-key>')

// Initial load
const { data: messages } = await stitchdb
  .from('messages')
  .select('id, body, created_at')
  .eq('room_id', roomId)
  .order('created_at')

// Then follow changes for this room only
stitchdb
  .channel('room-' + roomId)
  .on('postgres_changes',
      { event: 'INSERT', schema: 'public', table: 'messages', filter: 'room_id=eq.' + roomId },
      (p) => messages.push(p.new))
  .subscribe()

First publish the table with alter publication stitchdb_realtime add table public.messages;. Row level security decides which changes each subscriber receives, so a user only gets rows their policies let them read. See Postgres changes.

This is more code than a Convex useQuery. In exchange you get a schema with constraints and foreign keys, SQL for reporting, and data any Postgres tool can read.

#The alternatives in detail

#StitchDB

StitchDB gives each project its own Postgres database with Auth, REST and GraphQL APIs, Realtime, Storage and Deno Edge Functions. For Convex users a few pieces matter most:

• Server functions in TypeScript. Edge Functions are Deno.serve handlers with npm and JSR imports. Postgres functions can also be called from the client with rpc().
• Durable background jobs. Background jobs run multi-step work where each step is saved, failed steps retry and runs can sleep for days, similar in spirit to Convex's scheduled functions, and cron covers Convex-style cron jobs.
• Offline sync. Offline sync keeps a local copy of chosen tables, queues writes while offline and applies a per-table conflict rule.
• Generated types. stitchdb gen types generates TypeScript, Dart, Swift or Kotlin types from the schema, and stitchdb types --watch keeps a file current.
• Flat pricing. Free $0, Pro $15.99/month, Scale $49/month (as of November 2026). Team members are not billed per seat: Pro includes 10, Scale 100.

Trade-offs: no automatic query-level reactivity like Convex; you wire up subscriptions per table. Regions are EU-only (Germany and Finland). There is no self-hosted edition, while Convex can be self-hosted.

#Supabase

Supabase offers the same Postgres-plus-realtime model, 17 AWS regions and self-hosting with Docker. Free projects pause after a week of inactivity; Pro is from $25/month per organization (as of November 2026). See Supabase vs Convex.

#Firebase

Firestore listeners are the closest thing to Convex's reactivity in a document database: you attach a listener to a query and get updated snapshots. You lose Convex's TypeScript function model and transactional mutations as server code; you gain mature offline SDKs and Google Cloud. Cloud Functions and Cloud Storage require the Blaze pay-as-you-go plan.

#Appwrite

Appwrite has realtime events on its tables and documents, open source self-hosting (BSD 3-Clause) and functions in many languages. Pricing per project: Free, Start from $10 and Pro from $25 a month (as of November 2026).

#PocketBase

PocketBase gives realtime subscriptions to records from a single Go binary on your own server. It suits small apps; its FAQ says it scales on one server only.

#Moving data out of Convex

Convex can export your data as a zip file, from a backup in the dashboard or with npx convex export --path ~/Downloads. A practical path to Postgres:

1. Export the zip and unpack it. It holds the documents of each table.
2. Design tables. Document references become uuid or text foreign keys. Nested objects that you query on become columns; the rest can stay in a jsonb column.
3. Load each table into a staging table, then cast it into the real one:

create table import_tasks (doc jsonb);
-- from psql (the odd quote and delimiter keep JSON backslashes intact):
-- \copy import_tasks (doc) from 'tasks.jsonl' csv quote e'\x01' delimiter e'\x02'

insert into public.tasks (id, title, done, owner_id)
select doc->>'_id', doc->>'title', (doc->>'done')::boolean, doc->>'owner'
from import_tasks;

(If a file holds one JSON array instead of one document per line, convert it to one line per document first, for example with jq -c '.[]'.)

4. Rewrite query functions as SQL views, RLS policies and a few Edge Functions.
5. Replace useQuery with an initial select plus a Realtime subscription, as above.

#Who should pick what

• Small TypeScript team that loves reactive queries: stay on Convex.
• You want SQL and flat pricing as the team grows: StitchDB.
• You want SQL and self-hosting: Supabase.
• Mobile app with heavy offline use and Google services: Firebase.

For a direct comparison, see StitchDB vs Convex.

#FAQ

#Is Convex a SQL database?

Convex describes a relational data model, but you do not write SQL; queries are TypeScript functions. If you need SQL, use a Postgres backend.

#Can I self-host Convex?

Yes. Self-hosted Convex runs the open-source backend under FSL Apache 2.0 and uses SQLite by default, or Postgres or MySQL.

#Does Supabase or StitchDB have reactive queries like Convex?

Not at the query level. Both stream row changes from tables, filtered and checked against row level security. You merge the changes into your state.

#Is Convex pricing per developer?

Professional is $25 per developer per month as of November 2026. The free tier allows 1 to 6 developers.

Try Postgres with realtime and flat pricing: start free on StitchDB.