Convex vs Supabase vs PocketBase in SaaS Starters 2026

TL;DR

Supabase has the richest boilerplate ecosystem and the clearest path to production. Convex offers the best real-time reactivity and TypeScript DX, but you're betting on a newer platform. PocketBase is the go-to for self-hosted, zero-ops backends that ship as a single binary. The right choice depends on your hosting preferences, real-time requirements, and how much infrastructure you want to manage.

Key Takeaways

Supabase has 50+ community starters, official Next.js and SvelteKit templates, and Postgres under the hood
Convex bakes reactivity into the data model — queries auto-update when data changes without websocket boilerplate
PocketBase ships as a single 15MB binary — no Docker, no cloud account, no infra setup
Convex has the strongest TypeScript DX but the smallest starter ecosystem
Supabase has a generous free tier; PocketBase has zero hosting cost (self-hosted); Convex free tier is limited
All three support authentication, file storage, and REST-like querying

The Three Backend Paradigms

These are not just feature-equivalent alternatives. They represent genuinely different bets on what backend infrastructure should look like:

Paradigm	Convex	Supabase	PocketBase
Data model	Functions + reactive queries	Postgres + REST/GraphQL	SQLite + REST
Hosting	Convex cloud only	Cloud or self-hosted	Self-hosted only
Realtime	Built into queries	Postgres replication	SSE streams
TypeScript	First-class, schema-first	Good (typed client)	Generated types
Auth	Built-in	GoTrue (built-in)	Built-in
Files	Built-in storage	S3-compatible bucket	Filesystem
Pricing	$0 / $25+	$0 / $25+	Free forever
Lock-in	High	Medium	Low

Supabase — The Ecosystem Leader

Type: Open-source Backend-as-a-Service (Postgres) Stars: 70k+ | Pricing: Free → $25/month Pro

Supabase wraps PostgreSQL with a generous feature set: auth, storage, edge functions, realtime, and a rich REST API via PostgREST. The developer experience is excellent — the dashboard is polished, the docs are thorough, and the ecosystem is mature.

Supabase Starter Ecosystem

Official starters:

# Next.js App Router
npx create-next-app -e with-supabase

# SvelteKit
npx create-svelte . --template skeleton
# then follow Supabase SvelteKit guide

Community favorites:

Supastarter ($199) — multi-tenant, i18n, Nuxt/Next variants
Next SaaS Starter — free, opinionated Next.js + Supabase
Open SaaS — Wasp + Supabase variant
create-t3-turbo — T3 Stack with Supabase auth option
50+ additional community starters on GitHub

The Supabase Pattern

// lib/supabase.ts
import { createClient } from "@supabase/supabase-js";

export const supabase = createClient(
  process.env.NEXT_PUBLIC_SUPABASE_URL!,
  process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY!
);

// Realtime subscription
const channel = supabase
  .channel("messages")
  .on("postgres_changes", { event: "INSERT", schema: "public", table: "messages" }, (payload) => {
    setMessages((prev) => [...prev, payload.new]);
  })
  .subscribe();

Supabase Strengths

PostgreSQL under the hood — full SQL, JOINs, foreign keys, functions, triggers
Row-level security — auth-aware access control at the database level
Largest community — most boilerplate options, most answers on Stack Overflow
Self-hostable — Docker Compose stack you can run on any VPS

Supabase Limitations

Realtime requires polling setup — not as reactive as Convex
PostgREST limitations — complex queries sometimes need custom Postgres functions
Free tier is limited — 500MB database, projects pause after 1 week of inactivity

Convex — The Real-Time Reactivity Specialist

Type: Cloud backend platform Stars: 10k+ | Pricing: Free (development) → $25+/month

Convex rethinks the backend entirely. Instead of SQL tables and REST endpoints, you write functions that run on the Convex cloud. Queries are reactive — components subscribed to a query re-render automatically when the underlying data changes. No WebSocket setup, no polling, no cache invalidation.

Convex Starter Ecosystem

