Chapter 07 of 32

Spiral Model

Suppose ISRO asks your team to build the software that controls a new satellite's antenna. Nobody has built this exact antenna before. The hardware may change. The timing limits are strict. A bug could cost crores. Would you follow Waterfall and discover in month 18 that the chosen processor is too slow? Would you build a quick throwaway prototype and hope for the best? Neither feels right.

What you really want is a process that keeps asking one question again and again: "What is the biggest thing that could go wrong right now, and how do we deal with it before we spend more money?" That question is the heart of the Spiral Model.

The Spiral Model is a risk-driven software process model, proposed by Barry Boehm (published in 1986 and widely known from his 1988 IEEE Computer paper), in which development proceeds through repeated loops (cycles). In each loop the team sets objectives, identifies and resolves the most important risks, develops and verifies the next level of the product, and plans the next loop.

In earlier chapters we saw the Waterfall Model (sequential), Iterative & Incremental Models (repeat and grow), and the Prototyping Model (learn by building something quick). The Spiral Model combines ideas from all of them and adds one crucial thing: explicit risk analysis in every cycle.


The Intuition: Climbing a Mountain

A mountaineering team does not plan the entire climb in Delhi and then march to the summit. They climb to a base camp, check the weather, the team's health and the route, decide what is most dangerous next, and only then climb to the next camp. Each stage costs more (higher altitude, more supplies) and each stage begins with a risk check. If the risk is too high, they turn back before it is too late.

The Spiral Model treats software the same way: small commitment, check risks, bigger commitment, check risks again, and so on, with the option to stop at the end of any loop.


The Spiral Diagram

The model is drawn as a spiral on two axes, divided into four quadrants.

                              |
   Q1: DETERMINE OBJECTIVES,  |  Q2: EVALUATE ALTERNATIVES,
       ALTERNATIVES AND       |      IDENTIFY AND RESOLVE RISKS
       CONSTRAINTS            |      (risk analysis, prototypes,
                              |       simulations, benchmarks)
          loop 3 ----------.  |  .---------- loop 3
          loop 2 -------.  |  |  |  .------- loop 2
          loop 1 ----.  |  |  |  |  |  .---- loop 1
                     |  |  | (*) |  |  |          (*) = start, centre
   ------------------+--+--+--+--+--+--+-------------------------
                     |  |  |  |  |  |  |
          loop 1 ----'  |  |  |  |  |  '---- loop 1
          loop 2 -------'  |  |  |  '------- loop 2
          loop 3 ----------'  |  '---------- loop 3
                              |
   Q4: PLAN THE NEXT PHASES   |  Q3: DEVELOP AND VERIFY THE
       (review, commit to the |      NEXT-LEVEL PRODUCT
        next loop or stop)    |      (requirements, design, code, test)
                              |

   Movement: Q1 -> Q2 -> Q3 -> Q4 -> Q1 of the next, wider loop.
   Radius (distance from centre) = cumulative cost spent so far.
   Angle (position around a loop) = progress within the current loop.

Two things to remember about the geometry:

  • Radial dimension (distance from centre) = cumulative cost incurred so far. Every new loop is wider, because later loops do more expensive work.

  • Angular dimension = progress through the current cycle.


The Four Quadrants in Detail

Quadrant 1: Determine Objectives, Alternatives and Constraints

For the part of the product being worked on in this loop, the team decides:

  • Objectives: what must be achieved (functionality, performance, ability to accommodate change).

  • Alternatives: different ways to achieve it (design A or B, build vs buy, reuse an existing library).

  • Constraints: cost, schedule, interfaces, hardware limits.

Quadrant 2: Evaluate Alternatives, Identify and Resolve Risks

This is the quadrant that makes the Spiral Model special. Each alternative is evaluated against the objectives and constraints, which exposes risks: sources of uncertainty that could cause failure. The team then chooses cost-effective ways to resolve them:

  • building a prototype (for unclear requirements or a doubtful technology),

  • simulation or benchmarking (for performance worries),

  • user questionnaires, analytic modelling, reference checks, and so on.

Quadrant 3: Develop and Verify the Next-Level Product

