Lets say I had this idea for a great software product. If I
told you I was going to spend the next 3-4 months writing (and rewriting) the
product specification and design documentation and do everything I could to
address what I thought would be the key issues, and then expected to actually use that document to build a near-perfect product
that was going to succeed in the market, you’d likely dismiss me as being
naïve or inexperienced or both.
Why? Because, clearly, if we’ve learned anything
about software development it’s that the process is difficult to
completely plan for and much of what actually happens has to be emergent and “iterative”.
Though you may not be a fanatic follower of any of the specific agile methods
(like XP), chances are, you basically agree with some of the fundamentals of
the movement. Chances are, you wouldn’t develop a relatively sophisticated
software product today without using some
agile methods. Chances are, you wouldn’t be blindly using the waterfall
approach in its original form. The most important agile principle (at least
for me) is the need for iteration.
In an agile development world, we do not try and predict every possible
situation our product will need to handle, but we iterate and improve and refine – with the help of
users/customers.
So, why is that when it comes to starting businesses, so
many of us otherwise experienced and savvy software developers fall into the “waterfall
trap” and spend inordinate amounts of time writing and refining the business
plan? I would guess it’s because we think that a business plan is a
necessary component for raising funding (from VCs, angels, etc.) and that
funding is a necessary component for actually building the business. As it
turns out, this is not really true. You can start a software business without
raising funding, and you can raise funding without writing a business plan.
Why not take some of the same ideas we’ve learned from
agile software development and apply them to software startups? Though I
recognize that developing businesses and developing software are different in
many ways (I’ve done both for longer than I care to admit), there is
enough in common that its worth thinking about. In this light, I humbly offer
to you the agile startup manifesto with credit to the original.
The Agile Startup Manifesto
We, the entrepreneurial software developers
of the world believe that we have uncovered better ways to launch and grow successful
software businesses.
Through our experience, we have come to
value:
- Useful software over a comprehensive business plan. We would much rather focus
on creating value – in the form of (somewhat) working software, than
planning to create value in
the form of a business plan.
- Customer revenues over external funding. Customer revenues are the
clearest evidence that we are solving the right problem. The sooner we
figure this out, the better. If we want to learn about what users might
want in a software product, we ask the users. If we want to learn what
the market might or might not want in an offering, we ask the customers. Customers
communicate with their cash.
- Responding to change over
following a plan. We realize that most software businesses (especially the ones
that survive), rarely stick to their original idea. Flexibility is key.
We realize that most of the information we need to succeed with our
strategy will not become clear until after
we launch the company and product. Recognizing this, we focus on
responding to change rather than stubbornly following our original plan. The
key is to iterate.
- Building It well over building to sell. We have learned that the best
software developers design and develop products that they are passionately
committed to “getting right”. Programming is an expression of
the ideas of the developer which blends in real-world feedback from customers.
There is pride of authorship. These are the software products that
succeed. Just like we wouldn’t develop a software product with the
notion that we’ll simply be “passing it off” to someone
else to maintain later, we don’t build businesses with the express
intent of “flipping” them some day. This leads to mediocre
businesses that are at the whim of the market. Instead, we design our
companies much like we would design our software. With an eye towards
balancing the difficult tradeoffs, and building something that is designed
to endure. Like our software products, we would rather build it well.
I think that individuals and companies that use agile
methods have a distinct advantage over those that don’t (and likely have
a lower failure rate – though I can’t prove this). I would
similarly argue that applying agile principles to software startups would
likely have a similar effect – a lower failure rate and better businesses that actually create
real value and are sustainable.
If there are other ideas and concepts from software
development that you think have parallels with software startups, please share
them.