The Convex ecosystem is smaller but growing:

convex-saas (community, free) — Next.js App Router, Clerk auth, Stripe
template-nextjs-clerk-shadcn (official) — minimal starter
template-nextjs-lucia-shadcn (official) — lucia auth variant
ShadCN UI templates on the Convex docs

npm create convex@latest

The Convex Pattern

// convex/messages.ts — server function (not API route)
import { query, mutation } from "./_generated/server";
import { v } from "convex/values";

// Reactive query — auto-updates when data changes
export const list = query({
  args: { channel: v.id("channels") },
  handler: async (ctx, { channel }) => {
    return ctx.db
      .query("messages")
      .withIndex("by_channel", (q) => q.eq("channelId", channel))
      .order("desc")
      .take(50);
  },
});

// Mutation — transactional write
export const send = mutation({
  args: { channel: v.id("channels"), body: v.string() },
  handler: async (ctx, { channel, body }) => {
    const user = await ctx.auth.getUserIdentity();
    if (!user) throw new Error("Not authenticated");
    await ctx.db.insert("messages", { channelId: channel, body, author: user.email! });
  },
});

// React component — auto-reactive
function MessageList({ channelId }) {
  const messages = useQuery(api.messages.list, { channel: channelId });
  // messages updates automatically when new messages arrive — no polling!
  return messages?.map((m) => <Message key={m._id} message={m} />);
}

Convex Strengths

No cache invalidation — reactive queries keep UI in sync automatically
TypeScript-first — end-to-end type safety from DB schema to React component
Transactions — mutations are ACID transactional by default
Background jobs — cron jobs and scheduled tasks built-in
Simple mental model — no REST endpoints, no API routes, just functions

Convex Limitations

Vendor lock-in — Convex cloud only, no self-hosting
Not SQL — can't run arbitrary SQL, no JOINs, limited aggregations
Smaller ecosystem — fewer community starters vs Supabase
Pricing — free tier is development-only (database paused after 30 days inactive)

PocketBase — The Self-Hosted Single-Binary Backend

Type: Open-source backend (Go) Stars: 43k+ | Pricing: Free forever (self-hosted)

PocketBase ships as a single binary — download it, run it, you have a complete backend. No Docker, no npm, no cloud account, no infra setup. SQLite database with collections, auth, file storage, and a REST API. Extend it with JavaScript or Go hooks.

PocketBase Starter Ecosystem

PocketBase has a smaller but dedicated ecosystem:

# SvelteKit starter
npx degit pocketbase/js-sdk-examples/sveltekit-ssr

# Next.js + PocketBase
npx create-next-app -e https://github.com/danvansant/pocketbase-nextjs-template

# CLI quickstart
curl -fLo /tmp/pocketbase.zip https://github.com/pocketbase/pocketbase/releases/latest/download/pocketbase_linux_amd64.zip
unzip /tmp/pocketbase.zip -d ~/pocketbase
~/pocketbase/pocketbase serve

Community starters:

pocketbase-ts (typed SDK wrapper)
next-pocketbase (Next.js + PocketBase + Tailwind)
Various SvelteKit community templates

The PocketBase Pattern

// lib/pocketbase.ts
import PocketBase from "pocketbase";

export const pb = new PocketBase("http://127.0.0.1:8090");

// Authentication
async function login(email: string, password: string) {
  const authData = await pb.collection("users").authWithPassword(email, password);
  return authData;
}

// CRUD — typed with generated types
const posts = await pb.collection("posts").getList<Post>(1, 50, {
  filter: `author = "${currentUser.id}"`,
  sort: "-created",
  expand: "author",
});

// Realtime — SSE-based
pb.collection("messages").subscribe("*", (e) => {
  if (e.action === "create") {
    setMessages((prev) => [e.record, ...prev]);
  }
});

Self-hosting PocketBase on a $5/month VPS:

