Skip to main content

User Flow Diagram: How to Make One, With App Templates

How to make a user flow diagram step by step: notation, happy and unhappy paths, tools, and copy-ready templates for sign-up, checkout and booking.

Guides15 min read2,985 words

This guide is for founders, PMs, developers and designers who need to plan how people move through an app before designing screens. A user flow diagram is the cheapest way to find missing screens, dead ends and confusing branches — on paper, before anyone writes code. You will learn what a user flow diagram is and how it differs from related diagrams, the notation to use, a step-by-step method, the tools worth using, and copy-ready templates for the flows almost every app needs.

TL;DR: A user flow diagram maps the steps and decisions a user takes to complete one goal, from entry point to success. Use rounded shapes for start and end, rectangles for screens, diamonds for decisions and arrows for movement. Draw the happy path first, then add errors, edge cases and exits, and turn the result into a screen inventory. Start from the templates below.

What a user flow diagram is

A user flow diagram is a visual map of the path a user takes through a product to achieve a specific goal, such as "create an account" or "book a table". It shows:

  • •Where the user enters (an ad, a push notification, the home screen, a shared link).
  • •The screens and actions along the way.
  • •The decisions the user or the system makes ("Already have an account?", "Payment approved?").
  • •The outcome: success, or a defined failure or exit.

The key word is goal. A user flow is not a map of the whole app; it is a map of one task. An app has many flows, and each deserves its own diagram.

Why bother: what flows catch that screens miss

Teams that skip flows and go straight to screens usually discover the gaps in development, when they are expensive. Flows catch:

  • •Missing screens: the password reset confirmation, the "no results" state, the email verification wait.
  • •Dead ends: a screen with no way forward or back.
  • •Unnecessary steps: two screens that could be one.
  • •Unclear decisions: places where the system must decide something the team has not defined ("What if the user's card is expired?").
  • •Entry point gaps: the deep link from an email lands on a screen that assumes the user is signed in.

A flow also creates shared understanding. A PM, a designer and a developer looking at the same diagram will spot different problems, which is exactly the point.

User flow vs related diagrams

These terms get mixed up. Here is how they differ:

DiagramWhat it showsLevelUse it when
User flowSteps and decisions to complete one goal, often across screensMediumPlanning features and screens
Task flowA single linear path for one task, without branchesLowExplaining the simplest happy path
WireflowA user flow drawn with wireframe thumbnails instead of boxesMedium to detailedMobile apps, where screen layout and flow are tightly linked
User journey mapThe user's experience over time, including emotions, channels and touchpoints outside the productHighStrategy, service design, finding pain points
Sitemap or app mapThe hierarchy of all screens, without the path between themStructuralInformation architecture and navigation
FlowchartAny process, including back-end logicAnyEngineering logic and system processes

For most app teams, the progression is: journey map for strategy (optional), user flows for each key goal, wireflows once screens start to take shape, and a sitemap to check nothing is orphaned.

User flow notation

There is no single mandatory standard, but most teams use a small set of shapes borrowed from flowcharting. Keep it consistent and add a legend.

ShapeMeaningExample label
Rounded rectangle or ovalStart or end point"Taps Sign up on welcome screen", "Account created"
RectangleA screen or page"Email and password screen"
DiamondA decision, with labelled branches"Email already registered?" Yes / No
ArrowMovement from one step to anotherLabelled with the action: "Taps Continue"
Small rectangle or noteSystem action or background process"Send verification email"
Parallelogram (optional)User input"Enters card details"

Conventions that keep diagrams readable:

  • •Flow left to right or top to bottom, never both in one diagram.
  • •Label every branch leaving a diamond ("Yes", "No", "Error").
  • •Name screens consistently with the names you will use in design files and code.
  • •Use colour sparingly: for example, green for the happy path, red for errors, grey for out-of-scope steps.
  • •One goal per diagram. If a diagram covers several goals, split it and link them with an off-page reference ("Continues in Onboarding flow").

How to make a user flow diagram, step by step

Step 1: Define the user and the goal

Write one line: "A first-time visitor wants to create an account so they can save recipes." The user type matters because a returning user, a guest and an admin take different paths. The goal defines where the diagram ends.

Step 2: List the entry points

Where can this flow start? Common entry points for mobile apps:

  • •First launch after install
  • •Home screen or a tab
  • •Push notification
  • •Email or SMS link (deep link)
  • •Shared link from another user
  • •Paywall or locked feature prompt

Each entry point may skip or add steps. A user arriving from a "your order has shipped" notification lands deep inside the app and may need to sign in first.

Step 3: Draw the happy path

The happy path is the shortest successful route with no errors. Draw it as a straight line of screens and actions from entry to goal. Keep it short; if the happy path is more than seven or eight steps, ask whether some steps can be combined, deferred or removed.

Step 4: Add decisions and branches

