Convex puts backend operations in TypeScript and keeps subscribed clients updated as data changes. As applications built on Convex grow, teams may need SQL for reporting or backend services with different runtime and scaling requirements. Those needs can lead them toward their own AWS or GCP account, where they want more infrastructure control without making development and testing harder.

Reasons to consider Convex alternatives:

• Relational queries, reporting, and existing Postgres tools need SQL access rather than Convex-specific document queries.
• Workers or compute-heavy operations need to run beyond the platform's execution or concurrency limits.
• Services need separate deployment and scaling settings under the platform team's control.
• The backend needs to run in your own AWS or GCP account, with access to private services and existing networking and IAM.
• More subscriptions, function executions, and database traffic make usage costs harder to plan.
• Moving away means adapting the document model, functions, and reactive client subscriptions, even when much of the business logic is TypeScript.

Convex alternatives at a glance

Encore: backend code with infrastructure under your control

Encore combines the simplicity of a managed backend platform with infrastructure in your own AWS or GCP account, defined through type-safe primitives in application code. Developers and agents work with services, APIs, databases, Pub/Sub, buckets, caches, cron jobs, and secrets, while platform teams control how those resources run. The application runs on standard cloud services and can be built as a Docker image for deployment outside the Encore platform.

Encore uses static analysis to read APIs and resource declarations without running the code, building an application model of service dependencies, resource connections, and the IAM needed for supported resources. Backend operations use explicit APIs and SQL queries, with Pub/Sub for events between services. Postgres data can be accessed with standard SQL tools, while Convex queries, mutations, and reactive subscriptions depend on its document API and runtime, even in a self-hosted deployment.

Postgres-backed services run in your AWS or GCP account, with sizing, scaling, networking, and regions controlled through environment configuration. Developers define APIs and resource dependencies in application code, while platform teams configure how the services run. Encore provisions supported resources with integrated logs, metrics, and tracing; existing Terraform can continue managing shared or unsupported infrastructure.

Working with agents

~/orders — claude

Claude Code v2.1.180Opus 4.8 · Encore MCP connected~/orders

Infra from codereading the code…

SQLDatabaseorders · postgres

Topicorders · pub/sub

Bucketdeclared in code

not running yet

A database, bucket, Pub/Sub topic, or any other supported infrastructure resource is declared in the code that uses it. When an agent adds one:

• APIs, business logic, and resource dependencies can be reviewed in the same pull request, with generated clients providing typed access from the frontend.
• From the first encore run, the agent can test the change against local infrastructure, then check it end to end in an isolated preview environment on Encore Cloud, or in your own cloud account on Enterprise.
• The same application definitions drive local development, previews, and production, keeping services and resource dependencies consistent while capacity and cloud settings are configured per environment.
• The agent can use type errors, traces, and logs to find and fix failures, and test the authorization checks and business rules in the API before opening a pull request.
• Platform teams can configure separate processes per service for independent deployment and scaling, with Pub/Sub subscribers for asynchronous work and cron jobs for scheduled processing.
• Platform teams keep control of production configuration and credentials through their access controls, while developers work with application-level resources.

Cloud resources are billed directly in your account, with costs determined by the services and capacity your team configures, alongside Encore's platform fee.

Best for

Encore fits engineering teams moving beyond Convex that need their backend in their own AWS or GCP account, with developers and agents building features while platform teams control the infrastructure.

You can start with one API or background workload while Convex keeps handling the reactive parts of the product. An Encore service can call Convex functions through its client APIs, with authentication and authorization configured for that integration. If you use an external identity provider, the new backend can validate tokens from that same provider.

Moving the database means exporting Convex documents, designing a Postgres schema, and adapting queries and mutations to SQL-backed operations. Convex's automatic query subscriptions need application-defined streaming, polling, or a retained Convex feature; Encore's Pub/Sub connects backend services rather than providing a browser query subscription API.

Start with the quickstart.

Supabase: Postgres with a backend service bundle

