learn-metric-decomposition-with-phoebe / Builder session 10 of 10
Learn Metric Decomposition with Phoebe · Builder track · Session 10 of 10

Capstone: diagnose the drop

"Revenue is down 12% this month." That is the whole brief - a mystery, no cause attached. Nine sessions gave you every tool this needs: build the tree, simulate and read the drop, segment in SQL to the guilty slice, then write the one-paragraph narrative that a weekly business review can act on. Today you run the full loop end to end, on the clock, the way a real metric review runs. No new theory - just the method, done for real.

🟠 Builder track Analysts · PMs · founders · ops Live tree simulator + SQL 60 min · capstone
0-5 · The brief 5-20 · Build & read the tree 20-35 · Segment to the culprit 35-60 · Write the narrative
Part 0 · the brief

The mystery: revenue is down 12%

A message lands from your CEO on the first of the month: "Revenue is down 12% versus last month. What happened?" No driver named, no segment, no cause - just the drop and the question. This is the exact moment the whole track was built for. You will not argue about it in a meeting; you will diagnose it in four moves and hand back a paragraph anyone can act on. Everything you need - the three patterns, the leading-versus-lagging lens, the diagnosis playbook, the six domains - collapses into one repeatable loop today.

"Revenue is down 12%" - before and after the App conversion broke ✓ Before: total $208K Web $144K, App $64K Both channels healthy No branch flagged yet ✗ After: total down 12% Web $144K held flat App fell to about $39K Total now about $183K Web held; App conversion broke - the coral trail names the exact branch to segment next.
🔍 Click to zoom - Web holding flat isolates the drop to the App branch alone
Live - presented in session Self-study - read after class ▶ Live tree - editable & runnable Framework sources covered
★ What you walk out with today A repeatable diagnosis loop you can run on any top-line drop: tree -> branch -> segment -> hypothesize -> confirm -> narrate. By the end you can take any metric that falls and hand back a diagnosis with a named driver, a confirmed cause, an owner, and a next step with a date. That paragraph is the job.
Part 1 · the method in one picture

The diagnosis loop and its four questions 5 min live

The whole track reduces to one loop and four questions. Keep this picture in your head and no metric drop can intimidate you again - you always know the next move.

1 · Build tree which branch moved? 2 · Segment which slice fell? 3 · Hypothesize why would it fall? 4 · Confirm does data agree? 5 · Narrate one paragraph, owned Tree points at the branch, SQL finds the slice, a hypothesis explains it, data confirms it - then you narrate.
🔍 Click to zoom - the diagnosis loop: build, segment, hypothesize, confirm, narrate
LiveThe four questions, in order3 min

Every good metric review asks the same four questions in the same order. Skip one and you get a guess; run all four and you get a diagnosis.

  • Q1 - Which branch moved? Build the tree, read the drop, follow the coral trail to the guilty driver. This is Demo 1.
  • Q2 - Which slice fell? Segment the guilty driver by channel, plan, or cohort until one slice owns the fall. This is Demo 2.
  • Q3 - Why would it fall? Form a specific, testable hypothesis about the mechanism - a bug, a price change, a lost campaign.
  • Q4 - Does the data confirm it? Run the one query that proves or kills the hypothesis before you spend a cent fixing anything.
Order is not optional Tree before segment, segment before hypothesis, hypothesis before fix. Analysts who jump straight to SQL waste an afternoon slicing the wrong driver. Let the tree aim you first - it is the cheapest step and it saves every step after it.
Demo 1 of 3 · 15 min

Build and read the tree ★ 15 min · everyone builds

Start with the picture. Revenue splits by channel, and each channel is its own GMV tree: Traffic x Conversion x AOV. Read the baseline, press Simulate a drop, and answer the first two questions of the loop - which branch moved, and by how much. This is a two-level tree, so the coral trail runs from a leaf, up through a channel, to total revenue.

{
  "unit": "$",
  "root": {
    "label": "Revenue", "op": "+",
    "children": [
      {
        "label": "Web GMV", "op": "x",
        "children": [
          { "label": "Web traffic",     "value": 80000, "unit": "visits" },
          { "label": "Web conversion",  "value": 0.03,  "pct": true },
          { "label": "Web AOV",         "value": 60,    "unit": "$" }
        ]
      },
      {
        "label": "App GMV", "op": "x",
        "children": [
          { "label": "App traffic",     "value": 40000, "unit": "visits" },
          { "label": "App conversion",  "value": 0.025, "pct": true },
          { "label": "App AOV",         "value": 64,    "unit": "$" }
        ]
      }
    ]
  }
}

Read the baseline. Web is 80,000 x 3% x $60 = $144K; App is 40,000 x 2.5% x $64 = $64K; total revenue is about $208K at rest.