Once the risks are reduced to an acceptable level, the team does the actual engineering for this loop. Depending on how far along the project is, the "product" of this loop might be a concept of operations, a requirements specification, a design, or tested code. It is verified (reviewed or tested) before the loop moves on.

Quadrant 4: Plan the Next Phases

The results are reviewed with the key stakeholders. The review decides whether to commit to the next loop, and if so, plans it. This is also the natural point to stop the project if the risks have turned out to be unacceptable.


What Happens Across Loops

In Boehm's original illustration, the inner loops produce early, cheap artefacts and the outer loops produce the actual system. A typical progression looks like this:

Loop

Main output of Quadrant 3

Typical risk resolved in Quadrant 2

1

Concept of operation

Is the idea feasible at all? (first prototype)

2

Software requirements, validated

Do users agree on what they need? (second prototype)

3

Product (architectural) design, verified

Will the architecture meet performance needs? (third prototype, simulation)

4

Detailed design, code, unit/integration/acceptance test, implementation

Remaining implementation risks (operational prototype)

The number of loops is not fixed. It is decided by the project's risks. A risky project may need many loops; a simple one may need very few. This is one of the most frequently asked facts in exams.


Risk-Driven: Making It Concrete

"Risk-driven" means the amount of each activity (how much prototyping, how much documentation, how much testing) is chosen according to risk. A common way to rank risks is the risk exposure:

Risk Exposure (RE) = Probability of the unwanted outcome × Loss if it happens

We will study risk management in depth in a later chapter, Risk Management; here we only need enough to see how Quadrant 2 chooses what to work on.

Worked Example 1: Which Risk Comes First?

A team is building an online results portal for a state university. In Quadrant 2 of loop 1 they list three risks (loss in lakh rupees):

Risk

Probability

Loss (₹ lakh)

RE = P × L

Payment gateway integration fails

0.4

15

6.0

Site crashes under peak load on result day

0.2

40

8.0

Users reject the UI

0.5

4

2.0

Notice that the UI risk has the highest probability but the lowest exposure. The peak-load risk is the least likely, but it has the largest exposure (8.0), so it is attacked first, for example with a load-testing prototype of the results page. The Spiral Model directs effort to where it matters most rather than to where it is most obvious.

Worked Example 2: Is Risk Resolution Worth Its Cost?

Spending money on a risk only makes sense if it removes more expected loss than it costs. Suppose the peak-load risk is re-estimated more carefully as probability 0.30 with a loss of ₹20 lakh, and a ₹1 lakh benchmarking prototype (testing two candidate architectures under simulated result-day traffic) is expected to cut the probability to 0.05.

Step 1: RE before = 0.30 × 20 = ₹6 lakh.

Step 2: RE after = 0.05 × 20 = ₹1 lakh.