# Linux VPS setup
wget https://github.com/pocketbase/pocketbase/releases/latest/download/pocketbase_linux_amd64.zip
unzip pocketbase_linux_amd64.zip
./pocketbase serve --http="0.0.0.0:8090"

Total infrastructure cost: $5/month for a VPS. No database server, no separate auth service, no cloud storage fees.

PocketBase Strengths

Zero infrastructure cost — one binary, one process, one port
SQLite is fast — WAL mode handles thousands of writes/second
Extending with hooks — JavaScript or Go middleware for custom logic
Admin UI included — collection management, user admin at /_/
No vendor lock-in — move data anywhere, backup is a single file

PocketBase Limitations

SQLite limits — not ideal for high-write, distributed scenarios
Not horizontally scalable — single-process architecture
Smaller ecosystem — fewer premium starters, less community content
Go knowledge needed — for advanced custom hooks

Choosing for Your SaaS

Decision Framework

Choose Supabase if:

You want the most boilerplate options and community support
Your team knows SQL and wants to leverage PostgreSQL features
You might need to self-host later (Supabase Docker is mature)
You're building a data-heavy app with complex queries

Choose Convex if:

Your app is realtime-first (collaborative tools, live dashboards, chat)
You want maximum TypeScript DX and automatic cache invalidation
You're comfortable with vendor lock-in and cloud-only hosting
Your team prefers a functional/reactive programming model

Choose PocketBase if:

You're a solo founder and infrastructure cost is a concern
Self-hosting is required (compliance, data residency, client preference)
You're building an internal tool or smaller-scale SaaS
You want to own your entire stack without cloud dependencies

By Use Case

Use Case	Best Choice	Why
B2B SaaS MVP	Supabase	Fastest ecosystem, row-level security, generous free tier
Realtime collaboration	Convex	Reactive queries eliminate WebSocket complexity
Internal tool	PocketBase	Zero cost, fast setup, SQLite handles the load
AI SaaS with pgvector	Supabase	Native vector search in PostgreSQL
GDPR / EU data residency	PocketBase	Self-hosted, full control
Solo founder, bootstrap	PocketBase	$5/month total infra cost
Enterprise multi-tenant	Supabase	Schema isolation, RBAC, mature compliance story

Real Starter Stacks

Supabase Stack (Next.js)

Next.js 15 (App Router)
Supabase (Auth + Postgres + Storage)
Drizzle ORM or Supabase client
Stripe billing
Resend email
shadcn/ui
Tailwind CSS
Vercel deployment

Convex Stack

Next.js 15 (App Router)
Convex (backend + realtime)
Clerk (auth)
Stripe billing
Resend email
shadcn/ui
Tailwind CSS
Vercel deployment

PocketBase Stack

SvelteKit or Next.js
PocketBase (backend, self-hosted)
PocketBase auth (built-in)
Stripe billing (webhooks to PocketBase hooks)
Resend or SMTP email
Tailwind CSS
Hetzner VPS ($5-10/month)

Methodology

Analyzed starter ecosystems for all three platforms (GitHub, docs, community)
Reviewed pricing pages and free tier limitations as of March 2026
Tested code patterns from official quickstarts
Cross-referenced with developer community discussion (Reddit r/SaaS, Dev.to, Hacker News)
Reviewed migration stories and team adoption patterns

Migrating Between Backends: What It Actually Costs

The backend choice is more reversible than it initially appears, but the migration costs are real enough that it's worth choosing carefully upfront.

Moving from Supabase to another PostgreSQL provider (Neon, Railway, AWS RDS) is the least painful migration in this comparison. Your data is standard PostgreSQL — export a pg_dump, import to the new provider, update your connection string. The complication is Supabase-specific features: if you're using Supabase Auth, Row Level Security, Supabase Edge Functions, or Supabase Storage, those need replacement when you migrate. Applications that use only Supabase as a database and use separate auth (Clerk, NextAuth) can migrate providers in a day.

