Convex
convex.dev- Category
- Developer Tools
- Rank
- No. 299Tools index
- Listed in
- #3 Add a backend
- Pricing
- Freemium
- Type
- TOOL
- Use case
- Deployment & Operations
- Interfaces
- Web · API
- Builder
- @convex
- GitHub
- 12.6k stars
- Latest release
- precompiled-2026-09-24-d1770b1
- Date
About
Real-time backend platform with reactive queries, server functions, and automatic caching
What it does
Convex bundles a database with TypeScript logic that runs inside the same deployment, so an application's data and its business rules live together instead of being stitched across separate services over HTTP. A client that reads data keeps a live subscription, and when the underlying rows change it receives the new result automatically, without polling or manually refreshing state. It ships as both a hosted cloud product and a self-hostable build that runs under Docker or from a prebuilt binary.
Why it's ranked here
The backend workspace spans well over a hundred Rust crates covering persistence, search, isolate execution, sync and multiple cloud storage backends, evidence of a system built for production load rather than a demo. The official client crate documents a real subscription and mutation API, and the CLI ships as a packaged npm binary rather than a script. The tradeoff: every core crate depends on nightly-only Rust compiler features, and the README states the project's own test suites are withheld from this repository.
What's good
Self-hosting is a first-class path, not an afterthought: the same binary that runs the cloud product deploys under Docker or standalone, and it interoperates with common infrastructure choices like Postgres, Sqlite, Neon, Fly.io, Vercel and Netlify. The one piece of telemetry it phones home, a deployment beacon, is documented field by field in the README and has a single flag to turn off. Rust developers get a real native client, not just a TypeScript SDK wrapping a REST call: it exposes subscriptions and mutations directly.
Tradeoffs
The backend will not build on stable Rust: its core crates gate on nightly-only compiler features, some of them unstable enough to shift between toolchain releases. The README says outright that the maintainers' own randomized test frameworks are not part of the open source release, so anyone building from source inherits a large codebase without the safety net the team uses internally. The project also says it is tested far more on Linux and Mac than on Windows.
How to use it well
This fits teams building a web or LLM-backed app that want database, business logic and live updates delivered as one deployment rather than assembled from a queue, a cache and a database driver. Start on the hosted cloud tier for the free allowance and zero ops burden; move to self-hosting with Docker once you need control over data location or infrastructure vendor. It is a weaker fit for anyone wanting to hack on the backend engine itself, since building it requires a nightly Rust toolchain and the maintainers' own test suites stay private.
Technical notes+
Cargo.toml defines a workspace (resolver 2) covering crates/* plus crates/convex/sync_types, excluding crates/py_client and crates/python_client_tests, and pins dependencies for S3, Postgres, MySQL, Sqlite, a forked tantivy for search, and a deno_core-based JS runtime. crates/local_backend/src/main.rs wires an axum-based ConvexHttpService and a separate site proxy, plus a keygen subcommand that mints an admin key through KeyBroker; crates/local_backend/src/lib.rs assembles the Database, an in-process searcher, an in-process FunctionRunner, and a background beacon worker started unless disable_beacon is set. crates/database/src/lib.rs re-exports Database, IndexWorker, leader and follower retention managers, and write-log types backing occ-based transaction retries. crates/isolate/src/lib.rs implements the sandboxed UDF execution engine (module cache, isolate worker, timeout handling) and, like local_backend and database, is gated behind numerous nightly-only feature attributes. crates/udf/src/lib.rs defines the action and HTTP action outcome types, including a fixed HTTP_ACTION_BODY_LIMIT constant. crates/sync/src/lib.rs implements the SyncWorker that speaks a ServerMessage protocol over the wire. crates/function_runner/src/lib.rs declares the FunctionRunner trait with run_function, analyze, evaluate_app_definitions, evaluate_component_initializer, evaluate_schema and evaluate_auth_config methods, which crates/application/src/lib.rs consumes when building QueryReturn, MutationReturn and ActionReturn (and their Redacted variants) as the request and response contract. The published Rust client, crates/convex/src/lib.rs, wraps this in a ConvexClient with subscribe and mutation methods plus a lower-level BaseConvexClient for other language bindings, while the npm CLI package (npm-packages/convex/bin/main.js) is a thin loader that dynamically imports a prebuilt CLI bundle from the package's dist directory rather than shipping CLI source directly, and npm-packages/convex/src/index.ts only exports a version string.
Observed
- Language split
- Backend implemented in Rust across a multi-crate workspace; client libraries and CLI implemented in TypeScript under a separate npm package tree.
- Self-hosting interfaces
- Self-hosted deployments run via Docker or a prebuilt binary and include the same dashboard and CLI as the hosted product.
- Build toolchain requirement
- Multiple core Rust crates declare nightly-only compiler feature flags, so building the backend from source requires a nightly Rust toolchain rather than stable Rust.
- Interfaces
- Exposes a packaged CLI, a native Rust client library with direct subscribe and mutation calls, and an HTTP-serving backend process, rather than only a REST API.
- Platform support
- The project states it is tested more thoroughly on Linux and Mac than on Windows.
- Test suite disclosure
- The maintainers state their own randomized test frameworks are not included in the open source repository.
- Telemetry
- Self-hosted builds send a periodic beacon carrying a random deployment identifier, database migration version, backend git revision, and uptime, disabled with a single command-line flag.
Read from README.md, Cargo.toml, npm-packages/convex/src/index.ts, npm-packages/convex/bin/main.js, crates/local_backend/src/main.rs, crates/local_backend/src/lib.rs, crates/application/src/lib.rs, crates/database/src/lib.rs, crates/isolate/src/lib.rs, crates/udf/src/lib.rs, crates/sync/src/lib.rs, crates/convex/src/lib.rs, crates/function_runner/src/lib.rs.
What it can do
Execute real-time database queries
Database query with reactive parameters → Live-updating query results
Run server functions
Function calls with parameters → Computed results and side effects
Cache query results automatically
Database queries and function calls → Cached responses for faster retrieval
Sync data changes across clients
Database mutations from any client → Real-time updates to all connected clients
Handle backend API requests
HTTP requests and API calls → API responses and data operations
Manage database schema and migrations
Schema definitions and migration scripts → Updated database structure
Tags
Tech Stack
Media
Comments (0)
No comments yet
Editorially curated, with community endorsements as a secondary signal. Corrections welcome.