Chapter 20 of 32

Risk Management

The previous chapters gave us a size estimate, an effort estimate from the COCOMO Model, and a schedule from Project Scheduling: Gantt Charts, PERT & CPM. Every one of those plans rests on assumptions: the lead developer will stay, the requirements will not change much, the payment-gateway vendor will deliver its API on time. What if they don't?

Risk management is the discipline of asking "what could go wrong?" before it goes wrong, and preparing for it. Tom DeMarco and Tim Lister summed it up as "risk management is project management for adults". Boehm built an entire process model, the Spiral Model, around it. In this chapter we identify, analyse, prioritise and control risks, with numeric examples of risk exposure and risk leverage.

A risk is an uncertain event or condition that, if it occurs, has a negative effect on the project's objectives (schedule, cost, quality or scope).

(Some project-management standards such as the PMBOK Guide also count uncertain positive events, called opportunities, as risks. Software engineering texts like Pressman and Sommerville focus on threats, and so does this chapter.)

Every risk has two characteristics:

  • Uncertainty: it may or may not happen. A risk with 100% probability is not a risk, it is a problem (or a constraint).

  • Loss: if it happens, something bad results.


Reactive vs Proactive Risk Management

ReactiveProactive
Wait for problems, then fix them ("fire-fighting")Identify risks early, assess them, and plan responses before they occur
Resources are pulled in a hurry when crisis hitsContingency resources and plans are ready
Often leads to schedule slips, overtime and quality lossMany risks are avoided entirely; others hurt less
Cheap at the start, expensive laterSmall cost up front, large savings later

Reactive management is not "no planning" exactly; at best a team may have a vague idea of what it would do. But it only acts once the risk has become a problem. Software engineering texts strongly favour the proactive approach.


Types of Software Risks

By what they threaten

CategoryThreatensExamples
Project risksThe project plan: schedule, cost, staffingKey developer leaves; budget cut; estimates too low
Technical (product) risksQuality and timeliness of the software itselfNew framework does not perform; design cannot scale; integration with legacy system fails
Business risksThe organisation building or buying the softwareMarket risk (nobody wants the product); strategic risk (product no longer fits company strategy); sales risk; management risk (loss of senior support); budget risk

Sommerville uses a similar three-way split: project, product and business risks.

By how predictable they are

  • Known risks: can be found by careful evaluation of the plan and environment (for example, an unrealistic delivery date).

  • Predictable risks: extrapolated from past experience (for example, staff turnover, poor communication with the customer).

  • Unpredictable risks: can happen but are extremely hard to foresee (for example, a sudden change in government regulation).

Generic vs product-specific

Generic risks threaten every project (changing requirements, staff loss). Product-specific risks come from the particular technology, people and environment of this project and need someone who understands it deeply to identify them.


The Risk Management Process

Different books name the steps slightly differently, but the idea is the same. Boehm divides the work into risk assessment and risk control:

RISK ASSESSMENT                         RISK CONTROL
┌────────────────────┐                  ┌──────────────────────────┐
│ 1. Identification  │                  │ 4. Risk planning         │
│ 2. Analysis        │ ───────────────► │    (response / RMMM)     │
│ 3. Prioritisation  │                  │ 5. Risk resolution       │
└────────────────────┘                  │ 6. Risk monitoring       │
          ▲                             └────────────┬─────────────┘
          └───── repeat throughout the project ──────┘

Sommerville's version has four stages: risk identification → risk analysis → risk planning → risk monitoring. The key word is repeat: new risks appear and old ones change as the project moves on.


Step 1: Risk Identification

The aim is a list of risks that is as complete as practical. Common techniques:

  • Checklists built from past projects and literature.

  • Brainstorming with the team and stakeholders.

  • Interviews with experienced managers and domain experts.

  • Assumption analysis: list every assumption in the plan and ask "what if this is false?"

  • Reviewing lessons learned from earlier, similar projects.

Pressman's risk item checklist

Pressman groups the questions to ask into seven areas: product size, business impact, stakeholder characteristics, process definition, development environment, technology to be built, and staff size and experience. Each risk is then judged by which risk component it threatens: performance, cost, support or schedule.

Boehm's Top 10 Software Risk Items

In 1991 Boehm published a famous list of the most common sources of project failure. It is still a useful checklist and a popular exam question:

#Risk itemTypical management technique
1Personnel shortfallsHire top talent, team building, cross-training
2Unrealistic schedules and budgetsDetailed multi-source estimation, incremental development, reuse, cutting requirements
3Developing the wrong functions and propertiesUser surveys, prototyping, early user's manuals
4Developing the wrong user interfacePrototyping, scenarios, user characterisation
5Gold-plating (adding unneeded features)Requirements scrubbing, cost-benefit analysis
6Continuing stream of requirements changesHigh change threshold, information hiding, incremental development
7Shortfalls in externally furnished componentsBenchmarking, inspections, compatibility analysis
8Shortfalls in externally performed tasksReference checking, competitive design, team building
9Real-time performance shortfallsSimulation, benchmarking, modelling, prototyping
10Straining computer-science capabilitiesTechnical analysis, cost-benefit analysis, prototyping

