Do you sometimes feel like you don’t have enough information to visualize what your ideal product should be? Or have you built a product feature only to realize that your customers wanted something else?
We’ve all been there. As product managers, we need information to make good product decisions. The question is, how do you get these insights early in the product development process?
In the 1990s, the agile methodology was established and quickly started gaining more popularity, especially in software development. The agile methodology focused on processes that were more iterative and incremental in their approach, allowing you to obtain critical information much faster and make better decisions.
In this guide, we’ll define what iterative and incremental development means, the pros and cons of implementing this methodology, and what an iterative and incremental development process looks like in practice. To help illustrate, we’ll refer to some well-known examples.
Iterative development means releasing a product in phases, which are also called iterations. Think of iterations as shorter development and testing cycles applied to one part of the product, or a bare-bones version of a product, before improving the product by building additional features.
At the end of every short cycle, a new version of the product is released, after which feedback from customers and relevant stakeholders is sought and incorporated into the next cycle. These cycles continue until an optimized version of the product is reached.
Incremental development breaks down a project into smaller chunks, called increment. Each increment can be worked on separately, building on the previous one, so that improvements can be made with each increment. This ultimately enhances the product as a whole. Increments are easier to manage and allow for step by step improvements.
The iterative development and incremental models are closely associated with each other. Often, one doesn’t work without the other. Because of their complementary nature, iterative and incremental models are used together in product development cycles.
At the core of these models, you are allowing the flexibility to respond to change quickly and as efficiently as possible with each iteration and increment. This is also an integral part of the agile scrum methodology, and is thus often used in the software development lifecycle (SDLC). It is also used in other industries and customer-centric areas like design, marketing, education, and even when creating the perfect recipe!
An iterative and incremental development process can be used to deliver value to customers quickly and efficiently, thus making it a popular methodology for product management.
While the software development cycle is more or less defined in the same sequential steps — plan, design, develop, test, release, and evaluate — the cycles, or iterations, are shorter and faster, focusing on one part/version, or increment, of the product.
The cycles also include a feedback loop with customers and relevant stakeholders that can provide insights to help you improve the product:
Like everything else, iterative/incremental development has its pros and cons and it’s important to understand the best use cases for it.
Advantages of using an iterative or incremental development process include:
Because you are using shorter development cycles and gathering feedback faster, you are more inclined to identify problems faster and align better with customer needs.
Most software companies release features in two- to four-week sprints, or development cycles, granting the ability to seek feedback with a regular cadence and fix things as they come up.
Accommodating for changes at the end of each short development cycle helps you respond to change faster and more efficiently. It also gives you a chance to assess product strategy and how the changes align with it and identify the need to pivot and change the strategy all together if need be.
The more adaptive your processes are to change, the better the output of your product.
You can save money and resources with an iterative/incremental development process because you’re able to identify challenges early on in the development process instead of much later, when those resources are already spent.
You can also plan better for future development cycles based on the data of past cycles, helping you use your resources much more efficiently.
Communicating with customers and other stakeholders after every short development cycle enables a continuous flow of feedback and collaboration, bringing critical insights into what’s working and what’s not for your product.
This can give you a solid advantage over competitors because you’re leveraging almost real-time data to make your product more robust.
Sometimes you don’t have complete information about your customers’ needs or are trying to find the right product-market fit. Iterating through your product will allow you to identify what you need to make your product successful. Identifying critical issues early on in the development cycles also significantly reduces the risk of the project failing.
The following are disadvantages of using iterative/incremental process development:
Customers often ask for new things to be added to future development cycles. This frequent feedback can offset the initial scope you set for the project.
This could also put you under the pressure of prioritizing feedback based on the amount of resources available to you.
Constantly changing scope can be frustrating and lack of a process to manage these changes and translate them into product requirements can cause challenges. It can also be very difficult to measure change and minimize it, especially in the initial stages of development.
With most of the focus being on iterative/incremental process development, tech debt is often overlooked. Ultimately, it builds up until developing new functionality is no longer efficient without addressing the accumulated tech debt.
With fast moving processes and changing scope, documentation often takes a backseat. Sometimes, it doesn’t even make sense to document a feature development if it will ultimately change in the near future.
If documentation is not properly planned and baked into the process, you’re often left with little to no documentation through your iterations.
Because the development cycles are shorter and iterative, the output of the product in the initial cycles is nowhere close to the ideal product. This can be disappointing for customers if not communicated properly. Communication is the key to setting realistic expectations.
The iterative and incremental development process is more of a trial-and-error method until the final product is achieved. While this is great for software development, it can be unrealistic for industries like construction, agriculture, and manufacturing, where you have to finalize blueprints, materials, budget, and timelines and it’s very difficult to change them once they have been established.
There are three principles to remember when using an iterative and incremental development process in product management:
To illustrate what I mean, let’s look at three real-world examples from companies that everyone has heard of: GrubHub, Casper, and SpaceX.
It’s better to embrace change than to fight it. Whether it be evolving market trends, shifting product-market fit, or a pivot in the overall business strategy, you need the flexibility to respond to change quickly and efficiently. The iterative/incremental development process helps you do just that.
Take GrubHub, for example. The popular food delivery company started with two engineers who digitized paper menus and simply organized information about restaurants so people could easily find them. After a few years, they transitioned into an online food ordering system and eventually started offering food delivery services.
Using the agile methodology to build an end-to-end software platform helped the company pivot quickly and steadily to achieve high growth in a global market.
When you’re in the product manager role, managing various threads of information and evaluating customers’ needs, it’s natural to make assumptions. You don’t always have the answers, so you have to make assumptions to make decisions, whether they work out or not.
Ultimately, you have to validate those assumptions and refine your strategy and development based on what you learn through feedback loops after every iteration. Sometimes, the facts can be surprising, but they will lead you to make better decisions down the line.
Take Casper, for example. A disruptor of the mattress industry, Casper’s initial business model was to sell a mattress in a box directly to customers online, cutting out the middleman (retailers).
While the company had high growth when it started due to its unique technology, it eventually tumbled. Casper realized that people still liked brick-and-mortar stores where they could touch, feel, and physically test a mattress before buying it.
Today, you can find Casper mattresses in retail stores, and this decision has significantly contributed to the company’s growth. Had it not established feedback loops with its customers, Casper’s sales would have continued to plummet and its technology would not have continued to improve.
Failure is the first step to success. It’s better to fail often and fail fast.
Applying the iterative/incremental approach to your development process enables you to resolve issues sooner and thus accelerate the time it takes to achieve an optimal product. Furthermore, this mindset can give you early competitive advantage in your market, enabling faster adoption and, hence, product growth.
In the world of innovation, where there are a lot of unknowns, both from a product perspective and a technology perspective, iterative/incremental process development can come to the rescue.
For example, SpaceX invested in an end-to-end 3D modeling system to view and manage their simulations. The system also enables them to 3D-print models to study what they would look like and how they would work in real-life.
The ability to go from design to print quickly is important; it encourages a rapid iterative design approach because engineers don’t have to wait long to test a design and push it to failure. They can learn from the build what they couldn’t have learned from 100 simulations.
In this scenario, not only are SpaceX engineers designing and simulating their products, they are also printing and testing them thoroughly. This enables them to go through many more of these iterations quickly and efficiently before spending the resources to build a perfect prototype.
Iterative and incremental development can help you build higher-quality products and better manage your resources. But there are pros and cons to implementing this methodology, so it’s important to figure out what works best for you and your company.
The fist step is to get buy-in from your team and them take small, gradual steps toward making your processes more iterative. Gather feedback from your team members regularly, embrace the changing landscape, and celebrate every little win.
The incremental and iterative development process can be challenging, but is truly satisfying when done right.
Featured image source: IconScout
LogRocket identifies friction points in the user experience so you can make informed decisions about product and design changes that must happen to hit your goals.
With LogRocket, you can understand the scope of the issues affecting your product and prioritize the changes that need to be made. LogRocket simplifies workflows by allowing Engineering, Product, UX, and Design teams to work from the same data as you, eliminating any confusion about what needs to be done.
Get your teams on the same page — try LogRocket today.
This guide covers the biggest sources of stakeholder conflicts, explains how to fix them, and explores ways to build trust.
Product teams have a million things to do — but what comes first? A prioritization matrix makes it easy to decide. Here’s how to use it.
Dr. Deepti Mehtani talks about how her background as a clinician helps shape product strategy at NextGen Healthcare.
The following post breaks down why the feature factory mindset persists, how it manifests, and most importantly, how to escape it for good.
Learn more →
One Reply to "What is iterative and incremental development? Process, examples"
IID started in SW Dev in the 1970s based on ideas from the 1930s, the Agile concept came much latter https://tinyurl.com/yyjy4v8o