PostgreSQL vs Neon for Solo Developers

Quick Comparison

PostgreSQL Overview

Self-hosted PostgreSQL means you run the database on your own server. You control everything: the version, extensions, configuration, backup strategy, replication, and resource allocation. This gives you maximum flexibility and zero vendor lock-in.

The tradeoff is operational responsibility. You handle updates, security patches, backups, monitoring, connection pooling, and disaster recovery. For a solo developer who already manages a VPS, adding Postgres is straightforward. For someone who wants to focus purely on application code, it is extra work.

Cost-wise, self-hosted Postgres is unbeatable. A $5-10/mo VPS from Hetzner or DigitalOcean can run Postgres alongside your application. No per-query charges, no connection limits, no compute hour caps. Just a flat monthly server cost.

Neon Overview

Neon is serverless PostgreSQL that separates storage from compute, allowing your database to scale to zero when idle and spin up on demand. It is full PostgreSQL compatibility with a serverless billing model. Think of it as "Postgres without the ops."

The free tier is genuinely generous. It gives you 0.5 GB of storage per project, 100 CU-hours of compute per project each month, up to 100 projects, 10 branches per project, and a compute that autoscales up to 2 CU (8 GB RAM) before scaling to zero after five minutes idle. For side projects and early-stage products, this is enough to run a real application without spending anything. Note that Neon retired its old flat $19/mo Pro plan. Paid usage now runs through the pay-as-you-go Launch and Scale plans, where you are billed per CU-hour of compute and per GB-month of storage rather than a fixed monthly fee.

Database branching is Neon's standout feature. You can create instant copies of your database for testing, development, or preview deployments. This is genuinely useful when paired with preview deploy services like Vercel. Each preview gets its own database branch with real data.

Key Differences

Same engine, different delivery. Neon runs PostgreSQL. It is not a Postgres-compatible database. It is actual Postgres. Your SQL, extensions, and tools work the same way. The difference is in how the infrastructure is managed and billed.

Operational burden is the real comparison. Self-hosted Postgres means you manage backups, updates, monitoring, and failover. Neon handles all of this automatically. For a solo developer who would rather write features than manage database infrastructure, Neon removes a meaningful chunk of ops work.

Cold starts are the tradeoff. Neon's serverless model means your database can spin down when idle. The first query after inactivity takes a few hundred milliseconds to wake up the compute. For always-on production apps, this adds latency. Self-hosted Postgres is always running and always fast.

Cost structure differs significantly. Self-hosted Postgres costs whatever your server costs, regardless of usage. Neon charges based on compute hours and storage, at $0.106 per CU-hour and $0.35 per GB-month on the Launch plan. For a side project with sporadic traffic, Neon is cheaper because scale-to-zero means you pay almost nothing when nobody is hitting the database. For a production app with constant traffic, self-hosted is often cheaper because a flat VPS, from EUR 3.79/mo for a Hetzner CX22, has no per-hour compute meter running 24/7. See the worked numbers in "Real Cost at Solo-Dev Scale" below.

Branching is Neon's killer feature. Creating a copy of your production database takes seconds in Neon and uses copy-on-write storage, so it barely costs anything. Doing this on a self-hosted setup means dumping and restoring the database manually. For development workflows, especially with preview deploys, this is a legitimate advantage.

Connection pooling is handled for you. Neon includes a built-in connection pooler. Self-hosted Postgres needs PgBouncer or a similar tool to handle many concurrent connections efficiently, especially in serverless environments. One less thing to configure.

By the Numbers (2026)

Figures below were checked on 2026-05-29 against vendor pages and the public npm and GitHub APIs. Sources are listed at the end.

Versions. PostgreSQL 18 is the current major line. The latest minor release is 18.4, shipped 2026-05-14 alongside back-branch updates for 17.10, 16.14, 15.18, and 14.23. Neon runs real PostgreSQL (Postgres 17 by default), so the same SQL, extensions, and drivers apply on both sides.

Adoption and ecosystem. The official PostgreSQL source mirror (postgres/postgres) sits at 21,021 GitHub stars and 5,674 forks. Neon's serverless storage-and-compute engine (neondatabase/neon) sits at 22,075 stars. On the driver side, the long-standing node-postgres client (pg) pulled 29,260,035 npm downloads in the week of 2026-05-21 and is at version 8.21.0. Neon's HTTP/WebSocket serverless driver (@neondatabase/serverless) pulled 1,993,558 downloads that same week and is at version 1.1.0. The takeaway: any tool that talks to Postgres talks to Neon, and pg works against both.

Neon plan limits.

