Supabase bundles a Postgres database, authentication, file storage, edge functions, and real-time subscriptions into one platform. That's a lot of functionality for $25/month, and for early-stage projects the speed is hard to beat. You get a working backend in minutes.

The tradeoffs show up later. Pricing jumps as your database grows and API calls increase. You can tune some Postgres parameters via CLI now, but VPC peering isn't available (PrivateLink exists on the $599/month Team plan, limited to database connections), and infrastructure-level control remains limited compared to running your own instances. Compliance requirements in healthcare or finance often demand infrastructure in accounts you own. And Supabase's client libraries and auth system create coupling that makes migration harder the longer you stay.

Most Supabase alternatives are other BaaS platforms with the same fundamental model: managed infrastructure you don't control, usage-based pricing you can't predict, and varying degrees of vendor lock-in. This guide covers options that actually change the tradeoff, from infrastructure you own to open-source self-hosting to different architectural models entirely.

Supabase Alternatives: An Overview

Feature	Encore	Firebase	Appwrite	Convex	PocketBase	Neon
Type	Backend development platform	BaaS (Google)	Open-source BaaS	Reactive backend	Self-hosted backend	Serverless Postgres
Database	Your own RDS / Cloud SQL	Firestore (NoSQL)	MariaDB	Custom document store	SQLite	Serverless Postgres
Deploy target	Your AWS/GCP account	Google Cloud	Self-hosted or Cloud	Convex Cloud or self-hosted	Any server	Neon Cloud
Infrastructure ownership	Full (your account)	None	Full (if self-hosted)	Full (if self-hosted)	Full (single server)	Partial (managed Postgres)
Auth	Built-in, or bring your own	Firebase Auth	Built-in	Clerk integration	Built-in	None (bring your own)
Storage	S3 / GCS (auto-provisioned)	Cloud Storage	Built-in	Built-in	Built-in	None
Real-time	Pub/Sub (SNS+SQS / GCP Pub/Sub)	Firestore listeners	Realtime API	Reactive by default	SSE	None
Edge functions	Fargate / Cloud Run	Cloud Functions	Appwrite Functions	Convex functions	None	None
Vendor lock-in	Low (Docker export, standard cloud)	High (Google ecosystem)	Low (self-hosted)	Moderate (custom runtime, open-source)	None	Low (standard Postgres)
Pricing model	Cloud provider rates + platform fee	Usage-based	Free (self-hosted) or usage-based	Usage-based	Free (self-hosted)	Usage-based

Encore

Encore takes a different approach from Supabase's generated, client-facing data APIs. Teams define an explicit backend with the open source Infra SDK for TypeScript and Go, and its APIs, services, and supported infrastructure become part of the application model.

Supabase Auth, Storage, Realtime, and Postgres can remain external services, so the two platforms can be used together rather than treated as an all-or-nothing choice.

For teams using AI-first development workflows, the application model gives agents the API contract and infrastructure context in one place. Type safety and static analysis serve as guardrails, reporting invalid declarations during the build.

Here's what a service with a database, file storage, and event publishing looks like:

import { api } from "encore.dev/api";
import { SQLDatabase } from "encore.dev/storage/sqldb";
import { Bucket } from "encore.dev/storage/objects";
import { Topic } from "encore.dev/pubsub";

// RDS on AWS, Cloud SQL on GCP, Docker Postgres locally.
const db = new SQLDatabase("documents", { migrations: "./migrations" });

// S3 on AWS, GCS on GCP, local storage during development.
const uploads = new Bucket("uploads", { versioned: true });

// SNS on AWS, Pub/Sub on GCP, in-memory locally.
const docEvents = new Topic<DocumentEvent>("doc-events", {
  deliveryGuarantee: "at-least-once",
});

export const uploadDocument = api(
  { method: "POST", path: "/documents", expose: true, auth: true },
  async (req: UploadRequest): Promise<Document> => {
    const doc = await db.queryRow`
      INSERT INTO documents (owner_id, name, size)
      VALUES (${req.ownerId}, ${req.name}, ${req.size})
      RETURNING *`;
    await uploads.upload(
      `${doc!.id}/${req.name}`, req.data, { contentType: req.contentType }
    );
    await docEvents.publish({ docId: doc!.id, action: "created" });
    return doc!;
  }
);

