Cloud Database & Compute Shootout: 11 Free Tiers
The free plans of Neon, Supabase, Turso, Prisma Postgres, Convex, Railway, Render, Vercel, Modal, Cloudflare and Pixeltable, side by side: what each includes, what happens past free, and how it holds up under the same requests. Every number is the median of 3 runs spread over a day from AWS us-east-1, with latency also timed from eu-west-1, recorded .
We build Pixeltable, so the method, the code and every failure are public, and every chart ranks Pixeltable by the same rule as the rest.
Free plans
Machine is what serves a request on each free plan, from the provider's docs: it explains most of the latency and burst results below. Limits is what the plan gives you and what happens when it sits idle. Past free is what happens at the limit and what the next plan costs, each fact linked to the page that states it. Open a row for strengths, tradeoffs and the catch.
| Plan | Runtime | CPU | Memory | Scaling | Per request | Details | ||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| Managed container | Up to 1 vCPU (service 1, database 0.5 by default) | Up to 2 GB (service 2 GB, database 1 GB by default) | 1 worker per service; stops after 3 idle days | 30 min, 100 MB body | Stops after 3 idle days; a catalog or service request starts it. Also stops at a shared monthly cap; compute alone for the default database stays within it, and storage above the included amount counts toward the cap. Nothing is billed | 50 GB media storage, 10 GB database storage | enough compute for about a 0.5 vCPU · 1 GB database running all month; past that, databases and services stop until the 1st (UTC) | 1 database, 2 services (Community plan) | Not published source | Past the free monthly cap (compute, and storage above the included amount), databases and services stop until the 1st (UTC). Nothing is billed. Media is a hard limit source | Pro $29/mo plus usage, incl. $25 usage; $0.035 per vCPU-hour, $0.0175 per GiB-hour source | Not published source | ||
| RailwayFree ($1/mo credit, after the 30-day trial) | Container from your image | Up to 1 vCPU per service | 0.5 GB per service | 1 replica; sleeping when idle is optional | 15 min while data flows | Stops when the $1 monthly credit runs out | 0.5 GB volume | $1 of usage a month, after a 30-day, $5 trial | Deploy multiple services & template plugins | No for the trial; the Free plan does not say source | At a zero credit balance the subscription is cancelled; whether services stop is not published source | Hobby $5/mo incl. $5 usage; $20/vCPU-mo, $10/GB RAM-mo source | One region on Free; choosing a region needs the trial or a paid plan source | |
| RenderFree Web Service | Not published | 0.1 CPU | 512 MB | 1 instance; sleeps after 15 min | Not published | Sleeps after 15 min | Ephemeral container filesystem | 750 free instance hours/month (512 MB RAM) | 1 free web service | Not required for free instances source | Suspended until month end after 750 instance hours or the bandwidth cap without a card source | Web Starter $7/mo; Postgres Basic $6/mo source | Any of 5: Oregon, Ohio, Virginia, Frankfurt, Singapore source | |
| CloudflareFree Plan | V8 isolate | 10 ms CPU per request | 128 MB per isolate | Isolates in every edge location | 10 ms CPU, 50 subrequests | Always on | 5 GB D1 SQLite, 10 GB R2 object storage | 100,000 Workers requests/day, 5M D1 reads/day, 5M Vectorize queries/mo | 10 D1 databases, 100 Vectorize indexes | No source | Hard stop until midnight UTC: Error 1027 past 100,000 requests a day source | Workers Paid $5/mo; $0.30 per million requests over 10M source | Every edge location; D1 takes a location hint source | |
| ModalFree Tier ($30/mo Credit) | Container in gVisor | 0.125 core by default | 128 MiB by default | Up to 100 containers; zero after 60 s idle | 150 s per web request | Scales to zero | Ephemeral container disk + volume storage | $30/month recurring compute credit | Stateless compute runner (bring your own database) | Yes, a payment method on file source | Billed past the $30 monthly credit unless a workspace budget stops it source | Team $250/mo plus compute source | Region choice costs 1.15x to 1.75x source | |
| NeonFree Tier | Serverless Postgres | Not published | Autoscales up to 8 GB (2 CU) | Scales to zero after 5 min | Not published | Sleeps after 5 min | 1 GB storage per project | 100 compute unit (CU) hours/mo | Up to 100 projects, 10 branches per project | No source | Compute suspended when CU-hours or egress run out; writes blocked past storage source | Launch, no minimum; $0.106/CU-hour, $0.35/GB-month source | 8 AWS regions in the US, EU and APAC source | |
| SupabaseFree Tier | Postgres instance per project | Shared (Nano) | 0.5 GB | 60 direct, 200 pooled connections | Edge Functions: 2 s CPU, 150 s | Pauses after 7 days | 500 MB database, 1 GB file storage | Shared compute, 500k Edge Function invocations/mo | 2 active projects | Not published source | Grace period, then paused, read-only or HTTP 402 until the next cycle source | Pro $25/mo; $0.125/GB disk over 8 GB source | About 19 AWS regions, one per project source | |
| TursoStarter Free | Diskless SQLite, data on S3 | Not published | Not published | Archived after 10 days idle | Not published | Archived after 10 days | 5 GB total storage | 500M row reads/mo, 10M row writes/mo | Up to 100 databases | No source | Hard stop: every database blocked until upgrade or next month source | Developer $4.99/mo source | 6 AWS locations source | |
| Prisma PostgresPublic Beta Free | Unikernel Postgres 17 with PgBouncer | Not published | Not published | 10 pooled and 10 direct connections | 10 s query, 15 s transaction | Always on during beta | 500 MB storage | Shared compute pool | Up to 50 databases | No source | Hard stop: queries refused with PLAN_LIMIT_REACHED until the month resets source | Starter $10/mo; $8 per million operations over 1M source | 6 AWS regions source | |
| ConvexFree Plan | V8 runtime or Node.js | Not published | 64 MiB (V8), 512 MiB (Node) | 16 queries, 16 mutations, 64 actions at once | 1 s per query or mutation | Always on | 1 GB file & document storage | 1 Million function calls/mo | 1 deployment per project | Not published source | Writes may fail; a long overrun can make the deployment return errors source | Starter pay as you go; Professional $25 per developer a month source | US East or EU West source | |
| VercelHobby Free | Fluid compute functions | 1 vCPU | 2 GB | Auto-scales in 1 region | 300 s, 4.5 MB body | Scales to zero | Edge KV / Blob / Postgres (via partner integrations) | 100,000 serverless function executions/mo, 100 GB-hours | Edge functions frontend (stateless) | Not published source | No overage: the feature stops until the 30-day window resets source | Pro $20/mo incl. $20 usage source | One function region, your choice source |
Scorecard
Each plan’s best timed setup per test, named under the number; background acknowledgements are left out. Sort by a column. A dash means not timed, or left out for failing.
| Plan | |||||||||
|---|---|---|---|---|---|---|---|---|---|
| 35.4 msPixeltable Compute Route | 135 msPixeltable Compute Route | 22.9 msPixeltable Query Route | 54.2 msPixeltable Insert Route | 1,605Pixeltable Python SDK | 92Pixeltable Compute Route | 92Pixeltable Compute Route | 1.8Pixeltable Media Route | not timed | |
| Railway | 16.5 ms | 50 msRailway Postgres | 1.8 msRailway Postgres | 3.0 msRailway Postgres | 770Railway Postgres | 2,728Railway Postgres | 3,204Railway Postgres | 11.7Railway + Postgres + object storage | 94.7 |
| Render | 27.2 ms | 426 msRender Postgres | 3.2 msRender Postgres | 4.2 msRender Postgres | 1,388Render Postgres | 372Render Postgres | 368Render Postgres | 9.3Render + Postgres + object storage | 23.3 |
| Cloudflare | 17.4 msCloudflare Workers (Workers Paid) | 115 msCloudflare Workers (Workers Paid) | 57.0 msCloudflare Workers (D1) (Workers Paid) | 78.9 msCloudflare Workers (D1) (Workers Paid) | 650Cloudflare Workers (D1) (Workers Paid) | 3,260Cloudflare Workers (Workers Paid) | 5,063Cloudflare Workers (Workers Paid) | not timed | not timed |
| Modal | 38.8 ms | 4.4 s | not timed | not timed | not timed | 349 | 346 | not timed | 5.5 |
| Neon | not timed | 636 msNeon Serverless PG | 3.1 msNeon Serverless PG | 5.1 msNeon Serverless PG | 1,154Neon Serverless PG | 4,150Neon Serverless PG | 4,882Neon Serverless PG | not timed | not timed |
| Supabase | not timed | 888 msSupabase PostgREST | 23.8 msSupabase PostgREST | 25.6 msSupabase PostgREST | 950Supabase PostgREST | 807Supabase PostgREST | 751Supabase PostgREST | not timed | not timed |
| Turso | not timed | 256 msTurso libSQL | 1.9 msTurso libSQL | 25.1 msTurso libSQL | 1,183Turso libSQL | 42Turso libSQL | 37Turso libSQL | not timed | not timed |
| Convex | not timed | 184 ms | 16.6 ms | 28.6 ms | 334 | 1,536 | 2,402 | not timed | not timed |
| Vercel | 25.4 msVercel (Pro) | 129 msVercel (Pro) | not timed | not timed | not timed | not timed | not timed | not timed | not timed |
Columns: Request p50 · Cold first req · Read p50 · Write p50 · Batch rows/s · c=50 req/s · c=100 req/s · Stored vid/s · Decoded vid/s. Each opens its chart and what was timed.
Warm latency
Lower is better. Each handler returns without touching a database, so this is the platform’s own request path. Rows rank by p50; the line runs from min to p95. Database rows are under Reads and Writes.
300 sequential requests on one warm connection · min, p50, p95 · log scale · median of 3 runs · AWS us-east-1 client · 2026-10-27
- min
- p50
- p95
- 1
Pixeltable Compute Route (background=True)ACK8.3 ms1× - 4Vercel (Pro)HTTP25.4 ms3.1×
- 6
Pixeltable Compute RouteHTTP35.4 ms4.3×
| Rank | Plan | Result | Spread | What was timed |
|---|---|---|---|---|
| 1 | Pixeltable Compute Route (background=True) | 8.3 ms | min 5.2 ms, p50 8.3 ms, p95 27.0 ms | add_compute_route with background=True: a job URL at once. Min 5.2 ms, p95 27.0 ms; p50 ranged 8.01 to 10.42 ms across runs. |
| 2 | Railway | 16.5 ms | min 14.9 ms, p50 16.5 ms, p95 19.2 ms | POST /docs: the shared handler in FastAPI, nothing stored. Min 14.9 ms, p95 19.2 ms; p50 ranged 16.2 to 17.06 ms across runs. |
| 3 | Cloudflare Workers (Workers Paid) | 17.4 ms | min 12.3 ms, p50 17.4 ms, p95 41.0 ms | POST /compute: the shared handler, nothing stored. Min 12.3 ms, p95 41.0 ms; p50 ranged 12.63 to 19.79 ms across runs. |
| 4 | Vercel (Pro) | 25.4 ms | min 17.7 ms, p50 25.4 ms, p95 42.5 ms | POST /api/docs: the shared handler in a Python function. Min 17.7 ms, p95 42.5 ms; p50 ranged 24.33 to 25.72 ms across runs. |
| 5 | Render | 27.2 ms | min 16.2 ms, p50 27.2 ms, p95 48.5 ms | POST /docs: the shared handler in FastAPI, nothing stored. Min 16.2 ms, p95 48.5 ms; p50 ranged 21.48 to 34.74 ms across runs. |
| 6 | Pixeltable Compute Route | 35.4 ms | min 29.4 ms, p50 35.4 ms, p95 42.9 ms | add_compute_route: one computed column, no row stored. Min 29.4 ms, p95 42.9 ms; p50 ranged 31.9 to 38 ms across runs. |
| 7 | Modal | 38.8 ms | min 29.1 ms, p50 38.8 ms, p95 181.0 ms | POST /docs: the shared handler in a Modal container. Min 29.1 ms, p95 181.0 ms; p50 ranged 33.24 to 201.9 ms across runs. The runs disagreed widely, so this median is less certain than most. |
Not timed: Neon, Supabase, Turso, Prisma Postgres, Convex
Cold start
Lower is better. The first request after 20 minutes with no traffic, on a new connection. Free plans that sleep pay here; the note gives the same request once the server is awake.
one request after 20 idle minutes · median of 3 runs · AWS us-east-1 client · 2026-10-27
- 3Vercel (Pro)HTTP129 ms2.6×
- 4
Pixeltable Compute RouteHTTP135 ms2.7×
| Rank | Plan | Result | What was timed |
|---|---|---|---|
| 1 | Railway Postgres | 50 ms | A new connection to the awake server took 33 ms, so waking up added about 20 ms. |
| 2 | Cloudflare Workers (Workers Paid) | 115 ms | A new connection to the awake server took 83 ms, so waking up added about 32 ms. |
| 3 | Vercel (Pro) | 129 ms | A new connection to the awake server took 43 ms, so waking up added about 79 ms. |
| 4 | Pixeltable Compute Route | 135 ms | A new connection to the awake server took 78 ms, so waking up added about 93 ms. |
| 5 | Convex | 184 ms | A new connection to the awake server took 90 ms, so waking up added about 95 ms. |
| 6 | Turso libSQL | 256 ms | A new connection to the awake server took 38 ms, so waking up added about 204 ms. |
| 7 | Render Postgres | 426 ms | A new connection to the awake server took 205 ms, so waking up added about 220 ms. |
| 8 | Neon Serverless PG | 636 ms | A new connection to the awake server took 27 ms, so waking up added about 605 ms. |
| 9 | Supabase PostgREST | 888 ms | A new connection to the awake server took 86 ms, so waking up added about 736 ms. |
| 10 | Railway | 2.6 s | A new connection to the awake server took 39 ms, so waking up added about 2.6 s. |
| 11 | Modal | 4.4 s | A new connection to the awake server took 49 ms, so waking up added about 4.4 s. |
| 12 | Render | 22.2 s | A new connection to the awake server took 61 ms, so waking up added about 22.1 s. |
Not timed: Prisma Postgres
Point reads
Lower is better. One row read by primary key; rows rank by p50, the line runs from min to p50. SQL rows reuse an open connection, HTTP rows a kept-alive one.
one row by primary key, 300 sequential reads · min, p50 · log scale · median of 3 runs · AWS us-east-1 client · 2026-10-27
- min
- p50
- 6
Pixeltable Query RouteHTTP DB22.9 ms13×
| Rank | Plan | Result | Spread | What was timed |
|---|---|---|---|---|
| 1 | Railway Postgres | 1.8 ms | min 1.6 ms, p50 1.8 ms | One row by primary key (SQL wire protocol). p50 ranged 1.03 to 2.29 ms across runs. |
| 2 | Turso libSQL | 1.9 ms | min 1.8 ms, p50 1.9 ms | One row by primary key (HTTP pipeline). p50 ranged 1.79 to 3.16 ms across runs. |
| 3 | Neon Serverless PG | 3.1 ms | min 2.9 ms, p50 3.1 ms | One row by primary key (SQL over HTTP). p50 ranged 2.42 to 3.28 ms across runs. |
| 4 | Render Postgres | 3.2 ms | min 3.0 ms, p50 3.2 ms | One row by primary key (SQL wire protocol). p50 ranged 2.41 to 3.87 ms across runs. |
| 5 | Convex | 16.6 ms | min 12.1 ms, p50 16.6 ms | ctx.db.get(id) in a query function. p50 ranged 14.19 to 20.14 ms across runs. |
| 6 | Pixeltable Query Route | 22.9 ms | min 15.3 ms, p50 22.9 ms | add_query_route, one row by primary key. p50 ranged 19.21 to 23.86 ms across runs. |
| 7 | Supabase PostgREST | 23.8 ms | min 15.1 ms, p50 23.8 ms | GET filtered on id=eq. p50 ranged 18.09 to 30.34 ms across runs. |
| 8 | Cloudflare Workers (D1) (Workers Paid) | 57.0 ms | min 41.5 ms, p50 57.0 ms | One row by primary key (D1 through the Worker). p50 ranged 49.67 to 59.13 ms across runs. |
Not timed: Modal, Prisma Postgres, Vercel
Single-row writes
Lower is better. One row per request, sequentially; rows rank by p50, the line runs from min to p50.
300 sequential single-row writes · min, p50 · log scale · median of 3 runs · AWS us-east-1 client · 2026-10-27
- min
- p50
- 7
Pixeltable Insert RouteHTTP DB54.2 ms18×
| Rank | Plan | Result | Spread | What was timed |
|---|---|---|---|---|
| 1 | Railway Postgres | 3.0 ms | min 1.7 ms, p50 3.0 ms | INSERT over the SQL wire protocol. PostgreSQL WAL commit. |
| 2 | Render Postgres | 4.2 ms | min 3.9 ms, p50 4.2 ms | INSERT over the SQL wire protocol. PostgreSQL WAL commit. |
| 3 | Neon Serverless PG | 5.1 ms | min 3.9 ms, p50 5.1 ms | INSERT as SQL over HTTP. PostgreSQL WAL commit. |
| 4 | Turso libSQL | 25.1 ms | min 18.0 ms, p50 25.1 ms | INSERT through the HTTP pipeline. SQLite WAL on the primary. |
| 5 | Supabase PostgREST | 25.6 ms | min 17.7 ms, p50 25.6 ms | PostgREST POST with a JSON body. PostgreSQL WAL commit. |
| 6 | Convex | 28.6 ms | min 21.1 ms, p50 28.6 ms | Mutation function inserting one document. Convex transaction commit. |
| 7 | Pixeltable Insert Route | 54.2 ms | min 45.0 ms, p50 54.2 ms | add_insert_route: the row and its computed columns, then the response. PostgreSQL row + table version. |
| 8 | Cloudflare Workers (D1) (Workers Paid) | 78.9 ms | min 65.5 ms, p50 78.9 ms | D1 INSERT through the Worker. D1 primary commit (SQLite). |
Not timed: Modal, Prisma Postgres, Vercel
Batch ingest
Higher is better. Bar length is rows per second for 100 rows in one call. Payloads are not one schema.
100 rows in one call, 5 calls per run · median of 3 runs · AWS us-east-1 client · 2026-10-27
- 1
Pixeltable Python SDKHTTP DB1,605 rows/s100%
| Rank | Plan | Result | What was timed |
|---|---|---|---|
| 1 | Pixeltable Python SDK | 1,605 rows/s | t.insert() of 100 rows into the hosted table. |
| 2 | Render Postgres | 1,388 rows/s | executemany of 100 INSERTs over the SQL wire protocol. |
| 3 | Turso libSQL | 1,183 rows/s | 100 INSERTs in one transaction in one pipeline request. |
| 4 | Neon Serverless PG | 1,154 rows/s | One multi-row INSERT as SQL over HTTP. |
| 5 | Supabase PostgREST | 950 rows/s | One JSON array POST to PostgREST. |
| 6 | Railway Postgres | 770 rows/s | executemany of 100 INSERTs over the SQL wire protocol. |
| 7 | Cloudflare Workers (D1) (Workers Paid) | 650 rows/s | D1 batch: 100 INSERTs in one call. |
| 8 | Convex | 334 rows/s | One mutation inserting 100 documents in one transaction. |
Not timed: Modal, Prisma Postgres, Vercel
Burst
Higher is better. Bar length is sustained requests per second with 50 in flight. Every row starts with warm connections, so none pays for connection setup.
50 in flight for 15 s after 50 warm-up requests · median of 3 runs · AWS us-east-1 client · 2026-10-27
- 11
Pixeltable Compute RouteHTTP92 req/s2% - 13
Pixeltable Insert RouteHTTP DB14 req/s0%
| Rank | Plan | Result | What was timed |
|---|---|---|---|
| 1 | Neon Serverless PG | 4,150 req/s | One INSERT per request as SQL over HTTP. 62,271 of 62,271 requests succeeded (100%) in 15 s; p50 10 ms, p95 25 ms. |
| 2 | Cloudflare Workers (Workers Paid) | 3,260 req/s | A fixed reply from the edge isolate. 48,972 of 48,972 requests succeeded (100%) in 15.02 s; p50 14 ms, p95 25 ms. |
| 3 | Railway Postgres | 2,728 req/s | One INSERT per request on its own connection (SQL wire protocol). 41,010 of 41,010 requests succeeded (100%) in 15.03 s; p50 5 ms, p95 80 ms. |
| 4 | Railway | 1,996 req/s | The FastAPI handler; no database. 30,029 of 30,029 requests succeeded (100%) in 15.04 s; p50 23 ms, p95 36 ms. |
| 5 | Convex | 1,536 req/s | One mutation per request. 23,083 of 23,083 requests succeeded (100%) in 15.03 s; p50 28 ms, p95 56 ms. |
| 6 | Supabase PostgREST | 807 req/s | One row per request through PostgREST. 12,204 of 12,204 requests succeeded (100%) in 15.13 s; p50 53 ms, p95 98 ms. |
| 7 | Render Postgres | 372 req/s | One INSERT per request on its own connection (SQL wire protocol). 5,649 of 5,649 requests succeeded (100%) in 15.2 s; p50 102 ms, p95 298 ms. |
| 8 | Modal | 349 req/s | The FastAPI handler in Modal’s default container; no database. 5,850 of 5,868 requests succeeded (100%) in 16.75 s; p50 44 ms, p95 241 ms. |
| 9 | Cloudflare Workers (D1) (Workers Paid) | 327 req/s | One D1 INSERT per request through the Worker. 4,950 of 4,950 requests succeeded (100%) in 15.16 s; p50 132 ms, p95 261 ms. |
| 10 | Render | 150 req/s | The FastAPI handler on the 0.1 CPU free instance; no database. 2,297 of 2,297 requests succeeded (100%) in 15.3 s; p50 304 ms, p95 408 ms. |
| 11 | Pixeltable Compute Route | 92 req/s | A computed column per request; no row stored. 1,416 of 1,416 requests succeeded (100%) in 15.37 s; p50 488 ms, p95 975 ms. |
| 12 | Turso libSQL | 42 req/s | One INSERT per request; the single writer serializes them. 674 of 674 requests succeeded (100%) in 16.06 s; p50 1135 ms, p95 1548 ms. |
| 13 | Pixeltable Insert Route | 14 req/s | Each request inserts a row and computes its columns before answering. 259 of 259 requests succeeded (100%) in 18.22 s; p50 2797 ms, p95 6487 ms. |
Left out, most requests failed: Vercel
Not timed: Prisma Postgres
Extreme concurrency
Higher is better. Bar length is sustained requests per second with 100 in flight, from warm connections.
100 in flight for 15 s after 100 warm-up requests · median of 3 runs · AWS us-east-1 client · 2026-10-27
- 12
Pixeltable Compute RouteHTTP92 req/s2% - 14
Pixeltable Insert RouteHTTP DB16 req/s0%
| Rank | Plan | Result | What was timed |
|---|---|---|---|
| 1 | Cloudflare Workers (Workers Paid) | 5,063 req/s | A fixed reply from the edge isolate. 76,499 of 76,499 requests succeeded (100%) in 15.11 s; p50 18 ms, p95 28 ms. |
| 2 | Neon Serverless PG | 4,882 req/s | One INSERT per request as SQL over HTTP. 73,305 of 75,147 requests succeeded (98%) in 15.02 s; p50 17 ms, p95 31 ms. |
| 3 | Railway Postgres | 3,204 req/s | One INSERT per request on its own connection (SQL wire protocol). 48,096 of 48,096 requests succeeded (100%) in 15.01 s; p50 10 ms, p95 87 ms. |
| 4 | Convex | 2,402 req/s | One mutation per request. 36,121 of 36,121 requests succeeded (100%) in 15.04 s; p50 36 ms, p95 75 ms. |
| 5 | Railway | 1,993 req/s | The FastAPI handler; no database. 29,970 of 29,970 requests succeeded (100%) in 15.04 s; p50 47 ms, p95 83 ms. |
| 6 | Supabase PostgREST | 751 req/s | One row per request through PostgREST. 11,451 of 11,451 requests succeeded (100%) in 15.24 s; p50 123 ms, p95 193 ms. |
| 7 | Cloudflare Workers (D1) (Workers Paid) | 429 req/s | One D1 INSERT per request through the Worker. 6,709 of 6,709 requests succeeded (100%) in 15.65 s; p50 184 ms, p95 454 ms. |
| 8 | Render Postgres | 368 req/s | One INSERT per request on its own connection (SQL wire protocol). The server refused connection 97, so this row ran 96 at once. 5,624 of 5,624 requests succeeded (100%) in 15.3 s; p50 205 ms, p95 501 ms. |
| 9 | Modal | 346 req/s | The FastAPI handler in Modal’s default container; no database. 6,058 of 6,086 requests succeeded (100%) in 17.53 s; p50 117 ms, p95 1059 ms. |
| 10 | Modal Async (.spawn) | 302 req/s | background_task.spawn() returns before the function runs. 4,929 of 4,929 requests succeeded (100%) in 16.32 s; p50 265 ms, p95 732 ms. |
| 11 | Render | 142 req/s | The FastAPI handler on the 0.1 CPU free instance; no database. 2,210 of 2,210 requests succeeded (100%) in 15.59 s; p50 701 ms, p95 899 ms. |
| 12 | Pixeltable Compute Route | 92 req/s | A computed column per request; no row stored. 1,439 of 1,439 requests succeeded (100%) in 15.61 s; p50 1019 ms, p95 1532 ms. |
| 13 | Turso libSQL | 37 req/s | One INSERT per request; the single writer serializes them. 640 of 640 requests succeeded (100%) in 17.08 s; p50 2550 ms, p95 3798 ms. |
| 14 | Pixeltable Insert Route | 16 req/s | Each request inserts a row and computes its columns before answering. 293 of 293 requests succeeded (100%) in 18.76 s; p50 4434 ms, p95 8082 ms. |
Left out, most requests failed: Vercel
Not timed: Prisma Postgres
Separate checks
Microburst at c=350
500 requests, c=350
690 × 200, 810 × 429 across all runs, at 147.6 req/s (median run); p50 386 ms.
The ingress buffer queues a burst (burst=100, delay=50) before it answers 429.
Decompression bomb
625 megapixels
HTTP 400 in 0.08 s (median run).
The image decoder rejects the file before the full bitmap is allocated.
Synchronous insert pool
250 clients
606 × 200, 144 × 429 across all runs, at 17.5 req/s (median run).
Requests queue behind the computed-column work; once the ingress queue is full, the rest get 429.
Insert route with background=True at c=200
400 requests, c=200
225 × 200, 68 × 429, 907 × 503 across all runs, at 292.9 req/s (median run).
The route answers with a job id and inserts in the background. Past 64 unfinished jobs on the service instance it answers 503; past the gateway’s rate per API key, 429.
Media
Higher is better. Each video is decoded, a thumbnail made, the video and thumbnail stored, and a row inserted. Every row here does all five steps.
20 videos at concurrency 5 · median of 3 runs · AWS us-east-1 client · 2026-10-27
- 3
Pixeltable Media Route1.8 vid/s16% - 4
Pixeltable Media Route (background=True)BG1.7 vid/s15%
| Rank | Plan | Result | What was timed |
|---|---|---|---|
| 1 | Railway + Postgres + object storage | 11.7 vid/s | Same steps in FastAPI: video and thumbnail to Supabase Storage, row in Railway Postgres. p50 388 ms per video. |
| 2 | Render + Postgres + object storage | 9.3 vid/s | Same steps in FastAPI: video and thumbnail to Supabase Storage, row in Render Postgres. p50 472 ms per video. |
| 3 | Pixeltable Media Route | 1.8 vid/s | add_insert_route: video to R2, frame at 0.5 s, thumbnail to R2, row in PostgreSQL, then the response. p50 1795 ms per video. |
| 4 | Pixeltable Media Route (background=True) | 1.7 vid/s | Same work in the background; timed from submit until the job reports done. p50 2219 ms per video; the acknowledgement alone took 8 ms. |
Left out, most requests failed: Vercel
Not timed: Cloudflare, Modal, Neon, Supabase, Turso, Prisma Postgres, Convex
What each group does per video
| Group | Decode a frame | Make a thumbnail | Store the video | Store the thumbnail | Insert a row |
|---|---|---|---|---|---|
| Decode onlyRailway, Render, Modal | Yes | Yes | – | – | – |
| Decode, store, insertPixeltable, Railway, Render | Yes | Yes | Yes | Yes | Yes |
One schema, or several services
What a media or AI app needs beyond the timings above: built into one schema, or wired across services. Open a row for what it changes.
One deploy and one source of truth, instead of keeping a database, workers and an API in step.
No queue to run. The acknowledgement is not the work: the media chart times the background route until the job is done.
A new writer cannot forget to trigger the pipeline.
Frames and thumbnails are columns of the same row, with no transcode service in between.
Inference sits next to the data, and a stored result is read without calling a paid API again.
The index cannot drift from the rows, and a deleted row leaves no orphaned vector.
A model swap is a schema edit, not a backfill job.
How it was measured
One method per test, 3 runs spread over a day, from AWS us-east-1, with latency, reads and cold start also from eu-west-1. Read a chart within one protocol: the map below marks which rows did the same work.
The path
Client, every test
AWS us-east-1
c5.xlarge (4 vCPU, 8 GB) in us-east-1c. 3 runs, 20 idle minutes before each cold pass.
Client, latency, reads and cold start
AWS eu-west-1
Same instance type, 3 runs on the same clock, so no client sends traffic before a cold pass.
Global edge
- Cloudflare Workers
US East
- Railway
- Render
- Vercel
- Modal
- Modal Async (.spawn)
Pixeltable Compute Route
Pixeltable Compute Route (background=True)- Neon Serverless PG
- Turso libSQL
- Supabase PostgREST
- Convex
- Cloudflare Workers (D1)
Pixeltable Insert Route
Pixeltable Insert Route (background=True)
Pixeltable Query Route
Pixeltable Python SDK- Railway Postgres
- Render Postgres
- Prisma Postgres
The tests
- Warm latency
The target’s own request, on one kept-alive connection
- In flight
- 1
- Per run
- 300 after 5 untimed
- Published
- p50, with min and p95
- Cold start
The first request after 20 minutes with no traffic, on a new connection
- In flight
- 1
- Per run
- 1
- Published
- Time, beside a new connection to the awake server
- Point reads
One seeded row, read by primary key
- In flight
- 1
- Per run
- 300 after 5 untimed
- Published
- p50, with min
- Single-row writes
One row inserted per request
- In flight
- 1
- Per run
- 300 after 5 untimed
- Published
- p50, with min
- Batch ingest
100 rows in one call
- In flight
- 1
- Per run
- 5 calls
- Published
- Median rows per second
- Burst
As many requests as complete in 15 s, connections warmed first
- In flight
- 50
- Per run
- 15 s window
- Published
- Requests per second, error rate, p50 to p99
- Extreme concurrency
As many requests as complete in 15 s, connections warmed first
- In flight
- 100
- Per run
- 15 s window
- Published
- Requests per second, error rate, p50 to p99
- Media
A 240 KB MPEG: decode only, or decode, store and insert a row
- In flight
- 5
- Per run
- 20 videos
- Published
- Videos per second, in two separate groups
- Resilience
Pixeltable only: a c=350 microburst, c=250 synchronous inserts, a decompression bomb
- In flight
- 200 to 350
- Per run
- 400 to 500
- Published
- Status codes and req/s
Each chart shows the median of 3 runs; its whisker spans the lowest and highest run.
Which rows compare
| Target | Warm | Cold | Read | Write | Batch | c=50 | c=100 | Media |
|---|---|---|---|---|---|---|---|---|
| Cloudflare WorkersPOST /compute: the shared handler, nothing storedPlan: Workers Paid ($5/mo); the Workers Free plan stops at 100,000 requests a day | – | – | – | – | ||||
| RailwayPOST /docs: the shared handler in FastAPI, nothing storedPlan: Free, with Serverless on: the service sleeps when idle | – | – | – | decode · store | ||||
| RenderPOST /docs: the shared handler in FastAPI, nothing storedPlan: Free web service | – | – | – | decode · store | ||||
| VercelPOST /api/docs: the shared handler in a Python functionPlan: Pro: the deployment is in a Pro team | – | – | – | left out | left out | decode, left out | ||
| ModalPOST /docs: the shared handler in a Modal containerPlan: Starter ($30/mo credit) | – | – | – | decode | ||||
| Modal Async (.spawn)POST /docs/async: spawn() returns before the function runsPlan: Starter ($30/mo credit) | – | – | – | – | – | – | ack | – |
| – | – | – | – | |||||
| ack | – | – | – | – | left out | left out | – | |
| Neon Serverless PGINSERT or SELECT as SQL over HTTPPlan: Free | – | |||||||
| Turso libSQLINSERT or SELECT through the HTTP pipelinePlan: Free | – | |||||||
| Supabase PostgRESTPOST or GET through PostgRESTPlan: Free | – | |||||||
| ConvexA mutation or query function callPlan: Free | – | |||||||
| Cloudflare Workers (D1)D1 INSERT or SELECT through the WorkerPlan: D1 on Workers Paid | – | – | ||||||
| – | – | – | store | |||||
| left out | – | – | left out | – | left out | left out | store | |
| – | – | – | – | – | – | – | ||
| – | – | – | – | – | – | – | ||
| Railway PostgresINSERT or SELECT on an open connectionPlan: Free, with Serverless on: the database sleeps when idle | – | |||||||
| Render PostgresINSERT or SELECT on an open connectionPlan: Free; the database expires 30 days after it is created | – | |||||||
| Prisma PostgresINSERT or SELECT through Prisma’s poolerPlan: Free; its monthly operations ran out, so it refused queries | not run | not run | not run | not run | not run | not run | not run | – |
What failed or was left out
Every failed request across the 3 runs. A load row is left out of its chart when its median run failed more than 10% of requests, and a latency row when its runs together did; the rest stay, with their success rate in the row.
| Test | Target | Failed requests, all runs | In the chart |
|---|---|---|---|
| Every test | Prisma Postgres | Not run: its account’s free plan refused every query with planLimitReached in the 2026-10-07 runs | Left out |
| Warm latency | 626 × HTTP error, status not recorded | Left out | |
| Burst, c=50 | Cloudflare Workers | 1 × connection reset | Kept |
| Burst, c=50 | Modal | 18 × 429 Too Many Requests | Kept |
| Burst, c=50 | Neon Serverless PG | 3,614 × 500 Internal Server Error | Kept |
| Burst, c=50 | 970 × 503 Service Unavailable | Left out | |
| Burst, c=50 | 8,767 × 503 Service Unavailable | Left out | |
| Burst, c=50 | Vercel | 35,659 × 403 Forbidden, 19,437 × connection refused, 95 × server closed the connection, 55 × connection reset | Left out |
| Extreme, c=100 | Cloudflare Workers | 1 × connection reset | Kept |
| Extreme, c=100 | Modal | 28 × 429 Too Many Requests, 1 × TimeoutError | Kept |
| Extreme, c=100 | Modal Async (.spawn) | 1 × 500 Internal Server Error | Kept |
| Extreme, c=100 | Neon Serverless PG | 4,854 × 500 Internal Server Error | Kept |
| Extreme, c=100 | 905 × 503 Service Unavailable | Left out | |
| Extreme, c=100 | 8,989 × 503 Service Unavailable, 543 × 429 Too Many Requests | Left out | |
| Extreme, c=100 | Vercel | 40,453 × connection refused, 33,358 × 403 Forbidden, 268 × server closed the connection, 32 × connection reset | Left out |
| Media, decode | Vercel | 60 × 403 Forbidden | Left out |
The runs
- Run windows, UTC
- us-east-1 10-27 17:40–17:58us-east-1 10-27 21:40–22:02us-east-1 10-28 01:40–01:58eu-west-1 10-27 18:32–18:47eu-west-1 10-27 22:32–22:47eu-west-1 10-28 02:32–02:46
- Client software
- Python 3.11.17, aiohttp 3.14.5, asyncpg 0.32.0, psycopg 3.3.6, pixeltable 0.7.20
- Code and raw results
- Harness and target codeRaw JSON per run
Rerun it
One run against your own deployments. The published numbers come from remote_loop.sh: 3 cycles four hours apart, each a full run from us-east-1 and latency, reads and cold start from eu-west-1.
git clone https://github.com/pixeltable/pixeltable-vs-supabase-vs-convexcd pixeltable-vs-supabase-vs-convex/cloud-providers# deploy each target in targets/, then fill .env from .env.examplepython3.11 -m pip install aiohttp asyncpg 'psycopg[binary]' pixeltable==0.7.20set -a; . ./.env; set +aexport PIXELTABLE_API_KEY=$PXT_TOKENpython3.11 bench.py# 20 minutes with no traffic to any targetsleep 1200python3.11 bench.py cold
One handler, one row
Every compute target runs the same handler: read a title and body, return the title upper-cased and a summary, store nothing. The Pixeltable compute route is the exception: it reads only the title. Every database stores the same row: an id, a title and a body.
The plan each target ran on
Free plans with default settings, except: Vercel ran on Pro and Cloudflare on Workers Paid, the only accounts available; Railway’s services had Serverless on, so they sleep when idle. The Pixeltable service and the benchmark client both ran pixeltable 0.7.20. Each row’s plan is in the table above.
Dormancy is part of the plan
Render sleeps after 15 minutes, Neon after 5, Modal after 60 seconds, and Supabase pauses a project after 7 days. Pixeltable Community stops a database after 3 idle days. The cold-start chart times the first request after 20 idle minutes; nothing pinged the targets in between. It has one route per deployment: Pixeltable’s other routes and the D1 route share a deployment with a route timed before them, which had already woken it. A week-long pause or a ten-day archive was not timed.
Media frames
Pixeltable, Railway, Render and Modal decode the frame at 0.5 s of the 3.55 s clip, found the way Pixeltable’s extract_frame finds it. Vercel’s handler reads the first frame by design, which is less work.
Background routes
In pixeltable 0.7.20, a background route holds at most 64 unfinished jobs per service instance and answers 503 with Retry-After past that. The client counts a refused request as failed and does not retry; the load tests record its status, the latency test only that it failed. A background row that failed more than 10% of its requests leaves its chart and is listed under “What failed or was left out”.
Not measured
Latency from regions other than us-east-1 and eu-west-1, load from eu-west-1, cost per request, and paid plans other than the two named above.
Rerun every quarter
The harness, the code every target ran and the raw results are public; the next run replaces every number at once.
Questions
Do these numbers update themselves?
How does Pixeltable do on writes and throughput?
Which results were left out?
Does Pixeltable replace these databases?
How do these free tiers behave under extreme concurrency (c=100) or large payloads?
How do Railway Postgres and Render Postgres compare on this run?
What did the breaking-point checks record?
Sources
Limits come from each provider's pricing page and machine specs from its docs. Check there for changes since the run.
- Pixeltable pricingmachine specs
- Railway pricingmachine specs
- Render pricingmachine specs
- Cloudflare pricingmachine specs
- Modal pricingmachine specs
- Neon pricingmachine specs
- Supabase pricingmachine specs
- Turso pricingmachine specs
- Prisma Postgres pricingmachine specs
- Convex pricingmachine specs
- Vercel pricingmachine specs
pip install 'pixeltable[serve]'