---
title: "11 Free Cloud Database & Compute Tiers Compared (2026)"
description: "Free tiers of Neon, Supabase, Turso, Prisma, Convex, Railway, Render, Vercel, Modal, Cloudflare and Pixeltable: limits, what happens past free, and timed runs from AWS us-east-1 and eu-west-1."
url: "https://www.pixeltable.com/compare/cloud-providers"
---

# 11 Free Cloud Database & Compute Tiers Compared (2026)

Eleven free plans compared on what they include, what happens past free, and how they hold up under the same requests. 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. Every number is the median of 3 runs spread over a day from AWS us-east-1, with latency, reads and cold start also timed from eu-west-1.

## The 11 free plans

Each timed target ran on its free plan with default settings, except Vercel (Pro) and Cloudflare (Workers Paid), and Railway, whose services had Serverless sleeping on.

| Provider | Category | Plan | Storage | Compute / Quota | Dormancy Rule | Hidden Costs / Wedge |
| --- | --- | --- | --- | --- | --- | --- |
| Pixeltable | AI Data & Workflow | Community (Free) | 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) | A database with no activity for 3 days stops, its services with it, and nothing is deleted; the next request to its catalog or one of its services, or pxt db start, starts it again in about 2 minutes. The plan includes enough compute for about a 0.5 vCPU · 1 GB database running all month; past that, databases and services stop until the 1st (UTC). | Zero. ffmpeg, Whisper, CLIP & vector indexing run in-schema; no external orchestrators or vector DBs needed. |
| Railway | Compute & Hosting | Free ($1/mo credit, after the 30-day trial) | 0.5 GB volume | $1 of usage a month, after a 30-day, $5 trial | Stops when the monthly credit runs out; services can sleep when idle (Serverless), which stretches it | At Railway’s published rates, one service with 0.5 GB of RAM running all month costs more than the $1 credit, so a free database lasts only if it sleeps. No built-in multimodal, vector indexing, or pipeline triggers. |
| Render | Compute & Hosting | Free Web Service | Ephemeral container filesystem | 750 free instance hours/month (512 MB RAM) | Spins down after 15 minutes of inactivity (50s cold start); Free Postgres deleted after 30 days | Render as Postgres: free tier PostgreSQL databases expire and are permanently wiped after 30 days! Free web services suffer 50s cold starts after 15m idle. |
| Cloudflare | Edge Network | Free Plan | 5 GB D1 SQLite, 10 GB R2 object storage | 100,000 Workers requests/day, 5M D1 reads/day, 5M Vectorize queries/mo | Always warm across 300+ global edge locations; 0ms cold starts | Cloudflare D1 & Vectorize: Workers free plan has a hard 10ms CPU time limit. V8 isolates cannot run Python ML libraries (PyAV, Whisper, PyTorch). Must hop to Workers AI or external GPU clusters. |
| Modal | Compute & Hosting | Free Tier ($30/mo Credit) | Ephemeral container disk + volume storage | $30/month recurring compute credit | Containers shut down when idle (zero cost while inactive; 1-2s container cold boot) | Stateless: must maintain an external database and object store to persist state and query embeddings. |
| Neon | Serverless Database | Free Tier | 1 GB storage per project | 100 compute unit (CU) hours/mo | Compute scales to zero after 5 minutes of idle (1-3s wake-up cold start) | Requires external queue workers, object storage, and custom migration scripts for AI model updates. |
| Supabase | Serverless Database | Free Tier | 500 MB database, 1 GB file storage | Shared compute, 500k Edge Function invocations/mo | Projects automatically paused after 7 days of inactivity | External compute service required for heavy media transforms (Deno runtime cannot run ffmpeg/Whisper); manual vector backfill scripts. |
| Turso | Serverless Database | Starter Free | 5 GB total storage | 500M row reads/mo, 10M row writes/mo | Free databases are archived after 10 days of inactivity | Requires external file storage for media and custom Python workers to encode vectors before insertion. |
| Prisma Postgres | Serverless Database | Public Beta Free | 500 MB storage | Shared compute pool | No forced sleep during public beta | Requires external worker processes for media processing and model inference; manual backfill scripts. |
| Convex | Serverless Database | Free Plan | 1 GB file & document storage | 1 Million function calls/mo | No dormancy pause on active free accounts | Requires external HTTP compute service to run ffmpeg or local ML models; action/mutation hopping. |
| Vercel | Compute & Hosting | Hobby Free | Edge KV / Blob / Postgres (via partner integrations) | 100,000 serverless function executions/mo, 100 GB-hours | Scale-to-zero serverless lambdas; cold starts on idle wake | Stateless frontend platform: requires external database and background task workers for long-running ETL. |