The infrastructure declarations are the only Encore-specific parts. Everything inside them is standard TypeScript with standard npm dependencies. The Encore surface is small, and the rest of your codebase works the same way it would in any Node.js project.

The declarations map the service to a Postgres database, object storage bucket, and Pub/Sub topic in each environment. Unlike Supabase's bundled services, authentication, realtime behavior, and the public API remain explicit application-level choices.

Why teams consider Encore

The backend is explicit. Instead of clients querying platform services directly under RLS and Storage policies, Encore clients call type-safe APIs where authentication, validation, authorization, and business logic live in backend code.

AI agents can reason about the whole application. The SDK declarations form an application model containing APIs, services, infrastructure, and their relationships. Static analysis catches invalid resource usage at build time, while generated schemas and traces give agents context for implementing and checking changes.

The application can run outside a BaaS runtime. Encore can deploy supported infrastructure into your AWS or GCP account, and the application can also be built as a standard Docker image. Supabase's generated APIs, Auth, Realtime, and policy model are separate capabilities, so teams still need to choose or implement the ones their application uses.

Key features

• Application model, MCP context, and build-time guardrails for AI agents
• Explicit, type-safe backend APIs with generated clients
• Infrastructure declarations for Postgres, object storage, Pub/Sub, cron, caching, and secrets
• Built-in tracing, logs, metrics, and architecture metadata
• Deployment to your AWS or GCP account, or standard Docker images for self-hosting

Good to know

Encore cannot manage a Supabase-hosted database as one of its own resources, but an Encore application can use it as an external Postgres database. Using Encore-managed Postgres instead requires transferring the application schema and data; Supabase-managed auth and storage schemas are separate concerns.

Running Encore alongside Supabase

Encore can be used alongside Supabase Auth, Storage, Realtime, and Postgres. This makes it possible to use Encore for selected APIs or background work while retaining the Supabase features that fit the application.

Go deeper

• Encore compared with Supabase
• Authentication in Encore
• Coming from Supabase, if you decide to adopt Encore
• Coming from a PaaS

Try Encore

Use the quick start guide to build locally, or book a 1:1 intro for a walkthrough.

---

Firebase

Firebase is Google's BaaS and the oldest player in this space. It predates Supabase by nearly a decade and offers a broader set of services: Firestore, Authentication, Cloud Storage, Cloud Functions, Hosting, Remote Config, A/B testing, and Crashlytics. If you're building a mobile app with Google services, Firebase is deeply integrated into that ecosystem.

The biggest difference from Supabase is the database. Firestore is a NoSQL document store, not Postgres. If your data model is relational, with joins, transactions across tables, and complex queries, moving to Firebase means restructuring how you store and access data. For document-oriented data or real-time syncing to mobile clients, Firestore is well-suited. For anything that looks like a relational schema, it's a step backward.

import { initializeApp } from "firebase/app";
import { getFirestore, collection, addDoc } from "firebase/firestore";

const app = initializeApp(config);
const db = getFirestore(app);
const docRef = await addDoc(collection(db, "documents"), {
  ownerId: userId,
  name: "report.pdf",
  createdAt: new Date(),
});

Key features

• Firestore with real-time sync and offline support
• Firebase Auth with 10+ built-in providers plus SAML/OIDC via Identity Platform
• Cloud Functions (Node.js, Python)
• Firebase Hosting with global CDN
• Crashlytics, Analytics, Remote Config
• Generous free tier (Spark plan)

Good to know

Firebase runs entirely on Google Cloud infrastructure you don't control. The vendor lock-in is higher than Supabase because Firestore's data model and query language are proprietary. Migrating away from Firebase means rewriting your data layer, not just changing a connection string. Pricing is usage-based across reads, writes, storage, and function invocations, which can produce surprising bills under load. Firebase solves the "I want more services than Supabase" problem well, but it doesn't change the ownership or lock-in tradeoffs.

---

Appwrite

