You want to ship a realtime, AI-powered app. The classic path is five bills and five dashboards: a database, a websocket or polling layer for live updates, a job queue for scheduled work, a file bucket, and an auth vendor — plus the glue code holding them together. Convex collapses that stack into one product where all of it is just TypeScript functions running over a reactive database. For a solo founder, that's the difference between wiring infrastructure and building the app.
What it is#
Convex is an open-source reactive backend platform: a database where your queries and business logic are pure TypeScript functions with strong consistency, plus everything a real app needs around it. It was built by a team of ex-Dropbox infrastructure engineers, is a16z-backed, and its core is on GitHub.
The building blocks are three function types and a reactive database:
- Queries read the database. They're cached and reactive — Convex tracks what each query read, and when that data changes it re-runs the query and pushes the new result to every subscribed client over a websocket.
- Mutations are transactions that read and write the database.
- Actions step outside the transaction to call third-party APIs (OpenAI, Stripe, Twilio) or run Node.js code.
Around those sit built-in auth, file storage, scheduled functions and cron jobs, and vector + text search. On top is a Components ecosystem, including an official Agent component (@convex-dev/agent) for building AI agents — it manages threads and messages, tool calls, RAG, and streams tokens over websockets so every client stays in sync. Because everything is TypeScript and the schema flows types to your frontend, AI coding tools generate Convex code unusually well.
Realtime isn't a feature you turn on in Convex — it's the default behavior of every query, which is exactly the plumbing a solo founder shouldn't be hand-rolling.
Who it's for#
Solo founders, indie hackers, and small teams building apps where live data or AI is central — collaborative tools, dashboards, chat, agent apps — and who'd rather learn one mental model than integrate five services. It's especially strong if you're already in TypeScript/React/Next.js, because the frontend calls your backend functions through generated, type-safe hooks with no REST or GraphQL layer in between.
How to start#
One command scaffolds a project; a second runs the dev loop that pushes your functions and hot-reloads them:
npm create convex@latest # scaffold a new Convex app
npx convex dev # sync + push functions, watch for changesYour backend lives in a convex/ folder. A reactive query and a mutation look like this:
// convex/messages.ts
import { query, mutation } from "./_generated/server";
import { v } from "convex/values";
// Reactive: every client subscribed to this updates automatically
// when a new message is inserted — no polling, no manual sockets.
export const list = query({
args: {},
handler: async (ctx) => {
return await ctx.db.query("messages").order("desc").take(50);
},
});
// A transaction that writes to the database.
export const send = mutation({
args: { author: v.string(), body: v.string() },
handler: async (ctx, args) => {
await ctx.db.insert("messages", args);
},
});Call list from React and the UI re-renders the instant anyone calls send — that's the whole realtime story.
Pricing#
As published on convex.dev/pricing (mid-2026):
| Plan | Price | Shape |
|---|---|---|
| Free | $0 | ~1M function calls/month, 0.5 GB storage, no credit card |
| Starter | Pay-as-you-go | Scale-to-zero; pay only for usage past the free limits |
| Professional | $25 / developer / month | Higher included quotas (~50 GB storage, ~50 GB egress, ~250M calls), then per-unit overage |
Beyond the Pro quotas you pay per-unit overage on storage, egress, and function calls — so confirm the current rates on convex.dev/pricing and watch your usage as you grow. Self-hosting the open-source backend has no license fee — you pay only for the infrastructure you run it on.
The trade-offs / when NOT to pick it#
Convex is opinionated, and that cuts both ways. It is not a drop-in Postgres — you interact through its reactive document model and TypeScript functions, not arbitrary SQL, so if you need raw SQL, complex analytical joins, or an existing Postgres schema, a serverless Postgres like Neon, Supabase, or Turso is the better fit. The reactive model is its own mental model to learn. And the managed cloud is a vendor commitment — the honest mitigation is that the backend is open-source (FSL, converting to Apache 2.0) and self-hostable via Docker on SQLite or Postgres, so you're not fully locked in, but self-hosting is real ops you'd otherwise skip. Finally, usage-based pricing can surprise you at scale, so watch function-call and egress volume as you grow.
For a founder whose app is fundamentally about live, collaborative, or AI-driven data, Convex removes the most tedious infrastructure from the critical path and lets you ship the thing that actually matters.
