tursovsneon

what you're actually comparing

Turso is a globally distributed database built on libSQL, a fork of SQLite made for this purpose. Its defining feature is embedded replicas: a local SQLite file sitting next to your application that syncs with a remote primary. Reads hit the local file and return in under a millisecond with no network round trip; writes go to the primary and replicate outward. As of 2026, embedded replicas are free on every plan, including the free tier — which used to be the paywalled headline feature.

Neon is serverless Postgres, built by separating storage from compute so the database can suspend when nobody's using it and wake quickly when traffic arrives. Its other signature feature is branching: instant copy-on-write database branches that include the data, so every pull request can have a real database. Databricks acquired Neon in May 2025 for roughly $1 billion and has been folding the technology into Lakebase, its serverless Postgres layer for AI agent workloads; Neon still ships as a standalone product.

These are not straightforwardly competitors. They're two different answers to "what should a database do when nobody's looking at it" — Turso says be everywhere, Neon says be nowhere, cheaply.

pricing, honestly

Turso has an unusually generous free tier: 5GB of storage, 100 databases, and 500 million row reads a month. Developer is $4.99/month for unlimited databases, 9GB and 500 monthly active databases; Scaler is $24.92/month for 24GB and 2,500; Pro is $416.58/month for 50GB and 10,000. The tiering is built around how many databases are active, which tells you what Turso expects you to do with it — one database per tenant.

Neon's free tier is 0.5GB of storage and 100 compute-unit-hours per project per month with 10 branches, and compute scales to zero after five minutes idle. The paid plans changed shape after the Databricks deal and are now the more interesting half: no monthly minimum at all. Launch is $0.106 per compute-unit-hour, Scale is $0.222, storage on both is $0.35 per GB-month (down roughly 80% post-acquisition), and extra branches are $1.50 per branch-month.

The practical difference: Turso's free tier is more generous in absolute terms, but Neon's paid tier can cost less than Turso's $4.99 plan if your database actually idles, because you're billed by the hour for compute you use rather than for a plan you're on.

edge: neon for bursty or low-traffic apps, turso if you need a lot of separate databases.

where neon wins

It's Postgres. Extensions, pgvector, full SQL, every ORM, every tool. Turso's SQLite dialect is capable but it is not this.

Branching with data. A real database per pull request, created instantly, thrown away after merge. Once a team works this way they don't go back.

True scale-to-zero with no floor. No monthly minimum means an app with three users a day costs cents, not a plan fee.

Write throughput. Postgres handles concurrent writes in a way single-primary SQLite fundamentally does not.

Post-acquisition pricing went the right way. Acquisitions usually mean price rises. This one cut storage ~80% and removed the minimums.

where turso wins

Read latency, globally. If your users are on four continents and reads dominate, an embedded replica answering from a local file beats any amount of Postgres tuning. There's no network hop to optimize because there's no network hop.

Database per tenant, affordably. Turso's pricing is explicitly built for thousands of small databases. Giving every customer genuine physical isolation is a compliance story most architectures can't tell cheaply.

Local-first and offline. The data is a SQLite file. Apps that must keep working without a network are natural here and awkward everywhere else.

Embedded replicas are now free. They used to be the reason to upgrade; as of 2026 they're on every plan including free, which makes evaluating Turso properly much cheaper.

Small, fast, and boring underneath. SQLite is the most deployed database in the world and its failure modes are extremely well understood.

things to know before you pick

Single-primary writes are the ceiling. Every write in Turso goes through one primary. Read-heavy workloads love this; write-heavy ones hit a wall that no replica configuration solves.

SQLite's type affinity will surprise you. It's looser than Postgres about types. Fine once you know; a source of genuinely baffling bugs until you do.

Neon's cold starts are real. Compute suspends after five minutes idle on free, and waking it can take one to three seconds. Fine for most apps, wrong for latency-critical ones with unpredictable traffic.

Neon's roadmap now runs through Databricks. The product is standalone today and the pricing moved in users' favour, but its long-term direction is tied to Lakebase and an AI-agent-shaped strategy. Worth knowing if you're planning five years out.

Don't pick Turso for the novelty. If your users are in one region and your traffic is ordinary, Postgres is the right answer and edge replication is a solution to a problem you don't have.