Convex review (July 2026): the self-hostable reactive backend starter for Next.js

Convex is a reactive backend and database that pairs cleanly with Next.js: you write your schema and server functions in TypeScript, and your React components subscribe to live queries that keep themselves up to date. As of July 2026 the self-hostable backend sits at 12,050 stars on GitHub and ships daily precompiled binaries. The part a curated gallery has to say out loud: the self-host code is under the Functional Source License (FSL 1.1), which is source-available, not OSI open source, until it converts to Apache 2.0 two years after each release. If you want a managed reactive backend and can live with that license, Convex is one of the smoothest starters we have run behind a solo Next.js SaaS. If "open source" for you means OSI-approved and Postgres-portable, Supabase is the closer fit. Below are five ways to deploy it, the real free-tier math, and where it loses.

We build the stack so the stack can carry us

We keep a simple rule on the ShipGarden shelf: the backend you pick should do more work than you do. A solo founder does not have a platform team, so the platform has to come pre-assembled. That is the whole promise of a reactive backend like Convex. You describe the data once, and reads become live subscriptions instead of polling loops, cron jobs, and cache-busting you hand-wire at 1am.

We spent a week of July 2026 running the official Next.js starter against Convex, both on Convex Cloud and self-hosted with Docker, to see what a real solo SaaS build feels like. This is that hands-on read, not a feature-list recital.

What Convex actually is

Convex is a backend-as-a-service with a built-in transactional database. You write two kinds of server code in TypeScript: queries (read-only, cached, reactive) and mutations (transactional writes). The client library subscribes to a query, and when a mutation changes the underlying data, every subscribed component re-renders with the new value. No websockets to manage, no manual invalidation.

The GitHub description calls it "the open-source reactive database for app developers," and the reactivity is the real selling point. In a normal Next.js app you fetch in a Server Component, cache it, then fight the cache when data changes. With Convex the live query is the cache, and it is always current. For dashboards, chat, presence, collaborative editors, and agent state, that removes a genuine category of bugs.

The self-hosted backend is the same engine that powers Convex Cloud. You run it as a Docker container, point the CLI at it, and you get most of the cloud product including the dashboard and CLI. That is a strong self-host story on paper. The license is where you have to read carefully.

The license fine print (why we do not call it OSI open source)

The convex-backend repository is released under the Functional Source License, Version 1.1, Apache 2.0 Future License (FSL-1.1-Apache-2.0). In plain terms, from the license text itself:

• You can use, copy, modify, and self-host it for any "Permitted Purpose," which includes internal use, professional services, and non-commercial research and education.
• You cannot make a "Competing Use," meaning you cannot offer it as a hosted product that substitutes for Convex or provides substantially similar functionality.
• Two years after each version is published, that version converts to the plain Apache License 2.0.

That is source-available with a delayed open-source grant. It is a reasonable model, and for a solo founder self-hosting your own SaaS it changes almost nothing. But a gallery that files things under "open source" has to be honest: FSL is not OSI-approved, so if your procurement, your investors, or your own principles require an OSI license today, Convex self-host does not qualify until the two-year clock converts each release to Apache 2.0. This is the single most important thing the top-ranking Convex write-ups in 2026 gloss over.

By contrast, Supabase ships its core under Apache 2.0 and is built on PostgreSQL, so your data lives in a database you can lift and shift anywhere. If Postgres-portability is a hard requirement, that difference decides it before you write a line of code.

Five ways to deploy a Convex + Next.js starter

We ran the same to-do-plus-auth starter through five paths and tracked real setup time and monthly cost for a small SaaS (roughly 10K daily active reads, well under 1M function calls a month).

Path A. Convex Cloud Free and Starter. npm create convex@latest, log in, and the CLI provisions a dev deployment in under a minute. The Free and Starter tier is $0 with pay-as-you-go and includes 1M function calls, 0.5 GB database storage, 1 GB file storage, and 1 GB of database bandwidth per month (July 2026 pricing). For most pre-revenue SaaS this is genuinely free. Fastest path, zero ops, and the one we recommend for a first build.