Walk through the happy path and ask at every step: "What could be different here?"

  • •User decisions: chooses Sign in with Apple instead of email, skips a step, goes back.
  • •System decisions: email already registered, payment declined, item out of stock, location permission denied.
  • •State differences: signed in or not, first time or returning, free or paid.

Each becomes a diamond with labelled branches.

Step 5: Add errors, edge cases and exits

This is where flows earn their keep. For every screen, add:

  • •Validation errors (invalid email, weak password).
  • •System failures (no network, server error, timeout).
  • •Empty states (no results, nothing saved yet).
  • •Exits (user abandons, closes the app, cancels) and what happens when they return — is progress saved?

Every branch must end somewhere: back on the happy path, at a success point, or at a defined exit. No loose arrows.

Step 6: Review with the team

Walk through the diagram with a developer and someone who knows the business rules. Developers find system states you missed; business owners find rules ("users under 18 cannot purchase") that change branches. Update the diagram as you go.

Step 7: Turn it into a screen inventory

List every rectangle in the diagram. That list, with the states each screen needs, is your design scope. Compare it against your MVP list — our MVP app design guide explains how to decide which screens make the first version.

Step 8: Upgrade to a wireflow

Once the flow is stable, replace the rectangles with rough wireframes of each screen. This "wireflow" shows both structure and layout and is the best handoff into visual design. Our guide on how to wireframe an app covers that stage.

Step 9: Test it as a prototype

A flow is a hypothesis about how people will move through the app. Link the screens into a clickable prototype and watch real users try the goal. Where they hesitate or go the wrong way, the flow needs changing. See how to prototype an app for a testing script.

Templates for common app flows

Each template below lists the happy path first, then the branches to add. Copy them into your diagramming tool and adapt them.

Template 1: Sign up

Goal: a new user creates an account.

Happy path:

  1. •Start: taps Sign up on the welcome screen
  2. •Screen: sign-up options (Continue with Apple, Continue with Google, Continue with email)
  3. •Decision: which method?
  4. •Screen (email path): enter email and password
  5. •System: create account, send verification email
  6. •Screen: "Check your inbox" with resend option
  7. •Start (re-entry): taps verification link in email (deep link)
  8. •End: account created, lands in onboarding or home

Branches to add:

  • •Email already registered → offer Sign in or Reset password
  • •Weak password → inline error, stay on screen
  • •Verification link expired → screen with resend button
  • •Social sign-in cancelled → back to options
  • •No network → retry state

Our login screen design patterns cover the screen-level details for this flow.

Template 2: Onboarding

Goal: a new user reaches the first moment of value.

Happy path:

  1. •Start: account created or first launch
  2. •Screen: value proposition (one to three screens, skippable)
  3. •Screen: personalisation questions (goals, preferences)
  4. •Decision: does this feature need a permission now?
  5. •Screen: permission primer explaining why → system permission prompt
  6. •Screen: first action (create first item, follow first topics, start first lesson)
  7. •End: home with personalised content

Branches to add:

  • •User skips personalisation → default content
  • •Permission denied → continue with limited features, explain how to enable later
  • •User quits mid-onboarding → resume where they left off on next launch

The onboarding screen design playbook goes deep on the screens in this flow.

Template 3: Password reset

Goal: a user who forgot their password regains access.

Happy path:

  1. •Start: taps "Forgot password?" on sign-in
  2. •Screen: enter email
  3. •System: send reset link (always show the same confirmation, whether or not the email exists, to avoid revealing accounts)
  4. •Screen: "Check your email"
  5. •Start (re-entry): taps link in email
  6. •Screen: set new password
  7. •End: signed in, or returned to sign-in with a success message

Branches: link expired, password does not meet rules, user remembers password and goes back.

Template 4: Checkout

Goal: a shopper completes a purchase.

Happy path:

  1. •Start: taps Checkout in cart
  2. •Decision: signed in? (No → guest checkout or sign in)
  3. •Screen: shipping address (pre-filled if saved)
  4. •Screen: delivery option
  5. •Screen: payment (Apple Pay or Google Pay, saved card, new card)
  6. •Screen: review order
  7. •System: process payment
  8. •Decision: payment approved?
  9. •End: order confirmation with order number and tracking

Branches: payment declined → choose another method; item out of stock → update cart; address not deliverable → edit address; promo code invalid → inline error.

For the full browse-to-checkout journey, see our ecommerce user flow guide.

Template 5: Booking or appointment

Goal: a user books a time slot.

Happy path:

  1. •Start: taps Book on a service or provider
  2. •Screen: choose date
  3. •Screen: choose time from available slots
  4. •Decision: signed in? (No → sign in or sign up, then return to the same slot)
  5. •Screen: confirm details and pay or reserve
  6. •End: confirmation with add-to-calendar and reminder option

Branches: no slots available on chosen date → suggest next available; slot taken while booking → explain and offer alternatives; payment fails → retry.

Template 6: Subscription upgrade

Goal: a free user starts a paid plan.

