The six methods, step by step
Certainty-first · The classic linear model
The Waterfall Method
A linear, phase-gated march that turns a fuzzy problem into a build-ready design, one signed-off step at a time.
Plan it fully, then build it once.
- Time
- Months to years
- Flow
- One phase at a time, front to back
- Best for
- Well-defined, stable scope
- Watch out
- Late feedback — early errors travel far
- Deliverable
- Signed-off spec & high-fidelity design, ready to build
Where it shines. Its discipline makes scope, cost, and timelines easy to plan — each phase produces a finished artifact that feeds the next.
Where it strains. The catch is the same rigidity: validation sits near the end, so mistakes made early can travel a long way downstream before anyone catches them.
Phase 1 · Discovery
01 Discovery & Research
Interviews, competitive audits, analytics, and stakeholder input — gathered before a single solution is sketched.
Goal: Replace assumptions with evidence about who you're designing for and what they genuinely struggle with.
Solves:
- Building for an imagined user instead of a real one
- Solving a problem nobody actually has
- Teams anchoring on the first idea rather than the true need
02 How Might We Statements
Research findings reframed as short, open questions that invite solutions — “How might we…?”
Goal: Turn a defined problem into an actionable, optimistic prompt — broad enough to explore, narrow enough to answer.
Solves:
- Vague problem statements no one can act on
- Jumping to features before the problem is framed
- Scope that's too wide to start or too narrow to innovate
03 Personas
Composite profiles of your key user types — goals, contexts, and frustrations, grounded in the research.
Goal: Give the team a shared, memorable stand-in for real users to design and make decisions against.
Solves:
- “The user” meaning something different to everyone
- Designers unconsciously designing for themselves
- Edge-case debates with no reference point to settle them
04 Journey Maps
A step-by-step map of a persona's experience over time — their actions, thoughts, and emotions at each touchpoint.
Goal: Reveal where the current experience breaks down and where the highest-impact opportunities live.
Solves:
- Screen-by-screen tunnel vision
- Pain points hiding in the gaps between touchpoints
- Prioritizing work without knowing the emotional lows
Phase 2 · Design
05 Information Architecture
The structure, grouping, and labeling of content and features — sitemaps, hierarchies, and navigation models.
Goal: Organize the product so people can find what they need and predict where to go next.
Solves:
- Users getting lost or disoriented
- Features buried where no one thinks to look
- Labels that only make sense to the people who built it
06 User Flows
Diagrams of the paths a user takes to complete a task, including every decision point and branch.
Goal: Define every step, branch, and dead-end of a task before committing time to designing screens.
Solves:
- Missing states and error paths discovered late
- Dead ends that trap the user
- Flows that look fine per-screen but break end-to-end
07 Wireframes
Low-detail layouts showing structure, content priority, and placement — no color, type, or polish.
Goal: Decide what goes on each screen and its hierarchy before investing in visual design.
Solves:
- Debating color and styling before layout is settled
- Misjudged content priority
- Expensive rework once visuals have been applied
08 Wireflows
Wireframes connected by the interactions that move between them — a wireframe and a user flow in one artifact.
Goal: Show how each screen responds to actions, tying layout directly to behavior.
Solves:
- Static screens that hide the interaction logic
- Ambiguity about what a tap or click actually does
- The gap between “what it looks like” and “how it works”
09 Low-Fidelity Mockups
Greyscale, refined layouts with real structure and content but placeholder styling.
Goal: Pressure-test layout, spacing, and content with something close to the real thing — cheaply.
Solves:
- Feedback derailed by unfinished visual details
- Committing to a direction before it's been tested
- Costly changes made at high fidelity instead of low
10 High-Fidelity Mockups
Pixel-accurate designs with final color, typography, imagery, and real components.
Goal: Show exactly how the product will look, applying the full visual and brand system.
Solves:
- Stakeholders unable to picture the finished product
- Inconsistent styling across screens
- Developers left guessing at the intended look
11 Prototype
Clickable, interactive mockups that simulate the real experience — transitions, states, and all.
Goal: Let people actually use the design, so flow and interaction can be felt rather than imagined.
Solves:
- Interaction problems invisible in static screens
- Misread transitions, timing, and feedback
- Sign-off on something no one has actually experienced
12 Usability Testing
Watching real users attempt real tasks with the prototype, and noting where they hesitate or fail.
Goal: Find where the design fails <em>before</em> it's built, with evidence for exactly what to fix.
Solves:
- Shipping avoidable friction to real customers
- Opinion-driven debates with no data to settle them
- Mistaking the designer's familiarity for everyone's clarity
13 Design Handoff
Specs, assets, tokens, and documentation packaged and delivered to the engineering team.
Goal: Give developers everything they need to build the design accurately, without guesswork.
Solves:
- “That's not what I designed” after the build
- Missing states, measurements, and edge cases
- Endless back-and-forth over spacing, color, and behavior
Phase 3 · Build
Handed to engineering.
Certainty-first · UK Design Council
The Double Diamond
Two diamonds of divergent-then-convergent thinking — first explore and frame the right problem, then explore and build the right solution.
Design the right thing, then design the thing right.
- Time
- Weeks to months
- Flow
- Explore, then focus — twice over
- Best for
- When framing needs as much rigor as solving
- Watch out
- Heavy up front; demands real convergence
- Deliverable
- A well-framed problem and a solution proven against it
Where it shines. Gives problem-framing the same rigor as solving — the first diamond guards against building the wrong thing beautifully.
Where it strains. The catch is discipline: each diamond only works if the team truly converges, and it can feel heavy up front for small, well-understood problems.
Diverge · Discover
01 User Research
Broad, open exploration of user needs and behaviors to understand the problem space.
Goal: Explore widely and resist early conclusions — understand the problem before narrowing it.
Solves:
- Solving the wrong problem
- Narrowing before you understand
- Assumptions standing in for evidence
02 Context & Market Scan
Surveying existing solutions, trends, and constraints around the problem.
Goal: Map the landscape you're designing into — what already exists, and why.
Solves:
- Reinventing existing solutions
- Ignoring market and technical constraints
- Blind spots about competitors
03 Stakeholder Interviews
Gathering goals, constraints, and knowledge from across the business.
Goal: Surface internal knowledge and align on what success means before diverging further.
Solves:
- Design colliding with business reality late
- Hidden constraints surfacing too late
- Misaligned definitions of success
Converge · Define
04 Synthesis
Clustering everything discovered into themes and patterns via affinity mapping.
Goal: Converge the wide discovery into a focused set of insights.
Solves:
- A pile of findings with no direction
- Analysis paralysis
- No shared read on what matters
05 Insight Statements
Distilling research into sharp, actionable insights.
Goal: Turn observations into pointed insights that can steer design decisions.
Solves:
- Data without meaning
- Insights too vague to act on
- Losing the thread from research to design
06 Design Brief
A clear articulation of the problem to solve, its scope, and success criteria.
Goal: Lock a shared, well-defined challenge before entering the solution space.
Solves:
- Scope creep
- Teams quietly solving different problems
- No agreed target to aim at
Diverge · Develop
07 Ideation Workshops
Collaborative sessions generating many possible solutions.
Goal: Explore a wide range of solution directions before committing to one.
Solves:
- Betting on one idea too early
- A shallow solution space
- Ideas confined to a single discipline
08 Co-Design & Sketching
Involving users and cross-functional partners in shaping concepts.
Goal: Bring diverse perspectives — including users — into creating the solution.
Solves:
- Designing in a silo
- Solutions users don't recognize
- Late buy-in from partners
09 Prototyping
Making concepts tangible at steadily increasing fidelity.
Goal: Turn promising directions into things people can react to and test.
Solves:
- Debating abstractions
- Untested ideas advancing on opinion
- Costly late-stage changes
10 Iterative Testing
Testing prototypes with users and refining in rounds.
Goal: Let evidence, not opinion, decide which solution direction to carry forward.
Solves:
- Opinion-driven decisions
- Flaws surfacing only after launch
- Falling for an untested favorite
Converge · Deliver
11 Validation Testing
Final rounds of testing the refined solution against the brief.
Goal: Confirm the chosen solution actually solves the problem you defined.
Solves:
- Shipping unvalidated work
- Drift from the original brief
- Undetected usability gaps
12 Refine & Detail
Polishing states, edge cases, content, and visual details.
Goal: Bring the winning solution up to production quality.
Solves:
- Rough edges reaching users
- Neglected edge cases
- Inconsistent final execution
13 Launch & Handoff
Delivering specs and shipping the finished solution.
Goal: Get the validated solution into users' hands cleanly.
Solves:
- Messy handoffs
- Build diverging from design
- Launch-day surprises
14 Measure & Learn
Tracking real-world performance against the success criteria.
Goal: Close the loop — verify the solution works in the wild and capture the lessons.
Solves:
- Launching, then looking away
- No proof of impact
- Lessons lost for next time
Learning-first · IDEO · d.school
Design Thinking
A human-centered, non-linear loop — build deep empathy, frame the real problem, generate widely, prototype fast, and test with people, again and again.
Fall in love with the problem, not the solution.
- Time
- Flexible weeks, looping as needed
- Flow
- Five modes, revisited non-linearly
- Best for
- Ambiguous, deeply human problems
- Watch out
- Can stall in research without a bias to build
- Deliverable
- A tested concept grounded in real human needs, ready to refine
Where it shines. Excels at fuzzy, deeply human problems where the right question isn't yet known — the empathy-first loop keeps solutions grounded in real needs.
Where it strains. The catch is momentum: without a bias toward building, a team can linger in research and never ship.
Phase 1 · Empathize
01 User Interviews
Open, empathetic conversations with real users about their needs, motivations, and frustrations.
Goal: Understand people's lived experience deeply enough to design from their reality, not your assumptions.
Solves:
- Designing from guesswork
- Missing the emotional context behind behavior
- Solving surface symptoms instead of root needs
02 Empathy Maps
A canvas capturing what a user says, thinks, does, and feels.
Goal: Synthesize scattered observations into a shared, vivid picture of the user's inner world.
Solves:
- Raw notes no one can act on
- Focusing on actions while ignoring feelings
- A fragmented view of the user across the team
03 Contextual Observation
Watching users in their real environment as they actually go about the task.
Goal: See what people truly do — not just what they say they do — in their natural context.
Solves:
- The gap between reported and real behavior
- Workarounds you'd never hear about in an interview
- Lab-only insights that don't survive the real world
Phase 2 · Define
04 Affinity Mapping
Clustering research notes into themes to surface patterns.
Goal: Turn a wall of raw observations into a handful of meaningful insights.
Solves:
- Drowning in unstructured data
- Cherry-picking convenient findings
- No shared synthesis to decide from
05 Point of View
A crisp, human-centered problem statement: [user] needs [need] because [insight].
Goal: Lock the team onto one clearly framed, meaningful problem worth solving.
Solves:
- A problem too vague to act on
- Solving for the business instead of the person
- Everyone defining the problem differently
06 How Might We
Reframing the point of view as open, generative questions.
Goal: Open the framed problem into a launchpad for many possible solutions.
Solves:
- Leaping to a single solution too soon
- Questions phrased so narrowly they kill ideas
- Framing that inspires nothing
Phase 3 · Ideate
07 Brainstorming
Rapid, judgment-free generation of many ideas as a group.
Goal: Maximize the quantity and range of ideas before any get filtered.
Solves:
- Anchoring on the first plausible idea
- Self-censoring before ideas are heard
- A narrow solution space
08 Worst Possible Idea
Deliberately generating terrible ideas to loosen thinking and reveal what to avoid.
Goal: Lower the stakes, spark creativity, and expose hidden assumptions by inverting the problem.
Solves:
- Fear of proposing a “bad” idea
- Creative block and blank-page paralysis
- Unexamined assumptions about what “good” means
09 Dot Voting
Each person marks the ideas they find most promising to converge as a group.
Goal: Narrow a huge field of ideas to a few worth prototyping — fairly and fast.
Solves:
- Endless debate over which idea wins
- The loudest voice deciding
- No transparent way to prioritize
Phase 4 · Prototype
10 Paper Prototypes
Fast, rough, hand-drawn versions of an idea made to be reacted to.
Goal: Make an idea tangible in minutes, so it can be tested and thrown away cheaply.
Solves:
- Falling in love with an untested idea
- Over-investing before learning
- Abstract concepts no one can react to
11 Storyboards
Sketching the idea as a sequence of frames showing the user's experience in context.
Goal: Show how a solution plays out over time and in the user's real situation.
Solves:
- Screens divorced from context
- Missing the before-and-after of an experience
- Ideas that ignore the surrounding moment
12 Interactive Prototype
A clickable, higher-fidelity model of the chosen concept.
Goal: Simulate the real experience closely enough to test flow and interaction.
Solves:
- Static mockups that hide interaction issues
- Feedback limited by imagination
- Untested transitions and states
Phase 5 · Test
13 Usability Testing
Watching target users attempt real tasks with the prototype.
Goal: Learn where the concept succeeds and fails against real human behavior.
Solves:
- Assuming the design is intuitive
- Confusing your familiarity for everyone's clarity
- Shipping problems you could have caught
14 Feedback Synthesis
Gathering and clustering what you learned from testing.
Goal: Convert raw test observations into clear, prioritized direction for the next iteration.
Solves:
- Anecdotes overriding patterns
- No clear takeaways from testing
- Learning that evaporates before it's used
15 Iterate
Returning to earlier modes with what you learned — refining, or reframing entirely.
Goal: Treat every result as fuel for the next loop; design thinking is never one-and-done.
Solves:
- Treating the first prototype as final
- Ignoring disconfirming evidence
- Linear thinking on a non-linear problem
↺ Loop back as you learn
Learning-first · Google Ventures · Jake Knapp
The Design Sprint
A five-day workshop that compresses months of debate into one week — build a facade, test it on real customers, decide with evidence.
A week to fast-forward months of debate.
- Time
- Five days, one week
- Flow
- Diverge, then converge on one bet
- Best for
- Big, risky, or contested problems
- Watch out
- A prototype isn't a finished product
- Deliverable
- A tested prototype and a clear go / no-go call on one big bet
Where it shines. Buys certainty cheaply: instead of arguing for a quarter, the team builds a realistic facade and watches five real customers use it.
Where it strains. The limit is scope. A sprint validates a direction rather than shipping one, and five interviews surface big problems far better than subtle ones.
Mon · Map
01 Long-Term Goal
The team writes one optimistic sentence about why this project matters and where you want to be in a year.
Goal: Align everyone on a shared destination before diving into detail, giving the whole week a north star.
Solves:
- The team pulling in different directions
- Short-term thinking crowding out the real ambition
- Losing sight of why the work matters
02 Sprint Questions
Fears and assumptions reframed as questions — “Can we…?” — capturing what must be true to hit the goal.
Goal: Turn anxieties and unknowns into a concrete checklist you can actually answer by Friday.
Solves:
- Unspoken doubts derailing the project later
- Assumptions no one has ever tested
- No shared definition of what success requires
03 Make a Map
A simple diagram of the customer's journey to the goal — actors on the left, the goal on the right, key steps between.
Goal: Give the whole team a shared, at-a-glance model of the problem to focus the week.
Solves:
- Everyone holding a different mental model
- Complexity that's hard to reason about together
- No shared frame for the decisions ahead
04 Ask the Experts
Structured interviews with teammates and stakeholders, capturing insights as “How Might We” notes.
Goal: Pool the team's scattered knowledge and reframe every problem as an opportunity to prioritize.
Solves:
- Critical knowledge trapped in individual heads
- Problems framed as dead-ends
- Expert input that usually arrives too late to matter
05 Pick a Target
The Decider chooses one target customer and one key moment on the map for the sprint to focus on.
Goal: Narrow an ambitious goal to a single, tractable problem you can genuinely solve in a week.
Solves:
- Trying to fix everything at once
- Decision paralysis across too many options
- A sprint with no sharp point of focus
Tue · Sketch
06 Lightning Demos
Everyone shares quick demos of inspiring solutions — from other products, industries, or past work — and captures the good bits.
Goal: Gather a pool of proven ingredients to remix, rather than inventing everything from scratch.
Solves:
- Reinventing the wheel
- A reference pool that's too narrow
- Ideas anchored only on direct competitors
07 Divide or Swarm
The team decides whether to all sketch the same part of the problem or split up to cover different parts of the map.
Goal: Aim the team's effort where it produces the most useful competing ideas.
Solves:
- Redundant, overlapping work
- Important parts of the problem left uncovered
- Unclear ownership of each idea
08 Crazy 8s
Each person sketches eight variations of one idea in eight minutes — one rough concept per folded panel.
Goal: Push past the obvious first idea and generate a range of alternatives, fast.
Solves:
- Settling on the very first idea
- The paralysis of a blank page
- Groupthink converging too early
09 Solution Sketch
Each person makes one detailed, self-explanatory, anonymous sketch of their best idea as a three-panel storyboard.
Goal: Turn abstract ideas into concrete, comparable concepts anyone can judge on their own merits.
Solves:
- Vague verbal ideas that can't be compared
- Loudest-voice-wins dynamics
- Concepts that fall apart the moment they're made specific
Wed · Decide
10 Art Museum & Heat Map
Sketches are posted silently on the wall; everyone reviews them and marks compelling parts with dot stickers.
Goal: Surface the strongest ideas through silent, unbiased review before anyone speaks.
Solves:
- Persuasive talkers swaying the room
- Strong ideas getting overlooked
- Bias from knowing whose sketch is whose
11 Speed Critique
The team walks through each sketch together in a few minutes, narrating standout ideas and noting concerns.
Goal: Quickly build shared understanding of every concept's strengths — without endless debate.
Solves:
- Long, circular discussions
- Ideas being misunderstood
- Concerns that never get voiced
12 Straw Poll & Supervote
Each person casts a quick nonbinding vote, then the Decider casts the deciding “supervotes” on what to prototype.
Goal: Gather the team's input fast, then let one accountable person make the final call.
Solves:
- Design-by-committee
- Endless consensus-seeking
- Decisions that no one actually owns
13 Storyboard
The winning ideas are mapped into a step-by-step storyboard of the prototype, cell by cell.
Goal: Plan exactly what to build so Thursday is pure execution, not decision-making.
Solves:
- Prototyping with no plan
- Unresolved questions surfacing mid-build
- Scope creep once making starts
Thu · Prototype
14 Fake It
Build a realistic-looking facade — not a working product — just enough surface for a customer to react to.
Goal: Create something people treat as real, in a single day, without engineering it for real.
Solves:
- Sinking weeks into building the wrong thing
- Prototypes too rough to test honestly
- Over-engineering before there's any validation
15 Divide & Conquer
Assign roles — Makers, Stitcher, Writer, Asset Collector, Interviewer — so the prototype comes together in parallel.
Goal: Parallelize the build so a convincing prototype is ready by the end of the day.
Solves:
- Bottlenecks when one person builds everything
- Mismatched, inconsistent pieces
- An interviewer who's unprepared for Friday
16 Stitch & Trial Run
The Stitcher assembles the pieces into one seamless flow, and the team does a trial run to catch errors.
Goal: Deliver one coherent, believable artifact and confirm it holds together before customers see it.
Solves:
- Disjointed pieces that break the illusion
- Broken flows mid-interview
- Last-minute surprises on test day
Fri · Test
17 Five Customer Interviews
One-on-one interviews with five target customers, who think aloud as they use the prototype.
Goal: Watch real people react to the solution and hear their unfiltered reasoning.
Solves:
- Guessing at how customers will respond
- Internal opinion standing in for evidence
- Feedback from the wrong audience
18 Find Patterns & Decide
The team watches together, takes notes, and looks for patterns across the five interviews to decide what's next.
Goal: Turn a week of work into a clear, evidence-based call: move forward, fix, or pivot.
Solves:
- Cherry-picked anecdotes driving decisions
- Ending the week with no clear next step
- A week of effort that resolves nothing
Learning-first · Jeff Gothelf
Lean UX
A hypothesis-driven cycle — state your assumptions, turn them into testable bets, build the smallest experiment, and let real behavior decide what's next.
Outcomes over outputs; evidence over opinion.
- Time
- Short, continuous cycles
- Flow
- Hypothesize → build → measure → learn
- Best for
- High uncertainty, need to learn cheaply
- Watch out
- Thin research if 'lean' becomes an excuse
- Deliverable
- Validated learning — evidence for what to build, change, or kill
Where it shines. Built for uncertainty — it chases outcomes over outputs and buys real learning with the smallest possible experiment.
Where it strains. The catch is depth: when “lean” becomes an excuse to skip real research, a team can optimize confidently toward the wrong thing.
Phase 1 · Assumptions
01 Declare Assumptions
The team openly states what it believes about users, needs, and outcomes.
Goal: Get every hidden assumption on the table, so the risky ones can be tested rather than assumed.
Solves:
- Untested beliefs baked into the plan
- Silent disagreements within the team
- Building confidently on guesses
02 Proto-Personas
Provisional, assumption-based sketches of who you're designing for.
Goal: Start with a shared, testable guess at the user — to sharpen with evidence later.
Solves:
- Waiting on lengthy research to start
- No shared user in mind
- Personas treated as fact too soon
03 Outcome Framing
Defining success as a change in user behavior, not a feature shipped.
Goal: Aim the team at outcomes — what users actually do — rather than outputs.
Solves:
- Measuring success by features shipped
- Building things that change nothing
- Losing sight of real impact
Phase 2 · Hypotheses
04 Hypothesis Statements
Reframing work as testable bets: “We believe [this] will achieve [outcome].”
Goal: Turn ideas into falsifiable hypotheses you can prove or disprove.
Solves:
- Ideas that can't be tested
- No clear way to know if you're right
- Opinion-based roadmaps
05 Assumption Prioritization
Ranking assumptions by how risky and how uncertain each one is.
Goal: Focus testing effort on the assumptions that would hurt most if they're wrong.
Solves:
- Testing the safe, easy things
- Big risks going unchecked
- Wasted validation effort
06 Success Metrics
Defining, in advance, the signal that will confirm or kill each hypothesis.
Goal: Decide what evidence counts before you see it, so results aren't argued away later.
Solves:
- Moving the goalposts after seeing data
- Vanity metrics
- No agreed definition of success
Phase 3 · Design
07 Design Studio
The cross-functional team sketches solutions together, fast.
Goal: Generate and align on solution ideas collaboratively, not in a design silo.
Solves:
- Designing alone, then selling it
- Late team buy-in
- A narrow set of ideas
08 Minimum Viable Product
The smallest thing that can test the hypothesis with real users.
Goal: Learn the most while building the least.
Solves:
- Over-building before validating
- Slow, expensive experiments
- Sunk cost in unproven features
09 Shared Style Guide
A living library of reusable UI parts the team assembles from.
Goal: Let the team build experiments fast and consistently.
Solves:
- Rebuilding the UI every experiment
- Inconsistency across quick tests
- Slow iteration
Phase 4 · Experiment
10 Run the Experiment
Putting the MVP in front of real users, in the real world.
Goal: Gather real behavioral evidence for or against the hypothesis.
Solves:
- Deciding from internal opinion
- Lab conditions that don't generalize
- Guessing at real-world response
11 Rapid Research
Quick, lightweight, continuous user research running alongside the experiment.
Goal: Add the “why” behind the numbers — cheaply and continuously.
Solves:
- Metrics with no explanation
- Research too slow to matter
- Losing the human behind the data
Phase 5 · Learn
12 Measure Outcomes
Reading the behavioral signals and metrics against the success criteria.
Goal: See what actually happened when real users met the design.
Solves:
- Ignoring inconvenient data
- Confusing activity for impact
- Decisions made without evidence
13 Validate or Pivot
Deciding, on the evidence, to persevere, refine, or change direction.
Goal: Make an honest, evidence-based call instead of pushing on out of momentum.
Solves:
- Sunk-cost persistence
- Pivoting on a hunch
- Endless building with no decision
14 Iterate
Feeding the learning back into the assumptions and running the loop again.
Goal: Compound learning — each cycle sharpens the next set of bets.
Solves:
- One-shot thinking
- Learning that never updates the plan
- Repeating the same mistakes
↺ Build → measure → learn, repeat
Learning-first · Medlock et al. · Microsoft
The RITE Method
Rapid Iterative Testing and Evaluation — test with a user, fix the problem immediately, then test the fix with the next user, converging in days.
See a problem, fix it, test again — now.
- Time
- Days, back-to-back sessions
- Flow
- Test → diagnose → fix → re-test, fast
- Best for
- Polishing usability with the team watching
- Watch out
- Needs empowered deciders and a quick-to-edit prototype
- Deliverable
- A stabilized design — usability failures fixed and re-verified with fresh users
Where it shines. Problems get fixed as fast as they're found — and the whole team buys in, because they watched it happen live.
Where it strains. It asks a lot of the room: empowered deciders and a quick-to-edit prototype. It also targets clear usability failures far better than deep, open-ended questions.
Phase 1 · Prepare
01 Define Tasks & Criteria
Choosing the tasks users will attempt and agreeing in advance on what counts as a failure.
Goal: Make problems unambiguous, so the team can act the moment one appears.
Solves:
- Debating whether something is really a problem
- Vague test goals
- Missing failures because no one defined them
02 Assemble the Deciders
Getting designers, engineers, and stakeholders observing together, empowered to change the design.
Goal: Put everyone who can diagnose and fix issues in the same room, watching live.
Solves:
- Findings lost in a report no one acts on
- Slow sign-off to make changes
- Developers dismissing second-hand feedback
Phase 2 · Observe
03 Run a Test Session
A single participant attempts the tasks with the current build while the team observes.
Goal: Watch real behavior surface real problems, one user at a time.
Solves:
- Assuming the design is clear
- Problems invisible from the inside
- Guessing where users struggle
04 Diagnose the Failures
Identifying not just what failed but why — is it the interface, the copy, or the flow?
Goal: Pinpoint the cause precisely enough to fix it with confidence.
Solves:
- Treating symptoms instead of causes
- Fixes that miss the real issue
- Endless debate over what went wrong
Phase 3 · Fix
05 Decide to Fix Now
The team agrees on the spot which issues have clear causes and obvious fixes — and commits to them.
Goal: Turn observations into changes immediately, while the evidence is fresh.
Solves:
- Findings piling up unaddressed
- Waiting for a big redesign to fix small things
- Losing the context behind an issue
06 Update the Prototype
Implementing the agreed fixes right away — before the next participant arrives.
Goal: Get the improved design in front of users as fast as possible.
Solves:
- Testing the same broken flow repeatedly
- Slow build-test-build cycles
- Wasting sessions on known problems
Phase 4 · Verify
07 Re-test the Fix
The next participants use the updated version, confirming whether the change actually worked.
Goal: Verify each fix against fresh users instead of assuming it helped.
Solves:
- Fixes that quietly introduce new problems
- Assuming a change worked without proof
- Shipping unverified fixes
08 Repeat Until Stable
Cycling test → fix → re-test until sessions stop turning up new critical issues.
Goal: Converge quickly on a design that reliably works — in days, not months.
Solves:
- One-shot tests that leave problems unfixed
- Slow feedback loops
- Calling it done before the design is stable
↺ Test, fix, re-test — repeat