A2.01 · Value, not tasks · dive 3
The vertical slice
Value cuts through the layers. A story is a thin vertical thread — store, domain, surface — that a role can use end to end.
Its opposite is a horizontal slice: one whole layer, finished in isolation, that no role can demo. Toggle the grid on the right between a vertical thread and a horizontal layer, and read whether a role-usable thread exists.
Vertical thread vs horizontal layer · switch the cut
Value cuts down, not across
The Portal stacks three layers: a store (data and ids), a domain core (the framework-free rules), and a surface (the web app, the bot, the dashboard). Work can be cut through that stack two ways. A horizontal slice is one layer across the whole system — all the tables, the whole domain, the entire web layer. Each is large, each is real, and none is demoable on its own: there is no end-to-end thread a role can pull.
A vertical slice is one thin thread through every layer for a single story: enough store, enough domain, enough surface to let a role do one new thing. It is demoable, because it is end to end. This is the tracer-bullet shape — thin but complete, top to bottom, proving the path before it is widened. Cutting vertically is how value, not effort, becomes the unit of work.
- layers
- The Portal stack: store (data, ids), domain (framework-free rules), surface (web, bot, dashboard).
- horizontal slice
- One whole layer across the system. Large, real, and not demoable — no end-to-end thread.
- vertical slice
- One thin thread through every layer for a single story. Demoable, because it is end to end.
- tracer bullet
- The vertical-slice shape: thin but complete, proving the whole path before widening it.
A vertical slice is exactly the thin, provable rung the loop runs on: complete top to bottom, small enough for one pass, demoable the moment it lands.
Widen story by story
A system built from vertical slices grows differently from one built layer by layer. Each new story adds one thin thread through the layers, and each thread is demoable the day it lands; value accrues one thread at a time, not one layer at a time. The horizontal alternative demos nothing until the last layer crosses every story.
Add the Portal’s learner stories one at a time and read what a learner can do as the threads stack. Each step adds a complete vertical slice; the demoable surface grows downward-complete, never a half-built layer.
Stack vertical slices · add a story
The system grows by stacking thin vertical threads — each demoable the day it lands — not by finishing one horizontal layer that demos nothing until the end.
The vertical slice on the Portal
“A learner browses the catalogue of courses” is a vertical slice. It touches the store (a few courses to list), the domain (the rule that only published courses appear), and the surface (the page that renders them) — a thread thin enough for one rung, complete enough to demo. The horizontal alternative — build every table, then the whole domain, then the whole UI — finishes three large chores and demos nothing until the last one lands.
# Vertical: one thread through every layer for one story → demoable now browse the catalogue: store — domain — surface # spans 3/3 layers · a complete thread # Horizontal: one whole layer across all stories → no thread, nothing to demo store across all stories # spans 1/3 layers · no story end to end domain across all stories # spans 1/3 layers · no story end to end surface across all stories # spans 1/3 layers · no story end to end
The vertical slice demos on day one and widens story by story; the same id authority,
Portal.ID.generate/1, is touched by each thread without ever being a slice of its own.
The Portal’s Elixir and OTP internals — how the store and domain are built — are taught in the
companion Functional Programming course.
The principle
Value is a thin vertical thread through the layers, not a finished horizontal layer; a slice that no role can pull end to end is a chore.
On the Portal
“Browse the catalogue” is one thread through store, domain and surface — demoable now; “build all the tables” is a horizontal layer that demos nothing until the threads cross it.
Cut value vertically: a thin thread through every layer that a role can use end to end — and therefore demo — not a horizontal layer with no thread.
Recap — cut vertically
Value cuts down through the layers, not across one of them. A story is a thin vertical thread a role can use end to end and therefore demo; a horizontal layer is real work with no thread and no demo. The system grows by stacking thin vertical slices, value accruing one thread at a time. This closes A2.01: a unit of work is a unit of demonstrable value — named for a role, ordered by value, cut vertically. The next module gives that slice a shared written form.
Next, module A2.02 · The Connextra form and the three Cs writes the slice down: as a role, a want, and a reason — a card, a conversation, and a confirmation. Return to the A2.01 module hub or the A2 chapter to continue.
References
Sources for the tracer-bullet thread, vertical story slicing, and example-driven acceptance, and where this dive connects in the course.
Sources
- Hunt & Thomas — The Pragmatic Programmer — tracer bullets: a thin, complete, end-to-end thread first.
- Cohn, M. — User Stories Applied — slicing stories so each delivers value end to end.
- Adzic, G. — Specification by Example — a vertical slice specified and accepted by concrete example.
Related in this course
- A2.01 · Value, not tasks — the module hub.
- A2.01.2 · Who benefits — the previous dive.
- A2.01.1 · Outcome, not chore — the demonstrability test.
- A1.04 · Two layers: roadmap and specs — the spec layer each thread feeds.
- A2 · Decomposition — the chapter.
- Companion · Functional Programming in Elixir — the Portal’s layers in Elixir and OTP.