Insights at the intersection of digital business, technology, and customer experience from Maark agency leaders
For all the frustrating things about being at home the past eight months, one positive change has been the opportunity to get back into running. It's been a slow road, steadily increasing distances every few weeks, working up to an eighteen-mile run. I spent the few days leading up to that run hyping myself up, mentally preparing for what it would take out of me.
The run started like any other, setting the distance into the running app on my Apple Watch (which has recently replaced strapping my phone to my arm) and pressing GO. At about the nine-mile mark, I started to look for the road I was supposed to loop back on. To prevent making a mistake, I stopped to check the map.
The running app on my watch has a feature where it automatically pauses the run when it thinks you have stopped. It works most of the time but can be finicky, starting or stopping based on some arm movement or a momentary pause. This time, when I reached over to press the pause button, the app assumed I was ending my run and changed the pause button to a stop button. By the time I realized it had changed the button, it was too late. I heard a cheery voice through my headphones congratulate me on my "nine-mile run." Nine miles short of what I set out to do.
At face value, this is user error. I should have trusted that the system would work and pause the run for me. But it should also be hard for me, the user, to make that type of mistake. “User error,” of course, is just another way of saying “design fail.”
User error,” of course, is just another way of saying “design fail.
If an action a user is taking is potentially destructive or definitive, it should be relatively harder to achieve. Most folks experience this as a pop-up asking them to confirm they want to delete something or forcing people to type their email twice to make sure they typed it correctly (we can talk about if that actually helps people correctly type their email address in another post). But on my watch's running app, nobody implemented any of these potential mistake-stoppers.
We can use a few common methods to improve the “run-stopping” experience, so accidental stops are less likely.
A confirmation step is probably the most basic method to prevent user accidents. Most folks experience this method when they try to delete something, and an alert or pop-up appears asking them to confirm the action.
While running, this is as simple as asking the user if they are sure they want to end their run, giving them a chance to correct their mistake.
This method makes it harder to get to actions that are considered destructive. An action could be hidden deeper in the navigation (similar to account deletion on a social media service always being on the last page you look) or adjusting the size and position of a button to make it less prominent.
In our running app (and on the Apple Watch), going to a separate screen to stop seems like a lot to ask, but we could force the user to scroll to find the stop button.
This is a method that has become increasingly popular over the past few years. When the user tries to perform a destructive action, they must type in a word or code to confirm the action. This is similar to the confirmation method but has an added layer of interaction, making it even harder to make a mistake.
Forcing a user to “type” on the Apple Watch is probably overkill, so a better interface could be asking them to say the words "stop my run" to confirm the action.
This method offers a lot of room for creativity. We can take what might usually be just a button and turn it into something more unique, requiring a little more user effort to perform the action. This could be having them long-press a button to stop a run or using force-press on iOS devices. We could turn the button into a switch that is dragged across the screen to stop the run. We can even go a bit further and have the user draw an X to end their run.
Holding their finger on the “End” button shows the button color filling up until it triggers the ending of the run.
Perhaps the most mistake-proof is requiring the user to actually draw an X to end their run.
Users will always make mistakes—it's part of learning new systems and, frankly, just human nature. But design can make mistakes far less likely. Considering how someone will achieve a task in your app is just as important as thinking about how someone might make a mistake in your app.