Marcus Andrey Study
Ler em português Library

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.

A belt carrying a parcel from design to product, past four stations: prototype, handoff, critique and case study. Point at a station: the parcel rides to it and its sign goes up. Illustration: Marcus Andrey, drawn with Hairline (MIT, Lucas Marques).

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.

LowPaper sketch

Boxes, arrows and words, drawn by hand.

Answers: is this the right flow?
MidGrey wireframe

Real layout and labels, no colour or polish.

Answers: can people find things?
HighClickable mock-up

Looks like the real product, with real content.

Answers: does it read and feel right?
CodeCoded prototype

Runs in a browser, with real data or behaviour.

Answers: does it work for real?
Each level of fidelity answers a different question. Start low and go up only when the question needs it. Diagram: Marcus Andrey, CC BY 4.0.
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)

  1. Pick a small task: booking a table at a restaurant, for example.
  2. Write the one question you want answered ("Do people notice they can choose indoor or outdoor?").
  3. 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.
  4. 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

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.

Prototyping with AI · Test with three people · Usability testing with five people · Handoff to developers · The design process

Saved only on this device.

↑ ↓ to move · Enter to open · Esc to close