Who assumes the complexity: your user or your app?

Design · 5 min read

Every app has complexity. There's no way around it. If someone is using your app to manage budgets, track tasks, coordinate people, or organise information, there's going to be a lot happening under the hood. The question isn't whether the complexity exists. It's who absorbs it.

There's a principle I come back to constantly in design. I call it the complexity balance. One side of the system has to take on the hard work. Either the user does it, or the app does it. You can't split the difference. One of them carries the weight.

The best apps in the world feel effortless to use. Not because they do simple things. Because they do complex things and make them look simple. That's the whole trick. And it's harder to pull off than most people think.

Let the app carry the weight

I had a client who needed their users to set up a budget. There were multiple categories, different spending levels, and all sorts of variables depending on what the user was doing. The obvious approach is to give the user a form. Let them fill it all in. Dropdowns, text fields, checkboxes. The whole lot.

Instead, we gave them one button. One button that said "get recommendation." They tap it, the app does the maths, and the budget populates itself. If they want to tweak it, they can. But the starting point is already done. The complexity of calculating those numbers, pulling in the right data, matching it to the user's situation, that all lives in the back end. The user just sees the result.

That's the principle at work. The complexity didn't disappear. The developers still had to build all of it. But the user never touches it. They tap a button and things happen. That's how it should feel.

When the user absorbs it, things go wrong

You've used apps like this. The ones where you need to fill in three screens of setup before you can do anything. The ones that ask you questions you don't know the answer to. The ones where you have to configure twelve toggles and hope you got it right. That's what happens when the user absorbs the complexity. The app is technically simpler to build, but it's painful to use.

I see this a lot with first time app builders. They'll sketch out a flow and every screen has inputs. The user is doing all the work. Picking dates, entering numbers, selecting from lists, configuring preferences. And the back end is basically just storing what the user typed. That's backwards. The app should be thinking, calculating, recommending, and auto populating. The user should be confirming, adjusting, and approving.

It costs more to build it this way. I won't pretend otherwise. But the alternative is an app that feels like filling out a tax return. And nobody opens a tax return because they're excited about the experience.

Smart defaults do the heavy lifting

The easiest way to shift complexity off the user is through defaults. If you know something about the user, use it. If you can calculate a reasonable starting point, present it. If there's a best practice that applies 80% of the time, make it the default and let the other 20% override it. This doesn't require AI or anything fancy. It just requires knowing your user well enough to make good guesses.

Research from the Nielsen Norman Group has consistently shown that users tend to accept default values. When you give them a sensible starting point, most people keep it. That means the quality of your defaults directly affects the quality of the user's experience. Get them right, and most users never need to touch a settings screen.

This is where subject matter expertise really pays off. If you know your industry, you know what the defaults should be. You know what a typical budget looks like. You know which settings matter and which ones don't. You know the 80% case. That knowledge is what lets you push complexity into the back end and give the user something that just works.

Sources
The Power of Defaults (Nielsen Norman Group) - Users rely heavily on default values and rarely change them.
Tesler's Law (Laws of UX) - Every application has an inherent amount of complexity that cannot be removed or hidden.

Related blog posts:

The default matters more than the option →

Fewer screens forced better thinking →

Simplicity is harder to sell than complexity →