There is a lot of information about work with on the Internet. In this article I structured it and made a short overview of common practices. It might be useful for those, who feels he don’t have a full picture of this topic.

Nielsen Norman gives 3 of his 10 heuristics for mistakes. Seems like it’s quite an important issue, right? Here they are.

  1. User control and freedom. Users often choose system functions by mistake and will need a clearly marked “emergency exit” to leave the unwanted state. Support undo and redo.
  2. Error prevention. Either eliminate error-prone conditions or check for them and present users with a confirmation option before they commit to the action.
  3. Help users recognise, diagnose, and recover from errors. Error messages should be expressed in plain language, precisely indicate the problem, and constructively suggest a solution.

Look at these heuristics. Don’t you think they are a bit controversial? We should let users make mistakes and prevent those mistakes at the same time. And then not to forget to provide a user with a good error message. Please, don’t it simultaneously. They are controversial, because every time you should think what is suitable at the moment.

User control and freedom

Let users make mistakes and correct them by themselves. Don’t bombard them with warnings and confirmation — they are annoying and not very effective. Provide an obvious chance to “return as it was” with minimum effort. Support undo and redo or edit. It is also useful if a user changes his mind or a situation changes a context.

Gmail gives users an opportunity to cancel uploading without waiting for the end of the process

Error prevention

Minimize the number of conditions in which users can make errors.
Even the most understandable error messages can not make the site as friendly as the good logic, that prevents those errors, does. There are some ways to prevent errors.

  1. Eliminate the errors conditions
    Don’t add unnecessary options in interaction. Try to use minimum inputs, use autocomplete when it is possible. Users hate this thing. Make inputs in which it is hard to make a mistake, but keep them obvious. For example, in this article I describe how to make a degree input.
Some examples of strict inputs for national phone number, card number and time.

2. Add some hints
If your interface has some parts, that are not obvious, and you cannot avoid them, add some hints. So the user don’t have to google what he cannot understand.

Provide users with an extra information if they need one

3. Foresee and correct
Correct user mistakes automatically if it is possible.

Instead of a long form with different input fo city, country, home number and etc. Google suggests only one input for an address. Furthermore, it suggests different solutions even if a user mistakes.

4. Foresee and warn
Tell a user about a possible mistake if you know it’s going to happen.

Gmail foresees if a user forgot to attached a file

Help users recognise, diagnose, and recover from errors

If you cannot prevent user errors and cannot allow users just to make their mistakes, provide them with a good error message.

This error message isn’t helpful at all

An error message has to be understandable, friendly, clearly state a problem and suggest a solution. Never blame users for their mistakes. If they made one, it is your fault anyway. For example, don’t say “You’ve entered wrong password”, but “The password isn”t correct”.

MailChimp is trying to help users with their error messages, not to stress or blame them. It is short, friendly, states the problem and suggests a solution.

When to validate?

Speaking about the error messages, when is the best time to show them? Sometimes, the best choice is never. Don’t validate the inputs if you don’t know a correct answer. A name input, for example. In other cases it is better to use an inline validation. According to Luke Wroblewski’s research the inline validation form with the best performance showed compelling improvements across all the data we measured. But when exactly should we put an inline validation, on entering an input, while editing or after the focus lost? In the same research we see, that in most cases “after” method works better. Users are not distracted this way and complete the forms more quickly. For usernames and passwords it is better to use the “while” method with a short delay.

Things to remember

  1. Give users the possibility to cancel actions, return to previously canceled actions and fix errors
  2. Prevent errors: eliminate the error conditions, add hints, foresee errors and correct them or warn about them
  3. Error messages should be friendly and understandable, clearly state the problem and suggest possible solutions
  4. In most cases inline validation after the focus lost works better

Source link


Please enter your comment!
Please enter your name here