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.
| Metrics | Description | Options/Checkpoints |
| 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.
This indicates a quick and easy flow of events through the system. Users should be able to have the ability to go back.
Check items:
Was the user able to perform the action/task featuring no exceptional or error conditions?
Check items:
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.
Check items:
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.
Check items:
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.
Check items:
Users should not have to wonder whether different words, situations, or actions mean the same thing. Consistency should be maintained throughout the user flow.
Check items:
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.
Check items:
Error messages should be expressed in plain language (no codes), precisely indicating the problem.
Check items:
This verifies whether the messages constructively suggest a solution or not.
Check items:
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.
Check items:
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.
Check items:
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.
Check items:
Users should be guided throughout the process.
Check items:
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.
Check items:
Users should be able to clearly define the next action, which needs to be performed.
Check items:
Users should be able to resume work from where they left off.
Check items:
The system should conform to Section 508 Standards or W3C Web Content Accessibility Guidelines (WCAG) 2.0/2.1 Level A/AA/AAA.
The system works as expected in selected browsers.
Check items:
The system should be accessible through selected devices.
Check items:
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.
Developers need to do pre-development research when adapting the framework to develop user-centric software.
Pre-development research includes:
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:
- Irrelevant
The checklist item does not map to the task or the task is out of the scope of the system.
- Fulfilled
The checklist item is fulfilled in the task.
- Unfulfilled
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.
[1] Article: 10 Usability Heuristics for User Interface Design https://www.nngroup.com/articles/ten-usability-heuristics/
[2] Section 508 standards https://www.access-board.gov/guidelines-and-standards/communications-and-it/about-the-ict-refresh/final-rule/text-of-the-standards-and-guidelines
[3] W3C Web Content Accessibility Guidelines (WCAG) 2.0/2.1 https://www.w3.org/WAI/standards-guidelines/wcag/
For more details about our solutions or to discuss a specific requirement
