The Sprint and the four Scrum events

An invented six-person Scrum Team, two Developers in Pune and two in Berlin, spends 10 of each Developer’s 80 working hours in events during a two-week Sprint: 12.5 %. The Sprint is itself a fixed-length event of one month or less, and a new one starts the moment the last ends. Inside it sit the four Scrum events. Sprint Planning agrees why the Sprint is valuable, what the team will build and how; the Daily Scrum keeps the plan honest each day; the Sprint Review inspects the result with stakeholders; the Sprint Retrospective decides how the team will work better.

Two harder questions follow the definitions: running each event so it ends in a decision, and fitting the events into the hours Pune and Berlin share.

The Sprint is the container, and the four Scrum events sit inside it

The 2020 Scrum Guide settles the shape in one sentence: “The Sprint is a container for all other events.” Inside a SprintSprint: A fixed-length Scrum event of one month or less that contains all the other Scrum events; a new Sprint starts immediately after the previous one ends., no change may endanger the Sprint Goal, quality does not decrease, the Product BacklogProduct Backlog: In Scrum, the emergent, ordered list of what is needed to improve the product; items are added, split and reordered as the team learns. More in “Scope statements and work breakdown structures” is refined as needed, and scope may be renegotiated with the Product Owner. Only the Product Owner may cancel a Sprint, which the Guide allows when the Sprint Goal has become obsolete.

The Daily ScrumDaily Scrum: A 15-minute event for the Developers, held every working day of the Sprint, to inspect progress toward the Sprint Goal and adapt the plan for the next day. is a 15-minute event for the Developers to adapt their plan toward the Sprint Goal. The Sprint ReviewSprint Review: The working session near the end of a Sprint in which the Scrum Team and its stakeholders inspect the Increment and decide what to do next. is a working session where the team and its stakeholders decide what to build next. The Sprint RetrospectiveSprint Retrospective: The event that concludes a Sprint, in which the Scrum Team plans ways to increase quality and effectiveness and picks the changes that would help most. plans how the team will raise quality and effectiveness. Sprint PlanningSprint Planning: The event that opens a Sprint, in which the Scrum Team agrees why the Sprint is valuable, what can be Done and how the chosen work will get done. opens the Sprint with the goal, the items and the plan. Walk through the logistics team’s Sprint:

Refinement is not an event: the Product Backlog is refined as needed, with no timebox.

Every timebox is a maximum, and a shorter Sprint shortens it

A timeboxtimebox: The maximum length of an event, not a target: an event that reaches its outcome sooner ends sooner, and one that reaches the limit stops. is the longest an event may run, not the length it should run. The Guide’s maxima are for a one-month Sprint: Sprint Planning eight hours, the Review four, the Retrospective three; shorter Sprints usually have shorter events. The Daily Scrum is the exception: 15 minutes every working day, whatever the Sprint’s length. Two weeks is half a one-month Sprint, so this team halves the three and leaves the Daily Scrum alone:

The program adds them up and checks each timebox against the Guide’s maximum:

"""Event timeboxes of an invented two-week Sprint, scaled from the 2020 Scrum Guide's maxima.

The team is invented: a logistics-tracking product built by a six-person Scrum Team, with
two of its four Developers in Pune and two in Berlin. The Scrum Guide gives the maxima for a
one-month Sprint (Sprint Planning 8 hours, Sprint Review 4 hours, Sprint Retrospective
3 hours) and a fixed 15 minutes for the Daily Scrum. A two-week Sprint is half a one-month
Sprint, so this team halves the three scaled maxima and keeps the Daily Scrum at 15 minutes.

Every number below comes from the fixed inputs: no clock, no calendar, no randomness.
Run from this folder: mise exec python@3.14.8 -- python3 events.py
"""

from decimal import Decimal

