JAVA-290 · Lesson 4 of 12 · 35 min
Project planning and team workflow
▶ Video coming soon A video version of this lesson is on the way.
By the end of May the team knew what to build and how it would fit together. On Wednesday, May 31, 2028, they had to decide how three people with jobs, different schedules and one shared repository would actually build it, in what order, and how they would know each week whether they were on track. Ingrid began the evening by saying that most student teams she had mentored did not fail at programming but at coordination: two people building the same thing, work that sat unreviewed for a week, and a final fortnight of panic because nobody had noticed the plan was slipping until it had slipped.
Choosing a way of working
The two best-known agile approaches are Scrum and Kanban. Scrum, defined in the Scrum Guide by Ken Schwaber and Jeff Sutherland, most recently revised in 2020, organizes work into sprints of fixed length, at most a month, each with a sprint goal, a planning meeting at the start, a short daily meeting, a review with stakeholders at the end and a retrospective in which the team improves its own process. Kanban, as David Anderson described it for software in 2010, has no sprints: work flows continuously across a board, and the team limits how many items may be in each stage at once.
The team took pieces of both, which is common and nothing to apologize for. From Scrum they took two-week sprints, a sprint goal, a review with the clients at the end of each sprint and a retrospective; the fixed rhythm suited a client who could meet only every other Wednesday. From Kanban they took the board with work-in-progress limits, because with three part-time people the biggest risk was starting too much and finishing too little. Odile acted as the product owner, the one person who decides the order of the work; Ingrid was a mentor, not a manager, and attended as a guest.
| Event | When | Who | Output |
|---|---|---|---|
| Sprint planning | First Thursday of the sprint, 19:00, video call, 45 min | Team; Odile for the first 15 min | Sprint goal and selected stories |
| Daily check-in | Each weekday by 21:00, written in the team channel | Team | Done, next, blocked |
| Mentor evening | Every Wednesday, 18:30 to 20:30, back room | Team and Ingrid; Leif when needed | Design help, reviews, unblocking |
| Sprint review | Last Wednesday of the sprint, first hour of the evening | Team, clients, Ingrid | Feedback on working software on staging |
| Retrospective | Same Wednesday, after the review, 30 min | Team only | One or two changes to how they work |
The written daily check-in was Thierry's suggestion. A spoken stand-up was impossible with his warehouse shifts, and a written one had the advantage of leaving a record. Each person posted three short lines: what I finished, what I will do next, and anything blocking me. The rule was that a blocking line got an answer from a teammate before the next evening.
Sprints and goals
A sprint goal is a single sentence describing what the sprint will achieve for users, not a list of tasks. It gives the team a way to decide, mid-sprint, what to drop when something takes longer than planned: anything not needed for the goal goes first. The team planned five building sprints, from Thursday, June 1 to Wednesday, August 9, leaving the last two weeks of the term for release, documentation and demo day.
| Sprint | Dates | Goal |
|---|---|---|
| 1 | Thu Jun 1 to Wed Jun 14 | A customer can see the next free times on staging, and the new tables exist |
| 2 | Thu Jun 15 to Wed Jun 28 | A customer can book, find and cancel a repair on staging |
| 3 | Thu Jun 29 to Wed Jul 12 | The counter can run a whole day from the staff pages |
| 4 | Thu Jul 13 to Wed Jul 26 | Customers get reminders and Odile gets her figures; every page passes the accessibility checks |
| 5 | Thu Jul 27 to Wed Aug 9 | Security review fixed; the website is ready for its first customers |
| Release | Thu Aug 10 to Fri Aug 25 | Production, handover, documentation, demo day on Wed Aug 23 |
Sprint 1's goal deserves comment. It asks for very little: one read-only page, on staging. That was deliberate. Alistair Cockburn called this a walking skeleton: the thinnest possible version of the system that runs end to end, from the browser through every layer to the database and out through the real pipeline to a real server. Building it first flushes out the problems of integration and deployment while they are cheap, and every later story then adds flesh to a skeleton that already walks.
Estimating with story points
To plan sprints, the team needed sizes. People are poor at estimating work in hours, especially for work they have not done before, but they are reasonably good at comparing: this story is about twice as big as that one. Story points use that ability. The team picks a small, well-understood reference story, gives it a size, and sizes every other story relative to it, using a coarse scale such as 1, 2, 3, 5, 8 and 13, so that nobody wastes time arguing whether something is a 6 or a 7. The gaps grow with size because uncertainty does.
They estimated with planning poker, a technique James Grenning described in 2002 and Mike Cohn popularized. Each person holds cards with the scale's numbers. For each story, the client answers questions, then everyone chooses a card in secret and all reveal at once. If the numbers agree, that is the estimate. If they differ, the people with the highest and lowest cards explain their thinking, which usually uncovers something only one of them had noticed, and the team votes again. The reference story was US-04, the limit of two bookings per phone, which already half existed in version 1.5.0; they called it a 2.
import java.util.*;
public class Main {
static final int[] SCALE = {1, 2, 3, 5, 8, 13};
static String round(String story, Map<String, Integer> votes) {
for (int v : votes.values())
if (Arrays.binarySearch(SCALE, v) < 0) return story + ": " + v + " is not on the scale; vote again";
int min = Collections.min(votes.values()), max = Collections.max(votes.values());
int lo = Arrays.binarySearch(SCALE, min), hi = Arrays.binarySearch(SCALE, max);
if (hi - lo == 0) return story + ": agreed on " + min;
if (hi - lo == 1) return story + ": close, take the larger: " + max;
String low = votes.entrySet().stream().filter(e -> e.getValue() == min).map(Map.Entry::getKey).findFirst().get();
String high = votes.entrySet().stream().filter(e -> e.getValue() == max).map(Map.Entry::getKey).findFirst().get();
return story + ": spread " + min + " to " + max + "; " + low + " and " + high + " explain, then vote again";
}
static Map<String, Integer> votes(int hamza, int noemi, int thierry) {
Map<String, Integer> v = new LinkedHashMap<>();
v.put("Hamza", hamza); v.put("Noemi", noemi); v.put("Thierry", thierry);
return v;
}
public static void main(String[] args) {
System.out.println(round("US-01 see free times", votes(3, 3, 3)));
System.out.println(round("US-03 find and cancel", votes(3, 5, 5)));
System.out.println(round("US-02 book a repair", votes(5, 13, 8)));
System.out.println(round("US-02 book a repair (second vote)", votes(8, 8, 8)));
System.out.println(round("US-06 staff day list", votes(2, 5, 4)));
}
}US-01 see free times: agreed on 3 US-03 find and cancel: close, take the larger: 5 US-02 book a repair: spread 5 to 13; Hamza and Noemi explain, then vote again US-02 book a repair (second vote): agreed on 8 US-06 staff day list: 4 is not on the scale; vote again
What this code does
Each round first refuses any card that is not on the scale, then finds the lowest and highest cards and their positions on the scale with a binary search, which works because the scale is sorted. Equal cards are an agreement, neighbors on the scale are settled by taking the larger, and anything wider means the two people at the ends explain before a second vote. The last round shows a card that is not on the scale being refused, which is how the team kept 4 out of the conversation.
The wide vote on US-02 was the most useful five minutes of the evening. Hamza had voted 5 because the booking logic already existed in the API. Noemi had voted 13 because she was thinking of the form: six fields, error messages next to each field, a confirmation page, a text with the reference and everything working with a screen reader. Both were right about their half. On the second vote everyone chose 8, and Noemi's list became the story's tasks.
| Story | Points | MoSCoW |
|---|---|---|
| US-01 see free times | 3 | Must |
| US-02 book a repair | 8 | Must |
| US-03 find and cancel | 5 | Must |
| US-04 two active bookings per phone | 2 | Must |
| US-05 accessible pages | 5 | Must |
| US-06 staff day list and check-in | 5 | Must |
| US-07 reminder text | 5 | Should |
| US-08 waiting list | 8 | Should |
| US-09 weekly figures | 2 | Should |
| US-10 stand sign-up | 5 | Could |
| US-11 second language | 8 | Could |
US-05 was an odd one to estimate, because accessibility is not a feature that is finished once. The team estimated the work that could be finished, a shared layout, form components with labels and error messages, a skip link and the automated checks in the build, and added a line to the Definition of Done so that every later story would keep the pages accessible.
Forecasting with velocity
A team's velocity is the number of story points it finishes in a sprint. A new team does not know its velocity, and the honest answer to the question of when it will finish is a range, not a date. The team guessed a velocity between 7 and 11 points per sprint from Ingrid's experience of similar teams, planned with the low end for promises and the high end for hopes, and agreed to replace the guess with real numbers after the first two sprints.
import java.util.*;
public class Main {
public static void main(String[] args) {
Map<String, Integer> must = new LinkedHashMap<>(), should = new LinkedHashMap<>();
must.put("US-01", 3); must.put("US-02", 8); must.put("US-03", 5);
must.put("US-04", 2); must.put("US-05", 5); must.put("US-06", 5);
should.put("US-07", 5); should.put("US-08", 8); should.put("US-09", 2);
int mustPts = must.values().stream().mapToInt(Integer::intValue).sum();
int shouldPts = should.values().stream().mapToInt(Integer::intValue).sum();
int sprints = 5;
System.out.println("Must " + mustPts + " points, Should " + shouldPts + " points, " + sprints + " sprints");
for (int velocity : new int[] {7, 9, 11}) {
int capacity = velocity * sprints;
int mustSprints = (mustPts + velocity - 1) / velocity;
String verdict = capacity >= mustPts + shouldPts ? "all Must and Should"
: capacity >= mustPts ? "all Must, " + (capacity - mustPts) + " points of Should"
: "NOT all Must";
System.out.printf("velocity %2d: %2d points in %d sprints; Must done after sprint %d; %s%n",
velocity, capacity, sprints, mustSprints, verdict);
}
}
}Must 28 points, Should 15 points, 5 sprints velocity 7: 35 points in 5 sprints; Must done after sprint 4; all Must, 7 points of Should velocity 9: 45 points in 5 sprints; Must done after sprint 4; all Must and Should velocity 11: 55 points in 5 sprints; Must done after sprint 3; all Must and Should
What this code does
The forecast multiplies each possible velocity by the five sprints and compares the result with the points in the Must and Should groups. The number of sprints needed for the Must stories is a ceiling division, done with whole numbers by adding velocity minus one before dividing. At the pessimistic velocity the team finishes every Must and only some Should stories, which is exactly the situation MoSCoW is designed for.
Odile looked at the output and asked the right question: if only some Should stories fit, which ones? She ordered them US-09, US-07, US-08, cheapest and most useful first, and said that the waiting list was the one she could live without until autumn. That ordering is the product owner's job, and doing it before the pressure arrives made the later sprints calmer.
The board and its limits
The team's Kanban board was a GitHub project board linked to the repository's issues, with one card per story or task. A card moves from left to right through the columns, and each column has a work-in-progress limit, the most cards it may hold. When a column is full, nobody may pull another card into it; instead, they help finish something already there. The limits feel restrictive at first. Their purpose is to expose bottlenecks, such as pull requests waiting for review, and to make the team finish work rather than start it.
The rule is easy to state and easy to break, so Hamza encoded it in a small model while the team argued about the numbers. The model also counts how long a card has been in its column, because a card that sits still is the most useful thing a board can show.
import java.util.*;
public class Main {
static final List<String> COLUMNS = List.of("Ready", "In progress", "Review", "Done");
static final Map<String, Integer> LIMIT = Map.of("In progress", 3, "Review", 2);
static final Map<String, String> where = new LinkedHashMap<>();
static void move(String card, String to) {
long there = where.values().stream().filter(to::equals).count();
Integer limit = LIMIT.get(to);
if (limit != null && there >= limit) {
System.out.println("refused: " + card + " -> " + to + " (" + there + "/" + limit + "); help finish a card in " + to);
return;
}
int from = COLUMNS.indexOf(where.get(card)), dest = COLUMNS.indexOf(to);
if (dest != from + 1) { System.out.println("refused: " + card + " cannot skip from " + where.get(card) + " to " + to); return; }
where.put(card, to);
System.out.println(card + " -> " + to);
}
public static void main(String[] args) {
for (String c : List.of("US-02a form", "US-02b confirmation", "US-02c text", "US-03a find", "US-04 limit"))
where.put(c, "Ready");
move("US-02a form", "In progress");
move("US-02b confirmation", "In progress");
move("US-04 limit", "In progress");
move("US-03a find", "In progress");
move("US-04 limit", "Review");
move("US-02a form", "Review");
move("US-02b confirmation", "Review");
move("US-02c text", "Done");
move("US-04 limit", "Done");
move("US-02b confirmation", "Review");
System.out.println(where);
}
}US-02a form -> In progress
US-02b confirmation -> In progress
US-04 limit -> In progress
refused: US-03a find -> In progress (3/3); help finish a card in In progress
US-04 limit -> Review
US-02a form -> Review
refused: US-02b confirmation -> Review (2/2); help finish a card in Review
refused: US-02c text cannot skip from Ready to Done
US-04 limit -> Done
US-02b confirmation -> Review
{US-02a form=Review, US-02b confirmation=Review, US-02c text=Ready, US-03a find=Ready, US-04 limit=Done}What this code does
The move method checks two rules before moving a card: the target column must have room under its limit, and a card may move only one column to the right, so work cannot jump past review. A refusal says what to do instead, which is the point of a limit. In the run, the fourth card cannot start until something leaves In progress, and the confirmation page waits until a review finishes and frees a place.
The limits started at 3 for In progress, one per person, and 2 for Review. Ingrid predicted that Review would be the column that filled, because reviewing feels less urgent than writing, and she was right within a week. The team's response, written into the working agreement, was that each person checks the Review column before pulling anything new.
Definition of Ready and Definition of Done
Two short lists kept the board honest. The Definition of Ready says when a story may move into Ready: it must be understood well enough to start. The Definition of Done says when a story may move into Done, and it is the more important of the two, because done is the word teams most often stretch. A story that works on a laptop but has no tests, has not been reviewed or has never been deployed is not done, it is merely written, and the undone work comes back later at a worse moment.
| Definition of Ready | Definition of Done |
|---|---|
| Has a story in the agreed template and a client who owns it | Every acceptance criterion has a passing automated test named with its ID |
| Has acceptance criteria in Given, When, Then form | Code reviewed and approved by a teammate; all review comments resolved |
| Estimated by the whole team | All checks green: build, tests, architecture rules, secret scan, accessibility |
| Small enough to finish in one sprint | Pages checked by keyboard and with a screen reader if the story changes a page |
| Open questions answered or listed | Merged to main and deployed to staging; demonstrated to the client at the review |
| README, runbook or user guide updated if behavior or operations changed |
Lists like this are checked by people, but parts of them can be checked by programs. Thierry wrote the check the pipeline would run on every pull request, reading facts about the pull request and reporting which items of the Definition of Done were missing. It cannot judge whether a review was thoughtful, but it can stop the most common slips.
import java.util.*;
import java.util.function.Predicate;
public class Main {
record PullRequest(int number, String title, String story, List<String> criteria, List<String> testedCriteria,
int approvals, boolean checksGreen, boolean changesPages, boolean manualA11yNoted) {}
record Rule(String text, Predicate<PullRequest> ok) {}
static final List<Rule> DONE = List.of(
new Rule("names a story", pr -> pr.story() != null),
new Rule("every criterion tested", pr -> pr.testedCriteria().containsAll(pr.criteria())),
new Rule("approved by a teammate", pr -> pr.approvals() >= 1),
new Rule("all checks green", PullRequest::checksGreen),
new Rule("manual accessibility check noted", pr -> !pr.changesPages() || pr.manualA11yNoted()));
static void check(PullRequest pr) {
List<String> missing = DONE.stream().filter(r -> !r.ok().test(pr)).map(Rule::text).toList();
System.out.println("#" + pr.number() + " " + pr.title() + ": " + (missing.isEmpty() ? "meets the Definition of Done" : "missing " + missing));
}
public static void main(String[] args) {
check(new PullRequest(14, "feat(site): free times page", "US-01", List.of("US-01.1", "US-01.2", "US-01.3"),
List.of("US-01.1", "US-01.2", "US-01.3"), 1, true, true, true));
check(new PullRequest(19, "feat(site): cancel booking", "US-03", List.of("US-03.1", "US-03.2", "US-03.3", "US-03.4"),
List.of("US-03.1", "US-03.3"), 0, true, true, false));
check(new PullRequest(21, "chore: bump Gradle wrapper", null, List.of(), List.of(), 1, true, false, false));
}
}#14 feat(site): free times page: meets the Definition of Done #19 feat(site): cancel booking: missing [every criterion tested, approved by a teammate, manual accessibility check noted] #21 chore: bump Gradle wrapper: missing [names a story]
What this code does
Each rule of the Definition of Done is a description and a predicate over the facts of a pull request, so adding a rule means adding one line. The check lists every rule a pull request fails, not just the first, because a developer wants the whole list at once. Pull request 21 shows a real gap in the rules: maintenance work has no story, so the team later added an exception for pull requests labelled chore.
Branches, commits and reviews
For the repository, the team kept the workflow the booking API already used, a form of trunk-based development often called GitHub flow. Main is always deployable and protected: nobody pushes to it directly. Each piece of work happens on a short-lived branch named after its story, which lives for a day or two, not a week, and returns to main through a pull request that needs one approval and green checks. Short branches matter more than any naming rule, because the longer a branch lives, the more it diverges from what everyone else is doing and the more painful its merge.
| Convention | Rule | Example |
|---|---|---|
| Branch name | Story ID in lower case, a slash, a few words | us-03/cancel-page |
| Commit message | Conventional Commits type and scope, then a summary in the imperative | feat(site): show the cancel confirmation |
| Story reference | A Refs footer naming the story | Refs: US-03 |
| Pull request | Title as a commit message; description says what, why and how to test; links the issue | Closes #31 |
| Merging | Squash merge after one approval and green checks; the author merges |
The commit format was the one from the deployment course, Conventional Commits 1.0.0, which the release workflow already used to write release notes. The new part was the story reference, so that the history could answer which commits delivered US-03. A check in the pipeline enforced both, because a convention that relies on memory lasts about a week.
import java.util.*;
import java.util.regex.*;
public class Main {
static final Pattern BRANCH = Pattern.compile("(us-\\d{2}|chore|fix)/[a-z0-9-]{3,40}");
static final Pattern SUBJECT = Pattern.compile("(feat|fix|test|docs|refactor|chore|ci)(\\([a-z-]+\\))?!?: [a-z].{2,70}");
static final Pattern REFS = Pattern.compile("^Refs: US-\\d{2}$", Pattern.MULTILINE);
static List<String> check(String branch, String message) {
List<String> problems = new ArrayList<>();
if (!BRANCH.matcher(branch).matches()) problems.add("branch name");
String subject = message.lines().findFirst().orElse("");
if (!SUBJECT.matcher(subject).matches()) problems.add("subject line");
if (subject.endsWith(".")) problems.add("subject ends with a full stop");
if (branch.startsWith("us-") && !REFS.matcher(message).find()) problems.add("missing Refs footer");
return problems;
}
public static void main(String[] args) {
String[][] cases = {
{"us-03/cancel-page", "feat(site): show the cancel confirmation\n\nRefs: US-03"},
{"us-03/cancel-page", "feat(site): show the cancel confirmation"},
{"hamza-stuff", "Fixed things."},
{"fix/holiday-slots", "fix(domain): treat public holidays as closed"},
{"us-08/waitlist", "feat(site)!: replace the full-day page\n\nBREAKING CHANGE: new URL\nRefs: US-08"}};
for (String[] c : cases) {
List<String> p = check(c[0], c[1]);
System.out.println(c[0] + ": " + (p.isEmpty() ? "ok" : String.join(", ", p)));
}
}
}us-03/cancel-page: ok us-03/cancel-page: missing Refs footer hamza-stuff: branch name, subject line, subject ends with a full stop fix/holiday-slots: ok us-08/waitlist: ok
What this code does
Three regular expressions encode the conventions: the branch name, the subject line's type, optional scope, optional exclamation mark for a breaking change and a lower-case summary, and the Refs footer on a line of its own. MULTILINE makes the caret and dollar match at line boundaries, so the footer can sit anywhere after the subject. The third case fails three ways at once, and the last shows that a breaking change still needs its story reference.
How the team reviewed code
Code review in a three-person team is not mainly about catching bugs, although it catches some. It spreads knowledge, so that nobody is the only person who understands a part of the system, and it keeps the code consistent. Thierry, who had read more of other people's code than anyone, proposed the team's review guidelines, which fit on one screen.
| Reviewer | Author |
|---|---|
| Review within one working day; say when you cannot | Keep pull requests small: under about 300 changed lines |
| Read the story and criteria first, then the tests, then the code | Explain what, why and how to test in the description |
| Ask questions rather than give orders; say which comments block merging | Answer every comment, even with "done" |
| Run it if it changes a page | Do not take comments personally; the code is the team's |
| Approve when it is good enough, not when it is how you would have written it | Merge it yourself once approved and green |
The most important line is the last one in the left column. A reviewer who withholds approval until the code matches their own taste slows everything and teaches the author nothing. Comments that are preferences, not problems, were to be marked as such, with the word nit at the start, and never blocked a merge. Ingrid added that the best way to keep reviews quick is pairing on anything hard: two people writing it together are already reviewing it.
Risks and the working agreement
Before the evening ended, the team wrote down what could go wrong and what they would do about it. A risk register is a short list of risks, each with its likelihood, its impact, an owner and a response. Its value is that the response is decided calmly in May, not improvised in August.
| Risk | Likelihood | Impact | Response | Owner |
|---|---|---|---|---|
| Someone is unavailable for a week or more | High | Medium | No area known by only one person; pairing; small pull requests | Hamza |
| Reviews pile up | High | Medium | Review limit of 2; check Review before starting new work | Thierry |
| Changes to the API break the counter app | Medium | High | Contract tests for the REST endpoints run in every build | Hamza |
| Accessibility problems found late | Medium | High | Automated checks from sprint 1; screen reader check in the Definition of Done | Noemi |
| Clients cannot attend a review | Medium | Low | Record a short video of the demo on staging; decisions wait for Odile | Noemi |
| The SMS provider changes or fails | Low | Medium | Texts go through the outbox and Notifier port; bookings never depend on them | Thierry |
The last document of the evening was a working agreement: a handful of rules the team made for itself about how to treat each other and the work. It included answering a teammate's question within a day, not merging after ten at night when nobody can watch staging, keeping personal data out of the chat, and saying early, without embarrassment, when a task was going badly. Ingrid asked them to sign it, half as a joke, and they did.
Exercises
Try it yourself
Respect the limits
The board starts with every card in Ready. Complete move so that a card moves to to only if that column has fewer cards than its limit in LIMIT (columns without a limit accept any number); otherwise it prints refused CARD -> COLUMN. A successful move prints CARD -> COLUMN. Do not check the column order in this exercise.
import java.util.*;
public class Main {
static final Map<String, Integer> LIMIT = Map.of("In progress", 2, "Review", 1);
static final Map<String, String> where = new LinkedHashMap<>();
static void move(String card, String to) {
where.put(card, to);
System.out.println(card + " -> " + to);
}
public static void main(String[] args) {
for (String c : List.of("A", "B", "C", "D")) where.put(c, "Ready");
move("A", "In progress"); move("B", "In progress"); move("C", "In progress");
move("A", "Review"); move("B", "Review"); move("A", "Done"); move("B", "Review");
move("C", "In progress");
System.out.println(where);
}
}Try it yourself
When will the Must stories be done?
The Must stories total mustPoints. The team has finished two sprints with velocities 6 and 10. Complete main so that it prints the average velocity (integer division), then for the low (6), average and high (10) velocity the number of sprints needed to finish the Must stories, rounding up, in the form velocity 6: 5 sprints.
public class Main {
public static void main(String[] args) {
int mustPoints = 28;
int[] done = {6, 10};
System.out.println("average velocity: 0");
}
}On Thursday, June 1, at seven in the evening, the first sprint planning took forty minutes. The goal was the walking skeleton: free times on a page on staging, and the new tables in the database. Hamza took the slots page, Thierry the migrations and Noemi the shared layout and the accessibility checks in the build. The board had six cards, and the In progress column had room for exactly three.
Common mistakes
MistakePlanning sprints as lists of tasks.
InsteadGive each sprint a one-sentence goal for users, and drop whatever the goal does not need when time runs short.
MistakeEstimating new work in hours.
InsteadSize stories relative to a reference story in points, with planning poker so outliers explain their thinking.
MistakePromising a date from a guessed velocity.
InsteadForecast a range from low and high velocities and replace the guess with measured velocity after two sprints.
MistakeStarting a new card while others wait for review.
InsteadRespect work-in-progress limits and help finish what is already in progress.
MistakeCalling a story done when the code works on a laptop.
InsteadUse a Definition of Done that includes tests, review, green checks, staging and documentation.
MistakeLong-lived feature branches.
InsteadKeep branches to a day or two and merge to a protected, always-deployable main through small pull requests.
Summary and key terms
- The team combined Scrum's two-week sprints, sprint goals, reviews and retrospectives with Kanban's board and work-in-progress limits, with Odile as product owner.
- Sprint 1 aimed at a walking skeleton that runs end to end through the real pipeline.
- Stories were sized in points relative to a reference story using planning poker, where outliers explain before a second vote.
- A guessed velocity range gave a forecast range: every Must story at the low end and some Should stories, which Odile then ordered.
- The board's limits expose bottlenecks such as unreviewed pull requests.
- A Definition of Ready says when a story can start, and a Definition of Done, partly checked by the pipeline, says when it is finished.
- The repository uses short branches named by story, Conventional Commits with a Refs footer, small pull requests with one approval and green checks, and review guidelines that separate problems from preferences.
- A risk register and a working agreement completed the plan.
- Scrum
- An agile framework of fixed-length sprints with planning, daily check-ins, a review and a retrospective.
- Kanban
- A way of managing continuous flow of work across a board with limits on work in progress.
- Sprint goal
- A one-sentence statement of what a sprint will achieve for users.
- Walking skeleton
- The thinnest version of a system that runs end to end through every layer and the real deployment.
- Story point
- A relative unit of size for stories, compared with a reference story.
- Planning poker
- Estimating by secret, simultaneous votes, with the highest and lowest voters explaining before a revote.
- Velocity
- The number of story points a team finishes in a sprint.
- Work-in-progress limit
- The most cards a column of the board may hold at once.
- Definition of Done
- The shared list of conditions a story must meet before it counts as finished.
- Trunk-based development
- Working on short-lived branches that merge often into a single, always-deployable main branch.
Practice problems
Work each problem on paper first, then reveal the answer to check.
Why did the team choose a walking skeleton for sprint 1?
Show answer
To expose integration and deployment problems early, while they are cheap, by running a thin version end to end on staging.
What should happen when planning poker votes are far apart?
Show answer
The people with the highest and lowest cards explain their reasoning, and the team votes again.
Why did the forecast give a range rather than a date?
Show answer
Because a new team's velocity is unknown; low and high velocities give a range that is updated with real numbers later.
What problem do work-in-progress limits expose?
Show answer
Bottlenecks such as pull requests waiting for review, and the habit of starting work instead of finishing it.
Why does a commit message carry a Refs footer?
Show answer
So the history can show which commits delivered each story, and a pipeline check can enforce it.
Lesson quiz · 5 questions
Score 60% or more to complete this lesson.
Create a free account to save your progress, take quizzes and earn a certificate.