Designing for Errors

Everyone is familiar with Designing. It is relatively easy to design in the ideal situation-when everything goes well, where people use the device in the way that was intended, and no unforeseen events occur. The tricky part is to design things are just not right. Whether we are designing for a phone or a web application, it is obvious that users might do something which was not meant to be but this error should be provided for so that the user is not lost in the application.

Designing the application for handling errors is as important as designing the application itself.

Detecting Error:

If errors can be detected, then the problems created by them can be avoided. But not all errors are easy to detect. Early detection of errors helps the user from getting completely lost in the application. Different categories of errors have differing ease of discovery, here we going to research a few.

We all know Donald A Norman. Being a designer, he states that there are two types of errors : Slip and Mistake. Action slips are relatively easy to discover whereas, mistakes are much more difficult. User who are new to the application are more likely to make mistakes than slips, whereas experts are more likely to make slips.

Action slips are relatively easy to detect because it is usually easy to notice a disparity between the intended action and the one that got performed. But this detection can only take place if there is feedback. If the result of the action is not visible, how can the error be detected? Imagine you are going through your photo album on your phone and come across a old memory of you and your friend which you wish to share, but instead of share you click on delete and the memory itself is deleted and unrecoverable. This is a slip, the action which was intented to do is not the one which was performed and this can be easily detected. Atleast we now have a confirmation before deleting and even a recycle bin so that we can undo delete. We will see more into them later on.

Mistakes are difficult to detect because there is nothing that signals an inappropriate goal and once the wrong goal or plan is decided upon, the resulting actions are consistent with that wrong goal. So careful monitoring of the actions not only fails to detect the wrong goal but, because the actions are done correctly, they can further provide added confidence to the decision and so the user does not foresee the wrong goal set. Mistakes often arise from ambiguous or unclear information about the current state of a system and inappropriate procedures to perform a action.

Here I would like to give a personal example to understake the nature of mistakes, I misunderstood the oil-pressure warning light in my car, and thought it was the radiator fluid monitor, no matter how carefully I added coolent to the radiator, it would not fix the problem with oil pressure. This would be a mistake, since my action was inappropriate for the situation, even though I made no errors in executing my plan.

Oil pressure warning light in the car which looks like low radiator liquid

Designing for Error:

It is important that as a designer we are able to identify the errors which the user might possibly commit. There is no such thing as human error. If a error is done by users then its a faulty design. I would like to give a real life example here.

The radio I used back in my school days had all kinds of functions and knobs to set treble, bass, station frequency, right speaker volume, left speaker volume, master volume, the list goes on. I would by accident turn one knob which I did not meant to and setting it back would make me use it less. Wouldn’t it be much simpler if there were just 2 knobs, one to set what we want to change and one more to actually change the value of it.

Fisher radio with tuners for each function

Similarly when designing an application it is important to reduce the chances of a user causing an error. For this you have to be the first user of your own design and think from their perspective, which is very difficult since you know how the system/application works. So intentionally committing the possible errors itself is a task.

When several people are talking its easier to correct errors in their communication immediately and understand as intended. As humans have the thinking capability to understand the other person, what he/she is saying and mentally correct any errors made by the other person. Whereas, this sophistication has still not reached the application, we have to take care that there is no mis-communication in the application.

With the application, if we do something inappropriate and the action fits the proper format for a command, application just does it, even if it is wrong. This may prove disastrous incase of a healthcare, finance, NBU application because the scale of that error would be unimaginable. Many applications compound the problem by making it easy to commit an error but difficult to detect it or to recover from it.

One error should not cause multiple or chain of errors and care has to be taken to prevent that from happening.

Methods to avoid Errors :

Add constraints : It is very important to warn the user who is about to commit a error and if it can be prevented in the design itself, it should be done. Prevention often involves adding specific constraints to actions.

