Skip to content

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.

Free-plan limits for the plans in view.
PlanRuntimeCPUMemoryScalingPer requestDetails
PixeltableCommunity (Free)Managed containerUp 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 days30 min, 100 MB body
RailwayFree ($1/mo credit, after the 30-day trial)Container from your imageUp to 1 vCPU per service0.5 GB per service1 replica; sleeping when idle is optional15 min while data flows
RenderFree Web ServiceNot published0.1 CPU512 MB1 instance; sleeps after 15 minNot published
CloudflareFree PlanV8 isolate10 ms CPU per request128 MB per isolateIsolates in every edge location10 ms CPU, 50 subrequests
ModalFree Tier ($30/mo Credit)Container in gVisor0.125 core by default128 MiB by defaultUp to 100 containers; zero after 60 s idle150 s per web request
NeonFree TierServerless PostgresNot publishedAutoscales up to 8 GB (2 CU)Scales to zero after 5 minNot published
SupabaseFree TierPostgres instance per projectShared (Nano)0.5 GB60 direct, 200 pooled connectionsEdge Functions: 2 s CPU, 150 s
TursoStarter FreeDiskless SQLite, data on S3Not publishedNot publishedArchived after 10 days idleNot published
Prisma PostgresPublic Beta FreeUnikernel Postgres 17 with PgBouncerNot publishedNot published10 pooled and 10 direct connections10 s query, 15 s transaction
ConvexFree PlanV8 runtime or Node.jsNot published64 MiB (V8), 512 MiB (Node)16 queries, 16 mutations, 64 actions at once1 s per query or mutation
VercelHobby FreeFluid compute functions1 vCPU2 GBAuto-scales in 1 region300 s, 4.5 MB body

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.

Scorecard: each plan's result on every timed path. Lower is better for milliseconds; higher is better for rates.
Plan
Pixeltable35.4 msPixeltable Compute Route135 msPixeltable Compute Route22.9 msPixeltable Query Route54.2 msPixeltable Insert Route1,605Pixeltable Python SDK92Pixeltable Compute Route92Pixeltable Compute Route1.8Pixeltable Media Routenot timed
Railway16.5 ms50 msRailway Postgres1.8 msRailway Postgres3.0 msRailway Postgres770Railway Postgres2,728Railway Postgres3,204Railway Postgres11.7Railway + Postgres + object storage94.7
Render27.2 ms426 msRender Postgres3.2 msRender Postgres4.2 msRender Postgres1,388Render Postgres372Render Postgres368Render Postgres9.3Render + Postgres + object storage23.3
Cloudflare17.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 timednot timed
Modal38.8 ms4.4 snot timednot timednot timed349346not timed5.5
Neonnot timed636 msNeon Serverless PG3.1 msNeon Serverless PG5.1 msNeon Serverless PG1,154Neon Serverless PG4,150Neon Serverless PG4,882Neon Serverless PGnot timednot timed
Supabasenot timed888 msSupabase PostgREST23.8 msSupabase PostgREST25.6 msSupabase PostgREST950Supabase PostgREST807Supabase PostgREST751Supabase PostgRESTnot timednot timed
Tursonot timed256 msTurso libSQL1.9 msTurso libSQL25.1 msTurso libSQL1,183Turso libSQL42Turso libSQL37Turso libSQLnot timednot timed
Convexnot timed184 ms16.6 ms28.6 ms3341,5362,402not timednot timed
Vercel25.4 msVercel (Pro)129 msVercel (Pro)not timednot timednot timednot timednot timednot timednot 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. 1Pixeltable Compute Route (background=True)ACK8.3 ms
  2. 2RailwayHTTP16.5 ms
  3. 4Vercel (Pro)HTTP25.4 ms
  4. 5RenderHTTP27.2 ms
  5. 6Pixeltable Compute RouteHTTP35.4 ms
  6. 7ModalHTTP38.8 ms
