The Enterprise Value Tree

01 What it is

Strategy, turned into numbers

Strategy meetings talk in words. Performance meetings talk in numbers. The value tree is where the two meet.

Read it downwards to find a problem: value is down, profit held up, so it must be cash — and cash is down because customers are paying later. Read it upwards to make a case: this price change adds €1.9m of profit, and that is 3% of what the business is worth.

The tree has one number at the top and three branches under it. Revenue is what you charge times what you sell. Cost is what it takes to operate. Cash is what actually reaches the bank. Revenue minus cost is profit, and cash divided by profit shows how much of that profit is real money. Below revenue sits the strategy layer: STP decides where you compete, 3C checks whether you can win there, and 4P is what you actually do. That is why a marketing framework and a finance model end up on the same page.

One more thing about the formula at the top. Value = profit + cash efficiency adds money to a ratio, so you can't actually calculate it. It's a reminder that both halves matter: earning the profit, and turning it into cash. The sums that really do work sit one level down, and those are the ones worth measuring: revenue − cost = profit, price × quantity = revenue, cash ÷ profit = cash conversion. If the maths in your tree is honest, it will survive an audit. If it isn't, people stop using it within a couple of quarters.

02 The whole tree

One number at the top, three branches below

Here is the whole thing on one picture. Every box is a number you can define once and reuse everywhere. The sections after this take each branch in turn.

Solid lines mean the maths works: the box above is exactly the boxes below, added or multiplied together. Dashed lines and dashed boxes are background — formulas, goals, and the things that push a branch around without adding up to it. The three panels along the bottom use the colour of the branch they belong to.

03 Revenue

Price × Quantity — and don't mix them up

Revenue is up 10%. That tells you very little until you know whether it came from charging more or selling more. Money from a price rise is nearly all profit. Money from extra volume brings extra cost with it, so it usually delivers about a third as much. Mixing the two up is the most common and most expensive mistake in performance reporting — which is why the first split under revenue is always price and quantity, and why the worked example pulls them apart.

What moves price

Price isn't one number. There's the list price, the price on the invoice, and what's left after rebates, allowances and payment terms. Most of the money leaks out in the gap between the first and the last.

What moves quantity

Quantity breaks down further than most teams take it. Units = market size × your share. Or customers × how often they buy × how much they buy each time. Either works. Pick the one that matches how you actually run the business, and stick to it.

04 The foundation

STP decides where, 3C decides how, 4P decides what

These three frameworks aren't rivals and they aren't decoration. Each answers a different question, and each one lands on a specific box in the tree. STP picks the ground. 3C checks you can win on it. 4P is what you actually do about it.

05 Cost

What it takes to operate — and what you can actually change

Cost splits two ways at once, and you need both views. By type: direct cost, operating cost, and the efficiency that runs through both. By control: what you decide this quarter, what an old decision locked in, and what the world does to you. Cost programmes fall apart when a team is measured on a number that inflation and exchange rates are moving.

A quick test for any cost box: can you name the person who'd be asked to fix it, and the report they'd open? Overhead spread across four business units by headcount fails that test. Nobody owns it, so nobody moves it. Either push it down to something a real person controls, or leave it unallocated and be honest about it.

06 Cash

Profit is an opinion. Cash is a fact.

Profit depends on judgements — when you count revenue, how you spread costs, what you set aside for later. Cash is a bank balance. Companies do go under while reporting a profit, and this is the branch that catches it. Cash splits into three flows that together explain every movement in the balance.

07 How to build one

Six steps, in this order

You build a value tree once and then live with it, so the order matters. Break the number down before you measure it, and measure it before you set targets. Do it the other way round and you end up with a tree shaped by whatever data happened to be easy to get.

08 What good looks like

Eight habits worth copying

09 Connecting it to data

From a drawing on a whiteboard to numbers you can trust

Most value trees die somewhere between the offsite and the first month-end, and it's nearly always the same reason: the boxes were never connected to data that anyone maintains. Two teams work out "net revenue" differently, the walk stops adding up, and the tree quietly turns into a slide.

Connecting it is a modelling job — the same job the rest of the Academy teaches. Each box becomes a governed metric, and a governed metric needs four things: a formula, a level of detail, a source and an owner.

Read each row as a promise: this box means exactly this formula, at this level of detail, from this system. Where two boxes share a source — price and revenue both come from the invoice line — they have to use the same set of rows, or the tree won't add up.

Four ways it goes wrong

10 Worked example

A packaging maker, one year apart

The figures are made up; the method is the point. Revenue rose 9.6% and everyone was pleased. The tree asks two questions the headline can't answer: which half of revenue did it come from, and where did the money end up?

Question one: which half? Split the €4.4m increase into the part that came from price, the part from volume, and the bit where both moved together.

