UX Foundations · Step 8 · 6 min read
Prototype fidelity
A prototype is a question you can put in front of people. Low, mid and high fidelity, from paper sketches to coded prototypes, what each one can and can't answer, and how to choose the cheapest prototype that still answers your question.
The work only exists when it reaches the product. Before it gets there, a prototype lets you find out whether an idea works while changing it is still cheap. The trick is to make a prototype just real enough to answer your question: a paper sketch to check a flow, a polished mock-up to check how a page reads, a coded prototype to check how it behaves with real data. More polish is not more learning; it's often more cost.
What you'll be able to do after reading:
- Explain what "fidelity" means, and its three dimensions
- Choose low, mid or high fidelity, or code, for a given question
- Run a test with a paper prototype
- Avoid the traps of prototypes that look too finished
1. A prototype is a question
NN/g puts it simply: "A user interface prototype is a hypothesis", a candidate solution you can test by watching people use it (NN/g, Pernice, UX Prototypes: Low Fidelity vs. High Fidelity, 2016). The same article gives the reason to test early: "Ripping up code is very expensive. Ripping up a prototype is not, especially if it's just a piece of paper."
So before you open any tool, write the question down. "Do people understand that the delivery fee depends on the time slot?" is a question. "Test the new checkout" is not.
2. What fidelity means
Fidelity is "how closely it matches the look-and-feel of the final system", and NN/g splits it into three areas: interactivity, visuals and content (same article). A prototype can be high in one and low in another. A grey wireframe with the real product names and prices has low visual fidelity but high content fidelity, and that may be exactly what you need.
Boxes, arrows and words, drawn by hand.
Answers: is this the right flow?Real layout and labels, no colour or polish.
Answers: can people find things?Looks like the real product, with real content.
Answers: does it read and feel right?Runs in a browser, with real data or behaviour.
Answers: does it work for real?| Level | What it looks like | Good for | Not good for |
|---|---|---|---|
| Low | Paper sketches, sticky notes, boxes and arrows | Flow, order of steps, what goes on each screen | Reading, visual hierarchy, timing |
| Mid | Greyscale wireframes, real labels, simple clicks | Finding things, labels, navigation | Brand feel, fine visual detail |
| High | Looks like the real product, real content | Reading, trust, visual hierarchy, final wording | Big changes of direction (it feels finished) |
| Coded | Runs in a browser with real data or real behaviour | Speed, animation, real data, edge cases | Early ideas (too slow to throw away) |
"Mid fidelity" and "coded prototype" are common working terms rather than NN/g categories; NN/g's article compares low and high, and treats the levels as a range.
3. Low fidelity: cheap, fast and honest
NN/g lists real advantages of rough prototypes (NN/g, Pernice, 2016):
- Less time to prepare, so more time to design.
- Easy to change during the test: you can sketch a new screen between sessions.
- "Low-fidelity prototypes put less pressure on users." People see it's unfinished, feel the design is being tested and not them, and are more willing to criticise.
- "Designers feel less wedded to low-fidelity prototypes." It's easier to throw away a sketch than something you polished for a week.
- Stakeholders see it isn't finished, so nobody says "this looks good, let's make it go live now."
With a paper prototype, one person plays "the computer": when the participant taps a paper button, they put down the next paper screen. Jakob Nielsen called paper prototyping "one of the fastest and cheapest techniques you can employ in a design process" (NN/g, Nielsen, Paper Prototyping, 2003).
4. High fidelity and code: when realism matters
Go higher when the question is about things a sketch can't show: whether a page reads well, whether a button looks clickable, whether people trust a payment screen. NN/g notes that "High-fidelity prototypes often look like "live" software to users", so people behave more naturally, and the facilitator doesn't have to play the computer (same article).
A coded prototype goes one step further: it runs, so you can test real data, long names, slow connections, animation and screen readers. Today AI tools make quick coded prototypes much cheaper; see Prototyping with AI. The risk stays the same: the more real it looks, the harder it is for you, and for everyone else, to throw it away.
5. Common mistakes
- Starting in high fidelity because it looks better in a meeting.
- Making a prototype without writing down the question it should answer.
- Testing colours and fonts with a paper sketch, or a whole new flow with a pixel-perfect mock-up.
- Showing a polished prototype to stakeholders and having it treated as a finished design.
- Using fake content ("Lorem ipsum", "Product name") when the question is about reading or understanding.
6. Vocabulary
| Term | Meaning |
|---|---|
| Prototype | A rough or realistic version of a design, made to learn something |
| Fidelity | How close a prototype is to the final product |
| Low fidelity | Rough: sketches, paper, boxes |
| High fidelity | Looks and behaves like the real product |
| Paper prototype | Paper screens; a person plays "the computer" |
| Wizard of Oz | A person secretly produces the system's responses during a test |
| Coded prototype | A prototype that really runs, usually in a browser |
7. Try it (no tools needed)
- Pick a small task: booking a table at a restaurant, for example.
- Write the one question you want answered ("Do people notice they can choose indoor or outdoor?").
- Draw three or four paper screens, one per sheet. Ask a friend to try the task while you play the computer, swapping sheets as they tap.
- Note where they hesitate. Redraw that screen and try with someone else.
Optional: if you use Figma, link the same screens in a quick grey prototype and compare what each version taught you.
Reflection questions: What did the paper version tell you that a polished one might have hidden? What question would actually need high fidelity?
8. If you already practise
- Mix fidelities on purpose: low visuals with real content is often the best way to test labels and prices.
- Describe how much of a prototype works, not just how it looks. NN/g's companion article names prototypes by the part of the site tree that works: horizontal, T, M and semi-complete (NN/g, Pernice, IA-Based View of Prototype Fidelity, 2016).
- Pilot every prototype before a session; NN/g warns that "computer" errors confuse participants and spoil the test.
Checklist
Learn more
- NN/g: UX Prototypes: Low Fidelity vs. High Fidelity (2016, updated 2025) · IA-Based View of Prototype Fidelity (2016) · Paper Prototyping: Getting User Data Before You Code (2003)
Books, courses and videos to go deeper
Book links go to Amazon. As an Amazon Associate I earn from qualifying purchases, at no extra cost to you.
Related
Prototyping with AI · Test with three people · Usability testing with five people · Handoff to developers · The design process