Happy path:

  1. •Start: hits a locked feature or taps Upgrade in settings
  2. •Screen: paywall with plans and free trial details
  3. •Decision: which plan?
  4. •System: native purchase sheet (App Store or Google Play)
  5. •Decision: purchase successful?
  6. •End: unlocked feature with a confirmation

Branches: user dismisses paywall → return to previous screen with feature still locked; purchase cancelled; purchase pending (for example, waiting for parental approval); restore purchases for existing subscribers.

Writing flows as text or code

Not every flow needs a drawing tool. Text-based diagrams are quick to write, easy to version alongside code, and readable by developers. Mermaid is supported in many documentation tools and code hosts, including GitHub. Here is the sign-up flow as Mermaid:

flowchart LR
  A([Taps Sign up]) --> B[Sign-up options]
  B --> C{Method?}
  C -->|Email| D[Enter email and password]
  C -->|Apple or Google| G[System sign-in sheet]
  D --> E{Email already registered?}
  E -->|Yes| F[Offer sign in or reset password]
  E -->|No| H[Check your inbox]
  G --> I([Account created])
  H --> J[Taps verification link]
  J --> I

You can also write flows as indented text in a spec, which is often enough for small features:

Goal: Reset password
1. Sign in screen → taps "Forgot password?"
2. Enter email screen → taps Send
3. Check email screen (same message whether or not account exists)
4. Email link → Set new password screen
   - Link expired → Expired link screen → Resend
   - Password too weak → inline error
5. Success → signed in

Tools for making user flow diagrams

ToolStrengthsGood for
Pen and paper or whiteboardFastest, best for group thinkingFirst drafts and workshops
FigJamFlow connectors, sits next to Figma designsTeams already designing in Figma
MiroLarge templates library, strong for workshopsCross-functional mapping sessions
WhimsicalFast, clean flowcharts with minimal styling effortQuick, tidy diagrams
LucidchartDetailed diagramming, formal notationComplex flows and documentation
draw.io (diagrams.net)Free, works offline and in many integrationsBudget-conscious teams
MermaidText-based, version-controlled, renders in docsDeveloper-heavy teams and specs
FigmaWireflows with real screen thumbnailsLater-stage flows once screens exist

Pick one and stick with it so flows are easy to find. The tool matters much less than drawing the unhappy paths.

User flow diagram checklist

  • •The diagram has one user type and one goal, written at the top.
  • •All entry points are shown, including deep links and notifications.
  • •The happy path is clear and as short as possible.
  • •Every decision diamond has labelled branches.
  • •Errors, empty states and exits are included.
  • •Every branch ends somewhere — no loose arrows or dead ends.
  • •Screen names match the names used in design and code.
  • •The flow has been reviewed with a developer and a business owner.
  • •A screen inventory has been extracted from the diagram.
  • •The flow has been tested as a prototype with real users.

Common mistakes

  • •Mapping the whole app in one diagram. It becomes unreadable. One goal per flow.
  • •Only the happy path. The unhappy paths are where most missing screens hide.
  • •Mixing levels of detail, such as one step for "checkout" next to ten steps for "change avatar".
  • •Unlabelled arrows and branches. Readers cannot tell what triggers each move.
  • •Forgetting re-entry. Email links, notifications and returning after quitting all need defined landing points.
  • •Never updating it. Treat the flow as a living document while the feature is in design.

Once your flows are stable, you can generate the screens for each step in floow and lay them out as a flow on the canvas, which makes it easy to spot gaps between the diagram and the designs.

FAQ

What is a user flow diagram?

A user flow diagram is a visual map of the steps, screens and decisions a user goes through to complete one goal in a product, from entry point to success or exit. It typically uses rectangles for screens, diamonds for decisions and arrows for movement between steps.

What is the difference between a user flow and a user journey?

A user flow focuses on the steps inside the product to complete one task, such as signing up. A user journey map is broader: it covers the whole experience over time, including emotions, channels and touchpoints outside the app, like seeing an ad or contacting support.

What symbols are used in a user flow diagram?

The common set is ovals or rounded rectangles for start and end points, rectangles for screens, diamonds for decisions, and arrows for movement, sometimes with notes for system actions. There is no single official standard, so add a small legend to your diagram.

What tool is best for user flow diagrams?

FigJam and Miro are popular for collaborative work, Whimsical for quick and clean diagrams, Lucidchart for detailed documentation, draw.io as a free option, and Mermaid for text-based flows kept alongside code. Pen and paper is still the fastest way to start.

How detailed should a user flow be?

Detailed enough to show every screen, decision and outcome for one goal, including errors and exits, but not so detailed that it describes every UI element. If a single diagram becomes hard to read, split it into smaller linked flows.

Design it with floow

Turn a finished flow into screens you can review side by side on one canvas. Try this prompt in floow: "Design the full iOS sign-up flow for a recipe app: welcome, sign-up options with Apple, Google and email, email and password, check your inbox, email already registered error, and a success screen leading into onboarding."

Design your mobile app with AI.

Generate pixel-perfect iOS and Android screens in seconds, then export to Figma or code.