PlanetScale vs Neon in 2026: Metal NVMe, CoW & PG17 TCO
Engineering and 36-month TCO teardown of PlanetScale for Postgres vs Neon (Databricks) and AWS Aurora I/O-Optimized in 2026: local NVMe Metal unlimited IOPS vs disaggregated Pageservers, CoW branching, Neki sharding preview, FORCE RLS on PG17, and 1.2 TB math.

On this page

PlanetScale vs Neon used to be an odd comparison: PlanetScale meant Vitess MySQL, and Neon was an early serverless Postgres challenger. In 2026 both sell managed PostgreSQL, and they store your data in opposite ways. PlanetScale Metal keeps it on local NVMe drives next to the database process. Neon keeps it in a separate storage service and lets compute scale to zero. Once your relational core grows past 500 GB, that difference decides your latency, your branching workflow, and your bill, which is why the search usually widens to PlanetScale for Postgres pricing, Neon Postgres pricing, and Aurora I/O-Optimized TCO.
Keep adjacent layers distinct: Neon vs Supabase contrasts serverless Postgres with a bundled Backend-as-a-Service (Auth, Realtime, PostgREST), as Supabase vs Firebase does for the BaaS layer itself. Drizzle vs Prisma benchmarks TypeScript ORMs above your connection pool, and ClickHouse vs TimescaleDB weighs columnar OLAP against ACID transaction management. This guide covers managed PostgreSQL for OLTP only: local NVMe clusters versus disaggregated copy-on-write (CoW) storage.
At Idealogic, our custom software development, SaaS development, software development consulting, and dedicated development team teams build PostgreSQL backbones across fintech, healthtech, and logistics and supply chain. This article covers how PlanetScale Metal for Postgres, Neon (Databricks), AWS Aurora I/O-Optimized, and owned PostgreSQL 17 on NVMe differ inside, a production blueprint (FORCE RLS behind PgBouncer, ZFS copy-on-write CI branches, a logical replication cutover), and an illustrative 36-month TCO model at 1.2 TB and 18,000 peak QPS. We checked list prices in November 2026. PostgreSQL 18 is the current major version and PlanetScale supports 17.x and 18.x; the blueprint runs on either.
The short version
- PlanetScale Metal fits sustained 24/7 OLTP. PlanetScale for Postgres runs Metal M-class clusters from
$50/moon AWS, GCP, or Azure, with$5/mosingle-node and$15/moHA network-attached tiers below them (PlanetScale pricing). A Metal cluster is one primary plus two replicas across three AZs on local NVMe with unlimited IOPS. PgBouncer is available (dedicated instances are billed separately), and Neki horizontal sharding is in Platform Preview with no SLA, so don't plan production sharding around it yet. - Neon fits branching, AI sandboxes, and bursty compute. Databricks announced the acquisition in May 2025 and said AI agents created over 80% of the databases provisioned on Neon. The price was reported at about
$1B. Neon pricing is$0.106/CU-hron Launch,$0.222/CU-hron Scale, and$0.35/GB-mofor storage. You get near-instant copy-on-write branches, scale-to-zero that resumes in a few hundred milliseconds, andpgvector,PostGIS, andpg_partman. - Always-on compute is where Neon gets expensive.
32 CUactive all month (23,360 CU-hrs) on Neon Scale costs$5,185.92/mobefore storage, and a cache miss means fetching the page from aPageserverover the network instead of from a local drive. - 36-month TCO in our model (
1.2 TB,18kQPS). At$75/hrsenior CEE labor, owned PostgreSQL 17 on NVMe ($131,700) beats PlanetScale Metal ($168,600) by$36,900, Neon Scale ($251,400) by$119,700, and Aurora ($276,600) by$144,900. At$165/hrUS agency labor, PlanetScale Metal ($221,880) beats owned PostgreSQL ($227,100) by$5,220. Fair warning: the four options aren't sized identically, and resizing Neon or Metal moves these totals a lot. The TCO section spells out the assumptions.
2026 storage & compute internals: PlanetScale Metal vs Neon Pageservers vs Aurora
The PlanetScale vs Neon choice (or Neon vs PlanetScale, if that's how you search it) comes down to four boundaries: disk I/O, always-on versus scale-to-zero billing, how branches are cloned, and sharding versus extension coverage.
1. PlanetScale Postgres on Metal: local NVMe and Vitess heritage
PlanetScale built its reputation operating Vitess for large MySQL teams that had outgrown network block storage. It brought the same thinking to Postgres (PlanetScale Postgres docs, PlanetScale for Postgres architecture) and skipped network storage hops on its production tiers:
- Direct-attached local NVMe (
Metal). Instead of EBS volumes with IOPS limits and a network round trip on every uncached read, PlanetScale Metal (M-classtiers from$50/moon AWS, GCP, and Azure, with$5/mosingle-node and$15/moHA network-disk tiers for small workloads) puts PostgreSQL 17 or 18 on the host's NVMe SSDs. You get unlimited IOPS and steadierp99reads duringVACUUMor heavy data pipeline writes. - Three-AZ replicated durability. Local NVMe drives are ephemeral, so PlanetScale runs
1primary +2failover replicas across3AZs and continuously archives WAL to object storage. PgBouncer pooling is available, and dedicated PgBouncer instances are billed separately. - Insights, deploy requests, and
Neki.PlanetScale Insightsfingerprints queries in real time (p50/p99latency per normalized SQL digest, correlated with deploys). Schema branching and deploy requests check DDL lock safety before a change touches primary tables.Nekiis PlanetScale's Vitess-inspired horizontal sharding layer for PostgreSQL, meant to route multi-terabyte tenant workloads across independent Postgres shards behind one endpoint. It's in Platform Preview, a beta with no SLA, so treat it as a roadmap item for now. - Trade-offs. Production Metal bills as a fixed 24/7 cluster with no scale-to-zero (the
$5/mosingle-node and$15/moHA network-storage tiers cover lightweight staging). Branches are separate clusters: a dev branch starts empty and a branch with data is restored from a backup, so there are no zero-copyCoWpointers. You also choose from a curated Postgres extension allowlist; arbitrary custom C.sobinaries aren't allowed.
2. Neon serverless Postgres: Safekeepers, Pageservers and copy-on-write branches
Neon is developed in the open at neondatabase/neon (Apache 2.0) and has been part of Databricks since the May 2025 deal. Neon's architecture separates stateless compute from multi-tenant storage:
- Compute Units and scale-to-zero.
1 CUis1 vCPU+4 GB RAM. Neon autoscaling resizes CPU and RAM without dropping connections and suspends idle computes to0 CU. Resume typically takes a few hundred milliseconds (under500 ms). Safekeepers,Pageservers, and S3. Committed WAL records reach a Paxos quorum acrossSafekeepers, then stream toPageserversthat materialize8 KBpages from immutable layers in S3.- Copy-on-write branches for AI agents and CI. Neon branching forks a database through LSN metadata pointers, so a branch is near-instant whatever the database size and costs nothing until it diverges (you pay
$0.35/GB-moon logical state plus restore-history and branch deltas). At the Databricks announcement, AI agents were creating over 80% of the databases provisioned on Neon. Neon also shipspgvectorHNSW indexes,PostGIS, andpg_partman, and Neon PgBouncer pooling accepts up to10,000client connections (connections to the pooler, not simultaneous queries). - Where it struggles: sustained 24/7 OLTP. On Scale (
$0.222/CU-hr, with SOC 2, HIPAA, and private networking, versus$0.106/CU-hron Launch),32 CUactive all month (23,360 CU-hrs) costs$5,185.92/mobefore storage. Latency matters too. When random index scans or analytical joins spill pastshared_buffersand the compute node's Local File Cache (LFC), Postgres fetches8 KBpages fromPageserversover the network, and that tail is slower than a read from a local NVMe drive.
3. AWS Aurora PostgreSQL I/O-Optimized
Under AWS Aurora PostgreSQL pricing, Aurora I/O-Optimized drops the $0.20 per million I/O request charge (us-east-1). You pay for that with compute that costs roughly 30% more and storage at $0.225/GB-mo, 2.25x the standard $0.10/GB-mo. Reads still cross a network storage layer, and you take on multi-AZ vendor lock-in.
The latency row gives typical orders of magnitude. These aren't Idealogic benchmarks, so measure your own workload before you commit.
Production blueprint: FORCE RLS on PostgreSQL 17, PgBouncer transactions, ZFS CoW branches and a logical replication cutover
Whether you run Neon, PlanetScale Metal, or your own AWS i4i NVMe instances under CloudNativePG or Patroni, a regulated multi-tenant SaaS needs the same things: tenant isolation that travels with the schema, fast copy-on-write CI previews, and a way to switch clouds without downtime. See also multi-tenant SaaS architecture.
Tenant isolation belongs in the database, through FORCE ROW LEVEL SECURITY, which PostgreSQL has had since 9.5. Because the policies live in the schema, they move with a logical replication cutover and work the same on all three platforms. PCI DSS v4.0.1 is technology neutral and doesn't require RLS, but RLS is one control that can support its access-restriction requirements. These are the six decisions the blueprint rests on:
The cutover check is the part teams most often get wrong. On the source cluster, publish every table with partition roots included, create a logical replication slot named cutover_slot once, and switch only when pg_replication_slots shows the slot active and the gap between pg_current_wal_lsn() and confirmed_flush_lsn under 64 KB.
Creating the slot twice is a race: two callers running it at the same moment can both pass an existence check, so create it from a single deploy job or catch the duplicate_object error.
Once the check reports ready, the cutover takes five steps. Issue PAUSE on the upstream PgBouncer so incoming requests queue in memory instead of failing. Copy sequence values from pg_sequences to the target cluster. Confirm that pg_current_wal_lsn() equals confirmed_flush_lsn, which should take under 800 ms. Repoint PgBouncer's backend host from Neon or Aurora to PlanetScale Metal or CloudNativePG. Then run RESUME, and keep a reverse logical replication slot warm for 72 hours so you can roll back quickly.
PlanetScale vs Neon 36-month TCO model: 1.2 TB OLTP dataset, 18,000 peak QPS & 40 PR branches
At 1.2 TB and 18,000 peak QPS, owned PostgreSQL costs the least over 36 months at CEE labor rates, and PlanetScale Metal wins narrowly at US rates. This is an illustrative model, not a quote. We checked list prices in November 2026, and the sizing assumptions below matter as much as the prices.
The estate is a regulated OLTP workload over 36 months: a 1.2 TB (1,200 GB) active dataset, 18,000 peak QPS, an HA primary with 64 GB of memory plus replicas, 40 ephemeral CI/PR branches, SOC 2 Type II, and PCI DSS v4.0.1 scope.
Vendor SKUs don't line up one to one, so the four options aren't sized identically. Neon is modeled at 32 CU always on (a 16 CU primary plus 16 CU of read replica capacity, so 32 vCPU and 128 GB in total). PlanetScale Metal and the owned cluster use three 8 vCPU / 64 GiB nodes with 1,875 GiB of NVMe each. Aurora uses two 16 vCPU instances. Size Neon at 16 CU and its compute falls to $2,592.96/mo (11,680 CU-hrs x $0.222). Size Metal at 16 vCPU (M-1280 with 3,840 GiB, $5,020 to $5,639/mo) and it costs about what Neon Scale does. Run the model with your own sizing before you trust the ranking.
Labor compares Idealogic's $75/hr senior CEE rate with a $165/hr US agency rate (2.2x). Both are agency billing rates and our market assumption, not wages. For context, the EU whole-economy labour cost averages roughly EUR 34 to 35 per hour (Eurostat lc_lci_lev), and US wage data for software developers (15-1252) comes from O*NET and BLS OEWS:
- Option A: Neon Scale (
Databricks):$12,000setup (160hCEE;$26,400US) +$207,000($5,750/mo x 36:32 CUactive24/7x730hx$0.222/CU-hr=$5,185.92/mocompute +$564.08/mostorage, where1,200 GBat$0.35/GB-mois$420and the remaining$144.08is our estimate for a14-dayrestore window (Scale allows up to 30 days) and40PR branch deltas) +$32,400SRE/FinOps (12h/mo x 36 = 432hCEE;$71,280US) =$251,400CEE ($304,680US). Year-2+ run-rate:$79,800/yrCEE ($6,650/mo). - Option B: AWS Aurora PostgreSQL
I/O-Optimized:$12,000setup (160hCEE;$26,400US) +$232,200($6,450/mo x 36: Multi-AZ writer + readerr7g.4xlargeI/O-Optimizedcompute estimated at$5,850/mo(we couldn't tie this to a single list price, so confirm it in the AWS Pricing Calculator) +1.2 TBstorage@ $0.225/GB-mo$270/mo+ snapshots, Performance Insights & RDS Proxy$330/mo) +$32,400ops (12h/mo = 432hCEE;$71,280US) =$276,600CEE ($329,880US). Year-2+ run-rate:$88,200/yrCEE ($7,350/mo). - Option C: PlanetScale Metal for Postgres (
M-640:8 vCPU,64 GiB,1,875 GiBlocal NVMe, 3 nodes across 3 AZs):$12,000setup (160hCEE;$26,400US) +$124,200($3,450/mo x 36: Metal cluster budgeted at$3,100/mo, which is the$2,530 to $2,839list price across x86 and arm64 variants plus an allowance for a separately billed dedicated PgBouncer and egress, with unlimited IOPS + staging/CI deploy branches & S3 backups$350/mo) +$32,400ops (12h/mo = 432hCEE;$71,280US) =$168,600CEE ($221,880US). Year-2+ run-rate:$52,200/yrCEE ($4,350/mo). - Option D: Owned
PostgreSQL 17NVMe HA (CloudNativePG/Patroniacross3xi4i.2xlarge1-yr RI +PgBouncer+ZFSCoW Runner +pgBackRestS3 PITR):$39,000CEE build (520h@$75/hr;$85,800US @$165/hr) +$52,200AWS infra ($1,450/mo x 36, an estimate:3xi4i.2xlargenodes with8 vCPU,64 GiB, and1,875 GBNVMe each, about$0.686/hron demand in us-east-1 or roughly$1,500/mofor three before the 1-yr reservation discount + cross-AZ WAL +pgBackRestS3-IAPITR +ZFSCI worker) +$40,500CEE SRE (15h/mo x 36 = 540h;$89,100US) =$131,700CEE ($227,100US). Year-2+ run-rate:$30,900/yrCEE ($2,575/mo).
Sanity check: $75/hr CEE payback vs $165/hr US PlanetScale crossover
- At senior CEE rates (
$75/hr), owned PostgreSQL 17 on NVMe wins. Option D's$27,000extra build cost ($39,000minus$12,000) against$2,575/moOpEx pays back in5.65 monthsvs Aurora ($4,775/moOpEx savings;$144,900over 36 months),6.63 monthsvs Neon Scale ($4,075/mo;$119,700), and15.21 monthsvs PlanetScale Metal ($1,775/mo;$36,900). - At US agency rates (
$165/hr), PlanetScale Metal wins by$5,220. Metal ($221,880) edges owned PostgreSQL ($227,100) over 36 months unless the dataset exceeds2 TB, customer-VPC residency rules out third-party DBaaS, or custom C extensions (ParadeDB,Timescale, custompgvectorbuilds) force BYOC. A$5,220gap over three years is well inside this model's margin of error, so we'd call it a tie. - Below
200 GB, or with workloads that sleep18h/day, Neon Launch or Scale wins easily at roughly$150 to $400/mo. Scale-to-zero removes75%of monthly compute hours, and every engineer and coding agent gets copy-on-write branches of a production-shaped schema.
2026 PostgreSQL migration & NVMe HA build costs (Senior CEE vs US)
Our custom software development, SaaS development, and dedicated development team teams deliver PostgreSQL migrations at $75/hr Senior CEE vs $165/hr US agency rates (2.2x):
Inside the worked 520-hour ($39,000 CEE vs $85,800 US) owned PG17 NVMe stack
- 1.
CNPG / Patroni NVMe(25%/130h/$9,750CEE vs$21,450US): 3-AZi4iNVMe quorum failover (RPO = 0), hugepages/io_uringtuning, and OTel metrics. - 2.
PgBouncer & FORCE RLS(25%/130h/$9,750CEE vs$21,450US): HA PgBouncer transaction pooling,RESTRICTIVE+PERMISSIVEFORCE RLS,PCI DSS v4.0.1roles, and lag-aware replica routing. - 3.
ZFS CoW PR Branches(20%/104h/$7,800CEE vs$17,160US): Nightly PII-masked restore ontoOpenZFS(recordsize=8k) for<400mszfs clonePR branches. - 4.
pgBackRest S3 PITR(20%/104h/$7,800CEE vs$17,160US): ParallelZSTDblock-delta backups and WAL archiving toS3-IAvia VPC Gateway Endpoints. - 5.
Logical CDC Cutover(10%/52h/$3,900CEE vs$8,580US):PUBLICATION/SUBSCRIPTIONslot sync, row-hash parity checks,k6failover drills, and<4scutover.
Neon is very good at ephemeral copy-on-write branching for AI agents and pull requests, and PlanetScale Metal brought local NVMe and unlimited IOPS to managed PostgreSQL. Use Neon when computes sleep or fork constantly; move sustained terabyte-scale OLTP ledgers to PlanetScale Metal or owned i4i NVMe clusters before 24/7 CU-hour billing inflates your COGS.
PlanetScale vs Neon decision checklist and Idealogic PostgreSQL proof
Idealogic ships audit-hardened PostgreSQL cores across regulated workloads:
- Exchange & neobank ledgers (Bitholder & Fese): Sub-millisecond ACID settlement under PCI DSS v4.0.1.
PostgreSQL + pgvector& clinical sync (Pressmerit, AddMed & HaulBreeze): Multi-tenant RLS isolation and HIPAA/GDPR sync across healthtech and logistics and supply chain.
Five checks settle PlanetScale vs Neon vs Aurora vs Owned PG17 in 2026:
- Under
200 GB,<35%duty cycle, or autonomous AI agent sandboxes? Run Neon Launch or Scale (near-instantCoWbranches + scale-to-zero). - Sustained
24/7high-IOPS OLTP (500 GB to 2 TB) on US-only engineering rates? Pick PlanetScale Metal for Postgres ($221.9kUS /$168.6kCEE 36-mo TCO in our model, unlimited NVMe IOPS;Nekisharding is still in preview). - Want both local NVMe prod and near-instant cloud PR branches? Run prod on PlanetScale Metal or Owned NVMe PG17, syncing a masked nightly dump to Neon Launch for CI previews.
- Committed to AWS EDP? Benchmark Reserved Multi-AZ RDS before paying Aurora
I/O-Optimizedmarkups (roughly+30%CPU,$0.225/GB-mo). 1 TB+sustained OLTP, custom extensions (ParadeDB,Timescale), strict VPC residency, or CEE engineering leverage? Deploy OwnedPG17NVMe HA (CNPG+i4i+ZFSCoW +pgBackRest) ($131.7kCEE TCO). Contact our team for a 48-hour PostgreSQL TCO audit.

CTO and Co-founder at Idealogic. Directing engineering, systems architecture, security, and full-stack delivery across web, mobile, and blockchain.
Frequently asked questions
Pick PlanetScale Metal for Postgres when your OLTP workload runs around the clock with heavy random writes and you want local NVMe with unlimited IOPS. Pick Neon when you depend on instant copy on write branches for pull requests and AI agent sandboxes, on scale to zero for spiky workloads, or on extensions such as pgvector, PostGIS, and pg_partman. Neki sharding is still a Platform Preview with no SLA.
PlanetScale spent years running Vitess-sharded MySQL, then brought the same approach to PlanetScale for Postgres. Metal M-class clusters start at $50 per month, with $5 single-node and $15 high-availability network-attached tiers below them, and run on AWS, GCP, or Azure. A production Metal cluster is one primary and two replicas across three availability zones on local NVMe drives with unlimited IOPS. PgBouncer is available, though dedicated PgBouncer instances are billed separately. Neki, the Vitess-style sharding layer for Postgres, is in Platform Preview.
Databricks announced the Neon acquisition on May 14, 2025, for a press-reported price of about one billion dollars. At the announcement, Databricks said AI agents created over eighty percent of the databases provisioned on Neon. Neon pricing is usage based: Launch at $0.106 per Compute Unit hour, Scale at $0.222 per Compute Unit hour with SOC 2, HIPAA, and private networking, and $0.35 per gigabyte-month of storage.
Neon prices each Compute Unit (one vCPU and 4 GB RAM) for elasticity and scale to zero. A ledger that holds 32 Compute Units for all 730 hours of a month never suspends, so Scale compute bills 23,360 Compute Unit hours at $0.222, or $5,185.92 per month before storage. Our model budgets a three-zone PlanetScale Metal M-640 cluster at about $3,100 per month with no IOPS surcharge. The sizing isn't like for like, though: M-640 nodes have 8 vCPU and 64 GiB, and a 16 vCPU M-1280 cluster with 3,840 GiB lists at $5,020 to $5,639, roughly Neon's bill.
Neon separates stateless Postgres compute from log-structured Pageservers, so a pull-request branch is a Log Sequence Number pointer. It's created almost instantly whatever the database size, and you pay only for data that later diverges. PlanetScale for Postgres branches are separate clusters with their own storage: a development branch starts empty, and a branch with data is restored from a backup. You get isolation and schema deploy requests, but no zero-copy sharing of production blocks.
Aurora I/O-Optimized removes the $0.20 per million I/O request charge (us-east-1) that makes write-heavy bills unpredictable. In exchange, compute costs roughly thirty percent more and storage rises from $0.10 to $0.225 per gigabyte-month, 2.25 times higher. With a multi-AZ writer and reader pair, 1.2 terabytes of state, Performance Insights, RDS Proxy, and snapshots, our estimate comes to about $6,450 per month, and reads still cross a network storage hop.
In our illustrative model, labor rates decide the thirty six month crossover at 1.2 terabytes. With Idealogic's senior Central and Eastern European platform engineers at $75 per hour, an owned three-node i4i NVMe cluster on CloudNativePG or Patroni, with ZFS copy on write CI branches and pgBackRest S3 backups, totals $131,700 over thirty six months. That beats PlanetScale Metal ($168,600) by $36,900, with a 15.21-month payback. At $165 per hour US agency labor, PlanetScale Metal ($221,880) edges owned PostgreSQL 17 ($227,100) by $5,220 unless your dataset exceeds two terabytes or you need custom C extensions.
Working with Idealogic's senior Central and Eastern European PostgreSQL architects at $75 per hour (versus $165 per hour at US agencies), a two to three week Postgres Latency, RLS, and TCO Audit Sprint runs $11,250 to $18,000, a zero-downtime logical replication migration to PlanetScale Metal or Neon Scale runs $18,000 to $27,000, and a turnkey 520-hour owned PostgreSQL 17 NVMe HA platform with PgBouncer, FORCE RLS, ZFS PR branching, and pgBackRest S3 PITR costs $39,000 ($85,800 at US rates).
More from the journal

SigNoz vs Datadog in 2026: OTel, ClickHouse & APM TCO
Engineering and 36-month TCO teardown of SigNoz vs Datadog and Grafana Cloud in 2026: OpenTelemetry Collector tail-sampling, unified ClickHouse telemetry, p99 host high-water-mark billing, PG17 FORCE RLS alert planes, and 150-host math.

GrowthBook vs LaunchDarkly in 2026: Flags, CUPED & TCO
Engineering and 36-month TCO benchmark of GrowthBook vs LaunchDarkly in 2026 alongside Statsig (OpenAI / Amplitude) and CNCF OpenFeature: warehouse-native CUPED SQL, client MAU vs $40/seat billing, PG17 SSE providers, and 500k-MAU math.

ClickHouse vs TimescaleDB in 2026: OLAP, TigerData & TCO
ClickHouse vs TimescaleDB (TigerData) in 2026, compared on engineering and 36-month TCO: MergeTree vectorized scans vs Hypercore under the TSL, no timescaledb extension on AWS RDS, PostgreSQL FORCE RLS plus ClickHouse ROW POLICY isolation, and the math at 78B events/mo.