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.

The team's calendar of events, agreed May 31, 2028.
EventWhenWhoOutput
Sprint planningFirst Thursday of the sprint, 19:00, video call, 45 minTeam; Odile for the first 15 minSprint goal and selected stories
Daily check-inEach weekday by 21:00, written in the team channelTeamDone, next, blocked
Mentor eveningEvery Wednesday, 18:30 to 20:30, back roomTeam and Ingrid; Leif when neededDesign help, reviews, unblocking
Sprint reviewLast Wednesday of the sprint, first hour of the eveningTeam, clients, IngridFeedback on working software on staging
RetrospectiveSame Wednesday, after the review, 30 minTeam onlyOne 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.

The plan of sprints, May 31, 2028.
SprintDatesGoal
1Thu Jun 1 to Wed Jun 14A customer can see the next free times on staging, and the new tables exist
2Thu Jun 15 to Wed Jun 28A customer can book, find and cancel a repair on staging
3Thu Jun 29 to Wed Jul 12The counter can run a whole day from the staff pages
4Thu Jul 13 to Wed Jul 26Customers get reminders and Odile gets her figures; every page passes the accessibility checks
5Thu Jul 27 to Wed Aug 9Security review fixed; the website is ready for its first customers
ReleaseThu Aug 10 to Fri Aug 25Production, handover, documentation, demo day on Wed Aug 23
A timeline of the term from May 8 to August 25, 2028. The first four weeks are marked preparation: kickoff May 10, requirements May 17, architecture May 24, planning May 31. Five two-week sprints follow from June 1 to August 9, each with its review on a Wednesday. The last two weeks are marked release, with production on August 10, handover on August 16 and demo day on August 23.
The term at a glance: preparation, five sprints and the release weeks.

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.

Java Example
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)));
    }
}
Output
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.

Estimates from May 31, 2028.
StoryPointsMoSCoW
US-01 see free times3Must
US-02 book a repair8Must
US-03 find and cancel5Must
US-04 two active bookings per phone2Must
US-05 accessible pages5Must
US-06 staff day list and check-in5Must
US-07 reminder text5Should
US-08 waiting list8Should
US-09 weekly figures2Should
US-10 stand sign-up5Could
US-11 second language8Could

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.

Java Example
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);
        }
    }
}
Output
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.

A Kanban board with five columns: Backlog, Ready, In progress with limit 3, Review with limit 2 and Done. Cards carry story identifiers and the initials of the person working on them. The Review column holds two cards and is marked full, and an arrow from a card in In progress to Review is crossed out with a note: help review first.
The team's board in sprint 2, with the Review column at its limit.

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.

Java Example
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);
    }
}
Output
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.

The two definitions, version 1, May 31, 2028.
Definition of ReadyDefinition of Done
Has a story in the agreed template and a client who owns itEvery acceptance criterion has a passing automated test named with its ID
Has acceptance criteria in Given, When, Then formCode reviewed and approved by a teammate; all review comments resolved
Estimated by the whole teamAll checks green: build, tests, architecture rules, secret scan, accessibility
Small enough to finish in one sprintPages checked by keyboard and with a screen reader if the story changes a page
Open questions answered or listedMerged 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.

Java Example
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));
    }
}
Output
#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.

The repository conventions, from the team's CONTRIBUTING.md.
ConventionRuleExample
Branch nameStory ID in lower case, a slash, a few wordsus-03/cancel-page
Commit messageConventional Commits type and scope, then a summary in the imperativefeat(site): show the cancel confirmation
Story referenceA Refs footer naming the storyRefs: US-03
Pull requestTitle as a commit message; description says what, why and how to test; links the issueCloses #31
MergingSquash 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.

Java Example
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)));
        }
    }
}
Output
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.

The team's review guidelines.
ReviewerAuthor
Review within one working day; say when you cannotKeep pull requests small: under about 300 changed lines
Read the story and criteria first, then the tests, then the codeExplain what, why and how to test in the description
Ask questions rather than give orders; say which comments block mergingAnswer every comment, even with "done"
Run it if it changes a pageDo 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 itMerge 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.

The risk register, May 31, 2028.
RiskLikelihoodImpactResponseOwner
Someone is unavailable for a week or moreHighMediumNo area known by only one person; pairing; small pull requestsHamza
Reviews pile upHighMediumReview limit of 2; check Review before starting new workThierry
Changes to the API break the counter appMediumHighContract tests for the REST endpoints run in every buildHamza
Accessibility problems found lateMediumHighAutomated checks from sprint 1; screen reader check in the Definition of DoneNoemi
Clients cannot attend a reviewMediumLowRecord a short video of the demo on staging; decisions wait for OdileNoemi
The SMS provider changes or failsLowMediumTexts go through the outbox and Notifier port; bookings never depend on themThierry

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.

  1. 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.

  2. 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.

  3. 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.

  4. 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.

  5. 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.

Take the quiz