Usability is one of the fundamental principles of UX. The Heuristic method is a quick solution that can be used to evaluate usability in projects that are currently underway. It’s also useful during the design phase because it’s easily adapted, even by designers who are not considered experts in UX. Likewise, Heuristic evaluation is ideal for projects where there is no budget for a complex (lab-based) UX evaluation process.
Below is a description of how the Heuristic method works here at Making Sense.
Lean projects (like your app) require different UX solutions.
Some projects do actually require a rigorous (lab-based) UX evaluation process. At the other end of the spectrum, many smaller projects call for a leaner process and that’s what we’re here to talk about today. These projects demand quicker, more cost-effective techniques, which we call “Rapid”.
One such Rapid technique we use here at Making Sense is the Heuristic method.
Here’s a quick and simple way to ensure UX becomes part of the process of app development, rather than remaining just an afterthought.
Benefits of using Heuristic Evaluation
- Cost effective.
- Intuitive. It’s easy to get everyone on board.
- Useful right away. It’s effective even during the early stages of the UX Process.
- Used widely. It is the most recognizable and the most popular.
- Efficient. It teaches designers about the criteria to keep in mind while creating their own designs.
10 Essentials of Heuristic Evaluation
Here are the 10 criteria used when performing Heuristic Evaluation. They were compiled by Jakob Nielsen, who based them on factor analysis of a large number of usability problems:
#1. Visibility of system status:
The system should always keep users informed about what is going on, through appropriate feedback within a reasonable time.
#2. Match between system and the real world:
The system should speak the user’s language, with words, phrases and concepts familiar to the user, rather than system-oriented terms. Follow real-world conventions, making information appear in a natural and logical order.
#3. User control and freedom:
Users often choose system functions by mistake and will need a clearly marked “emergency exit” to leave the unwanted state without having to go through an extended dialogue. Support undo and redo.
#4. Consistency and standards:
Users should not have to wonder whether different words, situations, or actions mean the same thing. Follow platform conventions.
#5. Error prevention:
Even better than good error messages is a careful design which prevents a problem from occurring in the first place. Either eliminate error-prone conditions or check for them and present users with a confirmation option before they commit to the action.
#6. Recognition rather than recall:
Minimize the user’s memory load by making objects, actions, and options visible. The user should not have to remember information from one part of the dialogue to another. Instructions for use of the system should be visible or easily retrievable whenever appropriate.
#7. Flexibility and efficiency of use:
Accelerators—unseen by the novice user—may often speed up the interaction for the expert user such that the system can cater to both inexperienced and experienced users. Allow users to tailor frequent actions.
#8. Aesthetic and minimalistic Design:
Dialogues should not contain information which is irrelevant or rarely needed. Every extra unit of information in a dialogue competes with the relevant units of information and diminishes their relative visibility.
#9. Help users recognize, diagnose, and recover from errors:
Error messages should be expressed in plain language (not codes), precisely indicating the problem, and constructively suggesting a solution.
#10. Help and documentation:
Even though it is better if the system can be used without documentation, it may be necessary to provide help and documentation. Any such information should be easy to search and focused on the user’s task. It should list concrete steps to be carried out and it should not be too large.
The inspection process can take from a couple of hours for small systems, to several days for more complex projects.
- Project team selects a set of evaluators, typically 3 to 5.
- Select a number of Heuristics.
- Each inspector individually browses through each part of the interaction design.
- Assess the compliance of each part of the design.
- Notice places where one of the heuristics is violated.
- Notes places where heuristics are supported.
- All the inspectors get together and as a team.
- Merge their problem list.
- Select the most important to fix.
- Brainstorm suggested solutions.
- Decide on recommendations for the designers based on the most common problems.
A heuristic evaluation report should:
- Start with an overview of the system being evaluated.
- Give an overview explanation of the inspection process.
- List the inspection questions based on heuristics used.
- Report on potential usability problems revealed by the inspection (by heuristic or by part of the design or screen).
Over the years HE has evolved as the methods are adapted and customized by almost every team who uses it.
For example, other UX inspections can be scenario based, perspective- based, checklist-based (and more).
The perspective-based approach can be used to guide usability inspections by both novice and experts alike.
The persona-based approach involves consideration of “context of use” via the needs of personas.
The Heuristic method can be adapted fairly quickly by designers and developers who have little experience with UX. Even if a project has no designer, HE can be implemented with little investment in time or money. For that reason, it’s an incredibly useful tool, especially when time constraints and budgeting factors weigh heavily in a project. As you may know, this is often the case for app developers.
But one thing we like to keep in mind here at Making Sense is that Heuristic Evaluation isn’t right for every project. Like any inspection method, there are gaps, loopholes, and false negatives where problems identified by the system don’t actually turn out to be problems at all. At best, it’s a stop-gap measure that allows us a high degree of efficiency, when sophisticated UX principles aren’t called for.