Where Einstein Meets Edison

Feature Creep and the Importance of Iterations

Feature Creep and the Importance of Iterations

Dec 1, 2010

Software startups are often renowned for having cost-efficient and relatively simple product development trajectories.  Unfortunately, a side effect of cost-efficiency and simplicity is feature creep, which can plague a great startup before it even gets off the ground.  Feature creep occurs when entrepreneurs implement the full vision of their product from the beginning.  It results in overly complicated software with a mediocre-at-best user experience.  Through iterations, entrepreneurs can avoid feature creep and ultimately produce higher quality software.

Most examples of feature creep fail instantaneously, but a few manage to slip through into industry.  An excellent example of this is the software that comes with an average cell phone.  This software showed up immediately after grayscale phones and has barely changed since.  It can do anything a user could ever think of, but the user interface is so poorly designed that the user can never figure out how.  Even the simplest features require users to move through all sorts of menus.   When creating a new text message, for example, the default method for defining the recipient is by typing in their phone number, but adding a number from “Contacts” requires extra steps.  An even worse example is Name Cards which allow users to “easily” send contact information to another phone.  Every phone has this feature and it is quite convenient, but the software is so complicated that it has not been discovered by the mainstream.  Instead, users resort to temporarily memorizing a ten digit number so it can be sent within a text message.  Name Cards eliminate this confusion, and without feature creep they certainly would have been utilized more frequently.  Realize that feature creep is generally an issue because of the way a feature is implemented, not the functionality of the feature itself.

The first step in avoiding feature creep is understanding why it occurs.  Surprisingly, the blame falls on the entrepreneur.  Entrepreneurs like to think big; they have a vision for their product that scales to the entire market.  In an attempt to realize their vision, entrepreneurs work to ensure that every subset of their market will be completely satisfied immediately after the product is launched.  Because software is so “simple and inexpensive to develop” this actually seems like a feasible goal for the entrepreneur.  As it turns out, finding a way to implement all of the necessary features is quite easy; the difficulty is in finding the right way to include each feature.

Software is unique in that there are an infinite number of solutions for implementing the same feature.  By definition, the best solution is the one that users are most satisfied with, but it is impossible to know how users will react to an implementation.  Sometimes precedents have been set that allow developers to make accurate predictions, but software startups are typically exploring new realms where precedents do not exist.  As a result, the specific implementation of a feature is really just a guess at the best solution.  If too many wrong guesses are made, the software will suffer from feature creep.

Although it is impossible to accurately predict the best solution for each feature, it is still very possible to avoid feature creep.  Feature creep only occurs when software has an overwhelming ratio of poorly implemented features to properly implemented features.  Fortunately, software users can be very forgiving if the product is mostly satisfactory.  By taking advantage of this fact, entrepreneurs can avoid feature creep completely and still realize their big vision for the product.

The answer lies in iterations.  Rather than focusing on the big picture, entrepreneurs need to determine the subset of their features that are essential to their product.  These core features should be tested and reworked thoroughly until they have been perfected.  From that point on, additional features should be released one-by-one in the same manner.  Just because an aspect of the software has been perfected in the past does not mean it will remain perfect.  Every modification, regardless of size, will affect the product as a whole, and it is the entrepreneur’s job to ensure that the change betters the product. 

The success of this technique becomes exceptionally clear when comparing the recent social network giants, MySpace and Facebook.  The issue with MySpace was not necessarily feature creep, but instead that it refused to update its user experience.  It felt that any changes to the “user profile” page would cause its users’ profile designs to break and result in a significant loss of membership.  Keep in mind though, altering a profile design on MySpace effectively requires users to hack HTML and CSS into the “About Me” section of their profile.  Rather than building a profile customization tool embedded in MySpace to automate this, the company remained static and left their questionable user experience standing.  Everyone knows what happened next. 

Facebook did to Myspace what the iPhone is doing to traditional cell phone software.  It is constantly pushing new iterations live, reacting to its users, and methodically improving the software day after day.  Facebook’s user experience is far from perfect, and the company would probably agree.  However, it refuses to make the same mistakes MySpace did and instead continually strives for perfection.  Facebook may have won a battle with its initial core features, but it undoubtedly won the war with iterations.

Despite the buzzword name, feature creep should be taken very seriously.  For entrepreneurs, the risk is high but being aware of the causes makes it easy to circumvent.  Concentrate initially on the core features and do not push forward until they are perfected.  Then, slowly release additional features while working with users to ensure their experience is never diminished.  If nothing else, remember that quality software is the product of perpetual refinement through iterations.