To err is human, and errors happen when people engage with user interfaces. According to Don Norman, there are two categories of user errors: slips and mistakes. Slips occur when a user is on autopilot, and takes the wrong actions in service of a reasonable goal. We discuss slips and slip prevention in detail in the first article in this series. In this article we focus on mistakes.
Mistakes occur when a user has developed a mental model of the interface that isn’t correct, and forms a goal that doesn’t suit the situation well. For example, many online children’s games start with a short video tutorial or with a video advertisement for another game; in our user testing with children, we noticed that, when the video looks too much like a real game, kids are tempted to interact with it, thinking that they can already start playing. In this situation, the users form and execute an inappropriate goal, largely because they interpret incorrectly what they see on the website (namely, they think that the video is the real game). Good design should help prevent such mismatches between the user’s expectations and the interface.
The 2 Gulfs
When working with a system like a website or app, users start with a goal of some kind and, based on their mental model of the system, they form an action plan to accomplish that goal. Then they take action, and look to verify that their action produced the desired results. In his book The Design of Everyday Things, Don Norman refers to this process as bridging the Gulf of Execution (“How do I work with this tool to accomplish my goal?”) and the Gulf of Evaluation (“Did this work how I wanted it to?”).
A lot of user mistakes (but not slips) happen when users do not get enough help in bridging these two gulfs, and the designers’ mental model and interpretation of how the system should work does not match users’ mental models. In those situations, users either form an action plan that is incorrect or they do not understand well how the state of the system changed as a result of their actions. While preventing slips is often a simple matter of validation and enforcing constraints, preventing mistakes involves understanding users’ mental models and their expectations and making your designers match them. Do not make the error of thinking that users are going to eventually learn your designers’ mental models; while that may be the case in rare situations where users are forced to use the system regularly, with most consumer-facing apps and websites users just navigate to a different site instead of bothering to learn a tricky one.
Gather User Data
Discovering the specific gaps between users’ mental models and designers’ mental models is critical for avoiding mistakes, and requires gathering user data. There is a wealth of user research methods that can suit a variety of circumstances, so it is important to select a methodology that provides you with the context for why users make mistakes and what their expectations are. Methods such as contextual inquiry, field studies, and ethnographic studies are well suited for figuring out users’ mental models and expectations at an early stage, when you’re starting a new design. Once you do have a system (or at least a prototype) you can use qualitative usability testing to detect gaps between designers’ mental models and users’ expectations.
Follow Design Conventions
Using standard design conventions helps users bridge both the Gulf of Evaluation and the Gulf of Execution, and understand what actions they can take. This is reinforced by Jakob’s Law, which states that “users spend most of their time on other websites.” Each and every user that interacts with your website or application has been trained by thousands of other designers to expect common interactive elements to look and work a certain way, and error-prone conditions can arise when your website deviates from those conventions.
Communicate Affordances
Besides using conventions that users are able to recognize from previous experiences, another method of making controls understandable (and thus helping users bridge the Gulf of Execution) is having the design communicate how it can be used. For example, users are accustomed to clickable buttons looking like they have a subtle amount of shadow on the outside. This effect makes a button look like it is rising up out of the page, and you can push it. Conversely, form fields are also rectangular, but have a small amount of shadow on the inside of the shape, to indicate that they’re empty and can be filled.
This attribute of the design that indicated how it can be used is often referred to as the object’s signifier. The affordance itself is the way in which the object can be interacted with (buttons can be pushed, form fields can have typed input added), and the visual cues that communicate this to the user are known as the signifier of the affordance. If there isn’t a clear signifier that communicates the affordance, users may not understand how to use a control, and make mistakes.
Preview Results
Sometimes, users don’t realize they’re about to trigger an action that results in changes that are wide in scope and difficult to verify. Users may well wish to revise their goals once they have had a chance to compare the effect of the action with their goal; Preview features provide an opportunity to bridge the Gulf of Evaluation without making a mistake.
A good example is rendering special effects in a video-editing software where the editing the system does in the background may take 5 or 10 minutes, and the computer will be mostly unresponsive while it’s working. In this case, even if users haven’t permanently lost any work, if the result isn’t what they’re looking for, they have lost quite a bit of time, and possibly also patience. Wherever possible, offer a preview state that users can examine to make sure that they will get what they want. This assists in avoiding time-consuming mistakes before they can be made.
Preventing Both Mistakes and Slips
Some error-prevention strategies work with both slips and mistakes. The following are good general guidelines for reducing the likelihood (and the severity) of all types of errors.
Remove Memory Burdens
Whenever users need to keep a lot of information in their short-term memory while working on a task, they are vulnerable to slips where they can repeat steps, or fail to complete the task. Memory-lapses can also result in mistakes where users forget earlier decisions they’ve already made, and repeat the process with different outcomes. A good strategy for preventing both of these types of errors is to remove burdens on users’ memory.
Whenever possible, remove conditions that require users to keep information in their own memory while they move from one step to another in complex, multistep procedures. Instead, strive to display the contextual information that users need to complete a task. Remember, users are often distracted, multitasking, or otherwise not fully focused on the website or app that they’re using. A good approach is to imagine that your users could be interrupted by a phone call after every step in a multistep process. You want to show all of the information users need to readily resume their tasks after having been interrupted for several minutes.
Confirm Before Destructive Actions
Designers typically focus on user tasks related to creation. But deleting also has to be straightforward. Remember, when users delete an item, they destroy something that had taken work to create. Before you finish removing the object of that hard work, make absolutely sure that the user really meant to Delete by showing users a confirmation dialog.
This can be an effective, simple, and familiar way to give the user a final chance to stop, and double-check if they really want to delete all those vacation photos, for example.
It’s important to use confirmation dialogs carefully, however, since they interrupt users’ workflow, and inherently slow them down. If a confirmation dialog asks “do you really want to do that?” after every decision, many users won’t spend the time to double-check whether they made an error before instinctively clicking the highlighted Confirm button. Counter-intuitively, a design intended to prevent errors can actually increase them, as the user starts rushing to counteract the inefficiency of constantly confirming. Like in Aesop’s famous fable, “The Boy Who Cried Wolf”, a UI can become “The Computer That Cried Confirm” a few times too many. In both cases, people will have stopped paying attention to the false alarms by the time there’s something important to cry about. Don’t use confirmation dialogs as the sole error prevention method, apply them carefully with the other techniques discussed in this article to maximize their usefulness and limit their inefficiency.
Support Undo
Another primary principle of preventing users from making errors is to acknowledge that they will make mistakes and slips from time to time, and provide a safety net that makes these errors less costly. Nearly everyone has experienced the utterly horrifying moment of realizing that you just accidentally deleted an entire folder or directory of important documents, when you really only meant to delete only one file.
Providing the ability to undo the most recent action can help users to feel more secure and more confident to experiment with unfamiliar features, since they are aware that a mistake is low cost and can be easily fixed.
Warn Before Errors Are Made
Presenting subtle, contextual error warnings while a user is actively making an error can help them to quickly correct it. For example, when users are typing a review into an input box on an ecommerce store, don’t wait until after they have hit Submit to show an error message that the review is 35 characters too long, let them know while they’re typing those extra 35 characters (or better yet, warn them as they get close to the limit).
Summary
Even though users will always make some mistakes when using software, it’s possible to reduce overall errors by designing with the user’s experience in mind. Prevent mistakes by helping the user to build a good mental model of your interface. Use design patterns that communicate how they work to users, encourage users to double-check their work (especially before deleting), and warn before mistakes are made. These simple guidelines can help enable lower rates of user errors, and ultimately improve usability.
Reference
Don Norman. The Design of Everyday Things, Basic Books 2013.
Share this article: