Design that pays the business back.
My process wraps a fast prototype loop in the two things that make it count: research that improves every step after it, and an understanding of the business that points design at retention and growth. Here is how the pieces connect and how I map design work to the value it returns.
01 · The cycle
Prototype the real thing — inside a bigger loop.
The fast prototype loop is the engine, but it only pays off when it sits inside the business it serves: understood at the start, measured at the end, and fed back into the next round.
01
Understand the business
Goals, constraints and how the business makes money set what “better” means.
02
Research
Real users, real data. It gives every later step better material to work with.
03
Prototype, test, iterate
A working prototype in front of real people in the first weeks, then round after round.
04
Ship and measure
Systems, not slides, at hand-off; outcomes measured against the goals we started with.
02 · Delivery flow
Everyone knows what they own.
Here is the cycle as it runs on a real team, practice by practice. I fold it into our flexible delivery model so Product, Delivery, Design and Technology each own their part of the outcome, and the product is defined before it reaches market.
01
Discover & frame
Why, for whom, and is it worth it?
Product & strategy
- Problem statement and target user
- Success metric with a baseline
Delivery
- Kickoff with clear roles per initiative
Design
- User research and insights
- Current journey and pain points
Technology
- Early feasibility read
- Known constraints surfaced
Exit · Frame agreed02
Define & shape
What does good look like?
Product & strategy
- Scope in and out for this slice
- Prioritised roadmap slice
Delivery
- Dependency and risk log
- Capacity check against scope
Design
- Experience requirements
- Design scope or UX flow
- Key flows tested with users on a working prototype
Technology
- Spikes for untested assumptions
- Architecture and API contracts
Exit · Scope frozen03
Refine & ready
Can we build it without guessing?
Product & strategy
- Functional acceptance criteria
- Business logic, permissions, edge rules
Delivery
- Refinement and readiness check
- Next owner named on shared stories
Design
- Figma marked Ready for Dev and linked
- Copy, states and breakpoints specified
- System components and tokens; gaps logged and decided
Technology
- Implementation tasks broken down
- Estimates and risks flagged
Gate · Definition of Ready04
Build
Make it and keep it aligned
Product & strategy
- Open questions answered within a day
- Scope trade-off calls
Delivery
- Unblock and escalate
- Mid-sprint scope change tracked
Design
- Specs walked through with the team
- Figma mirror kept in sync with code
- Versioned change log
Technology
- Build to the linked spec
- Code review and automated tests
Exit · Build complete05
Verify & accept
Does it match the intent?
Product & strategy
- Accept against the acceptance criteria
Delivery
- Done check before merge
- Defect triage with every practice
Design
- Design QA on staging
- Visual defects logged
- Design sign-off before production
Technology
- Functional and regression testing
- Fix or defer logged defects
Gate · Definition of Done06
Release & learn
Did it move the outcome?
Product & strategy
- Go / no-go decision
- Measured against the success metric
Delivery
- Release coordination and comms
- Retro, then process docs updated
Design
- Post-launch UX review
- Design system and Figma mirror updated
Technology
- Deploy and monitor
- Analytics live for the metric
Exit · Outcome measured
Gate · after stage 3
Definition of Ready
Requirements, design and acceptance criteria are clear and aligned. The approved design is linked: a running prototype or story, with Figma frames for the art-directed states. Edge cases defined, every open question answered.
Gate · after stage 5
Definition of Done
The build matches the approved intent across states and breakpoints, uses only system components, and passes accessibility and state checks. Defects are resolved, logged or accepted. Product and Design sign off before production.
03 · Research to outcomes
Better inputs compound.
Research is not a phase to get through. It is the raw material for everything after it: richer artifacts, sturdier structure, better products, and outcomes you can point to. Skip it, and every later step inherits the guess.
01
Research
Real users, real data, real constraints.
Interviews · analytics · field studies
02
Better artifacts
Shared pictures of the problem everyone can act on.
Journey maps · service blueprints · prototypes
03
Better structure
Decisions made once and reused.
Information architecture · design systems · decision frameworks
04
Better products
Fewer dead ends, faster builds, clearer experiences.
Less rework · consistent UI · faster delivery
05
Better outcomes
Results the business can see.
Task success · retention · revenue
04 · Business to retention
Understand the business; keep the customer.
The more I understand a business — its goals, its economics, its customers — the better the design decisions get. Better decisions keep people. Keeping people is what turns into new ones.
01
Know the goals
How the business wins and where it leaks value. Design aims at the problems that matter, not the loudest ones.
02
Keep people
Experiences that solve real jobs earn return visits. Retention is the clearest signal design is working.
03
Win new ones
Retained customers recommend, review and renew. That lowers the cost of acquisition and makes growth compound.
04
Feed it back
Revenue funds the next round; usage data sharpens the next decision. The wheel turns faster each time.
05 · OpEx and CapEx
Design work, mapped to the value it returns.
Some design work runs the business better; some builds what the business will own. I map both from the start, so every activity has a budget line, a value lever and a measure — and design shows up in the business case, not just the backlog.
Stage
Discover and explore
- Discovery research
- Concept exploration
- Prototypes to compare options
- Business case and framing
Stage
Design and build the chosen solution
- Detailed product design
- Design system components that ship
- Interaction and content design in build
- Usability testing during build
Stage
Run and optimise
- Post-launch optimisation
- Internal tools and workflow fixes
- Design ops and tooling
- Support content
OpEx pays back by
Reducing effort
Less rework, fewer support calls, faster teams, lower cost to serve — and fewer wrong things built.
CapEx pays back by
Building assets that win business
New products, platforms and systems the business owns — and sells, retains and grows with.
| Design activity | Budget | Value lever | How we measure it |
|---|---|---|---|
| Discovery research and concept tests | OpEx | Avoid building the wrong thing | Ideas stopped or changed before build; rework avoided |
| Workflow and internal-tool redesign | OpEx | Reduce effort | Task time, handle time, support tickets |
| Design system build | CapEx | Reusable asset | Time to build a feature, adoption, consistency |
| New product or feature design in build | CapEx | Win new business | Conversion, new revenue, new markets |
| Post-launch optimisation | OpEx | Retain customers | Retention, churn, task success |
| Design ops and AI tooling | OpEx | Team efficiency | Cycle time, idea-to-test time |
How a cost is classified is the finance team’s call. Under common software-cost rules (US GAAP ASC 350-40, IFRS IAS 38), discovery and research are usually expensed, while designing and building a chosen solution can often be capitalised. I bring the map so that conversation happens at the start, not at year end.