When do you stop pushing a branch of an attack tree deeper?
answer
- depth is a budget, not a target
- spend it where the defender has choices
- same control below? stop
- outside your influence? one leaf, move up
- annotate why the node stopped
basics
~20 sStop when the node already names an action you can cost and defend, when every child would resolve to the same control, or when further detail describes work you cannot influence. Depth is a budget, and uneven depth is expected.
solid answer
~50 sI stop on four triggers. First, actionability: the node already names something an engineer can cost and mitigate. Second, no decision changes: every child would land on the same single control and owner. Third, the branch has left my sphere of influence — decomposing it produces detail I can neither price nor act on. Fourth, I would be inventing: I do not know the component well enough, so I stop and record it as an open assumption rather than fabricate children. The key idea is that depth is a budget I spend where the defender still has choices, so a good tree is deliberately lopsided — one branch may run four levels while its sibling stops at a single leaf. I annotate every deliberate stop with the reason, because six months later a stopped node and an unfinished one look identical.
go deeper
Know that a branch stops when it reaches an action someone can act on, and that trees are not meant to be symmetrical. Do not try to make every branch the same depth.
Be able to state the mechanics of a stop: the node is already actionable, or every child would resolve to the same control. Explain why extra depth below that point adds nothing.
Show the harder call live: a branch whose mitigations sit above it, not below it, stops at one leaf while the conversation moves up a level. Annotate each stop with its reason so a later reader can tell judgment from abandonment.
Own depth as a budget across a portfolio of models: decide where the organisation spends analysis effort, defend deliberate asymmetry to reviewers, and make the annotated stops the backlog that keeps trees living rather than one-off diagrams.
## Depth is a budget, not a target Beginners treat an attack tree like an org chart and try to make it tidy — every branch pushed to roughly the same level. That instinct produces two failures at once: shallow branches get padded with invented children, and the branches that would actually have repaid detail get the same attention as the ones that would not. The useful mental model is the opposite. Depth is a finite budget of attention, spent where the defender still has choices to make. ## Four things that mean stop **1. Actionability reached.** The node names something a competent engineer could cost and act on: a specific action with an implied, ownable control. This is the same granularity test that separates a concrete leaf from a category leaf, read from the other side — the moment it passes, you are done with that line. **2. No decision changes below this point.** If every child you could write would resolve to the same single control with the same owner, the split is decoration. Decompose while the children differ in how you would stop them; stop when they stop differing. **3. The branch has left your sphere of influence.** This is the subtle one, and it is where senior candidates separate themselves. Consider a newsroom's confidential-source submission box hosted on a managed platform. The asset is source identity, and one adversary is the hosting operator itself — compromised, or a party able to compel them. The branch *the provider is compelled or turned* can be decomposed: obtain the platform's records, correlate submission timing, identify the account. But none of those children changes what the newsroom does next. The defender's real moves all sit **above** that node: hold nothing at the provider that identifies a source, strip and expire metadata, split trust so no single operator holds enough. So the branch stops at one leaf, and the design conversation moves up a level instead of down. Further decomposition would have produced pages that no control could ever attach to. **4. You would be inventing.** If the next level requires facts about the component that nobody in the room has, stop. Record the node as an open assumption with an owner, and let it be visibly incomplete. A branch honestly marked *not yet understood* is far safer than a branch padded with plausible-sounding children, because the padding makes an unexamined area look examined. ## Uneven depth is information On the newsroom tree, *compel the provider* stops at depth one while *obtain a copy of submission traffic in transit* runs four levels, because that second branch has genuinely separable actions with genuinely different mitigations. The asymmetry is not sloppiness; it is a readable statement about where the defender has leverage. A reviewer who says 'this branch is underdeveloped' should be answered with the reason, not with padding. ## Record why you stopped The single most valuable habit here is annotating the stop. A leaf that stops because it is actionable, one that stops because it is outside your control, and one that stops because nobody knew the answer are three completely different states — and they render identically as a node with no children. Six months on, with a different reader, an unmarked stop is indistinguishable from an abandoned branch. A one-line reason on the node preserves the judgment: *stopped — no defender-side choice below this point*, or *stopped — needs the platform team, open question*. ## The two costs of getting it wrong Stopping too early leaves category leaves: headings that look like threats, imply no control, and hide the paths underneath them. Stopping too late produces a tree so large nobody finishes reading it, and it also manufactures false confidence — a big tree feels exhaustive, and an exhaustive-feeling tree stops people asking what is missing. Between the two, over-depth is the more expensive failure in practice, because it burns the budget you needed for the branch that mattered and it hides that fact behind volume. ## Revisit the stops, not just the tree Stopping criteria are not permanent. A branch stopped because it was outside your influence becomes worth decomposing the moment you take ownership of that component or change providers; a branch stopped for lack of knowledge reopens when the answer arrives. Treat the annotated stops as the tree's to-do list on the next revision, which is also the cheapest way to make an attack tree a living artifact instead of a one-off diagram.
- A reviewer complains that one branch is far shallower than the rest. How do you answer?I answer with the reason, not with padding. If the shallow branch stops because no child would change a defensive decision, or because the mitigations for it live above the node rather than below it, that is a finding worth stating out loud. Balanced depth is cosmetic. The only thing I would fix is an unannotated stop, which is genuinely indistinguishable from an abandoned branch.
- How do you record a branch you stopped because nobody knew the component well enough?As an explicit open assumption on the node, with an owner and a date, and visibly different from a leaf that stopped because it was already actionable. That way the gap is legible to the next reader and it becomes the first item on the next revision. Padding it with plausible children is the harmful alternative: it makes an unexplored area look explored.
- Does an attacker's high cost at a node justify stopping there?Not structurally. Cost is a prioritisation input, not a stopping rule, and expensive-looking branches routinely hide one cheap child — that is exactly what decomposition exists to surface. I stop for actionability, for no change in defensive decision, for leaving my sphere of influence, or for missing knowledge. If a branch still looks expensive after one more level, I deprioritise it rather than truncate the analysis.
saying these in an interview costs you the question
- Insists every branch be decomposed to equal depth
- Pads a shallow branch with invented children to look thorough
- Deletes a branch it cannot influence instead of stopping and annotating
- Treats a huge tree as evidence of completeness
- Leaves stopped nodes unmarked, so unfinished and finished look identical