The most consequential change in software is who writes it. Software is now written by developers and their agents together — agents scaffold applications, wire up logic, and increasingly operate the products they help create. A generation of new builders is arriving with them. Yet the backend they all inherit was designed for a different era: assembled by specialists, spread across systems, and held together by assumptions that only careful human review ever enforced.

Today, Convex announced its $57 million Series B, led by Insight Partners. We are proud to invest alongside Spark Capital, a16z, and Justin Kan, and to back Jamie Turner, James Cowling, and the Convex team as they build the backend for the agent era.

Faster code, falling confidence

Coding was the first domain frontier models transformed, and the frontend fell fast — today anyone can generate a polished interface in seconds. The backend is harder, for two reasons.

The first is visibility. State — the database, the cache, the queue, auth, cron, background workflows — lives in separate systems, configured in cloud consoles, held together by glue code. An agent reasons over what fits in its context window; a backend scattered across dashboards is one it physically cannot see, cannot safely modify, and cannot verify.

The second is confidence, and it is the newer anxiety. As agents generate code faster than anyone imagined, more of it ships without a human ever reading it. Each change is made with less of the system in view, and the nuanced invariants engineers used to enforce by reading every line quietly erode. Every team now feels the same tradeoff: go fast and lose confidence, or slow down and lose the whole point of agentic engineering.

There is a third shift worth naming, because it changes the market itself. For years, the biggest barrier to any new backend was human loyalty — to Postgres, to SQL, to the tools engineers had built careers on. Agentic engineering has dissolved that loyalty: developers now delegate implementation choices to agents, and agents simply pick what makes the system work. The force that created the confidence crisis also tore down the walls that protected incumbent infrastructure. For the first time in a decade, the backend is genuinely up for grabs.

Correctness by default

Convex made its bet in 2021, before any of this was obvious. Rather than hosting Postgres with conveniences bolted on, the team built a reactive database engine from scratch and collapsed the entire backend — schema, server functions, migrations, cron, workflows — into a single typed TypeScript project that lives alongside the frontend code.

The result is a backend where the guarantees engineers used to enforce by reading every line, the platform enforces instead. Transactions are ACID, so concurrent writes never corrupt data. Everything is TypeScript end to end, so a hallucinated field name is a build error, not a production incident. Sync and caching are automatic, so there is no glue code to subtly rot. And Convex Components extend the same idea to system design: sandboxed building blocks, each a context-window-sized unit an agent can reason about completely — while the reactive engine keeps the whole coherent.

This is not a database with AI features bolted on. It is an application model — one runtime where agents execute the logic they write, application state stays consistent, and humans supervise through views that update in real time. The market is voting: millions of Convex instances now run in production, enterprise plans launched with dozens of companies already on them, and teams like Reducto describe replacing entire stacks of state management with "a single fast and consistent source of truth" that both their engineers and their agents can work on safely.

Why Convex

Three things gave us conviction.

• The right abstraction for the new builder.

Whether the builder is an engineer, a designer, or an agent, the backend that wins is the one that fits in a single mind — or a single context window. "Backend in a folder" collapses the friction between an idea and a running, stateful application, the way the IDE once collapsed the friction of writing code.

• A structural lead, not a feature lead.

Convex's reactivity, determinism, and type-safety live at the engine level, not the feature level. Incumbent stacks were designed to be assembled by specialists; matching Convex's form would mean rebuilding the product, not shipping an update. In our diligence, customers across entirely different use cases independently described Convex the same way — not as a database, but as a different way to build applications. When the market converges on a category description the company didn't write, that is usually a signal.

• A team that built for this future before it had a name — and the reason we kept leaning in.

Jamie and James spent years at Dropbox on storage and distributed systems — exactly the pedigree required to write a reactive database engine from scratch. They started Convex when the market still demanded Postgres, absorbed years of skepticism, and held the line until agentic engineering made the industry reconsider what a backend should be. In our conversations, what stood out was engineering candor: a founding team that discusses its hardest problems in terms of concrete systems work rather than positioning stories. That is the temperament this stage of infrastructure requires.

The ambition is bigger than a better backend. As code becomes cheap, what remains valuable is design — the abstractions, boundaries, and invariants that keep fast-moving systems correct. Software is becoming always-on: fleets of agents building, running, and revising applications continuously, with people deciding what should exist and supervising through live views rather than reading logs after the fact. That world needs a runtime where agent execution, application state, and human oversight converge — durable, reactive, and correct by default. We believe the defining infrastructure companies of the agent era will own that layer. Convex is the furthest along in building it — and we are grateful to be building the future of software alongside Jamie, James, and the team.

Read Convex's announcement