For a new Next.js application in 2026, Neon is the most pragmatic serverless database choice. It is serverless Postgres with database branching, autoscales to zero on the free tier, and integrates directly with Vercel. PlanetScale still wins for MySQL compatibility and non-blocking schema changes. Supabase is the choice when you need a full backend stack beyond just a database.
What Makes a Database "Serverless"
Traditional managed databases (Amazon RDS, DigitalOcean Managed Postgres) run a dedicated VM. You pay for the instance whether or not it is receiving queries. Cold starts are not a concern because the database is always running.
Serverless databases decouple storage from compute. The database can scale to zero when idle (costing nothing) and scale up when traffic arrives. This is ideal for applications with unpredictable traffic patterns, staging environments that sit idle most of the time, and early-stage products where minimizing costs matters.
The tradeoff is connection handling. Traditional Postgres expects long-lived connections from a connection pool. A serverless environment where each function invocation creates and closes connections exhausts Postgres connection limits quickly. Serverless databases address this with HTTP-based query APIs or built-in connection poolers.
Neon: Serverless Postgres with Branching
Neon is the standout choice for Next.js developers in 2026. Here is what makes it compelling.
Postgres, without compromise. Neon runs actual Postgres (currently 16). Every Postgres feature, extension, and tool works. pgvector for AI embeddings, PostGIS for geospatial data, full-text search, window functions, row-level security. You are not using a Postgres-compatible database that misses edge cases. You are using Postgres.
Database branching. This is Neon's killer feature. You can create a branch of your database in about 2 seconds, the same way Git works with code. A Neon branch is a full copy-on-write fork of your database that diverges as writes happen. For development workflows, this is transformative: create a branch per pull request, run migrations against the branch, and delete it when the PR merges. Your staging environment shares the schema with production but has its own isolated data.
Autoscales to zero. On Neon's free tier, your database suspends after 5 minutes of inactivity and resumes on the next connection. There is a cold start (typically 200-500ms on first query after idle), but you pay nothing while idle. The free tier includes 0.5 GB of storage and 10 compute hours per month.
HTTP driver for serverless. Neon provides @neondatabase/serverless, a Postgres driver that uses HTTP instead of TCP. This means each serverless function invocation can query Neon without maintaining a persistent connection. No connection exhaustion issues in serverless environments.
Vercel integration. Neon's Vercel integration creates a database branch for each Vercel preview deployment automatically. Your preview deployments get isolated databases without manual setup.
PlanetScale: Serverless MySQL with Schema Branching
PlanetScale is built on Vitess, the database clustering system YouTube built to scale MySQL. PlanetScale adds a developer experience layer on top: a Git-like branching model for schema changes, non-blocking DDL, and a connection pooling infrastructure.
Non-blocking schema changes. In standard MySQL, some DDL operations (like adding a column to a large table) lock the table, causing downtime. PlanetScale's Vitess foundation handles DDL changes non-destructively. You make schema changes on a branch, open a "deploy request" (like a pull request), and PlanetScale applies the migration in a way that does not lock your production tables.
Schema branching. Similar to Neon's branching, but specifically focused on schema management. PlanetScale's branches are for evolving your schema safely. They are not full data forks like Neon's branches.
Connection pooling built in. PlanetScale's infrastructure handles connection pooling. You connect to PlanetScale with its HTTP driver, and PlanetScale manages the underlying MySQL connections. This is similar to Neon's serverless driver.
The 2024 pivot. PlanetScale eliminated its free tier in 2024, which caused significant developer backlash. The hobby plan was reintroduced at $39/month, which is not free-tier competitive with Neon. PlanetScale is now more clearly positioned at teams with strict MySQL requirements.
Supabase: Managed Postgres with Full Backend Stack
Supabase is covered in more depth in its own comparison post, but in the context of serverless databases specifically: Supabase is a managed Postgres with a connection pooler (Suvisor), REST API (PostgREST), authentication, storage, and edge functions built on top.
Supabase does not autoscale to zero (except on the free tier with pausing enabled, and even then the free tier pauses the entire project, not just the database). You pay for a dedicated compute instance per project. The free tier includes one project with limited compute.
Choose Supabase when you need the full backend stack in one place. Choose Neon when you just need a great serverless Postgres database.
TiDB Cloud: Truly Distributed MySQL
TiDB is a distributed, MySQL-compatible database that can handle HTAP workloads (mixed transactional and analytical). TiDB Cloud is its managed offering with a serverless tier that genuinely autoscales.
For most Next.js applications, TiDB is overkill. Its distributed architecture shines when you need horizontal scaling across multiple nodes. At the scale most indie developers and small teams operate, a single Neon database is more than sufficient.
TiDB's serverless tier has an attractive free tier and MySQL compatibility, making it a reasonable alternative to PlanetScale for teams that want MySQL semantics with true serverless scaling.
Practical Recommendation for Next.js
For a new Next.js project deployed to Vercel:
-
Default choice: Neon. Native Postgres, database branching per PR via the Vercel integration, generous free tier, HTTP driver for serverless functions. This is the path most Next.js developers take.
-
Existing MySQL codebase or strict MySQL requirements: PlanetScale. Non-blocking schema changes are a genuine operational advantage. The $39/month entry point is worth it for production MySQL workloads.
-
Need full backend beyond database: Supabase. When you also need auth, storage, real-time, and edge functions managed together, Supabase is the unified option.
Cost at Scale Reference
| Provider | Free Tier | Entry Paid | Per GB | |---|---|---|---| | Neon | 0.5 GB, 10h compute | $19/month | $0.08/GB | | PlanetScale | $39/month (hobby) | $39/month | Included in plan | | Supabase | 1 project, 500 MB | $25/month | $0.125/GB | | TiDB Cloud | 5 GB storage | $0.10/RU | $0.28/GB |
For early-stage applications, Neon's free tier and Supabase's free tier are the most generous starting points.
Keep Reading
- Supabase vs Firebase Comparison — detailed look at the full Supabase backend stack vs Firebase
- Next.js App Router Patterns 2026 — connecting serverless databases in the App Router
- CI/CD for Small Engineering Teams — using Neon database branches in your CI pipeline
Pristren builds AI-powered software for teams. Zlyqor is our all-in-one workspace — chat, projects, time tracking, AI meeting summaries, and invoicing — in one tool. Try it free.
