PROCESS

Here is How to Build

Design

Core

Deepen the direction

With the direction set and agreed, the next work is to deepen it into the backbone. The backbone is the detailed core process, the same core the direction named, now shown in full: every step it passes through, from beginning to end. It is not a new design. It is the direction filled in. The direction was the outline, a line or two of what the core is for and which way it goes; the backbone is that outline drawn out into the complete flow, level by level, until every part of the path the direction promised is on the page.

This is worth holding onto, because it is easy to lose. When the detail arrives, the steps, the teams, the systems, it can begin to feel like a different, larger thing than the simple direction above it, and a designer can drift, deepening into a shape the direction never called for. It does not. The backbone must remain a deepening of the direction and nothing else. If the direction says subscribe, activate, deliver, verify, the backbone shows how each of those four is done in full, and shows only those four, deepened. A backbone that grows a fifth stage the direction never named is no longer a deepening of the direction; it is a new direction, smuggled in below, and the agreement the direction won no longer covers it.

So deepening is disciplined, not free. At every step of it, the designer checks the growing detail against the direction above: does this belong to what the direction promised, or has it wandered? The direction is the test the backbone is measured against, all the way down. Deepen faithfully, and the backbone at the bottom is the same core the direction named at the top, only complete. That faithfulness is what lets the agreement reached at L1 hold all the way to L3: the people who agreed the direction agreed, in effect, to everything that is a true deepening of it, and to nothing that is not.

The highest possible standard is to deepen the direction into the backbone as a faithful filling-in of what the direction named, and nothing more, checking the growing detail against the direction at every step, so the backbone at L3 is the same core the direction set at L1, complete but unchanged.

Key Takeaway: With the direction agreed, the next work is to deepen it into the backbone: the detailed core process, the same core the direction named, now shown in full. It is not a new design but the direction filled in, the outline drawn out into the complete flow. This must be held onto, because detail can drift into a shape the direction never called for. The backbone deepens what the direction named and nothing else: if the direction says subscribe, activate, deliver, verify, the backbone shows those four in full and only those. Deepening is disciplined, checked against the direction all the way down, so the agreement won at L1 holds to L3.

The backbone is the direction filled in, a faithful deepening of what it named and nothing more.

MarvinPro · PROCESS · Here is How to Build · Design · Core · Discipline 4: The Backbone (L1→L3) · Section: Deepen the direction

MarvinPro | September 2026

marvinpro.com

Level by level to L3

The direction is not deepened into the full backbone in one move. It is deepened level by level, and the levels are checkpoints. From the direction at L1, the designer deepens first to L2, a simpler view of the whole, the direction's few stages broken into their main parts, but not yet the full detail. L2 can still be looked at whole and confirmed: it shows enough to see the shape taking form, and little enough to review without drowning. Only once L2 holds does the designer deepen again, to L3, the detailed end-to-end backbone, where every step is drawn out in full.

The levels exist so the deepening can be checked as it goes, and this is why skipping them is a mistake. To jump from the direction straight to full detail is to build the whole backbone before anyone has confirmed the shape between, and if that middle shape is wrong, the full detail built on it is wrong with it. Deepening through L2 first catches the error while it is still cheap to fix, the same economy as setting the direction first, applied one level down. A designer pressed to produce the detailed backbone at once, before the middle level is confirmed, is being pushed to skip the checkpoint that would have caught the fault early. Deepen in order, and each level confirms the one above before the next is built on it.

At L3, the backbone is complete, and complete means it shows everything the core work passes through. It shows every step, in the order they occur. It shows the teams that perform each step, who does what, and where the work passes from one to another. It shows the systems the core runs on, where each step is done and what it is done in. And it shows the known exceptions, the cases the core has already met and understood, marked at the points where they arise, so the backbone shows not only the normal path but the edges the design already knows. The exceptions not yet known do not appear, because they are not yet known; they surface later, in the running of the core, and are folded back in as they become known, at which point the backbone shows them too. So L3 is the full, honest picture of the core as it stands: every step, team, system, and known edge, the complete backbone the rules will govern and the sub-processes will connect to.

