Best Self Hosted Alternatives to Supabase

PocketBase is a compact open-source backend written in Go that provides an embedded SQLite database, realtime subscriptions, user authentication, file storage and a built-in admin dashboard. It can be used as a standalone single-file executable or as an embeddable Go library for custom apps. (github.com)

Key Features

• Embedded SQLite database with schema builder, validations and realtime change subscriptions (Server-Sent Events). (github.com)
• Authentication and authorization: email/password, token-based (JWT) auth, OAuth2 provider integrations and auth token refresh/management. (pocketbase.io)
• File storage with local or S3-compatible backends, file uploads attached to records and automatic thumbnail generation. (pocketbase.io)
• Built-in Admin dashboard UI for managing collections, records, files and users; extendable via Go hooks and an embedded JavaScript VM. (github.com)
• REST-style JSON APIs plus official SDKs (JavaScript, Dart) for quick client integration and realtime subscribe/unsubscribe helpers. (github.com)
• Small footprint single binary distribution with cross-platform prebuilt executables and example starter projects. (pocketbase.io)

Use Cases

• Prototyping and internal tools where a minimal backend (DB + auth + file storage + admin UI) is needed quickly.
• Client-driven web or mobile apps (SPAs, PWAs, React/Flutter apps) that need realtime updates and a simple REST API.
• Lightweight CMS-like applications, admin dashboards and hobby/side projects requiring a portable backend.

Limitations and Considerations

• Single-server architecture with an embedded SQLite store; no built-in sharding or multi-node clustering, so horizontal scaling is limited. (github.com)
• Realtime uses SSE (unidirectional) rather than WebSockets; reverse proxy configuration must support long-lived HTTP streams. (pocketbase.io)
• Project is under active development and the maintainers note potential breaking changes before a stable v1.0; review changelogs and migration notes for production upgrades. (github.com)
• Offline-first sync is not provided out-of-the-box; client-side handling is required for offline scenarios. (github.com)

PocketBase offers a pragmatic, compact backend for many web and mobile workflows where simplicity, portability and realtime updates matter. It is especially suited for prototypes, internal apps and small production services that accept the single-server SQLite tradeoffs.

Appwrite is an open-source Backend-as-a-Service (BaaS) platform for building web, mobile, and backend applications. It provides a unified backend with APIs and SDKs for common app needs like authentication, data storage, file management, serverless functions, and realtime events.

Key Features

• User authentication with multiple methods (email/password, OAuth, SMS, anonymous, magic links) and session management
• Database service for collections/documents with querying and access controls
• File storage with previews/transformations and security features such as malware scanning
• Serverless functions with event triggers and scheduled (cron) execution across multiple runtimes
• Realtime subscriptions to events across services
• Messaging across channels (e.g., email, push, SMS) under a unified service
• Web console for project administration and configuration

Use Cases

• Build a full-stack app backend quickly for web, mobile, and native clients
• Add authentication, realtime updates, and file uploads to SaaS products
• Implement event-driven workflows using functions triggered by database or storage events

Limitations and Considerations

• Runs as a set of containerized services; production deployments require planning for persistence, upgrades, and scaling
• Some advanced capabilities (for example, messaging providers and certain runtimes) may require additional external configuration

Appwrite fits teams that want a self-managed, API-first backend with a broad set of integrated services. It is especially useful for rapidly shipping applications while retaining control over infrastructure and data.

Directus is a flexible data platform that sits on top of an existing SQL database to provide an admin studio and real-time APIs. It can be used as a headless CMS, a backend for custom apps, or an internal data management interface without requiring database migrations.

Key Features

• Instantly generates REST and GraphQL APIs on top of supported SQL databases
• Admin Studio for managing content, data models, and relationships through a no-code UI
• Works with new or existing databases, keeping full control of the underlying schema
• Role-based access control with granular permissions for collections and fields
• Extensible platform with support for custom modules and interfaces
• Digital asset management for organizing and delivering uploaded files

Use Cases

• Headless CMS for websites and apps using an existing PostgreSQL/MySQL/SQLite database
• Internal admin panels for business data with fine-grained permissions
• Backend layer for custom products that need both REST and GraphQL APIs

Limitations and Considerations

• Licensed under Business Source License (BSL) 1.1 with an additional use grant, which may require a commercial license for some larger organizations

Directus is well-suited for teams that want to keep their SQL database as the source of truth while rapidly adding APIs and a modern admin UI. Its database-first approach and extensibility make it a strong fit for custom builds that outgrow traditional CMS patterns.

Hasura GraphQL Engine provides instant, realtime GraphQL and REST APIs over your data sources by introspecting schemas and exposing a composable, secure API surface. It supports multiple backends and connector SDKs for adding custom business logic, and includes an admin console and migration tooling for managing schema and metadata.

Key Features

