# Convex alternative with SQL and no per-developer price

> Convex is a reactive backend where queries are TypeScript functions over its own document database, priced per developer on Professional. Scribase is Postgres with SQL, auth, storage and realtime, priced per project. Which fits, with sources.

Source: https://scribase.com/convex-alternative

Convex stores JSON-like documents and you query them with TypeScript functions; every query is reactive without extra work. The price for that is a database only Convex runs, and a Professional plan billed per developer. Scribase is Postgres 17 with SQL, auth, storage, realtime and edge functions, billed per project. Pick Scribase when you want standard SQL and a database you can move. Stay on Convex when automatic reactivity is the main thing you are buying.

## The short answer

- Pick Scribase when you want SQL, joins, Postgres extensions and a database every Postgres tool understands.
- Pick Scribase when the team is growing and you do not want the bill to follow the number of developers.
- Stay on Convex when you want every query to update the UI on its own, with the whole backend written as TypeScript functions and transactions handled for you.

## Convex and Scribase, side by side

_Convex facts read on convex.dev 2026-11-17_

|  | Convex | Scribase |
| --- | --- | --- |
| Database | Its own database: a relational data model that stores JSON-like documents | Postgres 17 |
| How you query | JavaScript or TypeScript query functions. No SQL. | SQL, plus a REST API that supabase-js calls |
| Live updates | Every query is reactive by default | Realtime: subscribe to table changes, broadcast and presence. You choose what to subscribe to. |
| Server code | Queries, mutations and actions deployed with the database | Edge functions, SQL functions, pg_cron schedules and pgmq queues |
| Auth and files | Convex Auth and file storage | Built-in auth and storage, both enforced by row level security |
| Free plan | 1M function calls, 0.5 GB database storage and 1 GB file storage | 1 project free with no time limit (0.5 GB database, 1 GB files, no card) |
| Paid | Professional: $25 per developer a month, with 25M function calls, 50 GB database storage and 100 GB file storage included | Hobby $5 a project a month, Pro $25. No per-developer price. |
| Taking your data elsewhere | Export, then reshape for another database | A standard Postgres dump any Postgres host can load |

## Sources

- [Convex: Pricing](https://www.convex.dev/pricing)
- [Convex docs: Database](https://docs.convex.dev/database)
- [Scribase: Pricing](https://scribase.com/pricing)

## How the bill grows

Convex Professional is priced per developer: a team of 4 pays 4 x $25 = $100 a month before usage. Scribase is priced per project: the same team with one production project on Pro pays $25 a month, and each further project is $5 on Hobby or $25 on Pro.

The comparison turns around when one or two developers run many projects: per-developer pricing is then the cheaper model. Count your developers and your projects before choosing.

## Sources

- [Convex: Pricing](https://www.convex.dev/pricing)
- [Scribase: Pricing](https://scribase.com/pricing)

[See Scribase pricing](https://scribase.com/pricing)

## What the code looks like

On Scribase you query from the client with supabase-js or write SQL. Live updates are a subscription you open on the tables you care about.

_Creates the backend and writes the URL and anon key into your .env file_

```sh
npx scribase init
```

_Read rows, then subscribe to changes_

```ts
import { createClient } from '@supabase/supabase-js';

const db = createClient(process.env.NEXT_PUBLIC_SCRIBASE_URL!, process.env.NEXT_PUBLIC_SCRIBASE_ANON_KEY!);

const { data: messages } = await db.from('messages').select('*').order('created_at');

db.channel('messages')
  .on('postgres_changes', { event: '*', schema: 'public', table: 'messages' }, (change) => {
    // update your UI state here
  })
  .subscribe();
```

## Moving from Convex

There is no Convex importer, and the move is a rewrite, not a URL change. Tables become SQL tables, document references become foreign keys, query and mutation functions become SQL or client calls, and useQuery hooks become a fetch plus a realtime subscription. Budget for it honestly; for a large Convex app this is weeks of work.

[Talk to us about a move](https://scribase.com/contact)

## What Scribase does not do

- Queries are not reactive by default. You subscribe to changes and update state yourself.
- No end-to-end TypeScript types generated from server functions the way Convex does.
- One region today (Frankfurt). If your users or your compliance rules need another region, this is not the right host yet.
- Direct Postgres connections from the internet (ports 5432 and 6543, for psql or pg_restore) are not open yet. Migrations, the console SQL editor and the HTTP serverless driver work today.
- No compliance certifications yet (no SOC 2, no HIPAA BAA).
- The core is not open source. You can export everything, and a licensed self-hosted deployment exists, but you cannot clone the server from a public repository.

## FAQ

**What is a good Convex alternative with SQL?**

A Postgres backend such as Scribase or Supabase. Both give you SQL, joins and row level security with auth, storage and realtime on top. Scribase is priced per project with no per-developer fee and keeps one project free with no time limit.

**Does Convex support SQL?**

Convex queries are written as JavaScript or TypeScript functions. Its docs say there is "no need to write any SQL" and describe the database as a relational data model that stores JSON-like documents.

**How much does Convex cost?**

As of 2026-11-17, the Convex free plan includes 1M function calls, 0.5 GB of database storage and 1 GB of file storage. Professional is $25 per developer a month with 25M function calls, 50 GB of database storage and 100 GB of file storage included, then usage-based overage.

**Does Scribase have realtime like Convex?**

It has realtime, but it works differently. On Scribase you subscribe to Postgres table changes, broadcast messages or presence, and update your UI when an event arrives. Convex re-runs every query automatically. If automatic reactivity is the reason you chose Convex, Convex is the better fit.

**Can I migrate from Convex to Scribase automatically?**

No. There is no Convex importer. You recreate tables in SQL, export and load the data, and rewrite query and mutation functions as SQL or client calls.

## Related

- [Backend as a service compared](https://scribase.com/backend-as-a-service)
- [Firebase alternative](https://scribase.com/firebase-alternative)
- [Supabase alternative](https://scribase.com/supabase-alternative)
- [One backend instead of four vendors](https://scribase.com/one-backend)
- [Pricing](https://scribase.com/pricing)