Step 3: Risk Reduction Leverage (Boehm's measure) = (RE before − RE after) / cost of reduction = (6 − 1) / 1 = 5.

A leverage greater than 1 means each rupee spent on risk reduction removes more than a rupee of expected loss, so the prototype is worth building. A leverage below 1 would mean the team should accept or handle the risk some other way.


Why It Is Called a Meta-Model

The Spiral Model can behave like other models, depending on the risks:

  • If requirements and technology are well understood (low risk), each loop can be a straightforward phase, and the spiral looks very much like Waterfall.

  • If user-interface requirements are the main risk, the loops are dominated by prototypes, and it looks like the Prototyping Model.

  • If the product is delivered in growing releases, it behaves like an incremental model.

Because it can contain these models as special cases, the Spiral Model is often called a meta-model. Remember it as "Waterfall + Prototyping + Iteration, steered by risk analysis".


Later Refinements by Boehm

Boehm refined the model in later work. Two ideas are worth knowing for interviews:

  • WinWin Spiral Model: adds steps at the start of each loop to identify the key stakeholders and negotiate "win" conditions for all of them, so that the objectives in Quadrant 1 are agreed rather than assumed.

  • Anchor point milestones: Life Cycle Objectives (LCO), Life Cycle Architecture (LCA) and Initial Operational Capability (IOC). They give managers clear checkpoints, answering a common criticism that a spiral has no obvious "phase end". These ideas later influenced the Rational Unified Process.


Advantages

  • Explicit risk management: high-risk issues are found and handled early, when they are cheap to fix.

  • Suitable for large, complex, high-risk projects (defence, aerospace, new technology).

  • Flexible: requirements and design can change between loops.

  • Early and repeated stakeholder reviews at the end of each loop.

  • Natural stopping points: a project that is going to fail can be cancelled before most of the money is spent.

  • Combines the strengths of Waterfall (documentation, control) and Prototyping (learning).

Disadvantages

  • Depends heavily on risk-assessment expertise. If the team misjudges the risks, the model gives false confidence.

  • Costly and complex to manage; overkill for small or low-risk projects.

  • Hard to fix cost and schedule up front, because the number of loops is not known in advance. This makes fixed-price contracts difficult.

  • More documentation and review overhead per loop.

  • Without discipline, the spiral may go on for many loops.


Spiral vs Other Models

Aspect

Waterfall

Prototyping

Spiral

Driving force

Documents / phases

User feedback

Risk

Iterations

None (one pass)

Prototype cycles

Loops, number not fixed

Risk analysis

Not explicit

Only requirements risk

Explicit in every loop

Requirement changes

Difficult

Easy during prototyping

Possible between loops

Cost

Lowest overhead

Moderate

Highest overhead

Best for

Small, well-understood projects

Unclear, UI-heavy requirements

Large, expensive, high-risk projects


Common Mistakes

  • Thinking there are exactly four loops. There are four quadrants per loop. The number of loops depends on the project.

  • Mixing up the axes. Radius = cumulative cost. Angle = progress within a loop. The radius is not time or risk.

  • Treating risk analysis as a one-time step. It happens in every loop.

  • Saying the Spiral Model is best for small projects. Its overhead makes it a poor fit for small, low-risk work.

  • Ranking risks only by probability. Exposure (probability × loss) is what matters, as Worked Example 1 showed.


GATE and Interview Questions

Which software process model is risk-driven?

The Spiral Model. Its second quadrant in every loop is devoted to identifying and resolving risks, and the amount of each activity is chosen according to risk.

What do the radial and angular dimensions of the spiral represent?

The radial dimension represents cumulative cost incurred so far; the angular dimension represents progress made in completing each cycle.

Is the number of loops in the Spiral Model fixed?

No. The number of loops varies from project to project and is decided by the project manager based on the remaining risks.

Why is the Spiral Model called a meta-model?

Because it can include other models as special cases: with low risk it behaves like Waterfall, with requirements risk it uses prototyping in each loop, and it can deliver incrementally. It is a framework that adapts to risk.

Name the four quadrants of the Spiral Model in order.

(1) Determine objectives, alternatives and constraints; (2) evaluate alternatives, identify and resolve risks; (3) develop and verify the next-level product; (4) plan the next phases (review and commit).

A risk has probability 0.25 and loss ₹12 lakh. A ₹2 lakh mitigation reduces the probability to 0.05. Compute the risk reduction leverage.

RE before = 0.25 × 12 = 3 lakh. RE after = 0.05 × 12 = 0.6 lakh. RRL = (3 − 0.6) / 2 = 1.2. Since it is greater than 1, the mitigation is worthwhile, though only just.

Give two main drawbacks of the Spiral Model.

It needs experienced people for risk assessment (bad risk judgement makes the model ineffective), and it is costly and complex, with cost and schedule hard to fix in advance, so it is not suited to small projects.


Summary

  • The Spiral Model (Boehm, 1986/1988) is a risk-driven, iterative process model.

  • Each loop has four quadrants: objectives → risk analysis and resolution → develop and verify → plan next loop.

  • Radius = cumulative cost; angle = progress within a loop; the number of loops is not fixed.

  • Risks are ranked by exposure (P × L); mitigation is worth it when its leverage exceeds 1.

  • It is a meta-model that can behave like Waterfall, Prototyping or incremental development.

  • Best for large, expensive, high-risk projects; overkill for small, well-understood ones.

The Spiral Model gives us a way to manage uncertainty, but it says little about how testing lines up with each development phase. The next chapter, V-Model, answers exactly that by pairing every development activity with a matching testing activity.