UX design is a discipline that has been around long enough for there to be best practices to adhere to.

These best practices are called heuristics and through a heuristic evaluation you can assess whether your software meets the most common usability standards that all well-designed software should meet.

While a heuristic evaluation is no substitute for user research, it is still an invaluable part of the UX process. Better yet, it can be done by yourself and in your own time.

If you make sure your software adheres to these rules of thumb, you are already in a great position to provide a great user experience and can dedicate more time to solving more complex and user specific problems.

How to Conduct a Heuristic Evaluation

Conducting a heuristic evaluation is very simple.

All you need is to split a document into three columns and do the following:

  1. Heuristic
    • The heuristic column lists each of the heuristics mentioned above
  2. Score
    • You give each a score out of 5 to see how well your software is meeting it
  3. Comments
    • You comment where the standards aren’t being met and what can be done about it

It’s also a good to have an additional document that includes screenshots or videos that clearly illustrate the issues encountered.

Heuristics to Use

Over 25 years, Jakob Nielsen came up with a set of heuristics that are still followed to this day.

But two other heavyweights of UX design, Alan Cooper and Steve Krug, also came up with a few good usability practices that should be incorporated into any heuristic evaluation too.

Jakob Nielsen Heuristics

1. Visibility of system status

Well-designed software should let users know what’s going on. Doing so helps reduce anxiety and prevent guesswork as the software is used.

This doesn’t necessarily have to be something beautiful or complex like real time animations either. The goal is simply to inform users what is going on.

Example:

  • Progress bar
  • Color change
  • Notification prompt

2. Match between system and real world

Using jargons, concepts or metaphors that the average person doesn’t understand will only serve to confuse users.

You must make sure your software speaks the same language as your users by following real-world conventions and making information appear in a natural, logical order.

Example:

  • Familiar language like Register and Signup
  • Familiar icons like a folder or trashcan

3. User control and freedom

We as humans have a natural desire for freedom and control, so when software goes against this, we get frustrated.

Software therefore shouldn’t punish users for making mistakes or leading them down dead ends where they are then unable to take further action

Example:

  • Back button is functional at all times
  • Undo button

4. Consistency and standards

Software should be consistent in its visuals, language and functionality so not to confuse users. You should also be careful not to break with conventional patterns now considered standard with software and that match users’ mental models.

Example:

  • Consistent use of elements sitewide
  • Like button and heart icon function as expected

5. Error prevention

Well-designed software informs users about an error, but the very best designed software prevents the error from occurring in the first place.

Software should either eliminate conditions that are likely to result in an error or anticipate when an error might occur and forewarn the user.

Example:

  • Instructions
  • Suggestions
  • Confirmation dialog

6. Recognition rather than recall

We find it much easier to recognize than recall information. It’s easier to recognize a person’s face than recall their name, and it easier to answer a multiple-choice than open-ended question.

Good software should therefore require users to recognize rather than recall information.

There is only so much information we can carry around in our heads, and if context and cues aren’t provided, we must work much harder to retrieve the information.

Software should therefore provide context and cues in the form of names, pictures and icons to make users’ lives easier.

Example:

  • List of options
  • Recently viewed page
  • History page
  • Wishlist

7. Flexibility and efficiency of use

Your users probably lead busy lives, so whenever and wherever you can speed up a task so they can achieve their goals more quickly you should do so.

Software should also be designed with enough flexibility to accommodate both experienced and inexperienced users.

Example:

  • Shortcut buttons and commands
  • Customizable options

8. Aesthetic and minimal design

Every element and piece of information on a page should serve a purpose. If it is not relevant to the user and their goals, it should be disregarded.

If it is relevant to a user but not as much as other elements and information on the page, it should be given less priority.

Example:

  • Whitespace
  • Visual and informational hierarchy

9. Help users recognize, diagnose and recover from errors

Whenever an error occurs, the UX no longer flows as smoothly and friction is created. To make sure this friction is minimized and eliminated as quickly as possible, you want to help users be aware that there is an error, ensure that they understand what the error means and offer a constructive solution.

Example:

  • Error message is in plain language
  • Error message is highlighted
  • An actionable solution is offered

10. Help and documentation

You might be intimately aware of how your software functions, but your users do not share that same knowledge. Help and documentation should therefore be provided.

It should be easy to find, search through, focused and offer easy solutions in plain language.

Example:

  • Help page
  • Tutorials
  • FAQs

Alan Cooper Heuristics

The lesson to learn from Alan Cooper’s book, The Inmates Are Running the Asylum, is that software should be polite. You can use this concept to ensure that in your heuristic evaluation your software meets the following criteria.

1. Software should be interested in me

Software shouldn’t treat users like strangers. It should want to learn more about its users, their personal preferences and habits. As more of this information is learned and software becomes more personable, you can deliver a better user experience.

Example:

  • User referred by name
  • Most common actions are given priority

2. Software should be forthcoming

If you go to a restaurant, spend five minutes looking at the menu and decide to order the duck only to be told that it is off the menu today, you would understandably be annoyed.

The same applies to software.

So, if a piece of information is already known it should be shared with users

Example:

  • Notification warning

3. Software should have common sense

Software should behave with the same common-sense approach as a human.

For example, if you have to scroll through a long list of countries to find your own despite it being obvious where we live through your IP address, there is a lack of common sense in the software’s design and functionality.

Google is a great example of software that gets it right. It has no problem detecting and correcting typos in search queries. It has enough common sense to show results for what a user probably meant to type in.

Example:

  • Correcting typos
  • Default options

4. Software should be confident

Every time a user’s flow is interrupted the UX is negatively impacted. Software should therefore have more faith and confidence in both itself and its users.

Software should follow through on a user’s actions instead of asking for confirmation for the most inane of things.

Example:

  • Undo button
  • Reduce number of confirmation messages

Steve Krug Heuristics

Steve Krug introduced a brilliant concept in his book Don’t Make Me Think that he calls “The Reservoir of Goodwill”.

Every piece of software starts with a reservoir of goodwill. As users start to use software, one of three things happen to this reservoir: it diminishes, stays the same or increases.

To maintain this level of goodwill, you must therefore make sure that you don’t’ inconvenience or frustrate your users. Ideally, when possible, you want to pleasantly surprise them to increase the level.

There are two main takeaways from this concept that you can use in a heuristic evaluation.

1. Don’t waste my time

You’re unlikely to catch users when they’re able to give your software 100% of their attention. Similar to Nielsen’s flexibility and efficiency of use, you want to save as much time and steps wherever possible.

You also want to focus your design on the most common use cases, so they are put at the forefront of the software.

Example:

  • Shortcut buttons and commands
  • Customizable options
  • The most common use cases are more accessible and visible

2. Data should be reformatted

Forcing users to format data in a particular way is one of the fastest ways to diminish the reservoir of goodwill. Yet it’s so simple to avoid that any beginning developer can ensure that any inputted data is automatically reformatted.

Example:

  • Reformat phone numbers
  • Reformat birth dates
  • Reformat addresses

All 16 Heuristics to Follow

  1. 1. Visibility of system status
  2. Match between system and real world
  3. User control and freedom
  4. Consistency and standards
  5. Error prevention
  6. Recognition rather than recall
  7. Flexibility and efficiency of use
  8. Aesthetic and minimal design
  9. Help users recognize, diagnose and recover from errors
  10. Help and documentation
  11. Software should be interested in me
  12. Software should be forthcoming
  13. Software should have common sense
  14. Software should be confident
  15. Don’t waste my time
  16. Data should be reformatted