Summary: A serverless Postgres is still Postgres. Compute may suspend, and a pooler may sit in front of it, and the client still gets DATABASE_URL and SQL. For an AI app that stores users, sessions, and rows, Neon, Supabase, and Prisma Postgres are the hosts this page can describe from their current docs. Pixeltable is a different aisle: insert a video and the transcript is a column, with nobody calling fetch(). Further reading on a longer host list: Mastra’s serverless Postgres article.
What serverless Postgres means#
Provisioned Postgres is a server you size and leave running. Serverless Postgres, in the docs these three publish, means one of two things. The compute can suspend after it goes idle, and wake when the next query arrives. Or many short-lived clients share a smaller set of real database connections through a pooler. Sometimes both.
The wire protocol on the TCP path is Postgres. psql, ORMs, and pg_dump still apply. A pooler in transaction mode gives the connection back at the end of each transaction, so SET, LISTEN/NOTIFY, and temporary tables do not survive. Migrations and dumps use the direct connection. That limit is in Neon’s pooling docs, Supabase’s connection guide, and Prisma’s pooling docs.
None of that is a model pipeline. A row landing in users does not extract frames. If the product you need is “insert runs the model,” keep reading past the host list.
Five checks#
These are fit checks, read from each vendor’s docs. This page does not time them.
- Scaling and resume. Can compute grow with load, and what happens after it has been idle?
- Wire compatibility. Is the client speaking Postgres, or a different transport that happens to run SQL?
- Pooling. Where do serverless functions get a connection, and which session features does that path drop?
- Branching. Does a preview get a clone of the data, or a separate environment you migrate into?
- Insert. When a row is written and nobody calls
fetch(), does the model pipeline run?
Quick answer#
- Neon —
DATABASE_URL, copy-on-write branches, compute that suspends after idle time - Supabase — Postgres in the same project as Auth, a Data API, and row-level security
- Prisma Postgres — Postgres for a TypeScript app: pooled TCP, and an HTTP driver when the runtime cannot open TCP
- Pixeltable — the multimodal table beside that database, when insert should transcribe, embed, and index
At a glance#
| Database | Best for | What they ship | Limit for an AI pipeline |
|---|---|---|---|
| Neon | Branch the data, then suspend | Lakebase Postgres, copy-on-write branches, scale to zero, PgBouncer | An insert is a SQL write. A function still waits for HTTP |
| Supabase | Auth and RLS on Postgres | Postgres, Data API, Auth, Storage, preview branches | ffmpeg and Whisper need a service outside the database |
| Prisma Postgres | TypeScript app plus Postgres | Wire-compatible Postgres, transactional pool, HTTP driver for edge | The HTTP driver is not the Postgres wire protocol |
Convex is the adjacent backend people compare in the same sentence. It is not a row here. Convex’s own docs describe a document store with a JavaScript API and no SQL.
Neon#
Neon’s docs call the database Lakebase Postgres. That is Neon’s product. It is not Databricks Lakebase. The distinction is the one in Neon Functions vs computed columns.
Best for: an AI app that wants a real Postgres connection string, a branch of the data for a preview, and compute that is not billed while it sleeps.
What they ship: Scale to zero suspends an idle compute after 5 minutes and, in Neon’s docs, reactivates it within a few hundred milliseconds on the next query. Free plan users cannot turn that off. Computes larger than 16 CU stay active. Autoscaling moves a compute inside a min/max CU range you set, without a restart. The span between min and max cannot exceed 8 CU. Branching is a copy-on-write clone. Writes land as a delta. The parent’s load does not change. A Vercel integration can open a branch per preview deployment. Pooling is PgBouncer in transaction mode, on a hostname with a -pooler suffix, up to 10,000 client connections. Direct connections are for migrations, pg_dump, logical replication, and session state.
Limit: the database stores rows. Neon Functions are a Node fetch(request) on the branch. Nothing in that handler runs because a video row appeared. Insert still waits for a caller.
Supabase#
Best for: an AI app whose product surface is signed-in users, a browser-facing API, and policies on rows, with Postgres underneath.
What they ship: Supabase is Postgres. The connection guide sends a frontend through the Data API, which requires row-level security, and sends serverless or edge functions through the shared pooler in transaction mode. A persistent backend can use session mode. Transaction mode drops session SET, advisory locks, LISTEN/NOTIFY, and temporary tables between transactions, same family of limit as Neon’s pooler. Branching creates a separate environment with its own API credentials. With the GitHub integration, a push runs migrations on that branch, seeds it when seeding is enabled, and deploys changed Edge Functions.
Limit: the measured video app cannot run ffmpeg or Whisper inside Supabase. Deno cannot run ffmpeg, so the harness adds a 246-line compute service and calls it. The database does not start that work for every writer unless you add triggers. See the measured comparison.
Prisma Postgres#
Best for: a TypeScript app that wants hosted Postgres next to Prisma, including a preview database per branch when the app deploys with Prisma Compute.
What they ship: Prisma’s product page describes standard SQL, the Postgres wire protocol, extensions such as pgvector, and moving data with pg_dump. Application traffic uses a pooled hostname, pooled.db.prisma.io. Pooling is a per-tenant PgBouncer in transaction mode. Pooled queries time out at 10 minutes. Direct connections are for migrations, introspection, LISTEN/NOTIFY, and session state. When the runtime cannot open TCP, the serverless driver speaks HTTP and WebSockets. That path is pooled, and it is not the Postgres wire protocol. Prisma’s page says a Compute branch gets its own database. The Compute branching docs add the caveat that a database reached only through DATABASE_URL is as isolated as that variable’s value.
Limit: this is a place to put SQL. It does not transcribe a video because the row was inserted.
Convex, the adjacent backend#
Convex shows up in “backend for my AI app” threads next to Supabase. Convex’s database docs describe tables of JSON-like documents, read and written from JavaScript queries and mutations. Convex vs SQL says Convex does not use SQL. There is no DATABASE_URL to point psql at. Queries can subscribe, so a React client updates when the underlying documents change.
Choose Convex when the app is a reactive TypeScript backend and the media pipeline is not the product. The same public harness includes Convex: 425 lines of app code, plus the same 246-line compute service, because the Convex runtime cannot run ffmpeg. The developer-facing walkthrough is the Convex developer’s guide to Pixeltable. The measurement is Pixeltable vs Convex.
When you need a table instead#
Pixeltable is not a serverless Postgres host. It does not hand you Neon’s branches, Supabase Auth, or a DATABASE_URL. It is the schema for the media. A stored video column, a computed audio extract, and a computed transcript live on one class. Insert the row. The columns run. No request has to arrive first.
That is the fifth check, passed by the schema. Frames, embeddings, and HTTP routes are the same file when you need them. The pattern for frames is the video intelligence pipeline. What a typed media column is, as opposed to a path in a string column, is what a multimodal data table is.
The line counts in the table come from a published harness, Pixeltable 0.7.8, measured on 2026-09-18 and 2026-09-22: pixeltable-vs-supabase-vs-convex. The idle time, CU limits, connection cap, and pooled-query timeout quoted above are each vendor’s documented limits, not figures from that harness. The app is one video-intelligence workload. It suits a media table. It is not a ranking of database hosts.
| What the harness counted | Pixeltable | Supabase | Convex |
|---|---|---|---|
| App code you maintain | 129 lines, one Python file | 302 lines, SQL and TypeScript | 425 lines, TypeScript |
| Shared compute service | 0 (ffmpeg, Whisper, and CLIP run in-process) | 246 lines (Deno cannot run ffmpeg) | 246 lines (the Convex runtime cannot run ffmpeg) |
| Total | 129 | 548 | 671 |
| Files you open to read the backend | 1 | 7 | 7 |
The same repo records wall-clock timings. Supabase is faster at ingest in that harness. Convex is faster on the read path. Those figures, and the cases that flip, live on Pixeltable vs Supabase and Pixeltable vs Convex. This page does not restate them as a leaderboard.
Deploying that class is a separate walkthrough. Wait until the hosted database is AVAILABLE, then update the database, the schema, and the service, in that order. The steps are Configure Pixeltable Cloud and the Cloud docs.
Chooser#
- Neon when you need
DATABASE_URL, a copy-on-write branch for a preview, and compute that suspends after idle time. - Supabase when you need that Postgres plus Auth, a Data API, row-level security, and a preview environment that runs your migrations.
- Prisma Postgres when the app is TypeScript, you want the wire protocol for the server and an HTTP driver for the edge, and previews should get their own database.
- Pixeltable when insert should extract audio, transcribe, embed, and serve search. Keep Neon or Supabase for the app’s relational state if you need it. They can be used together.
- Convex when the app is a reactive TypeScript backend and the media pipeline is not the product.
Questions#
What does serverless Postgres mean?#
A Postgres whose compute can suspend when it is idle, or sit behind a pooler so many short-lived clients share fewer database connections. The client still speaks SQL. Serverless does not mean an insert runs a model pipeline.
Neon or Supabase for an AI app?#
Neon when you want a copy-on-write branch of the data and compute that suspends after idle time. Supabase when the same project should also provide Auth, a Data API, and row-level security. Both are Postgres. In the measured video app, neither runs ffmpeg or Whisper because a row was inserted.
Does Pixeltable replace Postgres?#
No. Use Neon, Supabase, or Prisma Postgres when the app needs DATABASE_URL, SQL, branching, or row-level security. Use Pixeltable when inserting a video should extract the audio and transcribe it. The two can sit side by side.
Where is the measured comparison?#
On Pixeltable vs Supabase, with the harness at pixeltable-vs-supabase-vs-convex. Pixeltable 0.7.8, measured on 2026-09-18 and 2026-09-22. App code is 129 lines on Pixeltable and 302 on Supabase, plus a 246-line compute service. Convex is in the same harness and is not Postgres.
