Experience Rot

Here’s a counter-intuitive fact: Chances are all those features you’ve been adding to your design are hurting your user experience. Every feature that’s squeezed in, in the name of giving your design a competitive edge, has been making your design less competitive.

Welcome to the effects of Experience Rot. As you add features, you’re adding complexity to the design, and decreasing the quality of the experience.

Pick up any modern TV remote and you’ll immediately see the problem of experience rot. On/Off, volume and channel selectors are no longer enough. We need to switch devices, control captions, have a text capability for on-screen editing, a thumbs-up and thumbs-down for ratings, pause, record, slow motion, rewind, 30-second rewind, and, well, you see the effects. The complexity never ends, it never gets simpler, and it’s never delightful.

Experience Rot Starts with Version 2 (maybe earlier)

By their nature, most first releases of a design are really simple. The design is a small collection of well thought out features. Everything fits and makes perfect sense. At this time, the rot hasn’t begun. Everything is new and fresh.

However, that doesn’t last long. The moment a new feature is added–one that wasn’t considered in the initial design–the rot starts to take hold. It’s at this moment that a rethinking of the design has to happen and the seeds of complexity are laid.

If that new feature is close in style and function to the original set of features, the experience rot may not be visible. Yet, because it needs to be retrofit into the original design, it starts down the inevitable road.

As more features are added, it becomes harder to make the overall design coherent and sensical. Soon features are crammed into corners that don’t make sense.

The Experience Rot Experience

Users who have been along for the ride since the early versions can slowly adopt to a few new features in each release. As more features are added, the chances they’ll want or need those features start to diminish. They’ll do their best to ignore anything that doesn’t work for them. It’s the features they like, but only use occasionally that give them the most trouble. These features are often hidden in a place they don’t expect. Their frustration grows.

New users suffer more dramatically. Having joined the design later in its evolution, they find themselves befuddled by any logic in its organization. As soon as they start to glean a consistent mental model, they encounter a feature that seems to have no logical reason to be there. It’s like wandering through a mansion and coming upon a large banquet hall with a toilet in the center.

Organizations and individuals become more reluctant to upgrade to the newest versions. The value in each new release is diminished by the hours lost learning the new interface. Eventually, it’s not worth the time and energy to get a few features which may never get used.

Rotting on the Inside

It’s not only the external user experience that suffers from the rot incurred by the slow addition of features. The internal code suffers too.

Every new feature puts demands on the architecture that wasn’t originally anticipated. At first, a smart team can keep up with the necessary refactoring. The increasing rate of new features puts pressure on the team and it isn’t before long that the architecture starts to show strain.

Often there’s a central piece of core functionality that suffers the worst. (In my experience, it frequently goes by the name “billing engine”.) The logic and threads get so gnarly that nobody can risk making changes without breaking something important.

All of this slows down the pace of future development, making even minor enhancements substantially more difficult. The time between design iterations can move from weeks to months to years.

In Comes the Competition

It’s the market leaders that often suffer the worst experience rot. They have the most money to spend on new development and they have the most pressure to keep leading the marketing place with new inventions.

It’s experience rot that opens a market up for disruption. The market leader, slowed down and overly complex, gives a chance for a new company to make inroads. By studying the small number of features that most users care about, and freed by not having a large codebase to deal with, they can implement a simplified version. This version is much easier for new users and a straightforward transition for the more experienced user base.

We’ve seen this pattern repeat itself dozens of times. Microsoft Word for DOS, with only 70 features upon launch, beat down the 1700-feature WordPerfect. Now we’re seeing Google Docs doing the same thing to Microsoft Office (despite Microsoft’s attempt to port desktop Office to its SaaS-version of Office 365). In search engines, Google took over from AltaVista. In the world of CRM systems, Salesforce.com displaced Siebel which upended Oracle who stole the market from SAP.

Experience rot not only makes design and development difficult, it puts the entire organization at risk. Unless it’s controlled early and often, it’s a growing time bomb waiting to go off.

‘No’ Fights Rot

The best way to fight experience rot is to say ‘no’ to everything except the most essential of features. Deliberately slowing down the product roadmap to only include well thought out and integrated new enhancements will keep experience rot at bay.

Saying ‘no’ is always in the designer’s toolkit, but in the excitement of producing something new that gets press and attention, it often gets overlooked. It takes a lot of organizational willpower to keep a design simple.

Often the organization’s design leadership doesn’t realize they needed to be saying ‘no’ until the rot is horrifically visible throughout the design. It isn’t until users are complaining about complexity and the developers can’t make important changes quickly enough that everyone realizes that full extent of the problem.

The 1,000 ‘no’s to every ‘yes’

It takes strong organizational leadership to keep the team focused on fighting rot from the beginning. It’s not the norm in today’s world, but we do catch glimpses of teams that pull this off.

Steve Jobs once said, “You have to pick carefully. I’m actually as proud of the things we haven’t done as the things I have done. Innovation is saying ‘no’ to 1,000 things.”

Picking the right things to say ‘yes’ to is a careful art. One trick is to give yourself a lot to choose from. Saying ‘no’ to 1,000 things, like Jobs referred to, means you have to have 1,000 things to say ‘no’ to.

The smart organizations spend a lot of time trying ideas, knowing they’ll say ‘no’ to most of them. However, that constant experimentation helps them understand what’s possible and gets them closer to finding the ‘yes’ that will dramatically enhance the experience without increasing rot.

Strong leadership, constant experimentation, and a diligent attention to what truly enhances the design is how you fight against experience rot.