Task Analysis for Usability Testing: Understanding What Users Are Actually Trying to Do

Task Analysis for Usability Testing: Understanding What Users Are Actually Trying to Do

Before you can test whether users can complete tasks, you need to understand what those tasks actually are. Task analysis is the method for doing that systematically.

"Place an order" is a goal. The task to place an order involves selecting a product, configuring options, adding to cart, entering shipping information, selecting payment, reviewing, and confirming. Each step has sub-steps, each with its own cognitive demands and failure modes.

Task analysis makes this structure explicit. Without it, you're testing the surface of a task, missing the complexity that causes real failures.

What Task Analysis Is (and Isn't)

Task analysis is a method for understanding the cognitive and procedural structure of how users accomplish goals.

It answers:

  • What steps does a user take to accomplish this goal?
  • What knowledge does each step require?
  • Where do decisions happen?
  • What can go wrong at each step?
  • What information does the user need at each step?

Task analysis is not:

  • A list of features to test
  • A test script
  • A requirements document

The output is a model of user behavior — how users accomplish goals — not a specification of how the system should work.

Hierarchical Task Analysis (HTA)

HTA breaks goals into a hierarchy of tasks and sub-tasks. Developed by Annett and Duncan in 1967, it remains the most widely used task analysis method.

The structure

Goal: Process a customer refund

Task 1: Locate the order
  1.1 Navigate to Order Management
  1.2 Search by order ID or customer email
  1.3 Select the correct order

Task 2: Initiate the refund
  2.1 Click Refund button
  2.2 Select items to refund (full or partial)
  2.3 Enter refund reason
  2.4 Choose refund method (original payment / store credit)

Task 3: Confirm and process
  3.1 Review refund summary
  3.2 Confirm refund
  3.3 Verify confirmation email sent

Plans (the conditions):
Plan 0: Do tasks 1, 2, 3 in sequence
Plan 1: If order not found by ID, try customer email search
Plan 2: If original payment unavailable, default to store credit

The "plans" specify the decision logic — what determines the order and selection of sub-tasks.

Building an HTA

Step 1: Define the goal

Start at the user goal level, not the system function level. "Process a refund" is a goal. "Click the Refund button" is a step within the task, not the goal.

Step 2: Decompose to manageable sub-tasks

Keep decomposing until sub-tasks are small enough to be atomic operations — a single action with a clear trigger and completion state.

The stopping rule: stop decomposing when the level of detail is sufficient for your purpose. For interface design, stop at "click button" or "enter text." For training design, you might go deeper. For error analysis, keep going until you've identified individual decision points.

Step 3: Identify plans

Plans describe the conditional logic: "if X, then do Y instead of Z." Document the branching conditions at each level.

Step 4: Annotate with error conditions

At each step, ask: what could go wrong? What errors can occur? This produces the failure taxonomy for your testing.

Using HTA for test design

HTA directly generates test cases:

  • Each plan branch becomes a test scenario
  • Each step becomes a point to observe in usability testing
  • Each error condition becomes an error path test

The task "Search by order ID or customer email" with plan "if order not found by ID, try customer email" generates scenarios:

  1. Search with valid order ID (happy path)
  2. Search with invalid order ID, then recover with email (branch execution)
  3. Search where email matches multiple orders (edge case)

HTA makes sure you don't miss scenarios by making the branching structure explicit.

Cognitive Task Analysis (CTA)

HTA models the procedural structure of tasks. CTA goes deeper: it models the knowledge and mental processes required.

CTA methods focus on:

  • Knowledge requirements: What does the user need to know to complete this step?
  • Mental workload: How much cognitive effort does this step require?
  • Decision points: Where does the user make choices? On what information?
  • Error patterns: Where do cognitive errors occur and why?

Critical Decision Method (CDM)

CDM, developed by Gary Klein, is used for complex expert tasks where the decision process isn't obvious from observation.

Process:

  1. Identify a critical incident (a real situation where the user had to make a difficult decision)
  2. Interview the expert about the incident in detail
  3. Probe the decision point: what information did they use? What alternatives did they consider? What would a novice have done differently?

For usability testing of expert-facing tools, CDM is valuable for understanding the cognitive demands the interface must support.

GOMS Analysis

GOMS (Goals, Operators, Methods, Selection rules) is a formal cognitive task analysis framework used to predict expert performance.

Goals: What the user wants to achieve Operators: Elementary cognitive and physical actions (keystroke, mouse click, mental recall) Methods: Sequences of operators that accomplish a goal Selection rules: Rules for choosing between methods when multiple options exist

GOMS is used to:

  • Predict task completion times for expert users
  • Compare design alternatives quantitatively
  • Identify efficiency bottlenecks

It requires significant expertise to apply correctly and is overkill for most product design contexts. Most teams use HTA for structure and CDM for decision-heavy workflows.

Task Analysis for Test Scenario Creation

The primary usability testing application: creating scenarios that accurately represent real user tasks.

From HTA to scenario

Bad scenario (based on system function): "Click on Settings, find the Notifications section, uncheck the Daily Summary checkbox."

Good scenario (based on task analysis): "You've been receiving daily email summaries that you don't have time to read. You want to stop getting them. Show me how you'd do that."

The difference:

  • The bad scenario describes the solution path, eliminating the discovery challenge
  • The good scenario describes the user goal, preserving the navigation and discovery challenge

HTA gives you the goal. The scenario communicates the goal to the participant in their language, without revealing the solution path.

Scenario realism checks

For each scenario, verify:

  1. Is this a real goal users have? (Not a feature tour)
  2. Does the scenario use user vocabulary, not system vocabulary?
  3. Does the scenario reveal the solution path? (If yes, rewrite it)
  4. Is the success criterion clear? (Both to the participant and the observer)
  5. Is the motivation real? (High-stakes scenario or routine task, as appropriate)

Task Mapping: Finding Where Interfaces Fail

Task analysis produces a task map. The interface design supports (or fails to support) each step.

Alignment analysis

For each task step in the HTA:

  • Is there an interface element that directly supports this step?
  • Is it easily discoverable?
  • Does the interface label match the user's vocabulary for this step?
  • Is the required information available at the point of decision?

Where alignment fails, usability problems exist. This analysis can be done as a design review before user testing, flagging the likely failure points.

Cognitive friction points

Some task steps have high cognitive demands. HTA identifies them by looking for:

  • Steps with complex plans (many conditions)
  • Steps requiring information recall from earlier in the task
  • Steps where multiple valid options exist
  • Steps where errors have severe consequences

These are the steps worth deepening in usability testing — more observation time, more probing.

Task Analysis in Practice

Quick task analysis for sprint planning

Full HTA takes hours. A lightweight version for sprint planning:

  1. Write the user goal (1 sentence)
  2. List the main steps (5–10 steps)
  3. Note the 2–3 most complex decision points
  4. Identify 2–3 likely failure modes

This takes 15–30 minutes per task and produces enough structure to write test scenarios and identify test priorities.

Task frequency and criticality matrix

Not all tasks deserve equal analysis depth. Prioritize by:

  • Frequency: How often do users perform this task?
  • Criticality: What's the impact if users fail this task?
Low Criticality High Criticality
High Frequency Full HTA + usability test Full HTA + CTA + usability test
Low Frequency Lightweight analysis Full HTA + usability test

High-frequency, high-criticality tasks (checkout, core data entry workflows, critical reports) justify full cognitive task analysis. Low-frequency, low-criticality tasks get lightweight coverage.

Involving users in task analysis

The best source for task analysis data is the users themselves. Methods:

Contextual inquiry: Observe users performing real tasks in their environment. Capture the actual steps, workarounds, and decision logic.

Structured interviews: Ask users to walk through a recent instance of the task step-by-step. "What did you do first? Then what? What were you thinking when you got to that step?"

Card sorting: For information architecture tasks, have users sort content cards to reveal their mental models for categorization.

Diary studies: Have users log their task-related activities over days or weeks. Captures real usage patterns, including infrequent edge cases.

Common Task Analysis Mistakes

Confusing system functions with user tasks: HTA of the system, not the user. Results in test scenarios that follow the feature list, not user goals.

Stopping too early: Decomposing to "Click Refund button" without capturing the decision logic that led there. Misses the cognitive complexity.

No error conditions: Mapping only the happy path. The error branches are where most usability failures occur.

Designing for the task model, not the user: Task analysis reveals what users do, not necessarily what they should do. Sometimes the task itself needs redesign (wrong steps, wrong order). Don't blindly optimize the interface for a broken task.

Skipping user validation: Task analysis built from system documentation and internal assumptions. Validate with actual users before designing tests around it.

Connecting Task Analysis to Usability Metrics

Task analysis enables meaningful usability metrics:

Task success rate: Did the participant complete the goal defined in the HTA? (Binary or partial credit)

Task completion path: Did the participant follow the expected task path or find an alternative? (Deviation from expected = system or HTA error)

Error rate per task step: At which HTA steps do errors cluster? (Points to redesign needs)

Time on task: Compared against GOMS-estimated expert time. Large deviations indicate cognitive friction.

Number of unnecessary steps: Steps the participant took that aren't in the HTA. Usually navigation errors or recovery actions.

Summary

Task analysis transforms usability testing from "let's watch people use the product" to "let's systematically examine how the interface supports each step of real user goals."

HTA gives you the task structure. CTA gives you the cognitive demands. Together they produce test scenarios grounded in what users actually need to do, identify the failure points worth testing deeply, and enable metrics that measure real user experience.

The investment pays off in test efficiency: you test what matters, at the right depth, with scenarios that accurately represent user reality.

Read more

Start now free