Agile & Project Management

The Scrum Framework: Accountabilities, Events and Artefacts

Beginner8 min readUpdated

Scrum is a deliberately minimal framework for delivering product in short cycles, and most teams that struggle with it are running something else under the same name. This guide sets out exactly what the current Scrum Guide specifies, walks through a single sprint from planning to retrospective, and is explicit about the gaps Scrum leaves for you to fill.

What you will learn

  • Name the three accountabilities, five events and three artefacts and say what each is for
  • Explain the commitment attached to each artefact and why the 2020 revision added them
  • Walk through a complete sprint and identify what happens at each event
  • Write a definition of done that is honest and enforceable
  • Identify the decisions Scrum deliberately leaves open and what a team must add

Scrum is the most widely used agile framework, and also the most widely misdescribed. The document that defines it is about thirteen pages long, was last revised in November 2020, and is deliberately incomplete: it tells you what to hold, who is accountable for what, and what to inspect, then stops. Everything else — how you estimate, how you branch, whether you pair, what your board looks like — is left to the team on purpose.

That minimalism is the source of both its usefulness and its trouble. Because the framework is small, it drops into almost any organisation; because it is small, organisations fill the gaps with whatever they were doing before, and end up with weekly status meetings called stand-ups and a project plan called a backlog. This guide describes what the framework actually specifies, then walks a sprint end to end. The Scrum Master and product owner guides go deeper on those two accountabilities, and agile principles covers the values Scrum implements.

Empiricism and the three pillars

Scrum describes itself as founded on empiricism and lean thinking. Empiricism means decisions are made from what is observed rather than what was assumed, and it rests on three pillars that the events exist to serve.

Transparency. The state of the work is visible and honestly represented to everyone who needs it. A board showing six items in progress when nine are actually being worked on breaks transparency, and every inspection built on it produces the wrong conclusion.

Inspection. Progress and artefacts are examined frequently enough to detect problems while they are still cheap. Each of the five events is an inspection point with a defined subject.

Adaptation. When inspection shows a deviation, something changes — the plan, the product, the process. Inspection without the authority to adapt is theatre.

Three accountabilities

The 2020 revision removed the term "development team" as a sub-group and replaced it with one Scrum team of typically ten or fewer people, holding three accountabilities. They are accountabilities, not job titles; a person can hold one while doing other work.

Product owner. Accountable for maximising the value of the product resulting from the team's work. That means owning the product goal, ordering the product backlog, and making the content and priority of that backlog transparent. Crucially, the product owner is one person, not a committee, and the organisation must respect their decisions for the accountability to mean anything.

Scrum Master. Accountable for the team's effectiveness and for Scrum being understood and enacted, inside the team and in the wider organisation. This is a leadership role serving the team rather than directing it, and it extends outward: coaching stakeholders, removing organisational impediments, helping the product owner with backlog techniques.

Developers. Everyone doing the work of creating a usable increment, whatever their speciality — coding, testing, design, analysis, operations. They are accountable for creating a plan for the sprint, instilling quality by adhering to the definition of done, adapting their plan daily, and holding each other professionally accountable. The team is cross-functional: it has every skill needed to go from backlog item to increment without depending on people outside it.

Three artefacts and their commitments

The 2020 revision attached a commitment to each artefact, so that each one has something to be measured against rather than being an open-ended list.

ArtefactWhat it isIts commitment
Product backlogThe single ordered list of everything that might improve the productProduct goal — the longer-term objective the team is currently working toward
Sprint backlogThe sprint goal, the selected items, and the developers' plan for delivering themSprint goal — the single objective for the sprint
IncrementA concrete step toward the product goal, additive to all prior incrementsDefinition of done — the shared standard for what "complete" means

The product goal gives the backlog a direction, so that ordering decisions can be argued about against something. The sprint goal is the reason the sprint is worth running; it is chosen in planning and creates coherence between items that might otherwise be unrelated tickets. The definition of done is the quality bar: work that does not meet it is not part of the increment, cannot be released and cannot be demonstrated as complete.

A definition of done is only useful if it is honest and enforced. A realistic one for a web service might require that code is reviewed and merged to the main branch, unit and integration tests pass in the pipeline, the feature is behind a flag or deployed to staging, monitoring and logging exist for the new path, documentation is updated, and no known defect of medium severity or higher remains open. If "tested" appears on the list but testing actually happens two sprints later, the definition is fiction and every increment is overstated. The testing fundamentals guide covers what a defensible quality bar contains.

Five events

The sprint is the container; the other four events happen inside it. All are time-boxed, all are inspection points, and none of them is a status report to management.

EventTime-box (one-month sprint)InspectsAdapts
SprintOne month or less—The container for everything else
Sprint planning8 hoursProduct backlog, capacity, past performanceSprint backlog
Daily Scrum15 minutesProgress toward the sprint goalThe plan for the next day
Sprint review4 hoursThe increment, with stakeholdersProduct backlog
Sprint retrospective3 hoursThe team's process, tools and interactionsThe team's way of working

Time-boxes scale down with sprint length: a two-week sprint gets up to four hours of planning, two hours of review and ninety minutes of retrospective. These are maximums, not targets.

