Loading
Developer Engineering2026-07-28· 10 min read
No fake QPS number.
Just what's documented.
SQLite's own docs on when it stops being the right answer, real hosted pricing for a side-project budget, and a framework for picking one before you've written a line of schema.
SQLite Writers
0
Concurrent writer, per SQLite's own docs
Turso Free Storage
0GB
10x Neon/MongoDB free tier
MongoDB Atlas M0
Free
512MB, shared RAM/vCPU, forever
Neon Free
0 CU-hr
Per month, scale-to-zero
← Back to Global Tech SearchI couldn't run Postgres or
One writer at a time —
Turso's free tier is
Neon's pricing doesn't reduce
Pick by data shape and
Why This Isn't A Query-Per-Second Benchmark
I couldn't run Postgres or
MongoDB here — and said so.
Most “Postgres vs MongoDB vs SQLite” posts show a bar chart of inserts-per-second with no disclosed hardware, dataset size, or query shape — the same unsourced-number problem covered in this site's Kubernetes vs Nomad piece. I looked into running one myself for this post; the sandbox this was written in has no running Docker daemon and no C++ build toolchain available for native SQLite bindings, so a first-hand, apples-to-apples query benchmark wasn't possible here either. Rather than fabricate one, this post is built on each database's own documentation and each hosting provider's own published pricing page instead — which turns out to answer the question a side-project developer is actually asking (“what will this cost and what will break first”) better than a synthetic throughput number would anyway.
What SQLite's Own Docs Actually Say
One writer at a time —
and that's usually fine.
Per SQLite's own “Appropriate Uses For SQLite” page, SQLite supports unlimited simultaneous readers but only one writer at any instant. The same page is refreshingly direct about when that matters: “if many threads and/or processes need to write the database at the same instant (and they cannot queue up and take turns) then it is best to select a database engine that supports that capability” — a client/server engine like Postgres or MongoDB. But it also notes that because a write transaction typically takes milliseconds, multiple writers can simply take turns, and SQLite “will handle more write concurrency than many people suspect.” For a solo developer's side project, an internal tool, or anything “device-local” with low writer concurrency and under a terabyte of data, SQLite's own documentation says it's almost always the better solution — not a toy database, a genuinely recommended one for that shape of workload.
What Each Free Tier Actually Gives You
Turso's free tier is
10x the storage of the others.
As of publishing, MongoDB Atlas's M0 free cluster offers 512MB of storage on shared RAM/vCPU, with no expiration. Neon's free Postgres tier offers 0.5GB of storage plus 100 compute-unit-hours per month, with the database scaling to zero after 5 minutes of inactivity so you only pay (or, on the free tier, consume your allotment) while it's actually handling queries. Turso's free tier — built on libSQL, a SQLite-compatible embedded database with a managed edge-replication layer on top — offers 5GB of storage, 500 million monthly rows read, and 10 million monthly rows written. For a project still finding its shape, that's meaningfully more runway before you hit a paywall.
Free-Tier Storage
Published limits: MongoDB Atlas M0, Neon Free, Turso Free
What It Costs Once You Outgrow Free
Neon's pricing doesn't reduce
to one number — on purpose.
Turso's Developer plan runs a flat $4.99/month for unlimited databases and 9GB of storage. MongoDB Atlas's Flex tier bills hourly at $0.011/hour but is hard-capped at $30/month, covering up to 5GB of storage that scales with operations per second; its dedicated M10 tier (2GB RAM, 2 vCPU) runs a flat $57/month. Neon deliberately doesn't have an equivalent fixed number to chart: its Launch tier bills $0.106 per compute-unit-hour for actual usage with no monthly floor, and its Scale tier bills $0.222/CU-hour — Neon removed its old $5/month minimum spend entirely, so a genuinely idle side project on a paid Neon plan can cost close to nothing between visits, but there's no single sticker price to put in a bar chart the way there is for Turso or MongoDB's dedicated tiers.
Cheapest Fixed-Price Paid Tier
Neon excluded — its Launch/Scale tiers are pure usage-based with no fixed floor
Picking One For A Side Project
Pick by data shape and
writer concurrency, not hype.
SQLite (via Turso, or just a local file)is the right default for a prototype, an internal tool, a local-first app, or anything with one process writing at a time — per SQLite's own documentation, that covers most side projects, and Turso's free tier gives the most storage runway of the three before any money changes hands.
Postgres (via Neon or similar)is the strongest general-purpose default once you need real relational integrity — foreign keys, multi-table transactions, complex joins — or you expect genuinely concurrent writers across multiple server processes. It's also the safer bet if you don't yet know your data shape: Postgres's JSONB support means you can store flexible, schema-less data inside a relational database without committing to MongoDB's document model up front.
MongoDBearns its place when your data is genuinely document-shaped from the start — deeply nested, variable-schema records where forcing a relational model would mean constant migrations — or when a team already has MongoDB expertise and tooling. For a brand-new side project without either of those reasons, it's usually solving a problem you don't have yet.
The honest version of this comparison is boring: read what each project's own docs say it's good at, check what the hosting actually costs at your stage, and pick the one that matches your data shape — not the one with the loudest unsourced benchmark chart.
Written by Abhishek Kushwaha
Founder and writer at Global Tech Search, based in Kathmandu, Nepal. Covers AI, infrastructure, markets, and climate with sourced data and original analysis. More about the author →
Recommended Tools
Affiliate disclosure — we may earn a commission at no cost to you.
Sources
- sqlite.org, Appropriate Uses For SQLite — documented single-writer concurrency model and recommended use cases
- neon.tech/pricing (as reflected across multiple 2026 pricing trackers) — free tier (0.5GB storage, 100 CU-hours/month), Launch ($0.106/CU-hour) and Scale ($0.222/CU-hour) usage-based tiers, no monthly minimum
- mongodb.com/pricing (as reflected across multiple 2026 pricing trackers) — M0 free tier (512MB), Flex ($0.011/hr, capped at $30/month), M10 dedicated ($57/month)
- turso.tech/pricing (as reflected across multiple 2026 pricing trackers) — free tier (5GB storage, 500M rows read/10M rows written monthly), Developer plan ($4.99/month)
This post does not include a first-hand query-throughput benchmark: the environment it was written in had no running Docker daemon and no C++ build toolchain available to compile native database drivers. Pricing figures were cross-checked across multiple independent 2026 pricing trackers rather than fetched directly from a single live pricing page in every case — cloud pricing changes, so verify current rates on each provider's own pricing page before budgeting.
Global Tech Search
Trace the number, or don't repeat it.
More independent, cited breakdowns of the infrastructure decisions that actually matter.
Back to Dashboard →