Map the user flow for a task, with decision points and edge cases
FreeTurn any task into a complete user flow: happy path, decision points, edge cases, exit states, and a ready-to-paste Mermaid flow diagram.
A build-ready user flow map for any task — the happy path, every decision branch, edge case and error state, all exits, and a renderable flow diagram — that a designer or engineer can build from without follow-up questions.
Your details
saved for every promptThis prompt
You are a senior UX/interaction designer who maps user flows that design and engineering can build from directly.
Map the complete user flow for a user trying to {{task_goal}} in {{product}} on {{platform}}. Aim for a result complete enough that a designer or engineer could build every screen and state without asking you a follow-up question: it covers the shortest happy path plus every decision point, alternate path, error state, and exit.
Use only the details given below. Where something isn't provided, surface it as an open question instead of inventing product behavior.
<flow_context>
- Product: {{product}}
- Task the user wants to complete: {{task_goal}}
- Platform / surface: {{platform}}
- Who the user is: {{audience}}
- Where the flow starts (entry point): {{entry_point}}
- What "done" looks like (success outcome): {{success_outcome}}
- Known rules, steps, or constraints: {{known_constraints}}
</flow_context>
Work through it in this order:
1. State the flow's scope in one line: the actor, the entry point, and the success outcome.
2. Map the happy path — the shortest route from entry to success — as an ordered list of steps. For each step, name the screen or state, the user's action, and the system's response.
3. At each step, mark any decision point where the flow branches. Label each branch with the exact condition that sends the user down it (for example, "email on file" vs "email not found").
4. Enumerate the alternate paths and edge cases the happy path skips: empty states, invalid input and validation failures, expired links or timeouts, permission or access blocks, rate limits, network or server errors, and user-initiated back / cancel / abandon.
5. Define every exit point — both success exits and failure or abandonment exits — and where each leaves the user.
6. Express the whole flow as a Mermaid flowchart (flowchart TD), with screens and states as rectangles and decision points as diamonds.
7. List your assumptions and any open questions where the context was silent.
Return your answer in this structure:
- Flow scope — one line (actor, entry, success).
- Happy path — a table with columns: Step | Screen/State | User action | System response.
- Decision points — a list; each written as "At [step]: if [condition] then [path A], else [path B]".
- Edge cases & error states — a table with columns: Trigger | What the user sees | Recovery path.
- Exit points — success exits and failure/abandon exits, listed separately.
- Flow diagram — a Mermaid flowchart TD covering the happy path, branches, and error states.
- Assumptions & open questions — bullets; put anything the context didn't specify here rather than guessing.
Constraints:
- Ground every step in the provided context; when product behavior isn't specified, add it to open questions instead of inventing it.
- Give each decision point exactly one clearly worded condition, and account for every branch it opens.
- Keep node labels short (2–5 words) and each state distinct — represent two different screens as two nodes.
- Include at least one successful exit and at least one abandonment or failure exit.10 fields still empty — the {{like_this}} slots fill in as you type.
See it in action
What this prompt produces with example details filled in:
**Flow scope** — A locked-out existing user resets a forgotten password from the login screen and ends logged in on their dashboard.
**Happy path**
| Step | Screen/State | User action | System response |
|---|---|---|---|
| 1 | Forgot-password form | Enters account email, submits | Validates format, sends reset email if the account exists, shows "Check your inbox" |
| 2 | Check-inbox confirmation | Opens email, clicks reset link | Verifies link is valid and unexpired, opens the reset form |
| 3 | Set-new-password | Enters and confirms new password, submits | Checks strength rules, saves password, invalidates the link |
| 4 | Auto sign-in | (none) | Logs the user in, redirects to dashboard with a "Password updated" toast |
**Decision points**
- At step 1: if email format is invalid then show inline error and stay on form, else proceed.
- At step 1: if the email belongs to an SSO account then show "Sign in with your identity provider" and send no email, else send the reset email.
- At step 1 (anti-enumeration): show the same "Check your inbox" screen whether or not the email is on file; only actually send mail when the account exists.
- At step 2: if the link is expired or already used then show "Link expired" with "Send a new link", else open the reset form.
- At step 3: if the password fails strength rules or the two entries don't match then show inline errors and stay on form, else save.
**Edge cases & error states**
| Trigger | What the user sees | Recovery path |
|---|---|---|
| Email not on file | Same "Check your inbox" screen, no mail sent | Re-check email, or "Contact support" link |
| SSO-managed account | "Your account uses SSO — sign in there" | Deep link out to the SSO provider |
| Reset link expired (>60 min) | "This link has expired" | "Send a new link" returns to the check-inbox step |
| Reset link already used | "This link is no longer valid" | "Send a new link" |
| Weak password or mismatch | Inline field errors | Correct input, resubmit (entries preserved) |
| Account locked (5 failed logins) | "Account locked for 15 minutes" banner on login, timer shown | Wait, or complete the reset flow to regain access |
| Network / server error on submit | "Something went wrong — try again" with a retry button | Retry; form data is preserved |
| User closes the tab mid-flow | — | Reset link stays valid until it expires; resume from the email |
**Exit points**
- Success exits: new password saved, auto signed in, lands on dashboard.
- Failure / abandon exits: redirected out to the SSO provider; tab closed (link valid until expiry); repeated dead ends route to "Contact support".
**Flow diagram**
```mermaid
flowchart TD
A[Login screen] -->|Taps Forgot password| B[Enter email]
B --> C{Email format valid?}
C -->|No| B
C -->|Yes| D{SSO account?}
D -->|Yes| E[Use SSO provider]
D -->|No| F[Check your inbox]
F --> G{Link valid and unexpired?}
G -->|No| H[Link expired]
H --> F
G -->|Yes| I[Set new password]
I --> J{Meets rules and matches?}
J -->|No| I
J -->|Yes| K[Save, invalidate link]
K --> L[Auto sign-in to dashboard]
```
**Assumptions & open questions**
- Assumed the reset email arrives promptly. Not specified: is there a cooldown or daily cap on how often a user can request a new link?
- Not specified: does setting a new password sign out other active sessions?
- Not specified: is there a CAPTCHA or bot check on the request form?
- Assumed the "Account locked (15 min)" state blocks login attempts but does not block a password-reset request.Tips
- Load real product rules into known_constraints (expiry times, lock-outs, permissions, plan limits) — that's where the valuable edge cases come from.
- Paste the Mermaid block into any tool that renders it (mermaid.live, Notion, GitHub, most Markdown editors) to see the diagram.
- Run it once per task or goal; keeping separate flows apart stays far cleaner than one mega-flow.
- To go deeper, follow up with 'expand each error state into its own recovery sub-flow' or 'add the system/API calls behind each step.'
Built by Web Innoventix
Want the work done, not just prompted? We design, build and rank websites that get found on Google and cited by AI.
Get a free quoteMore prompts
Browse all →Turn a rough UI idea into a build-ready design prompt
Turn a vague UI idea into a precise, generation-ready design prompt — a one-line vibe, a named-colour design system, and a numbered page structure — that v0, Stitch, Lovable, or Claude can render into a polished first screen on the first try.
Design critique that returns prioritised fixes
Get a senior product-design critique of any screen — specific, located, severity-ranked usability fixes tied to real heuristics, not vague praise.
Design a first-run onboarding flow to your product's aha moment
A ready-to-paste ChatGPT prompt that interviews you about your product, then designs a first-run app onboarding flow that walks new users to their aha moment — delivered as a build-ready spec.
Plan your product's information architecture and sitemap
A paste-and-go ChatGPT prompt that interviews you about your product and users, then delivers a full information architecture and sitemap — navigation model, page hierarchy, URL scheme, and key user flows.
Interview a user and turn it into a UX research brief
A paste-and-go ChatGPT prompt that runs a professional UX discovery interview one question at a time, then synthesizes your answers into a structured, shareable UX research brief.
Generate a design token system with light and dark palettes
A paste-and-go ChatGPT prompt that briefly interviews you, then generates a complete light and dark design token system — primitives, semantic tokens, and WCAG-checked contrast — ready to export as CSS variables, DTCG JSON, or a Tailwind config.

