Engineering blog

How the platform actually works.

Deep-tech write-ups for engineers — the wire bytes, the LSNs, and the functions that do the thing. No marketing fluff.

Start here

Most AI app builders stop at the preview. What production actually demands — and the architecture that answers it.

Anatomy of an AI app platform that ships to production

Turning a prompt into a running product is not a model problem — it's a systems problem. This is the map of the whole machine: how a chat message becomes an isolated Kubernetes workload with its own scale-to-zero Postgres branch, why the agent's work is gated by compilers and live probes instead of its own opinion, and how a release becomes a database branch promotion with a rollback anchor. Every other post on this blog zooms into one box of this diagram.

June 14, 2026 10 min read

Part 2ProductArchitectureAI-agents

The preview is not the product

Every AI app builder can show you a running preview minutes after a prompt — generation is the part that got easy. The product is everything that has to hold after a stranger logs in: deploys that don't touch their data, rollback that means something, secrets nobody pasted, an idle cost of zero, and a recovery story for every way a build can die. A tour of the gap, and the design stance that closes it: the agent may be wrong; the platform may not.

June 14, 2026 7 min read

Part 3ProductAI-agentsArchitecture

The life of a weekend app

One Friday evening, one casual paragraph about a ski-trip expense spreadsheet, and a platform doing everything the demo never shows. This is the true story of a single app — real prompts, real timestamps, real money — from first message to a verified, frozen, costs-nothing application. Every stop on the timeline is a door into the machinery that made it boring.

June 14, 2026 10 min read

Part 4ProductArchitectureDeployment

Adorable vs. Lovable, v0, Bolt, and Replit: where your backend actually runs

Every AI app builder now generates a working full-stack app. The category has converged on the easy 80%. What still separates these tools is three questions nobody puts on the landing page: where does your backend code actually run, what does a deploy do to your data, and how many moving parts — services and apps — can one project hold? Measured on those axes across Lovable, v0, Bolt, Replit, and us, the field splits in a way the feature grids hide.

June 15, 2026 10 min read

The database

Copy-on-write Postgres branches, scale-to-zero compute, deploys as branch promotions, and time-travel for the data an agent can break.

Part 1ArchitecturePostgresNeon

Why separated storage/compute Postgres is the right database for AI agents

The entity creating databases is no longer a human filling out a provisioning form — it's an agent, spinning up hundreds of short-lived, mostly-idle databases. That workload breaks the assumptions a traditional Postgres-per-app is built on. Here's why storage/compute separation with copy-on-write branching and scale-to-zero is the architecture that actually fits, mapped primitive-by-primitive to what agents do.

June 14, 2026 10 min read

Part 2ArchitecturePostgresRust

Scale-to-zero Postgres: a Rust proxy that wakes your database mid-connection

Every app on the platform gets its own Postgres that costs nothing while idle — the compute scales to zero. The trick is waking it transparently on the next connection: a Rust proxy speaks the Postgres wire protocol, parks the client, scales a K8s Deployment 0→1, and forwards the query once it's live. Here's the wire parsing, the single-flight wake, and the tokio Notify registration discipline that keeps the wake correct under concurrency.

June 14, 2026 13 min read

Part 3ArchitecturePostgresNeon

Time-travel for code AND data: undoing an AI agent's database mistakes

An AI agent will confidently run a migration that drops the wrong column. Git gives you an undo for code; nothing gives you one for data. Here's how code+data time-travel works on copy-on-write Postgres timelines — the checkpoint-at-LSN, the copy-on-write restore, and the cache coherence that keeps the compute repoint correct.

June 14, 2026 12 min read

Part 4ProductPostgresNeon

Giving the agent an undo button for your data

An AI agent that builds your app also runs migrations, bulk edits, and seeds — destructive operations that git can't undo, because git only versions code. So we gave the agent a data undo it wields itself: it snapshots before a risky operation and rolls back if the operation breaks the data. Here's how it works on copy-on-write Postgres, why restore keeps the same connection string, and why a fleet of these apps costs nothing while idle.

June 14, 2026 8 min read

Part 5ArchitecturePostgresNeon

Deploy is a branch promotion, not a migration

Shipping to production normally means moving data: dump dev, restore into a separate prod database, run the migrations, hope nothing drifted. On copy-on-write Postgres timelines it's a different shape — production is a branch, and going live is a promotion. No bytes move when prod forks from dev's head, re-deploys advance prod and apply only the pending migrations, rollback is a point-in-time branch, and each environment scales to zero independently. Here's the model and the mechanics.

June 14, 2026 9 min read

Part 6ArchitectureGitKubernetes

What a rollback is allowed to delete

A time-travel rollback has to land a project in a coherent state across three very different stores: git source, the live Kubernetes runtime, and a shared Postgres branch. The interesting question isn't "how do we restore" — it's "what are we allowed to physically delete, and how do we stay reversible?" The answer is a single invariant: only remove what is either recoverable from git history or regenerable from the spec, and soft-archive the one relational anchor that ties them together.

June 14, 2026 9 min read

The model

Which LLM drives the agent, how it's routed per task, and why a real bug is a truer benchmark than a leaderboard.

Part 1AI-agentsBenchmarkingModel-routing

A real bug is a truer benchmark than a leaderboard

Every model ships with leaderboard numbers. They measure one-shot deductive puzzles — and tell you almost nothing about how a model behaves when it's stuck on a real problem inside a live system. We got an unplanned head-to-head: the same prompt, the same broken file, the same running app, two models. One burned its entire budget over 51 steps re-deriving cross products by hand and never fixed it; the other fixed it in 19. The gap wasn't raw intelligence. It was *policy when stuck* — and the bug was engineered, by accident, to measure exactly that.

June 12, 2026 14 min read

The runtime

A Kubernetes namespace per app: isolation, lifecycle, secrets, custom domains — the day-2 operations nobody demos.

Part 1ArchitectureMulti-appKubernetes

The gravity of the primary app

A project on this platform isn't one app and one stack — it's N isolated apps and M services sharing a single Kubernetes namespace, all provisioned from a chat message. Once you allow that, almost every bug rhymes: a "new sibling app" silently collapses back into the primary one. This is the story of why that keeps happening, the single principle that fixes the whole class — converge to the declared state at one chokepoint, fail closed instead of falling back to primary — and how the same principle, run in reverse, lets us time-travel the entire stack (code in git, data in a shared Neon branch, and the live K8s infrastructure) back to one coherent moment.

June 14, 2026 14 min read

Part 2ArchitectureKubernetesLinux

Pausing a thousand idle apps: KEDA, CRIU, and the cgroup v2 freezer

Every app on the platform must cost nothing while nobody's looking at it — and come back instantly when someone does. We chose containers over microVMs, then tried three ways to make idle free: scale-to-zero with KEDA, checkpoint/restore with CRIU, and finally the cgroup v2 freezer with swap reclaim. The first two taught us, in very different ways, what the constraint actually was. This is the chronicle of the experiments, the failure modes we hit, and the design that survived.

June 14, 2026 12 min read