Evolutionary models: prototyping, spiral and RAD
Clear, exam-focused notes on evolutionary software process models: prototyping (throwaway and evolutionary), the Spiral model, and RAD, with definitions, diagrams-to-draw, worked exam-style examples, common mistakes and quick self-check questions.
Drafted with Aria, reviewed by the AiCanCode.org team · Updated . How we write and check our notes. Spotted an error? Use Give Feedback at the bottom of the page.
Why it matters
Evolutionary models are used when requirements are uncertain or expected to change. Engineers use them when they must deliver early working software, reduce project risk through iteration, or involve users frequently (for example, startups building an MVP, or systems where user workflows are unclear). Knowing when each model fits helps you choose process, plan iterations, control risk and communicate trade-offs to stakeholders.
Key ideas
Start by defining terms; each bold word is defined before use.
Software process model: A formal description of a sequence of activities, tasks and milestones used to develop software. Assumption: development proceeds through activities such as requirement elicitation, design, implementation, testing and deployment, possibly repeated.
Evolutionary model: A family of software process models where the system is developed incrementally through repeated cycles (iterations) and each cycle increases the functionality or fidelity of the product. Exact statement: an evolutionary model delivers successive intermediate versions (increments or prototypes) such that later versions refine or replace earlier ones. Assumptions: requirements may change; user feedback is available between iterations.
Prototype: A quick, working model of part or all of the system built to learn about requirements or design. Two important kinds:
- Throwaway prototype: built rapidly to understand requirements or UI, then discarded. Definition: a short-lived model whose purpose is elicitation and clarification, not final code.
- Evolutionary (incremental) prototype: built as the foundation of the final system and continuously refined until it becomes the final product. Also called exploratory prototyping.
Spiral model: A risk-driven evolutionary process model where development proceeds in spirals (cycles). Exact statement: Each cycle of the spiral includes (1) objective setting, (2) risk identification and analysis, (3) development and validation (including risk resolution via prototypes/POCs, simulations, or experiments), and (4) planning the next iteration. Assumptions: risks can be identified and mitigated iteratively; project can be decomposed into risk-driven phases. The model is especially useful for large, complex, high-risk projects.
Rapid Application Development (RAD): A development approach that emphasizes rapid delivery using timeboxed iterative development, heavy user involvement, component-based construction and often CASE tools. Exact statement: RAD organises development into short, fixed-duration phases (timeboxes) with parallel activities (requirements workshops/JAD, prototyping, component assembly) to deliver working systems quickly. Typical RAD lifecycle phases: requirements planning, user design, construction, and cutover. Assumptions: modularity in system, availability of users for frequent feedback, and reusable components or tools.
Timebox: A fixed, short duration allocated to complete a specific iteration or phase (for example, 2–6 weeks). Within a timebox scope is adjusted but duration is fixed.
Joint Application Development (JAD): A facilitated workshop technique to gather requirements quickly with users and developers present.
What to draw (diagrams):
- For a prototyping cycle: draw a small loop labelled: Requirements → Prototype → User evaluation → Refine requirements → Prototype (repeat). Label the loop with “throwaway” if prototype discarded or “evolutionary” if refined.
- For the Spiral model: draw a spiral starting at the centre and winding outward with at least three turns. On each turn, divide the circular ring into four quadrants and label them (in order around the ring): 1) Objective setting; 2) Risk identification & analysis; 3) Development & validation (choose a model to build a solution); 4) Planning the next cycle. On the radial axis label distance from centre as cumulative cost/time and angular progress as phases completed.
- For RAD: sketch parallel lanes: Requirements (JAD) | Prototyping & Construction (timeboxed) | Component assembly | Integration & Testing. Draw arrows showing short cycles and repeated user reviews.
Precise comparisons (exam style):
- If requirements are volatile and user feedback is easy to get → prototyping or RAD is suitable.
- If the project has high risks (technical, cost or safety) → Spiral is preferred because it makes risk analysis explicit.
- If schedule is strict and components are reusable → RAD with timeboxes is beneficial.
- If the system is safety-critical or requires formal verification → avoid using throwaway prototypes as final product; prefer spiral combined with heavy verification.
Formulas
(Listing the sequence templates to remember; each line shows a canonical sequence and when it applies.)
Prototype cycle = Requirements ↦ Prototype ↦ User feedback ↦ Refine requirements ↦ (repeat) — symbols: arrow means sequence of activities; applies to both throwaway and evolutionary prototypes.
Spiral cycle = Objective setting → Risk identification & analysis → Development & validation (risk resolution via prototype/POC) → Plan next cycle — applies to each loop of the Spiral model.
RAD iteration = JAD/requirements workshop + Timeboxed prototyping + Component assembly + Integration & User review — applies when components and users are available and schedule is fixed.
Timebox rule: Duration fixed; Scope variable — means during a timebox the team must adjust scope rather than extend time.
Worked examples
- Exam-style short answer: "Distinguish throwaway and evolutionary prototyping with one line each and give one suitable scenario for each."
- Answer: Throwaway prototype: a quick model built to clarify requirements and then discarded; suitable when the GUI or requirement details are unclear but you will implement the system later from a clean design. Example: designing a new mobile app's navigation flows with users, then discarding the mock UI and writing production code.
- Evolutionary prototype: a base system built and progressively refined into the final product; suitable when there is no big architectural change expected and you want working increments. Example: an early-stage SaaS product that is released and incrementally improved.
- Model question: "Choose a development model (prototyping, Spiral or RAD) for each scenario and justify briefly."
- Scenario A: A banking core system requiring formal validation, low tolerance for failure, and many regulatory constraints. Choice: Spiral model. Reason: High-risk domain; Spiral makes risk analysis and mitigation explicit and can incorporate formal verification and reviews in each cycle.
- Scenario B: A startup building an MVP e-commerce site rapidly to test market demand with frequent UI changes. Choice: RAD or Evolutionary prototyping. Reason: Need very fast delivery, heavy user feedback, and flexible scope; timeboxed iterations and prototypes let you ship quickly.
- Scenario C: An internal HR tool built from available reusable components with available user representatives and a fixed 3-month deadline. Choice: RAD. Reason: Component reuse, timebox discipline and JAD sessions fit well.
- Step-by-step trace (small example): Build a login-screen prototype (3 iterations)
- Iteration 1 (2 days): Requirements: username/password fields + login button. Prototype: static HTML mock. User feedback: wants "remember me" and "forgot password".
- Iteration 2 (3 days): Add checkbox and link; implement client-side validation. User feedback: wants social login and clearer error messages.
- Iteration 3 (5 days): Add OAuth buttons and server-side validation; do accessibility fixes. Decide: move prototype into evolutionary path (keep and harden) or throwaway and rebuild. Document decision. This trace shows how prototypes evolve and when a prototype becomes production code.
Common mistakes
- Treating throwaway prototypes as production code (security and maintainability issues).
- In the Spiral model, failing to state that each cycle must perform explicit risk analysis — leads to wrong justification.
- Drawing the spiral incorrectly (forgetting to label quadrants or radial meaning of cost/time).
- Confusing timebox (fixed duration) with fixed scope.
For your exam
Kinds of questions you will see: definitions (define prototype, RAD, Spiral), short notes (advantages/disadvantages), diagrams to draw (prototype loop, spiral with quadrants, RAD workflow), comparison essays (choose model for scenarios), and small case studies where you must recommend a model and justify with risks, schedule and team constraints.
What a full-marks answer includes:
- Precise definitions using bold terms where required.
- Clear assumptions (availability of users, component reuse, risk levels).
- Correct diagrams labelled exactly as requested (see "What to draw" in Key ideas).
- For comparisons: list criteria (requirements stability, schedule, risk, team skill, component reuse) and argue against alternatives.
- For scenarios: explicit mapping from scenario constraints to model features (e.g., "low tolerance for failure → Spiral because it forces risk analysis").
Quick check
- What is the main difference between a throwaway and an evolutionary prototype?
- Name the four activities (quadrants) of one cycle in the Spiral model in order.
- In RAD, what is a timebox? Answers: 1) Throwaway is discarded after learning; evolutionary is refined into the final product. 2) Objective setting → Risk identification & analysis → Risk reduction/development & validation → Plan next cycle. 3) A fixed-duration iteration where scope is adjusted to fit the time.
Finished this topic? Mark it so your progress, study plan and readiness keep up.
Stuck on something here?