# Neon vs PlanetScale: Serverless SQL Compared (2026)

URL: https://www.devopsness.com/blog/neon-vs-planetscale
Author: Kiril Urbonas
Published: 2026-08-06
Updated: 2026-10-31
Categories: Cloud
Tags: Neon, Planetscale, Serverless, Postgres, Mysql

Summary: A practitioner comparison of Neon's serverless Postgres against PlanetScale's Vitess-backed MySQL to help you pick the right database.

---
# Neon vs PlanetScale: Serverless SQL Compared (2026)

Choose Neon when you want Postgres that scales to zero, bills per compute-hour, and branches instantly for every pull request. Choose PlanetScale when you want an always-on production database: Vitess MySQL for sharding and non-blocking schema changes, or PlanetScale Postgres from $5 a month. Neon wins on idle cost; PlanetScale wins on predictable latency.

> [!VERIFIED]
> Neon Free, Launch and Scale plans, PlanetScale Postgres and Vitess plans, against the Neon pricing page and scale-to-zero docs and the PlanetScale pricing page and Vitess foreign key docs. Checked October 2026.

One correction to the usual framing first. "Neon is Postgres, PlanetScale is MySQL" stopped being true: PlanetScale now sells a managed Postgres product alongside Vitess, plus Neki for sharding Postgres. The real split in 2026 is serverless compute versus always-on clusters, not the SQL dialect. For the wider field, see our [best serverless databases](/blog/best-serverless-databases) roundup.

## The comparison at a glance

| | Neon | PlanetScale |
|---|---|---|
| Engines | Postgres | Vitess (MySQL) and Postgres |
| Scale to zero | Yes, after 5 minutes idle (cannot be disabled on Free) | No, clusters stay warm |
| Entry price (Oct 2026) | Free plan; Launch at $0.106 per CU-hour, no minimum | Postgres PS-5 at $5/month single node, $15 HA; Vitess from $39/month HA |
| Storage | $0.35 per GB-month on paid plans | Included volume per cluster, overage billed separately |
| Branching | Copy-on-write branches, 10 per project on Free and Launch | Branches plus deploy requests for schema changes |
| Horizontal scale | Single-writer, autoscaling up to 16 CU (56 CU fixed on Scale) | Vitess sharding; Neki for Postgres |

Prices are from each vendor's pricing page in October 2026 (PlanetScale figures are AWS us-east-1). Both companies have restructured plans more than once, so re-check before you sign anything. Neon now describes itself as "from Databricks".

## The core split: who pays for idle

Neon separates storage from compute. Data lives in a shared storage layer, and compute endpoints spin up on demand. After five minutes of inactivity, compute suspends and stops accruing CU-hours; the Neon docs say the next query reactivates it "within a few hundred milliseconds". Paid plans can disable suspension, and computes above 16 CU always stay on.

PlanetScale bets the other way. Every cluster stays warm, so there is no cold start by design, and you pay for that capacity whether or not anyone queries it. On Vitess, sharding routes queries across many MySQL instances once one instance can no longer hold your write volume. That is the model you reach for after vertical scaling and read replicas stop cutting it.

So Neon optimizes for many small or spiky databases where idle time dominates the bill, and PlanetScale optimizes for steady production traffic where predictable latency matters more than idle cost.

## Branching and the schema workflow

Both offer branches, used for different jobs. Neon branches are copy-on-write forks of data, so a production-sized branch appears almost instantly without copying bytes. That makes a database per pull request practical:

```
$ neonctl branches create --name pr-412 --parent main
$ neonctl connection-string pr-412
$ DATABASE_URL="$(neonctl connection-string pr-412)" npm run migrate
$ neonctl branches delete pr-412
```

PlanetScale pairs branches with deploy requests: you change the schema on a branch, open a deploy request, and PlanetScale applies it to production without locking tables.

```
$ pscale branch create app add-orders-index
$ pscale shell app add-orders-index   # run the ALTER TABLE here
$ pscale deploy-request create app add-orders-index
$ pscale deploy-request deploy app 42
```

