---
source_url: "https://layerbase.com/blog/best-database-for-nextjs-vercel"
title: "Best database for Next.js in 2026 (Vercel Postgres is gone) | Layerbase"
mirrored_at: 2026-08-30T01:01:02.204Z
host: layerbase.com
cited_in_42a: true
mirror_canonical: "https://index.42a.ai/layerbase.com/blog/best-database-for-nextjs-vercel"
---

> **Original source:** https://layerbase.com/blog/best-database-for-nextjs-vercel

Short version: Postgres is still the right default for a Next.js app on Vercel, and the only real question is who hosts it. Neon if you want the bill and the branching to stay inside Vercel. [Layerbase Cloud](https://cloud.layerbase.com/create?engine=postgresql) if you want plain managed Postgres without an enterprise-AI parent company. Supabase if you want auth and storage bundled and accept the lock-in. Convex if the app is real-time enough that SQL is the wrong shape, and Turso if reads are global and writes are rare.

The reason you have to pick at all is that Vercel does not run a database anymore. Vercel Postgres was their white-labelled Neon offering, and they wound it down in Q4 2024 and Q1 2025. Existing instances were migrated to Neon. The `@vercel/postgres` driver is no longer maintained. What Vercel sells now is a marketplace, and the list of credible options on it is shorter than the marketplace would suggest. Everything below is why each pick lands where it does.

The default if you do not want to think about it. The Vercel marketplace integration is one click and the bill comes through Vercel. Branching is genuinely useful for preview deployments because each git branch can get its own database branch in seconds.

The thing to know is that Neon is now owned by Databricks (May 2025, $1B). Prices actually went down post-acquisition (storage 80% cheaper, free tier doubled). If that is fine with you, Neon is a good pick. If you would rather your database vendor not also be an enterprise AI platform, see [Neon is now a Databricks product](https://layerbase.com/blog/neon-after-databricks) for the longer take.

What I build. Plain managed Postgres (and 17 other engines) with a Vercel-friendly serverless connection profile. Free dev tier, no card. Scale-to-zero on the free tier so cold and idle apps cost nothing. If your bill is going through Vercel and you want it to stay there, Neon is the smoother integration. If you want a database vendor that is not also chasing enterprise data-lakehouse customers, [Layerbase Cloud](https://cloud.layerbase.com/create?engine=postgresql) is the one to try.

The other thing Layerbase gets you, which neither Neon nor Supabase does, is the rest of the engine catalog under one account. Postgres for your app, Redis for sessions, Meilisearch for full-text, Qdrant for vector. Same dashboard, same bill, same auth. For most Next.js apps that is one Postgres and one Redis, but it scales nicely if the stack grows.

If you already have data somewhere, you do not start empty. The create flow has a **Migrating from another platform** option that copies your data across: paste an API key for Neon, Supabase, PlanetScale, Upstash, or Algolia and it lists your databases/indexes and copies the one you pick (Supabase auth users come over with their password hashes intact); or paste a connection string / Vercel KV URL for anything else. So switching is "paste a key, pick the database," not a weekend of `pg_dump`.

Postgres plus auth plus storage plus realtime plus row-level-security as one product. If you want all of that bundled and you like the Supabase developer experience, it is a good fit. The trade is that you are now opinionated about your auth and your storage layers in a way that you will pay to undo later if you outgrow them.

For a side project or an early-stage product, Supabase is fast. For a serious product where you expect to swap auth providers eventually, the bundling becomes a tax.

Not Postgres. A reactive document database with a TypeScript-native query language. If you are building something heavily real-time (collaborative editors, multiplayer, live dashboards), Convex is a different shape of database and the shape often fits better than bolting websockets onto Postgres.

The trade is that you are off SQL. If your team knows SQL, has SQL tooling, and might want a different backend in two years, Convex is a higher commit than Postgres.

MySQL and Postgres (Postgres support added in 2025). They killed the Hobby tier in April 2024, and the price objection has softened a lot since: a single-node PS-5 Postgres cluster is $5/mo, and the highly available three-node version of the same size is $15/mo. What did not come back is a free tier, so the cheapest way to try it still involves a card. For teams that genuinely need PlanetScale's branching and schema migration tooling at scale, it is good. For most Next.js apps the reason to skip it is that the tooling is aimed somewhere else, not the bill.

PlanetScale rates verified 2026-08-25 from [planetscale.com/pricing](https://planetscale.com/pricing), smallest Postgres cluster size.

SQLite at the edge. Read-heavy globally-distributed apps get great latency from this because the database lives close to the user. For a Next.js app where most pages are read-mostly content, this is interesting. For write-heavy apps it is harder, because SQLite is single-writer per database.

The default for "I do not want to deal with auth and database, just let me write the app." It works. It also locks you into a Google product surface that has burned a lot of developers (App Engine standard, Google Cloud Print, Stadia, the various Google chat apps). For a startup planning a multi-year product, Firebase is a bigger bet than it looks.

A Next.js app on Vercel typically needs four pieces. Database, KV / sessions, file storage, and sometimes search or vector. Here is the short matrix:

Piece

Start with

Move to when you outgrow it

**Database**

Postgres, on one of the hosts above

Convex if the app is heavily real-time, Turso if reads are global and writes are rare

**KV / Redis / sessions**

A free-tier Redis, which is usually enough

Upstash directly, or [Layerbase Cloud Redis](https://cloud.layerbase.com/create?engine=redis); Vercel KV is Upstash KV underneath either way

**File storage**

Vercel Blob, billed through Vercel

Cloudflare R2, cheaper at scale, or S3 if you already have AWS

**Full-text search**

Postgres' `tsvector`

[Meilisearch on Layerbase](https://cloud.layerbase.com/create?engine=meilisearch) or Algolia

**Vector / RAG**

pgvector inside your existing Postgres, fine through about 50M vectors

[Qdrant](https://cloud.layerbase.com/create?engine=qdrant) or [Weaviate](https://cloud.layerbase.com/create?engine=weaviate)

See [the vector DB roundup](https://layerbase.com/blog/vector-databases-compared-2026) for the longer take on that last row.

### Does Vercel have its own database?

Not anymore. Vercel Postgres was a white-labelled Neon offering and it was wound down across Q4 2024 and Q1 2025, with existing instances migrated to Neon and the `@vercel/postgres` driver left unmaintained. What Vercel runs now is a marketplace, so the database is a vendor decision you make yourself.

### What replaced Vercel Postgres?

Neon, literally: that is where the existing instances went, and the marketplace integration is the closest thing to the old first-party experience because the bill still arrives through Vercel. It is not the only option, though, and nothing about deploying on Vercel requires your database to live in the marketplace.

### What is the best database for a Next.js app in 2026?

Postgres, hosted by someone else. That answer holds for the large majority of Next.js apps, and the interesting decision is the host rather than the engine: Neon for the tightest Vercel integration, [Layerbase Cloud](https://cloud.layerbase.com/create?engine=postgresql) for plain managed Postgres, Supabase if you want auth and storage in the same product. Go off Postgres only for a specific reason, like a genuinely real-time app (Convex) or globally distributed reads (Turso).

### Is Neon still a good choice now that Databricks owns it?

Technically, yes. The acquisition closed in May 2025 at $1B, and prices went down afterwards rather than up: storage got 80% cheaper and the free tier doubled. The reason to look elsewhere is not the product, it is whether you want your database vendor to also be an enterprise AI platform with its own roadmap pressures. [Neon is now a Databricks product](https://layerbase.com/blog/neon-after-databricks) has the longer take.

### Do I need a separate Redis for a Next.js app?

Usually only for sessions, rate limiting, and caching, and a free-tier instance covers all three for a long time. Vercel KV is Upstash KV underneath, so using Upstash or [Layerbase Cloud Redis](https://cloud.layerbase.com/create?engine=redis) directly is the same class of thing with a different bill.

### How hard is it to switch hosts later?

Less exotic than it sounds, because all of these speak standard protocols: Postgres wire, MySQL wire, HTTPS. Moving between two Postgres hosts is a dump and a restore plus a connection-string change. Layerbase Cloud has a **Migrating from another platform** option in the create flow that copies from Neon, Supabase, PlanetScale, Upstash, or Algolia with an API key, so that particular direction is closer to "paste a key, pick the database" than a weekend of `pg_dump`. Leaving Supabase or Convex is the harder case, because the thing you have to replace is auth or the query model, not the rows.

For a typical Next.js app on Vercel in 2026:

-   Postgres is still the right answer. Pick a host.
-   If you want the smoothest Vercel integration and do not care about the Databricks ownership, use Neon.
-   If you want plain managed Postgres without the enterprise-AI parent company, use [Layerbase Cloud](https://cloud.layerbase.com/create?engine=postgresql).
-   If you want Postgres plus auth plus storage in one product and you accept the lock-in, use Supabase.
-   If your app is heavily real-time and you do not need SQL, look at Convex.
-   Skip PlanetScale unless you specifically need their tooling at scale.
-   Skip Firebase unless you really do not want to think about the backend.

The good news is that all of these speak standard protocols (Postgres wire, MySQL wire, HTTPS). Migration between them is annoying but not exotic. Pick the one that fits today, plan to swap if it does not.