design

Viewing posts tagged design

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.

Planning for Pixel Perfection & Mastering the Art of the Meticulous

High-quality, professional design is instantly recognizable. Every pixel is in place, every font considered, every interface element carefully selected, every color chosen intentionally. The end result glows with quality and effortless clarity.

Perfection not only thrills and pleases the client, but makes the entire design process easier on you, the designer. By getting the presentation and polish right from the beginning, clients more easily trust you, don’t second guess your choices ( or at least, not as much), and are far more likely to engage your services again.  The principle of least astonishment applies here;  try to think of the behavior that will least surprise someone who sees your work. The higher the quality of your deliverables, the more effortlessly they will be accepted.

But how do you get there? How does a junior UX designer develop an eye for detail and the skills to produce professional work? I remember struggling to climb this seemingly unobtainable pinnacle of perfect design many years ago, and today, I work with junior designers wrestling with the same challenges. This blog post came out of email discussions within our team, and we decided to share it publicly.  I realized recently that telling our designers they need to be perfect is useless guidance, and even somewhat cruel to ask of them. But offering some guidelines about how to get to perfection might actually be useful, to our internal designers and perhaps a larger audience as well.

When discussing how to teach perfection in design, we came up with three basic principles to keep in mind: Consistency, Accuracy and Coherence. Let’s look at each one a bit more deeply.

Consistency

Interaction design must be consistent on many levels. Navigation and element placement must be consistent throughout all screens. Colors and other visual touches must remain the same or within the same palette and visual family. Language, tone, labels and word choice must work together to create a unified voice. For example, if a header uses a blue background, stretchy width, a subtle grid pattern and is 120 pixels high on some pages, it should use the same styling on all screens.

The “flip book technique” (quickly moving between pages when reviewing your work) really helps with consistency. You can see where things shift out of place, etc. Consistency can also really help with accuracy, but more about that below.

Accuracy

Ever been in a review meeting where the client gets fixated on a typo? Nothing more annoying, right? It is up to the designer to always make sure files are absolutely accurate, spelling has been checked, the right logo is in place, and every bit of client feedback has been considered and properly reflected in the screens. Accuracy moves beyond just pixels and words to also encompass interaction design. It includes making sure all user behaviors have been thought through and reflect what can be done on the intended delivery platform within any technical limitations. Accuracy also means being aware of common interaction design platform conventions and respecting them.

Coherence

Coherence is making sure the story, the big picture, makes sense. In coherent design files, numbers add up, the narrative holds together and the interaction model reflects actual usage. Coherence is also what separates great interaction design from graphic design. A coherent interaction model is absolutely essential for users – if you don’t create a coherent mental model first, your users don’t stand a chance of making sense of your work.

The less time you have to spend on consistency and accuracy, the more time you have left to focus on crafting a coherent narrative that thoroughly addresses user needs. This is the heart of UX, and when you can achieve true coherence in UX design, you start to internalize what it means to be a senior designer.

Methods & Techniques

Ok, enough of the high level abstract approach. What does a junior designer actually DO to ensure flawless deliverables? Part of the answer is simply to check your work, again and again, and then have someone else check it as well. There is no magic trick here, only a lot of hard work, and most importantly, developing habits that become second nature over time. As your work matures, you will find yourself spending less time fidgeting with alignment and size issues, and more time thinking about the interaction model, your users’ needs, and how the approach to the application design as a whole could better meet those needs.

But first, it can sometimes take junior designers a long period of time to master consistency and accuracy. This is my personal approach to create perfect files for client delivery. In general, it seems to really help to export to the format you will be using to deliver to the client. Also, printing screens out and reviewing them in analog is often quite useful, though I have to counter-balance my hatred of wasting paper with the pay off of a non-glare surface. I also review any notes from the client or myself a few times too, to make sure all requested changes got made and didn’t get lost in the shuffle. Finally, I take a look at the previous rev of my files, to find any elements that might have disappeared by accident.

Then I send off my files to another member of the team for a review with a fresh set of eyes. I take and incorporate the feedback from this review, double and triple check the files a last time, and finally send them off for client review.

Sound like a lot of work? It is! But so worth it. When quality is lacking, client dialogue devolves into pixel picking and bickering over details. The big picture gets lost and the project as a whole loses its way. In our experience, doing many multiple rounds of review first is the only approach for professional quality design work.