What is a Neon Compute Unit (CU) and what does it cost?

1 Neon Compute Unit (CU) allocates 1 vCPU and 4 GB of RAM, priced at $0.16 per active hour ($0.00267/min). Neon can scale dynamically in fractional increments down to 0.25 CU ($0.04/hr) and up to 16+ CUs ($2.56/hr).

How does Neon suspend timeout affect monthly compute billing?

By default, Neon waits 300 seconds (5 minutes) after the last active query before suspending compute to 0 CUs. If background jobs or health-checks ping your database every 4 minutes, the database will never suspend, racking up 730 active compute hours every month. Reducing the suspend timeout to 60 seconds allows the database to shut down between sporadic requests, reducing bills by up to 70%.

How do I prevent 4x Neon billing spikes?

To prevent sudden 4x billing spikes, configure tight autoscaling bounds (e.g. min 0.25 CU, max 2 CUs instead of max 8 CUs), optimize slow queries with indexes to avoid CPU saturation, and use Neon's connection pooler endpoint for serverless functions.

Neon Serverless Autoscaling Costs (2026): $1.28/hr Cost Guide

Neon Postgres Autoscaling Costs: Prevent 4x Spikes & Tune CUs

How Neon computes CU hours, why unindexed queries cause compute spikes up to 8 CUs ($1.28/hr), how to tune suspend timeouts from 300s to 60s, and exact configurations to minimize monthly bills.

⚡ 60-Second Neon Postgres Verdict ✓ Verified October 2026

Compute Units (CUs) Sizing & Scale-to-Zero Cold Starts

Neon Serverless Cost Verdict: Neon charges $0.16 per Compute Unit (CU) hour (1 CU = 1 vCPU, 4GB RAM) with instant scale-to-zero. While scale-to-zero is ideal for staging databases, production apps with intermittent web traffic can experience 300–800ms cold start latency on disconnected pools. By configuring minimum CU allocations (0.25 CU = $28.80/mo) and using Neon's built-in connection pooler (PgBouncer), startups maintain sub-10ms query performance while preventing runaway 8 CU burst overages. Estimate database costs in our Serverless Postgres Estimator and compare caching in Upstash vs Redis Cloud.

Neon CU Rate $0.16 / CU-hour

0.25 CU Floor ~$28.80 / month

Cold Start Latency 300ms – 800ms

Connection Pooling Native PgBouncer Included

Direct Summary: How Neon CU Autoscaling Spikes Occur

Neon bills Compute Units at $0.16 per CU per active hour. Sudden 4x bill spikes occur when: 1) Default Max CU is left at 8 CUs ($1.28/hr) and an unindexed query spikes CPU; 2) 300-second idle timeouts keep compute awake 24/7 if background cron jobs query every 4 minutes; and 3) Connection poolers pinging SELECT 1 prevent scale-to-zero. Restricting max CUs to 1.5–2.0 and dropping the suspend timeout to 60s cuts typical bills by 50% to 75%.

How Neon Autoscaling Functions Internally

Neon decouples compute from storage using a custom Rust-based storage engine (Pageserver and Safekeepers) connected to a stateless PostgreSQL compute pod running inside Kubernetes microVMs.

When queries arrive, Neon dynamically adjusts CPU and memory allocations without restarting PostgreSQL. If memory pressure or CPU utilization crosses 80%, Neon automatically provisions additional CUs up to your configured maximum. When traffic subsides for the configured suspend timeout duration, Neon writes WAL records to safekeepers and spins down the compute pod to zero.

The 4 Best Practices to Prevent Neon Billing Runaways

1. Set Explicit Upper Bounds on Compute Units

By default, new projects may have autoscaling bounds set to 0.25 CU to 8 CUs. If an unindexed query runs (such as a full table scan on 5 million rows), Postgres will consume 100% of available CPU cores. Neon's autoscaler interprets this as traffic demand and instantly scales your instance to 8 CUs ($1.28/hr).

Rule: In the Neon Console under Settings > Compute, set your maximum bound to 1.5 CUs or 2.0 CUs for staging and medium production apps. This caps your maximum hourly spend at $0.32/hr.

2. Reduce Suspend Timeout from 300s to 60s

The default suspend timeout is 5 minutes (300 seconds). If your application receives sporadic requests every 4.5 minutes, your database never enters scale-to-zero sleep! It stays awake 100% of the month (730 hours).

