Low Impedance User Experiences
Some of the highest value work a product manager can do, leading to the best user outcomes, is to sponsor and encourage the creation of what I like to call “low impedance” user interfaces. This kind of interface facilitates smooth user experiences. Creating them requires thoughtful and insightful design. The reason this work is so valuable is that the user experience is the point of traction between your product and people trying to get something done. Making their task a chore, or simplicity itself, is the difference between a product that is loathed, or one that is a delight to use.
The key design goal, in low impedance user experiences, is to minimise cognitive load. The idea is to make the software resist the user’s intentions as little as possible. A good design should reduce the amount of thinking the user has to do, to succeed in accomplishing their task with your software. Let them simply do, without having to think too much about how to do.
When a user is attempting to use a product to accomplish some goal, their focus is on the job they want to do. The product is a tool. If it requires a lot of thought to use, it becomes a distraction and the user loses focus on their original intention. Instead, they have to fuss and futz with the software, until it yields the result they were looking for. In some designs, the software never yields at all and the user is thwarted in their aim.
Sadly, despite the recent focus on user experience design, the whole industry still produces user experiences that resist users fiercely, acting like opponents rather than facilitators. Some interfaces are positively injurious. Most just waste your time needlessly and get in the way of doing your work. There is still a long way to go.
Map the task
Before you can design a low impedance user experience, you must understand the task that the user is trying to accomplish in some detail. How would you do this without software? How does software help do it better (faster, fewer steps, automating tedious steps)? Prototype and validate the work flow on paper (or as digital design artefacts). See if real users like what you’re proposing. Producing a tool to do any job only has value if it makes the job easier.
Familiarity breeds facility
For better or worse, the gestures or mouse movements used on-screen to do certain things have been largely unchanged for some thirty years. It doesn’t make sense to go against all that accumulated learning, to introduce new ways to do the same things. Use familiarity and common usage patterns. People already know how to use other software. Make your software operate in similar ways. It’s still a source of irritation to people switching from Windows to Mac (or vice versa) that familiar operations, like minimising a window, are done differently. Web based applications have a third set of browser-based selection gestures. Making these switches increases cognitive load. It slows users down and draws their focus away from their task, while they figure out how to do something peripheral that was second nature, in the other computer.
Prompts and nudges
Have you ever noticed how most user interfaces present all the options available in the same way, no matter what you’re doing? The goal is to have a modeless design, so that no matter what you’re doing, you can do anything else you choose, at any time. The problem is that real people don’t work that way. You don’t stop chopping onions, just to place the half-finished onions in the stew on a whim. You also cannot take the onions back out of the stew to keep chopping them (they’ve already softened).
Instead, there are sequential constraints. The onions have to be fully chopped, before you add them to the pot. When there are sequential constraints in the real world task flow, a lot of the on-screen options you cannot practically use become temporary screen clutter. They’re irrelevant at the moment. Identifying which parts of the job the user is trying to do are truly modeless, versus those that are modal, requires analysis. The truth is that most creative tasks have moments when they are modal and moments when they are modeless. It’s a blend. I don’t want to see mastering tools, in a DAW, when I haven’t completed a mix, for example.
The problem with modal interface elements is that the user is easily disoriented. It has to be clear to them which mode they’re in now, how they got here, what they can and can’t do while in this mode and how to get back to somewhere more familiar, without breaking anything or losing their work. Most modal interfaces fail in at least one of these requirements.
You can make a lower impedance user interface by removing irrelevant options (or greying them out, but removal is cleaner), when they cannot be practically used. Also, you can prompt next possible actions using animation, to bring those controls to prominence or even wiggle them a bit, so that the user notices them in their peripheral vision. Giving the user a clue about what is and isn’t possible and useful, while they’re in the middle of doing some complex, multi-step work flow, can ease the cognitive load. The menu options and controls offered need to be dynamic.
Similarly, if the user interface presents an input form field, it often helps to auto-fill it with default values, or provide some sort of example as guidance. Don’t make people play guessing games and then thwart their flow by intruding in it with accusatory error messages, after the fact. Seeing what’s wrong while you’re doing it is far preferable to being told you did it wrong and having to do it again, from scratch. Correcting form entries before they are submitted is a better user experience.
Put it where I can see it
Let’s say you’re importing a 3D object, made in Microsoft Paint 3D, into a Word document, over a picture. Why would you ever want that object to appear behind the picture, thereby obscuring it completely? The answer is never, yet this is precisely what happens. The user is left wondering what happened to the thing they wanted to place. As a rule of thumb, put the thing I am focused on manipulating where I can see it.
The same thing applies to controls and options. Patterns of usage can be measured and characterised, using eye scans and heat maps. If the likelihood of using a control or option is high, at a given step in a work flow, then the size and position of it should be where I can see it. It shouldn’t remain hidden in sub menus, or be a tiny check box placed off to the side of larger controls that I’m not going to be interested in. Layout is flexible. Sometimes, it should change dynamically to put what you need to use in front of you, moving options and controls you’re not going to use out of the way.
Make the work flow
There is an art in making workflows flow. Ideally, your user interface should respect logical next steps, from real world practice. If the work flow is interrupted to do parenthetical subtasks, like configuring a peripheral device differently, or attending to pre-requisites that the work flow should have asked you to sort out, before you got into your task, then the work will not flow. It will feel disjointed and erratic, as if you’re waiting for buffering to complete. The golden rule is that, if the user is busy and their work is flowing, don’t interrupt them.
On an iPad, for example, you can be listening intently to a video that is playing, which has your full focus and attention, but the audio will dim to inaudibility momentarily, because an email notification has just arrived and the OS insists on playing a sound to alert you. It interrupts the soundtrack of the video to play a sound you didn’t want to hear! Incredibly intrusive!
If I’m listening to my favourite tunes in Spotify with my phone, connected to a Bluetooth speaker and I open up Twitter to check my messages, the phone will pause my music, to prepare to play videos embeded in the Twitter time line I have no interest in watching.
On Windows, you can be in the middle of recording some audio in Audacity, for example, and Windows will intrude to announce that there is a new security update available. Not only will the notification appear on the screen, but the recording will be contaminated with the audible notification announcement sound. You will have to start your recording again. It’s infuriating. Windows notifications do not respect important video conferences being in progress either.
The aim, in designing low impedance user experiences, is to give the sense that the mechanics of operating the interface are receding into the background, in the mind of the user, so that they can focus entirely on the work they’re doing with the software. If you drive a car, using the indicators or changing gears eventually become things you don’t have to consciously think about. You just do them, while thinking about other things, like driving to your destination. Low impedance interfaces are like that. Accomplishing what you want to do becomes autonomic. You can almost do it with your eyes closed. There certainly isn’t any need to apply conscious attention to the task.
Don’t make me go over there
During usability studies, it’s worth measuring mouse mileage, with a view to reducing it. It’s often the case that actions that are repeated often require the user to click on something on the screen, then move all the way across the screen to complete the operation, then move back again, to do it all again. This movement requires fine motor skills to aim at the object on the screen, so repetition fatigues human muscles and can even cause painful repetitive strain injuries. In the worst case, those injuring are so debilitating, that the user can’t use your software at all, any more.
Using a mouse for pixel perfect positioning of pictorial objects is a notorious source of fatigue that affects user experience designers themselves. The movement of the mouse is too imprecise, or too sensitive, requiring that arm muscles tense, while the user fights with the mouse to get the thing on their screen at just the right place. If you zoom in, then distant movements become a strain and hard to see. If you stay zoomed out, to see the context, then fine movements are difficult to accomplish with the mouse. It seems like you can’t win.
Low impedance interfaces take the coarse and fine movement problem into consideration and accommodate the user, to help them accomplish their task without needless frustration or strain. They also don’t make you repeatedly move long screen distances to land on tiny targets, as part of their work flow.
Discoverability
Most users prefer software that they can figure out how to use, without resorting to reading a manual or detailed training. What the software does should be more or less discoverable. Unfortunately, there are many applications where, unless you’ve walked through the right preliminary steps, in the right order, to set things up, you can peck around with the menu options forever and never accomplish anything. You’re lost, because you haven’t followed the implied rules of engagement and there is no way to easily discover what you don’t know you haven’t yet done, when you first use the software.
Low impedance user experiences walk you through this explicitly. They don’t land you in the middle of an application that isn’t yet set up to do anything useful. Rather, they guide you toward becoming productive quickly. Once you’ve established your preferences, they remember them and ensure that you have the option of automatically applying them, or else walking through the preliminaries again, when you next open the application.
Leverage muscle memory
Keyboard accelerators (or keyboard short cuts) are a double-edged sword. If you can remember them, they’re definitely faster and easier to use and allow you to work, without breaking your flow. However, there is a learning curve and the same key stroke combinations can do radically different (and unexpected things), in different software applications, on the same computer. For example, Control+Shift+Q will close Google Chrome for you, but you need to use :wq to exit popular and venerable text editing programme VIM (and save the file you were working on). Simply demanding you use the Control key in Windows and the Command key in MacOS (with the Control key sitting idly nearby), to perform simple things like cut and paste, is enough to break the flow.
Use key stroke accelerators judiciously. Leveraging muscle memory can make this way of interacting very fast, but if you’re not good at remembering magic spells and the context you’re in, they can hinder badly. The cognitive load can be high, until they’ve been committed to memory.
Wrapping it up
Even today, in the twenty-first century, user experiences are degraded because user interface designs fight you all the way, providing obstacles and interruptions to doing your work, which simply don’t need to be there. They still present a sea of irrelevance to new users and force them to comply with arbitrary and overly restrictive conditions. Often, they make simple tasks into difficult-to-achieve trials. They hide things that ought to be obvious and force you into playing guessing games you can only lose. Using them feels like having your cognition forcibly jarred and beaten. The work you do suffers, because part of your focus is drawn to dealing with the weirdness of the tool you’re trying to use.
In short, it’s as if they’ve been designed to make you learn to hate the software and the people that made and sold it to you.
We can and should do better than this.
About the author
Michael Topic is a freelance Product Manager with over thirty years experience delivering products that didn’t exist before. He welcomes contract enquiries to define new, competitive products, design them and deliver them. His speciality is software-based products.
Disclaimer
The opinions offered in this article are intended to describe common scenarios that sometimes occur in general product management practice. They are in no way intended to be read as referring to any particular employer, past or present.
