Short answer: Neon is the best default for serverless Postgres: it scales to zero, branches instantly, and has a usable free plan, at the cost of a cold start of a few hundred milliseconds when an idle database wakes. Supabase is the better pick when you also want auth, storage, and realtime in one $25/month Pro plan, and paid Supabase projects never cold start. PlanetScale is the pick for always-on production Postgres or MySQL with replicas included, starting at $5/month for a single node, but it has no free tier.
All three now offer Postgres. That is new: PlanetScale was a MySQL-only Vitess company until it launched PlanetScale Postgres, and Neon has been owned by Databricks since 2025. The real differences are in how each one bills compute, whether it sleeps when idle, and what comes bundled with the database. Prices on this page come from each vendor's pricing page and docs, checked on October 29, 2026, for the default AWS us-east-1 region. Latency figures are the vendors' own published numbers; we do not report our own millisecond benchmarks here, because network distance to your app swamps vendor differences.
For which one to run a production Next.js app on, see Supabase vs Neon vs PlanetScale for production Next.js. For a two-way comparison, see Neon vs Supabase Postgres. For a SQLite-at-the-edge option, see Cloudflare D1 vs Neon vs Supabase.
Supabase vs Neon vs PlanetScale at a glance
| Line item | Supabase | Neon | PlanetScale |
|---|---|---|---|
| Primary focus | Postgres plus auth, storage, realtime, auto-generated APIs, and edge functions | Serverless Postgres with separated storage and compute | Always-on managed Postgres, plus Vitess MySQL for sharding |
| Database engines | Postgres | Postgres | Postgres or MySQL (Vitess) |
| Free tier | Yes: 500 MB database, 5 GB egress, 2 active projects, paused after 1 week of inactivity | Yes: 100 CU-hours and 1 GB storage per project (20 GB per account), 5 GB egress per project | No |
| Paid starting price | Pro from $25/month, including $10 compute credit (one Micro instance) | Launch: no monthly minimum, pay for usage | Postgres PS-5 from $5/month single node, $15/month three-node HA |
| Compute billing | Fixed instance size billed hourly: Micro $10, Small $15, Medium $60, Large $110 per month | $0.106 per CU-hour on Launch, $0.222 per CU-hour on Scale | Fixed instance size per month, for example PS-40 (1/2 vCPU, 4 GiB) at $28 single node or $83 HA on arm64 |
| Storage | 8 GB per project included on Pro, then $0.125/GB | $0.35/GB-month on Launch and Scale | First 10 GB per cluster included, then a region-based rate |
| Egress | 250 GB included on Pro, then $0.09/GB | 500 GB per project included on paid plans, then $0.10/GB | 100 GB per month included on production branches, then a region-based rate |
| Scale to zero | Free projects pause after 1 week idle (manual restore); paid projects stay on | After 5 minutes by default; mandatory on Free, can be disabled on Launch, 1 minute to always on with Scale | No; databases are always on |
| Cold start | None on paid plans | "A few hundred milliseconds" per Neon docs, when a suspended compute wakes | None |
| Autoscaling | No; you change the instance size | Yes: up to 2 CU on Free, up to 16 CU on Launch and Scale | No; you change the instance size |
| Connection pooling | Supavisor: transaction mode on port 6543 for serverless, session mode on 5432 | Built-in PgBouncer via the -pooler endpoint; HTTP and WebSocket serverless driver | PgBouncer on the primary, transaction mode only, port 6432 |
| Branching | $0.01344 per branch per hour | Copy-on-write; 10 branches included on Launch, 25 on Scale, then $1.50/branch-month | Development branches with 10 GB included egress |
| High availability | Read replicas as paid compute add-ons | Read replicas billed as compute | HA plans include a primary and two replicas |
Serverless Postgres latency: what actually differs
For a warm database in the same region as your app, a simple query on any of these platforms returns in single-digit milliseconds. Three things change that number far more than the choice of vendor.
1. Cold starts
Only Neon scales to zero on paid plans. Neon suspends a compute after 5 minutes without activity by default, and its docs say it "reactivates automatically within a few hundred milliseconds." The first request after an idle period pays that delay; later requests do not. On Launch you can turn scale-to-zero off, and on Scale you can set the timeout anywhere from 1 minute to always on. Paid Supabase projects and all PlanetScale databases are always running, so they have no cold start. Supabase Free projects pause after a week of inactivity and must be restored by hand, which is an outage, not a cold start.
2. Connection setup from serverless functions
Opening a fresh TCP and TLS connection to Postgres costs several round trips, and serverless functions can open thousands of short-lived connections. All three vendors include a pooler for this case:
- Supabase: use Supavisor in transaction mode on port 6543. The shared pooler does not support prepared statements in transaction mode, so disable them in your client library.
- Neon: use the pooled connection string (the hostname with
-pooler), or the@neondatabase/serverlessdriver, which runs queries over HTTP or WebSockets from edge runtimes that cannot hold TCP connections. - PlanetScale: connect through PgBouncer on port 6432 instead of 5432. It runs on the same node as the primary and supports transaction mode only.
3. Region and network distance
A database one continent away adds tens of milliseconds to every round trip, which dwarfs any vendor difference. Put the database in the same cloud region as your functions. If you need low-latency reads across regions, Neon and Supabase sell read replicas as extra compute, and PlanetScale HA plans include two replicas.
Real monthly bills for three workloads
These are estimates from list prices in AWS us-east-1, not invoices. Assumptions are stated so you can rescale them.
1. Side project: under 0.5 GB of data, light traffic
- Neon Free: $0. 100 CU-hours per project covers about 400 active hours a month at 0.25 CU, and the compute sleeps when idle.
- Supabase Free: $0, as long as the project is used at least once a week; otherwise it pauses.
- PlanetScale: $5/month for a single-node PS-5 (1/16 vCPU, 512 MiB).
2. Production app: always on, about 4 GB of RAM, 20 GB of data, 200 GB egress
| Cost line | Neon Launch | Supabase Pro | PlanetScale Postgres |
|---|---|---|---|
| Plan or base fee | $0 | $25 | Included in instance price |
| Compute | About $77 (1 CU, 4 GB RAM, 730 hours at $0.106) | $60 Medium (4 GB RAM), less $10 credit | $28 PS-40 arm64 single node, or $83 HA |
| Storage | $7 (20 GB at $0.35) | $1.50 (12 GB over 8 GB at $0.125) | 10 GB included; 10 GB at the region rate |
| Egress | $0 (within 500 GB) | $0 (within 250 GB) | 100 GB included; 100 GB at the region rate |
| Estimated monthly total | About $84 | About $77 | From $28 single node or $83 HA, plus overages |
The instances are matched on memory, not CPU: PlanetScale PS-40 has 1/2 vCPU, while a Neon CU is 1 vCPU. If your app is idle half the day and you leave scale-to-zero on, Neon's compute line falls to about $39. Supabase's Pro price also covers auth for 100,000 monthly active users, file storage, and realtime, which you would pay for separately with Neon or PlanetScale.
3. Preview databases: 20 pull requests a month, each branch kept 7 days
- Neon Launch: roughly $5 to $15. Branches are copy-on-write, so storage is shared until data diverges. If each branch runs 10 active hours at 0.25 CU, compute is about $5.30; with more than 10 branches alive at once, extras cost $1.50 per branch-month.
- Supabase: about $45. Each branch costs $0.01344 per hour, so 168 hours is about $2.26 per branch.
- PlanetScale: development branches exist, but the Postgres pricing docs did not list a per-branch price when we checked. Confirm in the dashboard before budgeting.
Where each option fits (and where it does not)
| Platform | Best for | Where it loses |
|---|---|---|
| Neon | Serverless and edge apps, side projects, preview database per pull request, workloads idle much of the day | Latency-sensitive first requests after idle (unless you disable scale-to-zero); always-on workloads, where per-hour compute costs more than a fixed instance; no bundled auth or storage |
| Supabase | Full-stack apps that want Postgres, auth, storage, realtime, and APIs from one vendor | Compute does not autoscale; per-hour branching gets expensive with many preview branches; Free projects pause after a week idle |
| PlanetScale | Always-on production databases that need replicas, predictable instance pricing, local-NVMe Metal clusters, or MySQL sharding with Vitess | No free tier; no scale-to-zero, so idle databases still cost money; storage and egress overages are priced per region rather than listed as one flat rate |
No platform wins every row. Neon is the best default for serverless Postgres and the cheapest for spiky or idle workloads. Supabase gives the most per dollar if you would otherwise buy auth and storage separately. PlanetScale is the cheapest way to get always-on HA Postgres with two replicas, and the only one of the three that offers MySQL, but it costs money from day one.
How the platforms differ under the hood
Supabase runs standard Postgres on a fixed-size instance and layers PostgREST APIs, GoTrue auth, Realtime, Storage, and Deno-based Edge Functions on top. Row Level Security policies can read the signed-in user with auth.uid(), so access control lives in the database:
-- Supabase RLS: users can only read their own orders
create policy "Users read own orders"
on orders for select
using (auth.uid() = user_id);Neon separates compute from storage. Compute nodes are stateless, so they can autoscale within a range and suspend when idle, and branches share storage pages with their parent until written to. Neon's serverless driver runs over HTTP, which suits edge runtimes:
import { neon } from '@neondatabase/serverless';
const sql = neon(process.env.DATABASE_URL);
// Works in Cloudflare Workers, Vercel Edge, Deno Deploy
const products = await sql`
SELECT id, name, price FROM products
WHERE category = ${category}
ORDER BY created_at DESC LIMIT 20
`;PlanetScale sells instance-sized clusters. Postgres runs on network-attached storage (the PS-* plans) or on local NVMe (Metal plans, from $50/month for M-10 up to multi-thousand-dollar clusters). Its MySQL product runs on Vitess, which shards data across nodes and starts at $39/month for a three-node PS-10. Database branching and deploy requests for non-blocking schema changes remain PlanetScale's signature workflow on Vitess.
Frequently asked questions
Which is fastest: Supabase, Neon, or PlanetScale?
Query latency on all three is dominated by the distance between your app and the database region, not by the vendor. The differences that do matter are cold starts and connection setup. Neon suspends idle compute after 5 minutes by default and wakes it in what Neon describes as a few hundred milliseconds; you can disable that on paid plans. Supabase paid projects and every PlanetScale database stay running, so there is no cold start. For serverless functions, use each vendor's pooler: Supabase Supavisor transaction mode on port 6543, Neon's -pooler endpoint, or PlanetScale's PgBouncer on port 6432.
Which is cheapest: Supabase, Neon, or PlanetScale?
For a side project, Neon Free and Supabase Free both cost $0, and PlanetScale's cheapest Postgres database is $5/month (PS-5, single node). For an always-on production database with about 4 GB of RAM, the October 2026 list prices come to roughly $84/month on Neon Launch, $77/month on Supabase Pro with a Medium compute add-on, and $28/month single-node or $83/month three-node HA on PlanetScale PS-40 (arm64), before PlanetScale's storage and egress overages.
Does PlanetScale still only support MySQL?
No. PlanetScale now sells PlanetScale Postgres alongside its original Vitess-based MySQL product. Postgres plans start at $5/month for a single node (PS-5) and $15/month for three-node high availability. The Vitess MySQL HA plans start at $39/month. PlanetScale has had no free tier since April 2024.
Does Neon have cold starts?
Yes, when scale-to-zero is on. Neon suspends a compute after 5 minutes of inactivity by default and reactivates it automatically within a few hundred milliseconds, according to Neon's documentation. Scale-to-zero cannot be disabled on the Free plan; it can be disabled on Launch and configured from 1 minute to always on with Scale.
Is Supabase or Neon better for a Next.js app?
Choose Supabase if you also need authentication, file storage, and realtime subscriptions, because they are included in the $25/month Pro plan. Choose Neon if you only need Postgres and want instant copy-on-write branches for preview deployments and compute that scales to zero when idle. Both work with Prisma, Drizzle, and other standard Postgres tooling.
When should I pick PlanetScale over Neon or Supabase?
Pick PlanetScale when you need an always-on production database with replicas included, predictable instance pricing, or a path to very large scale through Metal (local NVMe) clusters or Vitess sharding on MySQL. It is a weaker fit for hobby projects, because there is no free tier, and for teams that want auth, storage, and APIs bundled with the database.
Start with Supabase · Try PlanetScale · Get started with Neon