Fauna

Best Self Hosted Alternatives to Fauna

A curated collection of the 4 best self hosted alternatives to Fauna.

Fauna is a serverless, globally distributed transactional database-as-a-service offering ACID transactions, GraphQL and FQL querying, and built-in data modeling and authorization for modern web and mobile applications.

Alternatives List

#1
Supabase

Supabase

Self-hostable backend platform combining Postgres, Auth, Storage, realtime APIs, edge functions, and an admin dashboard to build and scale apps quickly.

Supabase screenshot

Supabase is a self-hostable backend platform that provides a Postgres database plus common application backend services such as authentication, file storage, realtime updates, and serverless functions. It exposes auto-generated APIs and tools so teams can build production apps with a single, SQL-first backend.

Key Features

  • Postgres database with extensions and SQL-first development
  • Auto-generated REST API via PostgREST and GraphQL via pg_graphql (where enabled)
  • Realtime subscriptions for database changes (Postgres logical replication)
  • Authentication and user management (GoTrue), including JWT-based auth and social/OAuth providers
  • Object storage service with access control and signed URLs (S3-style semantics)
  • Edge Functions for server-side logic (Deno-based)
  • Web dashboard for database/admin tasks, logs, and configuration
  • Local development tooling and Docker-based self-hosting stack

Use Cases

  • Build mobile/web apps needing auth, database, and file uploads without a custom backend
  • Add realtime collaboration features (presence, live updates) backed by Postgres
  • Host internal tools/backends with SQL, row-level security, and API generation

Limitations and Considerations

  • Full feature parity with the hosted Supabase platform may require operating multiple services (database, auth, storage, realtime, functions) and configuring integrations yourself.

Supabase is suited for teams who want a single Postgres-centered backend with batteries included, while retaining the ability to run the whole stack on their own infrastructure. It is especially useful when you want strong relational data modeling and SQL/RLS while still getting Firebase-like developer experience.

95.9kstars
11.2kforks
View Details
#2
PocketBase

PocketBase

Single-file backend with built-in database, auth, admin UI, files, and real-time APIs for web and mobile apps.

PocketBase screenshot

PocketBase is a lightweight backend-as-a-service you run as a single executable. It provides a built-in SQLite database, an admin dashboard, authentication, file storage, and a generated API so you can ship web/mobile apps without standing up a full backend stack.

Key Features

  • Embedded SQLite database with collections (schema), migrations, and query filters
  • Admin UI to manage collections, records, users, and access rules
  • Auth system for email/password plus OAuth2 providers, with user management and sessions
  • REST-style API for CRUD and auth flows, plus real-time subscriptions for record changes
  • File uploads/attachments stored locally with access rules and signed/file-serving endpoints
  • Access control rules per collection/record (rule-based API permissions)
  • Extendable backend via Go: hooks/events, custom routes, and plugins
  • Single binary deployment; can be run via Docker and supports basic configuration via env/flags

Use Cases

  • Backend for a single-page app or mobile app needing auth + CRUD + files
  • Rapid prototyping of internal tools with an admin panel and API out of the box
  • Replacing managed BaaS for small/medium projects that prefer SQLite-backed simplicity

Limitations and Considerations

  • Primary datastore is SQLite (excellent for many workloads, but not a drop-in for horizontally scaled SQL clusters)
  • Server-side extensibility is Go-centric; advanced customization typically requires writing Go code

PocketBase is a strong fit when you want a minimal operational footprint while still getting a full backend stack (data, auth, files, admin UI, and real-time APIs). It’s especially useful for prototypes and production apps that fit well within an embedded-database deployment model.

55kstars
3kforks
View Details
#3
Appwrite

Appwrite

Self-hosted backend-as-a-service with auth, databases, storage, functions, and realtime APIs for web and mobile apps.

Appwrite screenshot

Appwrite is an open-source Backend-as-a-Service (BaaS) that provides a complete backend layer for web, mobile, and Flutter applications. It offers a unified API and SDKs for common backend needs such as authentication, databases, file storage, serverless functions, and realtime events.

Key Features

  • Authentication with multiple providers (email/password, OAuth2 providers) and session management
  • Databases with document collections, indexes, querying, and granular permissions/roles
  • File Storage with buckets, upload/download APIs, and access control
  • Serverless Functions to run backend logic on events or via HTTP execution
  • Realtime subscriptions for database and other events
  • Teams, roles, and permissions model for multi-user and multi-tenant apps
  • Webhooks and event system to integrate with external services
  • SDKs for multiple platforms (web/Node.js, Flutter, and others) and REST API
  • Console (web UI) for project administration and monitoring of resources

Use Cases

  • Build Firebase-like backends for mobile and web apps with local control
  • Add authentication, file uploads, and data APIs to internal tools quickly
  • Implement event-driven workflows (e.g., image processing on upload) with functions and webhooks

Limitations and Considerations

  • Functions runtime and scaling characteristics depend on deployment configuration and container resources
  • Feature parity with managed BaaS platforms can vary (some advanced managed integrations may require extra setup)

Appwrite is well-suited for teams that want an integrated backend platform with strong developer ergonomics and broad SDK support. Its modular services (Auth/DB/Storage/Functions/Realtime) make it practical for both MVPs and production applications where consistent APIs and permissions are required.

54.3kstars
4.9kforks
View Details
#4
Kinto

Kinto

Self-hosted JSON storage server with REST APIs, versioning, auth, and sync primitives used by Mozilla for offline-first and synchronization use cases.

Kinto screenshot

Kinto is a self-hosted, generic JSON storage service that exposes a REST API for storing and querying records, designed to support synchronization and offline-first workflows. It provides server-side features like versioning, access control, and validation so apps can reliably store structured data and sync changes across clients.

Key Features

  • RESTful JSON storage with collections/records, filtering, sorting, pagination, and field selection
  • Concurrency control via ETag and conflict detection for safe multi-client updates
  • Change tracking and incremental sync primitives (timestamps/last-modified)
  • Built-in authentication and authorization (pluggable), including per-bucket/collection/record permissions
  • Schema validation and payload size controls to enforce data contracts
  • Pluggable storage backends and caches (commonly PostgreSQL and Redis)
  • Event and webhook support via plugins for integrating with external systems

Use Cases

  • Building offline-first apps that need a sync-capable JSON backend
  • Central configuration/feature data distribution to many clients
  • Lightweight backend for structured app data without designing custom endpoints

Limitations and Considerations

  • Not a full BaaS: focused on JSON records/sync patterns (not file storage or realtime pub/sub)
  • Functionality often depends on selecting and configuring the right plugins (auth, webhooks, etc.)

Kinto is a good fit when you need a robust, sync-friendly JSON store with strong API semantics, versioning, and fine-grained permissions. It is commonly used as a dependable building block for data distribution and client synchronization scenarios.

4.4kstars
420forks
View Details

Why choose an open source alternative?

  • •Data ownership: Keep your data on your own servers
  • •No vendor lock-in: Freedom to switch or modify at any time
  • •Cost savings: Reduce or eliminate subscription fees
  • •Transparency: Audit the code and know exactly what's running