For example, the user is booking a flight ticket from Hong Kong to Singapore and he has the option to select the journey to and from dates . If there are no constrains applied he might select 15th Aug for departure and Return date as 9th Aug, by not paying attention, we can imagine the consequences. But if we have a small constrain that user can’t select the dates before the deporting date, then user might not even unintentionally commit the error. Many of us would have noticed this but never have given a thought. Preventing the user from committing errors is the best way to handle that error scenario.

Yatra adding constrains for user to not select wrong dates

Offer suggestions,feedback and confirmation before action :

Often user would not be sure what is the best way to go ahead or what would be the next step to reach their desired goal. It important as a designer to guide the user into a right path to achieve the targeted action. On websites that offer thousands of products, Search is an effective way of helping users find their proverbial needle in the haystack and without suggestions the user would be forced to go through all catogories and this would not only be time consuming but also would not attract the user to go back to the website.

Amazon offering suggestions based on keywords.

Feedback communicates the results of any interaction, making it both visible and understandable. Its job is to give the user a signal that they have succeeded or failed at performing a task. Without proper feedback being provided to the user, he would be in false assumption of whatever action he has performed. For example, In a payment system, not sending an error message when the transaction is not accepted. Leading user to falsely believe an order is placed even though no money is deducted from the bank account.

Confirmations are primarily used to prevent a class of errors called slips, which are unintended actions. While taking a confirmation be specific and inform users about the consequence of their actions. Do not ask Are you sure you want to do this? Instead, explain what this is, it helps the users to understand and recognise a mistake easily. While offering a feature to delete something, we as designers must consider the fact that the item going to be deleted must have consumed lot of time and effort to create it. Showing a confirmation dialogue box just before the delete action is performed makes sure and double checks that the user really meant to delete something that took time and effort to create it. Creative and careful usage of confirmation dialogue boxes is advisable. If we show confirmation dialogue boxes after every decision, it may put adverse effect i.e. people may start to ignore them.

Abstract taking confirmation before deleting a file.

Choose good defaults:

Filling out a long form can sometimes be reason enough for the user to choose another facility where the process is easier. By providing good default values, we save the user from the hassle of selecting all the relevant choices.

Typing has high interaction cost; it is error-prone and time-consuming even with a full keyboard and even more so on a touch screen. Always try to minimize typing and prevent users from making errors . People tend to stick to the defaults. Defaults are incredibly powerful tools for guiding users, speeding up application usage. Finding good defaults should be a process rather than a task. Use the data that is already available, like location, language, date and time, connect with external services to build a profile to get the name, contact details and picture based on already entered information.

Makemytrip by default scans which city your in and current date and sets the defaults based on that.

Pre-populating fields with the value if it can be determined in advance, but be sure that a large portion of users will select that value. People scan forms quickly online so don’t assume they will take the time to pursue through all the choices. They simply may skip to something that already has a value.

Undo & Redo :

Providing a safety net for the users who committed a slip or mistake is quite valuable. We all must have experienced that horrifying moment when we did something wrong unintentionally and had no option except to regret. Like closing a sketch file without saving it. Offering a feature to undo the most recent action can help users to feel more secure and confident to play around with various features available since they are aware that a mistake is low cost and can be easily fixed.

Deleting a important email on gmail, can easily be undone.

Remove memory burden of the user :

Dont expect users to keep track of the actions and perform the net set based on there previous once. If users can keep track of that they wouldn’t be using an application in the first place. The total amount of memory our brain can process at a time is referred to as the cognitive load. Cognitive overload happens when we get more amount of information to process than our mind can handle.

How overload can a tweet become.

Users are usually and easily distracted from there tasks. So it is important to keep the user aware of the previous action which has led them to there current state to resuming the interrupted activity. With this even if user goes away from the application and comes back he knows what are the previous steps which he has done to arrive there and helps him to complete the remaining steps without any errors.

Being a designer, its not just making the UI look more delightful and unique. The applicaion has to handle all the problems in the best possible way to create a delightful experience to the user. After all, the goal of any design, is to connect the user to it and a good design can prevent slips and mistakes all the while making the design more relevant and useful to the user.