Appwrite is an open-source BaaS that you can self-host on your own server or use as a managed cloud service. The feature set mirrors Supabase closely: database, auth, storage, functions, and real-time, with a similar client SDK pattern. The pitch is that you get Supabase-like functionality with the option to run it on infrastructure you own.

Appwrite uses MariaDB under the hood instead of Postgres. If you're coming from Supabase and your application depends on Postgres-specific features like pgvector, jsonb operators, or CTEs, you'll need to adjust your queries.

import { Client, Databases, ID } from "appwrite";

const client = new Client()
  .setEndpoint("https://your-appwrite.example.com/v1")
  .setProject("your-project-id");

const databases = new Databases(client);
const doc = await databases.createDocument(
  "main-db", "documents", ID.unique(),
  { ownerId: userId, name: "report.pdf" }
);

Key features

• Self-hosted on any Docker-compatible server
• Database, auth, storage, functions, and real-time
• 15+ SDKs across client and server (Web, Flutter, iOS, Android, Node, Python, Go, etc.)
• Role-based access control built in
• Managed cloud option (Appwrite Cloud)
• Active open-source community (55k+ GitHub stars)

Good to know

Self-hosting gives you infrastructure ownership, but you take on the operational work: updates, backups, monitoring, scaling, and security patching. Appwrite has had security vulnerabilities disclosed over the years, which is expected for actively maintained open-source software but highlights the surface area of running your own platform. If you don't want to self-host, Appwrite Cloud has the same shared-infrastructure tradeoffs as Supabase. Appwrite is the right choice if you want the BaaS development model and are willing to manage the hosting yourself.

---

Convex

Convex is a reactive backend platform that takes a different approach from both Supabase and traditional backends. Instead of SQL queries against a database, you write TypeScript functions that Convex runs on its own infrastructure. The database is a document store with automatic real-time subscriptions: when data changes, connected clients update immediately without you writing any sync logic.

The development model is closer to writing serverless functions than managing a database. You define queries, mutations, and actions as TypeScript files, and Convex handles execution, caching, and real-time delivery.

// convex/documents.ts
import { mutation, query } from "./_generated/server";
import { v } from "convex/values";

export const create = mutation({
  args: { name: v.string(), ownerId: v.string() },
  handler: async (ctx, args) => {
    return await ctx.db.insert("documents", {
      name: args.name,
      ownerId: args.ownerId,
      createdAt: Date.now(),
    });
  },
});

export const list = query({
  args: { ownerId: v.string() },
  handler: async (ctx, args) => {
    return await ctx.db
      .query("documents")
      .withIndex("by_owner", (q) => q.eq("ownerId", args.ownerId))
      .collect();
  },
});

Key features

• Automatic real-time updates on all queries
• TypeScript-first with end-to-end type safety
• ACID transactions
• Scheduled functions and cron jobs
• File storage
• Built-in full-text search

Good to know

Convex went open-source in 2024 and added self-hosting support in early 2025, so you can run it on your own infrastructure using Docker. The self-hosted option stores data in SQLite or Postgres, though the deployment and operational tooling is newer and less mature than the managed cloud. The database uses a custom document model and doesn't support SQL, so migrating away means rewriting your data access layer. If real-time reactivity is the core requirement and you're comfortable with a non-SQL data model, Convex delivers on that well. If you need Postgres compatibility or standard cloud services, it's the wrong direction from Supabase.

---

PocketBase

PocketBase is an open-source backend packaged as a single Go binary. You download it, run it, and get a SQLite database, authentication, file storage, and a real-time API. No Docker, no dependencies, no configuration files. For solo developers and small projects, the simplicity is unmatched.

PocketBase has grown to over 44,000 GitHub stars and earned a following among indie developers and hobbyists who want a self-contained backend they can deploy to a $5 VPS.

Key features

• Single binary, zero external dependencies
• SQLite database with a REST API
• Built-in auth with OAuth2 support
• File storage
• Real-time subscriptions via SSE
• Admin dashboard included

Good to know

