Nov 16, 20268 min read

Supabase vs Neon: Which Postgres Platform to Pick in 2026

How Supabase and Neon compare on pricing, compute, branching, scale to zero, auth and storage, and how to keep the choice open by running Postgres from your own backend code.

Illustration for Supabase vs Neon: Which Postgres Platform to Pick in 2026

Supabase and Neon both start as hosted Postgres with a generous free plan, which is why they end up on the same shortlist for a new project. Supabase puts each project on its own compute instance and builds Auth, Storage, Realtime and Edge Functions around it, while Neon separates storage from compute so databases can branch in seconds and scale to zero, and since Databricks acquired it in 2025 it has grown its own auth, functions and object storage.

This guide compares the two on pricing, compute, branching and the services around the database, and shows how Encore keeps the database choice open by declaring Postgres in your backend code and running it on RDS, Cloud SQL or Neon.

Supabase vs Neon at a glance

EncoreSupabaseNeon
Postgres runs onRDS or Cloud SQL in your account, or NeonA compute instance per projectServerless compute with separate storage
BillingYour cloud bill, or Neon usagePlan fee plus compute per projectCU-hours and GB-months
Paid entry pointYour cloud billPro $25/month incl. one Micro instanceLaunch, pay as you go, $0.106/CU-hour
Scale to zeroDepends on the database you chooseNo on paid plansYesafter 5 minutes on Free and Launch
BranchingNeon branches per environment, if you use NeonBranching on Pro and aboveCopy-on-write branches, 10 per project on Free and Launch
Free planOpen source, local Postgres with encore run500 MB database, paused after 1 week idle, 2 projects100 projects, 1 GB each, 100 CU-hours per project
Around the databaseAPIs, Pub/Sub, cron, buckets in your backend codeAuth, Storage, Realtime, Edge FunctionsAuth, Data API, Functions, Object Storage
Local developmentencore run starts PostgresSupabase CLI with DockerA Neon branch or your own Postgres

Prices are from the Supabase and Neon pricing pages, checked November 16, 2026.

Running Postgres from your backend code with Encore

Encore

Encore is a backend framework with built-in infrastructure for TypeScript and Go, and the database is one declaration in the service that uses it. Where that database runs is an environment setting: encore run starts Postgres locally, AWS and GCP environments get RDS or Cloud SQL in your own account, and an environment can use a Neon database instead, created as a new project or branched from another environment.

Set up the app

Get started
brew install encoredev/tap/encore &&
encore app create
Copy

Run in your terminal to get started locally.

~
$ encore app create notes --example=ts/hello-world$ cd notes && mkdir -p notes/migrations

The notes service has an encore.service.ts that exports new Service("notes"), a migration that creates the table with an index on owner and date, and the API below. The owner comes from the auth handler, not from the request.

// notes/notes.ts import { api, APIError, Gateway } from "encore.dev/api"; import { authHandler, Header } from "encore.dev/auth"; import { secret } from "encore.dev/config"; import { SQLDatabase } from "encore.dev/storage/sqldb"; import { getAuthData } from "~encore/auth"; import { createHmac, timingSafeEqual } from "node:crypto"; const sessionKey = secret("SessionKey"); interface AuthParams { authorization: Header<"Authorization">; } interface AuthData { userID: string; } export const auth = authHandler<AuthParams, AuthData>(async (params) => { const token = (params.authorization ?? "").replace(/^Bearer\s+/i, ""); const parts = token.split("."); if (parts.length !== 3) throw APIError.unauthenticated("invalid token"); const [id, expStr, sig] = parts; const exp = Number(expStr); if (!id || !Number.isFinite(exp) || exp <= Math.floor(Date.now() / 1000)) { throw APIError.unauthenticated("invalid token"); } const want = createHmac("sha256", sessionKey()).update(`${id}.${expStr}`).digest("hex"); const a = Buffer.from(sig); const b = Buffer.from(want); if (a.length !== b.length || !timingSafeEqual(a, b)) { throw APIError.unauthenticated("invalid token"); } return { userID: id }; }); export const gateway = new Gateway({ authHandler: auth }); // One declaration for every environment: Postgres from `encore run` locally, // RDS or Cloud SQL in your cloud, or a Neon branch if the environment uses Neon. const db = new SQLDatabase("notes", { migrations: "./migrations" }); interface Note { id: number; title: string; body: string; createdAt: Date; } export const create = api( { expose: true, auth: true, method: "POST", path: "/notes" }, async (p: { title: string; body?: string }): Promise<Note> => { if (!p.title.trim()) throw APIError.invalidArgument("title is required"); const ownerId = getAuthData()!.userID; const row = await db.queryRow<Note>` INSERT INTO notes (owner_id, title, body) VALUES (${ownerId}, ${p.title}, ${p.body ?? ""}) RETURNING id, title, body, created_at AS "createdAt"`; return row!; }, ); export const list = api( { expose: true, auth: true, method: "GET", path: "/notes" }, async (): Promise<{ notes: Note[] }> => { const ownerId = getAuthData()!.userID; const notes: Note[] = []; for await (const row of db.query<Note>` SELECT id, title, body, created_at AS "createdAt" FROM notes WHERE owner_id = ${ownerId} ORDER BY created_at DESC LIMIT 50`) { notes.push(row); } return { notes }; }, );