Warm latency. 300 sequential requests on one warm connection · min, p50, p95 · log scale · median of 3 runs · AWS us-east-1 client · 2026-10-27
RankPlanResultSpreadWhat was timed
1Pixeltable Compute Route (background=True)8.3 msmin 5.2 ms, p50 8.3 ms, p95 27.0 msadd_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.
2Railway16.5 msmin 14.9 ms, p50 16.5 ms, p95 19.2 msPOST /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.
3Cloudflare Workers (Workers Paid)17.4 msmin 12.3 ms, p50 17.4 ms, p95 41.0 msPOST /compute: the shared handler, nothing stored. Min 12.3 ms, p95 41.0 ms; p50 ranged 12.63 to 19.79 ms across runs.
4Vercel (Pro)25.4 msmin 17.7 ms, p50 25.4 ms, p95 42.5 msPOST /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.
5Render27.2 msmin 16.2 ms, p50 27.2 ms, p95 48.5 msPOST /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.
6Pixeltable Compute Route35.4 msmin 29.4 ms, p50 35.4 ms, p95 42.9 msadd_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.
7Modal38.8 msmin 29.1 ms, p50 38.8 ms, p95 181.0 msPOST /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

lowest to highest of the runs
  1. 1Railway PostgresSQL50 ms
  2. 3Vercel (Pro)HTTP129 ms
  3. 4Pixeltable Compute RouteHTTP135 ms
  4. 5ConvexHTTP DB184 ms
  5. 6Turso libSQLHTTP DB256 ms
  6. 7Render PostgresSQL426 ms
  7. 8Neon Serverless PGHTTP DB636 ms
  8. 9Supabase PostgRESTHTTP DB888 ms
  9. 10RailwayHTTP2.6 s
  10. 11ModalHTTP4.4 s
  11. 12RenderHTTP22.2 s
Cold start. one request after 20 idle minutes · median of 3 runs · AWS us-east-1 client · 2026-10-27
RankPlanResultWhat was timed
1Railway Postgres50 msA new connection to the awake server took 33 ms, so waking up added about 20 ms.
2Cloudflare Workers (Workers Paid)115 msA new connection to the awake server took 83 ms, so waking up added about 32 ms.
3Vercel (Pro)129 msA new connection to the awake server took 43 ms, so waking up added about 79 ms.
4Pixeltable Compute Route135 msA new connection to the awake server took 78 ms, so waking up added about 93 ms.
5Convex184 msA new connection to the awake server took 90 ms, so waking up added about 95 ms.
6Turso libSQL256 msA new connection to the awake server took 38 ms, so waking up added about 204 ms.
7Render Postgres426 msA new connection to the awake server took 205 ms, so waking up added about 220 ms.
8Neon Serverless PG636 msA new connection to the awake server took 27 ms, so waking up added about 605 ms.
9Supabase PostgREST888 msA new connection to the awake server took 86 ms, so waking up added about 736 ms.
10Railway2.6 sA new connection to the awake server took 39 ms, so waking up added about 2.6 s.
11Modal4.4 sA new connection to the awake server took 49 ms, so waking up added about 4.4 s.
12Render22.2 sA 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
  1. 1Railway PostgresSQL1.8 ms
  2. 2Turso libSQLHTTP DB1.9 ms
  3. 3Neon Serverless PGHTTP DB3.1 ms
  4. 4Render PostgresSQL3.2 ms
  5. 5ConvexHTTP DB16.6 ms
  6. 6Pixeltable Query RouteHTTP DB22.9 ms
  7. 7Supabase PostgRESTHTTP DB23.8 ms