Step 2: Risk Analysis (Risk Projection)

For each identified risk we estimate two things:

  • Probability P that it will occur (0 to 1, or a scale such as low/moderate/high).

  • Impact if it occurs, either as a category or as a cost.

Pressman uses four impact categories:

ValueCategoryMeaning (roughly)
1CatastrophicMission failure; project unlikely to succeed
2CriticalMajor degradation, serious schedule or cost overrun
3MarginalSecondary goals affected, recoverable
4NegligibleMinor inconvenience

Risk Exposure

To compare risks with one number, multiply probability by cost:

Risk Exposure RE = P × C

where P is the probability of the risk occurring and C is the cost (loss) to the project if it occurs.

RE is an expected loss. A risk with a 10% chance of costing ₹10 lakh has the same exposure (₹1 lakh) as a 50% chance of costing ₹2 lakh.

Worked Example: Risk Table for an E-Commerce App

A team building a shopping app for a regional retailer lists five risks. Compute the risk exposure of each, rank them, and find the total.

RiskCategoryProbabilityCost if it occursRE = P × C
R1: Requirements change heavily after designProject0.60₹8,00,000₹4,80,000
R2: Size underestimatedProject0.50₹5,00,000₹2,50,000
R3: App misses performance target at sale-time loadTechnical0.20₹10,00,000₹2,00,000
R4: Key developer leavesProject0.30₹6,00,000₹1,80,000
R5: Payment-gateway API delivered lateTechnical0.40₹3,00,000₹1,20,000
Total₹12,30,000

The table is already sorted by RE. Three observations:

  • R3 has the highest possible cost (₹10 lakh) but is only third, because it is unlikely. R1 is first because it is both likely and costly.

  • The total exposure of ₹12.3 lakh is a reasonable basis for a contingency reserve in the budget.

  • Managers usually draw a cut-off line: risks above it get full management attention and a written plan; those below are re-evaluated periodically. Pressman notes that a high-impact, low-probability risk should not absorb much management time, while high-impact risks with moderate-to-high probability must be planned for.

Probability–Impact Matrix

When precise costs are not known, teams place risks on a grid:

                     IMPACT
               Low      Medium      High
          ┌─────────┬──────────┬──────────┐
     High │ Medium  │   High   │ Critical │   ← R1
 P        ├─────────┼──────────┼──────────┤
 R   Med  │  Low    │  Medium  │   High   │   ← R2, R4, R5
 O        ├─────────┼──────────┼──────────┤
 B   Low  │  Low    │   Low    │  Medium  │   ← R3
          └─────────┴──────────┴──────────┘

Risks in the top-right cells get attention first.


Step 3: Risk Planning (Responses)

For each important risk, choose a response strategy:

StrategyIdeaExample
AvoidChange the plan so the risk cannot occurUse a proven framework instead of an untested one
Mitigate (minimise)Reduce the probability or the impactPair programming and documentation so knowledge is shared if a developer leaves
TransferShift the impact to a third partyFixed-price contract or penalty clause with the payment-gateway vendor; insurance
AcceptDo nothing in advance, but keep a contingency plan or reserveSmall risks below the cut-off line

Sommerville names three kinds of plan: avoidance strategies, minimisation strategies and contingency plans (what to do if the risk happens anyway).

RMMM: Mitigation, Monitoring and Management

Pressman organises risk control into the RMMM plan:

  • Mitigation: proactive steps to lower probability or impact before the risk occurs.

  • Monitoring: watching indicators (triggers) that show whether the risk is becoming more or less likely, and whether mitigation is working.

  • Management (contingency planning): what to do if the risk actually occurs.

Each major risk is documented on a risk information sheet. An example for R4:

Risk ID: R4            Probability: 30%        Impact: Critical
Description: A key developer (owner of the checkout module) leaves mid-project.

Mitigation:
  - Discuss career goals and workload with the team; fix causes of dissatisfaction
  - Pair programming and code reviews so at least two people know every module
  - Keep design documents and README files current
  - Identify a backup developer for each critical module

Monitoring (triggers):
  - Unusual absences, drop in engagement, mentions of other offers
  - Modules where only one person has committed code in the last month

Management / contingency:
  - Backup developer takes over immediately
  - Re-plan the schedule using float on non-critical tasks
  - If needed, bring in a contractor for non-critical work, not the critical path

Is Mitigation Worth It? Risk Leverage

Mitigation costs money. To decide whether a step is worth it, compare the reduction in exposure with its cost:

Risk Reduction Leverage (RRL) = (REbefore − REafter) / Cost of risk reduction

RRL > 1 means the mitigation saves more expected loss than it costs. Higher is better, so RRL can also rank alternative mitigation steps.