Path B. Convex Cloud Professional. $25 per developer per month. You pay this when you need higher limits, longer log retention, and team seats, not on day one. The pay-as-you-go overages above the free grant are cheap in isolation ($2.20 per additional 1M function calls, $0.22 per additional GB of storage), which makes the bill predictable until you hit real scale.

Path C. Self-host with Docker on a small VPS. Pull the container, set your instance secret, run the dashboard alongside it, and point npx convex dev at your own URL. On a $5 to $7 a month VPS this is the cheapest durable option, and you own the data and the uptime. Setup took us about half an hour the first time, mostly reading the self-hosting guide.

Path D. Self-host on Railway or Fly.io. The same container with a managed host in front. Expect roughly $5 to $15 a month depending on the plan and whether you attach a Postgres volume for durability instead of the default embedded storage. This is the middle ground: you keep control, you skip the raw-VPS babysitting.

Path E. Vercel for the Next.js front end plus Convex Cloud for the backend. The most common production shape we saw in the wild. Vercel hosts the app, Convex hosts the reactive backend, and the two talk over the Convex client. Cost is the sum of both, which for a small SaaS is often $0 to start and scales one lever at a time.

Our default for a solo founder shipping this quarter: Path A first, then Path E when you outgrow the free deploy target. Move to Path C only when the license conversion or data ownership genuinely matters to you.

Convex vs the usual alternatives (July 2026)

The honest read: Convex wins on developer experience for a TypeScript-first team that wants live data with the least wiring. Supabase wins the moment you need real SQL, Postgres portability, or an OSI license you can point a lawyer at. Neon plus your own ORM wins when you want a plain serverless Postgres and full control of the API layer. None of these is the "best backend." They are different trades, and the license row is the one most 2026 reviews skip.

Where Convex loses

We do not tilt reviews, so here is the losing column.

• It is not SQL. If your team thinks in joins, window functions, and existing Postgres tooling, the document-and-functions model is a re-learn, and complex relational queries are more awkward than in Supabase.
• The self-host license is FSL, not OSI. Covered above. For many founders this is fine. For some it is a hard stop.
• Lock-in is real at the query layer. Your queries and mutations are Convex functions. Moving off Convex is a rewrite of your data layer, not a database dump and restore the way leaving Postgres can be.
• Precompiled release cadence over semver. The self-host repo ships date-tagged precompiled binaries (the latest at review time was precompiled-2026-06-09-b6aaa1a) rather than crisp semantic versions, so pinning and changelog-reading takes more attention than a normal npm package.

Where a reactive backend pairs well on the shelf

A reactive backend is the data floor. It gets more interesting next to the pieces that sit above it. If you are building an agent product, the agent's state, message history, and tool-call log are exactly the kind of always-live data Convex handles well, which is why we cross-reference our hands-on Mastra AI starter review when readers ask what to put the agent loop on top of. And when the work outgrows a single request and needs durable retries and queues, our Trigger.dev v4 background-jobs starter review walks the deploy-paths matrix for the jobs layer that runs beside a reactive database.

The practical move

If you are a solo founder shipping a Next.js SaaS this quarter and your UI has any live surface (a dashboard, a chat, presence, an agent), start on Convex Cloud Free and wire the official Next.js starter. You will feel the difference on the first live query. Keep Supabase in your back pocket for the day you need real SQL or an OSI license, and treat self-host as a deliberate choice you make for data ownership, not a default.

We build the stack so the stack can fund the life, not the other way around. A backend that keeps itself current is one fewer thing between you and shipping.

Your move: clone the Convex Next.js starter tonight, put one live query on your ugliest polling screen, and delete the cron job you were about to write.

ShipGarden curates open-source and source-available SaaS and AI-app boilerplates. We have no commercial relationship with Convex, Supabase, Neon, Vercel, Railway, Fly.io, or Docker. Stars, license terms, release tags, and prices in this review were fetched live from GitHub and each vendor's own pages on July 1, 2026.