# Convex Launch

Jamie Turner, Convex

AI Engineer World's Fair 2024

[Talk page](https://ai.engineer/talks/JbyictbPFV0-convex-launch) · [Video](https://www.youtube.com/watch?v=JbyictbPFV0)

## Convex Launch

Convex extends dependency-driven updates from the interface into the backend, helping multistep AI applications expose results as their work progresses.

Basic familiarity with React state and backend APIs will help; no prior Convex experience is required.

### Replacing backend glue

[0:00](https://www.youtube.com/watch?v=JbyictbPFV0&t=0s)

What would it take to replace routine backend engineering with an API that feels native to an application? Jamie Turner introduces [Convex](https://www.convex.dev/) through that ambition, abandoning his planned deterministic-workflow title for a more revealing one: “We Accidentally Made an AI Platform and What Are We Gonna Do About It?”

The opening illustration includes an accidental generative-AI contribution: “fate limiting,” an ominous addition to the backend engineer’s responsibilities. The familiar work is less mysterious: gluing systems together, configuring them, and mapping data formats. Turner estimates that teams sometimes spend half their time on this integration work. Users receive little direct benefit from the plumbing itself. Convex’s proposed replacement is a high-level functional interface, with Firebase and Parse as precedents. The design question is what that interface should look like for applications built in the 2020s.

### Extending React’s state model to the server

[1:18](https://www.youtube.com/watch?v=JbyictbPFV0&t=78s)

React supplies the starting point: create a state variable and a setter, then let the framework refresh the places that depend on that state. In Turner’s small example, changing a name produces an uppercase greeting for Olivia. The essential relationship can be expressed in TypeScript like this:

```tsx
import { useState } from "react";

export function Greeting() {
  const [name, setName] = useState("");

  return (
    <>
      <input
        aria-label="Name"
        value={name}
        onChange={(event) => setName(event.target.value)}
      />
      <p>{`Hi ${name}`.toUpperCase()}</p>
    </>
  );
}
```

Entering `Olivia` calls the setter; React renders the dependent expression as `HI OLIVIA`. There is no separate instruction to find and update the greeting.

![Diagram with a state setter, React logo, connecting arrows, rendering code, and a browser displaying HI OLIVIA.](https://ai.engineer/api/talk-essay-media/a8626aaa9e2fcfe24e7544dcefc16914e022902778beb3fac14ea65dcb4c1044)

React state changes flow through to the rendered “HI OLIVIA” result.

That relationship usually breaks at the server boundary. The application must poll for changes, invalidate caches, or arrange its own push mechanism. Convex exposes **queries and mutations**, but its distinguishing mechanism is pervasive tracking of backend data flow and dependencies. Queries are subscribable: when underlying state changes, applications can receive updated results. **The reactive relationship extends through the backend**, instead of ending at local component state.

### A note-taker with visible checkpoints

[2:27](https://www.youtube.com/watch?v=JbyictbPFV0&t=147s)

The connection to AI appears when server-side work participates in the flow of state. A note-taking application needs more than a final response: it performs several operations and brings the interface back into the process at useful checkpoints. Turner sketches this sequence:

1. Run automatic speech recognition on the recording.
2. Summarize the transcription and show the summary in the application.
3. Generate embeddings for retrieval.
4. Find related notes and display them in the application.

The diagram connects ASR, summarization, embedding generation, a vector index, and related notes to the application. Each intermediate result can become useful before the whole workflow is finished.

![Flowchart labeled AI-Powered Voice Recorder, with ASR, summarization, embedding generation, vector index, related notes, and application boxes linked by arrows.](https://ai.engineer/api/talk-essay-media/c986198c8fc24f86d8b208386d3c3921a62cd180df7344093788a0f645920f1a)

An AI-powered voice recorder workflow connects transcription, summarization, embeddings, and related notes to an application.

The implementation distinction is between **subscribed query results** and **actions that perform external work**. Turner describes server-side actions as reacting entities; this does not establish that actions automatically subscribe to database changes. In the current [action API](https://docs.convex.dev/functions/actions), actions are invoked or scheduled, call external services, and store results through mutations. Query subscriptions then expose changed database state to the interface. That distinction makes the workflow concrete without assuming an automatic trigger for every processing step.

### Concurrent results in a project planner

[2:59](https://www.youtube.com/watch?v=JbyictbPFV0&t=179s)

Real applications can have several branches running at once. Turner demonstrates a developer’s application for generating an initial project plan from a prompt. The example asks for an app to track recipes. Clicking **Create Plan** starts work on Convex, with concurrent chains producing several kinds of output:

- **Project names:** candidate names for the application.
- **Initial feature requests:** a first set of capabilities to build.
- **Color palettes:** possible visual directions.
- **Icon ideas:** suggestions for the application’s identity.

Results flow into the interface as the chains produce them. The application does not need to hold every output until one complete plan is ready.

Synchronizing state between backend steps and the application turns out to be especially useful for generative AI products. Turner reports that, after the ChatGPT boom, more than 90% of projects on Convex were generative AI projects. He does not specify the observation window or classification method; the figure describes his account of adoption at the time. That concentration of AI builders shapes the next additions to the platform.

### Vector indexes in the existing schema

[3:56](https://www.youtube.com/watch?v=JbyictbPFV0&t=236s)

Vector indexing repeatedly appeared as a step developers needed. Convex already let them define schemas in TypeScript, with type completions, and add indexes to fields. Their request was to extend that same interface to vector indexes. The demonstrated `foods` schema adds a vector-index configuration with an embedding field, dimensions, and cuisine filtering. The extension keeps vector indexing alongside the application’s existing data definition.

![Slide titled “1. Last year: built-in vector search” showing a foods schema and vector index configuration.](https://ai.engineer/api/talk-essay-media/ec451ec55186fe65f905840ea7e6b9eb987ed8e6d11fafd7c2d1718883ee8236)

A schema example adds a vector index with an embedding field, dimensions, and cuisine filtering.

Turner says vector indexing shipped late the previous year and was already broadly used by Convex projects. It is an available capability in this recording, unlike the workflow components introduced at the end.

### Supporting startups and packaging workflows

[4:24](https://www.youtube.com/watch?v=JbyictbPFV0&t=264s)

The next announcement is [Convex for Startups](https://news.convex.dev/announcing-the-convex-for-startups-program/): discounts plus access to startup-only forums and events. Turner says the first admitted batch includes many generative AI companies, which he describes as the most engaged and excited customers at the time.

The final product direction raises the level of reuse from individual backend functions to **whole state machines**. Convex Components is intended to package sophisticated workflows, co-developed with customers, into building blocks developers can drop into an application. The slide illustrates the idea with puzzle pieces labeled **RAG** and **Model Flow**. These high-level components are forthcoming in the recording, described as arriving very soon.

![Slide titled “3. Soon: Convex AI Components” with two puzzle pieces labeled RAG and Model Flow.](https://ai.engineer/api/talk-essay-media/d112bac036b1e133f2f25e13eb060aa32e4c5ec38e4a5bfaeb79b392310814ad)

Upcoming Convex AI Components are illustrated as RAG and Model Flow puzzle pieces.

The progression is from synchronizing individual state changes to packaging entire workflows that maintain state across multiple steps. Turner closes by inviting generative AI builders to try Convex, with the aim of shipping applications quickly and confidently.

## Resources

- [Convex](https://www.convex.dev/) — The backend platform combining a database, server functions, and reactive application updates.
- [Convex query documentation](https://docs.convex.dev/functions/query-functions) — Define queries and understand caching, subscriptions, deterministic execution, and consistent database reads.
- [Convex action documentation](https://docs.convex.dev/functions/actions) — Call external services and coordinate their results with database queries, mutations, and scheduled functions.
- [Convex 1.2: vector search beta](https://news.convex.dev/announcing-convex-1-2/) — The original vector-search announcement, with TypeScript schema and action examples and historical beta restrictions.
- [Convex vector search documentation](https://docs.convex.dev/search/vector-search) — Current guidance for declaring vector indexes and searching embeddings in Convex.
- [Components for your Backend](https://stack.convex.dev/backend-components) — A walkthrough of reusable backend components with persistent state, isolated APIs, and transactional behavior.

## Slides

### Presenting sponsor: Microsoft

Microsoft is the presenting sponsor.

[0:05](https://www.youtube.com/watch?v=JbyictbPFV0&t=5s) [Microsoft logo beneath the words presenting sponsor.](https://assets.ai.engineer/sites/aiecode2025/sha256/605a59f154d28fbf96b866a91c64a9131245265bf9472e0498ad3a34bb3c9630.webp)

PRESENTING SPONSOR

Microsoft

### Innovation and platinum sponsors

AWS is the innovation sponsor; MongoDB, Google Cloud, and Neo4j are platinum sponsors.

[0:10](https://www.youtube.com/watch?v=JbyictbPFV0&t=10s) [AWS is the innovation sponsor; MongoDB, Google Cloud and Neo4j are platinum sponsors.](https://assets.ai.engineer/sites/aiecode2025/sha256/691e74aea1e0f2a8befa9a209c3c9b9e6f38be9db9b2d1ba13e131a215244f7f.webp)

INNOVATION SPONSOR
aws

PLATINUM SPONSORS
MongoDB®
Google Cloud
neo4j

### We accidentally made an AI platform

The speaker frames Convex’s accidental AI platform alongside its mission to replace traditional backend engineering.

[0:19](https://www.youtube.com/watch?v=JbyictbPFV0&t=19s) [Convex slide titled “... or, we accidentally made an AI platform” with the subtitle “and here’s what we’re doing about it.”](https://assets.ai.engineer/sites/aiecode2025/sha256/5dc14023d08dc35e565f2acedebc8032587d1541bda8829f88b0de6fa813bfa1.webp)

... or, we accidentally made an AI platform

(and here’s what we’re doing about it)

convex

### Undifferentiated backend work

The slide says many teams spend 40% or more of their time on undifferentiated backend/DevOps work: gluing systems together, configuring them and mapping data formats.

[0:28](https://www.youtube.com/watch?v=JbyictbPFV0&t=28s) [Illustrated collage of backend tasks, including caching, queuing, rate limiting and file storage; some small labels are distorted.](https://assets.ai.engineer/sites/aiecode2025/sha256/353d17d9821ee10b626ae565290e8081058ec9e93332a30ba14462531a3225ca.webp)

Illustration text:
ORTHESTRATION
CACHING
ORCHESATION
PROTOCOL MANAGEMENT
BROTOCOL JOBS
QUEUING
CACHING
PROTOCOL MANAGEMENT
STORAGE
RATE LIMITING
RATE LIMITING
RATE LIMITING
FATE LIMITING
QUA[illegible]ING
FILE MANAGINT
PROTOCOL MANAGMENT
[illegible] JOBS
ORMS
FILE STORAGE
ORM
FILE STORAGE
FILE JOBS
OR.E STORAGE
ORM [illegible]
ORMS
BRAKGROUD STORAGE
BRAKGROUND JOBS
DABABASES

Interface text:
co

[0:44](https://www.youtube.com/watch?v=JbyictbPFV0&t=44s) [Bullets describe gluing systems together, configuring them, mapping data, and time spent on backend and DevOps work.](https://assets.ai.engineer/sites/aiecode2025/sha256/2ce0f69d7575be3053c11babbe00b4441d9eb6a1383a134258382f530638df39.webp)

• We glue stuff to stuff
• Configure stuff for stuff
• Map data from one format to another
• Many teams spend 40% or more time on undifferentiated backend/DevOps stuff

Illustration text:
ORTHESTRATION
CACHING
ORCHESATION
PROTOCOL MANAGEMENT
BROTOCOL JOBS
QUEUING
CACHING
PROTOCOL MANAGEMENT
STORAGE
RATE LIMITING
RATE LIMITING
RATE LIMITING
FATE LIMITING
QUA[illegible]ING
FILE MANAGINT
PROTOCOL MANAGMENT
[illegible] JOBS
ORMS
FILE STORAGE
ORM
FILE STORAGE
FILE JOBS
OR.E STORAGE
ORM [illegible]
ORMS
BRAKGROUD STORAGE
BRAKGROUND JOBS
DABABASES

Interface text:
convex

### Users do not benefit

The speaker argues that gluing systems together and managing backend infrastructure does not benefit users. The slide estimates that some teams spend 40% or more of their time on undifferentiated backend and DevOps work.

[0:52](https://www.youtube.com/watch?v=JbyictbPFV0&t=52s) [A red ellipse and arrow highlight backend tasks above the statement that users do not care and do not benefit.](https://assets.ai.engineer/sites/aiecode2025/sha256/bf5c45906ecb496ea80d8741138894a3d71f5112d2e4bb6024bb6c2ab9198b70.webp)

• We glue stuff to stuff
• Configure stuff for stuff
• Map data from one format to another
• Pass signals from background work to foreground work
• A lot of teams? 40% or more time on undifferentiated backend/DevOps stuff

Your users don’t care and don’t benefit.

Illustration text: ORTHESTRATION; CACHING; ORCHESATION; PROTOCOL MANAGEMENT; BROTOCOL JOBS; QUEUING; CACHING; PROTOCOL MANAGEMENT; RATE LIMITING; STORAGE; FATE LIMITING; RATE LIMITING; QUACUING; FILE MANAGINT; [illegible] JOBS; PROTOCOL MANAGMENT; ORMS; FILE STORAGE; ORM; OR.E STORAGE; FILE JOBS; ORM [illegible]; BRAKGROUD STORAGE; BRAKGROUND JOBS; DABABASES.

convex

### Replacing backend engineering with an API

The speaker frames a design exercise: what would a high-level API that replaces backend engineering look like? The proposed interface should feel native to the application.

[1:09](https://www.youtube.com/watch?v=JbyictbPFV0&t=69s) [The slide asks how to replace backend engineering with an API.](https://assets.ai.engineer/sites/aiecode2025/sha256/02ad5dbbbd6cc91b83e680bff1f0b6fc5f02204522bbd0842d7ff792a5812dc9.webp)

If you wanted to replace all of backend engineering with an API...
...how would you do it?

convex

### React and application state

Convex drew inspiration from React and the functional, reactive relationship to state emerging across applications.

[1:16](https://www.youtube.com/watch?v=JbyictbPFV0&t=76s) [A large blue React logo appears at the center of the slide.](https://assets.ai.engineer/sites/aiecode2025/sha256/3744def511840742f9bd21d18fe490d7617c372d7b7c6134b7b1dc7c67b6b0d9.webp)

convex

[1:21](https://www.youtube.com/watch?v=JbyictbPFV0&t=81s) [React logo above the caption “kinda all apps.”](https://assets.ai.engineer/sites/aiecode2025/sha256/d8e5e9b5877e74c0fdf9d97e8a67c5d937ceb06a8fcabdbed8e939e345231940.webp)

(kinda all apps)

convex

### React state example

Calling setName("Olivia") changes React state, prompting dependent UI to re-render. The expression converts the name to uppercase, producing “HI OLIVIA.”

[1:46](https://www.youtube.com/watch?v=JbyictbPFV0&t=106s) [A state setter and rendering expression connect to React, with a browser displaying “HI OLIVIA.”](https://assets.ai.engineer/sites/aiecode2025/sha256/c901dfd967cc8185ebc9aa315e2fb2c01d885b3d309489865b04045b1ea319d3.webp)

const [name, setName] = useState();

setName("Olivia");

<div>HI {name.toUpperCase()}</div>

HI OLIVIA

convex

### Convex client-server state

A client mutation sends Olivia to the Convex backend; a subscribed query brings the result back for rendering. Convex tracks backend data flow and dependencies so applications receive updates.

[2:07](https://www.youtube.com/watch?v=JbyictbPFV0&t=127s) [Query and mutation code with arrows between client-side examples and the Convex server logo.](https://assets.ai.engineer/sites/aiecode2025/sha256/9a7d2c1e418d901a19e2ee89b2ef1d870675a07537953cda27aab9421329a84b.webp)

const name = useQuery(api.name.get);
const setName = useMutation(api.name.add);

client | server

setName("Olivia");

<div>HI {name.toUpperCase()}</div>

Interface text:
convex

### Convex reactive backend

Convex tracks data flow and dependencies through the backend, letting applications subscribe to queries and receive new results as soon as they are available.

[2:15](https://www.youtube.com/watch?v=JbyictbPFV0&t=135s) [Bullet points describe extending reactive state into the backend and pushing new query results to applications.](https://assets.ai.engineer/sites/aiecode2025/sha256/f074a9583f05e5800c82acd69cb2b20f5e9bd369bee9d0d6bf0d46b6c2114dd5.webp)

Convex...

• Extends the reactive state paradigm into the backend.
• Queries are universally subscribable and applications are pushed updates as soon as there is a new result.

Interface text:
convex

[2:21](https://www.youtube.com/watch?v=JbyictbPFV0&t=141s) [Convex extends reactive state to the backend and pushes updated query results to applications.](https://assets.ai.engineer/sites/aiecode2025/sha256/b4ff02bab7399ec776eab9f374f1f0952f8f4de82f29931a96224e0fa0906664.webp)

Convex...

• Extends the reactive state paradigm into the backend.
• Queries are universally subscribable and applications are pushed updates as soon as there is a new result.

### Why is this useful for AI?

The talk turns from reactive backend queries to AI, where server-side actions can also be reacting entities.

[2:27](https://www.youtube.com/watch?v=JbyictbPFV0&t=147s) [Slide asks why the reactive approach is useful for AI.](https://assets.ai.engineer/sites/aiecode2025/sha256/830847bd0f69f1fa7a1dc922d68dec0e972192d299a010b457d892069d8339f5.webp)

Why is this useful for AI?

Interface text:
neo4j
AI Engineer World's Fair
Microsoft
smol ai

### Server-side actions

Reactivity can extend beyond the application to server-side actions, bringing backend work into the reactive flow.

[2:30](https://www.youtube.com/watch?v=JbyictbPFV0&t=150s) [Slide says some reacting entities are server-side actions.](https://assets.ai.engineer/sites/aiecode2025/sha256/a03ae1107f99146c16efb09d8227d3f9cdda502eedc0894352fe9bdc22efe26a.webp)

Consider that some of the “reacting” entities are server-side actions

Interface text:
AI Engineer World's Fair
Galileo
Microsoft
smol ai

### AI-powered voice recorder workflow

Whisper transcribes speech, then GPT-4o summarizes it. The summary flows directly to the application and through an embedding and Pinecone index to find related notes, which also reach the application.

[2:38](https://www.youtube.com/watch?v=JbyictbPFV0&t=158s) [Diagram connects speech recognition to summarization, embedding generation, a vector index, related notes, and the application.](https://assets.ai.engineer/sites/aiecode2025/sha256/d8c72795f037ec9e6ccf2488e40bd6253c894afb25c5f631116a0edacac0b90c.webp)

AI-Powered Voice Recorder

ASR (Whisper)
Summarize (GPT-4o)
Generate Embedding (text-embedding-3-small)
Vector Index (Pinecone)
Find related Notes
Application

Interface text:
neo4j

### Project plan creation demo

The demo starts a project plan for a recipe-tracking app aimed at a dad. The speaker says creating the plan starts concurrent tasks for names, features, colors and icons, with results flowing into the app as they arrive.

[3:08](https://www.youtube.com/watch?v=JbyictbPFV0&t=188s) [A project-planning application shows a form for creating a plan from an app idea and target user.](https://assets.ai.engineer/sites/aiecode2025/sha256/b9e7c753f32c486b9f4e9b32b8e83a99bd1158e933dfb1298d94993e9b363675.webp)

Create your plan

Your idea
an app to help track recipes

Target user
a dad

Create plan

Credit to youtube.com/@WebDevCody

Interface text:
projectplannerai.com/dashboard
Project PlannerAI
Plans
Your Plans
Create plan
FashionFinds
[illegible]
convex

### AI-powered voice recorder workflow

The recorder routes transcription through summarization. The summary feeds the application directly and an embedding pipeline that finds related notes. Convex syncs state between backend steps and the application.

[3:34](https://www.youtube.com/watch?v=JbyictbPFV0&t=214s) [Voice recorder workflow from transcription and summarization through embeddings and related notes, alongside bullets about syncing backend state with an application.](https://assets.ai.engineer/sites/aiecode2025/sha256/80caa0b2ae84a412e4e4d1c4b2d104d76c5c606d53717eb3bb63db541a3359c8.webp)

AI-Powered Voice Recorder

ASR (Whisper)
Summarize (GPT-4o)
Generate Embedding (text-embedding-3-small)
Vector Index (Pinecone)
Find related Notes
Application

• “Reaction” by backend functions is effectively workflow
• Convex-style workflow seamlessly syncs state between multi-stage backend task chains and your user application
• This ends up being really, really useful in generative AI apps

Interface text:
AI Engineer World's Fair
Galileo
Microsoft
smol ai

### Generative AI projects on Convex

After the ChatGPT boom, the speaker says 90%+ of projects on Convex are generative AI, including many startups. He links this to syncing state between backend steps and the application.

[3:45](https://www.youtube.com/watch?v=JbyictbPFV0&t=225s) [Slide states that more than 90% of projects on Convex are generative AI projects after ChatGPT.](https://assets.ai.engineer/sites/aiecode2025/sha256/ca98d95e4e40f15ffe4d39eaffc98feb65a1ec5e1c22fdba5c382cad1a4e32df.webp)

Post ChatGPT, 90%+ of projects on Convex are generative AI.
And gen AI startups.

Google Cloud

### Built-in vector search announcement

After developers reported frequently needing vector indexing, Convex added built-in vector search. The Convex 1.2 announcement highlights LLM context and similar-content recommendations.

[3:57](https://www.youtube.com/watch?v=JbyictbPFV0&t=237s) [Slide shows an announcement for Convex 1.2 and describes vector search for AI applications and recommendations.](https://assets.ai.engineer/sites/aiecode2025/sha256/bd61eb249f4378dc0ace4254f853555d82b44c56e7cffd2faa9b27eead87553a.webp)

1. Last year: built-in vector search

SEP 5, 2023   RELEASES
Announcing Convex 1.2

Convex’s vector search enables you to provide useful context to LLMs for AI powered applications, recommendations for similar content and more.

Embedded screenshot: Search; Easy Rider; [illegible]

Interface text: AI Engineer World’s Fair; Galileo; Microsoft; smol ai

### Adding a conventional index

A TypeScript food schema indexes cuisine. Developers asked Convex to add vector indexes alongside its existing field indexes.

[4:07](https://www.youtube.com/watch?v=JbyictbPFV0&t=247s) [Food table schema with an index on the cuisine field.](https://assets.ai.engineer/sites/aiecode2025/sha256/8db128db0d18e12a9ee9cde6299167e2cc6fe58e05d9a9bb0a937f3810b7cbbd.webp)

1. Last year: built-in vector search

defineSchema({
  foods: defineTable({
    description: v.string(),
    cuisine: v.string(),
    embedding: v.array(v.float64()),
  }).index("by_cuisine", ["cuisine"])
});

Interface text:
AI Engineer
World’s Fair

### Last year: built-in vector search

Convex added vector indexes to its TypeScript schema. This example indexes 1,536-dimensional food embeddings and supports filtering by cuisine.

[4:14](https://www.youtube.com/watch?v=JbyictbPFV0&t=254s) [Food table schema with a vector index on embeddings, 1,536 dimensions, and cuisine as a filter field.](https://assets.ai.engineer/sites/aiecode2025/sha256/102ac9efb2d08c87c0a6451c13541f6e5e54135e8161aa3b8eab567b9f315c19.webp)

1. Last year: built-in vector search

defineSchema({
  foods: defineTable({
    description: v.string(),
    cuisine: v.string(),
    embedding: v.array(v.float64()),
  }).vectorIndex("by_embedding", {
    vectorField: "embedding",
    dimensions: 1536,
    filterFields: ["cuisine"],
  })
});

Interface text:
AI Engineer World's Fair

[4:19](https://www.youtube.com/watch?v=JbyictbPFV0&t=259s) [Convex schema code defines a vector index on food embeddings.](https://assets.ai.engineer/sites/aiecode2025/sha256/283026d9a8f0e38356a7d73d1d5599000bffd4bb07b476e9665c8229dd2cdf0d.webp)

1. Last year: built-in vector search

defineSchema({
  foods: defineTable({
    description: v.string(),
    cuisine: v.string(),
    embedding: v.array(v.float64()),
  }).vectorIndex("by_embedding", {
    vectorField: "embedding",
    dimensions: 1536,
    filterFields: ["cuisine"],
  })
});

Interface text:
AI Engineer World's Fair
Galileo
Microsoft
smol ai

### Convex for Startups companies

Convex’s first startup-program cohort includes generative AI companies; the slide shows a selection of company logos.

[4:37](https://www.youtube.com/watch?v=JbyictbPFV0&t=277s) [A grid of company logos under the Convex for Startups heading.](https://assets.ai.engineer/sites/aiecode2025/sha256/e0b0433bc7a70c5b571bfa495d0c60971cda5660aaa2ad5bc7830cdf20282882.webp)

2. Now: Convex for Startups

AI REALITY TV
Cliplama
DATAGEMS
Frame Me
hello wonder
HostAI
Mi Compa
nustom
KIVA
thred

Interface text:
AI Engineer World's Fair

### Soon: Convex AI Components

Convex plans RAG and Model Flow components as building blocks that encapsulate state machines and can be dropped into an app’s backend.

[4:47](https://www.youtube.com/watch?v=JbyictbPFV0&t=287s) [Two puzzle pieces labeled RAG and Model Flow represent Convex AI components.](https://assets.ai.engineer/sites/aiecode2025/sha256/e72e7dd8291062c4ffebe3930cbf41d94468deec5014cab53b5f149603bb8b2d.webp)

3. Soon: Convex AI Components

RAG
Model Flow

Interface text:
AI Engineer World's Fair
Galileo
Microsoft
smol ai

[4:52](https://www.youtube.com/watch?v=JbyictbPFV0&t=292s) [Two puzzle pieces labeled RAG and Model Flow.](https://assets.ai.engineer/sites/aiecode2025/sha256/1fe843367358833194fa5161943f9b59304acf84405992120c8c92c1a34dede1.webp)

3. Soon: Convex AI Components

RAG
Model Flow

Interface text:
AI Engineer World's Fair

### Convex

[5:06](https://www.youtube.com/watch?v=JbyictbPFV0&t=306s) [Closing slide displaying convex.dev.](https://assets.ai.engineer/sites/aiecode2025/sha256/ad75704719b59fb44335fbf20a87847ceba5e9093175729454cee8d06f9267e2.webp)

convex.dev

Interface text:
Cloud
AI Engineer
World’s Fair
Galileo
Microsoft
smol ai

## Full transcript

[0:00](https://www.youtube.com/watch?v=JbyictbPFV0&t=0s) [upbeat music] So, uh, originally I had this very fancy title for this talk, Deterministic Workflow and, uh, I don't know.

[0:19](https://www.youtube.com/watch?v=JbyictbPFV0&t=19s) But what I really wanna title it is, We Accidentally Made an AI Platform and What Are We Gonna Do About It? [clears throat] Convex's true mission, my company, is to replace traditional back-end engineering, uh, all the kinda stuff that we do on back-end engineering.

[0:35](https://www.youtube.com/watch?v=JbyictbPFV0&t=35s) Generative AI, by the way, thinks that fate limiting is one of those things. It's kinda cool. Um, sounds ominous, but, um, it is onimus- ominous, right? So we glue things to things.

[0:45](https://www.youtube.com/watch?v=JbyictbPFV0&t=45s) We configure stuff for, uh, different systems. We map data formats constantly, and a lot of times teams are spending a lot of their time, like half their time on this stuff.

[0:55](https://www.youtube.com/watch?v=JbyictbPFV0&t=55s) It has nothing to do with your product. Your users don't care, and they don't benefit. Um, so we wanna replace all this stuff with a high-level API, kind of functional interface that feels native to your application, similar to something like Firebase or Parse before it.

[1:10](https://www.youtube.com/watch?v=JbyictbPFV0&t=70s) So if you were doing this in the twenty twenties and it was a design exercise, what would you replace all that stuff with? What would that API look like?

[1:18](https://www.youtube.com/watch?v=JbyictbPFV0&t=78s) Well, for us, we took heavy inspiration from React and really more generally, the way that kind of all applications are starting to have this functional reactive data flow relationship to state.

[1:29](https://www.youtube.com/watch?v=JbyictbPFV0&t=89s) Um, if you're not familiar with React, here's a little baby example. You can create a state variable. It has the setter. And what React really empowers is it makes sure that whenever that state changes, all the places that depend on it are updated, re-rendered, um, refreshed.

[1:46](https://www.youtube.com/watch?v=JbyictbPFV0&t=106s) And so in this case, our app would have, "Hi, Olivia," in all caps. The problem is this paradigm breaks down when the server gets involved. The server doesn't play the game this way.

[1:55](https://www.youtube.com/watch?v=JbyictbPFV0&t=115s) You still have to poll the server. You have to invalidate caches. You have to invent your own push mechanisms. So Convex fixes that. So Convex has queries and mutations like other frameworks you may be familiar with.

[2:06](https://www.youtube.com/watch?v=JbyictbPFV0&t=126s) But in Convex's case, it completely tracks pervasively data flow and dependencies through the back end. And so it extends the reactive paradigm into the back end. Um, queries are these universally subscribable app, um, entities that applications can, uh, get updates from as soon as updates are available.

[2:27](https://www.youtube.com/watch?v=JbyictbPFV0&t=147s) So you might say, "What does this have to do with AI?" [chuckles]

[2:31](https://www.youtube.com/watch?v=JbyictbPFV0&t=151s) So what it has to do with is that some of the reacting entities are actually server-side actions. It's not just the application. This may be a kind of architecture you've thought through before or played with, so something like a note-taker.

[2:43](https://www.youtube.com/watch?v=JbyictbPFV0&t=163s) You know, maybe you're doing Automatic speech recognition, and then you summarize it, and you generate Embeddings, and find related notes or whatever. And along the way, th-these different checkpoints, the application sometimes needs to be brought in, show the summary, you know, show related notes, et cetera.

[2:59](https://www.youtube.com/watch?v=JbyictbPFV0&t=179s) Um, but in practice, we find that apps are actually a lot more sophisticated than this. This is a developer named [REDACTED:username] who's building an application on Convex that kinda like generates a first project plan given a prompt.

[3:10](https://www.youtube.com/watch?v=JbyictbPFV0&t=190s) So in this case, he is, uh, an app to track recipes, and when he creates-- hits Create Plan, it's running on Convex. This is sort of like, uh, let's get a bunch of, like, project names.

[3:21](https://www.youtube.com/watch?v=JbyictbPFV0&t=201s) Let's get first features requests, color palettes, icon ideas. All of these, as you can imagine, are kind of concurrent chains that are running in the background, um, and all of them kind of flow into the application as they have results.

[3:35](https://www.youtube.com/watch?v=JbyictbPFV0&t=215s) It ends up that Convex's kind of combination of, like, seamlessly syncing state between these back-end steps, and the application is incredibly useful for a lot of generative AI apps.

[3:45](https://www.youtube.com/watch?v=JbyictbPFV0&t=225s) And for that reason, post-ChatGPT boom, like ninety-plus percent of projects on Convex are generative AI, um, and a lot of generative AI startups. So here's what we're doing about it. [chuckles]

[3:56](https://www.youtube.com/watch?v=JbyictbPFV0&t=236s) So the first thing we did is we got a lot of feedback from developers that one of those steps was always vector indexing or quite often ven- vector indexing.

[4:04](https://www.youtube.com/watch?v=JbyictbPFV0&t=244s) So the developer said, "This is how you make a schema on Convex." It's just TypeScript, type completions, all that good stuff. They said, "Well, you already allow us to add indexes to our fields like this.

[4:15](https://www.youtube.com/watch?v=JbyictbPFV0&t=255s) Could you allow us to add vector indexes?" And so we said, sure. We rolled that out late last year, and it's being used very broadly now by projects on Convex.

[4:24](https://www.youtube.com/watch?v=JbyictbPFV0&t=264s) Uh, the second thing we just did, um, which just kind of announcing right now, is we started a Convex for Startups program. Discount program, kind of access to startup-only forums and events and stuff like that.

[4:37](https://www.youtube.com/watch?v=JbyictbPFV0&t=277s) Um, and the first batch, we just admitted tons and tons of generative AI companies in it. So [chuckles] again, this is sort of like, uh, the, the most engaged, excited, uh, customers right now.

[4:49](https://www.youtube.com/watch?v=JbyictbPFV0&t=289s) And then very soon we're releasing these kind of high-level components. We have this Convex Components framework, which kind of encapsulates whole state machines in these building blocks, so you can easily drop into your app to have your back end encompass these sophisticated workflows that we've de-- co-developed with customers, um, very easily and rapidly.

[5:07](https://www.youtube.com/watch?v=JbyictbPFV0&t=307s) So anyway, that's us. If you're building something cool in generative AI and you wanna sort of ship with confidence and quickly, check us out at convex.dev. Thank you. [upbeat music]
