Incremental Model of Software Development Life Cycle

Updated:
The incremental model is a software development life cycle model in which the product is built and delivered to users in parts, or increments. Each increment goes through detailed design, development, and testing and adds new functionality to the working version of the product. The first increment usually contains the core features, and the following ones extend the product based on user feedback.

Key Takeaways
- The overall architecture is defined at the start, and each increment is designed, built, and tested separately.
- Incremental development has been used on large projects since the 1950s, including at NASA and IBM.
- The incremental model adds new parts to the product, the iterative model reworks existing ones, and Scrum combines both approaches.
- The model is a poor fit if the system cannot be split into modules that work independently.
What Is the Incremental Model
An increment is a finished part of the product that works together with the parts already built. How the product is split into increments matters. The Agile Alliance glossary describes the recommended slices as “vertical”: each one cuts through all layers of the system, from the interface to the database, and gives the user a feature they can use. If the product is sliced “horizontally”, into separate technical layers, users get nothing that works until all the layers are ready.
For example, a fintech company building a mobile banking app might launch registration and balance viewing in the first increment, add transaction history in the second, and bill payments in the third.
The approach has a long history. In their article “Iterative and Incremental Development: A Brief History” (IEEE Computer, 2003), Craig Larman and Victor Basili show that iterative and incremental development was used on large projects as early as the mid-1950s. In the 1970s it was widely used at IBM Federal Systems Division, where Harlan Mills promoted it. There, the primary avionics software for NASA’s Space Shuttle was built in 17 iterations over 31 months.
Phases of the Incremental Model
The overall architecture is created once at the start of the project. Detailed design, development, testing, and deployment are repeated for every increment.
| Phase | What happens | Result |
|---|---|---|
| Planning and requirements analysis | The team gathers requirements, prioritizes them, and assigns them to increments | An increment plan and the feature list for the first increment |
| Architecture design (once) | The team creates an overall architecture that supports all planned increments | The architecture and key technical decisions |
| Increment design and development | The team details and builds the features of the current increment | Code for the new part of the product |
| Testing and integration | New features are tested on their own and together with existing ones, including regression testing | A tested version of the product |
| Deployment and feedback | The version is released to users and feedback is collected | A working version and refined requirements for the next increment |
Planning a phased product launch?
Comparison with Waterfall, Iterative, and Agile
These models are often confused. They differ in when users get a working product and how the team responds to changing requirements:
| Waterfall | Incremental | Iterative | Agile (Scrum) | |
|---|---|---|---|---|
| How the product is built | Sequentially, phase by phase | In parts, each of which works | In repeated cycles of refinement | In short sprints, each producing an increment |
| First working version | At the end of the project | After the first increment | After the first iteration, often incomplete | After the first sprint |
| Changing requirements | Difficult and expensive | In later increments | In later iterations | Every sprint, through the backlog |
| Planning | Complete at the start | High-level at the start, details for each increment | Refined with every iteration | Continuous, a few sprints ahead |
Scrum combines both approaches. According to the Scrum Guide, during a sprint the team turns a selection of work into an increment, a useful part of the product that meets the Definition of Done. The product itself evolves iteratively, sprint by sprint. To see how PMI describes the choice of development approach and life cycle, read our article on PMBOK 7.
Advantages and Limitations
Advantages of the model:
- Early access. Users get the core features long before the project is finished.
- Early feedback. Feedback on the first version goes into the plan while the team works on the next one.
- Flexibility with changes. New requirements are added to one of the next increments, and current work continues without interruption.
- Spread-out costs. The core features are funded first, and the rest of the budget is spread across later increments.
- Easier defect detection. Each increment is small, so defects are easier to locate.
There are three limitations:
- Dependence on architecture. If the overall architecture is not designed for growth, each new increment costs more and integration takes longer.
- Higher total cost. Repeated testing and integration can make the project more expensive than a single delivery.
- Scope creep. Without change control, new requirements stretch the project.
When to Choose the Incremental Model
The model fits when the core requirements are known but details may change, the product needs to reach the market quickly, and the system can be split into modules that work independently. One more condition: the client needs to review versions and give feedback regularly, otherwise later increments will be planned on assumptions.
If requirements are fixed by a contract or a regulator, the waterfall model may be simpler. If requirements are unclear at the start, iterative and agile approaches are a better fit.
How We Use the Incremental Model at New Line Technologies
At New Line Technologies, we often build products in increments. The first release contains the features the product cannot do without, and we plan later increments based on usage data and client feedback. This is how we work on platforms for fintech and real-time multimedia, where it is important to launch the core product quickly and develop it steadily.
Learn more about our software development services and how a dedicated development team can take over building the increments of your product.
A Common Mistake and How to Avoid It
The most common mistake in incremental projects is an overloaded first increment. The team tries to fit as many features into it as possible, the first delivery slips by months, and the model loses its main advantage.
Before approving the plan, check two things. The first increment should ship in the first weeks or months of the project, not close to its end. Each following increment should give users a feature they can use right away, not only a technical foundation for future features.
FAQs
The waterfall model goes through the phases once and delivers the product at the end of the project. The incremental model builds the product in parts, and users get a working version after the first increment.
The incremental model adds new finished parts to the product. The iterative model reworks parts that already exist. In practice, Scrum among others, the two approaches are combined.
Yes, if the system can be split into modules. ERP and CRM systems are often rolled out module by module so that departments move to the new system gradually.
Continuous integration (CI) automatically builds and tests the code after every change, and continuous delivery (CD) makes it possible to deploy a finished increment quickly. Together they shorten the time between finishing an increment and getting it to users.
Planning a product that should launch in stages? Talk to our team, and through our software development services we will help you plan the increments and put together the right team for your project.