Moving from Convex to a standard database is a more significant migration. Convex's data model (document-based, no SQL, reactive queries) doesn't map directly to relational tables. You'll need to design a PostgreSQL schema, write a data export from Convex's API (they provide export utilities), and rewrite your data access layer from Convex functions to SQL queries or an ORM. For a product with a complex Convex schema, budget a week or more. The Convex-specific reactive query patterns also need to be replaced with explicit data fetching or a library like TanStack Query.

Migrating from PocketBase means exporting SQLite data and transforming it to your new database schema. PocketBase's schema is stored in its own format — you'll need to write migration scripts to extract data into standard SQL. The migration complexity depends heavily on how custom your PocketBase schema is and whether you've used PocketBase-specific hooks that have no direct equivalent in your new stack.

The Startup vs Scale Decision Point

None of these three backends has meaningful scaling limitations for typical SaaS products. Supabase handles millions of users on standard plans. Convex scales automatically. PocketBase on SQLite can handle thousands of concurrent users on a $20/month VPS with proper tuning.

The decision point is not "which scales best" — it's "which operational model do I want to commit to as we grow?"

Supabase's operational model is managed cloud with self-host as a fallback option. Growth means paying more to Supabase (or migrating to self-hosted) while staying on the same PostgreSQL foundation. The path is clear and predictable.

Convex's operational model is cloud-only with Convex as the sole provider. There's no self-host option; if Convex's pricing changes or the service has downtime, you have no alternative. This is the highest vendor lock-in of the three options and should be a deliberate choice, not a default.

PocketBase's operational model is self-hosted by definition. Growth means upgrading the VPS, eventually moving to a multi-read-replica setup (which requires PocketBase's clustering support, still in early development), and managing the operational overhead yourself. For teams with DevOps capability and a preference for infrastructure control, this is fine. For teams that want infrastructure to be someone else's problem, PocketBase's self-hosted model is a liability at scale.

Compare all Supabase, Convex, and PocketBase starters on StarterPick — filter by backend, pricing, and features.

See our MongoDB vs PostgreSQL guide for the database layer decision within the PostgreSQL ecosystem.

Browse best SaaS boilerplates for 2026 for the top-ranked starters across all backend infrastructure choices.

Read the Drizzle vs Prisma for serverless SaaS guide for ORM comparisons relevant to Supabase-backed projects.

For the frontend side of the stack decision — which component libraries and UI patterns pair best with each backend — see the best Next.js boilerplates guide.

Local Development Experience

The day-to-day development experience differs meaningfully between the three platforms, and it is worth understanding before committing.

Supabase's local development uses the Supabase CLI, which spins up a full Supabase stack (PostgreSQL, PostgREST, GoTrue, Storage) via Docker. This requires Docker Desktop and adds startup time to your development environment, but it means your local environment is a faithful replica of production. Database migrations are managed with Supabase's migration files, and the Supabase Studio UI is available locally for inspecting data and writing queries. The local + cloud sync workflow is well-documented and reliable.

Convex's local development is simpler: npx convex dev starts a watcher that syncs your Convex function files to Convex's cloud development environment in real time. There is no local Convex runtime — your development environment always hits Convex's cloud, which requires an internet connection. This is a tradeoff most developers accept, but it means development without internet access is not possible, and the feedback loop for function changes depends on Convex's sync speed rather than local execution.

PocketBase's local development is the simplest of the three: download the binary, run it, and you have a complete backend on localhost in seconds. No Docker, no cloud account, no internet required. The tradeoff is that local and production are more likely to diverge if you are not careful about running the same PocketBase version in both environments. Schema migrations in PocketBase are managed through the Admin UI or migration files, which requires more discipline than Supabase's declarative migration system.

For most development team setups, Supabase's local stack is the most production-faithful and the most compatible with standard CI/CD pipelines. The Docker requirement is the most common friction point, but most teams have Docker in their workflow already. PocketBase's zero-dependency development is genuinely impressive for solo developers or teams that want to minimize infrastructure tooling.

The SaaS Boilerplate Matrix (Free PDF)