It can scarcely be denied that the supreme goal of all theory is to make the irreducible basic elements as simple and as few as possible without having to surrender the adequate representation of a single datum of experience.
— Albert Einstein

It has become fashionable of late, during the second coming of Apple, for a large number of consultants, executives and professional speakers to frame simplicity as an absolute good.  Simplicity, however, can have a number of negative implications for both design and usability, so I thought it prudent to highlight a few of its limitations as a guiding principal.

Ockham’s Razor vs. Einstein’s Razor

Before jumping to technology, it’s worth noting that this debate has origins in science as well.  Ockham’s Razor famously dictates that, given two hypotheses, the one with the fewest assumptions should be selected.  While not absolute, the principle is important because it shifts the burden of proof to the more complicated explanation.

Einstein (as quoted at the top of this post), pointed out the obvious: simplicity has its limits.  As a result, Einstein’s Razor is commonly stated as:

Make things as simple as possible, but not simpler.

Too many entrepreneurs and executives preaching the simple religion forget this.

Example: iPhone Home Button

When the iPhone launched in 2007, it was an extremely aggressive vision of the future of the smartphone.  Bucking the trend from 12-key numberpads to full QWERTY keypads, the iPhone debuted with just one button.

What could be simpler than one button?

Well, technically zero buttons would have been simpler.

Why the single button?  Apple decided this was as simple as they could get it without hiding a key function they felt people needed to be able to access with “tactile” accessibility.  Apple had decided to remove quite a bit of tactile access from the phone.  Feature phone users lost the ability to know that the “*” key was in the bottom left, or “3” was on the bottom right.  Treo & Blackberry users lost the ability, without looking, to know where keys like space and return were.

The answer? Apple decided that the importance of having a tactile method of accessing “home” was more important than enforcing that next level of simplification.  Simple as possible, but not simpler.

Wait? They Added a Switch?

Industrial design aficionados might have already spotted an issue with my previous example.  Apple may have reduced the keypad to a single button, but they actually were applauded at launch for adding a new physical control.

Apple added a hardware switch to mute the phone.

Along with hardware buttons for home, power, and volume up/down, the iPhone added a physical switch for turning mute on or off.

With most other dominant systems at the time (Nokia, Blackberry), turning off your ringer meant navigating from:

Home -> Settings -> Ringer (or Volume) -> Off

Now you could argue that Apple “simplified” the ability to turn off the ringer, but from an interface standpoint they added a control to their highest level of information architecture (the device) for this one function.  This is roughly the equivalent of a website adding this function to its primary header.

In the push to reduce the number of controls, simplicity gave way to an equally important design consideration: minimizing the number of steps to perform a high value action (with the added benefit of tactile access, crucial for a function you might want to perform sight-unseen, in your pocket)

Simplicity Can Lead to Overloading, Which Is Complex

Anyone who has worked on a design project around information architecture is familiar with the tradeoff.  Reducing the number of controls or number of entry points definitely simplifies the interface.  Fewer choices, less cognitive load on the user.

Unfortunately, if you have five branches at each level of a command structure, you can make 25 commands just two steps away.  If you have three branches at each level, you need three steps to reach that same number of commands.

No one wants to replicate the Microsoft Office hierarchy of thousands of commands littered across dozens of entry points.  But if your software honestly has four key functions, “simplifying” to one entry point can make the users job harder, not easier.

Wealthfront: Building Trust with Transparency

At Wealthfront, one of top priorities is building trust with guest visitors to our site.  Interestingly, we’ve discovered that over-simplification has another negative attribute: when people don’t readily see the answer to a key question, there is potential for them to assume you’re hiding that information.

As a result, our new user experience is a careful balance of simplicity, but balanced with providing crucial information to our visitors, even at the risk of some complexity.

We show our clients up front our investment choices, down to quick answers for why we’ve chosen each particular ETF.  We provide examples of both taxable and tax-deferred account allocations up front, even before the visitor has signed up for the service.

To be sure, like all software interfaces, there are significant improvements that we can make to our new user experience.  But it’s worth sharing that our experience has been that blind adherence to simplicity can actually hurt the level of confidence and trust people have with your service.  This interface has seen the company to record growth in 2013, up over 250% for the year (as of September).

More broadly, it’s worth considering that when you bury functions and features, you may trigger emotions in your user that aren’t positive:

• Frustration. They don’t know where to look for something they want.
• Anxiety. They worry that the thing they need is no longer supported.
• Distrust. They assume that you are hiding something for a reason.

So remember, when someone preaches the religion of simplicity, think carefully about Einstein’s Razor.

Make it as simple as possible, but not simpler.