Designing for Complexity

“Everything should be made as simple as possible, but not simpler.” – Albert Einstein

Simplicity is a frequent mantra for designers, and even a perpetual goal. How often have we heard or said – make it clean, make it simple, increase the white space, decrease the clutter. To be sure, simplicity is an utterly worthy goal in most cases.

But life, well, life is infinitely complicated, and sometimes software systems are complex as well. A to-do app on a smart phone should be super simple, but I want the security management tools used by the IT staff at my bank to be complete, providing them with the means to do all they need to do efficiently and without error. Sometimes, complexity can not be easily hidden, abstracted away or shoved under the hood. So what does a well intentioned designer do when faced with the challenges of designing for a complex system?

When confronted with a situation where there is a need to provide expert users with detailed information or an ability to manage very complex tasks that require years of experience or large amounts of training to master, I would like to suggest this is an appropriate time to shift the overriding design principle in play from “simple” to “efficient”, or even, “adept”. Instead of trying to hide or downplay the complexity of a system, instead, navigate users through the system with frictionless ease towards deep mastery. Humans are capable of incredibly arcane and recondite tasks, when trained properly and presented with repeatable and familiar guidance along the way. Therefore, UX design does not need to always shy away from complexity, but rather, sometimes must embrace and build for it.

Let’s look at some examples of truly elaborate and intricate software systems, and then explore some design strategies for coping with the complex.

Examples of Complex Applications

Here are examples of two major areas of software application design that are deeply complex in nature and truly call for more elaborate interfaces and design solutions; logistics and also remote monitoring and control.

Logistics

Applications that manage as well as provide workflow control, oversight and reporting for logistics and operations are rarely simple. Think of all the details that rest behind a simple act like ordering a physical book on Amazon. Is it in stock? Which warehouse is most cost effective to ship from? How does it get picked, packed, labeled and shipped? How does this single book purchase weigh into the massive reporting structures behind Amazon accounting?

Inventory management is just one example of a logistics application. Supply chain management and shipping are other related examples. And if thinking through the purchase of a single book seems complex, imagine the supply chain management applications that track every single part and supplier for a car, or a smart phone.

Remote Monitoring and Control

Software to oversee, monitor, maintain and control complex systems from afar are another seriously intricate and involved design challenge. Examples of this type of application would be the infamous systems used for air traffic control as well as train and subway control. I have never seen the software that manages the New York subway system, but it is easy to imagine its detailed demands as well as the possibly life imperiling consequences of thoughtless design choices.

Distributed database and network management tools are another common sub-species of this software category. Not only can a database or network schema involve thousands of objects and nodes, the virtual nature of these objects just adds another layer of abstraction to test and stretch the human brain. The database clusters that run the New York Stock Exchange are one example of the natural extreme of what software can create and manage for mankind, and they never will be simple.

UX Strategies for Complex Systems

So, let’s look at six basic strategies, techniques and approaches for taking these complex systems and turning them into manageable software designs.

1. Prioritize Tasks

Most enterprise software packages can do hundreds or even thousands of tasks, but not all of theses tasks are equally important or frequent.Therefore, going through an exercise to prioritize use cases can be extremely helpful. Once a designer knows what tasks are most common versus least common, it is far easier to make UI prioritization decisions such as choosing what actions are triggered by big buttons instead of small text links, or what items are in the main navigation versus secondary or tertiary navigation.

This exercise is known as weighting. Weighting allows the human brain to easily identify the most important controls in an application easily. Unweighted applications can be visually overwhelming, whereas weighting and prioritization guide users to their most common destinations effortlessly.

Segmentation is another corollary to weighting. By grouping tasks around a common theme or object, users will naturally seek and find related controls. Logical groupings can be around objects, or around common workflows. For example, users, groups, roles and permissions are almost always grouped together.

Of course, weighting and segmentation do nothing to help manage complexity if they aren’t approached from the perspective of the personas representing your heaviest users. If you weight your tasks according to the feature bullet points on your product’s sales presentations, or segment tasks according to your organization’s org chart, users will feel the functionality they rely on to do their jobs has been buried.

2. Be Consistent and Use Patterns

Humans just love patterns. We are hardwired to do the same things in the same way repeatedly. We look for objects in the physical world to stay where they were last put, and we expect the same of our software. Therefore, keeping navigation, language and page placement consistent across an application is key. If a command says Start Server on one page and is shown by a big green button, the same language and visual treatment should be used everywhere consistently. Similarly, if a link to My Account is shown on the top right of some screens, it should consistently keep the same placement across all screens.