encore run starts Postgres, applies the migration and serves both endpoints, so the app works on a fresh clone without a Supabase or Neon account. The queries are tagged templates, so values are sent as parameters, and the same code runs unchanged whether the environment's database is RDS, Cloud SQL or a Neon branch, with Encore wiring the connection and running migrations on deploy.

That split is the practical difference from picking Supabase or Neon directly: the database provider becomes a per-environment choice, so a team can use Neon branches for preview and staging and RDS in production, or move later without touching the code. The rest of the backend, such as Pub/Sub, cron jobs and buckets, is declared in the same TypeScript, and an AI coding agent can add a table, a migration and an endpoint in one change that encore run checks against a real Postgres.

Best fit: teams that want Postgres plus the rest of the backend declared in code, with the database on RDS or Cloud SQL in their own account or on Neon per environment.

Supabase: Postgres plus Auth, Storage and Realtime

Supabase gives each project a Postgres database, Auth, file Storage, Realtime and Edge Functions, and lets you use any of them or only the database through its connection string. The Free plan includes a 500 MB database on shared compute and two active projects, and free projects pause after a week without activity. Pro starts at $25 per month with 8 GB of disk per project, daily backups kept for 7 days and $10 of compute credit that covers one Micro instance (1 GB RAM, 60 direct and 200 pooler connections), and each additional project adds its own compute, from $10 for Micro to $110 for Large with 2 dedicated vCPUs. Team is $599 per month and adds SSO, longer backups and log retention.

Compute is an instance that runs whether or not queries arrive, which makes the bill predictable for steady traffic and means idle projects on paid plans still cost their instance price. Local development runs the stack through the Supabase CLI and Docker, and Branching on Pro and above gives a separate development environment off the production project.

Best fit: apps that want the database, auth, file storage and realtime from one provider, with steady traffic and a predictable monthly bill.

Neon: serverless Postgres with branching

Neon separates storage from compute, so a database can scale to zero when idle, autoscale between compute sizes and branch its data and schema in seconds as a copy-on-write copy. The Free plan includes 100 projects with 1 GB of storage each (20 GB per account), 100 CU-hours per project and compute that suspends after 5 minutes. Launch bills $0.106 per CU-hour (a CU is about 4 GB of RAM with CPU) and $0.35 per GB-month of storage, with autoscaling to 16 CU and a 7-day restore window, and Scale bills $0.222 per CU-hour with up to 30 days of history and configurable scale to zero.

Branching is the feature teams pick Neon for: a branch per pull request or per developer gets production-shaped data without a dump and restore, and with many small databases it suits tenant-per-database and agent-created databases, which TechCrunch reported made up 80% of new Neon databases at the time of the acquisition. A suspended compute adds a cold start to the first query after idle time, which matters for latency-sensitive production endpoints and is why Launch lets you turn scale to zero off.

Best fit: apps with idle or spiky database traffic, preview environments that need real data, and platforms that create many small databases.

How to choose

Pick Supabase when the app wants auth, storage and realtime from the same provider as the database and traffic is steady enough that an always-on instance is the simpler bill. Pick Neon when databases sit idle much of the time or you want branches with real data for every pull request. Pick Encore when the database is one part of a backend you want declared in code and running in your own AWS or GCP account, with Neon available per environment where branching helps and RDS or Cloud SQL where you want the database in your own account, and moving data between any of them stays a standard pg_dump and pg_restore.

Frequently asked questions

What is the difference between Supabase and Neon?

Supabase gives each project a Postgres database on its own compute instance plus Auth, Storage, Realtime and Edge Functions, billed as a plan fee plus compute per project. Neon runs serverless Postgres with storage separated from compute, branching and scale to zero, billed per CU-hour and GB-month, and has added auth, a Data API, functions and object storage around it.

Is Neon or Supabase cheaper?

For databases that sit idle much of the day Neon is usually cheaper, since suspended compute costs nothing and Launch bills $0.106 per CU-hour. For an always-on database, Supabase Pro at $25 per month including one Micro instance is easier to predict. Prices checked November 16, 2026.

Does Supabase have database branching like Neon?

Supabase offers Branching on Pro and above, which runs a separate development environment off the production project. Neon branches are copy-on-write copies of a database's data and schema that are created in seconds, with up to 10 branches per project on Free and Launch and 25 on Scale.

Can I use Neon with Encore?

Yes. An Encore environment can use a Neon database instead of RDS or Cloud SQL: connect your Neon API key under App Settings > Integrations > Neon and pick Neon database when creating the environment. The same SQLDatabase declaration then runs on local Postgres with encore run, on Neon in that environment and on RDS or Cloud SQL in others.

Deploy to your cloud on AWS and Google Cloud
without managing infrastructure

Encore lets developers and agents define application infrastructure directly in code, then automatically provisions it from local development to production in your AWS or GCP account.

~/orders — claude
Claude Code
Claude Code v2.1.180Opus 5.5~/orders