One CU (compute unit) is roughly 1 vCPU plus 4 GB RAM, and Neon bills it by the hour of active compute. Scale-to-zero (5 minutes idle on Free, configurable on paid) is what makes the meter stop on a quiet side project.

Self-hosted floor. The cost of running Postgres yourself is just the box it sits on. A Hetzner Cloud CX22 (2 vCPU, 4 GB RAM, 40 GB SSD, 20 TB traffic) is EUR 3.79/mo. On DigitalOcean, a Basic Droplet runs $4/mo (512 MiB RAM, 1 vCPU, 10 GiB SSD), $6/mo (1 GiB, 25 GiB), or $12/mo (2 GiB, 50 GiB). Postgres itself adds nothing to that bill.

Real Cost at Solo-Dev Scale

Here is a concrete comparison using the real per-unit rates above. The point is to show where the crossover sits, not to crown a winner.

Assumptions for a typical solo-dev production app:

• One always-on database (no scale-to-zero, because real users hit it through the day).
• 1 CU of compute (about 1 vCPU / 4 GB RAM), running 24/7.
• 10 GB of stored data.
• Light egress, inside the 100 GB included on Launch.
• A month is 730 hours.

Neon (Launch plan), always-on:

• Compute: 730 hours x 1 CU x $0.106/CU-hour = $77.38
• Storage: 10 GB x $0.35/GB-month = $3.50
• Egress: $0 (within the 100 GB included)
• Total: about $80.88/mo

Self-hosted on a Hetzner CX22 (2 vCPU, 4 GB):

• Server: EUR 3.79/mo, roughly $4 to $4.50/mo depending on the exchange rate
• Storage and egress: included in that flat price (40 GB SSD, 20 TB traffic)
• Total: about $4/mo, plus your time for backups, patching, and monitoring

For an always-on workload, self-hosting is dramatically cheaper, on the order of 15 to 20 times less per month, because a flat VPS has no per-hour compute meter. The cost you trade for that is operational: you own the backups, the upgrades, and the 2 a.m. page if the disk fills.

Now flip the workload to a sporadic side project (a hobby app that gets a handful of requests a day). With scale-to-zero, Neon's compute might only run a few CU-hours across the whole month. At $0.106/CU-hour, that is cents, and storage on 0.5 GB stays inside the free quota. Here Neon effectively costs $0 while the always-on VPS still costs its flat EUR 3.79/mo every single month whether anyone visits or not.

That is the real decision boundary. Steady traffic favors the flat VPS. Spiky, idle-heavy, or genuinely free-tier traffic favors Neon's scale-to-zero.

When to Choose Self-Hosted PostgreSQL

• You already manage a VPS and are comfortable with database administration
• You need predictable, flat-rate pricing regardless of usage
• You want zero cold start latency for always-on applications
• You need specific Postgres extensions or custom configurations
• You want maximum control and zero vendor lock-in

When to Choose Neon

• You want Postgres without managing infrastructure
• You are building side projects and want a free database
• You use preview deployments and want database branching
• Your application has variable or low traffic
• You want connection pooling handled automatically

The Verdict

Both earn a 9/10 for solo developers, and the right choice depends on your situation. If you already run a VPS and are comfortable with basic server administration, self-hosted Postgres gives you the best value and performance. No cold starts, no usage limits, no surprises.

If you want to focus entirely on building your application and never think about database ops, Neon is excellent. The free tier is generous enough for real projects, branching is genuinely useful, and the fact that it is real PostgreSQL means you can migrate away anytime. My recommendation: use Neon for side projects and prototypes, self-host Postgres for production applications that need consistent performance.

Sources

All figures checked on 2026-05-29.

• Neon pricing and plan limits: https://neon.com/pricing
• Neon plan reference (compute rates, storage rates, history windows): https://neon.com/docs/introduction/plans
• PostgreSQL current version (18.4, released 2026-05-14): https://www.postgresql.org/
• PostgreSQL source mirror stars and forks: https://github.com/postgres/postgres
• Neon engine repository stars: https://github.com/neondatabase/neon
• node-postgres (pg) latest version: https://registry.npmjs.org/pg/latest
• node-postgres (pg) weekly downloads: https://api.npmjs.org/downloads/point/last-week/pg
• Neon serverless driver latest version: https://registry.npmjs.org/@neondatabase/serverless/latest
• Neon serverless driver weekly downloads: https://api.npmjs.org/downloads/point/last-week/@neondatabase/serverless
• Hetzner Cloud CX22 pricing (EUR 3.79/mo, 2 vCPU, 4 GB RAM, 40 GB SSD): https://www.hetzner.com/cloud/
• DigitalOcean Basic Droplet pricing ($4 / $6 / $12 tiers): https://www.digitalocean.com/pricing/droplets