The highest possible standard is to deepen the direction level by level, confirming each level before building the next on it, until the L3 backbone shows every step, team, system, and known exception the core work passes through, never skipping the middle level that would catch a fault while it is still cheap to fix.

Key Takeaway: The direction is deepened not in one move but level by level, and the levels are checkpoints. From L1 the designer deepens to L2, a simpler view still reviewable whole, and only once it holds to L3, the full detail. Skipping the middle level builds the whole backbone before the shape between is confirmed, and a wrong middle carries the detail down wrong with it, so deepen in order. At L3 the backbone is complete: every step, the teams that perform each, the systems it runs on, and the known exceptions marked where they arise. The not-yet-known exceptions surface later and fold back in; L3 is the honest picture of the core as it stands.

Deepen level by level, each a checkpoint, until L3 shows every step, team, system, and known exception the core passes through.

MarvinPro · PROCESS · Here is How to Build · Design · Core · Discipline 4: The Backbone (L1→L3) · Section: Level by level to L3

MarvinPro | September 2026

marvinpro.com

Where the backbone ends

The backbone ends at L3, and it is worth being clear about why it ends there and not below. At L3 the core process is complete as a core process: the whole flow is shown, every step, team, system, and known edge, from beginning to end. Nothing about the core itself is missing. What lies below L3 is not more of the core; it is the detail of how each step is performed, and that is a different kind of work, belonging to a different volume.

Below the backbone come the finer levels. There is the view that breaks the backbone down department by department, into the lanes each team owns; and below that, the detailed instructions for performing each step, the click-by-click of the actual doing. These matter, and they must be built, but they are not the backbone, and they are not this volume's work. They are procedures, the how of each step, and they are treated where procedures are treated, in their own volume later in this domain. To pull them into the backbone would be to confuse two things the design keeps apart: the shape of the core, which is L3 and complete here, and the performance of each step, which is finer and comes later. The backbone stops where the core's shape is fully drawn and the detailing of its steps begins.

This boundary keeps the backbone what it is meant to be: the spine. A spine is complete without being exhaustive, it shows the whole structure and where everything attaches, without containing every fibre of every part. The L3 backbone is exactly that: the complete structure of the core, to which the rules attach, at which the exceptions arise, and to which the sub-processes connect, drawn fully enough to hold all of that, and no further. Deepen the direction to L3, and stop. What comes below is real and necessary, but it hangs from the backbone; it is not the backbone, and it is built after the backbone stands, in the volumes made for it.

The highest possible standard is to deepen the core to L3 and stop there, where its shape is complete, leaving the finer detailing of how each step is performed to the volume made for it, so the backbone remains the complete spine of the core and not a container for everything beneath it.

Key Takeaway: The backbone ends at L3, where the core is complete as a core process: the whole flow, every step, team, system, and known edge. What lies below is not more of the core but the detail of how each step is performed, the department-by-department lanes and the click-by-click instructions, which are procedures, treated in their own volume later. Pulling them into the backbone confuses two things the design keeps apart: the shape of the core (L3, complete here) and the performance of each step (finer, later). The backbone is the spine: complete without being exhaustive, showing the whole structure and where everything attaches. Deepen to L3, and stop.

The backbone ends at L3, the complete spine of the core; the finer detail of how each step is done hangs beneath it, in a later volume.

MarvinPro · PROCESS · Here is How to Build · Design · Core · Discipline 4: The Backbone (L1→L3) · Section: Where the backbone ends

MarvinPro | September 2026

marvinpro.com

A real example

