Neon's 2026 Pricing Reset: What $0.106/CU-Hour Serverless Postgres Really Costs Against Self-Hosted CNPG on Hetzner

Neon cut its own prices three times in under a year. Storage dropped 80%. Compute dropped twice. The $5/month account minimum — the one friction point every "just try it" pitch had to explain away — is gone entirely. If you priced out Neon for a branching-heavy dev workflow any time before August 2025, the numbers you remember are wrong.

Here's the current bill: Launch-plan compute costs $0.106 per CU-hour, storage costs $0.35 per GB-month, and a Compute Unit is 1 vCPU plus 4 GB of RAM. Below, a full line-by-line recompute of what that actually costs a real branching-heavy team — first at small-team scale, then at a scaled-up size — against running CloudNativePG (CNPG) on Hetzner virtual machines you provision and control directly, the same "owned hardware" baseline this blog keeps coming back to. The short version: at small scale the two bills land within about $40 of each other, and the labor cost of manually refreshing dev branches on the self-hosted side can erase that gap entirely. At larger, more always-on scale, self-hosting pulls ahead by roughly 3x. The crossover isn't about size — it's about how much of your workload is idle, bursty dev branches versus steady production compute.

The Timeline: Why This Bill Looks Different Now​

Databricks announced its intent to acquire Neon for roughly $1 billion in May 2025, citing a striking internal number as the rationale: over 80% of the databases provisioned on Neon were already being created automatically by AI agents, not humans. Three months later, on August 14, 2025, Neon shipped its first post-acquisition pricing reset — storage cut roughly 80%, from $1.75 to $0.35 per GB-month, and Launch-plan compute cut to $0.14 per CU-hour, riding Databricks' hyperscaler-scale infrastructure purchasing power.

That wasn't the last cut. Through 2026, Neon kept trimming further: Launch compute is now $0.106/CU-hour, down again from that August rate, and the old $5/month minimum spend is gone completely — invoices under $0.50 simply aren't collected, so a genuinely idle project costs nothing. Scale-plan compute, which adds a 99.95% SLA, HIPAA availability, SOC2, Private Link, and SSO, sits at $0.222/CU-hour.

That's the fastest sustained price-cutting streak of any serverless Postgres vendor in this category, and it changes the self-hosting math this blog has run against every other managed-database vendor. Time to run it properly.

The Rate Card, Line by Line​

Here's every number that goes into the recompute below, current as of mid-2026:

A Compute Unit is 1 vCPU + 4 GB RAM, and it scales to zero after five minutes of inactivity — a branch sitting idle overnight accrues zero CU-hour charges. Storage is billed on the actual bytes each branch's data adds on top of its parent, not a full copy per branch, which is what makes branching cheap in the first place.

Scenario A: The Small Branching Team​

Take a realistic setup: one production branch running 2 CU around the clock, one staging branch running 1 CU during business hours and CI windows (~300 hours/month), and eight developer branches that scale to zero overnight and average about three active hours a day (~66 CU-hours/month each at 0.5 CU).

Neon Launch, this workload:

CNPG on Hetzner, same workload. A production-grade CNPG deployment means a 3-node HA cluster (one primary, two streaming replicas CNPG manages automatically), sized to match the 2-CU production branch: three CCX13 instances (2 dedicated vCPU, 8 GB RAM), which post-2026-price-hikes run €42.99/month each. Staging and the eight dev "branches" — which on CNPG means separate logical databases on a shared instance, refreshed from production, not instant copy-on-write clones — fit on one more CCX13. Add a Hetzner Volume for WAL archiving and base backups.

Raw hardware: self-hosting wins by about $39/month, or roughly 17%. That's the number every "self-host and save" pitch would stop at — and it's the wrong place to stop, because it prices the infrastructure and ignores the one thing the TODO for this exact comparison flags: database-per-branch is a deliberate operational choice on CNPG, not a billed line item, and choices have labor costs.

Neon's branch creation is an API call that returns in seconds. CNPG has no equivalent — refreshing a dev branch means a pg_dump/pg_restore cycle or a logical-replication resync, and a plain restore of a 50 GB database runs roughly 20–30 minutes, even with parallel-job optimizations. Script it so the restore itself runs unattended, and a developer still needs about five minutes of hands-on-keyboard time per refresh — kicking off the job, watching for the completion notification, spot-checking the result — before trusting a branch that's supposed to mirror production.

