How to Create User Flows for a Mobile App
To create user flows for a mobile app, choose a user goal, identify where the journey starts, and map the actions and decisions that lead to a clear completion state. Then add alternative routes, failed actions, back navigation and recovery. For each branch, specify what the user sees, what information stays saved, and what they can do next.
What should a mobile app user flow describe?
Treat a user flow as a route to an outcome: book an appointment, save an address, submit a request or find a previous order.
For this exercise, distinguish between a screen and a step. A screen is a place in the interface; a step describes progress towards the goal. One screen might contain several steps, such as entering details, correcting an error and submitting a form.
Start with a goal statement:
"The user wants to book an available appointment and know that the booking is confirmed."
Avoid broad goals such as "use the booking section". They leave the finish line unclear.
This guide keeps the focus on how someone completes an already chosen goal.
How do you define the entry point and completion state?
Write the start and finish before drawing the middle.
For the entry point, record where the user arrives and what is already known. Someone opening a saved appointment link needs a different starting state from someone browsing services for the first time.
For completion, describe both the result and its visible evidence. "User taps Confirm" describes an action. "The appointment is saved and its details appear on a confirmation screen" defines the intended outcome.
Use a small preparation table:
| Item | Appointment example |
|---|---|
| User goal | Book an appointment |
| Entry point | Service details screen |
| Starting conditions | User has chosen a service but no appointment time |
| Required information | Available time and contact details |
| Completion state | Booking saved; confirmation shows service, time and reference |
| Other exit | User leaves without creating a booking |
Include any starting conditions that change the route, such as whether the user is signed in or has an unfinished draft.
How do you draw the main route?
Write the straightforward successful route as a short sequence:
Service details → Choose a time → Enter contact details → Review booking → Confirm → Booking confirmed
Give each step an action or a clear state. Avoid boxes labelled only "Next" or "Process".
Then connect each step with the action that moves the user forward. Between "Choose a time" and "Enter contact details", the connecting label might be "Select an available time".
For a simple diagram, choose a small notation and add a legend:
- Rounded box: entry point or ending.
- Rectangle: screen or action.
- Diamond: decision with labelled branches.
- Arrow: direction of travel.
The symbols matter less than consistent meaning. Someone reviewing the map should be able to follow it without guessing what a shape represents.
Where should alternative routes branch?
Add a branch wherever a condition changes the next step.
For the appointment example, ask:
- Is the selected time still available?
- Are the contact details complete?
- Does the user want to change the service?
- Is sign-in required before confirmation?
- Has the booking result been confirmed?
Label branches with answers such as "Available" and "Unavailable". An unlabelled fork leaves the rule undecided.
Bring routes back together when they share the same next step. For example, entering new contact details and choosing saved contact details can both lead to "Review booking".
Keep separate routes when their outcomes differ. A request awaiting approval should end with "Request submitted", with an explanation of what happens next. Do not call that state "Booking confirmed".
What does a worked user flow look like?
Consider an illustrative appointment app where users can browse without signing in and must provide contact details before booking. The following is a proposed flow, not a description of an existing service.
| Step | User action or condition | Next state |
|---|---|---|
| Service details | Chooses "Book appointment" | Available times |
| Available times | Selects a time | Contact details |
| Available times | Finds no suitable time | Chooses another day or leaves |
| Contact details | Enters complete details | Review booking |
| Contact details | Leaves a required field empty | Remains on the form; sees a specific correction |
| Review booking | Chooses "Change time" | Returns to available times; contact details stay saved |
| Review booking | Chooses "Confirm booking" | Submission in progress |
| Submission in progress | Booking is confirmed | Confirmation with booking details |
| Submission in progress | Time is no longer available | Explanation and a route to choose another time |
| Submission in progress | Result cannot be confirmed | Status-checking state with a clear next action |
Now walk through one branch in detail.
The user reaches review, changes their mind about the time, and goes back. In this proposed design, the app keeps their contact details and displays the previous selection. Choosing a replacement returns them to review, where the updated time is visible before confirmation.
That return journey belongs on the map. Without it, the diagram leaves unanswered whether changing a time clears the form or creates an additional booking.
How should you map failed actions and uncertain results?
For every important action, ask what the user should see if it cannot finish.
Distinguish between a correctable input problem, a rejected action and an uncertain result. Give each its own next step.
For example:
- Missing contact detail: keep the form populated and identify the field to correct.
- Selected time unavailable: explain the change and offer another time.
- Connection lost before submission: preserve the entered details and offer a retry.
- Result unknown after submission: check booking status before offering another submission.
For each error state, record the message's purpose, retained information and available actions. "Show error" is too vague to review.
Be precise about uncertainty. If the result is unknown, the proposed message should say that confirmation is pending rather than declaring that the booking failed.
What should Back, Cancel and leaving the app do?
Treat these as separate actions and define their destinations.
Back might return to the previous step while preserving entered information. Cancel might abandon the current booking attempt. Leaving and reopening the app needs an explicit rule about whether the user resumes a draft or starts again.
For every step containing user input, answer:
- Where does Back lead?
- Which values remain available?
- Does Cancel need a discard confirmation?
- What happens if the user returns later?
- What changes once the action has completed?
After confirmation, define where Back leads and prevent that route from submitting the same request again. For the example, it could lead to booking details or the appointment list.
Mark these decisions on the flow or in notes attached to the relevant step.
How do you check whether the flow is complete?
Walk through the map as a set of scenarios before polishing its appearance.
Check that:
- Every entry point leads to a usable state.
- Every decision has labelled outcomes.
- Every branch reaches completion, recovery or a deliberate exit.
- Error states explain what the user can do next.
- Back navigation has a destination.
- The map states which inputs remain saved.
- Completion includes visible evidence of the result.
- Uncertain results have a status-checking route.
Ask a reviewer to narrate each journey using only the map. Record any point where they must invent a rule.
Later, turn these routes into checks for the working app. The guide to testing an Android app before release provides a useful next step. For the route a new user takes on first launch, see designing app onboarding for first-time users.
To check the routes before building, see testing a mobile app prototype for usability. For the main navigation structure, see bottom navigation or a drawer.
What common mistakes should you avoid?
Mapping only successful taps. Include rejection, correction, abandonment and recovery beside the main route.
Ending at submission. Show the outcome the user receives after submitting, including pending states.
Drawing every detail on one canvas. Keep the main journey readable and expand complicated branches into linked diagrams.
Using screen names without actions. Explain why the user moves between screens.
Turning the exercise into a feature list. Map how the chosen goal works. Keep decisions about which goals belong in a release separate.
What questions come up when mapping mobile app flows?
Do you need finished screen designs first?
No. Start with labelled steps and decisions. Add rough screen sketches when placement or navigation needs clarification.
Should every goal have its own flow?
Start with one flow per goal. Connect related journeys where necessary, such as opening booking details after creating an appointment.
How much detail is enough?
Include enough detail to explain actions, decisions, outcomes and recovery without verbal explanation. Expand a step when reviewers cannot tell what should happen next.
When should you update the map?
Update it whenever a rule, entry point, navigation path or outcome changes. Review the affected branches too, so the map continues to describe the intended experience. Two flows worth mapping early are search and filters and deep links and their fallbacks.