Point reads. one row by primary key, 300 sequential reads · min, p50 · log scale · median of 3 runs · AWS us-east-1 client · 2026-10-27
RankPlanResultSpreadWhat was timed
1Railway Postgres1.8 msmin 1.6 ms, p50 1.8 msOne row by primary key (SQL wire protocol). p50 ranged 1.03 to 2.29 ms across runs.
2Turso libSQL1.9 msmin 1.8 ms, p50 1.9 msOne row by primary key (HTTP pipeline). p50 ranged 1.79 to 3.16 ms across runs.
3Neon Serverless PG3.1 msmin 2.9 ms, p50 3.1 msOne row by primary key (SQL over HTTP). p50 ranged 2.42 to 3.28 ms across runs.
4Render Postgres3.2 msmin 3.0 ms, p50 3.2 msOne row by primary key (SQL wire protocol). p50 ranged 2.41 to 3.87 ms across runs.
5Convex16.6 msmin 12.1 ms, p50 16.6 msctx.db.get(id) in a query function. p50 ranged 14.19 to 20.14 ms across runs.
6Pixeltable Query Route22.9 msmin 15.3 ms, p50 22.9 msadd_query_route, one row by primary key. p50 ranged 19.21 to 23.86 ms across runs.
7Supabase PostgREST23.8 msmin 15.1 ms, p50 23.8 msGET filtered on id=eq. p50 ranged 18.09 to 30.34 ms across runs.
8Cloudflare Workers (D1) (Workers Paid)57.0 msmin 41.5 ms, p50 57.0 msOne 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
  1. 1Railway PostgresSQL3.0 ms
  2. 2Render PostgresSQL4.2 ms
  3. 3Neon Serverless PGHTTP DB5.1 ms
  4. 4Turso libSQLHTTP DB25.1 ms
  5. 5Supabase PostgRESTHTTP DB25.6 ms
  6. 6ConvexHTTP DB28.6 ms
  7. 7Pixeltable Insert RouteHTTP DB54.2 ms
Single-row writes. 300 sequential single-row writes · min, p50 · log scale · median of 3 runs · AWS us-east-1 client · 2026-10-27
RankPlanResultSpreadWhat was timed
1Railway Postgres3.0 msmin 1.7 ms, p50 3.0 msINSERT over the SQL wire protocol. PostgreSQL WAL commit.
2Render Postgres4.2 msmin 3.9 ms, p50 4.2 msINSERT over the SQL wire protocol. PostgreSQL WAL commit.
3Neon Serverless PG5.1 msmin 3.9 ms, p50 5.1 msINSERT as SQL over HTTP. PostgreSQL WAL commit.
4Turso libSQL25.1 msmin 18.0 ms, p50 25.1 msINSERT through the HTTP pipeline. SQLite WAL on the primary.
5Supabase PostgREST25.6 msmin 17.7 ms, p50 25.6 msPostgREST POST with a JSON body. PostgreSQL WAL commit.
6Convex28.6 msmin 21.1 ms, p50 28.6 msMutation function inserting one document. Convex transaction commit.
7Pixeltable Insert Route54.2 msmin 45.0 ms, p50 54.2 msadd_insert_route: the row and its computed columns, then the response. PostgreSQL row + table version.
8Cloudflare Workers (D1) (Workers Paid)78.9 msmin 65.5 ms, p50 78.9 msD1 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

lowest to highest of the runs
  1. 1Pixeltable Python SDKHTTP DB1,605 rows/s
  2. 2Render PostgresSQL1,388 rows/s
  3. 3Turso libSQLHTTP DB1,183 rows/s
  4. 4Neon Serverless PGHTTP DB1,154 rows/s
  5. 5Supabase PostgRESTHTTP DB950 rows/s
  6. 6Railway PostgresSQL770 rows/s
  7. 8ConvexHTTP DB334 rows/s
Batch ingest. 100 rows in one call, 5 calls per run · median of 3 runs · AWS us-east-1 client · 2026-10-27
RankPlanResultWhat was timed
1Pixeltable Python SDK1,605 rows/st.insert() of 100 rows into the hosted table.
2Render Postgres1,388 rows/sexecutemany of 100 INSERTs over the SQL wire protocol.
3Turso libSQL1,183 rows/s100 INSERTs in one transaction in one pipeline request.
4Neon Serverless PG1,154 rows/sOne multi-row INSERT as SQL over HTTP.
5Supabase PostgREST950 rows/sOne JSON array POST to PostgREST.
6Railway Postgres770 rows/sexecutemany of 100 INSERTs over the SQL wire protocol.
7Cloudflare Workers (D1) (Workers Paid)650 rows/sD1 batch: 100 INSERTs in one call.
8Convex334 rows/sOne 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