Supabase combines Postgres, authentication, storage, realtime, and Edge Functions. Tables, foreign keys, joins, and SQL transactions give teams a relational data model, while client SDKs provide access to the bundled services.

Working with agents

An agent can write schema migrations, RLS policies, client calls, and Edge Functions, then check them with Supabase's local development tools. The operation still spans application code and database policies, so testing needs to cover the access path used by the client as well as any elevated backend credentials.

Best for

Supabase fits teams that want Postgres while keeping a managed backend bundle. Convex documents and functions need to be adapted to SQL queries, APIs, and RLS policies. Realtime database changes, Broadcast, and Presence provide different subscription behavior from Convex reactive queries. Self-hosting provides an ownership option with provisioning, security, backups, and scaling handled by your team. The managed offering has spend controls, with usage and capacity still determining the bill.

Firebase: managed services for mobile and web apps

Firebase combines authentication, databases, storage, functions, and hosting with mobile tools such as Crashlytics and Remote Config. Its Firestore database supports realtime listeners and offline client access, making it a good fit for apps that need to stay useful without a connection.

// With an initialized Firestore client:
const documents = query(
  collection(db, "documents"),
  where("ownerId", "==", userId),
);
onSnapshot(documents, (snapshot) => {
  renderDocuments(snapshot.docs.map((doc) => doc.data()));
});

Working with agents

An agent can generate client calls, functions, and Security Rules and test them with the Local Emulator Suite. Permissions live across rules for client access and IAM for server access, so checking a feature means following both paths. Functions can also call Google Cloud services beyond the Firebase bundle, with their permissions and configuration managed separately.

Best for

Firebase fits teams that want stronger mobile tooling or Firestore's sync model and are comfortable with Google's ecosystem and usage billing. Moving from Convex means adapting document queries, mutations, and subscriptions to Firestore's APIs and Security Rules. Its Postgres-backed SQL service preserves a relational model, with schemas and operations defined through its own connector tooling.

Appwrite: a backend bundle you can self-host

Appwrite provides authentication, databases, file storage, functions, and realtime APIs through client and server SDKs. You can use Appwrite Cloud or run the platform on infrastructure you control.

Working with agents

An agent can run backend function code in Docker with Appwrite's local development tools. Execution permissions, event triggers, and timeouts need to be checked against the deployed project or a self-hosted instance; the local function runner does not enforce them.

Best for

Appwrite fits teams that want a BaaS bundle they can operate themselves, with self-hosting putting updates, backups, monitoring, and scaling under their control. Moving from Convex means adapting functions, document queries, and reactive subscriptions to Appwrite's APIs and permission model. Its Realtime API delivers service events rather than automatically maintaining the results of Convex queries.

PocketBase: a small backend on one server

PocketBase packages a SQLite database, authentication, file storage, an admin UI, and realtime subscriptions into a single executable you run on your own server.

Working with agents

An agent can start a local instance, exercise the APIs, and work with collection rules and migrations without a hosted development account.

Best for

PocketBase fits small apps that can run on one server and teams willing to manage it. Moving from Convex means adapting the data model to SQLite-backed collections, and the single-server architecture becomes a constraint if you need independently scaled services. Its documentation advises against production-critical use while compatibility changes can require manual migrations.

How to choose

The right choice comes down to what you need to change:

• Encore for SQL-backed services and infrastructure in your own AWS or GCP account, with an integrated workflow for developers and agents.
• Supabase for Postgres with a backend service bundle.
• Firebase for mobile tooling, offline sync, and Google's ecosystem.
• Appwrite for a self-hostable backend bundle.
• PocketBase for a small backend that fits on one server.

If automatic query reactivity still fits the product and hosting is the main concern, self-hosting Convex can preserve more of the existing application. Convex also offers US and EU hosting regions, so a different region may address a data location requirement without changing platforms.

An Encore service can take on workloads that need SQL, separate scaling, or private cloud access while Convex continues handling reactive features. Keep the required transaction and subscription behavior explicit as operations move between the two systems.

Start with the quickstart.