Thin, not shallow

Thin describes a slice's shape, not its breadth. A vertical slice takes one capability and crosses every layer once — from the request, through the facade, to a rendered response. It is small in breadth and complete in depth, so it ships a usable thread and surfaces integration risk the moment it lands.

A horizontal layer does the opposite: it builds one layer broadly — all the database tables, or all the templates — with no thread connecting them. It is large in breadth and zero in depth. It cannot demo, proves nothing on its own, and hides every integration risk until the layers are finally wired together at the end. That is why a roadmap of vertical slices ships value continuously and a roadmap of horizontal layers ships nothing until the last day.

Getting the shape right — vertical, not horizontal — is only half the line. The other half is quality. A vertical thread that ships with no automated test, no compile-time gate, and no contract guard looks like a thin slice but behaves like a draft: the first change breaks it silently, and it has to be redone. That is flimsy.

The flimsy detector below takes a set of slices that are all vertical in shape and reports which are thin-but-robust and which are flimsy — naming the quality each is missing. The two figures teach different moves: the hero contrasts the shape of a slice (vertical versus horizontal), this one holds the shape fixed and tests its quality.

On the Portal — the learning platform this course builds — the web chapter F6 opens with the thinnest possible vertical thread. f6.1 is “the engine served as a web app (endpoint, request → facade → render)”: it does almost nothing — hit the root, see a page — but it runs through every layer once. It ships before persistence (f6.3) and before the rendered catalog (f6.5), which is exactly what makes it thin.

The horizontal alternative — build the whole schema first, or all the templates first — would demo nothing and defer the request → facade → render integration to the very end. F6 takes the vertical cut instead, and the slice stays robust because it holds the master invariant: it calls only the facade and renders only the closed error set.

# A vertical slice crosses every layer once; a horizontal layer crosses none.
#   vertical (thin)    : request → facade → render   — ships a thread, demos
#   horizontal (shallow): all schema, or all templates — ships nothing, defers risk

# The f6.1 tracer is the thinnest vertical thread, shipped before depth.
slice = "f6.1 — the engine served as a web app"
shape     = :vertical      # one capability, end to end
ships     = true           # hit the root, see a page
robust?   = true           # harnessed + gated + over the facade

# Shape (vertical) is necessary but not sufficient — quality makes it robust, not flimsy.

A thin slice is vertical: one capability crossing every layer once, small in breadth and complete in depth, shipping a usable thread and surfacing risk early. A shallow layer is horizontal: broad but threadless, demoing nothing and deferring risk to the end. And a vertical thread that skips a harness, a gate, or a contract guard is flimsy — thin in shape but a draft to be redone. With the shape settled, the next dive lists the seven properties that make a thin slice robust.

The sources behind the vertical-slice discipline, and where it connects in the course.