Minimizing Complexity In User Interfaces

The thing that people get wrong about the idea of "less is more" is that they choose the wrong features to eliminate. They don't have a strategy, except that they will do and be less. (And it's often the HARD things to design and build that they leave out.)

They focus so hard on elimination, that they don't add back things that the other apps do not have.

AND they think that they will still have universal appeal. They don't consciously say "OK, we are going to remove these features, because we don't want to serve this type of customer... which will make us more appealing to another type of customer."

They just think that less === more, and that's it.

Just like any dogma, people cargo-cult it. They use it as a mantra without understanding why.

FWIW, my app was one of the ones featured -- Freckle Time Tracking (http://letsfreckle.com/). They wrote:

"Freckle just makes you want to keep track of your time. The conveniently condensed interface shines with energetic color, turning a routine task into something fun."

And that, in a nutshell, is much of what we tried to achieve with Freckle. Our key feature? Take away the pain. Take away the guilt. Make it effortless, and dare I say it, fun.

We don't have everything, by choice.

Do we have fewer features than Harvest? Damn straight.

We don't do time sheet approval. We don't do pre-approved tasks. We don't do any kind of extreme permissions control.. anyone in the account can create new projects, for example.

Our software is built for small teams with a flatish hierarchy, not for traditional iron-fist-control businesses.

That is LESS with a purpose.

For our customers, that's not a "lack of features" -- it's a downright BONUS. Because they have a small team, or are by themselves, and so having to set up tasks in advance (like in other software) actually reduces their ability to work effectively.

On top of all those removals, we've added back things that nobody else does. Time entry on every page. The Pulse, which helps you identify your work patterns. Saveable reports.

Even most of the people who cancel their accounts write us that they love the app and they're sorry they have to cancel.

So I certainly feel we're doing something right. We don't want to be Microsoft Word. Our goal isn't just to make gobs of money, or even dominate the niche. We want to build software that fits our philosophy and makes people happy.

We have a smaller audience, yes, but it's an audience who agrees with our principles.

It's not about excluding features to make people happy, it's about designing something right from the ground up.

I didn't take a mental image of a time tracking app and then remove stuff. I started from scratch.

Different groups of people have different use cases, and different needs. It's a fallacy to think you can design one thing for all people. It compromises your vision.

Make sense?

And yes, by the way, there are lots of things we are able to do with Freckle because we have decided paths that we do not want to tread. For example, project creation is always on-the-fly. It's so elegant I could cry.

But if we added permission restrictions, based on who could create projects, that would take away the elegance, and add confusion.

In the end, our approach -- which is awesome for our desired audience -- would be totally compromised by the additional error-checking and rigamarole if we were to add this as a feature.

Thus, we won't do it. There are plenty of people who don't need or want that, who are our potential audience. And people who do need it, won't like the other assumptions our app makes. They will be better served by more traditional products.

To my mind, this is win/win/win.

> Studies have found that 80% of users use only 20% of software features.

The problem is that it's not the same 20%.

There are a few problems with this.

1. No one will do it.

2. Even people who do know how to program have a special aversion to JavaScript, especially.

3. Almost no one is equipped (or willing to invest the time/effort) to analyze their work and come up with a process that is best for them.

A typical person is about as self-aware as a box of rocks. Even particularly smart, savvy, successful people. It takes a lot of work to get real insight out of them in terms of work processes. And impossible to get them to generate novel ideas for solving those problems.

More importantly, to design great software you have to understand not just business processes, but software itself, and the human animal (psychology, sociology).

That is an extraordinary amount of extra crap to expect somebody to do, when they just want to get their work done.

This is born out wherever you see "lay people" creating their own solutions. Ever worked in an organization that powers itself on Excel? It's not only not pretty in a technical sense, but they never, ever, ever do a good job, even within the constraints of what is possible with Excel. And they also never think to question if there could be a better way.

So, that's what people like me are FOR.

All this crap happens to be my passion.

This is really tempting, but my guess is that the answer is going to be no. Users want something that just works, and they would probably rather dig through a pile of stuff to find that one thing that just works rather than script it themselves. Elegant solution > pile of features > elegant scripting > source. Or you can do it all, like Excel. Even Word has scripting.

I think ahoyhere has alluded to the reason why the pile of features tends to win, and that is because it is better at leveraging the economies of scale in the shrinkwrap software business. It is so cheap to distribute software that you are much better off building for the mass audience. Now the hot thing is webapps which do not scale nearly as well (but avoid most of the junk that comes with shrinkwrap scaling, like having to deal with a strange machine and a crappy OS that deluges the end user in spyware, or pushing updates to users you don't know much about), so there is more incentive to meet the needs of a niche audience. And Apple is having some success sort of splitting the difference (vertical integration from the hardware up, and attempting to exert more discipline on developers to increase quality, all at the expense of distributing software to mass audiences). Microsoft, of course, is still in a pretty dominant position from exploiting this scaling to the max when IBM so graciously made the hardware into a commodity mass market item.

So far, the most successful web app (Google) is the one which has made web app discovery scale like nothing else (every page with useful content on it is a web app - code, data, it's all the same). The brilliance of Google is that it captured a mass end user market with a minimal user interface. They did it with math (maximal leverage of plain text queries plus the structure of the web, and similarly with ads which have simple interfaces at both ends and are backed with sophisticated algorithms), and scaling by imposing unusual amounts of internal discipline on the best developers they can get (and they can get pretty good ones). All this just to get to a position where they might be able to compete with Microsoft as a platform, and unseat the power of shrinkwrap scaling. I think the only way they can do it is by attracting a lot more developers than Microsoft, and the only way they can do that is by taking a lot of Microsoft's developers away. They might be able to do it, but there are all sorts of challenges. My guess is that what will happen is that they will draw a lot of developers away from Microsoft, and in the process they will lose a lot of their external cultural influence as far as being able to promote clean interfaces. Web apps will be even more dominated by the everything in one place aggregators (exemplified by Amazon and eBay) than they are now.

The problem with nice UIs is that there just aren't enough good developers to make it scale.