Refresh eight branches weekly and that's roughly 35 refreshes a month, or about 2.9 engineer-hours/month. At a $60–150/hour loaded rate (the range covers junior to senior, US-market), that's $175–$435/month — which meets or exceeds the entire $39/month hardware saving on its own. Automate the trigger-and-verify step down to near-zero and the raw $39 edge holds; leave it as a manual weekly ritual, and Neon's $234 is very plausibly the cheaper option once an engineer's time is counted at all.

Scenario B: Sensitivity Check at Scale​

The workload shape, not the raw size, is what decides this. Scale the same team up — 8-CU production, a 2-CU staging branch, 20 developer branches, 300 GB of storage — and the ratio of steady production compute to bursty branch churn shifts hard toward production.

Neon Scale, at $0.222/CU-hour: production ($1,296.48) + staging ($133.20) + 20 dev branches at the same 33 CU-hr/branch average ($146.52) + 300 GB storage ($105) + 5 branches over the 25 included ($7.50) comes to ≈ $1,689/month.

CNPG on Hetzner: a 3-node CCX33 HA cluster (8 dedicated vCPU, 32 GB RAM each, €138.49/month post-hike) for production, a CCX23 (4 vCPU, 16 GB) for staging and dev, and a 500 GB backup volume — €415.47 + €85.99 + €28.50 = €529.96/month (≈ $572).

The gap widens to roughly $1,117/month, close to 3x in self-hosting's favor. The branch-refresh labor cost scales too — 20 branches refreshed weekly is about 7.2 engineer-hours/month, or $433–$1,083 at the same loaded rate — but even at the high end it doesn't erase a four-figure hardware gap the way it erased Scenario A's $39. More production compute, running steady-state 24/7, dominates the bill at this size; the same manual-refresh tax that flips the small-team verdict barely dents the large-team one.

What CNPG Genuinely Can't Replicate​

The dump-and-restore workaround above is a real, working answer for teams that need a Postgres per developer. It is not Neon's actual architecture, and it's worth being precise about the difference the TODO for this piece calls out directly. Neon's instant branching and true scale-to-zero come from a storage engine that separates compute from durable storage across dedicated Pageserver and Safekeeper components — not from anything CNPG's HA-Postgres-operator model does.

Self-hosting that engine, per Neon's own community and the third-party Neon Operator project attempting it, still "requires substantial infrastructure expertise" and remains explicitly early-stage — a Kubernetes operator managing pageservers and safekeepers, not a Docker Compose file. CNPG is the mature, well-documented path to self-hosted HA Postgres; it was never going to be the mature path to Neon's actual copy-on-write branching, and treating the two as interchangeable is where a cost comparison stops being honest.

Where Neon Still Wins Outright​

There's one workload shape no amount of Hetzner recompute touches: a solo developer or a genuinely spiky side project. Neon's Free tier — 100 CU-hours, 0.5 GB storage, 10 branches — costs $0/month for a project that's mostly idle. A Hetzner box doesn't have that option; a CCX13 costs the same €42.99 whether it's serving traffic 24 hours a day or sitting untouched for 23 of them. True scale-to-zero billing has no cheap self-hosted equivalent, and for a workload that's idle more than it's busy, that's decisive.

The Decision, Not the Verdict​

There's no single answer here, and that's the actual finding: workload shape decides it, not company size. A small team whose Postgres usage is mostly bursty dev-branch churn against a thin production slice is close to a wash on hardware, and likely cheaper on Neon once branch-refresh labor is counted honestly. A team running heavier, steadier production compute against the same branch count sees the gap widen to Hetzner's favor by 3x, because CNPG's cost advantage scales with the always-on compute that dominates a bigger bill — while the branch-refresh tax barely grows. Run the two totals for your own compute-hours, storage, and branch count before assuming either direction.

bex.co is the open-source, AI-native Render alternative — push a git repo, get a running HTTPS service on Hetzner machines you control directly. It deliberately doesn't manage tenant databases: pairing it with your own CloudNativePG cluster on the same owned hardware, sized against the numbers above, is the intended shape. Star the repo on GitHub or deploy your first app today.

Sources​

• Databricks Agrees to Acquire Neon to Deliver Serverless Postgres for Developers + AI Agents
• Neon's New Pricing, Explained: Usage-Based, No Minimum
• Pricing — Neon
• Neon plans — Neon Docs
• Neon Pricing 2026: Total Cost & Competitors Compared
• Hetzner Price Adjustment 15 June 2026 — Hetzner Docs
• Hetzner cloud server price increases in 2026: full breakdown and alternatives — Northflank
• Neon Operator: Self-Host Serverless Postgres on Kubernetes — Molnett
• How can we make pg_dump and pg_restore 5 times faster? — PeerDB