Skip to content
NEW v0.2.0 — Tracks, roadmaps and tiered stacks
STACK IT FIRST
Install the skills
Browse the site
03 · Backend

Backend

APIs, data pipelines and internal services built around a contract an agent can diff, validate and test before it changes a handler.
9 stacks 4 questions 0 skills

Backends reward exactly the things agents are good at: explicit contracts, repetitive handlers, and code that can be verified by running it. They also punish the thing agents are worst at, which is silent drift between a schema, its validation and its clients. Every recommendation on this track is organised around closing that gap.

The tiers are about how many things break when a contract changes. The profiles are about what the backend is optimised for: latency for a product API, throughput and retries for data work, and speed of change for internal tools.

Stage 1

Where are you?

Backend tiers are about how many things break when a contract changes. The more consumers an API has, the more the agent needs a schema it can diff and tests it can run before touching a handler.
  1. 01

    MVP · Ship it

    One process, one file-based or hosted database, a schema-validated router.

    A handful of clients, usually your own app · You, plus an agent

    Open tier
  2. 02

    Growth · Charge for it

    One service with modules, managed Postgres, a queue, and an OpenAPI contract.

    Several clients, some you do not control · Two to five engineers, each with agents

    Open tier
  3. 03

    Scale · Run it for many

    Compiled, typed services behind explicit contracts, with observability built in.

    Many clients across products · Six or more engineers across teams

    Open tier
Stage 2

What are you building?

The profile decides what the backend is optimised for: request latency for a product, throughput and retries for data work, or speed of change for internal tools.
Walk the roadmap
Tier Product API serves web & mobile Data & AI pipelines & jobs Internal tools & automation
01 MVP Ship it Bun + Hono + SQLite 5/5 FastAPI + Pydantic + Postgres 5/5 Hono + SQLite + server-rendered HTML 5/5
02 Growth Charge for it NestJS + Postgres + Redis 5/5 LangGraph + FastAPI + Postgres 4/5 Django + Postgres + Redis 5/5
03 Scale Run it for many Go services + Postgres, Rust where latency is the product 4/5 ClickHouse + a typed ingestion layer + Postgres 3/5 Rails + Postgres + Redis 5/5
Backend rules

Five rules for this track.

On top of the nine cross-track principles.
  1. 01

    The schema is the source of truth

    Database schema, request validation and generated types should come from one definition. An agent that can trace a field from the migration to the response never invents a shape.

  2. 02

    One process until it hurts

    A single service with clear modules is easier for an agent to reason about than a handful of small ones. Split only when teams, regions or compliance force explicit boundaries.

  3. 03

    Typed, compiled, or both

    TypeScript with strict mode, Python with Pydantic, or Go. Dynamic, untyped handlers are where agents introduce the bugs that tests do not catch.

  4. 04

    Every side effect is a job

    Emails, webhooks and long work go through a queue with retries. It keeps handlers small enough for the agent to read whole, and makes failures visible.

  5. 05

    Tests the agent runs before you do

    A fast integration suite against a real database, runnable per file, is the single biggest lever for agent-written backend code. Mock only the network.

The nine cross-track principles