What are the 10 usability heuristics?

Nielsen's 10 usability heuristics are a set of general principles for user interface design developed by Jakob Nielsen in 1994. They cover everything from keeping users informed of system status to preventing errors and providing helpful documentation. They remain the most widely used framework for heuristic evaluation in UX practice today.

Who is Jakob Nielsen?

Jakob Nielsen is a Danish web usability consultant and co-founder of the Nielsen Norman Group, one of the world's leading UX research and consulting firms. He developed his 10 usability heuristics in 1994, building on earlier work with Rolf Molich. Nielsen's research on discount usability methods - including heuristic evaluation - transformed how the industry approaches early-stage design critique.

What is the difference between heuristics and guidelines?

Heuristics are broad, principle-level rules of thumb that can be applied across many contexts - they require judgment to use well. Guidelines are more specific, prescriptive rules tied to particular platforms or design systems (for example, Apple's Human Interface Guidelines). Heuristics are better for early evaluation; guidelines are better when designing within a known platform ecosystem.

How many heuristics do you need to evaluate a design?

Nielsen's research suggests that a single evaluator using all 10 heuristics finds around 35% of usability problems. For better coverage, three to five evaluators working independently then comparing findings typically uncovers 75% or more of issues. You do not need to use all 10 in every review - apply the heuristics most relevant to the interface type and user task you are examining.

Nielsen's 10 Usability Heuristics (With Examples)

Nielsen's 10 usability heuristics are a set of general principles for evaluating the quality of a user interface, developed by Jakob Nielsen in 1994 and still the most widely applied framework in UX practice today.

If you are learning UX design or conducting your first heuristic evaluation, understanding these ten principles is essential. They do not tell you exactly what to build - they give you a lens for spotting problems in what already exists. Each heuristic addresses a different dimension of usability in UX design, and together they cover the most common ways interfaces fail users.

Why These Heuristics Still Matter

Nielsen published his original list in 1994 after analysing 249 usability problems. The heuristics were updated and refined in 2020, but the core ideas have not changed much - because the fundamental ways humans interact with systems have not changed much either. Whether you are reviewing a mobile app, a checkout flow, or a dashboard, these principles apply.

They are not a checklist. Applying them well requires judgment about context, user goals, and the severity of each problem you find. But they give you a shared vocabulary and a systematic way to move through an interface.

Nielsen's 10 Usability Heuristics Explained

1. Visibility of System Status

The principle: The system should always keep users informed about what is going on, through appropriate feedback within a reasonable time.

Why it matters: Users need to know whether their actions have registered and what the system is doing. Silence creates anxiety and leads to repeated clicks, abandoned tasks, or mistaken assumptions.

Example: When you upload a file to Google Drive, a progress indicator appears in the bottom-right corner showing the percentage complete. When it finishes, you see a confirmation. Without this, users would have no idea whether the upload succeeded or stalled.

2. Match Between System and the Real World

The principle: The system should speak the users' language, using words, phrases, and concepts familiar to the user rather than system-oriented terms. Information should appear in a natural and logical order.

Why it matters: When interfaces use jargon or metaphors that do not match how users think about a task, they create unnecessary cognitive load.

Example: Apple's Notes app uses a yellow legal-pad icon and a simple text editor that resembles writing on paper. The familiar metaphor reduces the learning curve - you do not need to learn new concepts to start using it. Compare that to early word processors that used terms like "carriage return" - meaningful to typists, confusing to everyone else.

3. User Control and Freedom

The principle: Users often choose system functions by mistake and need a clearly marked "emergency exit" to leave the unwanted state without having to go through an extended dialogue.

Why it matters: Errors and accidental actions are inevitable. If users cannot easily undo or escape, they lose confidence and trust in the product.

Example: Gmail's "Undo Send" feature, which gives you a short window to recall an email after hitting send, is a textbook application of this heuristic. It does not prevent the mistake - it gives you a recovery path before the consequences become permanent.

4. Consistency and Standards

The principle: Users should not have to wonder whether different words, situations, or actions mean the same thing. Follow platform conventions.

Why it matters: Inconsistency forces users to relearn how your interface works every time they encounter something new. It also signals a lack of care.

Example: If your app uses "Delete" in one section and "Remove" in another for the same action, users must pause and interpret whether there is a meaningful difference. Consistent language - across labels, icons, and interactions - lets users transfer what they already know from one part of the interface to another.

5. Error Prevention

The principle: Even better than good error messages is a careful design that prevents a problem from occurring in the first place.

Why it matters: Recovering from errors is frustrating and time-consuming. Designing to prevent them is almost always better than designing to handle them gracefully after the fact.

Example: When you book a flight on most airline websites, departure dates in the past are greyed out and unselectable. You cannot make that mistake. A confirmation dialogue before permanently deleting files serves the same purpose - it adds a moment of friction precisely where an irreversible action is about to happen.

6. Recognition Rather Than Recall

The principle: Minimise 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.

Why it matters: Human working memory is limited. Interfaces that require users to remember things across screens or sessions create unnecessary mental effort and increase error rates.

Example: Google's search bar autocomplete is a simple application of this principle - rather than requiring you to type an exact query from memory, it surfaces likely completions based on what you have started typing. Similarly, showing a user's recent orders on a returns page means they do not have to hunt for an order number before they can begin.

7. Flexibility and Efficiency of Use

The principle: Accelerators - unseen by the novice user - may often speed up the interaction for the expert user such that the system can cater to both inexperienced and experienced users.

Why it matters: A product that only serves beginners frustrates power users. A product that only serves experts excludes newcomers. Good interfaces offer layers that reveal themselves as users develop proficiency.

Example: Figma offers keyboard shortcuts for almost every action, but none of them are required - a new user can do everything through menus and toolbars. As designers become more experienced, they adopt shortcuts that dramatically accelerate their workflow. The interface does not change; what changes is how much of it each user reaches.

8. Aesthetic and Minimalist Design

The principle: Dialogues should not contain irrelevant or rarely needed information. Every extra unit of information in a dialogue competes with the relevant units of information and diminishes their relative visibility.

Why it matters: More is not better in interface design. Clutter competes for attention, obscures what matters, and signals to users that the designer did not understand their priorities.

Example: Airbnb's search results pages are deliberately sparse - a photo, a price, a star rating, and a handful of key details. Every piece of secondary information (host language, cancellation policy, amenities) is one click away but not on the card. This is not minimalism for aesthetic reasons - it is minimalism in service of the decision users are actually trying to make.

9. Help Users Recognise, Diagnose, and Recover from Errors

The principle: Error messages should be expressed in plain language (no codes), precisely indicate the problem, and constructively suggest a solution.

Why it matters: When something goes wrong, users are already frustrated. A cryptic error message adds insult to injury. A clear, actionable one can recover the situation.

Example: When you enter an invalid email address in a form, a good error message says "Please enter a valid email address, for example name@domain.com" - not "Input validation error: field 3." It names the field, shows the format expected, and gives the user everything they need to fix it immediately. Compare that to the generic "Something went wrong" message that tells users nothing about what to do next.

10. Help and Documentation

The principle: 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 to be carried out, and not be too large.

Why it matters: Complex products inevitably have edge cases where users need guidance. Help that is buried, jargon-heavy, or generalised is almost as useless as no help at all.

Example: Notion's inline help tooltips appear on hover for each formatting option, and their help centre is structured around tasks ("How do I share a page?") rather than features ("About sharing"). Users searching for help during a task need task-oriented answers, not feature documentation.

How to Apply the Heuristics in Practice

You do not need to be a senior UX designer to use Nielsen's heuristics - but you do need a method. The standard approach is to walk through an interface systematically, attempting key user tasks while asking yourself which heuristics each screen satisfies or violates. Work through the ten principles one at a time, or use them as a lens you shift between as you explore.

For each issue you find, record:

Which heuristic it violates
Where it occurs in the interface
A severity rating (cosmetic, minor, major, or catastrophic)
A brief description of the problem and a suggested fix

Running three to five evaluators independently and then aggregating findings dramatically improves coverage. One evaluator working alone will miss a significant proportion of issues - different people notice different things, and the heuristics are broad enough that two evaluators often apply them to different aspects of the same screen.

For a deeper walkthrough of the method itself - including how to plan an evaluation session, recruit evaluators, and present findings to a product team - see our guide to heuristic evaluation.

What Nielsen's Heuristics Do Not Cover

The 10 heuristics are powerful but not exhaustive. They focus on interaction design principles - they do not directly address performance, content strategy, or the emotional dimensions of experience. Accessibility in particular sits alongside the heuristics rather than within them: designing for screen readers, keyboard navigation, and WCAG 2.2 compliance requires its own specialised knowledge, which our Accessibility for UX course covers in depth. They also assume you already have something to evaluate. If you are in early ideation, different tools (jobs to be done, user journey mapping, co-design workshops) will serve you better.

For a broader view of the discipline and where heuristic evaluation fits within it, our introduction to what is UX design is a good starting point.

If you want to go beyond theory and apply frameworks like these in real design projects, UX Academy runs live online cohorts capped at 15 students, taught by practising designers. The next cohort starts 5 September 2026. You can get a feel for the teaching approach at the free UX masterclass before committing, or go straight to the Beginner UX Design course to see what the full programme covers.