The baseline: two channels roll up to total revenue Total revenue $208K Web: $144,000 80,000 visits x 3% conversion x $60 AOV App: $64,000 40,000 visits x 2.5% conversion x $64 AOV $144K plus $64K is about $208K at rest - the picture before anything drops.
🔍 Click to zoom - two channel trees, each its own GMV formula, roll up to one number

Simulate a drop. Press the button. One leaf falls and its whole path - leaf, its channel, and total revenue - lights coral. Note which leaf and by what percent.

Q1, which branch? Say it out loud: "Revenue fell X% because [which leaf] in [which channel] fell Y%." That is the first diagnosis question, answered.

Set up Q2. Whatever channel the coral trail lands in is where you point your SQL next. If App conversion fell, you segment the App channel. The tree just told you where to dig.

Worked path for today

Say the simulator (or the CEO's real data) points at App conversion, down sharply, dragging total revenue down 12%. Web held. Q1 is answered: the branch that moved is App conversion. Q2 is now scoped - do not touch Web, do not touch AOV; segment the App channel and find what broke conversion there. Carry that into Demo 2.

Demo 2 of 3 · 15 min

Segment to the culprit ★ 15 min · everyone builds

The tree pointed at a channel. Now SQL finds the slice and confirms the mechanism - questions 3 and 4 of the loop. Run the chain: first revenue by channel to see the fallen slice, then refund rate by channel to test why that channel's conversion or revenue broke. Two queries, and the mystery is solved.

LiveQ2 · Revenue by channel - find the fallen slice5 min

The tree said a channel moved. Confirm it in the data: split completed revenue by channel and see which slice is carrying the fall.

SELECT o.channel,
       COUNT(DISTINCT o.order_id)                 AS orders,
       ROUND(SUM(oi.quantity * oi.unit_price), 0) AS revenue
FROM orders o
JOIN order_items oi ON o.order_id = oi.order_id
WHERE o.status = 'completed'
GROUP BY o.channel
ORDER BY revenue DESC;
LiveQ3-Q4 · Refund rate by channel - confirm the mechanism6 min

Hypothesis (Q3): the fallen channel's revenue dropped because refunds spiked there - a checkout or fulfilment problem, not a demand problem. Confirm it (Q4): compute the refund rate per channel and see if the guilty channel is worse.

SELECT o.channel,
       COUNT(*)                                          AS all_orders,
       COUNT(*) FILTER (WHERE o.status = 'refunded')     AS refunds,
       ROUND(100.0 * COUNT(*) FILTER (WHERE o.status = 'refunded')
             / COUNT(*), 1)                              AS refund_rate_pct
FROM orders o
GROUP BY o.channel
ORDER BY refund_rate_pct DESC;
The diagnosis chain, complete Tree named the branch (App conversion) -> revenue-by-channel confirmed the slice -> a hypothesis named the mechanism (refunds) -> refund-rate-by-channel confirmed or killed it. Four questions, four moves. Now you have a named driver, a named segment, and a confirmed cause - everything the narrative needs.
Demo 3 of 3 · 15 min

Write the narrative ★ 15 min · writing, not code

This last demo is not code. A diagnosis nobody can read is not finished. The deliverable of every metric review is one tight paragraph - the Amazon Weekly Business Review format - that names the drop, the driver, the segment, the confirmed cause, the owner, and the next step with a date. Fill in the template, and you have done the whole job.

LiveThe WBR narrative template4 min

Every metric-review narrative fits one sentence-shaped template. Six blanks, and you filled every one of them in Demos 1 and 2.

The template "Revenue fell [X%] driven by [driver] in [segment], because [confirmed cause]; owner [team]; action [next step] by [date]."
  • [X%] - the top-line move, from the tree.
  • [driver] - the branch that moved, from Q1.
  • [segment] - the slice that owns it, from Q2.
  • [confirmed cause] - the mechanism you proved, from Q3-Q4. Not a guess - a confirmed one.
  • [team] - who owns the driver, so the fix has an address.
  • [next step] by [date] - one action, one deadline. A diagnosis with no action is trivia.
LiveWorked example, filled from Demos 1-23 min

Here is the whole diagnosis in one paragraph, using the numbers you traced today:

Filled in

"Revenue fell 12% driven by conversion in the app channel, because a checkout bug pushed the app refund rate well above web's; owner product; action ship the checkout fix and re-test the app funnel by this Friday."

Read it back against the loop: 12% is the tree, conversion is Q1, app channel is Q2, the refund spike is the confirmed cause from Q3-Q4, product is the owner, and the fix-by-Friday is the action. Nothing vague, nothing unowned, nothing without a date.

Self-studyYour blank to fill8 min write

Now you write one. Run the simulator's drop again in Demo 1, follow it through Demo 2's queries, and fill every blank from your own trace - not from the worked example.

Fill this in "Revenue fell ____% driven by ____ in ____, because ____; owner ____; action ____ by ____."
  • If you cannot fill a blank, you skipped a step - go back and run it. A missing [confirmed cause] means you never ran Q4.
  • Keep it to one paragraph. If it needs two, you are reporting, not diagnosing - cut to the single driver that owns the fall.
  • Read it out loud to a neighbor. If they know what to do next without asking a question, it is done.
Part 3 · wrap

Where this goes next - and what it is not honest close

You now own a loop you will use for the rest of your career. Here is where it lives in a real operating rhythm, and - just as important - an honest list of what this track deliberately did not teach.

LiveRun it weekly, roll it up monthly3 min

The loop is not a one-off. It is a cadence.

  • Weekly: the leader track's a5 turns this into the Weekly Business Review - the same four questions, run every Monday on last week's numbers.
  • Monthly: a6 rolls the weeklies into the monthly review, where you look for the trend under the noise, not just the single drop.
  • Everywhere: the paragraph you wrote today is the atom of both. Trees and queries are the work; the narrative is the deliverable.
Sibling courses

This track reads and decomposes metrics. Its siblings build the rest of the stack: learn-business-intelligence (the dashboards that surface the drop), learn-data-warehouse (where the numbers actually live), learn-marketing-attribution (the marketing-driver depth), and learn-strategic-thinking (the strategy the metrics ultimately serve).

Self-studyThe honest gap list2 min read

What this track is not, said plainly so you are not surprised later:

  • It does not build the data platform. The seed database is a teaching toy. Real pipelines, warehouses, and modeling are the data-engineering and warehouse courses.
  • It does not run the statistics. "Down 12%" here is read at face value. Whether a move is signal or noise - significance testing, confidence intervals, anomaly detection - is a statistics and experimentation course, not this one.
  • It does not fix the problem. The loop ends at a diagnosis and an owner. Shipping the checkout fix is the product team's job; the narrative just routes it there.
  • What it does do - and does well - is turn a vague top-line drop into a specific, owned, confirmed diagnosis in minutes. That skill is the difference between arguing and acting.
Homework · the capstone

Diagnose your own real drop ◐ 30-45 min

Framework sources

Frameworks this capstone draws on

The capstone pulls together every framework the track has taught - decomposition, leading indicators, the review ritual, and the discipline of watching more than one number. This page draws on:

Lean Analytics (Croll & Yoskovitz) - the one metric that matters, decomposedDemo 1 · picking and breaking down the top line that fell
DuPont analysis - the original driver-tree decompositionDemo 1 · the multiply-the-levers move, now second nature
Amplitude North Star Playbook - inputs that lead the outputPart 1 · steer by the leading branches, report the lagging root
Amazon Weekly Business Review - the narrative and the cadenceDemo 3 · the one-paragraph write-up, run weekly (a5) and monthly (a6)
Goodhart's Law - when a measure becomes a targetPart 3 · why you watch more than the single number you are judged on
Check yourself

Three questions before you go 🎯 ◐ 90 seconds

1 · What is the correct order of the diagnosis loop?

Tree before segment, segment before hypothesis, hypothesis before confirmation, then the narrative. The tree is the cheapest step and it aims every step after it - skipping it means slicing the wrong driver.

2 · The tree says App conversion fell. What is the very next move?

Tree points, SQL finds. Once the tree isolates App conversion, you segment only that channel - the tree already told you web and AOV are innocent, so spending effort there is wasted.

3 · What must a finished WBR narrative contain?

A diagnosis with no owner or no action is trivia. The narrative names the driver and segment, states the confirmed (not guessed) cause, assigns a team, and commits to one next step by a date.

The whole method · capstone cheat sheet · pin this

1 · Build the treeWrite the top line as a product, sum, or bridge of its drivers. Read the drop, follow the coral trail to the branch that moved.
2 · Leading vs laggingRoot lags and reports late; leaves lead and warn early. Steer by the leaves, narrate the root.
3 · The three patternsMultiplicative (rate x volume), additive (sum of parts), flow bridge (fills and drains). Pick the one that fits.
4 · The four questionsWhich branch? Which slice? Why would it fall? Does the data confirm it? In that order, every time.
5 · Segment to the culpritTree names the branch; GROUP BY finds the slice. Segment only the guilty driver, never the whole table.
6 · Baseline everythingA drop only means something against a baseline. "Down 12%" needs a versus - last month, last year, plan.
7 · Write the narrativeDrop, driver, segment, confirmed cause, owner, next step, date. One paragraph. The deliverable of the whole loop.
8 · Run it on a cadenceWeekly (a5) and monthly (a6). The loop is a rhythm, not a one-off. You now own it - go diagnose a real drop.