Let’s talk about your technical implementation.
Ben HoEntwicklung
Is Simplicity Really Just Hidden Complexity? Why Simple Digital Products Are Often the Hardest
“Keep it simple.” That is probably one of the most complicated sentences when it comes to digital projects. Because what looks simple rarely is. On the contrary: the more intuitive a digital product is for the user, the more work has most likely happened behind the scenes.
and that is exactly what a digital product aims to achieve: Complexity should stay in the background, while the experience is as simple and intuitive as possible.
How much work lies behind an apparently simple process becomes clear with the example of a search field. A user enters a search term and, without much effort, receives a suitable result for their search:
Fast and easy to the result – at least for the user. Because for the correct result to actually appear in the end, and not just any result, the product has to solve a whole series of problems in the background:
- What happens with typos?
- Are suggestions shown while typing? If so, which ones?
- What happens if there are no results? What happens with 10,000 results?
- How are results prioritized? How do filters and sorting work?
- What happens in the event of an API error? How is a loading state displayed?
- Does the search work just as well on a smartphone? Is it fully operable via keyboard?
- Which results is the respective person even allowed to see?
That is exactly where the paradox of good digital products lies:
Complexity does not disappear. We only decide who has to carry it.
That is one of the most important tasks of good product design: not every decision that is technically possible also has to be a decision made by a person.
What users see and what the product has to solve
Basically, there are two possibilities.
1. The complexity ends up with the user
The system leaves as many decisions as possible to the person using it.
This probably makes the system easier to develop. For users, however, it becomes more complicated. They need to know more and make more decisions. This is especially problematic when they cannot possibly know which decision makes sense at that moment and best reflects what they actually want to search for.
2. The complexity ends up in the product
A good product can take on this complexity in the background.
- Instead of asking the person for a category, the system can infer what they are looking for from the search query.
- Instead of making them choose a sorting option, it can show the most relevant results by default.
- Instead of displaying an error message like “Invalid input,” it can detect a typo and run the search the user most likely intended.
- Instead of confronting the user with ten options, it can set a sensible default.
Good digital products are the ones that hide complexity from end users.
Three Laws of UX that explain why this works
To hide complexity from end users as effectively as possible, it helps to understand why a product feels simple in the first place. This is where the so-called Laws of UX come in.
1. Tesler’s Law: Complexity cannot disappear
Tesler’s Law, also known as the Law of Conservation of Complexity, describes a key insight for designing digital products.
Every system has an inherent complexity that cannot be completely removed. It can only be shifted.
That is exactly what the search field example shows: A system can ask users to define category, search area, time period, and sorting—or it can handle much of that automatically. The underlying complexity has not disappeared; it has simply been shifted from the user into the product.
Tesler’s Law leads to an important question:
Which complexity does the user really need to handle themselves—and which parts can we take on?
For UX, this means for example:
- reducing unnecessary decisions
- defining meaningful defaults
- prioritizing information
- structuring complex processes step by step
- enabling automation
- accounting for edge cases
- handling errors cleanly
- mapping states and dependencies within the system
2. Hick’s Law: Fewer decisions feel simpler
Tesler’s Law shows that complexity fundamentally exists. Hick’s Law answers the question of how much of it the user has to deal with at the same time.
Put simply, the law describes the relationship between the number of available options and the time people need to make a decision. The fewer choices we offer, the lower the effort becomes. Additional information can be added later, suggested, or determined automatically.
Hick’s Law means that fewer decisions at once are often better.
For UX, this means:
- prioritizing choices
- grouping options
- using progressive disclosure
- setting meaningful defaults
- not confronting users with decisions that only become relevant later
3. Jakob’s Law: Familiarity reduces learning effort
Even if a product requires few decisions, it can still feel complicated if every interaction has to be learned from scratch. This is where Jakob’s Law comes in.
The basic idea: users spend most of their time with other digital products and transfer the expectations they learned there to new products.
Users
- know that underlined text is often a link,
- expect a logo to lead to the homepage,
- are familiar with search fields, shopping carts, menus, and buttons.
These expectations save learning effort. An interface therefore does not need to reinvent every interaction in order to be innovative. On the contrary: familiar patterns can make complex processes easier to understand, and not every creative idea is automatically a better solution.
For UX, Jakob’s Law means:
- using familiar interaction patterns
- not breaking conventions without a reason
- using familiar terms
- making navigation easy to follow
- considering user expectations
What really defines simple products
A good product does not try to eliminate every bit of complexity. That is often not even possible. It tries to distribute it correctly. Four questions help with that:
Simple is not easy
“Make it simple” is not a design criterion, but a complex task. At its core is one important question:
Which complexity can we take on so the user does not have to?
Because complexity does not disappear. We can push it onto the user. Or we can build a product that solves part of it for them. The best digital products choose the latter.
