Paper Prototyping

Hands holding a phone-shaped paper cutout with hand-drawn UI elements

In Brief

Paper prototyping is a low-fidelity usability test where you draw screens or interface elements on paper and have a real user interact with them as if they were a working product. One person acts as the user while another swaps paper screens in response to each action, simulating the product’s behavior. The output is direct observation of where users get confused, stuck, or surprised — giving you design feedback in minutes without writing any code.

Common Use Case

You have multiple design directions for a key part of your product and you are not sure which one makes sense to users. Before investing in a digital prototype, you want fast, cheap feedback from real people. You put rough paper sketches in front of them and watch where they tap, hesitate, or get confused.

Helps Answer

  • What basic shape might our solution take?
  • Where do users get stuck or confused in our design?
  • Is our product intuitive enough to use without instructions?
  • Are there situations or errors we did not think of?
  • What information do users need to complete a task?
Anywhere from a few minutes to several days. As a formal usability-testing approach, more time may be needed for advance planning of customer time and more complex preparation of mockups and scenarios. It can also be used in the moment as part of generative design work, with very little prep, in the time it takes to produce a few rough sketches and test them for weaknesses. AI tools like v0 or Figma AI can generate initial wireframe sketches from text descriptions, reducing prep time for more complex prototypes.
Paper prototyping requires virtually no cost beyond paper, markers, and scissors. Printable device templates are available for free online. For remote sessions, tools like Marvel let you photograph paper sketches and make them tappable on a phone.

Description

Paper prototyping is a low-fidelity usability test where hand-drawn screens stand in for a working interface. A real user attempts a real task, tapping or pointing at the paper. A second person — the “computer” — swaps screens or moves cutouts in response to each action, simulating how the product would behave. A facilitator coaches the user to think aloud; one or more observers take notes. The technique is documented end-to-end by Carolyn Snyder in Paper Prototyping — Carolyn Snyder, Morgan Kaufmann 2003, which traces the method back to Wizard-of-Oz studies in human–computer interaction.

Use paper prototyping when the questions you have are about flow and structure: does the user understand what to do next, do they look in the right place for a function, do they recognize the labels you chose. The empirical case for using paper at all comes from Marc Rettig’s Prototyping for Tiny Fingers — Marc Rettig, CACM 1994, which argued — and was later widely confirmed — that low-fidelity paper sessions surface substantially the same usability defects as code-based prototypes, at a fraction of the cost. Paper is the wrong tool when the question is about visual placement, scroll behavior, animation, micro-interactions, or anything keyboard- and pointer-specific. For those, you need a clickable prototype or the real thing. Bill Buxton’s Sketching User Experiences — Bill Buxton, Morgan Kaufmann 2007 makes the same point from the design side: a sketch is meant to invite change, a finished mockup is meant to defend a decision, and confusing the two costs you the feedback you came for.

AI wireframe tools — v0, Figma AI, Galileo and similar — can collapse the prep cost of a “paper” prototype to a few minutes. The trade-off is that their default output looks polished enough to push testers into design feedback (color, typography, layout opinion) instead of flow feedback (where they got stuck, what they expected to happen). If you go that route, deliberately strip the fidelity back: turn off color, replace real copy with placeholder text, and tell the participant up front that the visual treatment is not the subject of the test.

How to

Prep

  1. Define the task. Write the user task you are testing in one sentence — for example, “A first-time user signs up and creates their first project.” If you cannot state it in one sentence, you are testing too many things at once.
  2. Sketch the happy path, then the branches. Draw the screens a user sees when they complete the task without trouble. Then add screens for the most likely error or branch states (validation failure, empty state, “not found”). Keep the fidelity deliberately rough; per Buxton, polished sketches invite the wrong kind of feedback.
  3. Recruit five testers who match your real user. Snyder’s working number is five participants per round — beyond that, new defects arrive slowly. The catch is selection bias: five people who already understand your domain will not surface the issues a real beginner would. Recruit against the actual target user, not your network.
  4. Assign roles before the session. Decide in advance who plays the “computer” (swaps screens, never speaks), who facilitates (prompts the user to think aloud, stays neutral on the design), and who observes (takes notes, watches body language). Mixing these roles mid-session is how facilitators accidentally lead the user.
  5. Pilot once internally. Run the full script on a teammate who has not seen the screens. You are looking for missing screens, ambiguous prompts, and any place the “computer” has to improvise — those are the screens you forgot to draw.
  6. Decide how you will capture data. Pick one of: a written defect log per session, a photo of every screen state the user reached, or a recorded screen of a tappable digital version. You only need one — pick before you start.

