After PlanetScale killed its free MySQL tier, developers moved to Postgres — and the two free leaders are Supabase and Neon. Both run standard PostgreSQL and work with your existing ORM, but they're built around different philosophies. The right pick depends entirely on what you're building.

Quick comparison: free tiers

Supabase: the full backend-as-a-service

Supabase is an open-source Firebase alternative built entirely on real PostgreSQL. One project gives you the database plus a PostgREST auto-API, GoTrue auth (email, OAuth, magic links, phone OTP), file storage, WebSocket realtime, and Deno edge functions — replacing what you'd otherwise build with Express + Passport + Multer + a websocket server. The free tier: 500 MB database, 1 GB file storage, up to 50,000 monthly active auth users, 500K edge-function invocations, 200 realtime connections, 5 GB bandwidth, 2 active projects. The one catch: projects pause after 1 week of inactivity, adding a 1-2s cold start on the next request.

import { createClient } from '@supabase/supabase-js'

const supabase = createClient('https://yourproject.supabase.co', 'your-anon-key')



const { data } = await supabase.from('notes')

  .select('*').eq('published', true).order('created_at', { ascending: false }).limit(10)

Auth is zero-config (supabase.auth.signUp(...), signInWithOAuth({ provider: 'github' })), and its standout feature is Row Level Security — security rules live in the database, so the same "users see only their own data" policy applies whether a request comes through the SDK, REST API, or raw SQL:

ALTER TABLE notes ENABLE ROW LEVEL SECURITY;



CREATE POLICY "Users can read own notes"

ON notes FOR SELECT USING (auth.uid() = user_id);



CREATE POLICY "Users can insert own notes"

ON notes FOR INSERT WITH CHECK (auth.uid() = user_id);

For serverless deploys, use the "Transaction mode" connection string (routed through built-in PgBouncer) rather than a direct connection.

Neon: serverless Postgres with branching

Neon separates storage from compute, so compute scales to zero when idle — you're not paying for idle time. It's 100% standard PostgreSQL (PG 16) with no proprietary SDK, and it's the engine behind Vercel Postgres. The free plan restructured in 2026 and is now per-project (quoted from Neon's pricing page, August 2026): up to 100 projects, each with 100 compute-unit-hours/month and 0.5 GB of storage, compute sizes up to 2 CU (8 GB RAM), no credit card. Compute still scales to zero when idle, so the CU-hours only burn while a database is actually awake.

Its killer feature is database branching — a branch is an instant, near-zero-cost copy-on-write snapshot. That enables a fresh isolated database per pull request, migration testing against real production data (delete the branch if it breaks — production is untouched), and per-developer environments:

npm install -g neonctl

neonctl auth

neonctl branches create --name feature/add-users --parent main

neonctl connection-string feature/add-users

Neon's serverless driver talks over HTTP instead of TCP, so it works natively in edge runtimes (Cloudflare Workers, Vercel Edge) with no pooling config — the cleanest option for serverless:

import { neon } from '@neondatabase/serverless'

const sql = neon(process.env.DATABASE_URL)



const email = 'alice@example.com'

const user = await sql`SELECT * FROM users WHERE email = ${email}`  // parameterized, injection-safe

It pairs well with Drizzle (drizzle-orm/neon-http) and ships an official GitHub Action (neondatabase/create-branch-action) to spin up a preview branch on PR open and run migrations against it.

Head-to-head

• Branching — Neon wins clearly. Free-tier branching that lets you test a migration on real data and discard it removes a whole category of risk. Supabase has no free-tier branching.
• Auth & APIs — Supabase wins clearly. Neon is just a database (bring your own NextAuth/Clerk/Auth0). Supabase's bundled auth + auto REST API + RLS can replace days of CRUD and let the frontend read the DB securely with no separate API server.
• Serverless connections. Supabase uses standard PgBouncer; Neon's HTTP driver is more convenient in edge runtimes.
• Vector search. Both support pgvector equally; Supabase has better first-party docs.
• Cold start. Neon's ~300ms wake beats Supabase's 1-2s project resume for intermittent traffic.

-- Works on both Supabase and Neon

CREATE EXTENSION IF NOT EXISTS vector;

CREATE TABLE documents (id SERIAL PRIMARY KEY, content TEXT, embedding vector(1536));

CREATE INDEX ON documents USING ivfflat (embedding vector_cosine_ops) WITH (lists = 100);



SELECT content, 1 - (embedding <=> '[...]'::vector) AS similarity

FROM documents ORDER BY embedding <=> '[...]'::vector LIMIT 5;

Because both support pgvector, either can store embeddings alongside your data for RAG — no separate Pinecone or Chroma needed. Point an OpenClaw agent at a similarity-search tool over that table and you get free long-term memory.

Which should you use?

Choose Supabase for a full-stack app with user accounts (Auth + RLS = secure multi-tenant with almost no backend code), a mobile app (excellent React Native/Flutter SDKs), a Firebase migration (deliberately Firebase-like API), file uploads, or realtime.

Choose Neon for a Next.js/Vercel app (Neon is Vercel's recommended DB), anything needing database branches (preview DBs, migration testing), a serverless/edge-heavy app, or a backend where you already have auth handled and just want clean Postgres.

Limitations to know

• Supabase: pauses after 1 week (1-2s cold start), only 2 active projects, shared compute (inconsistent performance), no custom domain on free.
• Neon: auto-suspend after 5 min (~300ms wake can fail sub-100ms health checks), only 0.5 GB of storage per project, a 5-minute suspend you cannot switch off on the free plan, and no built-in auth/APIs/storage to add yourself.

Other free Postgres worth knowing: Turso (SQLite/LibSQL edge, 5 GB and 100 databases free) if you can use SQLite; Render Postgres (free but expires after 30 days — testing only); Fly.io retired its free allowances, so its Postgres is pay-as-you-go now. Both free tiers here are usable for small production with careful pooling and query design, but not high-traffic production without upgrading.

FAQ

Is Supabase or Neon better for a Vercel/Next.js app?

Neon — it's Vercel's recommended database and Vercel Postgres runs on Neon, so integration is tight and the HTTP driver suits edge functions. Choose Supabase instead if you also want built-in auth, storage, and realtime.

What is Neon's branching and why does it matter?

A branch is an instant copy-on-write snapshot of your database. It lets each pull request get its own isolated DB, and lets you test migrations on real production data then discard the branch if anything breaks — production stays untouched. It's free-tier on Neon, paid-only on Supabase.

Do both support vector search for AI apps?

Yes — both support the pgvector extension, so you can store and search embeddings alongside regular data without a separate vector database. Supabase has more first-party pgvector documentation.

Can I use both together?

Yes — some projects use Neon for the main database (branching + Vercel) and Supabase Storage for files. The free tiers work simultaneously with different accounts, though most developers pick one to reduce complexity.

The verdict

Supabase is the better choice if this is your first database, you're building full-stack, or you want a complete backend-as-a-service — you can ship an app with user accounts in an afternoon, and it's the natural home for ex-Firebase developers. Neon is better if you already have auth, deploy to Vercel, or do serious database work: its branching is the best database-DX improvement in years. Start with Supabase for a Firebase replacement, or Neon for the best free Postgres for serious development.