Breaking down a difficult task into bite-sized steps is a good first step to making a task simpler…but only if you build each step correctly. Here’s how to make a difficult process for your users into something much easier.
In a previous column on creating user interfaces for difficult tasks, I discussed how a difficult task is one with four components: Volatility, Uncertainty, Complexity, Ambiguity, and Delayed feedback (the military refers to this as VOCAD). In that column, I looked at the first two steps in creating a UX for handling difficult tasks so that the user no longer sees the task as difficult:
In this blog post I’m going to finish that discussion by looking at what you need to do in those simpler steps to further reduce complexity, address uncertainty, eliminate ambiguity, and avoid delayed feedback
Breaking the task down into simpler steps not only reduces the complexity overall, it also provides you with additional ways to reduce the task’s difficulty within each step.
For example, on each screen where the user the user has to make a decision you can reduce uncertainty by presenting all the necessary information the user needs on that form — and no other information except what the user needs on that form. Just by focusing the information you tell your users that they don’t need to worry about other inputs. This design also avoids asking the user to remember relevant information/decisions from previous screens. While, in theory, short term memory allows the user to remember things for up to 30 seconds that’s only true if the user isn’t distracted and knows what information they need to remember. In practice, without a special effort to remember something, items from previous screens will be lost to the user within 5 or 10 seconds.
You can also reduce ambiguity at each step by providing explanations of what will happen when the user makes a choice. Make sure that you avoid words that increase ambiguity: “Pick the appropriate option” and “Pick the right choice,” for example increase ambiguity. If the user is unfamiliar with the task and doesn’t know what they’re doing then the user won’t know what’s appropriate or right (quite frankly, if the user knew what the appropriate or right choice was, they wouldn’t consider this a “difficult task”). I discussed these kinds of words in a blog post on effective communication.
To further reduce ambiguity/uncertainty, tie your explanations to the user’s goals and the results they’re trying to achieve (i.e. don’t tie the explanations to internal changes to state of the application). In a shipping application, for example, the user’s goals are probably tied to speed and costs so an explanation like “Picking this choice will reduce shipping charges by 50%” is far more valuable than “Picking this choice will give you Premium Shipping”. The best explanation of all is tie the result what the user values using an example: “If you make this choice then you will get this result.”
Putting results-oriented explanations together with examples, leads to the Blank Slate design pattern. The Blank Slate pattern shows the outcome of each choice and avoid delayed feedback. In early steps, you can provide feedback to the user by specifying what options will no longer be available later in the process; In later steps, you can tell the user what result the user will get from their choice. Effectively, the user gets feedback at every step.
Finally, you can reduce complexity in individual steps by leveraging the choices that the user makes in early steps. For example, you can use early decisions to prune later options: the user will have fewer choices to make later in the process and later steps will appear less complicated. Alternatively, in later steps you can tell the user how these later choices will interact with earlier choices to provide the final result. Effectively, you can let the user see their mistakes before they commit to making them.
Because you’re now letting the user see their mistakes before they make them, it’s important that you allow the user to go back and change earlier entries. In a wizard this can mean clicking on a Previous button to go back to an earlier step; If the task is handled in a single form, it may just mean selecting a different option from higher up in the form. Giving users the ability to revisit earlier decisions reduces uncertainty by allowing the user to experiment with different combinations until they get one they like: The user isn’t forced to commit to a choice until they’re certain they’ll achieve their goal.
Part of implementing the “ability to experiment” is that you must allow the user to not make a change. While each step should advance the user towards their goal, no step (except the final one) should make any permanent changes. The user should also be able to cancel out of the process at any point — including right at the final step.
A common misconception among UX designers is that fewer controls will make the UI simpler. For difficult tasks, that’s not true. Instead, providing users with support for a difficult task consists of breaking the task down into smaller steps that make sense to the user, designing each steps in a way that supports the decision/action for that step, showing how each step ties to the user’s goals, and providing a flow that allows the user to experiment without commitment. Do those four things and your users may not even realize that they are completing a task that, without your help, would have been too hard for them to do.