You will map the three navigation layers required for usability testing and define the standard response for unexpected user actions. This capability ensures your prototype handles dead-ends gracefully without requiring full-scale development of every possible path.
Learning Objective: By the end of this lesson, learners will be able to outline the three layers of navigation and define the standard response for alternate paths during the planning phase.
When you build a prototype for user testing, you need to map three specific navigation layers. First are the main pages required to complete the selected tasks. These are the core screens where the primary action happens. Second are the intermediate pages that appear between main steps. These connect your major actions, often holding forms or confirmation states. Third are the alternate paths that users might take unexpectedly. This is where things get tricky, because users rarely follow your intended script perfectly.
You don't need to fully detail or build every single alternate path. However, you must plan a specific response for any direction a user might go that is not part of the primary task flow. The standard approach is a simple page stating that a certain path is not available. Crucially, this page must request the user to return to the previous page to try again. This keeps the test moving without breaking the flow.
Recognizing these three layers early prevents dead ends during your sessions. It ensures you have a clear strategy for when users wander off the main path.
Key Points:
Main pages required to complete the selected tasks
Intermediate pages that appear between main steps
Alternate paths that users might take unexpectedly
Imagine a user clicks a link that wasn't part of the planned task. You do not need to fully detail or build every alternate path to handle this. Instead, you must plan a specific response for any direction a user might take that is not part of the primary task flow. This approach keeps your prototype lightweight while ensuring the test doesn't stall.
The solution is a standard response page. It is a simple page stating that a certain path is not available. This immediately signals to the participant that this specific route is a dead end. You are not hiding the feature; you are just acknowledging its absence in this context.
There is one critical requirement for this page. It must include a clear action request. The page must request the user to return to the previous page to try again. This instruction prevents confusion and guides them back into the main flow.
By using this simple two-part structure, you maintain control over the test. You avoid the massive overhead of building out every possible branch. You simply provide a clear, honest boundary. When you outline this during the planning phase, you define exactly how these dead ends will be handled, ensuring a smooth session.
Key Points:
Do not fully detail or build every alternate path
Standard Response: A simple page stating that a certain path is not available
Action Request: The page must request the user to return to the previous page to try again
You've already mapped the main pages and set the standard response for dead ends. Now you need to lock down what goes into the prototype before you build a single screen. The pages included in the prototype are closely tied to the specific tasks chosen for the test. This connection matters because the scope of required pages varies greatly depending on the type of tasks included. A simple content retrieval task needs far fewer screens than a complex multi-step checkout flow. If you don't outline the list of pages, main, intermediate, and alternate, during the planning phase, you're guessing at your scope.
Take a moment to look at your current task list. Which of these tasks pulls in the most intermediate screens? Which one has the most likely alternate paths? The structural list of pages and paths should be outlined during planning, while the specifics of the tasks go into the discussion guide. This separation keeps your documentation clean and your build focused. When you apply the planning-phase documentation strategy for main, intermediate, and alternate pages, you eliminate the guesswork that usually derails a prototype build.
This clear outline defines exactly what you need to simulate.
Key Points:
Pages included in the prototype are closely tied to the specific tasks chosen
Scope of required pages varies greatly depending on the type of tasks included
Outline the list of pages (main, intermediate, and alternate) during the planning phase
[2s]
If your new design features highly interactive elements, you must simulate the navigation flow realistically to test the actual user experience. You build this prototype quickly, before full-scale development begins, which keeps the feedback loop tight and the costs low.
The reason this timing matters is that the structural list of pages needs to be outlined during the planning phase. This list includes the main pages, the intermediate steps, and the alternate paths you have mapped out.
However, the specific details of each task belong in the discussion guide, not in the prototype itself. This separation lets you focus on the structure of the interface while handling the content through your testing script.
So when you sit down to plan, you apply the planning-phase documentation strategy for main, intermediate, and alternate pages. You define the skeleton of the test before you build the flesh of the interactive elements.
This approach ensures that your prototype reflects the real navigation flow, while your documentation captures the specific task requirements. You get a realistic test environment without the overhead of full development.
Key Points:
For new designs with highly interactive elements, simulate navigation flow realistically
Create the prototype quickly, before full-scale development begins
Task specifics go into the discussion guide; structural list of pages goes into planning