Evaluating Usability: Nielsen’s 10 Heuristics
You have built a feature. It works. But does it feel obvious to a non-technical print-shop owner who has never read a manual? You could find out by watching real people use it — but that takes time and recruiting. There is a faster, cheaper way to catch the worst problems before anyone else sees them. It is called heuristic evaluation.
What heuristic evaluation is
- Heuristic
- A rule of thumb — a short, practical principle that is usually right, even if not always.
- Heuristic evaluation
- A way of checking an interface (a screen, a form, a flow) against a list of known usability rules, to spot problems. It is an inspection method: experts look at the design and judge it. No real users are needed, so it is fast and cheap.
The method was created by Jakob Nielsen and Rolf Molich, first presented at the ACM CHI conference in Seattle in April 1990. Nielsen later refined the rules into a canonical list of 10 heuristics in 1994, chosen by analyzing 249 real usability problems to find the principles that explained the most of them. The 10 rules have not changed since; only the wording and examples were modernized in 2020. This is a durable framework, not a passing trend.
Why you need more than one set of eyes
Nielsen’s experiments found that a single evaluator catches only about 20–51% of the usability problems. But aggregating the findings of just 3–5 evaluators catches the large majority (around 75% or more). Each person notices different things; together they cover the gaps. This is the famous “3–5 evaluators” rule.
The 10 heuristics at a glance
| # | Heuristic | One-liner | Good (print SaaS) | Bad (print SaaS) |
|---|---|---|---|---|
| 1 | Visibility of system status | Show what’s happening now | Checkout stepper + “Order #PF-1043 placed” | Frozen blank page after “Pay” |
| 2 | Match system & real world | Use the user’s words | “Store Name”; “card declined: insufficient funds” | “tenant_id”, “Error 422” |
| 3 | User control & freedom | Easy undo / exit | “Cancel order” link + “Undo” toast | Instant save, no undo |
| 4 | Consistency & standards | Same thing, same word | “Delete” everywhere; buttons in fixed spot | Save / Apply / Update for one action |
| 5 | Error prevention | Stop mistakes early | Delete dialog stating consequences | Bare “Are you sure? Yes” |
| 6 | Recognition not recall | Show, don’t memorize | Saved-address picker, one-click reorder | Re-type address every order |
| 7 | Flexibility & efficiency | Serve novices + experts | Bulk status update, saved views | 5-step wizard for a 50×/day task |
| 8 | Aesthetic & minimalist | Cut the noise | Clean checkout: summary + pay | Checkout buried under popups/upsells |
| 9 | Recognize/diagnose/recover errors | Say what’s wrong + next step | “Card 4242 declined — try another” | “System error” / stack trace |
| 10 | Help & documentation | Self-evident, else findable | Inline tooltip + short how-to | Disabled button, no tooltip |
Walking through the 10, one by one
1. Visibility of system status. The design should always keep users informed about what is going on, with timely feedback. Plain version: tell the user what is happening right now. A checkout that shows “Cart → Shipping → Payment → Confirm” and then “Payment successful — order #PF-1043 placed” is doing this. A blank, frozen page after pressing “Pay” is not — the shop owner cannot tell if the charge went through, so they click again and get double-charged.
2. Match between the system and the real world. Speak the user’s language; follow real-world conventions. Use “Store Name” and “Order Status”, not “tenant_id” or “slug”. A declined card should say “Your card was declined: insufficient funds”, never “Error 422” or a print job named “Path bTSxCeDjco”.
3. User control and freedom. People act by mistake; give them a clearly marked emergency exit — undo, cancel, back. A “Cancel order” link before fulfillment, and an “Undo” toast after archiving a product, both respect this. A setting that saves instantly with no way back does not.
4. Consistency and standards. The same thing should look and be named the same everywhere, and obey conventions users already know. Pick one word — “Delete” — and use it on every screen. Do not call it “Save” on one settings page, “Apply” on another, and “Update” on a third.
5. Error prevention. The best message is the one you never need, because the mistake was stopped first. A delete dialog that says “This will permanently delete ‘Premium Business Cards’ and remove it from all active orders. This cannot be undone” with a button labeled “Delete Product” prevents a costly slip. A bare “Are you sure? Yes” does not.
6. Recognition rather than recall. Minimize memory load — show options instead of making people remember them. Pre-fill saved addresses with a “Use this address” picker; offer one-click reorder. Do not force the shop owner to re-type the address they entered last order.
7. Flexibility and efficiency of use. Serve both beginners and experts; let frequent tasks be fast. A store owner who updates 50 orders a day needs bulk status updates and a saved “Needs action” view — not a 5-step wizard each time.
8. Aesthetic and minimalist design. Every extra element competes with the important ones. This is about content relevance, not flat or sparse visuals. A checkout that shows only the order summary, total, and pay button beats one buried under banners, upsells, and newsletter popups.
9. Help users recognize, diagnose, and recover from errors. When something breaks, say what went wrong and what to do next, in plain words, shown clearly near the field: “We couldn’t process your card ending 4242 — it was declined for insufficient funds. Try another card or contact your bank.” Never “System error”, “Error 500”, or a raw key like message.exportError.
10. Help and documentation. Ideally the design needs no explanation. When help is needed, make it findable, task-focused, and in-context: an inline tooltip next to “Shipping weight” explaining how it sets the rate, with a short “Learn more” link. Not a disabled button with no tooltip, and not a 60-page PDF the shop owner must dig through.
How to run a lightweight heuristic review
You do not need a research lab. Here is a practical version you can run on your own checkout, settings, and orders flows.
- Use Nielsen’s 10 as your checklist — the de-facto standard.
- Recruit 3–5 evaluators if you can. People who know both usability and the print domain (“double experts”) find the most. Each inspects independently first to avoid groupthink.
- Define concrete tasks — “complete a checkout”, “change store settings”, “find and reprint a past order”. Walk each screen about twice: once for flow, once for detail.
- Log each issue with the violated heuristic number, a plain description, the exact screen, a screenshot, and a severity rating.
- Rate severity on Nielsen’s 0–4 scale below, judged by frequency, impact, and persistence.
- Consolidate — merge everyone’s findings, remove duplicates, and average the severity in a group debrief.
- Prioritize and fix the 3s and 4s first, then re-review.
Nielsen's severity scale (0-4) 0 Not a usability problem 1 Cosmetic - fix if time allows 2 Minor - low priority 3 Major - important, high priority 4 Catastrophe - fix before release Severity = frequency x impact x persistence
Two thinkers deepen this. Don Norman, in The Design of Everyday Things, coined “user experience” and gave us “Norman doors” — a door you cannot tell whether to push or pull. Needing a “PUSH” sign is a design failure, the same spirit as heuristics #1 and #2. Clayton Christensen’s milkshake story reminds us to design for the job the user is hiring the product to do (roughly half of milkshakes were bought by solo morning commuters needing a thick, one-handed drink for a boring drive) — not for the feature spec.
Key takeaways
- Heuristic evaluation is a fast, cheap inspection against 10 fixed rules — no real users required.
- One evaluator finds only ~20–51% of problems; 3–5 evaluators catch the large majority. Don’t confuse this with the “5 users” testing rule.
- Memorize the 10 in plain language: status, real-world words, undo, consistency, prevent errors, recognition, efficiency, minimalism, recover from errors, help.
- #5 prevents errors; #9 recovers from them — a good design does both.
- Log each issue with its heuristic number and a 0–4 severity, then fix the 3s and 4s first.
- Even a solo founder can score checkout, settings, and orders against all 10 and catch the worst offenders.