ToolScore

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.

Value pick SQLite (WAL mode) 92/100

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
Turso Row-based (rows read / written) libSQL · “joining Supabase” 10.2026 $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
Supabase Instance + egress (BaaS) $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
Neon CU-hours (compute) + storage $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
MongoDB Atlas Hourly (cluster tier) ≈$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
PlanetScale Provisioned (usage-based from PS-5) Postgres now · Vitess/MySQL legacy $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
Firebase Firestore Per-document operations $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.

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
SQLite (WAL mode) single file, zero server Read-heavy single-server apps, embedded/edge, CI — Rails 8 and Laravel ship it as the default now Public domain 92/100
Postgres on a VPS Hetzner CX23: 2 vCPU / 4GB / 40GB 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
Turso embedded replicas SQLite at the edge, writes at the center 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

5K DAU loading a 500-doc catalog with no pagination turns a $30/mo app into an $800/mo app. A runaway function loop: $10 → $4,976. The community ceiling: a $50 bill that reached $70,000. Nothing stops it for you — Firestore bills Security Rules 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.
When managed wins
Spikey serverless traffic — scale-to-zero (Neon, Turso) bills $0 for idle while an idle VPS bills anyway. Failover and Multi-AZ you don’t build at 2 a.m. Zero ops. And at our hero workload the free tiers of Turso, Neon and Firestore genuinely cover the month at $0.
When self-host wins
50GB+ of storage or egress — at $0.09/GB, egress becomes the product you’re buying. Predictable load: provisioned once, ignored for months. And you being (or hiring) a sysadmin: 2–4 h/mo of admin is $150–300 of opportunity cost at $75–150/h, plus backups to R2/B2 ($1–3/mo) and monitoring ($0–5). Price the exit before you enter: Supabase → Postgres is pg_dump, 1–5 days ($500–3K); Firestore → SQL is a 2–6 week rewrite ($5–25K+).

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

Data freshness
Snapshot 2026-11-12. Pricing moves fast in this market: Turso’s Developer plan reads $5.99/mo while its own meta description still says $4.99, and PlanetScale’s engine is Postgres now with Vitess/MySQL as a legacy line. Turso is “joining Supabase” (announced 02.10.2026) — the product continues under new ownership. Every number above carries its source; cells without one don’t exist on this page.

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