Databases: ranked by the monthly bill for a real workload
The easy pick by value, not by hype. Our metric is what a real month costs: 1M reads + 100K writes against ~1GB of data with 5GB egress — the shape of a small app with actual users. The free tier gets you in; the operation takes you down — so every row prices the tier the free tier graduates into. Vendors bill different units (documents, rows, CU-hours, provisioned cores); we normalize all of them to one monthly bill and keep the traps attached.
Managed — you pay the operation, not the storage
Same workload for every provider, prices from the vendor’s own pricing pages. Sorted by value at that workload — trap exposure (no spend cap, 2× multi-region, tier cliffs) caps the score. Free tier shown with its caps, because the caps are the product’s real shape.
Single file, zero server — our own two production radars run on it with zero admin hours, at 10–50K reads/s on NVMe (the self-hosted table below has the row).
| Provider | Our workload /mo | Free tier caps | What scales the bill | Score |
|---|---|---|---|---|
| | $0 1M reads = 0.2% of the free cap · Developer plan $5.99/mo (2.5B reads / 25M writes) | 500M reads + 10M writes/mo · 100 DBs · 5GB | Rows READ: an unindexed SELECT bills every row it scans | 88/100 |
| | $25/mo Pro — 1GB data outgrows the 500MB free tier · includes $10 compute credits (one Micro instance) | 500MB DB + 1GB files + 5GB egress · pauses after 7d idle | Egress: $0.09/GB past 250GB on Pro, plus compute add-ons | 84/100 |
| | $0 scale-to-zero · ≈$19.35/mo always-on (0.25 CU) + $0.35/GB storage | 100 CU-h/mo · 1GB storage · scale-to-zero after 5 min | Always-on compute: a 0.25 CU that never sleeps burns 182.5 CU-h/mo | 78/100 |
| | ≈$8/mo Flex floor — 1GB doesn’t fit M0’s 512MB · Flex caps at $30/mo, then M10 starts at $56.94/mo | M0: 512MB · 100 ops/s · 500 connections | The tier cliff: Flex caps at $30/mo, M10 “starts at $56.94/month” | 61/100 |
| | $5/mo PS-5 single node · $15/mo HA 3-node · no free tier | None — free tier retired (verified 11.2026) | Provisioned compute + storage past 10GB | 58/100 |
| | $0 if even — ≈33K reads/day under the daily caps · $0.39/mo spiky (us-central1) | 50K reads/DAY + 20K writes/DAY · 1GiB · 10GiB egress/mo | Spike days over the daily caps — every read above them is billed | 54/100 |
Click a provider for the full picture — the traps, the score breakdown on the 10 pillars and the billing math live on its review page. Workload prices derive from the verified unit prices: Firestore $0.39 = 10 × $0.03 reads + 1 × $0.09 writes per 100K (us-central1); Neon $19.35 = 0.25 CU × 730 h × $0.106; Atlas’s 1GB dataset doesn’t fit M0’s 512MB, hence the Flex floor. Scores are our editorial estimate (0–100) of value per dollar at the hero workload.
- Firestore Blaze has NO hard spend cap: requests “will succeed even if you have exceeded your monthly budget” — Google’s own docs. The bill-shock ladder: $30 → $800/mo.
- Atlas Flex → M10 is a cliff, not a step: $0.08/h the moment you outgrow Flex’s 5GB — M10 “starts at $56.94/month”.
- “Turso is joining Supabase” (official blog, 02.10.2026) — the product continues, deal terms not published.
- Turso Developer is $5.99/mo (2.5B reads / 25M writes) — the $4.99 in their own meta description is stale.
Self-hosted & SQLite — you pay the sysadmin, not the operation
No per-operation price exists here: the cost model is a fixed VPS (or nothing) plus admin hours. This table is deliberately not price competition with managed — a €5.99 VPS “beats” $25/mo managed only if your hours are free. Sorted by fit for the job.
| Option | When it wins | License / status | Score |
|---|---|---|---|
| | Read-heavy single-server apps, embedded/edge, CI — Rails 8 and Laravel ship it as the default now | Public domain | 92/100 |
| | 50GB+ of storage or egress, predictable load, and a sysadmin on call — €5.99/mo ex. VAT + 20TB traffic vs managed $25–60+ for 1–4GB RAM | PostgreSQL License (permissive) | 80/100 |
| | Local-first apps: reads from the local file in microseconds, writes synced to a managed primary | libSQL (SQLite fork) · “joining Supabase” 10.2026 | 72/100 |
| LiteFS SQLite replication on Fly.io | Was the edge-SQLite answer — now a cautionary tale | Cloud retired 15.10.2024 · “outside our scope of support” | 22/100 |
Click an option for our full take — the true-cost math for the VPS (backups, monitoring, admin hours), the sync-page mechanics for embedded replicas, and the score breakdown on its review page. Hetzner note (checked 11.2026): all CX plans showed “not available” on the page; the same class of hardware sits at ARM CAX11 (2 vCPU/4GB, €6.49) and CPX12 (1 vCPU/2GB, €9.99), CX33 at €8.99 — EU prices ex. VAT, 20TB traffic. Scores are our editorial estimate (0–100) of fit for the job.
Bill shock — the free tier’s fine print, priced
$30 → $800/mothe price of one missing LIMIT clause
get()/exists() as reads, nam5 doubles every rate, and Blaze has no hard spend cap
(requests “will succeed even if you have exceeded your monthly budget”). The exits are boring and yours to
build: paginate every query, cache aggressively, alert on daily read counts, and write your own kill switch.
The SQLite ceiling — where Postgres stops being optional
sqlite.org confirms the shape: WAL allows exactly one writer at a time, readers don’t block that writer, and WAL works best with small transactions. The famous migration thresholds beyond that are community heuristics — and we label them as such.
>500–1,000 concurrent writes → Postgres (heuristic)
Not an sqlite.org number — a rule of thumb from the Rails-8-on-SQLite crowd (37signals, Fly.io). The direction is right; the exact threshold depends on your fsync path. Measure before you migrate.
Transaction size (official)
WAL loves small transactions: above ~100MB per transaction the rollback journal is faster, above ~1GB you risk an I/O error (sqlite.org/wal.html). Batch, don’t balloon. busy_timeout 5000 is a convention (DB Browser’s default), not an official recommendation.
Features decide before load does
RLS, PostGIS, pgvector → Postgres, at any traffic level. Reads almost never force the move: 10–50K reads/s on NVMe is more than most apps will ever need.
The stack around the database
For a solo builder the database sits under AI you’re already paying for: the AI Coding Plans ranking prices the agentic layer and the TTS comparison the voice layer — both are dwarfed by a database bill nobody modeled. The self-hosted storage and backup math (B2 + pgBackRest/WAL-G) is on the roadmap.
What to look for in a database
The free tier is a trial, not a plan
Supabase pauses after 7 idle days (nothing is deleted), Firestore caps by the day (50K reads/DAY, not per month), Atlas M0 stops at 512MB, PlanetScale has no free tier at all. Price the paid tier you’ll graduate into on day one.
Know your billing unit
Per-document ops (Firestore), CU-hours (Neon), rows read (Turso), provisioned compute (PlanetScale), hourly cluster (Atlas). The same workload lands on wildly different bills — and Turso’s unindexed SELECT is a full-table bill.
Spend caps are yours to build
Only Atlas Flex publishes a monthly cap ($30). Firestore/Blaze explicitly serves traffic past your budget. Alerts are not caps; kill switches are.
The exit is part of the price
Supabase exits with pg_dump in 1–5 days. Firestore → SQL is a 2–6 week, $5–25K+ rewrite. If you can’t afford to leave, you don’t own the architecture.
Deep dives
- The Firestore $30-to-$800 Month — per-document pricing, exploded
- SQLite Carried Our Data Platforms — years with zero database servers
- Managed Database Traps — egress, connections, the M10 cliff
- Postgres on a €6 VPS vs $25 Managed — the honest math, exit costs included
Sources: official pricing pages — Firestore, Firebase, Supabase, Neon, PlanetScale, MongoDB Atlas, Turso; the Turso–Supabase announcement (turso.tech/blog, 02.10.2026); sqlite.org/wal and the busy_timeout pragma docs; Turso embedded replicas docs; Hetzner cloud pricing pages; LiteFS status via Fly’s public docs and repo (superfly/litefs).