IBRAVRA Media Network
Comparisons • 12 min read

Neon vs PlanetScale vs Turso: Serverless Database Pricing Playbook

Three serverless databases, three different meters: Neon bills compute-unit hours plus storage, PlanetScale bills a flat monthly cluster rate, and Turso bills rows read and written. Only two of the three are Postgres — Turso is libSQL — and the cheapest at one workload is the most expensive at the next. This playbook runs the same three workloads through all three price lists.

By Enow A. Jovial • Published 2026-11-16

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.

The meter is the product. Neon charges for the compute you use, PlanetScale charges for the cluster you reserve, and Turso charges for the rows you touch. At the production workload, Turso costs $24.92, PlanetScale $50 plus storage, and Neon $60.00 — at the high-traffic workload the order is PlanetScale $570, Turso $626.58, and Neon $701. Pick the meter that matches your workload shape, not the vendor with the lowest headline price.

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.

AttributeNeonPlanetScale PostgresTursoAuthority
EnginePostgresPostgreslibSQL (SQLite fork)Neon; PlanetScale; Turso pricing
Billing unitCompute-unit hour + GB-monthMonthly cluster SKURows read/written + GBVendor pricing pages
Entry priceFree $0; Launch usage-basedSingle node from $5/moFree $0; Developer $4.99/moNeon; PlanetScale; Turso pricing
Compute rate$0.106/CU-hr Launch; $0.222/CU-hr ScalePS-80 $50/mo ARM (1 vCPU, 8 GiB)Included rows; $0.75–$1 per billion readPricing pages; pricing.md
Storage rate$0.35 per GB-monthEBS billed separately, rate unpublished$0.45–$0.75 per GB over includedPricing pages; pricing.md
Free tier100 CU-hrs/mo + 1 GB per projectNone listed for Postgres5 GB, 500M rows read, 10M rows writtenVendor pricing pages
Scale to zeroYes, after 5 min inactiveNo — cluster is always onIdle databases cost storage onlyNeon; PlanetScale; Turso pricing
Neon's Launch plan: $0.106 per CU-hr, $0.35 per GB-month, typical spend $15 a month, with Scale at a typical $701 a month
Neon's Launch plan: $0.106 per CU-hr, $0.35 per GB-month, typical spend $15 a month, with Scale at a typical $701 a month

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.

Neon monthly=(CU-hours×rate)+(GB stored×$0.35)\text{Neon monthly} = (\text{CU-hours} \times \text{rate}) + (\text{GB stored} \times \$0.35)

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.

PlanetScale monthly=cluster SKU+storage+backups+egress(last three unpublished)\text{PlanetScale monthly} = \text{cluster SKU} + \text{storage} + \text{backups} + \text{egress} \quad (\text{last three unpublished})

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.

Turso monthly=base+max⁡(0,GB−included)×storage rate+max⁡(0,reads−included)×read rate+max⁡(0,writes−included)×write rate\text{Turso monthly} = \text{base} + \max(0, \text{GB} - \text{included}) \times \text{storage rate} + \max(0, \text{reads} - \text{included}) \times \text{read rate} + \max(0, \text{writes} - \text{included}) \times \text{write rate}

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.

Production SaaS, Neon=500×$0.106+20×$0.35=$53.00+$7.00=$60.00\text{Production SaaS, Neon} = 500 \times \$0.106 + 20 \times \$0.35 = \$53.00 + \$7.00 = \$60.00

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.

High traffic, Neon=3,000×$0.222+100×$0.35=$666.00+$35.00=$701.00\text{High traffic, Neon} = 3,000 \times \$0.222 + 100 \times \$0.35 = \$666.00 + \$35.00 = \$701.00

Run the same three workloads through the pricing calculator with your own numbers before committing.

Turso's Developer plan: $4.99 a month, 9 GB of storage, 2.5 billion rows read, 25 million rows written, 10 GB of syncs
Turso's Developer plan: $4.99 a month, 9 GB of storage, 2.5 billion rows read, 25 million rows written, 10 GB of syncs

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

"I do not pick a database by its free tier. I pick it by the bill at the size I will be in six months, because the free tier is a trial and the second tier is the product. Neon's unit price doubles when you grow into Scale, PlanetScale's storage is a second bill you cannot see on the pricing page, and Turso's row meter punishes the one bad query you have not found yet. Price the workload you will have, not the one you have."
— Enow A. Jovial, Founder & Chief Executive Officer

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.

Turso's row meter bills reads, not time. A single missing index on a table scan can read millions of rows per query, and at $0.75 to $1 per billion rows read the bill follows the read count, not the clock. Audit the slow-query log before the first production month — the first bill after a bad deploy is the one that teaches the lesson — and the same warning applies to Neon's branch hours at $0.002 per branch-hour, which accumulate quietly across a fleet of forgotten preview branches.

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.

The cheapest serverless database month is inside a free tier. Neon Free covers 100 CU-hours and 1 GB per project, and Turso Free covers 5 GB and 500 million rows read — enough for a side project's entire workload. Run the free tier for a full month, measure the real compute hours and row reads, and only then choose the paid plan; the vendors' typical-spend figures are marketing.