If you have been looking for an open-source alternative to Firebase, two names keep coming up: Supabase and Appwrite. Both give you a database, authentication, file storage, serverless functions, and realtime capabilities out of the box. Both are open-source. Both let you self-host.

So which one should you pick? The answer depends on how much you value raw SQL power versus a streamlined self-hosting experience. This guide breaks down every major difference so you can decide with confidence.

Feature Comparison

Feature	Supabase	Appwrite
Database engine	PostgreSQL	MariaDB
Query language	SQL (joins, CTEs, extensions)	REST / GraphQL API
Auth providers	20+ (OAuth, magic link, phone)	30+ (OAuth, magic link, phone)
Row-level security	Native PostgreSQL RLS	Document-level permissions
File storage	S3-compatible object storage	Built-in storage with buckets
Realtime	PostgreSQL CDC (change data capture)	WebSocket channels
Edge functions	Deno-based	Node.js / Bun runtime
Self-hosting	Docker Compose (multiple services)	Single Docker command
Managed cloud	Yes (free tier available)	Yes (free tier available)
Dashboard	SQL editor + table view	GUI-first console
CLI	Yes	Yes
Open-source license	Apache 2.0	BSD 3-Clause

Both platforms cover the essentials. The differences show up when you dig into the details.

Database: PostgreSQL vs MariaDB

This is the single biggest difference between the two.

Supabase runs on PostgreSQL, which means you get full SQL support — joins, subqueries, common table expressions, window functions, and a massive ecosystem of extensions like PostGIS for geospatial data and pg_vector for embeddings. If you already know SQL, Supabase feels natural. You write queries directly against your database, and you can use any PostgreSQL client or ORM to connect.

Check out our PostgreSQL cheat sheet if you need a quick reference.

Appwrite uses MariaDB under the hood, but you never interact with it directly. Instead, you work through a REST API or GraphQL endpoint to create documents in collections. This is closer to how Firestore works — you define attributes on collections and query them through the SDK. There are no joins. If you need related data, you handle it at the application level or denormalize your schema.

For projects that need complex queries, reporting, or analytics, Supabase has a clear advantage. For simpler CRUD apps where you prefer an API-first approach, Appwrite’s model can be faster to get started with.

If you are comparing Supabase to other PostgreSQL-based platforms, see our Neon vs Supabase breakdown.

Self-Hosting

Appwrite wins on self-hosting simplicity. You can spin up the entire platform with a single Docker command:

docker run -it --rm appwrite/appwrite

That gives you the database, auth, storage, functions runtime, and dashboard in one container. The experience is polished and well-documented.

Supabase self-hosting is possible but more involved. The platform is made up of several services — the PostgreSQL database, GoTrue for auth, the storage API, the realtime server, PostgREST, and the Studio dashboard. You orchestrate all of them with Docker Compose. It works, but it requires more configuration and maintenance than Appwrite’s single-container approach.

If self-hosting is a hard requirement and you want the smoothest path, Appwrite is the better choice. If you are fine with a managed cloud service, Supabase’s hosted platform handles all of that complexity for you.

Auth and Storage

Both platforms offer built-in authentication with support for email/password, magic links, phone OTP, and dozens of OAuth providers like Google, GitHub, and Apple.

Supabase ties auth directly to PostgreSQL through row-level security (RLS). You write security policies as SQL expressions, and the database enforces them on every query. This is powerful but has a learning curve if you are new to RLS.

Appwrite uses a document-level permission model. You assign read and write permissions to users, teams, or roles on each document or file. It is more intuitive for developers coming from Firebase or similar platforms.

For file storage, Supabase provides S3-compatible object storage with policies that mirror its RLS approach. Appwrite has its own built-in storage system with bucket-level and file-level permissions. Both support image transformations and CDN delivery on their managed platforms.

Edge Functions

Supabase edge functions run on Deno. You write TypeScript, deploy with the Supabase CLI, and they execute at the edge on the managed platform. They integrate tightly with the rest of the Supabase stack — you can call the database, auth, and storage from within a function using the standard client library.

Appwrite functions support multiple runtimes including Node.js, Python, PHP, Ruby, Dart, and more. They run as containers, which gives you flexibility in language choice. On the managed platform, they execute in Appwrite’s cloud infrastructure. The tradeoff is that cold starts can be slower compared to Deno-based edge functions.

If you are a TypeScript-first team, Supabase functions feel more natural. If you need to write backend logic in Python or another language, Appwrite gives you more options.

When to Use Supabase

• You want the full power of PostgreSQL — SQL joins, extensions, and RLS
• You are building a data-heavy application with complex queries
• You prefer writing SQL over interacting with a REST API
• You want a mature managed cloud platform with a generous free tier
• You are already in the PostgreSQL ecosystem

For a deeper look at how Supabase stacks up against Google’s offering, read Supabase vs Firebase.

When to Use Appwrite

• Self-hosting simplicity is a top priority
• You prefer an API-first approach over raw SQL
• You want multi-runtime support for serverless functions
• You need a straightforward permission model without learning RLS
• You are building a mobile or web app with standard CRUD patterns

Verdict

Supabase and Appwrite solve the same problem from different angles.

Supabase bets on PostgreSQL as the foundation, giving you unmatched SQL capabilities, a rich extension ecosystem, and tight integration between auth, storage, and the database through row-level security.

Appwrite bets on developer experience and portability, offering a cleaner self-hosting story and a simpler API-driven model.

Pick Supabase if your project benefits from relational data, complex queries, or the PostgreSQL ecosystem. Pick Appwrite if you want to self-host with minimal friction or prefer working through APIs instead of SQL.

Both are solid open-source platforms that continue to ship features quickly. You will not go wrong with either — the right choice depends on your team’s preferences and your project’s data model.

FAQ

Is Supabase better than Appwrite?

Supabase is better if you need the full power of PostgreSQL with SQL joins, extensions, and row-level security. Appwrite is better if you prioritize easy self-hosting and prefer an API-first approach over writing raw SQL.

Can I self-host both?

Yes, both Supabase and Appwrite are fully open source and support self-hosting. Appwrite is simpler to self-host with a single Docker command, while Supabase requires orchestrating multiple services via Docker Compose.

Which has better auth?

Both offer robust authentication with 20+ OAuth providers, magic links, and phone OTP. Supabase ties auth to PostgreSQL row-level security for database-enforced access control, while Appwrite uses a more intuitive document-level permission model.

Is Appwrite free?

Appwrite is free and open source — you can self-host it at no cost. The managed Appwrite Cloud also offers a free tier with generous limits for small projects and prototyping.