### Past free

| Provider | Card needed | At the limit | Next plan | Regions |
| --- | --- | --- | --- | --- |
| Pixeltable | [not published](https://www.pixeltable.com/pricing) | [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](https://www.pixeltable.com/pricing) | [Pro $29/mo plus usage, incl. $25 usage; $0.035 per vCPU-hour, $0.0175 per GiB-hour](https://www.pixeltable.com/pricing) | [not published](https://www.pixeltable.com/pricing) |
| Railway | [No for the trial; the Free plan does not say](https://railway.com/pricing) | [At a zero credit balance the subscription is cancelled; whether services stop is not published](https://docs.railway.com/pricing/plans) | [Hobby $5/mo incl. $5 usage; $20/vCPU-mo, $10/GB RAM-mo](https://docs.railway.com/pricing/plans) | [One region on Free; choosing a region needs the trial or a paid plan](https://railway.com/pricing) |
| Render | [Not required for free instances](https://render.com/docs/free) | [Suspended until month end after 750 instance hours or the bandwidth cap without a card](https://render.com/docs/free) | [Web Starter $7/mo; Postgres Basic $6/mo](https://render.com/pricing) | [Any of 5: Oregon, Ohio, Virginia, Frankfurt, Singapore](https://render.com/docs/regions) |
| Cloudflare | [No](https://workers.cloudflare.com/) | [Hard stop until midnight UTC: Error 1027 past 100,000 requests a day](https://developers.cloudflare.com/workers/platform/limits/) | [Workers Paid $5/mo; $0.30 per million requests over 10M](https://developers.cloudflare.com/workers/platform/pricing/) | [Every edge location; D1 takes a location hint](https://developers.cloudflare.com/d1/configuration/data-location/) |
| Modal | [Yes, a payment method on file](https://modal.com/docs/guide/billing) | [Billed past the $30 monthly credit unless a workspace budget stops it](https://modal.com/pricing) | [Team $250/mo plus compute](https://modal.com/pricing) | [Region choice costs 1.15x to 1.75x](https://modal.com/pricing) |
| Neon | [No](https://neon.com/pricing) | [Compute suspended when CU-hours or egress run out; writes blocked past storage](https://neon.com/docs/introduction/plans) | [Launch, no minimum; $0.106/CU-hour, $0.35/GB-month](https://neon.com/pricing) | [8 AWS regions in the US, EU and APAC](https://neon.com/docs/introduction/regions) |
| Supabase | [not published](https://supabase.com/pricing) | [Grace period, then paused, read-only or HTTP 402 until the next cycle](https://supabase.com/docs/guides/platform/billing-faq) | [Pro $25/mo; $0.125/GB disk over 8 GB](https://supabase.com/pricing) | [About 19 AWS regions, one per project](https://supabase.com/docs/guides/platform/regions) |
| Turso | [No](https://turso.tech/pricing) | [Hard stop: every database blocked until upgrade or next month](https://turso.tech/pricing) | [Developer $4.99/mo](https://turso.tech/pricing) | [6 AWS locations](https://docs.turso.tech/api-reference/locations/list) |
| Prisma Postgres | [No](https://www.prisma.io/pricing) | [Hard stop: queries refused with PLAN_LIMIT_REACHED until the month resets](https://www.prisma.io/docs/cli/error-reference) | [Starter $10/mo; $8 per million operations over 1M](https://www.prisma.io/pricing) | [6 AWS regions](https://www.prisma.io/docs/postgres/npx-create-db) |
| Convex | [not published](https://www.convex.dev/pricing) | [Writes may fail; a long overrun can make the deployment return errors](https://www.convex.dev/pricing/faq) | [Starter pay as you go; Professional $25 per developer a month](https://www.convex.dev/pricing) | [US East or EU West](https://docs.convex.dev/production/regions) |
| Vercel | [not published](https://vercel.com/docs/plans/hobby) | [No overage: the feature stops until the 30-day window resets](https://vercel.com/docs/plans/hobby) | [Pro $20/mo incl. $20 usage](https://vercel.com/pricing) | [One function region, your choice](https://vercel.com/docs/functions/configuring-functions/region) |

## Free-plan machine

What serves a request on each free plan, from the provider's docs. "Not published" means the docs give no figure.

| Provider | Runtime | CPU | Memory | Scaling | Per request | Source |
| --- | --- | --- | --- | --- | --- | --- |
| Pixeltable | 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 | https://docs.pixeltable.com |
| Railway | 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 | https://railway.com/pricing |
| Render | Not published | 0.1 CPU | 512 MB | 1 instance; sleeps after 15 min | Not published | https://render.com/docs/compute-plans |
| Cloudflare | V8 isolate | 10 ms CPU per request | 128 MB per isolate | Isolates in every edge location | 10 ms CPU, 50 subrequests | https://developers.cloudflare.com/workers/platform/limits/ |
| Modal | 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 | https://modal.com/docs/guide/resources |
| Neon | Serverless Postgres | Not published | Autoscales up to 8 GB (2 CU) | Scales to zero after 5 min | Not published | https://neon.com/docs/introduction/plans |
| Supabase | Postgres instance per project | Shared (Nano) | 0.5 GB | 60 direct, 200 pooled connections | Edge Functions: 2 s CPU, 150 s | https://supabase.com/docs/guides/platform/compute-and-disk |
| Turso | Diskless SQLite, data on S3 | Not published | Not published | Archived after 10 days idle | Not published | https://docs.turso.tech/cloud/durability |
| Prisma Postgres | Unikernel Postgres 17 with PgBouncer | Not published | Not published | 10 pooled and 10 direct connections | 10 s query, 15 s transaction | https://www.prisma.io/docs/postgres/more/known-limitations |
| Convex | 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 | https://docs.convex.dev/production/state/limits |
| Vercel | Fluid compute functions | 1 vCPU | 2 GB | Auto-scales in 1 region | 300 s, 4.5 MB body | https://vercel.com/docs/functions/limitations |

## Critical Provider Deep-Dives: Free Tier Policies & Traps

### Railway as Postgres: A $1 Credit That Needs Sleep (Container PaaS)

**Summary:** Railway provides a one-click PostgreSQL template in its marketplace that spins up an isolated Docker container with a persistent volume.

- **Critical Policy:** After a 30-day, $5 trial, the Free plan gives $1 of usage a month, with each service capped at 1 vCPU and 0.5 GB. At Railway’s published rates an always-on Postgres costs more than that, so on Free the database has to sleep when idle, and the first query after idle pays the wake-up.
- **Architectural Limitation:** Vanilla containerized Postgres without native multimodal primitives or automated embedding pipelines. Developers must build custom Dockerfiles for extensions, write custom Python workers for inference, and coordinate external vector/blob storage.
- **Cost & Dormancy Trap:** An always-on free database runs out of credit; a sleeping one adds a wake-up to the first query after idle.
- **Verdict:** Good for Docker prototypes that sit idle most of the time; an always-on database needs the $5 Hobby plan.

### Render as Postgres: The 30-Day Hard Deletion Rule (30-Day Ephemeral)

**Summary:** Render offers a managed PostgreSQL service alongside its free container web services.

- **Critical Policy:** Render Free Postgres instances expire and are permanently deleted after 30 days. Render does not pause or snapshot the database; after 30 days the database is wiped unless upgraded to a paid tier ($7/mo minimum). Additionally, free web services spin down after 15 minutes of inactivity with a 50-second cold start.
- **Architectural Limitation:** 1 GB storage ceiling with 100 max connections, but zero vector search extensions preconfigured and zero ML runtime capabilities.
- **Cost & Dormancy Trap:** Developers unaware of the 30-day lifecycle risk total data loss if they build permanent applications or benchmarks on Render free Postgres.
- **Verdict:** Strictly a temporary 30-day test sandbox. Never rely on Render free Postgres for continuous production state.

### Cloudflare D1 & Vectorize: Edge SQLite with the 10ms CPU Ceiling (Edge SQLite + V8)

**Summary:** Cloudflare offers D1 (edge SQLite with 5M reads/day, 100k writes/day, 5 GB storage) and Vectorize (vector index with 5M queries/mo and 200k vectors) running inside Workers.

- **Critical Policy:** Free Workers are bound by a strict 10ms CPU execution time limit per request (Standard Free ceiling). A Worker response is fast (17.4 ms warm p50 here), but one D1 row read through the Worker took 57.0 ms in this run, and Workers cannot execute CPU-intensive tasks.
- **Architectural Limitation:** The V8 isolate runtime cannot execute native Python AI packages (PyAV, OpenCV, Whisper, PyTorch, sentence-transformers). D1 also enforces a single primary writer architecture with eventual consistency for edge read replicas.
- **Cost & Dormancy Trap:** To build multimodal AI, developers cannot process media inside Cloudflare Workers. They must call Workers AI (consuming neural compute tokens) or route requests to external GPU workers (Modal, RunPod, AWS), creating network hop latency and multi-vendor dependency.
- **Verdict:** Unbeatable for ultra-low latency edge reads and JSON routing, but completely blocked from native multimodal media pipelines.

## Operational Path 1: Stateless Serverless Compute

Measuring pure transformation and compute execution latency, CPU limits, cold start delay, and burst throughput.

| Platform | Architecture | Warm p50 | min | Burst (req/s) | Cold Start | CPU / Time Limit | Notes |
| --- | --- | --- | --- | --- | --- | --- | --- |
| Cloudflare Workers | Global edge V8 isolates | 17.4ms | 12.3ms | 3259.7 req/s | No container start | 10 ms CPU per request (free plan) | A fixed JSON reply from the edge. It cannot run Python packages such as PyAV, Whisper or PyTorch. |
| Railway | Container PaaS | 16.5ms | 14.9ms | 1996.2 req/s | A wake-up after idle, with Serverless on (as timed here) | Up to 1 vCPU | A FastAPI handler that returns without touching a database. |
| Render | Container web service | 27.2ms | 16.2ms | 150.2 req/s | Sleeps after 15 minutes idle; see the cold-start chart | 0.1 CPU | The same FastAPI handler as Railway, on Render’s free instance in Virginia. |
| Modal | Serverless containers | 38.8ms | 29.1ms | 349.3 req/s | Scales to zero after 60 s idle; see the cold-start chart | 0.125 core by default | The same handler, on Modal’s default container size. |
| Pixeltable Compute Route | add_compute_route on a Pixeltable service | 35.4ms | 29.4ms | 92.2 req/s | Keeps running; stops after 3 idle days | Up to 1 vCPU (Community) | Evaluates a computed column for the request without storing a row. |

## Operational Path 2: Point Reads & Scans (SELECT 10 rows, US-East)

Sequential point/range query read latency for database and edge providers. Lower ms is better.

| Platform | Category | p50 Latency | min | Query Type | Status |
| --- | --- | --- | --- | --- | --- |
| Cloudflare Workers (D1) | database | 57.0ms | 41.5ms | One row by primary key (D1 through the Worker) | 200 OK |
| Railway Postgres | database | 1.8ms | 1.6ms | One row by primary key (SQL wire protocol) | 200 OK |
| Render Postgres | database | 3.2ms | 3.0ms | One row by primary key (SQL wire protocol) | 200 OK |
| Neon Serverless PG | database | 3.1ms | 2.9ms | One row by primary key (SQL over HTTP) | 200 OK |
| Turso libSQL | database | 1.9ms | 1.8ms | One row by primary key (HTTP pipeline) | 200 OK |
| Supabase PostgREST | database | 23.8ms | 15.1ms | GET filtered on id=eq | 200 OK |
| Convex | database | 16.6ms | 12.1ms | ctx.db.get(id) in a query function | 200 OK |
| Pixeltable Query Route | database | 22.9ms | 15.3ms | add_query_route, one row by primary key | 200 OK |

## Operational Path 3: Single Row Ingest & Writes

Measuring sequential single-row insert latency and transactional write mechanisms.

| Platform | p50 Latency | min | Burst Write (req/s) | Write Mechanism | Durability Architecture |
| --- | --- | --- | --- | --- | --- |
| Railway Postgres | 3.0ms | 1.7ms | 2727.7 req/s | INSERT over the SQL wire protocol | PostgreSQL WAL commit |
| Render Postgres | 4.2ms | 3.9ms | 371.6 req/s | INSERT over the SQL wire protocol | PostgreSQL WAL commit |
| Neon Serverless PG | 5.1ms | 3.9ms | 4150.0 req/s | INSERT as SQL over HTTP | PostgreSQL WAL commit |
| Turso libSQL | 25.1ms | 18.0ms | 42.0 req/s | INSERT through the HTTP pipeline | SQLite WAL on the primary |
| Supabase PostgREST | 25.6ms | 17.7ms | 806.6 req/s | PostgREST POST with a JSON body | PostgreSQL WAL commit |
| Convex | 28.6ms | 21.1ms | 1535.9 req/s | Mutation function inserting one document | Convex transaction commit |
| Cloudflare Workers (D1) | 78.9ms | 65.5ms | 326.5 req/s | D1 INSERT through the Worker | D1 primary commit (SQLite) |
| Pixeltable Insert Route | 54.2ms | 45.0ms | 14.2 req/s | add_insert_route: the row and its computed columns, then the response | PostgreSQL row + table version |

## Operational Path 4: Bulk Batch Ingest (100 rows in 1 atomic payload)

Measuring single-payload batch write throughput for persistent database providers.

| Platform | Throughput | Duration | Ingest Method |
| --- | --- | --- | --- |
| Neon Serverless PG | 1153.7 rows/sec | 0.087s | One multi-row INSERT as SQL over HTTP |
| Railway Postgres | 769.7 rows/sec | 0.130s | executemany of 100 INSERTs over the SQL wire protocol |
| Render Postgres | 1387.8 rows/sec | 0.072s | executemany of 100 INSERTs over the SQL wire protocol |
| Supabase PostgREST | 950.0 rows/sec | 0.105s | One JSON array POST to PostgREST |
| Turso libSQL | 1183.1 rows/sec | 0.085s | 100 INSERTs in one transaction in one pipeline request |
| Convex | 334.5 rows/sec | 0.299s | One mutation inserting 100 documents in one transaction |
| Cloudflare Workers (D1) | 650.0 rows/sec | 0.154s | D1 batch: 100 INSERTs in one call |
| Pixeltable Python SDK | 1605.3 rows/sec | 0.062s | t.insert() of 100 rows into the hosted table |

## Media: decode only, or decode, store and insert

20 videos at concurrency 5. The decode group decodes a frame and makes a thumbnail in memory; the store group also uploads the video and thumbnail and inserts a row. Compare rows within a group.

| Platform | Group | Videos/s | p50 | p95 | Run range (videos/s) | Notes |
| --- | --- | --- | --- | --- | --- | --- |
| Railway | decode only | 94.74 | 40ms | 87ms | 81.62 to 96.58 | In-memory PyAV decode of the frame at 0.5 s + thumbnail; nothing stored |
| Render | decode only | 23.33 | 196ms | 305ms | 22.79 to 24.45 | In-memory PyAV decode of the frame at 0.5 s + thumbnail on 0.1 CPU; nothing stored |
| Modal | decode only | 5.55 | 517ms | 1428ms | 4.5 to 34.94 | In-memory PyAV decode of the frame at 0.5 s + thumbnail on the default 0.125 core; nothing stored |
| Pixeltable Media Route | decode, store, insert | 1.84 | 1795ms | 5687ms | 1.72 to 1.98 | add_insert_route: video to R2, frame at 0.5 s, thumbnail to R2, row in PostgreSQL, then the response |
| Railway + Postgres + object storage | decode, store, insert | 11.72 | 388ms | 512ms | 10.16 to 12.08 | Same steps in FastAPI: video and thumbnail to Supabase Storage, row in Railway Postgres |
| Render + Postgres + object storage | decode, store, insert | 9.25 | 472ms | 744ms | 8.92 to 9.75 | Same steps in FastAPI: video and thumbnail to Supabase Storage, row in Render Postgres |
| Pixeltable Media Route (background=True) | decode, store, insert | 1.71 | 2219ms | 6815ms | 1.1 to 1.92 | Same work in the background; timed from submit until the job reports done |

## Cold start

The first request after 20 minutes with no traffic, on a new connection, beside a new connection to the then-awake server.

| Platform | First request | Awake, new connection | Wake-up cost |
| --- | --- | --- | --- |
| Cloudflare Workers | 115ms | 83ms | 32ms |
| Convex | 184ms | 90ms | 95ms |
| Modal | 4402ms | 49ms | 4363ms |
| Neon Serverless PG | 636ms | 27ms | 605ms |
| Pixeltable Compute Route | 135ms | 78ms | 93ms |
| Railway | 2618ms | 39ms | 2579ms |
| Railway Postgres | 50ms | 33ms | 20ms |
| Render | 22163ms | 61ms | 22102ms |
| Render Postgres | 426ms | 205ms | 220ms |
| Supabase PostgREST | 888ms | 86ms | 736ms |
| Turso libSQL | 256ms | 38ms | 204ms |
| Vercel | 129ms | 43ms | 79ms |

## Burst (c=50)

Each row keeps that many requests in flight for the load window, after warming as many connections. Throughput is successful requests divided by the window.

| Platform | Throughput | Requests | Success | p50 | p99 | Window | Notes |
| --- | --- | --- | --- | --- | --- | --- | --- |
| Cloudflare Workers | 3259.7 req/s | 48972 | 100% | 14ms | 49ms | 15.02s | A fixed reply from the edge isolate. |
| Railway | 1996.2 req/s | 30029 | 100% | 23ms | 79ms | 15.04s | The FastAPI handler; no database. |
| Render | 150.2 req/s | 2297 | 100% | 304ms | 595ms | 15.3s | The FastAPI handler on the 0.1 CPU free instance; no database. |
| Modal | 349.3 req/s | 5868 | 100% | 44ms | 1136ms | 16.75s | The FastAPI handler in Modal’s default container; no database. |
| Pixeltable Compute Route | 92.2 req/s | 1416 | 100% | 488ms | 1268ms | 15.37s | A computed column per request; no row stored. |
| Neon Serverless PG | 4150.0 req/s | 62271 | 100% | 10ms | 36ms | 15s | One INSERT per request as SQL over HTTP. |
| Turso libSQL | 42.0 req/s | 674 | 100% | 1135ms | 1680ms | 16.06s | One INSERT per request; the single writer serializes them. |
| Supabase PostgREST | 806.6 req/s | 12204 | 100% | 53ms | 278ms | 15.13s | One row per request through PostgREST. |
| Convex | 1535.9 req/s | 23083 | 100% | 28ms | 93ms | 15.03s | One mutation per request. |
| Cloudflare Workers (D1) | 326.5 req/s | 4950 | 100% | 132ms | 434ms | 15.16s | One D1 INSERT per request through the Worker. |
| Pixeltable Insert Route | 14.2 req/s | 259 | 100% | 2797ms | 7906ms | 18.22s | Each request inserts a row and computes its columns before answering. |
| Railway Postgres | 2727.7 req/s | 41010 | 100% | 5ms | 123ms | 15.03s | One INSERT per request on its own connection (SQL wire protocol). |
| Render Postgres | 371.6 req/s | 5649 | 100% | 102ms | 400ms | 15.2s | One INSERT per request on its own connection (SQL wire protocol). |

## Extreme concurrency (c=100)

Each row keeps that many requests in flight for the load window, after warming as many connections. Throughput is successful requests divided by the window.

| Platform | Throughput | Requests | Success | p50 | p99 | Window | Notes |
| --- | --- | --- | --- | --- | --- | --- | --- |
| Cloudflare Workers | 5063.1 req/s | 76499 | 100% | 18ms | 46ms | 15.11s | A fixed reply from the edge isolate. |
| Railway | 1993.3 req/s | 29970 | 100% | 47ms | 108ms | 15.04s | The FastAPI handler; no database. |
| Render | 141.8 req/s | 2210 | 100% | 701ms | 1000ms | 15.59s | The FastAPI handler on the 0.1 CPU free instance; no database. |
| Modal | 345.7 req/s | 6086 | 100% | 117ms | 1245ms | 17.53s | The FastAPI handler in Modal’s default container; no database. |
| Pixeltable Compute Route | 92.2 req/s | 1439 | 100% | 1019ms | 1814ms | 15.61s | A computed column per request; no row stored. |
| Neon Serverless PG | 4881.7 req/s | 75147 | 98% | 17ms | 96ms | 15.02s | One INSERT per request as SQL over HTTP. |
| Turso libSQL | 37.5 req/s | 640 | 100% | 2550ms | 3860ms | 17.08s | One INSERT per request; the single writer serializes them. |
| Supabase PostgREST | 751.2 req/s | 11451 | 100% | 123ms | 377ms | 15.24s | One row per request through PostgREST. |
| Convex | 2402.2 req/s | 36121 | 100% | 36ms | 151ms | 15.04s | One mutation per request. |
| Cloudflare Workers (D1) | 428.8 req/s | 6709 | 100% | 184ms | 1386ms | 15.65s | One D1 INSERT per request through the Worker. |
| Pixeltable Insert Route | 15.6 req/s | 293 | 100% | 4434ms | 12133ms | 18.76s | Each request inserts a row and computes its columns before answering. |
| Railway Postgres | 3203.8 req/s | 48096 | 100% | 10ms | 92ms | 15.01s | One INSERT per request on its own connection (SQL wire protocol). |
| Render Postgres | 367.6 req/s | 5624 | 100% | 205ms | 694ms | 15.3s | One INSERT per request on its own connection (SQL wire protocol). The server refused connection 97, so this row ran 96 at once. |
| Modal Async (.spawn) | 302.1 req/s | 4929 | 100% | 265ms | 924ms | 16.32s | background_task.spawn() returns before the function runs. |

## Separate checks

### Microburst at c=350

500 requests at c=350 against one API key, in each of 3 runs. 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

25,000 by 25,000 PNG to the photo insert route. 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 synchronous inserts at c=250. 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 at c=200 to /docs/async. 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.

## Architectural Matrix: State vs. State + Flow

| Dimension | Category | Pixeltable (State + Flow) | Traditional Cloud (Frankenstack) | Why It Matters |
| --- | --- | --- | --- | --- |
| Where data and compute live | Plumbing | Tables declare their computed columns and HTTP routes in one Python schema | A database (Neon, Turso, Supabase) wired to compute (Modal, Railway, Vercel) by your code | One deploy and one source of truth, instead of keeping a database, workers and an API in step. |
| Background work | Plumbing | background=True on a route: a job id comes back first, with a status URL | A task queue (Celery, BullMQ, Inngest, QStash) and often a Redis broker, provisioned and paid for separately | No queue to run. The acknowledgement is not the work: the media chart times the background route until the job is done. |
| Work on insert | Plumbing | Computed columns run when a row is inserted, from any writer | Workers triggered by webhooks or polling, with dispatch code in every writer | A new writer cannot forget to trigger the pipeline. |
| Video, audio and images | Media & ML | Video, Audio, Image and Document column types, decoded with FFmpeg and PyAV inside the engine | URLs or blobs in the database; decoding in a separate worker, since edge isolates cannot load FFmpeg | Frames and thumbnails are columns of the same row, with no transcode service in between. |
| Models and AI APIs | Media & ML | Local models (Hugging Face, CLIP) run in the engine; API calls (Gemini, Groq, OpenAI) get retries, rate limits and stored results | Databases cannot run models, and the Cloudflare and Vercel free plans cap CPU or bundle size below model weights | Inference sits next to the data, and a stored result is read without calling a paid API again. |
| Embedding index | Media & ML | An embedding index on a column, updated on every insert | Embedding calls in application code, then upserts to a separate vector store | The index cannot drift from the rows, and a deleted row leaves no orphaned vector. |
| Changing a model | Maintenance | Change the embedder in the schema; pxt schema update rebuilds the index in place over every row | A migration script that walks every row and handles the API rate limits itself | A model swap is a schema edit, not a backfill job. |

## How a number gets onto this page

Every number comes from 3 runs of one harness, spread over a day, from AWS us-east-1 (every test) and eu-west-1 (latency, reads, cold start); the page shows each metric's median and its lowest and highest run. The harness, the code every target ran and the raw results: https://github.com/pixeltable/pixeltable-vs-supabase-vs-convex/tree/main/cloud-providers

One run against your own deployments (`remote_loop.sh` schedules the published ones):

```bash
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
```

## 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 | Pixeltable Insert Route (background=True) | 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 | Pixeltable Compute Route (background=True) | 970 × 503 Service Unavailable | Left out |
| Burst, c=50 | Pixeltable Insert Route (background=True) | 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 | Pixeltable Compute Route (background=True) | 905 × 503 Service Unavailable | Left out |
| Extreme, c=100 | Pixeltable Insert Route (background=True) | 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 |

## Benchmarking Methodology, Dormancy Defense & Disclosures

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