Patterns are another similar technique to appeal to familiarity and recognizable controls. One of the more common patterns known to many users is the use of a wizard to guide users through a multi-step process. Most everyone will recognize a wizard, know that the numbered steps represent parts to the process, and will have a clear sense of where they are and what needs to be done. When patterns emerge as part of your product, it makes sense to use these patterns consistently, to both reinforce and satisfy user expectations about their behavior. This consistency can provide the user with the confidence that the time and energy they invest in mastery will be rewarded.

3. Use Data Visualizations (wisely)

Data visualizations are all the rage and for good reason – there is nothing like a basic line graph to make a trend immediately obvious from what would otherwise be an indistinguishable sea of numbers.  Charts and graphs are absolutely invaluable for parsing large data sets and getting at underlying anomalies, trends, totals, comparisons and proportions. When used properly, data visualization can be used to tell a story, alert users to errors and oddities as well as call out recurring events and issues.

The key is to keep data visualization relevant and accurate, with an appropriate level of fidelity and user control. The choice of which data to visualize and of the data visualization method should be appropriate to the user’s task as it relates to the data. Extraneous charts or chart types (whether to provide eye candy or other spurious motivations) only serve to clutter and detract from the clarity of the data message the expert user needs to be able to receive in a timely and efficient manner.

That being said, it is equally important to provide a sufficient level of granularity and user control to allow the user to complete their task. If the user needs be able to see daily values, showing them a chart that only contains monthly values isn’t going to help the user much with their task. Some tasks require the ability to apply complex filters and rules to reveal patterns or associations that would otherwise be difficult to detect. In order to choose these mechanisms wisely, it is of the utmost important to have a crystal clear understanding of the nature of the user’s tasks, particularly those of the frequent/heavy/expert user.

4. Adapt UI to Roles

Most complex software is designed for not just one type of user, but several. For example, the domain administrator who sets up a process for source control management to be used throughout an entire company is not the developer who will be checking in code. Personas to the rescue! By carefully identifying the different types of users in a system (personas or roles), and the tasks they are required to perform, large chunks of the application can be “hidden” from those users who will never need them.

Adapting the user interface to the role of the user and their specific needs requires a fair amount of careful planning up front, but it can be a huge aid in removing superfluous commands and complexity from the user’s experience.

5. Learn and Adapt to Repeated User Behavior

Software systems are too often designed as static. What you get out of the box, is what you get, forever. However, it is not hard to see after a week or month, what tools and controls are used by individuals most often. A set of user-specific frequent tasks on the home or dashboard of an application is a quick way to provide short cuts for each user to what they need and do most often. More sophisticated UIs can change the weighting and priority in navigation and screens layouts to match user behavior as well. Similarly, forms or entries that are re-used frequently, and with the same common values, can be pre-filled based on previous repeated entries. Here the concept of software memory comes into play to help the user gracefully complete repeated tasks as effortlessly as possible.

Adaptive UIs require an understanding of the way a user’s task may change or evolve over time. Day one tasks are different from month one tasks, and those may different yet again from month two tasks.

6. The Simplest UI is no UI

Sometimes, the best user experience solution is to skip the user interface entirely. It is always worth asking if a UI is the right solution for a problem, or if instead a script, a notification, and/or a wiki page of instructions might be the better answer.

Strange as it may seem conceptually, sometimes the answer might not be great design, but great DevOps.  DevOps is about collaboration, people over process over tools. Taking it even a step further, NoOps is about automation; invisible tools that make people and process unnecessary. Whether NoOps turns out to be a pipe dream or not, it’s clear that in many areas of software development and operations, there is a strong push towards automation as a means of increasing software quality. A desire for automation leads to the need to eliminate user interfaces that cannot be easily scripted and ultimately controlled by other software.

Never send a human in to do a computer’s job.

In Conclusion

This simple toolset of methods to mitigate complexity is by no means exhaustive, but should provide a good starting point when designing for complexity.

If nothing else, remember that complexity is not always enemy and need not be equated with difficulty. Complexity is merely another design constraint. Complex applications can be immensely powerful and even aesthetically pleasing and enjoyable to use when designed with the proper approach and techniques.

Tags: , , , , ,