# ---- the Sprint and the team (fixed inputs) ---------------------------------------
WORKING_DAYS = 10  # two weeks of five working days
HOURS_A_DAY = Decimal("8")
DEVELOPERS = 4
# learn-lint-allow inclusive: "Scrum Master" is the 2020 Scrum Guide's name for an accountability, a proper noun, never generic wording
OTHER_MEMBERS = 2  # the Product Owner and the Scrum Master
TEAM = DEVELOPERS + OTHER_MEMBERS

# name, one-month maximum in minutes, how this Sprint sets it, times held,
# who attends ("team" = the whole Scrum Team, "devs" = the Developers)
EVENTS = [
    ("Sprint Planning", 480, "halved", 1, "team"),
    ("Daily Scrum", 15, "fixed", WORKING_DAYS, "devs"),
    ("Sprint Review", 240, "halved", 1, "team"),
    ("Sprint Retrospective", 180, "halved", 1, "team"),
]


def hours(minutes: int) -> Decimal:
    """Minutes as hours with one decimal place."""
    return (Decimal(minutes) / Decimal(60)).quantize(Decimal("0.1"))


def clock(minutes: int) -> str:
    """Minutes as "4 h" or "15 min"."""
    if minutes < 60:
        return f"{minutes} min"
    whole, rest = divmod(minutes, 60)
    return f"{whole} h" if rest == 0 else f"{whole} h {rest} min"


def scaled(maximum: int, how: str) -> int:
    return maximum // 2 if how == "halved" else maximum


def share(part: int, whole: int) -> str:
    return f"{(Decimal(part) * 100 / Decimal(whole)).quantize(Decimal('0.1'))} %"


rows = []
for name, maximum, how, times, who in EVENTS:
    this_sprint = scaled(maximum, how)
    rows.append((name, maximum, this_sprint, times, who, this_sprint * times))

print("A two-week Sprint of a six-person Scrum Team: four events and their timeboxes")
print()
head = f"{'Event':<21}{'One month':>11}{'This Sprint':>13}{'Held':>6}{'Attend':>8}{'Hours':>8}"
print(head)
print("-" * len(head))
for name, maximum, this_sprint, times, who, total in rows:
    who_label = "Team" if who == "team" else "Devs"
    print(
        f"{name:<21}{clock(maximum):>11}{clock(this_sprint):>13}"
        f"{times:>6}{who_label:>8}{str(hours(total)):>8}"
    )
print("-" * len(head))

inside = all(scaled(m, how) <= m for _, m, how, _, _ in EVENTS)
print(f"Every timebox is inside the Guide's one-month maximum: {'yes' if inside else 'no'}")
print()

# ---- what the events cost one person and the whole team ---------------------------
dev_minutes = sum(total for *_, who, total in rows if who in ("team", "devs"))
other_minutes = sum(total for *_, who, total in rows if who == "team")
sprint_minutes = int(HOURS_A_DAY) * 60 * WORKING_DAYS
team_minutes = sum(total * (TEAM if who == "team" else DEVELOPERS) for *_, who, total in rows)
team_sprint_minutes = sprint_minutes * TEAM
uncapped = sum(maximum * times for _, maximum, _, times, _ in EVENTS)

print("What the events take from the Sprint")
print()
print(f"A Developer's working hours in the Sprint: {hours(sprint_minutes)} h")
print(
    f"A Developer's event hours: {hours(dev_minutes)} h"
    f" ({share(dev_minutes, sprint_minutes)} of the Sprint)"
)
# learn-lint-allow inclusive: "Scrum Master" is the 2020 Scrum Guide's name for an accountability, a proper noun, never generic wording
label_other = "A Product Owner's or Scrum Master's event hours"
print(f"{label_other}: {hours(other_minutes)} h ({share(other_minutes, sprint_minutes)} of the Sprint)")
print(
    f"The team's event hours: {hours(team_minutes)} person-hours of {hours(team_sprint_minutes)}"
    f" ({share(team_minutes, team_sprint_minutes)})"
)
print(
    f"The same events at the one-month maxima: {hours(uncapped)} h a Developer"
    f" ({share(uncapped, sprint_minutes)} of the Sprint)"
)
print()

