Chapter 1 · How Software Gets Built
Process Models: Waterfall, Incremental, RAD and Big Bang
- Page 3 of 18
- 17 min read
The previous page, The Software Development Life Cycle (SDLC), ended with a problem. The seven activities (planning, requirements, design, implementation, testing, deployment, maintenance) look like a neat line, but real projects overlap and go back. A process model is a team's planned answer to that problem: in what order the activities happen, how often they repeat, and when the customer sees working software.
This page explains the classic models you will hear about in interviews and in job descriptions: Waterfall, incremental and iterative development, RAD and Big Bang, plus a short look at the spiral model and the V-model. No model is best for every project. The goal is to understand what each one assumes, so that you can choose one for a real situation and explain why.
What you will learn
- How the Waterfall model works, where it helps, where it hurts, and what Royce's 1970 paper actually said.
- The difference between incremental and iterative development, and why most teams combine them.
- When RAD (rapid application development) fits, and why Big Bang only suits tiny or throw-away work.
- The main idea of Boehm's spiral model and the shape of the V-model.
- How to choose a model with a comparison table and a checklist, practised on short invented scenarios.
Waterfall: one activity after another
How it works
In the Waterfall model, the team finishes each activity before starting the next, and each activity ends with an approved document. Work flows down, like water over steps, and going back up is treated as an exception.
Example:
Requirements --> approved requirements specification
|
v
Design --> approved design documents
|
v
Implementation --> finished code
|
v
Testing --> test report
|
v
Deployment and maintenance --> the customer receives the whole systemStrengths and weaknesses
| Strengths | Weaknesses |
|---|---|
| Clear documents at each step; easy to see where the project is | Feedback is late: the customer sees working software only near the end |
| Scope, price and dates can be agreed up front, which some contracts require | Changes after the requirements are approved are slow and expensive |
| New people can read the documents and understand decisions | Mistakes in requirements stay hidden until testing, when they are hardest to fix |
| Fits work where requirements are stable and well understood | Testing is squeezed when earlier steps run late |
Waterfall fits best when the requirements are known and unlikely to change, when the technology is familiar, and when a contract or regulator expects approved documents before building, for example a small extension to a system whose rules are fixed by law. It fits badly when users cannot say what they want until they see something.
Invented scenario:
Suppose the ClinicQueue team had used a strict Waterfall plan.
Week 1 Requirements written and approved by Nadia.
Week 2 Design approved.
Week 3-4 Farhan and Aiko build everything: booking, reminders, queue screen.
Week 5 Kwame tests. Rina sees the queue screen for the first time.
Rina: "Walk-in patients are half of our morning. Where do I add them?"
The requirements never mentioned walk-ins. Design, code and tests must change,
and the busy season starts in one week.Nobody was careless here. The need was simply invisible until Rina saw a working screen. That is the core weakness of a single pass: the team learns the most important things last.
What Royce actually wrote
Waterfall is often linked to a 1970 paper by Winston W. Royce, "Managing the Development of Large Software Systems". The common story says Royce proposed Waterfall. The paper says something different. Royce drew the one-pass sequence and then wrote: "I believe in this concept, but the implementation described above is risky and invites failure." He went on to add feedback between steps and a section titled "Do It Twice", suggesting that the version delivered to the customer should really be the second version for the critical design and operations areas. Secondary sources also note that Royce did not use the word "waterfall"; the name came later.
So the paper is better read as a warning about the one-pass approach, followed by ideas to reduce its risk. Remember this nuance when someone says "Waterfall was invented in 1970".
Incremental and iterative development
These two words are often used together, and many textbooks treat them as one idea, but they mean different things.
Incremental: deliver working parts
In incremental development, the system is built and delivered in parts called increments. Each increment adds a usable piece to what already works, and goes through design, code and test on its own. Users get value early, and the team learns from real use before building the next part.
Example:
ClinicQueue, delivered in increments (invented dates are relative to the start)
Increment 1 (week 3) Online booking + front-desk list of today's bookings
Increment 2 (week 4) SMS reminders the day before each visit
Increment 3 (week 6) Live queue screen with walk-in patients
Increment 4 (later) AI-drafted reminder text, checked by Rina before sending
Each increment is designed, built, tested and released. After increment 1,
Rina uses it for real, and her feedback changes the plan for increment 3.Notice that this is the plan the feasibility check on the previous page pointed to: booking first, reminders second, because booking is the most valuable part and time is tight.
Iterative: improve the same part in repeated passes
In iterative development, the team builds a rough version of something, gets feedback, and improves it in repeated cycles called iterations. The same feature gets better with each pass, instead of being designed perfectly once.
Example:
The booking form, in three iterations
Iteration 1 A plain form: name, phone, pick a slot. Omar watches 5 patients use it.
Finding: older patients cannot find the "next week" button.
Iteration 2 Bigger buttons, a simple calendar.
Finding: some patients do not notice the confirmation.
Iteration 3 A clearer confirmation screen and SMS.| Question | Incremental | Iterative |
|---|---|---|
| What grows? | The amount of the system that exists | The quality of a part that already exists |
| Each cycle produces | A new usable piece | A better version of the same piece |
| Main benefit | Early value; the most important parts first | Learning; the design improves with feedback |
| ClinicQueue example | Booking, then reminders, then the queue screen | The booking form, improved three times |
In practice most modern teams do both: they deliver the system in increments, and they improve each increment over several iterations. The Agile methods on the next page, Agile, Scrum and Kanban, build on both ideas. Incremental and iterative are general terms used across many textbooks; no single person is credited with them.
RAD: rapid application development
Rapid application development (RAD) puts speed and user involvement first. James Martin's 1991 book Rapid Application Development made the approach well known. In general terms, RAD uses:
- Prototypes: quick working models of screens and flows that users can try, built instead of long specifications.
- User involvement: real users join workshops and try each prototype, often several times a week.
- Time-boxing: each piece of work gets a fixed amount of time, a time-box. When the time is up, the team delivers what it has, and the scope shrinks instead of the date moving.
- Reuse and tools that let screens and data forms be built quickly.
Invented scenario:
Nadia is unsure how the queue screen should look. Lena sets a 2-week time-box.
Day 1 Workshop: Rina, Dr. Rahman, Omar, Aiko. Paper sketches of the queue.
Day 2-4 Aiko builds a clickable prototype with fake patients.
Day 5 Rina tries it at the real desk for an hour. Three changes agreed.
Day 6-9 Second prototype; Dr. Rahman adds "patient is in the room" status.
Day 10 Time-box ends. The team keeps the agreed design, drops the colour themes.RAD fits when the system is mostly screens and data forms, users are available and willing to give time, the technical risk is modest, and the team is small and skilled. It fits badly when users cannot be reached, when performance or safety needs careful engineering, or when the parts cannot be built separately. A known danger is that a quick prototype is shipped as the product without the tests and design work a product needs: the "it works on my laptop" problem from What Software Engineering Is, and Why Coding Is Not Enough.
Big Bang: little planning, then build
In the Big Bang model there is almost no planning or written requirements. The developer starts coding with whatever resources are available and the customer sees the result at the end. If it is wrong, it is changed or thrown away.
Big Bang is only reasonable for tiny or throw-away work: a one-day experiment, a demo for a meeting, a learning project, a script you will run twice. Farhan's weekend version of ClinicQueue (from page 1) was a Big Bang build, and that was fine for its purpose: it helped Nadia see what she wanted. It became a problem only when it was treated as a product. For anything that real users rely on, or that more than one person will change, Big Bang is a gamble with other people's time.
Two more models you will meet
The spiral model
Barry Boehm's spiral model (1986, widely published in 1988) is risk-driven. The project goes round in repeated cycles. Each cycle starts by setting objectives and looking at the biggest risks, then does whatever reduces them most (a prototype, a study, a piece of the real system), then plans the next cycle. The project grows outwards like a spiral. For ClinicQueue, the first cycle might target "can we send SMS reliably and cheaply?" before anything else is built. The spiral model suits large, risky projects; for a small team its formal risk analysis can be more process than the project needs.
The V-model
The V-model pairs each design level with a test level. The left side of the V goes down from requirements to detailed design; the bottom is coding; the right side goes up through test levels, and each test level checks the matching level on the left. Its origins are disputed (there are German and US versions), so it has no single inventor or year.
Example:
User requirements <----------------------------------> Acceptance testing
System requirements <------------------------> System testing
Architecture design <--------------> Integration testing
Detailed design <------> Unit testing
\ /
CodingThe V-model's strength is that test planning starts early: while Lena writes user requirements, Kwame can already write acceptance tests for them. Its weakness is the same as Waterfall's: it is still largely one pass. It is common in regulated and safety-related work, where each requirement must be traced to a test. You will meet the test levels on Software Quality, Testing and QA.
Choosing a model
Comparison
| Model | Customer sees working software | Handles change | Planning and documents | Best for |
|---|---|---|---|---|
| Waterfall | Near the end | Poorly | Heavy, up front | Stable, well-understood requirements; fixed contracts |
| V-model | Near the end | Poorly | Heavy, with a test plan per level | Regulated or safety work needing traceability |
| Incremental / iterative | After the first increment | Well, between and within increments | Moderate, per increment | Most products where value can be delivered in parts |
| RAD | Very early, as prototypes | Well | Light; prototypes replace long specs | Screen-heavy business apps with available users |
| Spiral | Depends on the risks handled first | Well | Heavy risk analysis each cycle | Large, high-risk projects |
| Big Bang | At the end | Only by rebuilding | Almost none | Tiny experiments and throw-away work |
A decision checklist
Ask these questions about the project. No single answer decides, but together they point clearly.
| Question | If the answer is... | Lean towards |
|---|---|---|
| How stable are the requirements? | Fixed and well understood / likely to change | Waterfall or V-model / incremental, iterative or RAD |
| How high is the risk (new technology, unknowns)? | Low / high | Any plan-driven model / spiral, or small increments that tackle risks first |
| How available is the customer or user? | Rarely / weekly or more | Up-front documents / RAD or short iterations |
| How large is the team? | One or two / many, in several groups | Light process / more planning and written interfaces |
| Is the work regulated or safety-related? | No / yes | Lighter documents / V-model or traceable increments |
| How long will the software live? | Days / years | Big Bang is acceptable / never Big Bang |
Practitioners disagree about how strict this choice should be. Some say a team should follow one named model carefully so everyone knows the rules. Others say real teams mix models: for example, an approved, Waterfall-style requirements phase for the legal parts and short iterations for the screens. Mixing is common and can be sensible, as long as the team agrees what it is doing and why. What does not work is having no agreed model and calling it flexibility.
Practice: three short scenarios
Invented scenario:
A. ClinicQueue itself. Requirements will change once Rina and patients use it. Nadia
can meet weekly. Team of 5. Personal data, but not safety-critical. Must live years.
B. A payroll export for a hospital group. The file format is fixed by the bank and the
tax rules are set by law for this year. The client wants a fixed price and date.
C. Aiko wants to know whether an SMS service's test account can send Bangla text.
She has one afternoon. Nobody else will use the code.Reasoning through the checklist:
- A: incremental and iterative. Requirements will change, the customer is available and value can come in parts (booking first). Waterfall would repeat the walk-in surprise above. A short RAD-style prototype for the queue screen fits inside this plan.
- B: Waterfall (or V-model). Requirements are fixed by outside rules, the customer wants a fixed contract, and Waterfall's main weakness, slow and costly change, matters little here because change is unlikely. Strong testing against the bank's format matters, so planning tests per level, V-model style, is a good addition.
- C: Big Bang. It is a one-afternoon experiment whose only output is an answer. Writing a plan would cost more than the experiment. If the answer is "yes", the real feature is then built properly inside model A.
Where this shows up at work
- Interviews often ask you to compare Waterfall and incremental development, or to say which model you would choose for a described project. A reasoned answer with trade-offs beats naming a favourite.
- Contracts reflect the model: a fixed-price contract with a full specification is Waterfall-shaped; paying per delivered increment is incremental.
- Regulated work in health, transport or finance often uses V-model-style traceability from each requirement to a test, even when the team works in increments.
- Freelancers who deliver a small first increment to a new client learn quickly whether they understood the job, and get paid earlier.
Common mistakes
- Calling Waterfall always wrong. It bites when a project with fixed rules and a fixed contract is run as open-ended experiments. Fix: use the checklist; stable requirements and fixed contracts can suit a plan-driven model.
- Repeating the "Royce invented Waterfall" story. It is a common myth; his paper called the one-pass version risky and added feedback and iteration. Fix: describe the paper accurately, or leave it out.
- Confusing incremental with iterative. Teams then deliver many half-built parts, or polish one part forever. Fix: decide both what the next usable increment is and how many feedback rounds each part gets.
- Shipping a RAD prototype as the product. It bites when real users hit missing validation, tests and security. Fix: treat a prototype as a learning tool and plan the engineering work before release.
- Using Big Bang for something that will live. A weekend script becomes the clinic's booking system and nobody can safely change it. Fix: the moment others depend on it, switch to a planned model.
Try it yourself
- Easy: Name the model described in each sentence: (a) "We deliver booking first, then reminders, then the queue screen"; (b) "Each test level checks the matching design level on the other side"; (c) "Each cycle begins by looking at the biggest risks"; (d) "Requirements are approved before design starts, and design is approved before coding starts"; (e) "Users try a clickable prototype every few days inside a fixed two-week time-box".
- Medium: Explain the difference between incremental and iterative development using a feature that is not on this page: ClinicQueue's report that shows Nadia how many patients missed their visits each month. Give one increment plan (at least two increments) and one iteration plan (at least two iterations).
- Hard: Choose a model, with reasons from the checklist, for each invented project. (a) A one-person freelancer builds an online menu and order form for a small restaurant; the owner is busy but can reply to messages daily; it must be live in 3 weeks. (b) Software that controls the dose on an infusion pump in hospitals; it must be certified before use. (c) A new team of 12 builds a ride-sharing app for a city where no one on the team has worked with live map data. Then name one risk your chosen model leaves for each project.
Answers
- (a) Incremental. (b) V-model. (c) Spiral. (d) Waterfall. (e) RAD (time-boxing and prototypes with users).
- Model answer: Increments: increment 1 shows a table of missed visits per month for the last 6 months; increment 2 adds a breakdown by doctor; increment 3 adds an export file for Nadia's accountant. Each one is usable when delivered. Iterations on increment 1: iteration 1 is a plain table, and Nadia says she cannot see the trend; iteration 2 adds a simple text bar per month; iteration 3 adds the percentage of all bookings so busy months compare fairly. A good answer shows increments adding new usable capability and iterations improving the same capability after feedback, and says that the two are usually combined.
- Model answer: (a) Incremental and iterative with very light process, or a short RAD-style approach: the owner can give daily feedback, the time is short, and the risk is low; deliver the menu first, then ordering. Remaining risk: the owner's slow replies, so agree a reply time. Big Bang is tempting but the site will be used by customers for years. (b) V-model (or another plan-driven, document-heavy model): safety and certification need approved requirements and traceable tests at every level. Remaining risk: late feedback from nurses using it, so plan early usability studies with mock-ups. (c) Spiral, or small increments that tackle the highest risks first: live map data is new to everyone, so early cycles should prove the risky parts (location updates, matching drivers) before building everything. Remaining risk: the cost of risk analysis and coordination in a team of 12. A good answer uses checklist factors (stability, risk, customer availability, team size, regulation, lifetime) by name, not just a favourite model.
Summary
- A process model decides the order, overlap and repetition of the SDLC activities and when users see working software.
- Waterfall does each activity once, in order, with approved documents; it suits stable requirements but gives late feedback. Royce's 1970 paper called the one-pass version risky and added feedback.
- Incremental development delivers usable parts; iterative development improves a part through feedback. Most teams combine them.
- RAD uses prototypes, user workshops and time-boxes; Big Bang suits only tiny or throw-away work. The spiral model is risk-driven; the V-model pairs each design level with a test level.
- Choose with evidence: requirements stability, risk, customer availability, team size, regulation and how long the software will live.
Next: Agile, Scrum and Kanban shows how the Agile Manifesto builds on incremental and iterative ideas, and how Scrum and Kanban put them into daily practice.

