A serverless database comparison written in November 2026 has a trap the 2025 version did not: two of the three products are Postgres. Neon sells serverless Postgres that autoscales and scales to zero. PlanetScale sells Postgres as a flat monthly cluster. Turso sells libSQL, a fork of SQLite, replicated to the edge. Comparing the three on price alone, without naming the engine, is how a team ends up with a cheap bill and a rewrite. Figures as read on November 16, 2026, from the vendors' pricing pages and PlanetScale's pricing catalog.
What each product actually is
Neon is serverless Postgres built around storage-compute separation, sold as Lakebase Postgres by Databricks. A database is measured in compute units, autoscales, and scales to zero after five minutes of inactivity on Free and Launch. Branching is first-class: each branch is a copy-on-write clone at $0.002 per branch-hour on paid plans. PlanetScale Postgres is the opposite shape: a cluster you pick from a SKU table and pay for monthly, whether it is busy or idle. Single node is one machine, high availability is one primary plus two replicas across three availability zones, and Metal is the same shape on local NVMe with storage included. Turso is the third shape: a SQLite file that replicates. Databases are cheap to create — the Free plan allows 100 — and idle databases cost only storage.
| Attribute | Neon | PlanetScale Postgres | Turso | Authority |
|---|---|---|---|---|
| Engine | Postgres | Postgres | libSQL (SQLite fork) | Neon; PlanetScale; Turso pricing |
| Billing unit | Compute-unit hour + GB-month | Monthly cluster SKU | Rows read/written + GB | Vendor pricing pages |
| Entry price | Free $0; Launch usage-based | Single node from $5/mo | Free $0; Developer $4.99/mo | Neon; PlanetScale; Turso pricing |
| Compute rate | $0.106/CU-hr Launch; $0.222/CU-hr Scale | PS-80 $50/mo ARM (1 vCPU, 8 GiB) | Included rows; $0.75–$1 per billion read | Pricing pages; pricing.md |
| Storage rate | $0.35 per GB-month | EBS billed separately, rate unpublished | $0.45–$0.75 per GB over included | Pricing pages; pricing.md |
| Free tier | 100 CU-hrs/mo + 1 GB per project | None listed for Postgres | 5 GB, 500M rows read, 10M rows written | Vendor pricing pages |
| Scale to zero | Yes, after 5 min inactive | No — cluster is always on | Idle databases cost storage only | Neon; PlanetScale; Turso pricing |
The meters, side by side
Neon's meter is the most transparent of the three, and it contains a surprise: the unit price rises with the tier. Launch bills $0.106 per compute-unit hour; Scale bills $0.222 — more than double — for the same compute unit. The higher tier buys service levels, HIPAA support, and private networking, not cheaper compute, so a workload that grows into Scale pays more per unit than one that stays on Launch. One compute unit is one vCPU with 4 GB of RAM — the page sizes it in pairs, 2 CU to 8 GB and 16 CU to 64 GB.
PlanetScale's meter is a reservation, not a meter at all. Single-node EBS SKUs run from PS-5 at $5 a month (1/16 vCPU, 512 MiB) through PS-80 at $50 (1 vCPU, 8 GiB) to PS-640 at $379 (8 vCPU, 64 GiB). The three-node high-availability SKUs are roughly three times the single-node price at the small end — PS-5 at $15, PS-80 at $148, PS-320 at $570 — and ARM is consistently cheaper than x86-64, by about 15% at PS-160 and above. What the catalog does not publish is the per-GB price of the EBS storage, backups, and egress the SKU price excludes — the price is the cluster SKU only. A PlanetScale total is therefore always the SKU price plus an unpublished amount, and any comparison that quotes the SKU price as the total understates it.
Turso's meter counts work, not time. Every plan includes a block of storage, rows read, rows written, and syncs, and overages are billed per unit at rates that fall as the plan rises: storage overage is $0.75 per GB on Developer, $0.50 on Scaler, and $0.45 on Pro; rows read overage is $1 per billion on Developer, $0.80 on Scaler, and $0.75 on Pro; rows written overage is $1 per million on Developer and $0.80 and $0.75 on Scaler and Pro. The Free plan's 500 million rows read and 10 million rows written a month is a genuine free tier, and Developer at $4.99 a month is the cheapest paid entry here — but the row meter surprises teams, because a single unindexed query can read millions of rows and the bill follows the read count, not the clock.
Three workloads, three bills
The only fair way to compare a compute meter, a reservation, and a row meter is to run the same workload through all three and show the arithmetic. The workloads below are illustrative, built from the published rates read on November 16, 2026: a compute-unit hour on Neon is one CU running for one hour; a row read on Turso is one row returned by a query.
Workload 1 — one side project, 1 GB stored, 10 compute-unit hours a month, 50 million rows read. On Neon Free the month is $0: 100 CU-hours and 1 GB per project are included, and the project uses 10 of each. On Turso Free the month is also $0: 5 GB, 500 million rows read, and 10 million rows written are included, and the project uses a tenth of the read allowance. On PlanetScale the month is $5: the PS-5 single-node SKU is the floor, plus storage, backups, and egress on top. Two vendors are free at this size; PlanetScale lists no free tier for Postgres.
Workload 2 — one production SaaS, 20 GB stored, 500 compute-unit hours a month, 10 billion rows read, 100 million rows written. On Neon Launch the compute is 500 × $0.106 = $53.00 and the storage is 20 × $0.35 = $7.00 — $60.00 a month. On PlanetScale the comparable single-node cluster is PS-80 on ARM at $50 a month — 1 vCPU and 8 GiB against roughly 0.7 CU of average load — plus unpublished storage, backup, and egress. On Turso Scaler the month is $24.92: 10 billion rows read inside the 100 billion included, 100 million rows written exactly on the 100 million included, and 20 GB inside the 24 GB included — nothing overages. Turso wins this workload by more than half, because the included allowances cover it entirely.
Workload 3 — high traffic, 100 GB stored, 3,000 compute-unit hours a month, 200 billion rows read, 500 million rows written. On Neon Scale the compute is 3,000 × $0.222 = $666.00 and the storage is 100 × $0.35 = $35.00, for $701.00 a month — and that figure is not a coincidence: Neon's own page states a typical Scale spend of $701 a month for high load with 100 GB, and the arithmetic reproduces it exactly, which implies the typical load is about 3,000 CU-hours. On PlanetScale the comparable high-availability cluster is PS-320 on ARM at $570 a month — 4 vCPU against about 4.1 CU of average load — plus storage, backups, egress. On Turso Pro the base is $416.58, the 200 billion rows read sit inside the 250 billion included, the 500 million rows written exceed the 250 million included by 250 million at $0.75 per million for $187.50, and the 100 GB of storage exceeds the 50 GB included by 50 GB at $0.45 for $22.50 — $626.58 a month. At this size PlanetScale is cheapest on the published numbers, Turso second, and Neon last — the reverse of the production workload, because Neon's Scale unit rate is the highest of its own tiers.
Run the same three workloads through the pricing calculator with your own numbers before committing.
The ceilings that force upgrades
Every free tier here has a ceiling that ends it, and the ceilings are different shapes. Neon's Free plan caps at 100 CU-hours a month per project, 1 GB of storage per project, and 2 CU of size — a project that needs a 4 CU machine, more than 100 hours of compute, or more than 1 GB of data leaves Free whether it is busy or not. Turso's Free plan caps at 100 databases, 5 GB of storage, 500 million rows read, and 10 million rows written a month — a project that reads 600 million rows leaves Free even if the database is 1 GB. PlanetScale has no free tier to leave: the floor is the PS-5 SKU at $5 a month, and the ceiling is the SKU table itself — a workload that outgrows PS-2560 at 32 vCPU must move to high availability, Metal, or Neki sharding. The Postgres connection pooler is the other ceiling nobody budgets: our PgBouncer and Supavisor playbook prices the pooling layer serverless Postgres needs once connections, not compute, become the limit.
Founder & CEO Insight — Enow A. Jovial
Who should not pick each
Neon is the wrong pick for a workload always on at a fixed size: a database that runs 4 CU around the clock pays $0.106 or $0.222 per CU-hour for 730 hours a month, while PlanetScale's PS-320 reservation is a flat $190 a month for the same 4 vCPU — the autoscaling premium buys nothing when the load never drops. PlanetScale is the wrong pick for a bursty workload that idles most of the month — the cluster bills whether it is busy or not — and for a team that needs a single all-in number before finance approves it, because the storage, backup, and egress rates are unpublished. Turso is the wrong pick for an application that needs Postgres: extensions, Postgres-specific SQL, and the Postgres tooling ecosystem do not run on libSQL, and the migration cost dwarfs any monthly saving. It is also wrong for read-heavy analytics, because the row meter charges for every row a query touches. A team that needs Postgres with a flat bill should look at the managed Postgres pricing comparison instead.
Execution checklist
- [x] Step 1: Measure your real workload. Record one month of compute-unit hours, gigabytes stored, rows read, and rows written before choosing a vendor.
- [x] Step 2: Run the three-workload math. Price the side project, the production SaaS, and the high-traffic month on all three vendors with your own numbers.
- [x] Step 3: Test the engine fit first. If the application needs Postgres extensions or Postgres-specific SQL, Turso is out before pricing starts.
- [x] Step 4: Get the PlanetScale storage number in writing. The SKU price excludes storage, backups, and egress — ask for the full monthly total for your gigabyte count before signing.
- [x] Step 5: Cap the row meter. Set Turso spend alerts on rows read before the first production deploy; set a Neon branch cleanup policy so preview branches do not accumulate branch-hours.
- [x] Step 6: Re-price quarterly. Neon repriced its tiers when it became Lakebase, Turso is joining Supabase, and PlanetScale regenerated its catalog on November 16, 2026. Re-run the three-workload math every quarter.
A note on vendor continuity
Two of the three vendors changed owners or parents in the window this comparison covers. Neon's page brands the product Lakebase Postgres, by Databricks. Turso's page carries a banner announcing that Turso is joining Supabase. PlanetScale's page leads with Neki, its sharded Postgres product, and a catalog regenerated on November 16, 2026 for AWS us-east-1. None of this changes the rates above — every figure is read from the live pages on November 16, 2026 — but a vendor that just joined a larger parent may reprice, rebrand, or retire a tier — re-price on the next quarter's page. The cloud IDE pricing playbook is the cautionary tale for what happens when the vendor behind the meter disappears.

