Using Convex?

Convex functions timing out or schema refusing writes? We ship it properly.

Convex replaces a database, a server and a realtime layer with a set of typed functions and reactive queries. That works beautifully until a mutation exceeds its transaction budget, a schema validator rejects a field that used to be optional, or a query recomputes on every unrelated write because the dependency graph is wider than it looks. We trace the function logs, the schema and the subscription tree until writes commit and reads stay cheap.

  • Since 2015Fixing technology
  • FreeEstimates
  • US teamReal engineers

convex-functions.log

still timing out

What it is

Convex at a glance

Convex is a reactive backend-as-code platform founded in 2021 by former Dropbox engineers. It replaces the usual stack of database, API server and realtime layer with TypeScript functions that run on Convex infrastructure against a transactional document store. Queries re-execute automatically when their inputs change, and clients subscribe to them for live updates.

By 2026 Convex has become a common pick for React, Next.js and React Native apps that want realtime without wiring Postgres, Redis, a WebSocket layer and an API framework together. The developer experience is the main draw: everything is typed TypeScript, deploys are atomic, and the dashboard shows exactly which function ran and how long it took. The tradeoffs are real but the productivity bump is also real.

Type
Reactive backend and transactional document database
First released
2022 public beta, 2023 general availability
License
Proprietary cloud service, open source client libraries
Maintained by
Convex, Inc.
Typically used for
Realtime React and React Native apps, collaborative tools, AI chat backends, prototypes that will ship to production

The honest version

Convex pros and cons

No technology is all upside. This is where Convex earns its place and where it tends to cause trouble.

Where Convex is strong

  • Reactive queries by defaultA query hook subscribes to its result. When any write touches the data the query read, the subscription fires and the UI updates. You do not wire WebSockets, you do not invalidate caches, it just works.
  • Strongly typed end to endFunction signatures, schema and client calls share generated types. Renaming a field surfaces as a TypeScript error in the frontend before it ships, which is rare for a backend-as-code product.
  • Transactional document storeMutations are serializable across the documents they touch, so you can read, compute and write in one function without the usual race conditions that hand-rolled APIs ship with.
  • Deploys are atomicA push is one unit. Schema, functions and config move together, and a bad push can be rolled back as cleanly as it went out.
  • Good escape hatchesActions let you call external APIs, HTTP endpoints let third parties hit your backend, and scheduled functions and cron give you background work without a second service.
  • File storage and vector search built inBlob storage, signed URLs, image serving and vector search ship as first-class primitives rather than as a second integration to buy.

Where Convex bites

  • Transaction budgets are tightMutations have a 1 second execution limit and a size cap on reads and writes. Batch jobs, migrations and bulk writes have to be chunked, which is a mindset shift from a long Postgres transaction.
  • Vendor lock-in is realThe function model, the schema language and the reactive query semantics are Convex-specific. Moving off onto a traditional stack is not a database export; it is a rewrite of the server layer.
  • Schema evolution has sharp edgesAdding a required field to a schema with existing data fails validation until a backfill is done. The dashboard surfaces it, but the first time you hit it in production is still a scramble.
  • Query performance depends on index designThe automatic reactivity is powerful; it is also expensive when a query without an index scans a growing table on every write. Index design matters just as much as it does in Postgres.
  • Pricing scales with function calls, not storageReactive apps can fire a lot of queries, and the bill tracks that. Teams that treat Convex as free on the free tier sometimes get a surprise when a feature ships.
  • Cold starts and regions still a conversationConvex runs in specific regions and has function cold start behavior. Latency-sensitive apps outside those regions need to plan for it, and multi-region deployments are not a one-click option.

Sound familiar?

Common Convex problems we fix

The Convex problems that bring people to us, and what you have once each one is fixed.

ConvexError: Function execution timed out after 1000ms

Mutations time out on a bulk update

A single mutation that tried to update hundreds of rows in one transaction and exceeded the 1 second budget. The fix is almost always to chunk the work across scheduled mutations.

Bulk writes split into chunks

SchemaValidationError: Document does not match schema

A schema change rejects old documents

A new required field added to the schema without a backfill, so writes referencing existing documents fail validation because the stored doc does not match the new shape.

Schema changes paired with backfills

ConvexError: Transaction too large

Function reads too much to commit

A query inside a mutation that scanned too many documents for the serializable budget. Usually caused by a missing index or a broad filter across a growing table.

Reads scoped by index