lowest to highest of the runs
  1. 1Neon Serverless PGHTTP DB4,150 req/s
  2. 3Railway PostgresSQL2,728 req/s
  3. 4RailwayHTTP1,996 req/s
  4. 5ConvexHTTP DB1,536 req/s
  5. 6Supabase PostgRESTHTTP DB807 req/s
  6. 7Render PostgresSQL372 req/s
  7. 8ModalHTTP349 req/s
  8. 10RenderHTTP150 req/s
  9. 11Pixeltable Compute RouteHTTP92 req/s
  10. 12Turso libSQLHTTP DB42 req/s
  11. 13Pixeltable Insert RouteHTTP DB14 req/s
Burst. 50 in flight for 15 s after 50 warm-up requests · median of 3 runs · AWS us-east-1 client · 2026-10-27
RankPlanResultWhat was timed
1Neon Serverless PG4,150 req/sOne INSERT per request as SQL over HTTP. 62,271 of 62,271 requests succeeded (100%) in 15 s; p50 10 ms, p95 25 ms.
2Cloudflare Workers (Workers Paid)3,260 req/sA fixed reply from the edge isolate. 48,972 of 48,972 requests succeeded (100%) in 15.02 s; p50 14 ms, p95 25 ms.
3Railway Postgres2,728 req/sOne 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.
4Railway1,996 req/sThe FastAPI handler; no database. 30,029 of 30,029 requests succeeded (100%) in 15.04 s; p50 23 ms, p95 36 ms.
5Convex1,536 req/sOne mutation per request. 23,083 of 23,083 requests succeeded (100%) in 15.03 s; p50 28 ms, p95 56 ms.
6Supabase PostgREST807 req/sOne row per request through PostgREST. 12,204 of 12,204 requests succeeded (100%) in 15.13 s; p50 53 ms, p95 98 ms.
7Render Postgres372 req/sOne 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.
8Modal349 req/sThe 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.
9Cloudflare Workers (D1) (Workers Paid)327 req/sOne 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.
10Render150 req/sThe 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.
11Pixeltable Compute Route92 req/sA 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.
12Turso libSQL42 req/sOne INSERT per request; the single writer serializes them. 674 of 674 requests succeeded (100%) in 16.06 s; p50 1135 ms, p95 1548 ms.
13Pixeltable Insert Route14 req/sEach 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

lowest to highest of the runs
  1. 2Neon Serverless PGHTTP DB4,882 req/s
  2. 3Railway PostgresSQL3,204 req/s
  3. 4ConvexHTTP DB2,402 req/s
  4. 5RailwayHTTP1,993 req/s
  5. 6Supabase PostgRESTHTTP DB751 req/s
  6. 8Render PostgresSQL368 req/s
  7. 9ModalHTTP346 req/s
  8. 10Modal Async (.spawn)ACK302 req/s
  9. 11RenderHTTP142 req/s
  10. 12Pixeltable Compute RouteHTTP92 req/s
  11. 13Turso libSQLHTTP DB37 req/s
  12. 14Pixeltable Insert RouteHTTP DB16 req/s
Extreme concurrency. 100 in flight for 15 s after 100 warm-up requests · median of 3 runs · AWS us-east-1 client · 2026-10-27
RankPlanResultWhat was timed
1Cloudflare Workers (Workers Paid)5,063 req/sA fixed reply from the edge isolate. 76,499 of 76,499 requests succeeded (100%) in 15.11 s; p50 18 ms, p95 28 ms.
2Neon Serverless PG4,882 req/sOne 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.
3Railway Postgres3,204 req/sOne 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.
4Convex2,402 req/sOne mutation per request. 36,121 of 36,121 requests succeeded (100%) in 15.04 s; p50 36 ms, p95 75 ms.
5Railway1,993 req/sThe FastAPI handler; no database. 29,970 of 29,970 requests succeeded (100%) in 15.04 s; p50 47 ms, p95 83 ms.
6Supabase PostgREST751 req/sOne row per request through PostgREST. 11,451 of 11,451 requests succeeded (100%) in 15.24 s; p50 123 ms, p95 193 ms.
7Cloudflare Workers (D1) (Workers Paid)429 req/sOne 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.
8Render Postgres368 req/sOne 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.
9Modal346 req/sThe 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.
10Modal Async (.spawn)302 req/sbackground_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.
11Render142 req/sThe 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.
12Pixeltable Compute Route92 req/sA 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.
13Turso libSQL37 req/sOne INSERT per request; the single writer serializes them. 640 of 640 requests succeeded (100%) in 17.08 s; p50 2550 ms, p95 3798 ms.
14Pixeltable Insert Route16 req/sEach 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

