Best Self Hosted Alternatives to Convex

Supabase is an open source Postgres development platform for building web, mobile, and AI applications. It combines PostgreSQL with a set of services for authentication, instant APIs, realtime updates, serverless functions, and file storage.

Key Features

• Dedicated PostgreSQL database with SQL, roles, and Row Level Security
• Auto-generated REST APIs from your database schema
• Optional GraphQL API via a PostgreSQL extension
• Authentication and authorization with JWT-based sessions and OAuth2 support
• Realtime subscriptions over WebSockets driven by PostgreSQL changes
• File storage service with access control policies backed by Postgres
• Edge/serverless functions for custom backend logic
• Vector/embeddings support using Postgres extensions (for semantic search and RAG patterns)
• Web-based dashboard for managing projects, data, and configuration

Use Cases

• Replace or self-host a Firebase-like backend for apps with Postgres
• Build internal tools and SaaS backends with auth, APIs, and storage
• Create AI-enabled applications using Postgres vector search and embeddings

Limitations and Considerations

• Some functionality relies on multiple cooperating components (database, realtime, auth, storage, gateway), which increases operational complexity compared to a single service
• Feature set and behavior can vary depending on the chosen self-hosting setup and enabled extensions

Supabase provides a cohesive backend stack around PostgreSQL while keeping data ownership and portability. It is well-suited for teams that want a modern developer experience with SQL and strong database-native security controls.

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.

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.