Table of Contents
In reality, developers, testers, and user experience (UX) designers have different focus and expertise. However, with the growth of digital technology, developers and testers will need to broaden their expertise to include the UX field as it plays a vital role when creating enterprise-level products and services.
Currently, there is no framework created for developers and testers to evaluate UX in enterprise software. The proposed framework provides a simple checklist for developers and testers to evaluate feature/product-wise UX aspects qualitatively and quantitatively. The checklist is created around Nielsen's Usability Heuristics for User Interface Design along with additional items to capture different aspects in UX. This will help to identify, in advance, the actual experience gaps that end users may face in real deployments. This will reduce rework, saving developer and user time and effort.
This white paper will introduce a developer/tester focused framework to evaluate UX in enterprise products.
The framework is built around four quantitative metrics and seven qualitative metrics to evaluate UX. The quantitative metrics are associated with checkpoints that define the metrics.
The table below shows the checkpoints that are associated with each metric.
|Time on task||Total time taken to complete the task||-|
|Success rate||Successful completion rate of the task||
|Difficulty score||Difficulty level in completing the task||
|Number of errors||Number of errors the user experienced when completing the task||-|
|Findability||Ease of finding relevant functionality, content or information||
|Simplicity||A clean, understandable, and minimalistic design, which provides the most straightforward way to do the task||
|Intuitiveness||Ease of use of the system to the degree where the user is able to interact without applying knowledge consciously||
|Consistency||Similar elements/functions having a consistent look and functionality||
|Guidance||Directing and guiding users to perform tasks||
|Accessibility and Compatibility (Optional)||Comply with accessibility standards and cross-browser support||
|Responsiveness (Optional)||The system renders well when viewed on devices of different screen sizes||
Checkpoints provide clear guidelines when evaluating UX in products. Each checkpoint is associated with check items. See below for the list of checkpoints with relevant check items.
1. Clear and consistent navigation
This indicates a quick and easy flow of events through the system. Users should be able to have the ability to go back.
- Is there a quick and easy flow through the system?
- Can the user go back to the previous action?
2. Happy path work
Was the user able to perform the action/task featuring no exceptional or error conditions?
- Was the user able to perform the action/task featuring no exceptional or error conditions?
3. Visibility of system status
The system should keep users informed about what is going on, through appropriate feedback within a reasonable timeframe. Progress should be indicated for multi-step workflows.
- Is the user informed about what is going on?
- Is the user given relevant feedback after a particular action, e.g. notification, status bar, and loading indicator?
- Does the action give feedback within a reasonable context (time and place)?
4. Match between the system and the real world
The system should speak the users' 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.
- Does the design match with real-world conventions and concepts?
- Is the labeling convention that is used in the system familiar to you?
- Does the information appear in natural and logical order?
5. 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. Should support undo and redo.
- Is there a clear exit to the task, e.g. Cancel?
- Can the user undo the action?
6. Consistency and standards
Users should not have to wonder whether different words, situations, or actions mean the same thing. Consistency should be maintained throughout the user flow.
- Does the flow maintain the same patterns and consistency?
7. Error prevention
Users should be prevented from problems even before their occurrence in the first place. For this, either eliminate error-prone conditions or check for them and present users with a confirmation option before they commit to the action.
- Is all relevant validations provided?
- Is there a confirmation option before committing to actions?
8. Error recognition
Error messages should be expressed in plain language (no codes), precisely indicating the problem.
- Is the error message expressed in plain language?
- Does the error message precisely indicate the problem?
9. Error recovery
This verifies whether the messages constructively suggest a solution or not.
- Are the messages constructively suggesting a solution?
10. 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.
- Are the objects, actions, and options clearly visible?
- Are the instructions for the task visible or easily retrievable when necessary?
11. 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. These allow users to perform frequent actions faster.
- Does the task cater to both experienced and inexperienced users?
12. Aesthetic and minimalistic design
Dialogues should not contain information that 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. Related information is clearly grouped together.
- Does the system contain information that is relevant and needed? (no irrelevant or rarely needed info)
- Is the information/elements properly positioned and aligned?
13. User guidance
Users should be guided throughout the process.
- Is the user guided throughout the process?
14. 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 for, be focused on the user's task, list concrete steps to be carried out, and not be too large.
- Is the necessary documentation provided?
- Does the content appear in a structured and logical order?
- Is the content up to date and accurate?
15. Clear call to action
Users should be able to clearly define the next action, which needs to be performed.
- Was the user able to clearly define the next step/action to perform?
16. Restore task progress
Users should be able to resume work from where they left off.
- Can the user resume work from where they left off?
17. Comply with accessibility standards (optional)
The system should conform to Section 508 Standards or W3C Web Content Accessibility Guidelines (WCAG) 2.0/2.1 Level A/AA/AAA.
18. Cross-browser compatibility (optional)
The system works as expected in selected browsers.
- Does the system work as expected in selected browsers (IE8–11, CH, FF, SF)?
19. Responsive Design (optional)
The system should be accessible through selected devices.
- Does the system work as expected in selected devices, e.g. mobile, tab, and desktop?
There are three phases for the approach. Developers need to go through all three phases and testers can start from the second phase (task breakdown) onwards.
4.1 Pre-development research
Developers need to do pre-development research when adapting the framework to develop user-centric software.
Pre-development research includes:
- Identifying/mapping the high-level epics with the feature
- Identifying the related personas
- Creating user stories related to the feature
4.2 Task breakdown
Check whether the items are marked against the tasks that are derived from the user stories. A feature may have one or more tasks associated with it. A task list needs to be created in order to evaluate the feature/scenario.
According to the template, the developer/tester needs to go through the check items for each task and mark the fields related to each check option.
There are three types of check options:
The checklist item does not map to the task or the task is out of the scope of the system.
The checklist item is fulfilled in the task.
The checklist item is not fulfilled in the task.
After filling the check items, developers/testers will get a clear understanding on the missing UX aspects of the feature/scenario. Developers can work on the unfulfilled items before releasing the feature and testers can report issues.
The UX framework discussed in this white paper will help developers and testers to identify and bridge the experience gaps that customers and end users may face even before releasing the feature. This saves both the developer’s and customer’s time and effort. It covers the key UX principles and aims at improving customer and end-user experience.
For more details about our solutions or to discuss a specific requirement contact us.