Chapter 05 of 32

Iterative & Incremental Models

Imagine ordering a big wedding cake and seeing nothing for six months, then receiving it on the wedding day, only to find the flavour is wrong. That is how a customer can feel in a pure Waterfall Model project: they see working software only at the very end, when changing anything is most expensive.

A smarter approach: deliver a small but usable part first, let the customer use it and react, then add more in the next round, improving along the way. This is the idea behind iterative and incremental development (IID), the family of models that most modern methods, including Scrum, are built on. In this chapter we study the incremental model, the iterative (evolutionary) model, the exact difference between "iterative" and "incremental", the Rational Unified Process (RUP) and Rapid Application Development (RAD), with worked examples and a clear guide on when to use each.


Two Ideas: Incremental and Iterative

The two words are often used together, but they mean different things.

Incremental development: the system is divided into pieces (increments). Each increment adds new, working functionality to what has already been built and is usually delivered to the customer. After the last increment, the complete system exists.

Iterative development: the system is developed through repeated cycles (iterations). In each cycle the team revisits and refines the product, improving existing features and design based on feedback and what was learned, rather than trying to get everything right in one pass.

An easy way to remember:

  • Incremental = add. Build and deliver the system part by part. Each part is done well before moving to the next.

  • Iterative = rework / refine. Build a rough version, learn, and improve it again and again.

An Example: A Food Delivery App

Purely incremental:

Increment 1 : Restaurant list + menu browsing            (complete, polished)
Increment 2 : Cart + online payment                      (complete, polished)
Increment 3 : Live order tracking                        (complete, polished)
Increment 4 : Ratings, reviews, offers                   (complete, polished)

Purely iterative:

Iteration 1 : Whole flow works roughly: browse -> order -> pay (cash only),
              plain screens, manual tracking by phone
Iteration 2 : Same flow, better UI, UPI and card payments added
Iteration 3 : Same flow, live map tracking, faster search
Iteration 4 : Polished, optimised, ratings and offers refined

Real projects combine both: every cycle adds some new features (increment) and also improves what already exists using feedback (iteration). That is why we usually say iterative and incremental.


The Incremental Model

In the incremental model, the requirements are first gathered and divided into increments, usually ordered by priority. Each increment then goes through its own mini-waterfall: analysis, design, code, test, delivery. Pressman draws it as staggered linear sequences:

Functionality
delivered
   ^
   |                                       +-----+-----+-----+-----+
   |                    Increment n        | Req | Des | Code| Test| --> delivery n
   |                                       +-----+-----+-----+-----+
   |                         ...
   |                 +-----+-----+-----+-----+
   |  Increment 2    | Req | Des | Code| Test| --> delivery of 2nd increment
   |                 +-----+-----+-----+-----+
   |  +-----+-----+-----+-----+
   |  | Req | Des | Code| Test| --> delivery of 1st increment ("core product")
   |  +-----+-----+-----+-----+
   +------------------------------------------------------------------> Time

How It Works

  1. Gather the overall requirements and agree on a high-level architecture that can grow.

  2. Split the requirements into increments, most important first.

  3. Build the first increment, the core product: the basic features without which the product is useless.

  4. Deliver it; the customer uses and evaluates it.

  5. Plan the next increment using that feedback: it may add features, modify the core, or change priorities.

  6. Repeat until the complete product is delivered.

Increments can be developed one after another, or partly in parallel by different teams, as the staggered diagram suggests.

Worked Example: Value of Early Delivery

A company plans a 12-month project. Option A is Waterfall: everything is delivered at month 12. Option B is incremental: four increments, each worth 25% of the total features, delivered at months 3, 6, 9 and 12.

Let us measure "feature-months": how much of the system the users could actually use, summed over each month.

Option B (incremental), within the first 12 months:
  Increment 1 (25%) usable from month 3  -> 0.25 × (12 − 3) = 2.25
  Increment 2 (25%) usable from month 6  -> 0.25 × (12 − 6) = 1.50
  Increment 3 (25%) usable from month 9  -> 0.25 × (12 − 9) = 0.75
  Increment 4 (25%) usable from month 12 -> 0.25 × (12 − 12) = 0.00
                                                     Total  = 4.50 feature-months

Option A (waterfall), within the first 12 months:
  100% usable from month 12              -> 1.00 × (12 − 12) = 0.00 feature-months

By month 12, incremental users have already had 4.5 feature-months of real use; Waterfall users have had none. Looking over 18 months the gap remains: incremental gives 10.5 feature-months versus 6.0 for Waterfall. Just as important, Option B received three rounds of real feedback before the final increment was built, so increments 2 to 4 were more likely to be what users actually needed. (This assumes both options finish at month 12; in practice the incremental project also has some overhead for repeated integration and release.)

Advantages of the Incremental Model

  • Early working software: the customer gets the core product quickly and can start using it (and gaining business value).

  • Feedback after each increment improves later increments.

  • Lower risk: the most important parts are built and tested first, and receive the most testing over time, since every later increment re-tests them.

  • Easier to manage change: new or changed requirements can go into a later increment.

  • Smaller initial investment and staffing: a small team can build the first increment; more people can join later if needed.

  • Partial value even if the project stops early: delivered increments remain useful.