PocketBase runs on a single server with SQLite. There's no horizontal scaling, no managed cloud option, and no support for Postgres. If your application needs multiple servers, high availability, or handles more data than SQLite can manage comfortably, PocketBase isn't the right tool. It's designed for projects that fit on one machine and stay there. For prototyping and personal projects it's excellent. For production workloads that outgrew Supabase, moving to another single-server architecture doesn't solve the underlying problem.

---

Neon

Neon is serverless Postgres. It's not a Supabase replacement in the sense that it doesn't offer auth, storage, or edge functions. What it does offer is a Postgres database with branching, scale-to-zero, and a generous free tier. If the main thing you use from Supabase is the database, and you're building your backend with a framework, Neon gives you a better Postgres experience without the rest of the BaaS bundle.

Database branching is Neon's standout feature. You can create instant copies of your database for each PR or test run, similar to how Git branches work for code. This is useful for preview environments and testing migrations against production data without risk.

// Standard Postgres connection — works with any framework
import postgres from "postgres";

const sql = postgres(process.env.DATABASE_URL);
const docs = await sql`
  SELECT * FROM documents WHERE owner_id = ${ownerId}
`;

Key features

• Serverless Postgres with scale-to-zero
• Database branching for previews and testing
• Point-in-time restore
• Postgres 17 with pgvector support (Postgres 18 in preview)
• Connection pooling built in
• Generous free tier (0.5 GB storage, 100 compute-hours/month with scale-to-zero)

Good to know

Neon solves one piece of the Supabase puzzle well. You still need to build or choose solutions for auth, file storage, background jobs, and deployment yourself. That's either liberating or exhausting depending on your team. Neon pairs naturally with backend frameworks: you get serverless Postgres from Neon and the rest of the backend stack from the framework. With Encore, you can use Neon as your database provider and still get infrastructure-from-code for everything else. For teams that want to keep Postgres but ditch the BaaS model, Neon is the starting point, and a framework fills in the rest.

---

How to choose

Teams leaving Supabase are usually trying to solve one of three problems: they want more infrastructure control, they want to reduce costs at scale, or they've hit the limits of the BaaS development model. The right alternative depends on which problem matters most.

Firebase and Appwrite Cloud are lateral moves. They offer a similar BaaS experience with different strengths: Firebase has more services and tighter mobile integration, Appwrite has a broader SDK ecosystem and an open-source option. If you like the BaaS model and your frustration with Supabase is about specific missing features rather than the model itself, these are worth evaluating, though the shared-infrastructure and lock-in tradeoffs that pushed you away from Supabase remain.

Appwrite self-hosted gives you infrastructure ownership, but you take on everything that Supabase handled: updates, backups, security patches, scaling, monitoring. For teams with the ops capacity to manage it, it's a legitimate path. For teams that left Supabase specifically to avoid operational complexity, it trades one set of problems for another.

Convex is the right choice if real-time reactivity is central to your application and you're comfortable trading Postgres and infrastructure control for a simpler real-time development model. It solves a different problem than Supabase, not the same problem differently.

PocketBase works well for solo projects and prototypes that fit on a single server. If your application outgrew Supabase, it likely needs more than SQLite on one machine can offer.

Neon gives you better Postgres without the BaaS bundle. If you're building a backend with a framework and just need a database, Neon's branching and scale-to-zero make it a strong choice for the database layer.

Across all of these: Firebase and Appwrite keep the BaaS model, Convex trades SQL for reactivity, and Neon handles the database but not the rest of your backend. Encore is the only option here that gives you a complete backend with infrastructure you own.

Encore is the most complete Supabase replacement for teams moving to production infrastructure. Your backend deploys to standard AWS or GCP services in your own account, with native billing, no shared failure domains, and no runtime dependency on Encore's servers. You write TypeScript, declare your infrastructure in code, and the platform handles provisioning, networking, and observability. If you've outgrown BaaS and want to own your infrastructure without hiring a DevOps team, Encore is the most direct path from Supabase to production-grade AWS or GCP.

Related resources

• How to Migrate from Supabase to AWS
• How to Migrate from Supabase to GCP
• Coming from Supabase
• What is Infrastructure from Code?
• Encore Quick Start