Sprint planning answers three questions. Why is this sprint valuable — the product owner proposes and the team crafts the sprint goal. What can be done — the developers select items they believe they can finish to the definition of done. How will it be done — enough decomposition that the team is confident, typically into a plan of work items, though the guide does not prescribe the format.

The Daily Scrum is a fifteen-minute working session for the developers to inspect progress toward the sprint goal and adjust the day's plan. The 2020 guide deliberately removed the three scripted questions because they had turned the event into a round of individual status reports. If the outcome is that nobody's plan changes, the event is not doing its job.

The sprint review is a working session with stakeholders in which the increment is demonstrated and the group discusses what to do next given what they now know. It is a conversation about the product, not a sign-off gate, and the output feeds directly into backlog ordering.

The sprint retrospective closes the sprint by inspecting how the work went — process, tools, interactions, definition of done — and identifying improvements. The output is a small number of concrete changes, ideally one that the team commits to trying in the next sprint. Retrospectives that generate a long list of grievances and no change are the most common cause of a team quietly abandoning the event.

A sprint, end to end

Consider a two-week sprint for a team building a payments dashboard.

On day one the team spends three hours in planning. The product owner explains that the most valuable next step is letting finance users see settlement discrepancies without exporting to a spreadsheet, and the team crafts the sprint goal: finance users can identify and explain a settlement mismatch inside the dashboard. They select five backlog items that serve that goal and leave a sixth, a reporting export, out — it is valuable but unrelated, and including it would dilute the goal.

Each morning the developers meet for fifteen minutes at the board. On day four they discover the settlement feed omits a currency code, which makes one item impossible as written. Rather than escalating, they renegotiate with the product owner the same day: the item is reduced to single-currency accounts, which still serves the goal. The sprint backlog changes; the sprint goal does not.

On day nine an urgent production defect arrives. The team fixes it and drops the lowest-value item from the sprint to make room. At the review on day ten they demonstrate the working discrepancy view to two finance users, who immediately ask for filtering by counterparty — a request that becomes a new backlog item rather than a change to the finished work. The retrospective that afternoon surfaces that the missing currency code cost a day and a half, and the team agrees on one change: refinement sessions will include a five-minute check of the actual upstream data contract before an item is considered ready.

What Scrum deliberately does not say

Scrum is a framework, not a method, and the omissions are intentional. It says nothing about how to estimate, whether to use story points, how long refinement should take, how to branch and merge, what a board looks like, how to handle bugs, how many teams can share a product, or how to do any technical practice at all. Teams must supply those, and the choices matter more than the framework does — a team following every rule in the guide with no automated tests and a two-month release cycle will not deliver a usable increment every sprint no matter how well it runs its events. A delivery pipeline is the practical prerequisite for the increment being genuinely releasable.

The framework is also explicitly non-negotiable as a whole: the guide states that Scrum's elements serve a purpose and removing parts of it while keeping the name produces something that hides problems rather than surfacing them. In practice most organisations do remove parts, which is fine as long as everyone is honest that what results is a local process rather than Scrum.

Key takeaways

  • The current Scrum Guide dates from November 2020 and defines one team with three accountabilities, five events, three artefacts and three commitments — nothing more.
  • Each artefact has a commitment: product goal for the backlog, sprint goal for the sprint backlog, definition of done for the increment.
  • The sprint is a container; the other four events are inspection points with defined subjects and time-boxes that scale with sprint length.
  • The sprint backlog can change daily, but the sprint goal is fixed for the sprint; only the product owner can cancel a sprint.
  • A definition of done that is not enforced makes every increment an overstatement, and no amount of process discipline compensates for it.
  • Scrum omits estimation, engineering practice and tooling on purpose; those choices determine whether the framework produces anything useful.

Sources and further reading

Frequently asked questions

How long should a sprint be?
The guide sets a maximum of one month and says shorter sprints generate more learning cycles. Two weeks suits most product teams: long enough to finish something meaningful, short enough that a bad sprint costs little. Choose one length and keep it, because a stable cadence is what makes throughput comparable between sprints. Changing length every few sprints destroys any ability to forecast.
Can the sprint backlog change during the sprint?
Yes. The sprint backlog belongs to the developers and they update it throughout the sprint as they learn — adding tasks, dropping work that turned out to be unnecessary, renegotiating scope with the product owner. What must not change is the sprint goal. If new information makes the goal obsolete, the correct response is to cancel the sprint, which only the product owner can do.
What happens to work that is not finished at the end of a sprint?
It is not counted as delivered and it returns to the product backlog, where the product owner reorders it against everything else. There is no partial credit and no carrying half-finished items forward as though the sprint had produced them. Repeatedly ending sprints with unfinished work is a planning signal, not a reason to loosen the definition of done.
Is Scrum suitable for maintenance or support work?
Poorly, in its pure form. Scrum assumes a team can commit to a goal for a whole sprint, and an unpredictable stream of urgent incidents breaks that assumption. Teams in that situation commonly use a flow-based approach with work-in-progress limits instead, or reserve a fixed share of capacity for interrupts and plan the sprint around what remains.