Latest / 5 Minute UX / Using Task Flows to Map User Paths
Transcript
- 0:08This lesson is Using Task Flows to Map User Paths. Let's get
- 0:12started.
- 0:19Task flows are diagrams that identify the specific path users
- 0:22take through a website or application, utilizing visual
- 0:25elements similar to site maps. At the heart of any basic task
- 0:28flow are decision nodes, which ask a definitive question like,
- 0:32"Is the user logged in?" From this point, branching paths
- 0:35represent distinct routes based on the answer, where "Yes" leads
- 0:38directly to a Logged-In Page, while "No" directs the user to a
- 0:41Not Logged-In Page. These routes eventually converge on
- 0:44terminal states, which are the final pages or states reached,
- 0:47such as the Home Page, the Logged-In Page, or the Not
- 0:50Logged-In Page. By clearly identifying these three
- 0:53structural components, you can construct diagrams that
- 0:55distinguish user decision nodes, branching paths, and terminal
- 0:59states to clarify complex application processes.
- 1:08You've already seen how a task flow maps the user's journey
- 1:10through decision nodes and branching paths. Now, let's
- 1:13clarify where that fits versus a site map. A site map
- 1:15communicates the visual hierarchy of a site’s or
- 1:17application’s layout, showing how pages nest and relate to one
- 1:20another. A task flow, however, provides details of users’
- 1:23options and the specific paths they will be able to take. While
- 1:26they may appear similar at first glance, they serve distinct
- 1:28purposes in information architecture, which means you
- 1:31can't just swap one for the other without losing critical
- 1:33context. Think about the login example we just covered. The
- 1:36site map shows you that a Logged-In Page and a Not Logged-
- 1:39In Page exist within the structure. The task flow
- 1:41explains the decision node, "Is the user logged in?", and how
- 1:44that answer dictates which of those pages the user actually
- 1:47reaches. One is a static blueprint of the space, while
- 1:49the other is a dynamic map of movement through that space. You
- 1:52need both to fully understand the user experience, but they
- 1:55answer fundamentally different questions about how the product
- 1:57works and how people navigate it.
- 2:05In practice, task flows serve three specific contexts that
- 2:07clarify user behavior before code is written. First, for
- 2:10information display, they work alongside your site map to show
- 2:13exactly how a user arrives at a page with a specific set of
- 2:15information displayed. This ensures the content matches the
- 2:18path that led the user there, not just the destination itself.
- 2:21Next, they drive mental model alignment by illustrating how a
- 2:24specific user type expects to traverse a website. You are
- 2:26mapping what that persona expects to see based on their
- 2:29personal mental model, rather than guessing their next click.
- 2:32If the flow contradicts their expectations, the friction is
- 2:35visible immediately on the diagram. Finally, they provide
- 2:37pre-development clarity by identifying complex processes
- 2:40that must be clearly understood before the project is handed off
- 2:43to the development team. This prevents costly rework later
- 2:46when engineers discover an ambiguous state they weren't
- 2:48told about. These three uses turn the flow from a static
- 2:51drawing into a functional bridge between design intent and
- 2:53technical execution.
- 3:01The workflow for testing and development moves from broad to
- 3:04specific, ensuring the final build matches user intent. You
- 3:06start by creating a high-level task flow that identifies the
- 3:09different paths a user could take. In a travel-shopping
- 3:12application, for example, this maps three distinct paths based
- 3:15on how users prioritize results by price, date flexibility, or
- 3:18schedule. Next, you use this high-level flow to direct user
- 3:21testing. This step ensures the detailed flow for each path
- 3:24meets user needs before resources are committed to
- 3:26building them. By testing against the high-level map, you
- 3:29verify that the branching logic actually aligns with how people
- 3:32expect to traverse the application. Once the high-
- 3:35level paths are validated, you create detailed task flows for
- 3:38each of the high-level paths. These detailed diagrams specify
- 3:41the exact decision nodes, branching paths, and terminal
- 3:43states for every route. Finally, you provide these detailed task
- 3:47flows to the development team to create the pages necessary for
- 3:50testing. This handoff gives developers a clear, tested
- 3:52blueprint for the interface.
- 4:01So, let's apply this to a real scenario. In a travel-shopping
- 4:04application, users set dates to search and then face a critical
- 4:08decision node: they can prioritize results by price,
- 4:10flexibility of travel dates, or travel times. Your high-level
- 4:13task flow identifies these three distinct paths based on
- 4:16prioritization. This structure isn't just for documentation; it
- 4:20provides direction to persons facilitating user testing. It
- 4:23ensures the detailed flow for each path meets user needs
- 4:25before development begins. Think about your current
- 4:28project. Identify one complex process that requires pre-
- 4:31development clarity via a task flow. Where do your users make
- 4:34choices that lead to different terminal states? Map those
- 4:37branching paths now. By clarifying these options before
- 4:40handing off to the development team, you ensure the pages
- 4:43created for testing actually reflect how users expect to
- 4:46traverse your application. This is where your task flow moves
- 4:49from a diagram to a functional tool for alignment.
- 4:54Welcome to The Take. I'm joined by a fellow practitioner and
- 4:57together we're going to dig into Using Task Flows to Map User
- 5:01Paths — what it means in practice and what's worth
- 5:03remembering.
- 5:05[HOST] I keep thinking about that distinction between the
- 5:08static site map and the dynamic task flow. [LEARNER] Yeah,
- 5:11that's where most teams get tripped up. [HOST] We treat the
- 5:14site map as the source of truth, but it misses the decision logic
- 5:18entirely. [LEARNER] Exactly. It shows the rooms exist, but not
- 5:21how the user chooses which door to walk through. [HOST] And
- 5:25that's where the friction hides. [LEARNER] It does. I had a
- 5:28client who thought their checkout was broken because
- 5:31users were dropping off. [HOST] Was it actually broken, or was
- 5:34the path just counterintuitive? [LEARNER] The path. They
- 5:37expected to see shipping costs before entering payment details.
- 5:41[HOST] The diagram would have shown that branching path
- 5:44immediately. [LEARNER] If we had drawn it, sure. But we skipped
- 5:47the flow and went straight to the UI. [HOST] That’s the pre-
- 5:50development clarity gap. [LEARNER] It is. Engineers
- 5:53guessed the state transitions, and we ended up with a mess.
- 5:56[HOST] I wonder if AI tools are changing how we approach this.
- 6:00[LEARNER] How so? [HOST] They can generate the initial
- 6:03structure from a text description of the user journey.
- 6:06[LEARNER] I’ve seen that. It’s fast, but it often misses the
- 6:09nuance of the decision nodes. [HOST] It maps the likely path,
- 6:12not the edge cases. [LEARNER] Right. It assumes the "Yes"
- 6:15branch is the primary one. [HOST] But in reality, the "No"
- 6:19branch is often where the confusion lives. [LEARNER]
- 6:22Absolutely. The error states are the real product. [HOST] So the
- 6:25AI drafts the skeleton, but we have to flesh out the friction
- 6:28points. [LEARNER] That’s the right division of labor. [HOST]
- 6:32We shouldn't let the tool do the thinking for us. [LEARNER] No.
- 6:35It just saves us the time to draw the boxes. [HOST] Which
- 6:38lets us focus on why the boxes are there in the first place.
- 6:42[LEARNER] Exactly. The "why" is still human work. [HOST] And
- 6:45that's where the real alignment happens.