The Design Emergency

Help for grown worlds

Our world is complicated. It has grown historically. It has so many interdependent interfaces in an unstable network. No one can see through it anymore. It can no longer go on like this: we must make the world simpler again.

Are you familiar with this kind of a setting? If you replace “world” with “software” (or, interestingly, “organization”) this scenario might even remind you of one or two meetings in your company.

I call this phenomenon Design Emergency. I have encountered it again and again at large and small B2B software vendors, especially when the core product is just celebrating its first two-digit birthday (in software years it comes from the Stone Age). All of a sudden, operating problems appear at every turn, dissatisfaction among users is spreading, and the sales department is getting more and more embarrassed when something goes wrong with the product presentation. Surprise, the world outside has once again become more complicated and we are lagging behind. Possible reactions: discuss it, change everything immediately, call for help, freeze, make eyes, hide in the cave, see what happens. It seems like a huge construction site and nobody knows where to start. In this article I would like to show how you can react to such a Design Emergency with small means and without panic.

Get the club out!

The temptation is always close to surrendering to the complexity of the world and hoping that the Design Emergency will eventually take care of itself. However, change cannot be achieved in this way and experience has shown that problems tend to increase rather than decrease over time. So I suggest the following first step (which was also invented in the Stone Age, by the way): Get the club out!

We really pull it through, hit the structure in front of us with full force and dismantle it into its individual parts with one blow. Bämmmm.

In reality the club brings up some questions, a little less brutal, but just as powerful. We don’t break anything, but rather try to uncover the core of our product. This starts with the mother of all UX questions:

• Who are our users?

We should ask ourselves this question again and again, even if we think we already know everything about our users. We continue with questions of principle:

• What problem do we actually want to solve with our product?
• Which features contribute to this?
• What are the components of our software interface?

But it may and must also become more abstract:

• What personality does our software have/ how does it tick?
• What feelings does our software trigger during operation?
• What comparisons come to mind when we look at the user interface as if it were the first time we saw it?

Consistency as a miracle cure

In the case of the acute Design Emergency, it has already been good to look at things from a different perspective. Provided that we come to the conclusion that the software product still fulfills a purpose, then we should do something as soon as possible to make it popular again. What we need is a little miracle cure. I suggest this: Identify consistency problems and eliminate them! Small effort – big effect. Or as Jacob Nielsen says: “Consistency is one of the most powerful usability priciples: when things always behave the same, users don’t have to worry about what will happen”.

With interfaces that have grown over the years, consistency problems can always be found, that’s a promise! Sometimes they can be read like diaries that have been kept over the years: Legends from the founding phase, traces of changing development teams, one or more redesigns. But so that it doesn’t get too complicated again, it’s first a matter of fixing the seemingly most banal things, such as “Are my buttons the same everywhere and recognizable as buttons everywhere?”.

Now you could think that consistency is not so important, because users have got used to these things a long time ago. But it is difficult to get used to things that are always different. Think of a tap with hot and cold directions reversed, would you like to get used to it? Exactly, which is why we need consistency.

Clean up!

“We still need this, we still need that, we need everything!” Clearly, feature requests are the snowball that leads to the big Design Emergency avalanche. And once developed, you can’t get rid of these things that quickly. Not even in agile development projects, by the way. Or ask anew in every sprint: Which of the stuff we have developed is still being used?

And so the interface fills up more and more, becomes more and more complicated and inconsistent, the information architecture resembles a timbered booth and nobody dares to go through with the evacuation team. Unless the technical dept is high enough, then features are allowed to bless the passing of time.

For users, on the other hand, there is hardly anything more frustrating than favourite features that disappear overnight or information that is located in other places than usual. That’s why it’s important that users are involved in the decluttering process and that it’s not just a technology-driven decision. Cleaning up also means structuring for order. In concrete terms, this means bringing things back to the place where they belong.

Inspire in detail

I’ll sum it up: Up to this point, we have dismantled everything into its individual parts with a club, then took a sip of consistency potion to strengthen it, before the interface is mucked out, structured and dust wiped. In short, we have already taken important steps to improve the usability of our software. The Design Emergency has been averted for the time being. And even though we should be aware that no software is immortal, we have done something to ensure that existing and new users can work better with our software now (and not after two years of development). Duty fulfilled. But I wouldn’t be a User Experience Designer if I didn’t ask at the end: What can we do to inspire users beyond that?

Keep looking for a detail, for the small innovation. Learn from your users. Don’t be satisfied with the current situation. You don’t have to redo everything and turn it upside down: In the end, it is the small gestures that make the difference, because they show to the users that their needs are understood.

Note:

Anna Zinsser has published more articles in the t2informatik Blog, including

t2informatik develops and modernises software as a service provider. Click here to learn more.