The DevOps Daily · Serverless Postgres Benchmarks
Neon vs Supabase, measured.
Every number below is the median of repeated runs against real projects in the same AWS region, timed from a client in the same metro. Raw samples ship in the repo; nothing here is quoted from a pricing page.
Read the write-ups: free tiers · operational benchmarks · scaling costs · full comparison
Query latency
Connect + TLS + auth + one query, cold connection each run. Bar is the median, amber tick is p95, the faint line spans min to max. Hover any row for the full spread.
Latency percentiles
The same raw samples as cumulative percentile curves: read p50 and p95 straight off the dashed lines, and how heavy each path's tail is. Hover a curve for its summary.
Project creation
Time until a brand-new project answers SQL. Every dot is one run; hover for its exact time.
Neon cold start
First query against a suspended compute. Docs say 300–500 ms typical.
Neon database branch, to queryable
A writable branch carrying the parent's full dataset. Supabase branching requires a paid plan and starts without data; it will appear here once the paid-tier runs land.
Launch / Pro tier · paid plans
The operational benchmarks.
Neon (Scale account, Launch-tier operations) vs Supabase Pro: the operations that unlock when you pay. Same region, same client, same rules.
Connection stampede
N clients connect at once, each running one query. Bar is the median wave wall-time; tick is the worst wave. Refusals would appear here; there were none.
Branch, to queryable
Neon branches arrive carrying the parent's 100k rows; Supabase branches copy schema and config only (their with-data API path requires pre-existing physical backups and refused every attempt on a fresh project). Every dot is one branch.
Resize: apply time vs outage
Changing compute size, alternating up and down. Apply is when the API says done; outage is how long SQL actually failed (probed every 250ms).
Replica, to first query
Neon replicas share storage with the primary (compute-only); Supabase replicas clone the database (Small compute minimum). Every dot is one replica.
Neon restore to 60 seconds ago
Branch restore to a timestamp, timed until SQL answers on the restored state. Supabase PITR is a $100/month add-on with a 7-day minimum window; we document it rather than benchmark it.
Does it scale with database size?
The same branch and replica operations, repeated as the seeded database grows 50x. Copy-on-write architectures should stay flat; physical clones should grow with data.
Branch creation vs database size
Neon branches carry the data; Supabase Pro branches copy schema only, which is why both lines are flat for different reasons.
Read replica vs database size
Provisioning dominates replica time at these sizes on both platforms; Supabase grows ~12% by 5M rows while Neon's storage-sharing replicas stay flat.
What the same app costs as it grows
One application priced through five growth stages on both platforms. Three regimes: scale-to-zero wins the quiet months, the flat fee wins the middle, and metered auth decides the end game. Assumptions are parameters; rerun the model with your own.
Findings you only get by running it
Supabase free-plan direct hosts are IPv6-only (IPv4 goes through Supavisor), the pooler cluster varies per project, and database TLS chains to Supabase's own CA.
Resize is not one operation
Supabase compute changes restart the database (~39s of measured SQL outage) and are throttled for minutes between changes. Neon resizes applied with zero failed probes across forty cycles.
Data branches have prerequisites
Supabase's with_data branch flag returned 406 "Failed to fetch latest physical backup" on every fresh-project attempt: data-included branches need pre-existing physical backups.
Run history
Median query latency per benchmark session. A flat line is the expected (and boring) result; divergence is news.
Same region, same metro
Both platforms run in aws eu-central-1; the timing client is a VM in Frankfurt, 1 to 2 ms from each. Network distance never puts a thumb on the scale.
Raw samples, not averages
Every operation runs 10 to 50 times. Charts show medians and p95; every individual sample is committed to the repo and visible on hover.
Reproducible by you
The harness is ~600 lines of TypeScript. Bring your own API keys and rerun the whole thing; if your numbers disagree, open an issue.