Disadvantages

  • Needs a good architecture early: if the overall structure is not designed to grow, later increments become hard to fit in.

  • Requires careful planning of how to divide the system into increments that can each work alone.

  • Total cost can be higher than a single Waterfall pass, because of repeated integration, testing and release.

  • Hard to fix the total scope and price in a contract when later increments may change.

  • Common facilities are tricky: features needed by many parts (login, logging, reporting) must be identified early or they get duplicated.


The Iterative (Evolutionary) Model

In the iterative model we do not try to specify the whole system upfront. We build an initial version, get feedback, and then evolve it through successive versions until it is adequate. Rajib Mall calls this the evolutionary model; Pressman groups such approaches (including prototyping and spiral) under evolutionary process models.

        +--------------------------+
        | Initial requirements     |
        | (outline, main features) |
        +------------+-------------+
                     |
                     v
  +-------------------------------------+
  |        Plan this iteration          |<------------+
  +------------------+------------------+             |
                     |                                |
                     v                                |
  +-------------------------------------+             |
  | Analyse -> Design -> Code -> Test   |             |
  +------------------+------------------+             |
                     |                                |
                     v                                |  not good enough yet:
  +-------------------------------------+             |  feedback, new and
  | Release version k; evaluate it with |-------------+  changed requirements
  | the customer and users              |
  +------------------+------------------+
                     |
                     |  good enough
                     v
       Final version (then ongoing evolution)

Key Points

  • Each iteration produces a working version that is more complete or better than the previous one.

  • Requirements are expected to evolve: users learn what they want by using the software.

  • Design and code may be reworked in later iterations. Refactoring is a normal activity, not a failure.

  • Iterations are often time-boxed (fixed length, such as 2 to 6 weeks): if not everything fits, scope is reduced, not the deadline extended.

Advantages

  • Handles unclear or changing requirements well.

  • Major risks (technical or about requirements) surface early, while they are still cheap to deal with.

  • Users see real software early and often, which improves validation.

  • The team learns and improves its process from iteration to iteration.

Disadvantages

  • Hard to estimate total cost and schedule at the start.

  • The structure can degrade if repeated changes are not followed by refactoring (remember from Software Characteristics & Software Crisis: software deteriorates due to change).

  • Needs active, continuous customer involvement.

  • Without discipline, it can slide back into code-and-fix ("we will fix it in the next iteration").

  • Progress is harder to show with traditional document-based milestones.


Iterative vs Incremental: Comparison

Aspect

Incremental

Iterative

Core idea

Build and deliver the system in parts

Build the system through repeated refinement cycles

What each cycle does

Adds new functionality

Improves and reworks existing functionality (and may add some)

Requirements

Mostly known upfront, then partitioned and prioritised

Outline upfront; details discovered and changed along the way

Each part when built

Intended to be finished

Expected to be revisited

Main benefit

Early delivery of usable parts

Learning, risk reduction, better fit to real needs

Risk if misused

Poor architecture makes later increments painful

Endless rework, unclear end point

In practice, almost every modern process is both. The Scrum Guide, for example, describes Scrum as an iterative, incremental approach: each Sprint produces a usable Increment, and the next Sprint is shaped by feedback (see Scrum).

Comparison with Waterfall

Aspect

Waterfall

Iterative & incremental

Number of passes through the phases

One

Many (one per iteration or increment)

First working software

At the end

After the first cycle

Customer feedback

At the end

After every cycle

Requirement changes

Expensive

Absorbed in later cycles

Integration risk

Concentrated at the end ("big bang")

Spread across cycles

Planning effort

Mostly upfront

Ongoing, per cycle


The Rational Unified Process (RUP)

The Unified Process, best known through its commercial version, the Rational Unified Process (RUP) from Rational Software (later IBM), is a well-known iterative and incremental framework closely tied to UML. It is use-case driven, architecture-centric, and iterative and incremental.

RUP divides a project into four phases, each ending in a milestone, and each phase contains one or more iterations:

Phase

Goal

Ends with milestone

Inception

Define scope and business case; identify key use cases and major risks

Lifecycle Objectives

Elaboration

Analyse the problem, build and test an executable architecture, remove the biggest risks

Lifecycle Architecture

Construction

Build the remaining features in iterations; produce a working product

Initial Operational Capability (beta-ready)

Transition

Deliver to users: beta testing, training, fixing, deployment

Product Release

Across these phases, disciplines (workflows) such as business modelling, requirements, analysis and design, implementation, test and deployment continue with different intensity. Requirements work is heavy in inception and elaboration; implementation is heaviest in construction. A key difference from Waterfall: phases are not the same as activities. Coding happens in elaboration too (to prove the architecture), and requirements work continues in construction.

Effort      Inception   Elaboration     Construction           Transition
            [ I1 ]     [ E1 ][ E2 ]  [ C1 ][ C2 ][ C3 ][ C4 ]   [ T1 ][ T2 ]