# ---- the hours each event leaves for the rest of the Sprint -----------------------
left = sprint_minutes - dev_minutes
print("Hours left for the work itself, per Developer")
print()
print(f"  {hours(sprint_minutes)} h of working time")
print(f"- {hours(dev_minutes)} h in the four events")
print(f"= {hours(left)} h for building the Increment ({share(left, sprint_minutes)} of the Sprint)")

A two-week Sprint of a six-person Scrum Team: four events and their timeboxes

Event                  One month  This Sprint  Held  Attend   Hours
-------------------------------------------------------------------
Sprint Planning              8 h          4 h     1    Team     4.0
Daily Scrum               15 min       15 min    10    Devs     2.5
Sprint Review                4 h          2 h     1    Team     2.0
Sprint Retrospective         3 h   1 h 30 min     1    Team     1.5
-------------------------------------------------------------------
Every timebox is inside the Guide's one-month maximum: yes

What the events take from the Sprint

A Developer's working hours in the Sprint: 80.0 h
A Developer's event hours: 10.0 h (12.5 % of the Sprint)
A Product Owner's or Scrum Master's event hours: 7.5 h (9.4 % of the Sprint)
The team's event hours: 55.0 person-hours of 480.0 (11.5 %)
The same events at the one-month maxima: 17.5 h a Developer (21.9 % of the Sprint)

Hours left for the work itself, per Developer

  80.0 h of working time
- 10.0 h in the four events
= 70.0 h for building the Increment (87.5 % of the Sprint)

Ten hours of a Developer’s 80 go to events, 12.5 %, leaving 70 for the Increment; the other two members attend 7.5 hours, because the Daily Scrum belongs to the Developers. Had the team kept the one-month maxima in a two-week Sprint, the events would take 17.5 hours, 21.9 %.

What each event must end with, and what it is not

An event that inspects without changing anything wastes its timebox. Name the outcome before booking the room:

Two of those lines surprise people who learned Scrum from older material. The 2020 revision removed the Daily Scrum’s three standard questions, leaving the structure to the Developers as long as the event tracks progress toward the Sprint Goal. And the Guide calls the Review “a working session” that should not be limited to a presentation. Sprint Planning’s three topics are why the Sprint is valuable, what can be Done against the Definition of DoneDefinition of Done: The written description of the state work must reach before it counts as finished; work that does not meet it returns to the backlog instead of being released., and how the work will get done.

Facilitating each event so it ends in a decision Pro: opens with a Pro, Premium or Ultimate pass

Scheduling events for a team across IST and Europe Pro: opens with a Pro, Premium or Ultimate pass

Practise: the Sprint, its timeboxes and the four events

Keep the maximum and the length apart, and decide each answer before you check it:

Interview questions

Warm-up: in Scrum, is a timebox a target or a maximum?

A maximum. For a one-month Sprint the Guide caps Sprint Planning at eight hours, the Review at four and the Retrospective at three, and shorter Sprints usually have shorter events; the Daily Scrum is 15 minutes at any length. An event that reaches its outcome early ends early, so a Retrospective that has its change after 40 of 90 minutes is finished. The Sprint is the exception: it is fixed length, because a cadence that stretches cannot be compared from one Sprint to the next.

Three questions an interviewer may ask about running these events follow:

Key takeaways

• The Sprint is a fixed-length event of one month or less that contains the other four; the next one starts as soon as it ends, and only the Product Owner may cancel one.
• The timeboxes are maxima for a one-month Sprint, eight, four and three hours, with the Daily Scrum fixed at 15 minutes.
• Scaled to two weeks the four Scrum events take 10 of a Developer’s 80 hours, 12.5 %, leaving 70 for the Increment.
• Each event ends in something you can name: a goal and a plan, a plan for the next day, what to build next, or a change with an owner.