Neon Postgres Pricing Explained: Compute Units & Monthly Bill Simulator
Understand how Neon bills for Compute Units ($0.16/CU/hr), autoscaling ranges (0.25 to 16 CUs), storage ($0.35/GB), and compare Launch ($19/mo) vs Scale ($69/mo).
Neon Production Cost Estimator
Simulate your active compute hours, average CU allocation, and database storage to find the optimal tier.
1. Official Neon Pricing Plans (2026)
Neon separates storage and compute at the hypervisor level. Here is how the official tiers are structured:
| Plan | Monthly Base | Included Compute | Included Storage | Max Autoscaling | Extra Compute Rate |
|---|---|---|---|---|---|
| Free Tier | $0 | 100 CU-hours | 0.5 GB | Fixed 0.25 CU | Suspends at cap |
| Launch | $19 / mo | 300 CU-hours | 10 GB | Up to 2 CUs | $0.16 / CU-hour |
| Scale | $69 / mo | 750 CU-hours | 50 GB | Up to 8 CUs | $0.16 / CU-hour |
| Business / Enterprise | Custom | Custom pool | Custom | Up to 32+ CUs | Volume discounts |
2. Three Rules to Prevent Neon Compute Spikes
- Set Hard Autoscaling Upper Bounds: Never leave your autoscaling range uncapped. On Launch, set the range to
0.25 CU min - 1 CU maxfor general traffic. - Tune Suspend Timeout: Neon defaults to suspending after 5 minutes of idle time. For staging databases, keep this at 5 minutes. For production, increase to 15–30 minutes to prevent user-facing 500ms cold starts.
- Use Connection Pooling: Neon provides native PgBouncer connection pooling endpoints (port 6543). Direct connections consume dedicated backend processes that inflate compute utilization.
Frequently Asked Questions
Serverless Postgres Architecture, Scale-to-Zero Math & Compute Unit (CU) Economics
Neon decouples relational compute from storage by re-architecting PostgreSQL for modern cloud infrastructure. Neon's custom storage engine distributes PostgreSQL write-ahead logs (WAL) across multi-tenant storage nodes, while stateless compute instances (running standard unmodified PostgreSQL) scale dynamically from 0.25 Compute Units (CU) up to 16 CUs, or spin down to zero during idle periods. Understanding Neon's CU billing metric (1 CU = 1 vCPU and 4 GB RAM = $0.16/hour) is essential to optimizing production database spend.
Neon Compute Unit (CU) Sizing & Monthly Cost Matrix
| Compute Sizing | vCPU / RAM | Hourly Cost | Continuous 24/7 (730 hrs) | Dev Auto-Suspend (40 hrs/wk) |
|---|---|---|---|---|
| 0.25 CU (Fractional) | 0.25 vCPU / 1 GB RAM | $0.040 / hr | $29.20 / mo | $6.40 / mo |
| 1.0 CU (Standard) | 1.0 vCPU / 4 GB RAM | $0.160 / hr | $116.80 / mo | $25.60 / mo |
| 4.0 CU (Production) | 4.0 vCPU / 16 GB RAM | $0.640 / hr | $467.20 / mo | $102.40 / mo |
| 16.0 CU (Enterprise Max) | 16.0 vCPU / 64 GB RAM | $2.560 / hr | $1,868.80 / mo | $409.60 / mo |
Instant Database Branching in CI/CD Pipelines
Spin up an isolated copy-on-write database branch for automated pull request testing in GitHub Actions:
# Create ephemeral database branch via Neon CLI
neon branches create --name pr-${{ github.event.pull_request.number }}
# Extract branch connection string and run migrations
export DATABASE_URL=$(neon connection-string pr-${{ github.event.pull_request.number }})
npx prisma migrate deploy
npm run test:e2e
# Tear down branch after test suite completion
neon branches delete pr-${{ github.event.pull_request.number }}Cold Start Latency & PgBouncer Connection Pooling
When compute auto-suspension is enabled, resuming an idle Neon database endpoint triggers a cold start delay of 500ms to 1,500ms. For serverless applications where sub-50ms response times are required, deploy Neon's built-in PgBouncer connection pooler endpoint (`-pooler` connection string suffix). This prevents serverless Lambda functions from flooding the database with ephemeral connections while maintaining active poolers during short traffic pauses.
Scale-to-Zero Auto-Suspend & Cold Start Optimization
Neon's serverless architecture allows development and staging branches to auto-suspend after 5 minutes of inactivity, reducing compute expenditure to zero during non-working hours. When a new incoming query arrives, Neon's control plane re-attaches stateless compute to persistent storage in under 800 milliseconds.
For latency-sensitive production environments, disabling auto-suspend on the primary branch while routing serverless edge connections through Neon's connection pooler maintains sub-15ms query execution times.