Return to the software core, its direction agreed: subscribe, activate, deliver, verify. Now it is deepened. At L2, each of the four becomes its main parts, still a view you can take in whole. Activate, for instance, opens into its main stages: settle the payment, open the account, record the entitlement. Deliver opens into make the software available, and see it downloaded, installed, and logged into. Verify opens into check the subscription's standing, and hold the software back where it has lapsed. That is L2: the direction's four beats, each shown in its main parts, enough to confirm the shape before the full detail is drawn.

Only once that shape held was it deepened to L3, the full backbone. Now each of those parts is shown in full: the exact steps of settling a payment and what happens if it fails; the team that opens the account and the system the account is opened in; the entitlement recorded, in which system, checked by what, at what moments; the delivery mechanism and the login; the standing check that runs for the life of the subscription and the hold-back that follows a lapse. It shows the teams at each step, the systems each runs on, and the known exceptions, the payment that fails, the entitlement that lapses, the download that will not complete, marked where they arise. That is the L3 backbone: the whole core, drawn out, with its known edges on it.

And there it stopped. The backbone did not descend into how a support agent actually clicks through the account-opening screen, nor into the department-by-department lanes of who touches what; that finer detail, the procedures for performing each step, waits for the volume made for it. What this volume produced was the spine: subscribe, activate, deliver, verify, deepened from a one-line direction, through a reviewable middle, into a complete end-to-end backbone showing every step, team, system, and known edge the core work passes through, and stopping exactly where the core's shape was fully drawn. From that spine, everything else in the design will hang.

The direction was deepened level by level into the full L3 backbone, every step, team, system, and known edge, and stopped where the core's shape was complete.

MarvinPro · PROCESS · Here is How to Build · Design · Core · Discipline 4: The Backbone (L1→L3) · A real example

MarvinPro | September 2026

marvinpro.com

The Backbone (L1→L3)

With the direction set and agreed, the next work is to deepen it into the backbone: the detailed core process, the same core the direction named, now shown in full. It is not a new design but the direction filled in, the outline drawn out into the complete flow. And it must stay a deepening of the direction and nothing else: if the direction says subscribe, activate, deliver, verify, the backbone shows those four in full and only those. A backbone that grows a stage the direction never named is a new direction smuggled in below, no longer covered by the agreement the direction won. So the designer checks the growing detail against the direction at every step, and the agreement reached at L1 holds all the way to L3.

The deepening is done level by level, not in one move, and the levels are checkpoints. From L1 the designer deepens to L2, a simpler view of the whole, still reviewable, the direction's stages broken into their main parts; and only once L2 holds, to L3, the full detail. Skipping the middle level builds the whole backbone before the shape between is confirmed, and a wrong middle carries the detail down wrong with it. Deepen in order, and each level confirms the one above before the next is built on it.

At L3 the backbone is complete, and complete means it shows everything the core work passes through: every step, in order; the teams that perform each and where the work passes between them; the systems the core runs on; and the known exceptions, the cases the core has already met, marked where they arise. The exceptions not yet known do not appear; they surface later in the running of the core and are folded back in as they become known, and then the backbone shows them too. So L3 is the honest picture of the core as it stands, the complete backbone the rules will govern, the exceptions edge, and the sub-processes connect to.

And the backbone ends there. Below L3 is not more of the core but the detail of how each step is performed, the department lanes and the click-by-click instructions, which are procedures, treated in their own volume later. The backbone is the spine: complete without being exhaustive, showing the whole structure and where everything attaches. So the discipline is this: deepen the agreed direction faithfully, level by level, confirming each level before the next; carry it to L3, where it shows every step, team, system, and known edge; and stop there, where the core's shape is complete and the detailing of its steps begins. Do this, and the core has a spine, deepened once, on a direction that held, from which the whole rest of the design will hang.

Deepen the agreed direction level by level to the complete L3 backbone, and stop where the core's shape is drawn, so the spine of the whole design stands.

MarvinPro · PROCESS · Here is How to Build · Design · Core · Discipline 4: The Backbone (L1→L3) · Chapter Outcome

MarvinPro | September 2026

marvinpro.com

Think Simple.