SQLite (WAL mode)
SQLite project (sqlite.org) · databases · reviewed by Stan K. · Source: data snapshot · data as of 2026-11-12
Single file, zero server, public domain — 10–50K reads/s on NVMe and two production radars run on it with zero admin hours; one writer at a time (WAL) is the ceiling that eventually sends you to Postgres.
#1 of 9 in Databases
ToolScore breakdown — why 92/100
10 criteria × 10 points. Low pillars are visible on purpose — that's the point of a score you can audit. Methodology →
What it does well
- ▸$0 and public domain — no server, no bill, no vendor
- ▸10–50K reads/s on NVMe — reads almost never force the move to Postgres
- ▸Our own radar stack (two production scanners) runs on single-file SQLite with zero admin hours
- ▸Rails 8 and Laravel ship it as the default now — the mainstream has caught up
- ▸WAL keeps readers from ever blocking the (single) writer
Where it costs you
- ▸Single-writer is real: WAL allows one writer at a time
- ▸WAL works best with small transactions — above ~100MB per transaction the rollback journal is faster, above ~1GB you risk an I/O error
- ▸Features decide before load does: RLS, PostGIS, pgvector → Postgres, at any traffic level
- ▸The >500–1,000 concurrent-writes threshold is a community heuristic, not an sqlite.org number — measure before you migrate
Hidden traps — the stuff the pricing page doesn't say
WAL allows exactly one writer at a time; readers never block that writer. sqlite.org confirms the shape — the migration threshold beyond it (>500–1,000 concurrent writes) is a community rule of thumb from the Rails-8-on-SQLite crowd (37signals, Fly.io), not an official number. Measure before you migrate.
Above ~100MB per transaction the rollback journal is faster than WAL; above ~1GB you risk an I/O error (sqlite.org/wal.html). Batch, don’t balloon.
The busy_timeout 5000 you’ll see everywhere is a convention (DB Browser’s default), not an official recommendation — tune it to your workload instead of inheriting it.
Know the limits before you pay: read the traps above, then decide with eyes open.
Visit official siteAffiliate link where available — never affects the score.
- official sqlite.org WAL documentation — one writer, transaction sizes (official) verified
- official sqlite.org pragma docs — busy_timeout verified
Data as of 2026-11-12. Prices and limits change monthly — report anything stale. How we verify: methodology.
Closest alternatives
Row-based pricing with the largest free cap in the table — 500M reads + 10M writes/mo covers our her
The BaaS whose exit is pg_dump — Supabase → any Postgres in 1–5 days, zero schema change — $25/mo Pr
Postgres on a Hetzner CX23 (2 vCPU / 4GB / 40GB, 20TB traffic) at €5.99/mo ex. VAT — the box that be
SQLite (WAL mode) review
In-depth analysis · last updated 2026-11-12
The value pick is a file
SQLite in WAL mode is a single file with zero server, public domain, $0 — and it tops this comparison at 92 because the evidence is ours: our own radar stack (two production scanners) runs on single-file SQLite with zero admin hours. The read ceiling is 10–50K reads/s on NVMe, and as the hub puts it, reads almost never force the move — that is more throughput than most apps will ever need. Rails 8 and Laravel now ship SQLite as the default: the mainstream arrived where the embedded crowd always was.
The ceiling is honest and documented
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. Above ~100MB per transaction the rollback journal is faster; above ~1GB you risk an I/O error. The famous “>500–1,000 concurrent writes → Postgres” threshold is a community heuristic — the Rails-8-on-SQLite crowd (37signals, Fly.io), not an sqlite.org number. The direction is right; the exact threshold depends on your fsync path. Measure before you migrate. And features can decide before load does: RLS, PostGIS, pgvector → Postgres, at any traffic level.
How the pillars land
Price/Value 10: $0, public domain, no server to rent. Real limits 8.5: 10–50K reads/s on NVMe against one writer at a time and the 100MB/1GB transaction walls — published, with the heuristic labeled as a heuristic. Latency & cold starts 9.5: reads almost never force the move — and there is no server to cold-start. Data handling 9: single file on your own disk, zero server — the data never leaves hardware you control. Portability & export 10: the export is a file copy; the license is public domain. Feature set 8: WAL, embedded/edge, CI — docked because RLS, PostGIS and pgvector live in Postgres. Track record 10: sqlite.org documentation precise enough to separate official thresholds from community heuristics, plus two production radars of our own on it. Ease of use 9.5: zero admin hours is not marketing here, it is our ops log. Pricing transparency 10: there is no price to hide. Support & docs 7: the docs are reference-grade — the support model is you plus sqlite.org.
Verdict — BEST VALUE, 92/100
Start here. For read-heavy single-server apps, embedded and edge workloads, and CI, SQLite in WAL mode is the right default — free, portable, and fast enough that reads will not be the reason you leave. The migration triggers are few and legible: one writer at a time, transactions that balloon past ~100MB, or a feature (RLS, PostGIS, pgvector) that only Postgres has. Until one of those fires, the database bill is a non-event.