• Instant GraphQL APIs generated from database schemas with support for queries, mutations, subscriptions (realtime).
• Fine-grained row- and column-level access control and permission rules.
• Database event triggers and webhooks for serverless workflows and asynchronous processing.
• Data Connectors architecture (V3) enabling Postgres, MongoDB, ClickHouse, MS SQL Server and other sources.
• Connector SDKs for writing custom business logic in TypeScript, Python, and Go.
• Admin console and migration tooling for schema management and metadata versioning.
• Remote schemas and schema stitching to merge custom GraphQL services into a single endpoint.
• Container-friendly deployment with Docker and orchestration support for cloud/Kubernetes environments.

Use Cases

• Rapidly expose an existing database as a secure, realtime GraphQL API for web and mobile apps.
• Build event-driven pipelines by triggering functions or webhooks on database changes.
• Compose data from multiple sources into a unified API for microservices and analytics.

Limitations and Considerations

• Full feature parity depends on the connected data source; some advanced features vary by connector and database capabilities.
• Operational behavior (performance, caching, realtime scalability) is influenced by the underlying datastore and deployment topology.

Hasura is designed to accelerate API development by automating schema-to-API creation and providing production-oriented features for access control, subscriptions, and eventing. It is commonly used to modernize data access, integrate heterogeneous data sources, and power realtime user experiences.

Budibase is an open-source low-code platform for building and deploying internal business applications and automating workflows. It connects to common databases and APIs or can be used to create apps from scratch, with built-in user management and secure deployment options.

Key Features

• Visual app builder for single-page internal apps (forms, admin panels, portals, approval flows)
• Data connectivity to popular databases and REST APIs
• Automation engine for workflow steps, integrations, and webhook-driven processes
• Pre-built UI components and templates for responsive apps
• Role-based access control and user/group management for app distribution
• Extensibility via JavaScript and plugins, plus a public API for interoperability
• Multiple deployment options including Docker and Kubernetes

Use Cases

• Building internal CRUD tools like ticketing, inventory, and operations dashboards
• Creating secure customer/supplier portals and approval workflows
• Automating routine IT and business processes across connected systems

Limitations and Considerations

• Feature set and enterprise controls can vary by edition and deployment; evaluate required auth, auditing, and governance needs upfront

Budibase is well-suited for teams that want to ship internal tools quickly while retaining flexibility through integrations and extensibility. It provides a practical path to reduce engineering time spent on routine business applications and workflow automation.

TrailBase is an open-source application server designed as a lightweight Firebase-style backend you can run as a single executable. It provides database-backed REST and realtime APIs, built-in authentication, an optional admin UI, and a WebAssembly runtime for extending server-side logic.

Key Features

• Single-binary deployment for consistent environments (dev, testing, edge, production)
• Type-safe RESTful CRUD APIs exposing tables and views
• Realtime subscriptions for push-based data change sync
• Built-in authentication with JWT access tokens and refresh tokens
• Optional built-in admin dashboard for configuration and data exploration
• Authorization via ACLs and SQL-based access rules
• Built-in WebAssembly runtime for extending functionality with guest languages

Use Cases

• Backend-as-a-service for mobile, web, and desktop applications
• Realtime data sync for collaborative or event-driven apps
• Lightweight deployments where SQLite and a single executable simplify operations

Limitations and Considerations

• SQLite-based architecture may not fit workloads requiring a separate scalable SQL cluster
• Extending behavior via WebAssembly requires building and managing WASM components

TrailBase is a good fit when you want a fast, low-ops backend that still provides core BaaS capabilities like auth, realtime updates, and API generation. Its single-binary approach and standards-oriented design help reduce operational complexity and vendor lock-in.

bknd is a lightweight backend platform that provides core primitives most applications need, including data management, authentication, media handling, and workflows. It is designed to run in many JavaScript runtimes and can be deployed standalone or embedded into popular web frameworks via adapters.

Key Features

• Modular, opt-in building blocks for data, auth, media, and workflow automation
• Integrated admin UI for managing schema, data, and backend configuration
• Instant REST API with OpenAPI support and a type-safe TypeScript SDK
• Adapter-first architecture for multiple runtimes and infrastructure providers
• Supports SQL backends including SQLite variants and PostgreSQL
• Storage adapters for S3/S3-compatible providers and filesystem-based storage

Use Cases

• Build MVPs and prototypes with a ready-to-use backend and admin panel
• Create API-first apps that need a portable, framework-agnostic backend
• Run SaaS backends with user management and multi-tenant data isolation patterns

Limitations and Considerations

• Requires Node.js 22.13+ for certain Node-based deployments
• Actively developed project; backward compatibility may change before 1.0

bknd is a practical choice when you want a compact backend that can be deployed across environments without committing to a single vendor. Its adapter-based approach makes it suitable for teams that want control over databases, storage, and runtime choices while keeping development simple.

MongooseIM is an open-source, Erlang-based XMPP server designed for enterprise-scale messaging. It supports multi-tenant deployments, REST and GraphQL Admin APIs, and WebSocket connectivity, along with push integrations for mobile devices.

