esc
  • WorkflowsPages
  • Case studiesPages
  • Machine Learning FoundationsLearn
  • AI EngineeringLearn
  • AI Guardrails & Red TeamingLearn
  • UI/UXLearn
  • Design SystemsLearn
  • Production System DesignLearn
  • Book a callContact
  • Download ResumeContact
Let’s talk

I’ll build the agent for it.

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

    Name the risk

    Ask what could go wrong. Is it the order of the menu, or the size of a button?

  2. 2

    Pick the cheapest level that answers it

    Questions about structure need low fidelity. Questions about detail need higher fidelity.

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

Python
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

How is this lesson?

Last updated on 17 November 2026

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.