Chapter 5 · Quality, Release and the Future
Practice Lab and Capstone: Plan a Small Project End to End
- Page 18 of 18
- 24 min read
You have now walked through the whole life of a piece of software: from a clinic manager's problem, through requirements, plans, risks, design, code, review and tests, to a release that has to be maintained. Knowing each step is one thing. Doing them together, on one small project, is what turns the knowledge into a skill.
This last page has two parts. The Practice Lab gives you five short exercises, each reusing a technique from an earlier page, with worked solutions and runnable Python where code fits. The Capstone is a project file you fill in for a project of your own, with a short ClinicQueue example to copy from. A cheat sheet of the whole tutorial and pointers for what to learn next close the page. As always, every ClinicQueue number is invented.
What you will learn
- How to apply five core techniques again on a new feature: testable requirements, story splitting, PERT estimates, risk scoring and boundary-value tests.
- How the pieces connect: the output of one step (a requirement, a story, an estimate) becomes the input of the next.
- How to write a one-file plan for a small project of your own, from problem statement to release plan.
- Where each idea of this tutorial lives, in one table you can keep.
- Where to go next in the Skills track.
How to use this page
Do the lab first. For each exercise, read the task, close your eyes to the solution, and write your own answer on paper or in a text file. Then compare. Your answer does not have to match word for word; check it against the "a good answer contains" notes. The Python blocks run on their own in a fresh folder, so you can copy them and change the numbers.
All five exercises are about one new ClinicQueue feature, so the lab also works as a small project rehearsal.
Invented scenario:
After the first releases, Rina notices that fully booked days still have gaps: patients cancel
late, and the freed slot stays empty. Nadia (clinic manager, Product Owner) asks for a waiting
list: "When a day is full, patients should be able to join a list and get the slot if someone
cancels." Lena (project lead, Scrum Master) plans it as the next release with Farhan, Aiko,
Omar and Kwame. You will do their thinking.Practice Lab: five exercises
Exercise 1: make a vague requirement testable
Task. Nadia's first note says: "Patients on the waiting list should be told quickly when a slot frees up, and joining the list should be easy." Rewrite it as testable "shall" requirements and add acceptance criteria in Given/When/Then, as on the page Functional and Non-functional Requirements, and Acceptance Criteria.
Solution. The words that cannot be tested are "quickly" and "easy". Ask Nadia for a number and an example, then write one requirement per statement. A tiny script can flag the usual vague words; it is a reminder to ask questions, not a replacement for thinking.
VAGUE = {"fast", "quickly", "easy", "simple", "user-friendly", "soon", "secure", "reliable"}
def vague_words(text):
"""Vague words in a requirement: each one is a prompt to ask 'how much, how fast?'"""
words = text.lower().replace(",", " ").replace(".", " ").split()
return sorted(set(words) & VAGUE)
before = ("Patients on the waiting list should be told quickly when a slot frees up, "
"and joining the list should be easy.")
after = ("REQ-21: When a booked slot is cancelled, the system shall send an SMS offer to the "
"first patient on the waiting list for that doctor and day within 5 minutes.")
print("before:", vague_words(before))
print("after: ", vague_words(after))before: ['easy', 'quickly']
after: []Example:
REQ-21 When a booked slot is cancelled, the system shall send an SMS offer to the first patient
on the waiting list for that doctor and day within 5 minutes.
REQ-22 An offer shall hold the slot for 30 minutes; if the patient does not accept in time, the
system shall offer it to the next patient on the list.
REQ-23 From the "no free slots" message, a patient shall be able to join the waiting list in at
most 2 steps; in a test with 5 first-time users, at least 4 shall do it within 1 minute.
Scenario: First patient accepts the freed slot
Given Dr. Rahman's 2027-01-12 is full, with Tania and then Sami on its waiting list
When the patient booked at 10:30 cancels
Then Tania gets an SMS offer for 10:30 within 5 minutes
And when she accepts within 30 minutes, the 10:30 slot is booked for her
Scenario: Offer expires
Given Tania got an offer for 10:30 at 08:00
When she has not accepted by 08:30
Then the offer moves to Sami and Tania's offer link no longer worksA good answer contains: no vague words left; a number with a unit for every quality (5 minutes, 30 minutes, 2 steps); the actor named in each statement; one happy and at least one unhappy scenario with concrete dates and names. The 30-minute hold is a new rule, so it must go back to Nadia for agreement: you are proposing it, not deciding it.
Exercise 2: split the waiting-list epic
Task. The epic is "As a patient, I want to join a waiting list for a fully booked day, so that I can get a slot if someone cancels." Split it into small vertical stories, check one against INVEST, and suggest a MoSCoW priority for each (as on User Stories, Use Cases and Prioritising).
Solution. Split by workflow step and by happy path first, exceptions later. Each story must work on its own from screen to database.
Example:
Horizontal split (avoid): "waiting-list table", "waiting-list API", "waiting-list screens"
Vertical split: MoSCoW (proposed)
US-13 Patient joins the waiting list for a full day (one doctor) Must
US-14 First patient on the list gets an SMS offer and accepts it Must
US-15 An offer expires after 30 minutes and goes to the next one Should
US-16 Patient leaves the waiting list Should
US-17 Receptionist sees the day's waiting list on the queue screen CouldINVEST check for US-14. Independent: it needs US-13 (someone must be on the list), which is fine because US-13 comes first in the order. Negotiable: the offer text and link are open. Valuable: on its own it already fills freed slots. Estimable and Small: yes, a few days. Testable: Exercise 1 already gave its scenario. The proposed priorities go to Nadia: as Product Owner, she orders the backlog. If she says "US-14 without expiry is enough for the first week", US-15 waits and nothing is lost, which is the point of a vertical split.
Exercise 3: a PERT estimate for the release
Task. Farhan and Aiko give three-point estimates for the work. Assume each task needs the one before it, so they form one chain. Compute the expected time and spread for each task and for the chain, and write one sentence for Nadia (as on Planning, Estimation and Scheduling).
Solution. Expected time E = (O + 4M + P) / 6, spread SD ≈ (P − O) / 6; for a chain, add the E values and the squared SDs, then take the square root.
import math
def pert(o, m, p):
"""Three-point (PERT) estimate: expected time and a rough standard deviation."""
return (o + 4 * m + p) / 6, (p - o) / 6
# Waiting-list release: (optimistic, most likely, pessimistic) in working days
estimates = {
"list_schema": (1, 1, 2),
"join_list": (1, 2, 4),
"offer_logic": (2, 3, 8),
"list_ui": (1, 2, 3),
"testing": (1, 2, 4),
}
total, variance = 0.0, 0.0
for name, (o, m, p) in estimates.items():
e, sd = pert(o, m, p)
total += e
variance += sd ** 2
print(f"{name:<12} O={o} M={m} P={p} expected={e:.2f} sd={sd:.2f}")
sd_chain = math.sqrt(variance)
print(f"chain expected={total:.2f} sd={sd_chain:.2f}")
print(f"most likely sum {sum(m for _, m, _ in estimates.values())} days; "
f"say {total:.0f} to {math.ceil(total + 2 * sd_chain)} working days")list_schema O=1 M=1 P=2 expected=1.17 sd=0.17
join_list O=1 M=2 P=4 expected=2.17 sd=0.50
offer_logic O=2 M=3 P=8 expected=3.67 sd=1.00
list_ui O=1 M=2 P=3 expected=2.00 sd=0.33
testing O=1 M=2 P=4 expected=2.17 sd=0.50
chain expected=11.17 sd=1.28
most likely sum 10 days; say 11 to 14 working daysThe most likely values add up to 10 days, but the expected chain is about 11.2, because the offer logic (timers, two patients accepting at once) has a long pessimistic tail. Adding two chain SDs gives about 13.7, so the sentence for Nadia is: "Most likely about 11 working days; plan for up to 14." Lena keeps the difference as one visible buffer, not hidden padding in each task.
Exercise 4: score and sort a risk register
Task. The team lists six risks for the waiting list. Score each one (probability × impact on 1 to 5), apply the same bands as on Risk Management (12 or more is HIGH, 6 to 11 MEDIUM, 5 or less LOW, and any impact of 5 is HIGH), and sort with the most serious first.
# Waiting-list risks (invented). Probability and impact on a 1-5 scale.
risks = [
{"id": "W1", "risk": "Two patients accept the same freed slot", "p": 2, "i": 4,
"response": "reduce", "owner": "Farhan"},
{"id": "W2", "risk": "Offer SMS arrives after the slot has passed", "p": 3, "i": 3,
"response": "reduce", "owner": "Kwame"},
{"id": "W3", "risk": "Patients ignore offers; slots stay empty", "p": 3, "i": 2,
"response": "accept", "owner": "Rina"},
{"id": "W4", "risk": "Waiting-list phone numbers kept for months", "p": 2, "i": 5,
"response": "reduce", "owner": "Farhan"},
{"id": "W5", "risk": "Farhan is on leave in week 2", "p": 4, "i": 3,
"response": "reduce", "owner": "Lena"},
{"id": "W6", "risk": "Extra SMS messages raise the clinic's bill", "p": 2, "i": 2,
"response": "accept", "owner": "Nadia"},
]
def level(p, i):
"""Score = probability x impact; 12 or more, or any impact of 5, is HIGH."""
score = p * i
if score >= 12 or i == 5:
return score, "HIGH"
return score, "MEDIUM" if score >= 6 else "LOW"
for r in sorted(risks, key=lambda r: (-r["p"] * r["i"], r["id"])):
score, lvl = level(r["p"], r["i"])
print(f"{r['id']} {r['risk']:<44} {score:>2} {lvl:<6} {r['response']:<6} {r['owner']}")W5 Farhan is on leave in week 2 12 HIGH reduce Lena
W4 Waiting-list phone numbers kept for months 10 HIGH reduce Farhan
W2 Offer SMS arrives after the slot has passed 9 MEDIUM reduce Kwame
W1 Two patients accept the same freed slot 8 MEDIUM reduce Farhan
W3 Patients ignore offers; slots stay empty 6 MEDIUM accept Rina
W6 Extra SMS messages raise the clinic's bill 4 LOW accept NadiaHow to read it: W5 (Farhan on leave during the offer-logic work) is the top risk, so Lena reduces it by having Aiko pair with Farhan on that code in week 1. W4 scores only 10 but is HIGH because of the impact-5 rule: keeping phone numbers longer than needed is a privacy risk, so the response is to delete waiting-list entries at the end of each day. W1 is MEDIUM, but the cheap response is obvious (the same database rule that already stops double bookings), so it is worth doing anyway. W3 and W6 are accepted with a reason, and the owners are spread across the team instead of all landing on Farhan.
Exercise 5: boundary-value tests
Task. A cancellation frees a slot for the waiting list, so the cancellation rule matters more now. Nadia's rule: online cancellation is allowed up to and including 2 hours before the visit. Choose test values with equivalence partitioning and boundary value analysis, and write them as a unittest suite (as on Software Quality, Testing and QA).
Solution. Work in minutes before the visit. Two partitions: allowed (120 and more) and refused (below 120, including a visit that has already started). The edge is between 119 and 120, so test 119, 120 and 121, plus one value from deep inside each partition.
import io
import unittest
CANCEL_LIMIT_MINUTES = 120
def can_cancel(minutes_before):
"""Online cancellation is allowed up to and including 2 hours before the visit."""
return minutes_before >= CANCEL_LIMIT_MINUTES
class TestCanCancel(unittest.TestCase):
def test_one_minute_too_late(self):
self.assertFalse(can_cancel(119), "119 minutes before: phone the desk")
def test_exactly_two_hours(self):
self.assertTrue(can_cancel(120), "exactly 2 hours before is still allowed")
def test_one_minute_inside(self):
self.assertTrue(can_cancel(121), "121 minutes before is allowed")
def test_visit_already_started(self):
self.assertFalse(can_cancel(-10), "after the start time: refused")
def test_day_before(self):
self.assertTrue(can_cancel(1440), "a day before is allowed")
def run_tests(case):
"""Run one TestCase class; print one line per test and a summary without timings."""
suite = unittest.defaultTestLoader.loadTestsFromTestCase(case)
names = [test.id() for test in suite]
result = unittest.TextTestRunner(stream=io.StringIO(), verbosity=2).run(suite)
failed = {test.id() for test, _ in result.failures + result.errors}
for name in names:
print("FAIL" if name in failed else "ok ", name.split(".")[-1])
print("all passed:", result.wasSuccessful(), "| tests run:", result.testsRun)
run_tests(TestCanCancel)ok test_day_before
ok test_exactly_two_hours
ok test_one_minute_inside
ok test_one_minute_too_late
ok test_visit_already_started
all passed: True | tests run: 5Now check that the tests can actually catch a mistake. Replace the rule with a version that looks almost the same:
def can_cancel(minutes_before):
"""A tempting rewrite with a slip: > instead of >=."""
return minutes_before > CANCEL_LIMIT_MINUTES
run_tests(TestCanCancel)ok test_day_before
FAIL test_exactly_two_hours
ok test_one_minute_inside
ok test_one_minute_too_late
ok test_visit_already_started
all passed: False | tests run: 5Only the boundary test at exactly 120 minutes fails. A suite with only "a day before" and "after the start" would have passed and the slip would have reached patients. Breaking the code on purpose, once, is a quick way to see that your tests test something.
Capstone: plan your own project
Now plan a project of your own from start to finish in one file. You do not need a team or a customer to do it well: you can play the roles yourself, but write down who would hold each one.
Choosing a project
- Small: something one to three people could build in two to six weeks. Smaller is better for a first plan.
- Real users: ideally a real person who has the problem: a shop that takes orders by phone, a tuition centre's attendance sheet, a club's event sign-up, a family's shared expenses.
- A clear "done": you can imagine the day someone uses it for the first time.
The project file template
Copy the template into a text file or document and fill each section. Each line names the page where the technique was taught.
Template:
PROJECT FILE: <project name> version <n>, <ISO date>
1 Problem statement (p01, p05)
Who has which problem today, and how will we know it is solved? (2-4 sentences)
2 Stakeholders (p05, p08)
Name or role | what they need | how involved (decides / is consulted / is informed)
3 Requirements with acceptance criteria (p06)
REQ-nn "shall" statements, functional and non-functional (with numbers),
plus Given/When/Then scenarios for the most important ones, unhappy paths included
4 Prioritised backlog (p07)
Product Goal; vertical user stories in order, each with MoSCoW and a size
5 Process choice with reason (p03, p04)
Model or method, iteration length, and WHY it fits this project and team
6 Plan and estimate (p09)
Work breakdown, three-point estimates for the critical chain, milestones, one buffer
7 Risk register (p10)
id | risk | P | I | score | response | owner; review date
8 Design sketch (p11, p12)
Layers or modules in a plain-text diagram; main entities and relationships
9 Test plan (p15)
Test levels; boundary values for the key rules; who tests; Definition of Done (p14)
10 Release plan (p16)
Version number, environments, release notes outline, rollback plan, who maintains itA filled example: the ClinicQueue waiting list
Here is the file the team wrote for the waiting-list release, reusing your lab answers. A real file would be longer in sections 3 and 4; this one is shortened so you can see all ten sections at once.
Example:
PROJECT FILE: ClinicQueue waiting list version 1, 2027-01-04
1 Problem: on full days, late cancellations leave empty slots while other patients wanted
one. Solved when most freed slots are rebooked through the list (Nadia checks weekly).
2 Stakeholders: Nadia (decides priorities, accepts the release); patients (join, accept
offers); Rina (sees the list, phones patients without SMS); Dr. Rahman (informed).
3 Requirements: REQ-21 offer within 5 min; REQ-22 30-min hold, then next patient; REQ-23
join in at most 2 steps. Scenarios: "first patient accepts", "offer expires".
Non-functional: waiting-list entries deleted at the end of each day (privacy).
4 Backlog (Product Goal: freed slots are used): US-13 Must, US-14 Must, US-15 Should,
US-16 Should, US-17 Could. Nadia orders it; developers size it.
5 Process: Scrum as before, 2-week sprints, Lena as Scrum Master. Reason: same team,
requirements still moving (the 30-minute rule is new), Nadia available every review.
6 Plan: chain list_schema -> join_list -> offer_logic -> list_ui -> testing.
PERT: expected 11.2 days, SD 1.3; promise "up to 14 working days" (3-day buffer).
Milestones: M1 offer SMS sent in staging; M2 Nadia accepts in staging; M3 live.
7 Risks: W5 Farhan on leave (HIGH, pairing with Aiko); W4 phone numbers kept (HIGH,
delete daily); W2, W1, W3 MEDIUM; W6 LOW. Review every Friday.
8 Design: new waiting_list module in the logic layer; WaitingEntry entity
(patient, doctor, day, position, offered_at); SMS through the existing adapter.
9 Tests: unit tests on offer order, 30-min expiry (29, 30, 31 min) and the 2-hour
cancel rule (119, 120, 121 min); system test of the whole offer flow; Kwame owns them.
Done = reviewed, tests pass, deployed to staging, release notes updated.
10 Release: 2.1.0 (new feature, backwards compatible). Staging check, then production.
Rollback: switch the waiting list off with its setting; redeploy 2.0.0 if needed.
Release notes for Rina: "Full days now offer a waiting list".Notice how much of the file came straight from the lab. That is the real lesson: the techniques are not separate chapters but one chain, where each step's output feeds the next.
Checking your file
Before you call your plan finished, review it as a stranger would. If you can, ask a friend to read it and answer these questions without your help.
| Section | Question to ask | Warning sign |
|---|---|---|
| Problem | Could someone tell whether the project succeeded? | "Build an app for X" with no measure |
| Requirements | Can each one pass or fail a test? | "fast", "easy", "secure" without numbers |
| Backlog | Does the first story give a user something working? | First items are "database" and "API" |
| Process | Is there a reason, not just a name? | "Agile" with no iteration length or reason |
| Estimate | Is it a range with the assumptions written? | One date, no buffer, testing missing |
| Risks | Does every HIGH risk have a response and an owner? | All risks owned by one person |
| Tests and release | Are the rule edges tested, and can you roll back? | Only happy-path tests; no previous version kept |
How detailed should the file be? Practitioners disagree, as you saw on Requirements Engineering: Finding Out What to Build and Agile, Scrum and Kanban. A one-person hobby project may need only sections 1, 3, 4 and 9 on one page; a paid project for a client needs all ten, because the file is also how you agree scope and dates. Write as much as helps the people who will read it, and update it when things change instead of letting it go stale.
Cheat sheet: the whole tutorial
| Page | Title | The idea to keep |
|---|---|---|
| 1 | What Software Engineering Is, and Why Coding Is Not Enough | Software engineering is building software that others rely on, with a team, over time |
| 2 | The Software Development Life Cycle (SDLC) | Every project does feasibility, requirements, design, building, testing, release and maintenance in some form |
| 3 | Process Models: Waterfall, Incremental, RAD and Big Bang | Choose a model by how stable the requirements are and how costly change is |
| 4 | Agile, Scrum and Kanban | Scrum: 3 accountabilities, 5 events, 3 artifacts (2020 Guide); Kanban: visualise, limit work in progress |
| 5 | Requirements Engineering: Finding Out What to Build | Find all stakeholders, elicit needs (not solutions), validate, manage changes |
| 6 | Functional and Non-functional Requirements, and Acceptance Criteria | Testable "shall" statements with numbers; Given/When/Then scenarios |
| 7 | User Stories, Use Cases and Prioritising | Three Cs, INVEST, vertical splits, MoSCoW, one ordered backlog |
| 8 | Project Management and the Roles in a Software Team | Balance scope, time, cost and quality; clear roles; RACI; manage change openly |
| 9 | Planning, Estimation and Scheduling | WBS, PERT (O + 4M + P) / 6, estimates as ranges, critical path, one buffer |
| 10 | Risk Management | Identify, analyse (P × I), respond (avoid, reduce, transfer, accept), monitor; one owner each |
| 11 | Software Design Basics: From Requirements to Modules | High cohesion, low coupling, layers, interfaces, design for change |
| 12 | Data Modelling with Entity–Relationship Diagrams | Entities, keys, cardinality; many-to-many needs a link table |
| 13 | Writing Maintainable Code | Clear names, small functions, style guide (PEP 8), refactor in small tested steps |
| 14 | Code Review, Version Control and Team Workflow | Small pull requests, kind specific reviews, releasable main, a Definition of Done |
| 15 | Software Quality, Testing and QA | Test levels, partitions and boundaries, regression tests, severity versus priority |
| 16 | Releasing and Maintaining Software | SemVer, release notes, rollback plan, environments, technical debt |
| 17 | Software Engineering with AI Coding Assistants | You own the code: review it, test it, keep secrets out, mind licences |
| 18 | Practice Lab and Capstone: Plan a Small Project End to End | All the steps form one chain; write the plan in one file and keep it current |
Where to go next
This course is the first topic of the Skills track. The courses below are coming next in the Skills track; they are not published yet.
- Software Engineering Foundations: Advanced continues this course with larger projects and deeper practice.
- Data Structures and Algorithms: choosing the right way to store and process data, for code that stays fast as the data grows, and a common topic in technical interviews.
- DevOps for AI Builders: automating builds, tests, releases and monitoring, so that more of the release plan in section 10 runs automatically.
- System Design for AI Apps: designing systems bigger than one application with layers, the next step after page 11.
Meanwhile, the best next step is the capstone itself: plan one real project, build its first story, and compare what happened with the plan. That comparison will teach you more than any further reading.
Where this shows up at work
- A freelancer's proposal is a short project file: problem, scope as a backlog, a ranged estimate, risks and how the work will be delivered.
- A team starting a new feature writes a one-page plan, often called a brief or design document, before the first sprint.
- In job interviews, being able to walk through how you planned, tested and released one project often matters as much as the code itself.
- A student or portfolio project with a clear plan, tests and release notes stands out because it shows engineering, not only coding.
Common mistakes
- Planning a project that is too big. A first capstone with ten features never gets finished, and nothing is learned about releasing. Fix: cut to one Must-have story that works end to end, and plan more only after it ships.
- Filling the template once and never touching it again. The plan goes stale in a week and stops guiding anything. Fix: put a version and date on the file, and update the estimate and risks at every review.
- Copying the ClinicQueue numbers. They are invented for this course. Fix: ask your own users for numbers, and make your own three-point estimates.
- Treating the exercises as separate. A requirement without acceptance criteria cannot be tested, and an estimate without a backlog has nothing to estimate. Fix: let each section use the previous one, as the example file does.
- Writing a reason for the process that is only a label. "We use Agile" says nothing. Fix: name the iteration length and the fact about your project that makes it fit.
Try it yourself
- Easy: Rina says: "The waiting list on the queue screen should update fast and be easy to read." Rewrite this as two testable "shall" requirements.
- Medium: Kwame adds a task to the end of the waiting-list chain: "acceptance test with Nadia", with O = 1, M = 1, P = 3 days. Compute its PERT expected time and SD, then the new chain expected time and SD (the earlier chain is 11.17 days with SD 1.28). Does the promise "up to 14 working days" still hold if you keep using expected + 2 SD?
- Hard: A friend shows you this excerpt of their capstone file for a tuition centre's attendance app: "Problem: make an attendance app. Requirements: it must be fast and secure. Process: Agile. Estimate: done on 2027-03-01. Risks: none. Tests: we will test it at the end." Write a short, kind review: at least four problems, each with a concrete improvement.
Answers
- Model answer: "REQ-24: The queue screen shall show a new waiting-list entry within 5 seconds of a patient joining the list." "REQ-25: The waiting-list panel shall show each entry's position, patient first name and doctor in text that Rina can read from 2 metres away, which is checked with Rina at the screen in a demo." A good answer replaces "fast" and "easy to read" with a measure and a check, names the actor or system, and keeps one requirement per statement. The 5 seconds matches the queue-screen requirement from earlier pages; the exact numbers must be agreed with Rina and Nadia.
- E = (1 + 4 × 1 + 3) / 6 = 8 / 6 ≈ 1.33 days; SD = (3 − 1) / 6 ≈ 0.33. New chain E = 11.17 + 1.33 = 12.50 days. New SD = √(1.28² + 0.33²) = √(1.6384 + 0.1089) = √1.7473 ≈ 1.32. Expected + 2 SD = 12.50 + 2.64 = 15.14, so "up to 14" no longer holds: Lena should tell Nadia "most likely about 12 or 13 working days, plan for up to 16" (or cut scope, for example by moving US-15 to the next release). The added task is short, but it sits on the chain, so it moves the date.
- Model answer: "Thanks for sharing; here is what I would change. (1) Problem: say who has which problem today, for example 'teachers spend 10 minutes per class on a paper register, and parents are not told about absences', and how you will know it is solved. (2) Requirements: 'fast' and 'secure' cannot be tested; for example 'the class list shall load within 3 seconds on a phone' and 'only the class teacher and the centre manager shall see a student's attendance'. Add Given/When/Then for marking a student absent. (3) Process: say which method, the iteration length and why, for example 'one-week iterations, because the centre manager can try each version on Saturday'. (4) Estimate: one date with no range or breakdown; list the tasks, give three-point estimates and a range with a buffer. (5) Risks: 'none' is itself a risk; at least the students' personal data, and your own availability during exams. (6) Tests: testing only at the end finds problems late; write boundary tests for the rules (for example the time after which a student counts as late) as you build each story." A good answer contains at least four of these, each with a concrete replacement rather than "make it better", and a respectful tone.
Summary
- The lab repeated five core techniques on one feature: testable requirements with Given/When/Then, vertical story splits with MoSCoW, PERT estimates as ranges, a scored and sorted risk register, and boundary-value tests that can catch a real slip.
- The steps form one chain: each output (requirement, story, estimate, risk, test) is the input of the next.
- The capstone project file has ten sections, from problem statement to release plan; keep it short, give reasons, and update it as you learn.
- The cheat sheet maps every page of this tutorial to the one idea worth keeping.
Next: plan and build your own capstone project. Then continue with Software Engineering Foundations: Advanced and the other Skills topics, Data Structures and Algorithms, DevOps for AI Builders and System Design for AI Apps, all coming next in the Skills track.

