DSE ICT | System Development Life Cycle and Project Management Lesson-Prep Guide (for tutors) | six phases, waterfall vs agile, four common errors

2026-11-05

Tutor lesson-prep guides · Secondary ICT

Students can chant analysis, design, implementation, testing, deployment, maintenance, yet cannot say which phase is most expensive to get wrong or how agile differs from waterfall. This lesson strings the six phases onto one 120-working-day project, then uses 1:10:100 to show why testing comes early.

Objectives — Students can: (1) draw the six phases and name each deliverable (feasibility report, design specification, program code, test report, training manual, maintenance log); (2) allocate a 120-working-day schedule across the phases and explain how waterfall and agile differ in delivery rhythm, with five two-week sprints covering 50 working days; (3) use test cases and defect rate (48 cases finding 6 defects, 12.5 percent) to describe coverage, and use the 1:10:100 ratio to compute what the same defect costs at different phases.

01 Prerequisites (3-minute check)

If any of these fails, fix it before the lesson starts.

Skill	Quick check	Pass mark
Information systems	Which five parts make up an information system	Hardware, software, data, procedures, people
Databases	What does a primary key do	Uniquely identifies each record
Projects	What are the three classic constraints on a project	Scope, time, cost

02 Lesson flow (60 minutes)

Time	Stage	Tutor does	Student does
0-6 min	Prior check	Three quick items, especially the triple constraint	Answer orally, errors go in the board corner
6-20 min	Six phases and deliverables	Draw the phases and fill the 120-day allocation	Students complete the deliverable column
20-34 min	Waterfall against agile	Compare both models and count the five sprint deliveries	Students name one suitable scenario each
34-48 min	Testing and defect rate	48 cases, 6 defects, compute coverage and density	Students design three boundary tests
48-56 min	The 1:10:100 repair cost	Three design defects cost 3 units now, 300 after go-live	Students convert their own project days
56-60 min	Exit check	Collect three items, mark at once, tag the act	Work independently

03 Teaching script (read it out)

Scene 1: Act 1: six phases, every one with a deliverable

Ask the class to recite the six phases and most can. Then ask what the analysis phase hands over and the room goes quiet. So act one is about deliverables: feasibility produces a report covering technical, economic, schedule and legal angles; analysis produces the requirements specification; design produces the design document with database schema and interfaces; implementation produces code and unit tests; testing produces the test report and fix log; deployment produces training and conversion plans; maintenance produces change records.
Use one 120-working-day project: analysis 10, design 15, implementation 40, testing 35, deployment 12, maintenance 8, which totals 120 days, or 480 person-days for a team of four. Students should see that implementation plus testing take about seven tenths of the schedule, which is the point that coding is only the visible tip.
Put the misconception on the board: maintenance is not the short phase. It usually runs for years after go-live, which is why it is planned as an ongoing service.

Students repeat: six phases, each with a deliverable, and implementation plus testing take most of the time.

Scene 2: Act 2: waterfall and agile differ in rhythm, not in age

Waterfall flows down in layers: requirements freeze, then design, then code, then test. Its strength is documentation and clear contracts; its weakness is that the customer sees nothing until the end, so a misunderstood requirement is expensive to unwind.
Agile slices the project into short sprints: five sprints of ten working days, 50 working days in total, each ending with a usable increment, so feedback arrives while change is still cheap. Students should compare directly: waterfall shows something around day 100, agile shows a usable build on day 10.
Then the matching exercise: stable requirements with heavy audit needs, such as a core banking system, suit waterfall; shifting requirements and a fast market, such as a mobile app, suit agile. The lesson is that these are trade-offs, not generations.

Students repeat: waterfall delivers once, agile delivers every sprint; stable needs favour waterfall, changing needs favour agile.

Scene 3: Act 3: testing and the cost of finding defects late

