Skip to content

Strategy & Systems Design

Technical roadmapping: riskiest unknown first, every stage usable

A big project can spend months building before anything works, and find its hardest problem near the end. A roadmap puts the work in a better order: the thing most likely to change the plan gets checked first, and each stage ends with something the business can use. If the work stopped after any stage, you'd still be better off than before it started.
Talk through your plansSee the four stages ↓
firststage 1stage 2stage 3stage 4close-out on sitephotos on the jobinvoices toaccountingapproval over$2,500reminderscustomer accountweekly reportby areacan accountingtake invoices?unknownriskiest unknown firstusable aftera yes or no, earlyusable afterno paper job sheetsusable afterno re-typingusable aftercustomers see their jobusable afterthe owner's weekly viewBefore each stage, the owner reviews what's usable and decides whether to continue

Four stages, each one usable

Each stage ends with something people use the next day, not a component waiting for the rest.
First: can accounting take invoices?a yes or no, before stage 2 is designednothing
1 · Close-out on site, photos on the jobno paper job sheets; photos attached to jobsnothing
2 · Invoices to accounting, approval over $2,500no re-typing into accountingthe first check, and stage 1's job records
3 · Reminders and the customer accountcustomers get reminders and can see their jobstage 1
4 · Weekly report by areathe owner's weekly view, without exportsstages 1 and 2

How the order is decided

Six rules, applied to every roadmap.

  1. 01

    Riskiest unknown first

    Whatever could change the plan

    Checked before anything depends on it, while changing course is still cheap.

  2. 02

    Every stage usable on its own

    Something people use

    Not a database waiting for screens, or screens waiting for data.

  3. 03

    Dependencies before what depends on them

    Drawn, not remembered

    Each stage lists what it needs from earlier ones.

  4. 04

    The old way runs until the new one is proven

    No big switch-over day

    Paper sheets stay available until close-out on site has worked for a while.

  5. 05

    A review before every stage

    The owner decides

    What's usable, what was learned, and whether the next stage still makes sense.

  6. 06

    Changes recorded

    With the reason

    When the plan changes, the roadmap says what changed and why.

When the plan changes

It will. The roadmap is built to absorb it.

Accounting can't take invoices from the backend

  1. First check

    accounting takes files, not a direct connection

    failed

  2. Decision record

    its “revisit if” condition is met

    done

  3. Stage 2 redesigned

    a daily invoice file instead of a live connection

    done

  4. Review

    agree the change before stage 2 starts

    with the owner

Found before anything depended on it, so only one stage changed.

What the roadmap is built from

Built from

Architecture
the parts
Decision records
what each depends on
The business's calendar
busy seasons, staff
Roadmap
stages, dependencies, what's usable, reviews

Starts

The first build
check, then stage 1
Reviews
with the owner
Unknowns list
and how each is checked

Worth doing when the work is too big to do at once

Good fit

  • A big project you'd rather pay for in useful pieces.
  • Several things depend on each other and nobody's sure what goes first.
  • The business can't stop while its systems change.

Not the right fit

  • One small piece of work. Just do it.
  • The order is obvious and nothing depends on anything else.

Where this capability is used

Next to technical roadmapping

Questions about technical roadmapping

How long is each stage?

It depends on what's in it. Each stage is estimated when it's planned in detail, and the review before it is where that's agreed.

Can we change the order later?

Yes, within the dependencies. That's what the reviews between stages are for.

What happens to the old way of working?

It keeps running until the new stage has proven itself, then it's retired.

Why put a check before stage 1?

If accounting couldn't take invoices, stage 2 would need a different design. Finding that out first costs a little. Finding it out in stage 2 costs the stage.