Skip to content
Engineering deep-divesAll articles

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.

Artem Zaitsev
Artem ZaitsevCTO · Idealogic
Author: Artem ZaitsevPublished: Updated: Reading time: 20 minHow we write →
On this page
Idealogic 2026 engineering comparison of PlanetScale for Postgres vs Neon and AWS Aurora covering Metal local NVMe unlimited IOPS, Pageserver scale-to-zero, copy-on-write branching, Neki sharding, and 36-month TCO

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/mo on AWS, GCP, or Azure, with $5/mo single-node and $15/mo HA 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-hr on Launch, $0.222/CU-hr on Scale, and $0.35/GB-mo for storage. You get near-instant copy-on-write branches, scale-to-zero that resumes in a few hundred milliseconds, and pgvector, PostGIS, and pg_partman.
  • Always-on compute is where Neon gets expensive. 32 CU active all month (23,360 CU-hrs) on Neon Scale costs $5,185.92/mo before storage, and a cache miss means fetching the page from a Pageserver over the network instead of from a local drive.
  • 36-month TCO in our model (1.2 TB, 18k QPS). At $75/hr senior 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/hr US 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.

Four structural hardware, storage, branching, and sharding boundaries separating PlanetScale for Postgres and Neon in 2026

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:

  1. Direct-attached local NVMe (Metal). Instead of EBS volumes with IOPS limits and a network round trip on every uncached read, PlanetScale Metal (M-class tiers from $50/mo on AWS, GCP, and Azure, with $5/mo single-node and $15/mo HA network-disk tiers for small workloads) puts PostgreSQL 17 or 18 on the host's NVMe SSDs. You get unlimited IOPS and steadier p99 reads during VACUUM or heavy data pipeline writes.
  2. Three-AZ replicated durability. Local NVMe drives are ephemeral, so PlanetScale runs 1 primary + 2 failover replicas across 3 AZs and continuously archives WAL to object storage. PgBouncer pooling is available, and dedicated PgBouncer instances are billed separately.
  3. Insights, deploy requests, and Neki. PlanetScale Insights fingerprints queries in real time (p50/p99 latency per normalized SQL digest, correlated with deploys). Schema branching and deploy requests check DDL lock safety before a change touches primary tables. Neki is 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.
  4. Trade-offs. Production Metal bills as a fixed 24/7 cluster with no scale-to-zero (the $5/mo single-node and $15/mo HA 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-copy CoW pointers. You also choose from a curated Postgres extension allowlist; arbitrary custom C .so binaries 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:

  1. Compute Units and scale-to-zero. 1 CU is 1 vCPU + 4 GB RAM. Neon autoscaling resizes CPU and RAM without dropping connections and suspends idle computes to 0 CU. Resume typically takes a few hundred milliseconds (under 500 ms).
  2. Safekeepers, Pageservers, and S3. Committed WAL records reach a Paxos quorum across Safekeepers, then stream to Pageservers that materialize 8 KB pages from immutable layers in S3.
  3. 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-mo on 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 ships pgvector HNSW indexes, PostGIS, and pg_partman, and Neon PgBouncer pooling accepts up to 10,000 client connections (connections to the pooler, not simultaneous queries).
  4. Where it struggles: sustained 24/7 OLTP. On Scale ($0.222/CU-hr, with SOC 2, HIPAA, and private networking, versus $0.106/CU-hr on Launch), 32 CU active all month (23,360 CU-hrs) costs $5,185.92/mo before storage. Latency matters too. When random index scans or analytical joins spill past shared_buffers and the compute node's Local File Cache (LFC), Postgres fetches 8 KB pages from Pageservers over 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.

Architectural dimensionPlanetScale Metal (Postgres)Neon Scale (Databricks)AWS Aurora I/O-OptOwned PG17 NVMe (CNPG)
Storage engine3-AZ local PCIe NVMe + S3 WALSafekeeper + Pageserver + S36-way network storage (3 AZs)3-AZ i4i NVMe + pgBackRest
Uncached read p99Hundreds of microseconds (local NVMe)Low milliseconds (Pageserver over network)Low milliseconds (storage network)Hundreds of microseconds (local NVMe)
IOPS & storage feeUnlimited IOPS includedIncluded in CU + $0.35/GB-mo$0 I/O (about +30% CPU, $0.225/GB)Unlimited local NVMe IOPS
Scale-to-zeroNo (24/7 Metal; $5 entry tier)Yes (resume under 500 ms)Serverless v2 0 ACU (resume about 15s)Prod 24/7; CI ZFS on-demand
CI / AI branchingDeploy requests + branches restored from backupNear-instant zero-copy CoW branchesAurora copy-on-write fast clone<400ms ZFS CoW clones
Horizontal shardingNeki (Platform Preview, no SLA)App-level shardingManual / RDS Blue-GreenCitus / pg_partman / app-level
ExtensionsCurated allowlist (pgvector+)Curated list (pgvector, PostGIS)Curated AWS RDS list100% custom C/Rust (ParadeDB)

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:

Design decisionEnforced inWhat it does and where the platform matters
FORCE RLS tenant isolationDatabaseRestrictive and permissive policies apply to a runtime role without BYPASSRLS, and they read the tenant ID from a transaction-scoped setting wrapped in a subquery, so Postgres evaluates it once per query instead of once per row.
Idempotent writesDatabaseA unique constraint on tenant ID plus idempotency key turns a retried request into a constraint error instead of a duplicate ledger row.
Pooler-safe transactionsApp and databaseEvery request opens an explicit transaction and sets the tenant ID, a 1.5 s lock timeout, and a 4.5 s statement timeout with SET LOCAL, so nothing leaks to the next client under PgBouncer transaction mode. Any error rolls back, and a connection that fails its rollback is discarded instead of going back to the pool.
Lag-aware replica readsAppThe app checks replica lag with the WAL replay functions every two seconds and sends read-only work to a replica only when it is 250 ms or less behind. Otherwise reads go to the writer.
Copy-on-write CI branchesCI runnerNeon branches natively, and PlanetScale branches are restored from a backup. An owned cluster gets the same effect by restoring a nightly masked pgBackRest backup from Amazon S3 onto OpenZFS (recordsize 8k) and cloning it per pull request into a throwaway Postgres container.
Replication slot before cutoverSource databaseA logical replication publication and a pre-created slot keep the target in sync, and the switch waits until the slot is active and less than 64 KB behind.

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.

Outgrowing 24/7 serverless CU-hour bills or Aurora I/O-Optimized storage markups?
Send your dataset size, peak QPS, extension list, and CI branching setup. Our senior PostgreSQL architects will model PlanetScale Metal vs Neon vs Owned NVMe HA.
Audit your PostgreSQL TCO

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:

  1. Option A: Neon Scale (Databricks): $12,000 setup (160h CEE; $26,400 US) + $207,000 ($5,750/mo x 36: 32 CU active 24/7 x 730h x $0.222/CU-hr = $5,185.92/mo compute + $564.08/mo storage, where 1,200 GB at $0.35/GB-mo is $420 and the remaining $144.08 is our estimate for a 14-day restore window (Scale allows up to 30 days) and 40 PR branch deltas) + $32,400 SRE/FinOps (12h/mo x 36 = 432h CEE; $71,280 US) = $251,400 CEE ($304,680 US). Year-2+ run-rate: $79,800/yr CEE ($6,650/mo).
  2. Option B: AWS Aurora PostgreSQL I/O-Optimized: $12,000 setup (160h CEE; $26,400 US) + $232,200 ($6,450/mo x 36: Multi-AZ writer + reader r7g.4xlarge I/O-Optimized compute 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 TB storage @ $0.225/GB-mo $270/mo + snapshots, Performance Insights & RDS Proxy $330/mo) + $32,400 ops (12h/mo = 432h CEE; $71,280 US) = $276,600 CEE ($329,880 US). Year-2+ run-rate: $88,200/yr CEE ($7,350/mo).
  3. Option C: PlanetScale Metal for Postgres (M-640: 8 vCPU, 64 GiB, 1,875 GiB local NVMe, 3 nodes across 3 AZs): $12,000 setup (160h CEE; $26,400 US) + $124,200 ($3,450/mo x 36: Metal cluster budgeted at $3,100/mo, which is the $2,530 to $2,839 list 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,400 ops (12h/mo = 432h CEE; $71,280 US) = $168,600 CEE ($221,880 US). Year-2+ run-rate: $52,200/yr CEE ($4,350/mo).
  4. Option D: Owned PostgreSQL 17 NVMe HA (CloudNativePG / Patroni across 3x i4i.2xlarge 1-yr RI + PgBouncer + ZFS CoW Runner + pgBackRest S3 PITR): $39,000 CEE build (520h @ $75/hr; $85,800 US @ $165/hr) + $52,200 AWS infra ($1,450/mo x 36, an estimate: 3x i4i.2xlarge nodes with 8 vCPU, 64 GiB, and 1,875 GB NVMe each, about $0.686/hr on demand in us-east-1 or roughly $1,500/mo for three before the 1-yr reservation discount + cross-AZ WAL + pgBackRest S3-IA PITR + ZFS CI worker) + $40,500 CEE SRE (15h/mo x 36 = 540h; $89,100 US) = $131,700 CEE ($227,100 US). Year-2+ run-rate: $30,900/yr CEE ($2,575/mo).
Worked 36-month PostgreSQL TCO ($k, CEE labor included) at 1.2 TB active state, 18,000 peak QPS & 40 PR branches: Owned PG17 NVMe HA ($131.7k) and PlanetScale Metal ($168.6k) undercut Neon Scale ($251.4k) and Aurora ($276.6k)
36-month line item (1.2 TB, 18k QPS)Option A: Neon ScaleOption B: Aurora I/O-OptOption C: PlanetScale MetalOption D: Owned PG17 NVMeEconomic driver
1. Setup / build ($75/hr CEE)$12,000 (160h; $26.4k US)$12,000 (160h; $26.4k US)$12,000 (160h; $26.4k US)$39,000 (520h; $85.8k US)CNPG + ZFS CoW + pgBackRest
2. 36-mo DB SaaS / AWS Infra$207,000 ($5,750/mo)$232,200 ($6,450/mo)$124,200 ($3,450/mo)$52,200 ($1,450/mo)24/7 CU tax vs Metal vs RI i4i
3. 36-mo DB SRE / FinOps ($75/hr)$32,400 (12h/mo; 432h)$32,400 (12h/mo; 432h)$32,400 (12h/mo; 432h)$40,500 (15h/mo; 540h)Operator failover automation
Total 36-Month TCO (CEE)$251,400$276,600$168,600$131,700 (CapEx incl.)Saves $36.9k to $144.9k CEE
Total 36-Month TCO (US $165/hr)$304,680$329,880$221,880$227,100 (CapEx incl.)PlanetScale wins US by $5,220
Year-2+ Run-Rate (CEE)$79,800/yr ($6,650/mo)$88,200/yr ($7,350/mo)$52,200/yr ($4,350/mo)$30,900/yr ($2,575/mo)Saves $21.3k to $57.3k/yr

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,000 extra build cost ($39,000 minus $12,000) against $2,575/mo OpEx pays back in 5.65 months vs Aurora ($4,775/mo OpEx savings; $144,900 over 36 months), 6.63 months vs Neon Scale ($4,075/mo; $119,700), and 15.21 months vs 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 exceeds 2 TB, customer-VPC residency rules out third-party DBaaS, or custom C extensions (ParadeDB, Timescale, custom pgvector builds) force BYOC. A $5,220 gap 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 sleep 18h/day, Neon Launch or Scale wins easily at roughly $150 to $400/mo. Scale-to-zero removes 75% 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):

Engagement tierTimelineHoursSenior CEE ($75/hr)US Agency ($165/hr)Deliverables
Postgres Latency & RLS Sprint2 to 3 wks150 to 240h$11,250 to $18,000$24,750 to $39,600pg_stat_statements audit, FORCE RLS check & 36-mo TCO
PlanetScale / Neon CDC Cutover4 to 6 wks240 to 360h$18,000 to $27,000$39,600 to $59,400Logical CDC slot sync, PgBouncer guard & <4s cutover
Owned PG17 NVMe HA (520h)7 to 10 wks440 to 600h$33,000 to $45,000 ($39.0k)$72,600 to $99,000 ($85.8k)3-AZ i4i CNPG/Patroni, FORCE RLS, ZFS CoW & pgBackRest
Sharded Multi-Region Core12 to 16 wks760 to 1,040h$57,000 to $78,000$125,400 to $171,600Citus or app-level sharding (Neki once out of preview), EU/US cells & KMS
Dedicated Postgres SRE PodOngoing240h/mo (2)From $18,000/moFrom $39,600/moSenior PostgreSQL DBA/SRE + TypeScript/Go engineers

Inside the worked 520-hour ($39,000 CEE vs $85,800 US) owned PG17 NVMe stack

Worked model: 520-hour ($39,000 at $75/hr CEE vs $85,800 at $165/hr US) owned PostgreSQL 17 3-AZ i4i NVMe HA cluster, PgBouncer FORCE RLS, ZFS CoW PR branches & pgBackRest S3 PITR
  • 1. CNPG / Patroni NVMe (25% / 130h / $9,750 CEE vs $21,450 US): 3-AZ i4i NVMe quorum failover (RPO = 0), hugepages/io_uring tuning, and OTel metrics.
  • 2. PgBouncer & FORCE RLS (25% / 130h / $9,750 CEE vs $21,450 US): HA PgBouncer transaction pooling, RESTRICTIVE + PERMISSIVE FORCE RLS, PCI DSS v4.0.1 roles, and lag-aware replica routing.
  • 3. ZFS CoW PR Branches (20% / 104h / $7,800 CEE vs $17,160 US): Nightly PII-masked restore onto OpenZFS (recordsize=8k) for <400ms zfs clone PR branches.
  • 4. pgBackRest S3 PITR (20% / 104h / $7,800 CEE vs $17,160 US): Parallel ZSTD block-delta backups and WAL archiving to S3-IA via VPC Gateway Endpoints.
  • 5. Logical CDC Cutover (10% / 52h / $3,900 CEE vs $8,580 US): PUBLICATION/SUBSCRIPTION slot sync, row-hash parity checks, k6 failover drills, and <4s cutover.

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.

Artem Zaitsev · CTO at Idealogic

PlanetScale vs Neon decision checklist and Idealogic PostgreSQL proof

Idealogic ships audit-hardened PostgreSQL cores across regulated workloads:

Five checks settle PlanetScale vs Neon vs Aurora vs Owned PG17 in 2026:

  1. Under 200 GB, <35% duty cycle, or autonomous AI agent sandboxes? Run Neon Launch or Scale (near-instant CoW branches + scale-to-zero).
  2. Sustained 24/7 high-IOPS OLTP (500 GB to 2 TB) on US-only engineering rates? Pick PlanetScale Metal for Postgres ($221.9k US / $168.6k CEE 36-mo TCO in our model, unlimited NVMe IOPS; Neki sharding is still in preview).
  3. 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.
  4. Committed to AWS EDP? Benchmark Reserved Multi-AZ RDS before paying Aurora I/O-Optimized markups (roughly +30% CPU, $0.225/GB-mo).
  5. 1 TB+ sustained OLTP, custom extensions (ParadeDB, Timescale), strict VPC residency, or CEE engineering leverage? Deploy Owned PG17 NVMe HA (CNPG + i4i + ZFS CoW + pgBackRest) ($131.7k CEE TCO). Contact our team for a 48-hour PostgreSQL TCO audit.
Weighing PlanetScale Metal, Neon Scale, Aurora I/O-Optimized, or Owned PG17 NVMe?
Share your dataset size, read/write QPS, extension dependencies, and compliance scope. Our senior CEE PostgreSQL architects will return a 36-month cost model and migration plan in 48 hours.
Request a 48-hour Postgres TCO audit

Occasional field notes on building software, no spam

Protected by Cloudflare Turnstile · Privacy · Terms

Artem Zaitsev
Artem ZaitsevCTO · Idealogic Development OÜ

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).

Still unanswered
Ask us directly

A senior engineer replies under 4 hours.