DEV Community

Alex Spinov
Alex Spinov

Posted on

Neon Has a Free Tier — Serverless Postgres With Branching, 512 MB Storage, and No Credit Card

#postgres #database #serverless #webdev

Most developers still spin up a $15/mo Postgres instance on RDS or DigitalOcean for side projects. Then they forget about it. Then they get the bill.

Neon gives you serverless Postgres that scales to zero. Free tier: 512 MB storage, 0.25 vCPU, database branching (like git for your database), and no credit card.

Here's everything you get — and the code to start using it in 30 seconds.

What's in the Free Tier

Resource Free Limit
Storage 512 MB
Compute 0.25 vCPU, 1 GB RAM
Branches 10
Projects 1
Autoscaling Scale to zero (pay nothing when idle)
Regions AWS us-east-1, eu-central-1, ap-southeast-1

The killer feature: database branching. Create a copy of your production database in <1 second for testing, migrations, or feature development. No pg_dump. No waiting.

Quick Start (Node.js) 

npm install @neondatabase/serverless
Enter fullscreen mode Exit fullscreen mode 
import { neon } from '@neondatabase/serverless';

const sql = neon(process.env.DATABASE_URL);

// Create a table
await sql`CREATE TABLE IF NOT EXISTS users (
  id SERIAL PRIMARY KEY,
  name TEXT NOT NULL,
  email TEXT UNIQUE NOT NULL,
  created_at TIMESTAMP DEFAULT NOW()
)`;

// Insert
await sql`INSERT INTO users (name, email) VALUES ('Alex', 'alex@example.com')`;

// Query
const users = await sql`SELECT * FROM users WHERE created_at > NOW() - INTERVAL '7 days'`;
console.log(users);
// [{ id: 1, name: 'Alex', email: 'alex@example.com', created_at: '2026-03-26T...' }]
Enter fullscreen mode Exit fullscreen mode

That's it. No connection pooling config. No SSL certificates. No pg_hba.conf. The serverless driver handles everything over HTTP.

Quick Start (Python) 

pip install psycopg2-binary
Enter fullscreen mode Exit fullscreen mode 
import psycopg2
import os

conn = psycopg2.connect(os.environ["DATABASE_URL"])
cur = conn.cursor()

cur.execute("""
    CREATE TABLE IF NOT EXISTS events (
        id SERIAL PRIMARY KEY,
        name TEXT NOT NULL,
        payload JSONB,
        created_at TIMESTAMP DEFAULT NOW()
    )
""")

cur.execute(
    "INSERT INTO events (name, payload) VALUES (%s, %s)",
    ("signup", '{"plan": "free", "source": "github"}')
)

conn.commit()

cur.execute("SELECT * FROM events WHERE payload->>'plan' = 'free'")
print(cur.fetchall())
Enter fullscreen mode Exit fullscreen mode

Standard psycopg2. Your existing Postgres code works without changes.

Database Branching — The Feature That Changes Everything 

# Install Neon CLI
npm install -g neonctl

# Create a branch from main
neonctl branches create --name feature/new-auth

# Get connection string for the branch
neonctl connection-string feature/new-auth
# postgres://user:pass@ep-xxx.us-east-1.aws.neon.tech/neondb?sslmode=require

# Run destructive migrations safely
psql $(neonctl connection-string feature/new-auth) -c "ALTER TABLE users DROP COLUMN legacy_field"

# If it works → merge. If not → delete the branch. Production untouched.
neonctl branches delete feature/new-auth
Enter fullscreen mode Exit fullscreen mode

This is what makes Neon different from Supabase, PlanetScale, or plain RDS. You get instant, copy-on-write database copies. A 10 GB database branches in <1 second because it's just pointer duplication, not data copying.

Use cases:

  • Preview environments (each PR gets its own database branch)
  • Safe migration testing
  • Data analysis on a snapshot (without touching production)
  • Debugging with production-like data

Neon vs. Supabase vs. PlanetScale

Feature Neon Supabase PlanetScale
Engine Postgres Postgres MySQL (Vitess)
Free storage 512 MB 500 MB 5 GB (was free, now paid)
Branching ✅ instant ❌ ✅ (but MySQL)
Scale to zero ✅ ❌ (always running) ✅
Serverless driver ✅ (HTTP) ✅ (REST/GraphQL) ❌
Auth built-in ❌ ✅ ❌
Cold start ~0.5s N/A ~1s

Choose Neon if: You want standard Postgres, database branching, and true scale-to-zero.
Choose Supabase if: You want a full backend (auth, storage, realtime) in one platform.
Choose PlanetScale if: You need MySQL or horizontal sharding at scale.

When You'll Hit the Free Tier Limits

512 MB sounds small, but for most side projects it's plenty:

  • Blog with 10K posts (title + body + metadata): ~200 MB
  • SaaS with 50K users (users + sessions + basic data): ~150 MB
  • API cache (10K JSON records): ~50 MB

You'll hit the compute limit (0.25 vCPU) before storage if you run complex queries. For that, upgrade to Pro ($19/mo for 1 vCPU + 10 GB).

The Bottom Line

Neon solves the "I need Postgres but don't want to manage infrastructure" problem better than anyone else right now. The free tier is generous enough for any side project, the branching feature is genuinely unique, and the serverless driver means zero config.

Try it: neon.tech — sign up takes 30 seconds, no credit card.

Top comments (0)