Requirements ######     #####  ###     ##    #     .     .         .
Design         ##       #####  #####   ###   ##    #     .         .
Implement.     .        ##     ###     ####  ##### ##### ####      ##
Test           .        #      ##      ###   ###   ####  #####     ###
Deployment     .        .      .       .     .     #     ##        #####

(# = relative amount of effort in each iteration; "." = little or none)

Rapid Application Development (RAD)

RAD, popularised by James Martin in his 1991 book Rapid Application Development, is an incremental approach that emphasises very short development cycles through:

  • Time-boxing: each increment has a fixed, short deadline; scope is cut rather than the deadline moved.

  • Heavy reuse of existing components and the use of high-productivity tools (code generators, form designers, low-code platforms).

  • Prototypes and intense user involvement, often through joint workshops.

  • Small, highly skilled teams, possibly several working in parallel on different modules.

Typical RAD phases: requirements planning → user design (with prototypes) → construction → cutover.

RAD works when the system can be modularised so each module can be built quickly, and when users are available. It is a poor fit for high-performance, high-risk systems built on new technology, or when the system cannot be split into independent modules. Today its ideas live on in agile methods and low-code platforms.


When to Use Iterative and Incremental Models

Situation

Good fit?

Core requirements clear, but extras and details will change

Yes: incremental

Customer needs some working functionality early (market deadline, business need)

Yes: incremental

Requirements unclear; users will discover needs by using the product

Yes: iterative / evolutionary

New technology with uncertain performance

Yes: early iterations tackle the risky parts (or use the Spiral Model for explicit risk analysis)

Small project with completely fixed requirements

Not necessary: Waterfall is simpler

System cannot be split into independently useful parts

Incremental delivery is difficult

A historical note: iterative and incremental development is not a new agile invention. Craig Larman and Victor Basili (2003) traced its use back to large government and aerospace projects in the 1950s to 1970s. Agile methods (from 2001) packaged these ideas with short time-boxes and close collaboration.


Common Mistakes Students Make

  • Using "iterative" and "incremental" as synonyms. Incremental adds parts; iterative refines through repeated cycles. Most real processes use both.

  • Confusing the iterative model with the iterative waterfall model. Iterative waterfall delivers once and only uses feedback paths to fix errors; the iterative model plans repeated cycles, each producing a working version.

  • Thinking incremental means no upfront design. A sound overall architecture is needed early, or later increments will not fit.

  • Thinking each increment must be released to the public. Some increments are delivered internally or to a pilot group; the key is that each one works.

  • Saying RUP is a waterfall because it has four phases. RUP phases contain iterations, and all disciplines happen in every phase in varying amounts.


Interview / GATE-Style Questions

1. What is the difference between iterative and incremental development?

Incremental development builds and delivers the system in parts, each adding new functionality. Iterative development builds the system through repeated cycles, each refining and improving the previous version based on feedback. Modern processes such as Scrum combine both.

2. What is the "core product" in the incremental model?

The first increment, containing the basic, essential requirements. It is delivered and used first; supplementary features come in later increments, which are planned using feedback on the core product.

3. Give two advantages and two disadvantages of the incremental model.

Advantages: early delivery of working software; easier accommodation of changes and lower risk because important features are built and tested first. Disadvantages: requires a well-designed, extensible architecture early; total cost can be higher and scope is harder to fix in a contract.

4. Name the four phases of RUP and their milestones.

Inception (Lifecycle Objectives), Elaboration (Lifecycle Architecture), Construction (Initial Operational Capability) and Transition (Product Release).

5. In which RUP phase is the architecture baselined and the major risks removed?

Elaboration.

6. A project delivers 3 equal increments (each one-third of the features) at months 2, 4 and 6. How many feature-months of use do users get by month 6? What about Waterfall delivering everything at month 6?

Incremental: (1/3)(6 − 2) + (1/3)(6 − 4) + (1/3)(6 − 6) = 4/3 + 2/3 + 0 = 2 feature-months. Waterfall: 1 × (6 − 6) = 0 feature-months.

7. When is RAD not suitable?

When the system cannot be properly modularised, when high performance must be achieved by tuning interfaces to system components, when technical risk is high (new technology), or when users and skilled developers are not available for the intense, short cycles.

8. Is Scrum iterative, incremental, or both?

Both. Work happens in fixed-length Sprints (iterations), and each Sprint produces a usable Increment that adds to previous ones, with feedback from the Sprint Review shaping the next Sprint.


Summary

  • Incremental: build and deliver the system in parts, most important first (the core product); each increment is a mini-waterfall.

  • Iterative / evolutionary: develop through repeated cycles, refining a working version with feedback until it is good enough.

  • Most real processes are iterative and incremental, including Scrum.

  • Benefits: early working software, early feedback, earlier risk discovery, easier change. Costs: needs good architecture, careful planning, active customers; total scope and cost are harder to fix.

  • RUP: four phases (inception, elaboration, construction, transition), each made of iterations; use-case driven and architecture-centric.

  • RAD: time-boxed, component-reusing, user-intensive incremental development for modular systems.

When the requirements themselves are the biggest uncertainty, building a quick model just to learn what users want can help. That is the Prototyping Model, our next chapter.