One of the missions of UX is to simplify complex processes. In the meantime, entangled with the placement, size, and color of a Button, or studying the “temper” of various user groups. Make simple become complicated, it’s very simple. But to make the complexity simple, to become very simple, this is creativity.
In terms of function, by evaluating and deleting unnecessary functions, concealing the functions that cannot be deleted, in order to reduce the complexity. Visually, by reducing visual interference, reuse components, in order to reduce the complexity of the senses.
In short, leave the complexity to yourself and return the simplicity to the user.
Look through the foreign language translations at the bottom of the press box, and come up with a translation to share with everyone.
Good products focus on simplicity rather than complex functions. The problem should be solved through a simple solution, once and for all. The perfect solution is so simple and transparent that you might even forget that it was designed.
However, the elegant little design is not accidental. They are the result of difficult decisions. Whether in conception, design, or in the testing phase of the project, UX designers play a key role in reducing the complexity of the project.
Why you should reduce complexity in scope
Over-designed and complex products usually originate from the concept of “more is better”. Add functional features outside of demand to enhance the overall value of the product. In essence, the continuous increase of product features makes people feel that the product can give users more flexibility in choice. Similarly, reducing product features means limiting your users.
If we equate scope and complexity instead of flexibility, then the theme of this article will change, because in fact, complexity and scope have a mutually reinforcing relationship. Every new feature brings additional expectations. To put it bluntly, the continuous expansion of the scope means that there are more opportunities to mess up the product.
In the early stage, unnecessary and complicated functions will make product development more difficult and add extra burden to future versions. Because at the beginning of the project, the user interface has already established constraints. We will achieve our original design ideas through continuous iterations in the future. Therefore, it is crucial to focus on early features. The other method, trying to solve the problem more and more quickly, means that the risk of reaching the initial design decision is increasing.
Reduce complex technology, elegant small functions can help you clarify product propositions and simplify user experience. Any function that is not conducive to helping users solve problems should be considered as the cause of distracting users and causing unnecessary obstacles, which will destroy the value of your product.
Define the scope correctly
Defining the scope is not easy. Different users have different needs. This is a gray area. Deleting features may result in a decline in the value of your product and revenue.
In addition, the simplified design reduces complexity, but it does not always work, and sometimes even creates huge obstacles for users. A good example is financial software. The user interface of this type of software is usually designed around the complex function of “financial management”.
However, to design a complicated user interface and user experience just because of a complicated task is a complete excuse. We need to control the number of real needs to design solutions. Only by removing complexity while retaining power and control can an excellent solution be obtained.
Prevention of scope spread
Once your initial scope (or the level of complexity you can tolerate) has been defined, the best approach is to solve one feature at a time. Each iteration revolves around the most critical and understandable problem and solves it.
In this way, the additional functions often make users feel that it is a simple natural extension, which is a simple method that kills two birds with one stone. Although sometimes seemingly low-cost additional function design, there are hidden costs.
Unnecessary features can distract developers and designers. Make them unable to focus on optimizing the details of the product or other things that can help users. They will also downplay the core goals and important features of your product.
Clearly understand what new features you need to add, and what is the point of developing them. Categorize functions as useful and easy-to-use, extract them, and make sure that they are really necessary requirements through repeated consideration. Ultimately, you have to accept the gray area. The features you remove will result in a drop in expectations and revenue.
Why you should reduce the complexity of internal design
Complexity cannot be simply expressed as functional spread. It may still exist in a very small viable product, the interaction method is too complicated, and the performance is unconventional.
Although the function is tightly restricted to an elegant minimal function, what we need to think about is the complexity of the function itself. This may lead to internal complex functions. The most appropriate remedy is to add an additional function.
Here is an example. In a recent project, when the user insisted on an auto-save button function at a specific location on a page, the save button allowed the user to have more interaction, and its results were more intuitive (confirmed after testing).
The expansion of the minimum viable product range increases complexity, which offsets the reduced complexity of system technology and user interface design.
Therefore, the minimum feature set does not necessarily translate into a simplified user interface. Cumbersome interactions or poorly designed user experiences can easily offset the benefits of removing unnecessary features. Similarly, it is sometimes necessary to expand the scope of the system to reduce the complexity of some internal functional design.
Complexity management of internal design
Managing the “complexity of internal design” relies on a paradox. This sentence applies to the complexity of any particular single function. However, the meaning of “internal” complexity is not limited to a single function. Managing the complexity of internal design requires us to evaluate solutions on two levels. Only by analyzing the key solutions from beginning to end can we effectively judge whether any single function can be as simple as possible or show its importance.
Check a feature set and decide which features can be safely eliminated without jeopardizing the core goal of the product. Simplification is a double-edged sword. The simple concept and mentality inherent in “the smallest viable product” will drive us to achieve cleaner, more convenient, and more elegant designs. However, the simplified process often deceives us and compromises a simple solution as a whole.
Broadly speaking, it may actually lead us to add a function here or there to make it easier to use.
Take the above auto-save function as an example: correct insight into the behavior of a single function is a complicated matter. Adding a feature reduces the chance of the feature being misunderstood or misused. However, in addition to this, it will also ensure that instances of counter-intuitive behavior will not be used as precedents for how to perceive broader solutions.
This is a paradox: you can have the most elegant and simple feature set, but if you do not follow the principle of overall and flexibility, you will not achieve simple features. A single simple function may become a trend.
In conclusion
The core difficulty of the complexity and user interface we discussed is that the degree of complexity can easily be misunderstood. This is a qualitative concept. Therefore, it is important for us to avoid subjectivity in our discussions. We must realize that complexity can only be reduced to a certain point, after which the design may lose its integrity and influence.
It does not mean that all design methods are more or less complicated. We are talking about the experience of the system, not a quantitative analysis of complexity. Finally, to determine the overall user experience impact range and internal design complexity, you need to refer to the context to understand.
As a result, many discussions of complexity and simplification revolve around whether complexity is an additional attribute. Maybe there is nothing wrong with this, but you should have a clear understanding of your product. Software should have its own deep-rooted personality.