lowest to highest of the runs
  1. 3Pixeltable Media Route1.8 vid/s
  2. 4Pixeltable Media Route (background=True)BG1.7 vid/s
Media. 20 videos at concurrency 5 · median of 3 runs · AWS us-east-1 client · 2026-10-27
RankPlanResultWhat was timed
1Railway + Postgres + object storage11.7 vid/sSame steps in FastAPI: video and thumbnail to Supabase Storage, row in Railway Postgres. p50 388 ms per video.
2Render + Postgres + object storage9.3 vid/sSame steps in FastAPI: video and thumbnail to Supabase Storage, row in Render Postgres. p50 472 ms per video.
3Pixeltable Media Route1.8 vid/sadd_insert_route: video to R2, frame at 0.5 s, thumbnail to R2, row in PostgreSQL, then the response. p50 1795 ms per video.
4Pixeltable Media Route (background=True)1.7 vid/sSame 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

What each media group does per video
GroupDecode a frameMake a thumbnailStore the videoStore the thumbnailInsert a row
Decode onlyRailway, Render, ModalYesYes–––
Decode, store, insertPixeltable, Railway, RenderYesYesYesYesYes

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.

  1. One deploy and one source of truth, instead of keeping a database, workers and an API in step.

  2. No queue to run. The acknowledgement is not the work: the media chart times the background route until the job is done.

  3. A new writer cannot forget to trigger the pipeline.

  4. Frames and thumbnails are columns of the same row, with no transcode service in between.

  5. Inference sits next to the data, and a stored result is read without calling a paid API again.

  6. The index cannot drift from the rows, and a deleted row leaves no orphaned vector.

  7. 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

HTTP compute: a handler that stores nothing A database write or read through an HTTP API A database write or read over the Postgres wire protocol, connection already openack Answers before its work runs
Which tests timed each target, and what one request to it does
TargetWarmColdReadWriteBatchc=50c=100Media
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 outleft outdecode, 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–
Pixeltable Compute Routeadd_compute_route: one computed column, no row storedPlan: Community (Free)––––
Pixeltable Compute Route (background=True)add_compute_route with background=True: a job URL at oncePlan: Community (Free)ack––––left outleft 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––
Pixeltable Insert Routeadd_insert_route: the row and its computed columns, then the responsePlan: Community (Free)–––store
Pixeltable Insert Route (background=True)add_insert_route with background=True: a job id at oncePlan: Community (Free)left out––left out–left outleft outstore
Pixeltable Query Routeadd_query_route: one row by primary keyPlan: Community (Free)–––––––
Pixeltable Python SDKt.insert() through the SDKPlan: Community (Free)–––––––
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 queriesnot runnot runnot runnot runnot runnot runnot 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.

Failed requests by test and target, summed over every run
TestTargetFailed requests, all runsIn the chart
Every testPrisma PostgresNot run: its account’s free plan refused every query with planLimitReached in the 2026-10-07 runsLeft out
Warm latencyPixeltable Insert Route (background=True)626 × HTTP error, status not recordedLeft out
Burst, c=50Cloudflare Workers1 × connection resetKept
Burst, c=50Modal18 × 429 Too Many RequestsKept
Burst, c=50Neon Serverless PG3,614 × 500 Internal Server ErrorKept
Burst, c=50Pixeltable Compute Route (background=True)970 × 503 Service UnavailableLeft out
Burst, c=50Pixeltable Insert Route (background=True)8,767 × 503 Service UnavailableLeft out
Burst, c=50Vercel35,659 × 403 Forbidden, 19,437 × connection refused, 95 × server closed the connection, 55 × connection resetLeft out
Extreme, c=100Cloudflare Workers1 × connection resetKept
Extreme, c=100Modal28 × 429 Too Many Requests, 1 × TimeoutErrorKept
Extreme, c=100Modal Async (.spawn)1 × 500 Internal Server ErrorKept
Extreme, c=100Neon Serverless PG4,854 × 500 Internal Server ErrorKept
Extreme, c=100Pixeltable Compute Route (background=True)905 × 503 Service UnavailableLeft out
Extreme, c=100Pixeltable Insert Route (background=True)8,989 × 503 Service Unavailable, 543 × 429 Too Many RequestsLeft out
Extreme, c=100Vercel40,453 × connection refused, 33,358 × 403 Forbidden, 268 × server closed the connection, 32 × connection resetLeft out
Media, decodeVercel60 × 403 ForbiddenLeft 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

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.

