Product Design · A Field Guide

Design Methodologies

Six ways to make a product, grouped by the one question behind them all — how much do you already know, and how fast must you learn? Compare them below, then open any method to walk its process step by step.

Six ideas over time

When each approach emerged and how long it's endured — the plan-driven default of 1970, then a burst of learning- and adapt-first methods in the 2000s. Select a method to expand it, or open its full process.

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

  1. 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
  2. 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
  3. 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
  4. 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

  1. 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
  2. 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
  3. 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
  4. 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”
  5. 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
  6. 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
  7. 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
  8. 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
  9. 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

  1. 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
  2. 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
  3. 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

  1. 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
  2. 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
  3. 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

  1. 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
  2. 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
  3. 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
  4. 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

  1. 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
  2. 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
  3. 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
  4. 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

  1. 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
  2. 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
  3. 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

  1. 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
  2. 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
  3. 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

  1. 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
  2. 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
  3. 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

  1. 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
  2. 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
  3. 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

  1. 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
  2. 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
  3. 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

  1. 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
  2. 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
  3. 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
  4. 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
  5. 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

  1. 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
  2. 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
  3. 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
  4. 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

  1. 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
  2. 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
  3. 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
  4. 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

  1. 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
  2. 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
  3. 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

  1. 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
  2. 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

  1. 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
  2. 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
  3. 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

  1. 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
  2. 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
  3. 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

  1. 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
  2. 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
  3. 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

  1. 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
  2. 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

  1. 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
  2. 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
  3. 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

  1. 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
  2. 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

  1. 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
  2. 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

  1. 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
  2. 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

  1. 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
  2. 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