Execution

  1. For each screen or interface state in the task, lay out the paper mockup illustrating what the user would see. For quick internal ideation, paper is faster than any digital tool — you can sketch, rearrange, and discard in real time with no overhead. For external sessions (especially remote ones), an AI-generated low-fidelity wireframe from a tool like v0 or Figma AI is easier to share and modify between sessions. In either case, keep fidelity deliberately rough: if participants start commenting on visual polish rather than flow and structure, the prototype is over-engineered.
  2. One person (or a pair) plays the customer.
  3. Another person (or several) plays the “computer” — the software simulator.
  4. The customer interacts with the paper prototype as if it were a real application, physically tapping or pointing at the interface. Encourage them to explain their thinking aloud as much as possible.
  5. For each action the customer takes, the computer moves or swaps the paper to reflect the new state. As a general rule, the computer does not talk. Per Snyder, breaking that rule is the most common way a paper-prototype session collapses into a tutorial.
  6. For more formal sessions, observers watch for additional insights and capture notes. A facilitator may also be useful, prompting the customer to ask questions and think aloud without coaching them through the flow.
  7. If a layout or interaction clearly is not working, mock up an alternate flow on the spot and re-run the same task. Paper is cheap; that’s the point.

Analysis

You are looking for places where the customer got stuck, could not find what they were looking for, or accidentally went down the wrong path. Anything misleading, confusing, or hard to find is noteworthy. For each, dig into what information the customer was missing that led to the confusion and how that information could be provided — or how the need for it could be eliminated. Watch for situations where the response by the “computer” was not defined, or where an action was possible that you did not want to be possible. Also revisit assumptions about the customer’s motivations and the knowledge or experience base they bring; the test will often expose assumptions that did not hold and suggest ways to improve the solution.

Cluster the friction observations across all five sessions before deciding what to change. A single confused tester might be noise; the same hesitation in three out of five is a defect. Rettig’s original argument was specifically that low-fidelity sessions catch substantially the same defects as high-fidelity ones — so trust what you saw, and do not wait for a polished prototype to “really” test it.

Biases & Tips
  • Confirmation bias A facilitator or other participant who knows the software too well can drop “hints” that lead the customer through the flow. Brief facilitators to stay neutral, read prompts as written, and respond to questions with “What would you expect?” rather than an answer.
  • Social desirability bias Customers may hide feedback when they are worried about appearing incompetent or offending the team. Reassure them up front that you are testing the design, not the user, and that confusion is data you need.
  • Selection bias If the test user is more experienced than the real audience, you will miss issues a less savvy user would have surfaced. Recruit testers who match the actual target user, not whoever is convenient.
  • Fidelity drift Paper prototypes can miss fine-grained usability issues like placement, pixel-level alignment, scroll behavior, animation, and keyboard or pointer interactions. Move to a clickable prototype or a coded build for that level of detail.
  • Over-polished AI prototypes AI wireframe tools can produce outputs that look finished enough to distract testers into giving visual feedback rather than flow feedback. If using an AI-generated prototype, deliberately reduce its fidelity (strip color, use placeholder text, remove brand marks) before testing.

Next Steps

  • Iterate the paper prototype based on test findings before going digital.
  • If the core flow works, create a Clickable Prototype for wider testing.
  • Share paper-prototype photos with the team to align on the design direction.
  • Use Usability Testing with a higher-fidelity prototype to confirm the flows that worked on paper still work on screen.
  • Run a Solution Interview to confirm that the design direction addresses the underlying customer problem before investing in development.
Learn more

Case Studies

PalmPilot

Jeff Hawkins is widely credited with carving a wooden block to the intended device size, using a whittled chopstick as a stylus, and slipping paper “screens” into a sleeve to simulate the interface. He carried it for weeks, pretending to take notes and check appointments in meetings to feel out which interactions were essential. The exercise validated the four core features that shipped on the original PalmPilot in 1996. The Computer History Museum dates the wooden model to the mid-1990s in its mobile-computing exhibit. and The Palm Pilot Story — Alberto Savoia, Medium 2019

PalmPilot wooden model — Computer History Museum

TenTune

A small music-product team used paper sketches and pencil iteration to settle the core interaction model for their app before any code was written. Iterating on paper let them throw out two early designs that tested poorly without burning engineering time on either.

Lean Tools: How TenTune Harnessed the Power of the Pencil — Grasshopper Herder

IBM

Among the first large companies to adopt paper prototyping as standard practice in the mid-1990s, pioneering the method at enterprise scale. Snyder’s later book documents IBM-team work showing that paper prototypes uncover substantially the same usability problems as high-fidelity digital prototypes.

Paper Prototyping — Carolyn Snyder, Morgan Kaufmann 2003

Got something to add? Share with the community.