How an AI app platform that ships to production actually works. https://adorable.bot/blog 2026-06-15T00:00:00Z https://adorable.bot/blog/adorable-vs-ai-app-builders 2026-06-15T00:00:00Z

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.

The Adorable team https://adorable.bot/blog/anatomy-of-an-ai-app-platform 2026-06-14T00:00:00Z

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.

The Adorable team https://adorable.bot/blog/deploy-is-a-branch-promotion 2026-06-14T00:00:00Z

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.

The Adorable team https://adorable.bot/blog/life-of-a-weekend-app 2026-06-14T00:00:00Z

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.

The Adorable team https://adorable.bot/blog/neon-architecture-for-agentic-workloads 2026-06-14T00:00:00Z

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.

The Adorable team https://adorable.bot/blog/pausing-a-thousand-idle-apps 2026-06-14T00:00:00Z

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.

The Adorable team https://adorable.bot/blog/scale-to-zero-postgres-proxy 2026-06-14T00:00:00Z

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.

The Adorable team https://adorable.bot/blog/the-gravity-of-the-primary-app 2026-06-14T00:00:00Z

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.

The Adorable team https://adorable.bot/blog/the-preview-is-not-the-product 2026-06-14T00:00:00Z

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.

The Adorable team https://adorable.bot/blog/time-travel-for-code-and-data 2026-06-14T00:00:00Z

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.

The Adorable team https://adorable.bot/blog/time-travel-for-the-apps-you-build 2026-06-14T00:00:00Z

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.

The Adorable team https://adorable.bot/blog/what-a-rollback-is-allowed-to-delete 2026-06-14T00:00:00Z

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.

The Adorable team https://adorable.bot/blog/truer-benchmark-than-a-leaderboard 2026-06-12T00:00:00Z

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.

The Adorable team