Convex is an open-source reactive database designed for web developers who want to build dynamic, live-updating applications without managing separate backend services or APIs. It combines a real-time database, server functions, and client libraries into a unified system powered by TypeScript, enabling strong consistency and reactive data flows. Developers can write queries and mutations in pure TypeScript that run directly on the server, with automatic real-time updates to clients.
Built in Rust for performance and deployed via Docker or prebuilt binaries, Convex supports self-hosting on PostgreSQL, Neon, SQLite, Fly.io, Vercel, and Netlify. It includes a dashboard and CLI for development, and integrates with existing infrastructure while maintaining strong consistency and low-latency updates. The system uses isolated JavaScript runtimes for user-defined functions and provides client libraries for seamless frontend integration.
What You Get
- Pure TypeScript Server Functions - Write business logic and data mutations in TypeScript that run directly on the server with no REST or GraphQL API layer needed.
- Real-Time Reactive Queries - Automatically push live data updates to clients when database records change, without manual polling or WebSocket management.
- Self-Hosting Support - Deploy Convex on PostgreSQL, Neon, SQLite, Fly.io, Vercel, or Netlify using Docker or prebuilt binaries with full feature parity to the cloud version.
- Built-In Dashboard & CLI - Manage your database, monitor queries, and deploy functions using Convex’s official CLI and web-based admin interface.
- Isolated UDF Runtime - User-defined functions execute in secure JavaScript isolates (udf-runtime) with controlled access to database and external services.
- Strong Consistency Model - All reads and writes guarantee immediate consistency across clients, eliminating eventual consistency pitfalls common in traditional databases.
Common Use Cases
- Building live dashboards - A SaaS founder uses Convex to power real-time analytics dashboards that update as users interact with the system, without writing WebSocket handlers or backend APIs.
- Developing collaborative apps - A team builds a real-time document editor where changes from multiple users are instantly synced using Convex’s reactive queries and mutations.
- Running a real-time chat app - A developer implements a chat platform with message delivery, read receipts, and typing indicators using Convex’s reactive data streams and server functions.
- Creating data-heavy side projects - A solo developer deploys a habit-tracking app with live progress charts using Convex’s free tier, avoiding the complexity of managing a separate backend.
Under The Hood
Architecture
- Modular Rust monorepo with explicit crate separation for core domains like authentication, database, and function execution, enforcing clear boundaries through path dependencies
- Service-layer design leveraging Rust’s type system for dependency injection and trait-based abstractions, eliminating runtime DI frameworks while preserving composability
- Event-driven workflows using async channels to decouple data processing pipelines, enabling non-blocking communication between storage, cloud services, and function runners
- HTTP API layer built on Axum with middleware for authentication and validation, cleanly separating routing, handlers, and business logic
Tech Stack
- Rust-based backend with Axum for HTTP and WebSocket handling, powered by a comprehensive workspace of internal crates
- AWS SDK integration for S3 and SSO with aws-lc-rs for cryptographic operations and smithy-http for service client generation
- Full Rust tooling ecosystem including rustfmt, dprint, and Cargo workspaces to maintain consistency across 50+ internal modules
- Async-first design using async-trait, async-broadcast, and tokio to enable high-concurrency I/O across distributed systems
- Auto-generated OpenAPI specs and TypeScript clients that remain decoupled from backend implementation details
Code Quality
- Extensive test coverage spanning backend, frontend, and integration layers with specialized macros and runtime harnesses for deep validation
- Strong type safety enforced via TypeScript generics and compile-time assertions to prevent invalid configurations at the client level
- Consistent naming, modular boundaries, and clear separation between Rust core, Node.js runtime, and React UI components
- Comprehensive testing patterns including isolated UDF execution, mock HTTP clients, and state-simulated component rendering
- Strict linting, type-checking, and automated API contract enforcement through generated client code
What Makes It Unique
- Native component-based modeling with hierarchical definitions and typed exports enables declarative, self-documenting system architecture
- Seamless full-stack data flow from React components directly to backend Convex functions via type-safe hooks, bypassing traditional REST/GraphQL layers
- Real-time log filtering that dynamically correlates function calls with component contexts using runtime identifier resolution
- Built-in snapshot export engine with time-bound access and binary object management, removing dependency on external backup tools
- HTTP mount paths as first-class architectural primitives, embedded directly into the component model for API design consistency