Act three puts numbers on quality. Run 48 test cases and find 6 defects, a 12.5 percent rate. That is not the number of bugs left in the system; it is what this set of cases exposed, which is why coverage and boundary values matter. Teach three case families: normal, boundary and invalid input, and only all three count as tested.
Then 1:10:100: the same defect costs 3 units to fix in design, 30 in build and 300 after go-live. Leaving three design defects to production costs 300 units, a hundred times the design figure, which is the arithmetic behind design reviews and early testing rather than a matter of programmer pride.
Convert to effort: if one unit is half a person-day, 300 units is 150 person-days, longer than the whole testing phase. That comparison lands harder than any slogan about quality.

Students repeat: three families of test cases, and late discovery costs roughly one to ten to one hundred.

04 Question types and worked steps

Type	Example	Steps	Answer
Phase and deliverable	What does the analysis phase hand over	1 state the goal 2 name the deliverable 3 say who signs it off	Requirements specification with functional and non-functional needs
Schedule allocation	How should a 120-day project be split across six phases	1 set proportions 2 make the total match 3 add risk buffer	Analysis 10, design 15, implementation 40, testing 35, deployment 12, maintenance 8 days
Waterfall or agile	Requirements keep changing mid-build; which model	1 judge stability 2 compare delivery rhythm 3 state the risk	Agile, using short sprints to buy feedback
Defect cost	Three design defects reach production; how many times the design cost	1 apply 1:10:100 2 map to phases 3 convert to person-days	A hundred times, 300 units against 3

Sanity check (teach this): Check the arithmetic: the six phase figures must total 120 days, no more and no less. A four-person team gives 480 person-days, so a total below 120 means the team size was forgotten. A 12.5 percent defect rate is plausible; 120 percent means cases and defects were swapped. Repair cost must rise from left to right, so a cheaper production fix means the ratio was inverted.

05 Independent practice (3 questions)

Question	Answer	What to watch
List the six phases and one deliverable each.	Analysis (requirements), design (design document), implementation (code), testing (test report), deployment (training manual), maintenance (change log)	No phase missing, deliverable matches
What percentage of a 120-day project goes to implementation and testing together?	62.5 percent, that is 75 days out of 120	Both phases added before dividing by the total
If three design defects reach production, how many design-phase units does that cost at 1:10:100?	300 units, a hundred times	Ratio applied per phase and the multiplier stated

06 Common mistakes and what to say

Mistake	Student writes	Say this
Treating maintenance as the shortest phase	Answering that maintenance lasts a month or two	The system runs for years, so maintenance is usually the longest phase; your code is the starting point, not the end.
Reading agile as simply newer	Answering that agile is always better than waterfall	It is a trade-off: stable requirements and audit needs favour waterfall, changing requirements favour agile.
Testing only normal input	All 48 cases use ordinary values	Without boundary and invalid input you have not tested; all three families are needed.
Confusing defect rate with remaining bugs	Answering that only six bugs remain in the system	That figure is what this set of cases found, not the number left in the whole system.

07 Homework (paper, section and question numbers)

Redo this chapter — Redo practice items 1 to 3 (questions 1-3), writing the phase and formula used
ICT subject index — Pick the databases chapter and do question 2, marking primary and foreign keys
Build a test table — Write nine cases for a login function: three normal, three boundary, three invalid

08 Exit check (last 5 minutes)

Question	Answer	Decision
Which phase usually runs longest	Maintenance	Answering implementation means replay act one
The biggest difference between waterfall and agile	Delivery rhythm: one drop against an increment per sprint	Answering agile is faster means replay act two
What does 1:10:100 describe	The repair cost of one defect in design, build and production	Answering a test ratio means replay act three

09 Tutor FAQ

Does DSE examine agile?

The syllabus centres on waterfall, but comparison questions expect the benefits of agile, so both must be explained.

What belongs in a feasibility study?

Technical, economic, schedule, legal and operational feasibility; four of these are enough for full marks.

How do unit and system testing differ?

Unit testing targets one module and is done by the developer; system testing targets the integrated system and is done by a tester.

Find a tutor — free Tutor Registration →

A TutorZone lesson-prep guide. Written by the TutorZone team; questions and lesson flow are original and are not taken from any school or publisher material.