On this page
| Projects | 100 |
| Storage | 1 GB per project |
| Compute | 100 CU-hours/month per project |
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
| Feature | Supabase (Free) | Neon (Free) |
|---|---|---|
| Database | PostgreSQL (version varies by project) | PostgreSQL (version varies by project) |
| Storage | 500 MB database | 1 GB database per project (up to 100 projects) |
| Compute | Shared; project may pause after 1 week of low activity | 100 CU-hours/month per project; scales to zero after 5 idle minutes |
| Projects | 2 active projects | Up to 100 projects |
| Branching | No | Yes — 10 branches |
| Built-in Auth | Yes — email, OAuth, magic links | Managed Better Auth, up to 60K MAU |
| Auto REST API | Yes (from your schema) | Data API available |
| Functions | Edge Functions | Node.js Functions, 1M invocations/month |
| File storage | 1 GB | 5 GB object storage |
| Realtime | Yes | Live SQL (beta) |
| pgvector | Yes | Yes |
| Region | Chosen at project creation | Chosen at project creation |
| Sleeps / expires? | Pauses after ~1 week idle; no expiry | Auto-suspends after 5 min; no expiry |
| Commercial use | Allowed on free tier | Allowed on free tier |
| Credit card | Not stated on pricing page | No, per pricing page |
| Best for | Full-stack apps with auth + storage | Dev branches, AI/serverless workloads |
Supabase: the full backend-as-a-service
Supabase is an open-source Firebase alternative built on PostgreSQL. One project gives you the database plus an auto-generated REST API, Auth, file storage, Realtime, and Edge Functions. Its Free pricing page lists 500 MB database, 1 GB file storage, 50,000 monthly active auth users, 5 GB egress, and 2 active projects. Free projects with low activity may be paused after a 7-day period and need to be restored by the owner.
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 Postgres storage from compute, and compute scales to zero when idle. Its current Free plan allows 100 projects, each with 100 CU-hours/month and 1 GB of database storage, with compute sizes up to 2 CU (8 GB RAM), without a credit card. An October 2026 update raised the database storage limit from 0.5 GB to 1 GB per project. Neon now also offers Managed Better Auth, object storage, Functions, and a Data API; compare the individual service limits if you need those features.
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 has a mature integrated Auth and auto-generated REST API with RLS. Neon now includes Managed Better Auth and a Data API, so compare their SDKs and access controls against your app's requirements.
- Serverless connections. Supabase uses standard PgBouncer; Neon's HTTP driver is more convenient in edge runtimes.
- Vector search. Both support
pgvectorequally; Supabase has better first-party docs. - Inactivity. Neon compute scales to zero after five idle minutes and wakes on demand. A Supabase Free project with low activity over a week may pause until its owner restores it. Test each behavior for an intermittent app.
-- 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 database branches (preview DBs and migration testing), serverless Postgres, or a project that benefits from its integrated Auth, storage, and Functions. Check feature availability in your region before planning around newer backend features.
Limitations to know
- Supabase: only 2 active Free projects; a low-activity project may pause after a week and require owner restoration. The Free plan uses shared compute.
- Neon: compute scales to zero after five idle minutes, and Free database storage is capped at 1 GB per project. Newer backend services have separate quotas and may require an integration review.
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's HTTP driver and database branching work well with serverless apps. Supabase has a long-established integrated Auth, Storage, and Realtime stack; Neon now also includes Auth, Storage, Functions, and Realtime in beta. Compare the current quotas and SDK support for your app.
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 remains a good starting point for a full-stack app that needs its integrated API, Auth, Storage, and Realtime. Neon is strong for serverless Postgres and branching, and its newer backend features now cover Auth, Storage, and Functions as well. Check the Supabase and Neon pricing pages for the limits that matter to your workload.