Example 1 (R4). Pair programming and cross-training cost ₹60,000 and reduce the probability of serious damage from 0.30 to 0.10 (the cost if it happens stays ₹6 lakh).

RE_before = 0.30 × 6,00,000 = 1,80,000
RE_after  = 0.10 × 6,00,000 =   60,000
RRL       = (1,80,000 − 60,000) / 60,000 = 2.0   → worth doing

Example 2 (R1). Building an interactive prototype for the customer costs ₹1,50,000 and halves the probability of heavy requirement changes from 0.60 to 0.30.

RE_before = 0.60 × 8,00,000 = 4,80,000
RE_after  = 0.30 × 8,00,000 = 2,40,000
RRL       = (4,80,000 − 2,40,000) / 1,50,000 = 1.6   → worth doing

Both are worthwhile; if the budget allows only one, the higher leverage (Example 1) gives more protection per rupee.


Step 4: Risk Monitoring

Risks are not "done" after planning. Monitoring means:

  • Reviewing the risk list regularly (for example, every week, or in every Sprint Retrospective), re-estimating probability and impact.

  • Watching triggers and checking whether mitigation steps are actually being carried out.

  • Adding newly discovered risks and closing risks that can no longer occur.

  • Keeping a visible top-10 risk list with each risk's rank this week, last week, and progress on resolution (Boehm's "top-10 risk item tracking").


Risk in Different Process Models

ModelHow it handles risk
WaterfallWeak: many risks (wrong requirements, integration problems) surface only near the end.
PrototypingReduces requirements and UI risk by showing users something early.
SpiralExplicitly risk-driven: every loop includes a risk analysis quadrant, and the riskiest issues are resolved first.
Agile / ScrumShort iterations limit how much can go wrong before feedback. The Scrum Guide 2020 notes that short Sprints limit the risk of cost and effort to a smaller time frame; Sprint Reviews catch wrong-product risk and Retrospectives catch process risk.

Common Mistakes

  • Listing problems as risks. "The budget is ₹20 lakh" is a constraint; "the budget may be cut by 20%" is a risk. A risk must be uncertain.

  • Ranking by impact alone. Rank by exposure (P × C) or by a probability–impact matrix.

  • Confusing mitigation with contingency. Mitigation happens before the risk occurs; contingency (management) happens after.

  • Computing leverage with the wrong order. RRL = (REbefore − REafter) / cost. If the result is below 1, the mitigation costs more than it saves.

  • Identifying risks once and filing the list. Risk management is continuous.

  • Adding probabilities across risks. Each risk's RE is computed separately and the REs are summed, not the probabilities.


Exam and Interview Questions

Q1. A risk has a 70% chance of occurring, and if it does, it will cost ₹5,00,000. What is its risk exposure?

RE = 0.7 × 5,00,000 = ₹3,50,000.

Q2. A mitigation step costs ₹1,00,000 and reduces a risk's exposure from ₹2,50,000 to ₹1,00,000. Should it be applied?

RRL = (2,50,000 − 1,00,000) / 1,00,000 = 1.5 > 1, so yes: it saves ₹1.5 of expected loss for every ₹1 spent.

Q3. Classify as project, technical or business risk: (a) a competitor launches a similar app first; (b) the chosen database cannot handle the expected load; (c) the client cuts the budget by 30%.

(a) Business (market) risk. (b) Technical risk. (c) Project risk (budget/cost; some books also call it a business budget risk).

Q4. What does RMMM stand for? Explain each part.

Risk Mitigation (reduce probability or impact in advance), Monitoring (track triggers and whether mitigation works) and Management (contingency actions if the risk occurs).

Q5. Name any five of Boehm's top 10 software risk items.

Personnel shortfalls; unrealistic schedules and budgets; developing the wrong functions and properties; developing the wrong user interface; gold-plating; continuing stream of requirements changes; shortfalls in externally furnished components; shortfalls in externally performed tasks; real-time performance shortfalls; straining computer-science capabilities.

Q6. Which process model is called "risk-driven", and why?

The Spiral Model. Each loop of the spiral includes a dedicated risk analysis and resolution activity, and the project's next steps are chosen to resolve the biggest remaining risks first.


Summary

  • A risk is uncertain and causes loss if it occurs; a certain event is a problem, not a risk.

  • Prefer proactive risk management over reactive fire-fighting.

  • Risk types: project, technical, business; known, predictable, unpredictable; generic vs product-specific.

  • Process: identify → analyse → prioritise → plan → resolve → monitor, repeated throughout the project.

  • Risk exposure RE = P × C; rank risks by RE and draw a cut-off line. The sum of REs guides the contingency reserve.

  • Responses: avoid, mitigate, transfer, accept. Pressman's RMMM: mitigation, monitoring, management.

  • RRL = (REbefore − REafter) / cost; apply mitigations with RRL > 1, highest first.

  • The Spiral model is risk-driven; Agile limits risk through short feedback cycles.

  • Next, Software Design Principles moves from managing the project to designing the software itself.