Key Features

• Massive scalability with clustered nodes and dynamic multi-tenant domains
• Fully open-source XMPP server with no proprietary extensions and standards-based routing
• GraphQL Admin API for managing users, rosters and messages via HTTP or CLI
• REST API and WebSocket/BOSH-based client access for diverse app integrations
• MongoosePUSH for push notifications to iOS and Android
• MongooseICE integration for audio/video workflows
• Rich observability with metrics, instrumentation and compatibility with modern monitoring
• DevOps-friendly deployment with containerization, orchestration and load testing tooling

Use Cases

• Enterprise messaging backend powering mobile and web chat for thousands of users across multiple domains
• Multi-tenant chat platforms for SaaS providers requiring isolated, scalable environments
• Backend for customer-support and frontline worker apps needing reliable delivery and push capabilities

Conclusion

MongooseIM provides a scalable, standards-driven messaging platform designed for large deployments, with flexible management, multi-tenant support, and extensive integrations for modern apps.

Para is a modular, Java-based backend framework that provides object persistence, search indexing and distributed caching for web, mobile and IoT applications. It exposes a RESTful JSON API and is designed for multitenant deployments and rapid prototyping.

Key Features

• Multitenancy: each application has its own storage, search index and cache isolation.
• RESTful JSON API with signed requests and stateless client authentication using JSON Web Tokens (JWT).
• Database-agnostic persistence layer with adapters for various data stores and lightweight support for embedded databases.
• Full-text search support via Lucene or Elasticsearch with automatic indexing of objects.
• Distributed and local caching options (Hazelcast or other cache implementations) for low-latency access.
• Pluggable security: LDAP/SAML/social login support, CSRF protections and resource-level permissions.
• Validation and robustness via JSR-303 / Hibernate Validator and optimistic locking support in DAOs.
• Modular architecture with dependency injection and plugin support, executable JAR with embedded servlet container, and metrics/monitoring integration.

Use Cases

• Rapidly build backend APIs for mobile and single-page web applications with per-app multitenancy.
• Add full-text search and indexing to application data using Lucene or Elasticsearch.
• Provide a unified backend for IoT or game clients that need scalable caching and flexible auth.

Limitations and Considerations

• JVM-centric: primarily a Java/Maven codebase and requires a Java runtime to run and build.
• Relies on external components for some functionality: search (Elasticsearch/Lucene) and distributed cache (Hazelcast) need to be provisioned and configured for production scaling.
• Advanced integrations and hardening (e.g., enterprise SSO, specific DB backends) require additional setup and testing per deployment.

Para is targeted at teams that want a tested, extensible backend framework rather than a managed SaaS API. It is suitable for prototyping and production deployments where a JVM-first, modular backend with search and caching is desirable.

Expressa is a Node.js/Express middleware that creates data-driven REST collection APIs from JSON Schema and exposes a Django-like admin interface for creating collections and managing permissions. It is designed to be embedded into existing Express apps and supports per-collection storage backends (MongoDB, PostgreSQL, or JSON files). (github.com)

Key Features

• JSON Schema-driven collections: define collection schemas using standard JSON Schema and edit them via the admin UI. (github.com)
• Built-in admin interface: browser-based admin for creating collections, roles/permissions and managing data (admin UI rebuilt with Vue.js in a past release). (npmjs.com)
• Pluggable storage per collection: supports MongoDB and PostgreSQL drivers plus file-backed JSON storage for versionable data. (github.com)
• Standard REST endpoints generated for each collection: list, get by id, create, update (including mongo-style update), delete, plus schema endpoints. (github.com)
• Middleware-first design: installs as Express middleware so it can be mixed with other Express routes and middlewares; supports event listeners/hooks to modify/stop requests and responses. (github.com)

Use Cases

• Rapid CRUD backends: quickly add collection-based REST APIs and an admin UI for internal tools, prototypes, or admin dashboards. (github.com)
• Decoupled frontends: expose JSON-schema-backed endpoints so frontends can reuse schema for forms and validation. (github.com)
• Small CMS or content stores: manage content collections with per-collection storage and role/permission controls for editorial workflows. (github.com)

Limitations and Considerations

• Data types: only standard JSON types are supported natively; dates must be stored as strings (ISO 8601) and there is no built-in advanced date type handling. (github.com)
• Feature gaps noted in project roadmap: automatic GraphQL support, JWT token expiration handling, cookie-based auth, and file-upload features were listed as roadmap items (indicating they may be absent or limited). (npmjs.com)
• Small ecosystem and low npm usage: the project is community/open-source with modest download numbers and community size; consider maintenance and support requirements for production use. (npmjs.com)

Expressa is a pragmatic option when you need a schema-driven REST admin layer that plugs into an existing Express app. It emphasizes simplicity and extensibility (hooks/listeners) while relying on common Node.js stacks (Express, MongoDB, PostgreSQL); evaluate the listed limitations and project activity before picking it for critical production workloads. (github.com)