Selling more looked like the bigger win — €2.40m against €1.90m — but it produced less than half the profit, because every extra unit took 64% of its own revenue straight back out in cost. The same pattern shows up if you nudge each lever by 1%: price +1% is worth €0.50m of profit (8.3% of the total), volume +1% is worth €0.18m, and cutting direct cost by 1% is worth €0.32m. Price is roughly three times the lever that volume is.

Question two: where did the money go? Profit was €6.0m. Cash from operations was €4.2m. That's a cash conversion of 0.70 — below 1.0, so the profit isn't turning into cash.

Nine extra days of customer credit on €50m of revenue is €1.23m — a day of revenue is €137k, and that's the whole calculation. So the tree's verdict is: the price rise was the real win, the volume push was expensive, and most of the year's improvement is currently sitting in customers' bank accounts rather than yours. Three different people to talk to, all on one page.

11 Developer lab

Hands-on: build the tree as real metrics

# the one people get wrong: price is a ratio, not a column
metrics:
  - name: avg_net_price
    type: ratio
    type_params:
      numerator: net_revenue
      denominator: units

semantic_models:
  - name: invoice_lines
    model: ref('fct_invoice_lines')
    entities:
      - { name: invoice_line_id, type: primary }
      - { name: customer, type: foreign, expr: customer_id }
      - { name: product,  type: foreign, expr: product_id }
    dimensions:
      - name: invoiced_at
        type: time
        type_params: { time_granularity: day }
      - { name: product_tier, type: categorical }
    measures:
      # what counts and what doesn't belongs here, not in each dashboard
      - { name: net_revenue,  agg: sum, expr: "net_amount" }
      - { name: list_revenue, agg: sum, expr: "list_price * billed_qty" }
      - { name: units,        agg: sum, expr: "billed_qty" }

metrics:
  - name: avg_net_price                # the PRICE box
    type: ratio
    type_params: { numerator: net_revenue, denominator: units }
  - name: gross_to_net_pct             # how much of list price you keep
    type: ratio
    type_params: { numerator: net_revenue, denominator: list_revenue }
  - name: operating_profit              # the PROFIT box
    type: derived
    type_params:
      expr: "net_revenue - total_cost"
      metrics: [ { name: net_revenue }, { name: total_cost } ]

-- Split a change in revenue into price, volume and mix.
-- Measure price and volume at last year's weights, then let mix be
-- whatever is left over -- that way the parts always add to the whole.
WITH by_product AS (
  SELECT product_id,
         SUM(CASE WHEN yr = 2025 THEN net_amount END) AS rev_py,
         SUM(CASE WHEN yr = 2026 THEN net_amount END) AS rev_cy,
         SUM(CASE WHEN yr = 2025 THEN billed_qty END) AS qty_py,
         SUM(CASE WHEN yr = 2026 THEN billed_qty END) AS qty_cy
  FROM fct_invoice_lines GROUP BY 1
), p AS (
  SELECT *, rev_py / NULLIF(qty_py, 0) AS price_py,
            rev_cy / NULLIF(qty_cy, 0) AS price_cy
  FROM by_product
)
SELECT
  SUM((price_cy - price_py) * qty_py)              AS price_effect,
  SUM((qty_cy   - qty_py)   * price_py)            AS volume_effect,
  SUM((price_cy - price_py) * (qty_cy - qty_py))  AS interaction,
  SUM(rev_cy) - SUM(rev_py)                        AS total_movement
FROM p;   -- the first three must add up to the last one

# Which lever is worth pulling? Move each one 1% and compare.
price, units = 12.50, 4_000_000
var_cost_per_unit, fixed_cost = 8.00, 12_000_000

def profit(p=price, u=units, v=var_cost_per_unit, f=fixed_cost):
    return p * u - (v * u + f)

base = profit()
levers = {
    "price +1%":        profit(p=price * 1.01),
    "volume +1%":       profit(u=units * 1.01),
    "direct cost -1%": profit(v=var_cost_per_unit * 0.99),
    "fixed cost -1%":  profit(f=fixed_cost * 0.99),
}
for name, p in sorted(levers.items(), key=lambda kv: -kv[1]):
    print(f"{name:<18} {p - base:>12,.0f}  ({(p / base - 1) * 100:>5.1f}% of profit)")

# price +1%          500,000  (  8.3% of profit)   <- the order is the point
# direct cost -1%    320,000  (  5.3% of profit)
# volume +1%         180,000  (  3.0% of profit)
# fixed cost -1%     120,000  (  2.0% of profit)

The YAML makes price a ratio, so two reports can't disagree about it. The SQL makes sure the walk adds up. The Python turns the tree into a ranked list of where to spend the quarter. Define, check, rank — that's the whole job.

12 Analyst lab

Hands-on: draw your own, then defend it

13 Skill matrix

Rate yourself, then aim one column right

Find the row that describes you today, and use the next column as the goal.

14 Glossary

Terms worth knowing

15 Test yourself

Five quick questions

16 Keep learning

Where to go next

A value tree is only as good as the definitions underneath it. These tracks are how each box becomes a number you can defend: