Usability Heuristics: Nielsen's 10 Rules for Interface Design

What & Why

In 1994, Jakob Nielsen distilled decades of usability research into 10 general principles for interaction design. These are not rigid rules. They are heuristics: broad guidelines that apply across virtually every interface, from command-line tools to mobile apps to VR environments.

Why do these matter? Because usability testing is expensive and slow. Heuristic evaluation gives you a fast, cheap way to find usability problems before users ever touch the product. Nielsen showed that 3-5 evaluators using these heuristics can identify roughly 75% of usability issues in a single afternoon. That is an extraordinary return on investment.

The 10 heuristics also serve as a shared vocabulary. When a designer says "this violates H4" (consistency), everyone on the team knows exactly what class of problem is being discussed. They turn subjective opinions ("I don't like this menu") into structured, actionable findings.

How It Works

The 10 Heuristics

H1: Visibility of System Status. The system should always keep users informed about what is going on, through appropriate feedback within reasonable time. Progress bars, loading spinners, and "saving..." indicators all serve this heuristic. A file upload with no progress indicator violates it.

H2: Match Between System and the Real World. The system should speak the user's language, with words, phrases, and concepts familiar to the user, rather than system-oriented terms. A shopping cart icon matches the real-world metaphor. An error message saying "ERRNO 0x4F2A" does not.

H3: User Control and Freedom. Users often choose system functions by mistake and need a clearly marked "emergency exit" to leave the unwanted state. Undo, redo, cancel, and back buttons all serve this heuristic.

H4: Consistency and Standards. Users should not have to wonder whether different words, situations, or actions mean the same thing. Follow platform conventions. If every other app uses a floppy disk icon for "save," do not use a cloud icon.

H5: Error Prevention. Even better than good error messages is a careful design that prevents a problem from occurring in the first place. Confirmation dialogs before destructive actions, disabled submit buttons until required fields are filled, and date pickers that prevent invalid dates all serve this heuristic.

H6: Recognition Rather Than Recall. Minimize the user's memory load by making objects, actions, and options visible. The user should not have to remember information from one part of the dialogue to another. Dropdown menus, autocomplete, and recently-used lists all reduce recall burden.

H7: Flexibility and Efficiency of Use. Accelerators, unseen by the novice user, may speed up the interaction for the expert user. Keyboard shortcuts, command palettes, and customizable toolbars serve both audiences.

H8: Aesthetic and Minimalist Design. Dialogues should not contain information that is irrelevant or rarely needed. Every extra unit of information competes with the relevant units and diminishes their relative visibility.

H9: Help Users Recognize, Diagnose, and Recover from Errors. Error messages should be expressed in plain language (no codes), precisely indicate the problem, and constructively suggest a solution. "File not found" is better than "Error 404." "The file 'report.pdf' was moved or deleted. Check your Downloads folder." is better still.

H10: Help and Documentation. Even though it is better if the system can be used without documentation, it may be necessary to provide help. Any such information should be easy to search, focused on the user's task, list concrete steps, and not be too large.

Heuristic Evaluation Process

Severity Rating Scale

Each violation is rated on a 0-4 scale:

Evaluator Coverage

Nielsen's research showed that the number of usability problems found follows a curve based on the number of evaluators $e$:

Where $L$ is the average proportion of problems found by a single evaluator (typically $L \approx 0.31$ for heuristic evaluation). With 5 evaluators:

So 5 evaluators find roughly 84% of problems. The cost-benefit curve flattens after 5, making additional evaluators less worthwhile.

Complexity Analysis

Heuristic evaluation has well-defined cost characteristics compared to other usability methods:

The severity-weighted problem count for an evaluation with $p$ problems is:

A higher weighted score indicates more severe overall usability debt. Teams typically prioritize fixing all severity 4 and 3 issues before addressing lower-rated problems.

Implementation

ALGORITHM HeuristicEvaluation(interface, heuristics, evaluators)
  INPUT: interface (set of screens/flows to evaluate),
         heuristics (list of 10 Nielsen heuristics),
         evaluators (list of 3-5 UX evaluators)
  OUTPUT: prioritized list of usability findings

  allFindings ← empty list

  FOR EACH evaluator IN evaluators DO
    findings ← empty list
    FOR EACH screen IN interface DO
      FOR EACH heuristic IN heuristics DO
        violations ← evaluator.inspect(screen, heuristic)
        FOR EACH violation IN violations DO
          findings.append({
            screen: screen,
            heuristic: heuristic.id,
            description: violation.description,
            location: violation.element,
            evaluator: evaluator.id
          })
        END FOR
      END FOR
    END FOR
    allFindings.append(findings)
  END FOR

  merged ← DeduplicateFindings(allFindings)

  FOR EACH finding IN merged DO
    severityVotes ← empty list
    FOR EACH evaluator IN evaluators DO
      severityVotes.append(evaluator.rateSeverity(finding))
    END FOR
    finding.severity ← mean(severityVotes)
  END FOR

  SORT merged BY severity DESCENDING
  RETURN merged
END ALGORITHM

ALGORITHM DeduplicateFindings(allFindings)
  INPUT: allFindings (list of lists, one per evaluator)
  OUTPUT: merged list with duplicates combined

  unique ← empty map keyed by (screen, heuristic, location)

  FOR EACH evaluatorFindings IN allFindings DO
    FOR EACH finding IN evaluatorFindings DO
      key ← (finding.screen, finding.heuristic, finding.location)
      IF key NOT IN unique THEN
        unique[key] ← finding
        unique[key].foundByCount ← 1
      ELSE
        unique[key].foundByCount ← unique[key].foundByCount + 1
      END IF
    END FOR
  END FOR

  RETURN values(unique)
END ALGORITHM

ALGORITHM ProblemsCoverage(numEvaluators, L)
  INPUT: numEvaluators (integer >= 1), L (proportion, default 0.31)
  OUTPUT: estimated percentage of problems found

  coverage ← 1 - (1 - L) ^ numEvaluators
  RETURN coverage * 100
END ALGORITHM

Real-World Applications

• Google's Material Design: Codifies H4 (consistency) across all Google products with shared components, spacing, and interaction patterns
• GitHub's error pages: The 404 page uses plain language and a search bar (H9: help users recover from errors) instead of just showing a code
• Slack's keyboard shortcuts: Cmd+K command palette serves H7 (flexibility and efficiency) by letting power users navigate without touching the mouse
• Amazon's 1-Click ordering: Eliminates unnecessary steps (H8: minimalist design) and prevents the error of accidentally ordering twice (H5: error prevention) with a brief undo window
• iOS confirmation dialogs: "Delete this photo?" with a red "Delete" button serves H3 (user control) and H5 (error prevention) simultaneously
• VS Code's command palette: Surfaces all available actions with fuzzy search (H6: recognition over recall, H7: flexibility)
• Stripe's API error messages: Include the error type, a human-readable message, and a link to documentation (H9 and H10 combined)
• Figma's multiplayer cursors: Real-time visibility of other users' cursors and selections serves H1 (system status) in a collaborative context, showing who is editing what
• Notion's slash commands: Typing "/" reveals a contextual menu of block types, serving H7 (flexibility) for power users while keeping the default interface minimal (H8)
• Google Maps' "Did you mean?": When a search returns unexpected results, Maps suggests alternatives, combining H5 (error prevention) with H9 (error recovery)

Key Takeaways

• Nielsen's 10 heuristics are not a checklist to pass or fail. They are lenses for identifying usability problems across any interface
• Heuristic evaluation with 3-5 evaluators finds roughly 75-85% of usability problems at a fraction of the cost of full user testing
• Severity ratings (0-4) turn subjective opinions into prioritized, actionable backlogs
• The most commonly violated heuristics in practice are H1 (visibility of system status), H4 (consistency), and H9 (error recovery)
• Heuristic evaluation complements but does not replace user testing. Evaluators find different problems than real users do
• The heuristics work best as a shared vocabulary: when everyone on the team knows "H3," discussions about undo/cancel become precise and productive