Prototyping: Test Your Ideas Before You Build Them
Learn how designers make cheap, early versions of a screen, test them with people, and change them before any code is written.
In short
A prototype is a cheap, early version of a screen that designers test with people and change before any code is written.
5 min readFree
What is a prototype?
A prototype is an early model of a design. You make it to try an idea before you build the real product. A prototype can be a paper sketch or a screen you can click. Real users can try it, and you can watch what they do.
In this lesson you will learn why teams build prototypes early, how to choose the right level of detail, how to test with a few people, and how a tiny click-through prototype works in Python.
Key words
- Prototype
- An early, cheap version of a design. You use it to test ideas and find problems.
- Fidelity
- How closely a prototype matches the look, feel, and behaviour of the final product.
- Wireframe
- A simple outline of a screen. It shows layout and content, not colour or style.
- Usability test
- A session where a real person tries tasks on your design while you watch and listen.
- Click-through prototype
- Linked screens that let a person tap through a task, even though the app is not built.
- Wizard of Oz test
- A test where a hidden person decides which screen the user sees next.
Why build one early?
Changing a paper sketch costs very little. Changing finished code costs much more. Nielsen Norman Group says that throwing away a simple prototype is far cheaper than throwing away a built product.
Find problems sooner
Early tests show where people get stuck, before anyone writes code for the screen.
Change things cheaply
A change to a sketch or a clickable mock is quick. Nielsen Norman Group cites a common estimate that a change made before coding is about 100 times cheaper than one made after.
Learn from real people
Watching users shows what they understand, what confuses them, and what they expect to happen next.
Tip
Build a prototype to answer one question. Write the question down first. If you cannot name the question, you are not ready to build the prototype.
What are low and high fidelity?
Fidelity means how close a prototype is to the final product. Nielsen Norman Group says fidelity can differ in three areas: interactivity, visuals, and content. One prototype can be detailed in one area and rough in another.
Low fidelity
Rough sketches or plain wireframes. They focus on layout and the order of steps. Users often feel free to criticise them, because they look unfinished.
High fidelity
Detailed, clickable screens that look like real software. People tend to act more like they would with a real product, and the team can test colour, text, and small animations.
Both, in order
Many teams start with low fidelity to explore ideas, then move to high fidelity to check details.
Low fidelity cannot show subtle animations or small interaction details well. For those questions, a more detailed version is needed.
How do you choose the right level?
- 1
Name the risk
Ask what could go wrong. Is it the order of the menu, or the size of a button?
- 2
Pick the cheapest level that answers it
Questions about structure need low fidelity. Questions about detail need higher fidelity.
- 3
Test, change, and repeat
Fix what you learn, then test again with a slightly more detailed version.
Faking the behaviour
A prototype does not need working code to feel real. During a test, a person can play the part of the computer and react to each tap.
Paper computer
Screens are drawn on paper. A person swaps in the right sheet when the user taps the paper.
Wizard of Oz
A hidden person controls the screen from another room. The user is told only that the system is unfinished and slow.
Steal the mouse
The prototype runs on a screen in the same room. The facilitator changes the page while the user looks away.
Tip
Tell testers the prototype is unfinished. Do not explain every element. Let them try the task and tell you what they think.
A tiny click-through in Python
This sample models a click-through prototype. Each screen has taps that lead to the next screen. The code uses only the standard library and prints the path a user takes.
flow = {
"home": {"Sign up": "form", "Log in": "login"},
"form": {"Next": "done"},
"login": {"Log in": "done"},
"done": {},
}
taps = ["Sign up", "Next"]
screen = "home"
print("Start on:", screen)
for tap in taps:
screen = flow[screen][tap]
print("Tap", repr(tap), "->", screen)Output
Start on: home Tap 'Sign up' -> form Tap 'Next' -> done
How do you test with a few people?
You do not need a big crowd for early tests. For an early paper prototype, a small group of about five representative users can find the most important problems. Give each person the same tasks, note where they hesitate, and change the design before the next round.
Early tests often reveal problems with terms, flow, and missing steps. A paper test can show these problems before anyone builds a screen.
Quick check
A team wants to know if the order of menu items makes sense. Which prototype fits this question best?
Key takeaways
A prototype is a cheap test of an idea. Build it early, match its detail to your question, and test it with real people. Then change it and test again before you build the final product.
Sources
- Nielsen Norman Group: UX Prototypes: Low Fidelity vs. High Fidelity
- Nielsen Norman Group: Paper Prototyping: Getting User Data Before You Code
- MockFlow Glossary: What is Prototypes?
- Interaction Design Foundation: What are Interactive Prototypes?
- UserTesting: What is UX Prototyping and Why Should You Test Early?
- Zuehlke Machines, Code, People: Why you should create a paper prototype
- Optimal Workshop: Using paper prototypes in UX
- Figr: Types of Prototyping: 8 Methods Teams Use in 2026
Last updated on 17 November 2026
Related lessons
Learn with me
Every lesson is free. I add new ones as I learn. Have a question, or want help with your own work? Book a short call.