How Do You Run a Usability Test on an App Prototype?
To usability test a mobile app prototype, ask people who match your intended users to complete realistic tasks on a phone, without guiding them through the screens. Record what they attempt, where they get stuck, and whether they recognise a successful outcome. Separate interface problems from missing prototype behaviour, then fix the problems that block or mislead users and test the revised flow.
What should the test help you decide?
Choose a specific interface decision: can someone find a saved item, change a booking, or correct an entry before submitting it?
Keep the session focused on whether people can use the proposed screens. Questions about whether the product idea deserves investment belong in a separate exercise. A participant completing a task does not establish demand for the app.
Write down the flow under review, its starting point, and the visible result that counts as completion. If the first release still contains too many competing journeys, use our guide to how to scope an app MVP to narrow the work before testing.
Who should take part?
Recruit people who resemble the users of the flow you are testing. Describe them through relevant behaviour and circumstances: what they do today, their familiarity with similar tasks, their phone use, and any access needs the interface must support.
For a booking flow, look for people who arrange the relevant kind of appointment. For a staff approval flow, include people who actually review requests.
Avoid relying entirely on colleagues who already know the design. Their knowledge makes it harder to observe how someone approaches unfamiliar screens.
Ask about recruitment needs without explaining the route through the prototype. If you are testing different user roles, give each role its own tasks and review its findings separately.
How do you prepare the prototype?
Make the task path usable from its starting screen through to a recognisable outcome. Include the decisions you want to observe, such as choosing between similar options or reviewing details before confirmation.
Run through the prototype yourself and list its limits:
- Which controls do not work?
- Does typing accept real input or reveal prepared text?
- Can someone go back, cancel, and correct a choice?
- Are loading, empty, and error states represented?
- Does the prototype remember earlier selections?
Use fictional information, and tell participants not to enter passwords, payment details, or private records.
For a mobile flow, ask participants to use a phone where practical. Check that the prototype opens and its controls respond before starting. If the session uses a different device, record that condition alongside the findings.
How do you write tasks without giving away the answer?
Describe a situation and the outcome the person wants. Leave out menu names, button labels, and instructions about where to tap.
The following booking tasks are illustrative:
| Leading instruction | Task script to use instead |
|---|---|
| Tap Book, then choose a service. | You want to arrange a visit for a repair. Show what you would do. |
| Open My Bookings and tap Edit. | Your plans have changed. Move your existing appointment to another available slot. |
| Tap the pencil beside your address. | You notice the visit address is wrong. Correct it before confirming. |
| Tap Confirm to finish. | Finish arranging the visit, then tell me what you expect to happen next. |
Prepare a separate observer note for each task. Include the starting state, acceptable outcomes, and prototype limitations.
Allow any valid route. If someone reaches the right outcome through a different path, record it without steering them towards your preferred route.
What should you say during the session?
Start with a short explanation:
“We are checking the screens. Please approach each task as you normally would. Say what you are looking for and what you expect to happen. Some parts are unfinished; I will explain if you reach one.”
Ask for permission before recording, explain how the recording will be used, and accept a refusal. Notes can still support the session.
Give one task at a time. Let the participant read, pause, and explore. Avoid pointing, finishing their sentences, or praising particular choices.
When you need clarification, use neutral prompts:
- “What are you looking for?”
- “What did you expect to happen?”
- “What would you do next?”
If someone asks where to tap, ask what they would try. If you eventually provide help, mark the outcome as assisted. Do not count a coached completion as independent success.
What should observation notes capture?
Record behaviour before interpretation. “Opened the address screen twice, then stopped” is an observation. “The navigation is confusing” is a possible explanation to investigate.
Use a consistent note structure:
| Field | What to record |
|---|---|
| Task and starting state | What the participant was asked to do and where they began |
| Actions | Screens visited, choices made, backtracking, and abandoned attempts |
| Expectations | What they said they expected before or after an action |
| Outcome | Completed independently, completed with help, stopped, or blocked by the prototype |
| Observer intervention | Any hint, explanation, reset, or technical help |
| Possible issue | A tentative interpretation, kept separate from the observation |
Record whether the participant recognised completion. Reaching a confirmation screen while believing more action is required deserves attention.
Keep participant identities out of shared findings. If you record task duration, note interruptions and prototype delays so the figure is not presented without context.
Which prototype shortcuts can mislead the findings?
Review shortcuts before interpreting a smooth journey as evidence that the interface works.
Oversized tap areas: a participant may tap near a control and advance accidentally. Note whether they identified the intended control.
Prepared input: a text field that fills itself leaves typing, editing, and validation untested. Mark those interactions as outside the session’s evidence.
Missing alternatives: if only the intended route responds, other choices cannot be fairly assessed.
Automatic success: a flow that always confirms an action leaves failure messages and recovery unresolved.
Visible interaction hints: a prototype that highlights every clickable area gives help the finished interface may not provide. Disable those hints when testing discoverability, where possible.
When a shortcut interrupts the task, explain only the limitation needed to continue. Record what happened before and after the explanation separately.
How do you decide which problems to fix?
Group observations by the underlying interface problem. Keep a clear link between each proposed change and the behaviour that prompted it.
Prioritise by consequence, recovery, and relevance to the release:
| Finding | Suggested response |
|---|---|
| A user cannot complete a core task | Fix before treating the flow as ready |
| A user confirms an unintended choice without noticing | Review the choice, review screen, and confirmation together |
| A user makes a mistake and cannot recover | Add or clarify the correction path, then retest |
| A user hesitates but completes the task independently | Investigate the cause and weigh it against stronger blockers |
| A missing prototype interaction stops progress | Repair the prototype before judging that interaction |
Do not rank issues by frequency alone. A single observed mistake may deserve priority if its consequence is serious. Equally, a preference about colour needs a different response from an inability to find a necessary action.
For each selected fix, write the observed problem, the proposed change, and what a follow-up session must demonstrate. Retest with people who have not been taught the revised route.
What common mistakes should you avoid?
Do not turn the session into a product demonstration. Explaining each screen removes the opportunity to observe independent use.
Avoid asking only “Was that easy?” after completion. Ask what the participant thought happened, then compare that answer with their actions.
Keep requested features separate from observed usability problems. A suggestion may be useful, but it does not automatically explain a failed task.
Finally, keep the test’s limits visible. A clickable prototype leaves working-app behaviour unresolved, including permissions, connectivity, and device-specific interactions. Carry those questions into testing an Android app before release.
What else do founders ask about prototype usability testing?
How many participants should we recruit?
Plan around the distinct user roles and flows under review. Begin with a manageable round, address clear blockers, and recruit again to check revisions. Avoid presenting a small qualitative session as a population-wide success rate.
Can we test an unfinished prototype?
Yes, if the relevant journey works and you record what remains unfinished. Where the prototype supplies an answer or skips an interaction, limit the conclusion accordingly.
Should the designer moderate?
The designer can moderate if they can observe without defending or explaining the design. Where practical, have another person take notes so the moderator can concentrate on the participant.
When is the flow ready for development?
Use a defined review checklist: participants can complete the core tasks independently, recognise the outcome, and recover from the mistakes covered by the prototype. Resolve serious observed problems and document remaining uncertainty before handing the flow over.
Need help preparing an app flow for testing? Explore our app design and development services.