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

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

Comments