terminal
git clone https://github.com/pixeltable/pixeltable-vs-supabase-vs-convex
cd pixeltable-vs-supabase-vs-convex/cloud-providers
# deploy each target in targets/, then fill .env from .env.example
python3.11 -m pip install aiohttp asyncpg 'psycopg[binary]' pixeltable==0.7.20
set -a; . ./.env; set +a
export PIXELTABLE_API_KEY=$PXT_TOKEN
python3.11 bench.py
# 20 minutes with no traffic to any target
sleep 1200
python3.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?

No. They are the median of 3 runs, spread over a day, recorded 2026-10-27 from AWS us-east-1 and eu-west-1. The harness, the code every target ran and the raw results are public in pixeltable/pixeltable-vs-supabase-vs-convex under cloud-providers/; the page is regenerated from them, and a quarterly rerun replaces every number at once.

How does Pixeltable do on writes and throughput?

A synchronous insert route computes the row's columns and records a table version before it answers, which plain databases do not: with 50 in flight it ran 14 req/s, where Neon Serverless PG ran 4150. A 100-row batch through the Python SDK ran 1,605 rows/s (Render Postgres: 1,388). Storing a video with its frame and thumbnail ran 1.8 videos/s (Railway + Postgres + object storage: 11.7). The background routes answer first and run that work after the response.

Which results were left out?

Prisma Postgres was not run: its account’s free plan refused every query with planLimitReached in the 2026-10-07 runs. Pixeltable Insert Route (background=True), Pixeltable Compute Route (background=True), Vercel: a load row leaves its chart when its median run failed more than 10% of requests, and a latency row when its runs together did. Every failed request, kept or left out, is listed under “What failed or was left out”.

Does Pixeltable replace these databases?

No. Use Neon, Supabase, Prisma Postgres, or Turso when the app needs their database. Use Pixeltable when inserting a row should run a media pipeline. The two can sit side by side.

How do these free tiers behave under extreme concurrency (c=100) or large payloads?

With 100 requests in flight, the Pixeltable Compute Route sustained 92 req/s, p50 1019 ms and the synchronous insert route 16 req/s, p50 4434 ms; Render’s web service 142 req/s, p50 701 ms. The background insert route accepted 6% of its requests: past 64 unfinished jobs on the service instance it answers 503. The slowest other row was Turso libSQL, at 37 req/s, p50 2550 ms. Vercel rejects a request body above 4.5 MB with HTTP 413; Pixeltable accepts uploads up to 100 MB.

How do Railway Postgres and Render Postgres compare on this run?

Point reads took 1.8 ms on Railway and 3.2 ms on Render, and a 100-row batch ran at 770 and 1,388 rows/s. With 100 in flight: Railway 3204 req/s, p50 10 ms, Render 368 req/s, p50 205 ms. One INSERT per request on its own connection (SQL wire protocol). The server refused connection 97, so this row ran 96 at once.

What did the breaking-point checks record?

Microburst at c=350: 690 × 200, 810 × 429 across all runs, at 147.6 req/s (median run); p50 386 ms. Decompression bomb: HTTP 400 in 0.08 s (median run). Synchronous insert pool: 606 × 200, 144 × 429 across all runs, at 17.5 req/s (median run).
pip install 'pixeltable[serve]'
See how it works