Clickable Prototype Before App Development: What to Expect and How to Review It
Short answer: A clickable prototype is a set of designed app screens linked together so you can tap through the main journeys on a phone before any code is written. Expect it to cover the key flows, the most important screens and their states (empty, loading, error, success), not every settings page. Review it by running about five short test sessions with real staff and customers, give feedback in a structured format tied to specific screens, and sign it off against agreed criteria. It is the cheapest point to change your mind, but it cannot prove performance, real data behavior or how integrations will work, so some things will still shift during the build.
What a prototype is, and is not
Designers usually build prototypes in Figma. Each screen is a static design; links between them make taps, swipes and back buttons behave as if the app existed. On a phone, through the Figma mobile app or a shared link, it feels surprisingly real.
What it does not have: a database, real logins, payments, notifications from a server, or actual speed. Typing into a field may not work, or may show fixed sample text. Lists show the same sample items every time. Understanding this keeps feedback focused on what the prototype can actually tell you.
What gets designed
For a mid-sized business app, such as a members app for a chain of three climbing gyms, a typical prototype includes:
- Primary flows: sign up, book a class, buy a day pass, check in at the desk.
- Key screens: home, class schedule, class detail, checkout, membership card, profile.
- States for important screens:
- Empty: no bookings yet.
- Loading: schedule loading.
- Error: payment failed, class full.
- Success: booking confirmed.
- Navigation: tab bar or menu, back behavior, how users return home.
- A few edge cases: canceling a booking, what an expired membership looks like.
What is often left out: every settings screen, legal text pages, admin tools and rare errors. Ask the designer upfront which flows are in scope so you know what you will be reviewing.
Running five short test sessions
Testing with a handful of people finds most of the obvious problems. The approach below borrows from standard usability testing practice and needs no lab.
Who to invite
- Two or three customers who match your main user type (for the gym: one regular, one occasional visitor).
- One or two staff members who will support the app, such as front desk staff.
How to run each session (20 to 30 minutes)
- Hand them a phone with the prototype open. Explain it is a mock-up and some things will not work.
- Give a task, not instructions: "You want to book Thursday's 6pm bouldering class. Show us how you would do it."
- Ask them to think aloud while they tap.
- Stay quiet. Do not point at buttons or explain the design.
- Note where they hesitate, tap the wrong thing or say "I expected...".
- After three or four tasks, ask two questions: what was confusing, and what was missing?
Record sessions with permission, or have a second person take notes. Five sessions over two days is plenty.
Feedback that developers and designers can use
Unstructured feedback ("the booking feels clunky") leads to long meetings. Use a simple table, one row per issue:
| Screen | What happened | Who | Severity | Suggestion |
|---|---|---|---|---|
| Class schedule | Two of five testers did not see the date picker | Customers | High | Make dates more prominent |
| Checkout | Unclear whether a day pass includes gear rental | Front desk | Medium | Add a line under the price |
| Profile | Wanted to see visit history | Regular | Low | Consider for later |
Severity levels:
- High: blocks a task or causes a wrong action.
- Medium: causes confusion but the person recovers.
- Low: preference or nice-to-have.
You can also leave comments directly on screens in Figma. Pin each comment to the exact element so nobody has to guess what it refers to. Figma's guide to prototyping covers how links between frames and shared prototype views work.
Sign-off criteria
Agree with your designer, before testing, what "approved" means. A practical set:
- All primary flows can be completed in the prototype without help.
- All high-severity issues are fixed and retested.
- Medium issues are either fixed or logged with a decision.
- Screen states (empty, error, loading) exist for the main flows.
- Key content is final or close to final: prices, plan names, button labels.
- The owner and one staff representative have tapped through the final version.
Sign-off then becomes a short email confirming each point.
What still changes during the build
A prototype reduces surprises; it does not remove them. Expect changes like these:
- Real data is messier: long class names wrap, a gym with 40 classes on a Saturday makes the schedule look different.
- Platform conventions: iOS and Android have different patterns for back navigation, date pickers and sharing; developers may adjust details.
- Integration limits: the booking system's API may not provide a field the design assumed, such as remaining spots.
- Performance: animations that look smooth in Figma might be simplified to keep the app fast.
- Legal and store requirements: consent screens, account deletion and permission prompts need space in the flow.
Ask the team to flag such changes as they come up, with screenshots, rather than discovering them at the end.
Common mistakes owners make
- Reviewing on a desktop monitor instead of a phone.
- Asking only friends and family to test.
- Focusing on colors and logos when the flow is the real question.
- Adding new features during the prototype review, which reopens scope.
- Signing off without staff input, then hearing their objections after launch.
FAQ
How long does a prototype stage take?
For a small app, often a few weeks including one round of testing and revisions. Complex apps take longer.
Can developers build directly from the prototype?
They use it as a reference along with design specs and assets. A prototype shows behavior; developers still need details such as spacing, fonts and states.
Should we pay for a prototype if we are not sure about building the app?
It can be a sensible step: it lets you test the idea with users and get firmer quotes before committing to development.
Do customers mind testing an unfinished app?
Most enjoy it, especially when you explain that their feedback shapes the final version. A small thank-you, like a free class, helps.
Planning an app and want a prototype you can put in front of customers before committing to the build, get in touch and we can talk through the scope.