For teams shipping frequent migrations to a busy MySQL table, deploy requests remove a real category of production risk. On Neon you get standard Postgres DDL, so large-table changes need care: the [expand and contract migration pattern](/blog/zero-downtime-postgres-migrations-expand-contract) and tooling like `pg_repack` do the job that deploy requests do on Vitess.

## Connections from serverless runtimes

Serverless functions open and close connections constantly, which exhausts Postgres and MySQL connection limits. Neon ships a pooled endpoint (PgBouncer under the hood, the same trade-offs as in our [PgBouncer pooling guide](/blog/postgres-connection-pooling-pgbouncer)) and a serverless driver that speaks HTTP or WebSocket, which works in edge runtimes:

```javascript
// lib/db.js
import { neon } from '@neondatabase/serverless';
const sql = neon(process.env.DATABASE_URL);
const rows = await sql`select id, email from users where id = ${userId}`;
```

PlanetScale offers its own serverless driver for Vitess and pooling through Vitess or a dedicated PgBouncer on Postgres, billed separately.

## Foreign keys and dialect fit

PlanetScale's Vitess docs state that foreign key constraints are supported only on unsharded databases; for sharded setups you contact your account manager. Adding a foreign key through a deploy request does not validate existing rows, so orphaned data can survive. On Neon, foreign keys are plain Postgres with no caveats.

If you want `pgvector`, PostGIS, `JSONB` and Postgres semantics, both Neon and PlanetScale Postgres qualify, which narrows the decision to the compute model. If your app and team are MySQL-shaped, PlanetScale Vitess is the only option of the two. Do not treat dialects as interchangeable: moving queries, types and stored procedures between MySQL and Postgres is a project.

## Where this breaks

The scale-to-zero argument collapses for a database that is busy around the clock: with no idle time, you pay CU-hours continuously and the cold-start trade buys nothing. Neon's single-writer model also caps write throughput at one compute, so a workload that needs sharded writes outgrows it. PlanetScale's always-on pricing is wasteful for dozens of rarely used preview or tenant databases, and it has no free plan listed. Neither choice is final: both speak standard wire protocols, but branching, deploy requests and sharding are the sticky parts, not the SQL. The broader trade-off between this model and a classic instance is in [serverless vs traditional databases](/blog/serverless-vs-traditional-database).

## Questions people ask

### Is Neon or PlanetScale cheaper?

For idle or spiky workloads, Neon, because suspended compute accrues no CU-hours and paid plans have no monthly minimum (Launch is $0.106 per CU-hour plus $0.35 per GB-month, as of October 2026). For always-busy databases the gap narrows or reverses, since PlanetScale Postgres starts at $5 a month single-node and $15 for three-node HA with no compute-hour metering.

### Does PlanetScale support Postgres now?

Yes. As of October 2026 PlanetScale sells a managed Postgres product next to its Vitess MySQL offering, priced from a $5 per month PS-5 single-node cluster, and lists Neki for sharding Postgres beyond one cluster. Its Postgres clusters stay warm and do not scale to zero, which is the main practical difference from Neon.

### Does Neon have cold starts?

Yes, when scale-to-zero is on. Compute suspends after five minutes idle, and Neon's docs say the next query reactivates it within a few hundred milliseconds. Paid plans can disable suspension for latency-sensitive endpoints; on the Free plan it cannot be turned off. PlanetScale clusters stay warm, so they have no equivalent delay.

## The call we'd make

For greenfield Postgres apps with real idle time, preview environments and branch-per-pull-request workflows, we'd pick Neon: scale-to-zero and instant branches change how a small team works, and Postgres compatibility keeps the exit open. For MySQL workloads, heavy write volume heading toward sharding, or recurring schema changes on hot tables, PlanetScale Vitess is the more serious choice. If you want Postgres and your traffic never sleeps, price PlanetScale Postgres against Neon with scale-to-zero off before deciding.

## Sources

- [Neon pricing](https://neon.com/pricing)
- [Neon docs: Scale to zero](https://neon.com/docs/introduction/scale-to-zero)
- [PlanetScale pricing](https://planetscale.com/pricing)
- [PlanetScale docs: Foreign key constraints (Vitess)](https://planetscale.com/docs/vitess/foreign-key-constraints)