ToolScore

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

Try SQLite (WAL mode) for $0
Real price
$0 · OSS
open-source
Free tier
Yes
$0 and public domain — no server, no account, no bill. Rails 8 and Laravel ship SQLite as the default now.
Limits
8.5/10
$0 · public domain · single file, zero server — 10–50K reads/s on NVMe
Verdict
BEST VALUE
Single file, zero server. 10–50K reads/s on NVMe; WAL allows exactly one writer at a time (readers never block

ToolScore breakdown — why 92/100

Price / Value
10.0
Token & Rate Limits
8.5
Speed / Latency
9.5
Privacy & Retention
9.0
BYOK (Own API Key)
10.0
Output Quality
8.0
Stability
10.0
Ease of Setup
9.5
Billing Transparency
10.0
Support & Community
7.0

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

medium riskOne writer at a time

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.

medium riskTransaction size has hard physics

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.

low riskbusy_timeout 5000 is a convention, not a rule

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.

Try SQLite (WAL mode)

Know the limits before you pay: read the traps above, then decide with eyes open.

Visit official site

Affiliate link where available — never affects the score.

What the advertised price hides
$0 and public domain — no server, no account, no bill. Rails 8 and Laravel ship SQLite as the default now.
Sources & freshness

Data as of 2026-11-12. Prices and limits change monthly — report anything stale. How we verify: methodology.

Closest alternatives

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.

From the insights