Usability Heuristics
Recognition Rather Than Recall
Show options and information on screen — don't make users carry them in their head between steps.
Where it comes from
It's the sixth of Jakob Nielsen's ten usability heuristics. The principle draws on a basic fact of memory: recognising something you're shown is far easier than recalling it unaided — so interfaces should show, not make users remember.
Why it matters for your website
Human memory is unreliable, especially under pressure. Nielsen Norman Group's sixth heuristic says interfaces should show users what they need rather than make them remember it. Every extra memory demand raises cognitive load and the odds of abandonment.
Recognition and recall are not equally hard. Picking the right option from a visible list is easy; dredging the same information up from memory, unprompted, is much harder — especially under the time pressure and distraction of real use.
So every time an interface asks the user to remember something — a code from a previous screen, a setting they chose earlier, an option they have to recall by name — it's leaning on the weakest part of their cognition. Showing the information instead, where and when it's needed, removes the demand entirely.
Wrong vs right
A search interface that makes users remember exact command syntax rather than offering visible options.
Visible, selectable options and suggestions, so users recognise rather than recall.
Asking users to remember a code or value from an earlier screen to use it on a later one.
Carrying the information forward and showing it where it's needed.
A menu that hides options behind memorised names or paths.
Showing the available options on screen, so users choose from what they can see.
Understanding Recognition Rather Than Recall
Recognition rather than recall is the sixth of Jakob Nielsen's ten usability heuristics. It rests on a well-established asymmetry in memory: recognising something — picking it out when you see it — is far easier than recalling it from scratch, unaided. So interfaces should make information and options visible rather than requiring users to remember them.
The practical force of this is that human memory is unreliable, and especially so under the time pressure, distraction, and stress of real use. Every demand to remember — a code from a previous step, a setting chosen earlier, an option that must be recalled by name — raises cognitive load and the odds that the user gets it wrong or gives up.
Designing for recognition means keeping what users need in view. Show options rather than requiring their names; carry information forward rather than asking users to remember it; surface choices, context, and prior input where they're needed. This lets recognition do the work memory shouldn't have to. It connects to working memory, knowledge in the world, and Miller's Law.
How Kweri checks it
Kweri can flag some recognition-versus-recall problems it can observe — interfaces that appear to require remembered codes, commands, or values rather than showing options, or steps that depend on information from an earlier screen that isn't carried forward. What it can't fully assess without walking a flow is everything a user is asked to retain across steps. So Kweri surfaces likely places where the design relies on memory rather than showing what's needed, and prompts you to make options and context visible, while verifying the full memory burden means tracing the whole flow.
FAQ
What is recognition rather than recall?
It's Jakob Nielsen's sixth usability heuristic: interfaces should show users options and information rather than make them remember it. Recognising something you're shown is far easier than recalling it unaided, so design should minimise memory demands.
Why is recognition easier than recall?
Because recognising something visible is a much lighter cognitive task than dredging it up from memory unprompted — especially under the pressure and distraction of real use. Showing information removes the demand on unreliable memory.
How do I design for recognition?
Keep what users need in view: show selectable options rather than requiring remembered names or commands, carry information forward across steps, and surface context and prior input where it's needed, so users recognise rather than recall.
What's an example of forcing recall?
Making users remember exact command syntax, a code from a previous screen, or a setting they chose earlier to reuse it later. Each asks the user to retrieve information from memory that the interface could simply show.
How is this related to working memory?
It's a direct application. Working memory is limited and short-lived, so interfaces shouldn't ask users to hold information in it across steps. Recognition over recall keeps the needed information visible, sparing working memory.
Related principles
Good design externalises the knowledge users need to act — it puts it in the world, not in their heads. A product that requires memorisation is a product that requires training.
The brain's temporary active store holds only 4–7 chunks for 20–30 seconds — information users have to remember across steps will be forgotten unless the system carries it for them.
Working memory holds only a handful of items — chunk information to ease the load.
Attribution & sources
Identified by Jakob Nielsen (1994). Catalogued from Nielsen Norman Group — Recognition Rather Than Recall.
The sixth of Nielsen's 10 Usability Heuristics; the linked article is the reference used here.
See Recognition Rather Than Recall on your own site
Run a free Kweri audit — a plain-English review of your site’s speed, accessibility, SEO and design, ranked by what to fix first. No login, no jargon.
Run a free audit →