Firebase

Best Self Hosted Alternatives to Firebase

A curated collection of the 5 best self hosted alternatives to Firebase.

Firebase is Google’s mobile and web app development platform offering backend-as-a-service features—real-time and Cloud Firestore databases, authentication, hosting, Cloud Functions, storage, analytics, crash reporting, and messaging—to speed app development and operations.

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
#5
AnyCable

AnyCable

AnyCable is a scalable WebSocket server for Ruby on Rails Action Cable, offering a Go server with RPC to Rails and support for Redis and other brokers.

AnyCable screenshot

AnyCable is a WebSocket server built for Ruby on Rails applications using Action Cable. It replaces the default Rails Action Cable server with a high-performance Go implementation while keeping the Rails channel code and APIs, enabling easier scaling and better concurrency.

Key Features:

  • Drop-in replacement for Rails Action Cable server (keeps existing channel code)
  • Go-based WebSocket server designed for high concurrency and lower memory usage
  • RPC bridge between the WebSocket server and Rails application for channel callbacks
  • Supports different broadcast adapters/brokers (commonly Redis; also supports other pub/sub backends via adapters)
  • JWT-based authentication support and flexible connection identifiers (via Rails integration)
  • Observability hooks/metrics and structured logging options (implementation-dependent)

Use Cases:

  • Scaling Rails real-time features (chat, notifications, live updates) beyond a single Action Cable process
  • Reducing memory/CPU footprint of WebSocket handling in production Rails deployments
  • Running real-time WebSocket infrastructure as a separate service while keeping Rails channel logic

Limitations and Considerations:

  • Requires deploying and operating an additional WebSocket server component alongside the Rails app
  • Full feature parity depends on the chosen broker/adapter and configuration (e.g., advanced setups beyond Redis)

AnyCable is a pragmatic choice for teams invested in Rails Action Cable who need better performance and horizontal scalability without rewriting real-time application code. It separates WebSocket handling from Rails while preserving the familiar Action Cable programming model.

2.2kstars
110forks
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