By reducing the suspend timeout to 60 seconds, the instance will shut down within 1 minute of query completion, reducing idle billing time by up to 80%.

3. Avoid Keep-Alive "SELECT 1" Pings in Serverless Poolers

Some external connection poolers (or ORMs like Prisma) configure automated health check heartbeats that execute SELECT 1 every 30 seconds to maintain warm connections. Doing this completely defeats serverless scale-to-zero!

Use Neon's native Serverless Driver over HTTP/WebSockets for Vercel and Cloudflare Workers, which requires zero long-lived connections and enables immediate suspend.

4. Branch Deletion & Copy-on-Write Storage Hygiene

Neon branches are free copy-on-write snapshots, but any writes performed on preview branches (such as CI migration test runs) accumulate billable delta storage at $0.35/GB. Set up a GitHub Action to automatically delete ephemeral preview branches when PRs are merged or closed.

Fractional Compute Units (CU) & Storage Branching Economics

Neon architecture separates storage (Safekeeper and Pageserver nodes) from ephemeral compute microVMs running on Kubernetes. Compute capacity is billed in Compute Units (CUs), where 1 CU equals 1 vCPU and 4GB of RAM at $0.16 per hour ($116.80/month). Neon allows fractional provisioning down to 0.25 CU (0.25 vCPU, 1GB RAM) at $0.04/hour. While autoscaling dynamically flexes compute to 8 CUs during traffic spikes, unconstrained auto-scaling can generate bill shock if runaway background worker queries hold database locks and keep compute scaled to max capacity.

Monthly Operating Cost Matrix: Neon Serverless Postgres Tiers

Workload Profile	Configured CU Range	Autosuspend Delay	Compute Cost	Storage & WAL (50GB)	Total Monthly Bill
Hobby / Staging	0.25 CU (Static)	5 minutes	$2.40	$6.15	$8.55
Early SaaS	0.25 to 2.0 CU	10 minutes	$28.50	$8.20	$36.70
Production Scale	1.0 to 8.0 CU	Always Warm (No suspend)	$145.00	$24.60 (200GB PITR)	$169.60

Workload Profile

Configured CU Range

Autosuspend Delay

Compute Cost

Storage & WAL (50GB)

Total Monthly Bill

Hobby / Staging

0.25 CU (Static)

5 minutes

$2.40

$6.15

$8.55

Early SaaS

0.25 to 2.0 CU

10 minutes

$28.50

$8.20

$36.70

Production Scale

1.0 to 8.0 CU

Always Warm (No suspend)

$145.00

$24.60 (200GB PITR)

$169.60

Neon API Autoscaling Constraint & Branching Provisioner

// Provision a preview branch in CI with strict 0.25 CU cap and 5-min autosuspend
export async function createPreviewDatabaseBranch(projectId: string, branchName: string) {
  const response = await fetch(`https://console.neon.tech/api/v2/projects/${projectId}/branches`, {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${process.env.NEON_API_KEY}`,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      branch: { name: branchName },
      endpoints: [{
        type: 'read_write',
        autoscaling_limit_min_cu: 0.25,
        autoscaling_limit_max_cu: 0.5, // Strict cap prevents unexpected cloud bills
        suspend_timeout_seconds: 300   // Suspend after 5 mins of idle CI tests
      }]
    })
  });
  return response.json();
}

Production Neon Guardrails & Failure Modes

Prevent WAL History Bloat: Neon retains write-ahead logs (WAL) to power instant branching and time-travel queries. Unchecked long retention windows (e.g. 30 days) on heavy write workloads significantly increase storage charges. Set retention to 7 days for dev and 14 days for prod.

Pooler Connection String: Always connect via the `-pooler` endpoint hostname. Connecting directly to the compute node bypasses PgBouncer, limiting concurrent connections to the raw Postgres limit and causing connection drops during compute resize operations.

Engineering Q&A: Neon Serverless Architecture

How does Neon database branching affect total storage billing?

Neon branches use Copy-on-Write (CoW) page references. When you branch a 100GB production database for a pull request, the branch uses 0MB of initial storage. You are only billed for new page changes written to that branch, allowing teams to create hundreds of isolated testing environments for pennies.

Does resizing compute drop active database connections?

No. Neon dynamically adds vCPUs and RAM to the active Linux cgroup of the running microVM in real time. Resizing does not require a database restart or connection drop, provided clients connect through the pooled connection gateway.