Query recomputed 847 times in the last minute

Reactive query thrashes on every write

A query that subscribes to a table and runs on every write to it, even when the write has nothing to do with the query's result. Narrower filters and better indexes stop the thrash.

Subscriptions targeted to real dependencies

ArgumentValidationError: Expected string, got undefined

Client passes the wrong argument shape

An older client calling a renamed or newly required argument, or a form that sends an empty field as undefined instead of null. The validator stops the mutation at the door.

Client and function contract aligned

ConvexError: Write conflict detected

OCC retries pile up under load

Two mutations touching the same document at once, triggering optimistic concurrency retries. Normal at low volume, but a hot document under heavy write load will see retries climb.

Hot writes serialized or batched

Action timeout: 30s exceeded

An external API call hangs an action

An action that waited on a third-party HTTP call that stalled, which blew past the action budget. Timeouts, retries and a background pattern move it off the critical path.

External calls bounded and retryable

Index 'by_user' not used

A query falls back to full table scan

A filter whose field order does not match the defined index, so Convex scans the whole table rather than using the lookup. Shows up as slow queries that scale with table size.

Index matched to query shape

What we do

Convex help, from one timeout to a full backend audit

Call us for one function that will not finish, or hand us the whole backend.

Rescue
Mutations timing out, schema validation failing after a deploy, or reactive queries firing too often. We work from the dashboard logs and the dependency tree.
Schema and index design
Schemas that evolve safely with backfills, indexes matched to real query shapes, and tests that catch a drift before the next deploy.
Function performance
Mutations and queries sized to the transaction budget, actions with proper retries and timeouts, and scheduled functions that chunk bulk work cleanly.
Realtime patterns
Subscriptions scoped to the data a view actually needs, presence and live-cursor patterns, and offline-tolerant clients that resync on reconnect.
Integration work
Clerk or Auth0 wired into the context, Stripe webhooks hitting Convex HTTP endpoints, and AI model calls kept inside actions with the right error handling.
Managed Tech
Ongoing watch over function timings, schema migrations, usage trends and the Convex changelog, plus a line to call when a deploy goes sideways late in the day.

How it works

From first message to fixed

  1. Look Free estimate

    Tell us what's going wrong. We look at it, then tell you plainly what's wrong and what it will cost.

  2. Fix

    We fix the cause, not the symptom. If something is down, getting it back up comes first.

  3. Harden

    Backups, monitoring, updates and access, so the same problem can't quietly come back.

  4. Hand back or stay on

    You get a plain-language write-up. Or we stay on for hosting, upkeep and new work.

Often found together

Running Convex alongside something else?

We work on the whole stack, so the problem can be wherever it actually is.

Questions

Convex questions

Something else? Call+1 737 727 7327

Why do our Convex mutations keep timing out?

Mutations are capped at one second to keep the transactional model honest. The fix is usually not a longer timeout but a smaller transaction: chunk the work, use scheduled mutations for bulk operations, and move anything that calls an external API into an action where longer budgets apply.

How do we evolve the Convex schema without breaking writes?

New fields should start optional, then be backfilled, then flipped to required after you confirm every document matches. Convex has helpers for this; the mistake teams make is flipping required on first and letting production writes fail until the dashboard notices.

Convex or Supabase for a new app?

Convex wins on realtime out of the box, typed end to end functions, and a transactional document model. Supabase wins when you want Postgres directly, SQL as a lingua franca, and a wider ecosystem of integrations around it. We have shipped both and will say plainly which fits the workload.

How do we keep the Convex bill under control?

Reactive queries can fire often. The levers are tighter subscription scope, indexes that keep per-write work small, and splitting heavy background work into scheduled functions rather than running it in response to every user action. The dashboard breaks the usage down per function, which makes the review concrete.

Can we use Convex for an existing Next.js app?

Yes. The client library plugs into Next.js app router or pages router without a lot of ceremony, and you can migrate one feature at a time while the rest of the app keeps its existing API. The usual starting point is a single reactive feature like a chat or dashboard rather than a full rewrite.

How much does Convex help cost?

The first conversation is free. Share the function that is misbehaving, the error from the dashboard, and we come back with a price before any work is booked.

Free estimate

Convex giving you trouble?

Tell us what you're running and what's going wrong. A person reads it and comes back with an estimate.

  • No charge to find out what it will take
  • If it's urgent, say so

Replies come from a person. By sending, you authorize us to email you back. No marketing.