This is the first in a series of articles I plan to write about some of my thoughts on 37signals and their e-book “Getting Real”. [For the record, I highly recommend the book]. Most of the advice is really good.
There has been a lot of talk on the net about simplicity and the whole principle of “less is more”.
I must say that I agreed with a large majority of what they had to say in the book, and most of it I think is good advice for software entrepreneurs. However, the things I disagreed with, I strongly disagreed with and felt it necessary to respond to.
Disclaimer: Overall, I like 37signals and what they have done. They’ve shown us what is possible in the “real” Web 2.0 world where companies can create value, charge customers and run a real business. Further, Jason Fried (founder/director/evangelist of 37signals) was kind enough to let me interview him for some graduate work I’m doing at MIT, so I am grateful for that (thanks Jason!). I am also a paying customer of the company and have used their products.
Having said that, I’m just getting a little weary of this “less is more” message. I think we are beginning to confuse the simplicity message with the “less” message. Very, very powerful things (like the Google search engine) can be very, very simple too – from a user’s perspective.
So, to be clear, there are various “dimensions” on which less can be measured:
- Less complexity (from a customer’s view point)
- Less “baggage” (more flexibility)
- Less features.
It’s the last item that I have contention with. Less (features) is not always more. So, lets dig a little deeper here. In every technology industry that I know, customers demand more features/capabilities over time. Whether it be software, a car or a mobile phone – as time goes, you expect more out of the technology in your life for it to continue to be useful to you. Paradoxically, you want things simpler too – but simpler does not mean you’re willing to give up on features. You want both.
Lets take a classic example from the software world: the word processor. The 37signals team might have us believe that the answer here is the simplest possible set of features are all that people really care about or want. Basically, you write/edit text and save/print it. That’s it. Basically, something like Notepad. At the other extreme, we have Microsoft Word with its 10,000+ features. Many can (and have) argued that nobody uses more than 20% of the features in Word. That’s likely true. The issue is that it is a different set of features for each user, and within that set, one or more features are very important. Not nice to have, not customers whining because they want everything, but important. For our word processing example, we could divide the kinds of features that people might want into some simple buckets:
- Formatting and Printing (fonts, images, layout, rulers, etc.)
- Better writing features (spell check grammar check, word count, etc.)
- Large document features (table of contents generator, footnotes, etc.)
Now, ask anyone that falls squarely into one of the above groups as to whether “less is more” – and they’ll clearly disagree. A journalist needs spell check and word count. When writing my master’s thesis, I need the table of contents feature. Sure, we crave simplicity (so we like features to “go away” when we don’t want them), but we’re not willing to give up the features we want. Most of the most successful products in the software industry are those that were able to deliver “more” to the customer without disproportionately increasing the complexity (examples are Lotus/Excel, Word, Photoshop, Quicken, etc.)
To be sure we're clear here, I'm not suggeesting that companies build products that try to do everything for everyone. I'm a big believer in focus. But, once you've picked what kinds of cusotmers you're going to focus on, the goal should then be to deliver what these customers expect. In the 37signals case, it seems that they are picking a broad range of customers and then choosing the minimalist set of features (i.e. "lowest common denominator") that all of these customers need. The result is a very small set of features that doesn't meet the full needs of most customers.
Overall, I’m all for finding a Clayton Christensen style “disruption” (See “The Innovator’s Dilemma) and playing a different game. The issue is that in the world of software, even simple things sometimes require some planning, thought and design so that you don’t paint yourself into a corner. Here’s the one example from the book that just about gave me an ulcer:
From “Getting Real” by 37signals:
Build software for general concepts and encourage people to create their own solutions.
When we built Ta-da List we intentionally omitted a bunch of stuff. There’s no way to assign a to-do to someone, there’s no way to mark a date due, there’s no way to categorize ,items etc. We kept the tool clean and uncluttered by letting people get creative. People figured out how to solve issues on their own. If they wanted to add a date to a to-do item they could just add (due: April 7, 2000) to the front of the item. If they wanted to add a category, they could just add [Books] to the front of the item. Ideal? No. Infinitely flexible? Yes.
Now, let me breathe deeply and explain why I think the above example is so troublesome. I’ve been a professional programmer for all of my career. I’ve read the books, got a CS degree, written big apps and small apps, worked with some exceptional people (folks that Joel Spolsky and Paul Graham would like), and so on. Not a single person that I respect and know from the software development community would likely consider the above a “good approach”. Repurposing things as simple as a due-date and having users make up their own ways to solve the need is just asking for trouble – very soon. This goes against so much of what we have learned (simple things) about creating great, enduring, well designed software. We’re not saying it should be more complex, but there needs to be some minimal design that accounts for the most basic needs. Other than the fact that the above application is web-based and Ajax-powered (which is cool), it’s just another simple data management application, with minimal structural support. I think we’re getting overly distracted by the coolness of new technologies and taking a major step backwards. In the above example, what happens when users want to be notified of items that are due? How about when users want to see tasks that are assigned to them (if that feature ever gets added). There’s no need to add these features now (though one could argue that for a task management system, these are bare essentials), but given the choice, customers are likely to want these things – once they get done with the basics.
As a final point, I’ll include another excerpt from the book: Solve the simple problems and leave the hairy, difficult, nasty problems to everyone else.
In my experience, the simple problems (that people are willing to pay to have solved) are both hard to find and hard to build enduring software companies around. Even things that start simple end up becoming complex as customer demands increase. The 37signals approach to addressing this increased complexity seems to be to build “opinionated software” (basically, push back on the customers and keep things simple). I think this is a sub-optimal strategy. History is replete with companies that didn’t work hard enough to meet the growing demands of their customers and ultimately got left behind.
If you’re an aspiring software entrepreneur and have found nice, easy problems to solve that customers are willing to pay for, congratulations! That’s great! You too can be a huge success like 37signals. But if not, you’re in good company. Thankfully there are still lots of difficult, challenging and interesting problems that customers need solved in the software world. Looks like Its poor, wretched souls like you and me that will likely have to take on these problems. Such is life…
What do you think? Am I off-base here?