Simple is Expensive

The simpler a product feels, the more thought usually goes into making it that way.

Some of the simplest products I’ve worked on have been the hardest to design. Not because the screens were complicated, but because getting them to feel simple required a lot more thinking than I initially expected.

Think about a screen with one input field and a button. It looks straightforward enough, right? But what happens when the user enters the wrong information, loses their connection, or clicks the button and nothing seems to happen? Suddenly, that simple screen has a lot more going on than meets the eye.

This is something I’ve come to appreciate more as a Product Designer. The work isn’t always about what people see on their screens. A lot of it happens behind the scenes, in the decisions we make to ensure that what people see actually makes sense.

And that is why I think simple is expensive.

The happy path is easy

When designing a product, it’s tempting to focus on the ideal experience. A user opens an app, finds what they need, completes a payment, and moves on with their day. Everything works as expected, and the experience feels effortless.

But how often does everything go exactly as planned?

People change their minds, enter the wrong information, abandon a process halfway through, or come back days later expecting to pick up where they left off. Sometimes a payment fails, a booking changes, or money leaves someone’s account without an immediate confirmation.

I’ve worked on payment flows, booking experiences, wallets, account verification, travel products, and operational tools, and one thing I’ve noticed is that the ideal scenario is only a small part of the experience we need to design for.

The real work begins when things don’t go as planned. What does the user see when a payment fails? How do they know whether to try again? If a booking is no longer available, what happens next?

These questions might not seem particularly exciting, but they can make the difference between a product that works in a design presentation and one that actually works for the people using it.

A simple button can carry a lot of weight

Take a button that says “Pay”. It’s probably one of the simplest things to design visually, but the experience around it can get complicated very quickly.

Can the user pay in instalments or split the amount across different payment methods? What happens if the payment fails and they try again? What if the money leaves their account but the transaction is still pending? What should the receipt show, and how should the transaction appear in their history?

Now imagine the same experience from the business owner’s side. They need to know whether the payment is complete, how much is outstanding, and whether the sale can be closed.

The button hasn’t changed, but the number of things that need to happen correctly has grown considerably.

This is the part of product design I find interesting. You can spend hours thinking through all these scenarios, making decisions about what should happen and how the system should respond, only for the final result to be a button that looks almost too obvious to notice.

The interface might be simple, but the thinking behind it rarely is.

Removing complexity isn’t as simple as it sounds

For a long time, it’s easy to think of simplicity as removing things from a screen. Fewer fields, fewer buttons, fewer steps, shorter copy. And to be fair, these decisions can improve an experience when they’re made for the right reasons.

The problem is that removing something from the interface doesn’t always remove the work it was doing.

If you take a step out of a booking flow, for example, you still need to decide what happens to the information that was collected at that stage. Can the system handle it automatically? Does the user need to provide that information earlier? Is it even necessary in the first place?

There is usually another decision waiting behind the one you’ve just made.

This is why I don’t think a product is necessarily simpler just because it has fewer screens or fewer options. Sometimes, removing too much leaves users guessing, and making them guess isn’t simplicity.

Good simplicity means giving people less to figure out, not simply giving them less to look at.

The work people don’t see

I’ve found myself paying more attention to what happens around a screen than just the screen itself. What happens before a user gets there? What happens after they leave? And what happens when they make a mistake or return to the product later?

These questions tend to reveal work that isn’t immediately visible in the final design. You might need an error message, a loading state, a confirmation screen, or a different experience for someone with a different permission level. Each decision adds to the work, even if none of it makes the interface look more impressive.

Sometimes, after considering all these possibilities, the screen barely changes. It still has the same button, the same input field, and the same short piece of copy.

The difference is that you’ve thought through what happens when someone uses it in ways you didn’t initially expect.

And I think that’s one of the more interesting things about designing products. The amount of work involved doesn’t always show in the final result. You can spend hours working through a problem only for the solution to look so obvious that nobody thinks twice about it.

In a way, that’s the point. People shouldn’t have to understand everything that went into making a product work before they can use it.

Less isn’t always better

There’s a tendency in product design to treat fewer steps, fewer clicks, and less copy as signs of a better experience. Sometimes they are, but I don’t think they should be the goal on their own.

A shorter booking flow isn’t necessarily better if the user reaches the end only to discover that something important is missing. A dashboard with fewer numbers isn’t more useful if people now have to work harder to understand how their business is performing.

Even a well-written sentence can be more helpful than a shorter one if it gives someone the confidence to make a decision.

What matters is whether the experience makes sense to the person using it.

I’ve started to think less about making products look simple and more about making them feel simple. That means understanding what users need, giving them enough information to move forward, and making sure the product responds in a way they can understand.

Sometimes that means removing a step. Other times, it means adding an explanation or giving someone a little more control. The right decision depends on the problem, not on how minimal the final screen looks.

When good design feels obvious

Think about the products you use every day without giving them much thought. You know where to go, what to do, and what happens after you take an action. When something goes wrong, you have a reasonable idea of what happened and what you can do next.

You don’t need to stop and figure out how the product works every time you use it. It simply fits into what you’re trying to do.

That kind of experience can look almost boring from the outside, but getting there requires a lot of decisions. It means understanding the complicated parts of a product, questioning what really needs to be there, and being willing to leave out things that might look impressive but don’t help anyone.

Sometimes, the best decision is not to add another feature or redesign a screen. It’s to solve the problem that made the experience difficult in the first place.

Simple is expensive

The longer I spend designing products, the more I appreciate the work that goes into making things feel natural. I’m less concerned with how sophisticated a screen looks and more interested in whether someone can use it without having to stop and work out what to do.

That doesn’t mean every product needs to be minimal or that every problem can be solved with fewer steps. It means being deliberate about the decisions we make and understanding how those decisions affect the person on the other side of the screen.

A product can have complicated rules, systems, and processes behind it. The user doesn’t necessarily need to see all of that, but they should be able to trust that it works.

And when an experience feels straightforward, I no longer assume the work behind it was straightforward too. More often than not, someone has spent a considerable amount of time working through the difficult parts so the person using it doesn’t have to.

Making something complicated feel simple is expensive, and that’s often where the real design work happens.

Simple is Expensive was originally published in Bootcamp on Medium, where people are continuing the conversation by highlighting and responding to this story.