←
BACK_TO_BLOG

Why We Build a Clickable Prototype Before Writing the Spec

Share
X_/_TwitterLinkedInCopy_Link
TL;DR
  • A clickable prototype is a fake version of the product that people can tap through. It looks real enough to react to, and nothing behind it works yet.
  • We build one before the spec, because people answer questions better when they can see the screen. Reacting to a screen they can tap is far easier than imagining one from a page of text.
  • Five comparable users in a round find most of the usability problems. Test small, fix, and test again, before any production code exists.
  • The prototype is thrown away once the decisions are made. What people did with it becomes the spec the developers build from.
A thick stack of paper tied up with string, beside a blue paper phone that a finger is tapping.

A clickable prototype is a set of realistic screens linked into a flow that people can tap through before any real code exists, and it is the first thing we build for new software, before the spec. It looks like the product, it runs on a phone or a laptop, and the people who will use it can try their task on it. Nothing behind it is real, which keeps it cheap to build, cheap to change and quick to settle the questions a written spec leaves open. This post covers what a clickable prototype is, why it comes before the spec, how we test one, and what changed when we walked through one.

What a Clickable Prototype Is

A clickable prototype is a set of screens linked together so a person can move through a task, such as booking a job or checking in a car, as if the product existed. The data is made up and nothing is saved.

It is easy to confuse with two neighbours:

ThingWhat it isWhat it answers
WireframeGrey boxes showing layout, usually staticWhere things go on a screen
Clickable prototypeRealistic screens linked into a flow, with fake dataWhether people can do the task, and what they expect next
MVPA small but real product, with working data and loginsWhether people keep using it

The prototype sits in the middle. It is much cheaper than an MVP and far more useful than a wireframe for one job: watching a real user try the workflow. We usually build ours with an AI coding agent, so a simple flow can be clickable in hours. A design tool's prototype mode, which links static screens with tap targets, also works when the question is only about layout and wording.

Why the Prototype Comes Before the Spec

A spec written first asks everyone to imagine the product. The founder imagines one thing, the developer another, and the gap shows up weeks into the build.

A prototype closes that gap early. Martin Cagan made the case in his guide How to Write a Good PRD (2005), which puts "Prototype and Test the Product Concept" as step five of ten, before the step called "Write It Down". His reasoning: "there is no substitute for putting the prototype in front of actual people from the target customer base."

In practice, the questions a prototype settles are the ones that cause rework:

  • Order of steps. Does the attendant take the photo before or after printing the ticket?
  • What is missing. Where does the customer go when the slot they want is full?
  • What is too much. Which fields does nobody fill in?
  • Words. Do people understand "assign", or do they call it "send out"?

Each of these takes minutes to change in a prototype and days to change in a built product.

What Testing a Prototype Shows You

Testing a prototype means asking a real user to do a real task with it while you watch and stay quiet. You learn more from where they hesitate than from what they say.

Got an idea and no screens yet?

  • FLOWS??
  • SCREENS??
  • FAKE DATA??
  • USER TESTS??
  • FIXES??
  • SPEC??

Tell us the workflow. Our builds start with a clickable prototype in the first two weeks, and we'll scope yours in one call.

SCOPE_MY_PROTOTYPE→
A hand pressing a paper button on a cut-out phone screen made of blue paper

You don't need many testers. Jakob Nielsen of Nielsen Norman Group wrote in Why You Only Need to Test with 5 Users (18 March 2000) that a first study with five participants finds 85% of the usability problems. His advice is to run several small tests: test with five, fix what they found, then test the new version. The rule holds for similar users, so if two quite different groups will use the product, such as owners and gate staff, test a few people from each.

A prototype makes that loop cheap. Nielsen made the same case for even rougher prototypes in Paper Prototyping: Getting User Data Before You Code (13 April 2003): testing early ideas lets you fix usability problems before you pay to build something that doesn't work.

What Changed After Our First Walkthrough

In October we built a prototype for the owner side of a parking lot app: sign-up, setting up the lot by areas and spots, inviting gate staff, pricing, and a dashboard with the day's earnings and free spots. It took a few days and covered most of the owner's journey, with nothing real behind it.

We walked through it internally first, with the person driving the venture on our side, and that one session changed the plan. The read was that the people using the app most would be the gate attendants, who are not technical, and that it had to be far simpler for them. The app for the lot moved ahead of the app for drivers, cut down to three screens: what is in the lot right now, check-in and check-out with payment, and the end-of-day reconciliation.

A spec written up front would have described the owner dashboard in detail before anyone asked who stands at the gate. Seeing the screens got that question asked in the first session. The next step, planned that afternoon, was a simpler prototype for lot owners to react to.

Steps to Prototype an App Idea Before the Spec

This is the order we follow. Each step is small.

Step 1: Pick One Workflow

Choose the one task that happens most often, such as taking a booking or checking a car in. Leave everything else out.

Step 2: Build Only the Screens That Task Needs

Link them into a flow with realistic fake data. Use names and numbers that look like your testers' own, because people react honestly to data they recognise.

Step 3: Put It on the Device They Will Use

If the attendant uses a phone at the gate, test on a phone at the gate. A laptop in a meeting room gives you different answers.

Step 4: Watch Five People Try the Task

Give them the task, stay quiet, and write down every hesitation and question. If two different groups will use it, such as owners and gate staff, watch a few from each.

Step 5: Fix, Retest, Then Write the Spec

Change the prototype, test again, and only then write the spec from what you saw. Our guide on how to write a PRD covers what goes into it.

How Founder's Agentcy Uses Prototypes

At Founder's Agentcy the prototype is a scoping tool. The founder and the people who will use the software see something they can tap through early, and the questions it raises go straight into the spec as rules and edge cases.

The prototype itself is thrown away. It has no real logins, no real data handling and no tests, and it was never meant to. Our post on vibe coding internal tools covers what a production build adds on top of a quick prototype.

My take: the cheapest week in a software project is the one spent watching five people use something fake. It is also the first week to get cut when a deadline looms.

What's the one workflow you'd want five people to tap through first?

FAQs

// QUESTIONS //
Q.

What is the difference between a clickable prototype and an MVP?

A clickable prototype has realistic screens but no working system behind it. An MVP is a small real product, with working data and logins, that people use for real.

Q.

How long does it take to build a clickable prototype?

For one workflow, usually a few days. With AI coding tools, a simple flow can be ready in hours.

Q.

What is the difference between a prototype and a wireframe?

A wireframe shows layout, usually in grey boxes and often static. A clickable prototype looks close to the real product and lets people move through a task.

Q.

Can a clickable prototype become the real product?

Rarely as-is. It is built for speed and has no real security, data handling or tests, so the production version is built separately, using the prototype as the reference.

Q.

How many people should test a prototype?

Five is a good start for each round. Fix what they find, then test the new version with another small group.

2-WEEK SPRINTS
//
$2,500 FLAT
//
LIVE IN 90 DAYS
//
THE CODE IS YOURS
//
ZERO LOCK-IN
//
2-WEEK SPRINTS
//
$2,500 FLAT
//
LIVE IN 90 DAYS
//
THE CODE IS YOURS
//
ZERO LOCK-IN
//
2-WEEK SPRINTS
//
$2,500 FLAT
//
LIVE IN 90 DAYS
//
THE CODE IS YOURS
//
ZERO LOCK-IN
//
2-WEEK SPRINTS
//
$2,500 FLAT
//
LIVE IN 90 DAYS
//
THE CODE IS YOURS
//
ZERO LOCK-IN
//

Show it before you [spec it.]

START_PROJECT
→