Instead of developing a huge (and expensive) spaceship that could take humans to the Red Planet, he chose to build a smaller rocket and iterate on the design.
“We weren’t just going to sit there and analyze something for years and years and years and years to the nth degree. SpaceX was built on ‘test, test, test, test, test.’ We test as we fly’”. – David Giger, a SpaceX engineer.
Falcon 1 became the company’s Minimum Viable Product (MVP). Its first launch ended in a disaster – the rocket blew up over the launch site on Omelek Island.
Following two more failures, Falcon 1 finally became the first privately-built rocket to deliver payload into the orbit.
The lessons learned from early failures were used to develop Falcon 9, which in turn became a part of Falcon Heavy. Its maiden launch was a tremendous success with two side boosters landing simultaneously at Kennedy Space Center and Musk’s personal Tesla Roadster flying off into the orbit.
All of this would’ve been impossible without iterative development.
What iterative development is
Iterative model suggests gradual improvement. Following this approach, developers quickly release a working, yet imperfect version of software.
They repeatedly go through planning, design, coding, testing and evaluation phases to rework the product or add new functionality. Frequent releases allow them to collect feedback and improve the product to meet all requirements.
Deloitte Center for Government Insights reveals that in 2017, 80% of large federal IT projects were labeled as “Agile Iterative”.
This approach is often coupled with incremental development where the product is released in chunks. Each release adds a complete feature that is visible to users and needs no additional re-works.
Only by combining iterative and incremental development, can you become truly Agile.
Wanna succeed? Create-evaluate-repeat
75% of companies mention faster delivery as the top reason for going Agile with iterative planning being the 2nd most-used Agile technique. – Annual State of Agile report.
Imagine a construction team that’s tasked with building ten houses.
After some planning, they lay the foundation for the first building. Then they leave it alone and build a second foundation. Once all ten foundations are ready, they build the walls for the first house. In the same fashion, they install roofs and finish interiors for all houses.
This is what our project schedule looks like:
If development stops midway the project, you get 0% value.
This is the Waterfall approach to building houses: in a Waterfall software development model, each phase must be completed before the next phase can begin.
So, after 40 weeks of hard work, the project is finally over. But customers would have to wait at least 31 weeks before they could move into a new house (and investors would have to wait for their ROI).
And what if something unexpected happened during this time and the project was cut short?
You’d have 10 houses without roofs and a whole bunch of money wasted.
Only a finished house is of any use to customers and only a complete feature has value to users.
Instead of building an application like a cake with many layers, incremental model splits the product into vertical slices of functionality, each a complete feature.
Imagine a team that finishes the first house in a month and delivers 7x more value by the 31st week.
And even if the project is finished prematurely, you’d still get some value out of it.
With iterative development, you get >50% value if the project stops halfway down the road.
Unlike in the construction world, it’s often impossible to know all the requirements when you start building an app. Many key aspects of the project will only emerge later in development requiring significant changes to the plans. You might discover that users wanted a barn instead of the house you’ve built for them.
What’s more, iterative software development allows the team to deliver the most valuable features upfront. Depending on business priorities, they might:
- Directly contribute towards company revenue (e.g. premium features in SaaS apps);
- Increase the number of users (e.g. features that attract new categories of customers);
- Increase user loyalty (e.g. adding frequently requested features);
- Make business processes more efficient (e.g. automating tasks to boost speed and decrease the number of errors); or
- Improve a company’s long-term prospects by investing in new tech (e.g. refactoring the existing code to make future development easier).
Iterative process changes the way stakeholders interact with the team. To get maximum value, they have to stay tightly involved at all stages of development, adjusting requirements and helping to prioritize features on the product backlog.
Smaller releases help customers to gradually adapt to new features.
This also allows developers to collect feedback and analyze how new features are performing with users.
The insights gained from feedback can help business adapt to the changing market with maximum efficiency.
How to get started with iterative development
Starting with an iterative approach puts businesses on a good trajectory towards becoming a truly flexible organisation.
In traditional, Waterfall model, the team gathers all requirements, designs the architecture and then starts building the app. Moving from point A to point B and never looking back.
In today’s fast-changing business world, it’s impossible to know all the requirements from the start (when we talk about medium to large software projects). And no matter how well you plan, you can’t predict how users will react to your product.
Whether your company opts for an in-house team or partners with a software development company, we recommend that you develop your MVP with a Waterfall model. This approach is predictable and transparent, so it’s ideal for establishing trust with a new partner or modeling productive internal workflows. Then, proceed to more efficient collaboration using the iterative approach.
With iterative model, the team works in small cycles called iterations. Each iteration lasts 2-6 weeks and has 5 phases (requirements analysis, design, coding, testing and evaluation).
1. Requirements analysis
Iterative development doesn’t need a full list of requirements to get started. The first iteration usually focuses on the smallest amount of features needed for a Minimum Viable Product (MVP).
At the start of each iteration, business analysts gather new requirements and updates product specifications for everyone engaged in development process.
2. Design & Coding
The team translates user stories into technical specifications that include the choice of necessary tools, frameworks, DB models, APIs, etc. Meanwhile, designers come up with the app’s look and feel. Rapid prototyping allows you to create a model of the future application and show it to stakeholders or potential users.
Now, programmers have to write code that satisfies the cycle requirements. Developers also create Unit tests that check the smallest pieces of code to find bugs as early as possible and reduce the costs to fix them.
Each time a programmer commits a change to the code, the system automatically tests it and deploys to production. By making dozens of micro-releases a day, developers can quickly detect bugs and isolate them in the code.
A high degree of automation increases development speed and shortens the feedback loop.
Refactoring (i.e. revising and improving the code structure) allows developers to keep up with the ever-changing requirements.
QA engineers design and run various kinds of tests to discover any bugs hiding in the app’s code. The tests performed in the current iteration will become a part of the next cycles regression suite. Iterative testing ensures that the new functionality doesn’t break the existing features. As a result, test coverage grows with each new release.
Your regression suite will grow with each new release.
Once the product is functional enough to satisfy initial requirements and there are no critical bugs, the application is ready for a release. It can either be public or internal (where only a limited number of people get access to the application).
Either way, you’ll get valuable feedback that will help improve the product in next iterations.
The last phase of an iteration evaluates whether the release meets the requirements and delivers the expected value.
If the release passes the evaluation, it becomes the starting point of the next iteration. Customer feedback is then used to define the next cycles requirements and make necessary changes.
UI and requirements are most prone to revisions, although architecture, code, and even technologies can be altered if this benefits the project.
If an iteration fails evaluation, the stakeholders can either discard it or start over.
With most projects, you have to compromise between budget, deadlines, and features.
Iterative development process offers a way to build large projects on a tight budget. It allows you to quickly release a core product and improve it over time based on user feedback.
Advantages of iterative development
- Early feedback allows you to improve the product.
- Faster time to market and regular delivery.
- Reduced risk of a failed project.
- Parallel development of features/modules.
- Greater flexibility with making changes.
- Faster return on investments.
- Earlier detection of problems and lower cost to fix them.
- Less time spent on writing documentation.
- Easier risk management/mitigation.
- Higher software quality.
- Stakeholders and users can actively influence the project.
- Easier to gauge team progress.
- More value delivered in earlier releases.
- Predictable scheduling.
- Ideal for small and medium businesses.
When to use
- Requirements are incomplete or likely to change over time.
- Time-to-market is critical to success.
- You deal with new tech or unfamiliar domain.
- You don’t have necessary resources/skills.
- Your goals will be influenced by user input.
- You’ve just finished your MVP.
- The market evolves at a great pace.
How to not fail at iterative development
- The point of this approach is to release on time at a consistent pace. Keep iterations consistent in length and you can plan your deliveries with more accuracy.
- Late modifications can cost you a penny as each change requires a new iteration.
- Constant changes may corrupt the system making refactoring a necessity.
- Ensure high user involvement to succeed with this approach.
- Choose features thoughtfully: feature creep can happen when users make a lot of suggestions.
- Ensure good project management and high team skills: make an accurate risk analysis, provide smart management and rely on developers experience.
To be successful with iterative development approach, you need to involve people from across your product team. But with the right resources, it can truly boost your business with faster ROI, greater flexibility and higher product quality.