Skip to content
Tutorials Center
My learning

Topics

Lesson 8 of 29 ยท The Scrum Framework

Scrum Artifacts and Commitments

Learn the three Scrum artifacts and their commitments: Product Backlog and Product Goal, Sprint Backlog and Sprint Goal, Increment and Definition of Done.

Scrum keeps a team honest by making its work visible. It does this with three artifacts: things the team builds and maintains so that everyone can see what is planned, what is being worked on, and what has actually been delivered. Each artifact comes with a commitment, a statement that gives the artifact a purpose and a way to judge whether it is doing its job.

This lesson covers all three pairs: the Product Backlog with the Product Goal, the Sprint Backlog with the Sprint Goal, and the Increment with the Definition of Done. If you have not read it yet, Scrum Roles explains who owns each one, and Scrum Events shows when each one is updated.

Jira, covered later in this tutorial, is a tool that stores these artifacts. The artifacts themselves are ideas, and you can keep them on a wall of sticky notes. The runnable examples below are small JavaScript models that show how the pieces fit together. They are stand-ins for the concepts, not Jira itself.

Three artifacts, three commitments

Product Backlog Everything the product may need.
Sprint Backlog The plan for this Sprint.
Increment Work that is really done.

Each one has a commitment that gives it focus.

1 / 2

The Product Backlog

The Product Backlog is an ordered list of everything that might be needed in the product: features, improvements, bug fixes, technical work, experiments. It is the single source of work for the Scrum Team. There is one Product Backlog per product, no matter how many teams work on it.

A few properties matter more than any template:

  • Ordered, not just listed. The top of the backlog is the most valuable and most urgent work. The Product Owner decides the order, using value, risk, dependencies, deadlines and anything else that matters to the business.
  • Emergent. It is never finished. A new product starts with a short list of what is known, and the list grows and changes as the team learns from users and from building.
  • Detailed at the top, vague at the bottom. Items near the top are small and clear enough to be picked up in a Sprint. Items far down can be one line long. Writing detailed requirements for work that may never be built is waste.
  • Owned by the Product Owner, but anyone may suggest items, and the Developers help estimate and refine them.

An entry on the backlog is called a Product Backlog item (PBI). Most teams write PBIs as user stories, which the next lesson, User Stories and Acceptance Criteria, covers in detail. Bugs and technical tasks live on the same list. Keeping everything in one ordered list stops teams from running a hidden second backlog.

Refinement

Refinement is the ongoing activity of making backlog items ready: adding detail, estimating, and splitting large items. It is not a formal Scrum event, and the team decides how and when to do it. Many teams spend up to about ten percent of their capacity on it, in short sessions during the Sprint.

A common rule of thumb is that an item is ready for Sprint Planning when the team can finish it within one Sprint, usually with room to spare. The Scrum Guide does not define a formal "Definition of Ready", and teams that turn it into a gate that blocks work tend to slow themselves down. Treat it as a helpful checklist, not a rule.

The Product Goal

The Product Goal is the commitment for the Product Backlog. It describes a future state of the product, something that gives the team a target and a way to measure progress. "Guests book a table in under a minute" is a Product Goal. "Build the booking module" is not: it names a piece of work, not an outcome.

The Product Goal is a long-term objective, and the Scrum Team should fulfil it, or abandon it for a better one, before taking on another. Every backlog item should help reach it. If an item does not, either the item or the goal needs a second look.

Run the model below. It keeps an ordered backlog, marks which items are ready, and shows what refinement does to a large item.

JS A tiny Product Backlog model

Press Run (or Ctrl + Enter) to see the console output here.

No output.

The "value" and "size" numbers are made up to keep the model small. In real life the Product Owner's ordering is a judgement, not a sort on one number. The model does show the shape of the idea: a single ordered list, a goal above it, and refinement that turns vague or oversized items into ready ones. Notice that the 13-point item was split into two items of 5, which keeps the same value but makes each part small enough to finish in a Sprint.

The Sprint Backlog

The Sprint Backlog is the plan for one Sprint. It has three parts:

  1. The Sprint Goal, which says why this Sprint is valuable.
  2. The Product Backlog items selected for the Sprint, which say what will be delivered.
  3. An actionable plan for delivering the Increment, which says how.

The Developers own the Sprint Backlog. They create it during Sprint Planning and update it throughout the Sprint as they learn more. It is a live plan, not a contract: tasks are added, removed and re-ordered as the work shows what is really needed. What does not change is the Sprint Goal.

Because it is the Developers' plan, it should show up-to-date progress at any moment, ideally on a visible board. A Daily Scrum is where the team inspects it. Tools such as the Jira board show the same thing electronically.

The Sprint Goal

The Sprint Goal is the commitment for the Sprint Backlog: a single objective for the Sprint, created during Sprint Planning and fixed once the Sprint starts. It gives the Developers coherence and focus, because they can make trade-offs against it.

A useful Sprint Goal is short, understood by the whole team and checkable at Review. "A guest can book and cancel a table without calling us" is a goal. "Finish tickets 101 to 108" is just a list.

The goal is also what protects flexibility. If the work turns out larger than expected, the Developers negotiate scope with the Product Owner without endangering the goal. They may drop a nice-to-have item, but not the thing the Sprint exists to achieve. If the goal itself becomes obsolete, only the Product Owner can cancel the Sprint.

The Increment

An Increment is a concrete, usable step toward the Product Goal. Each Sprint produces at least one, and every Increment is added to all earlier ones and verified to work together. Think of it as the sum of everything that is done so far, not only this Sprint's changes.

Increments can be delivered to users during the Sprint, and often should be: Scrum does not require waiting for the Review to release. What Scrum does require is that a product is only counted as an Increment when it meets the Definition of Done. Work that is "almost done" is not an Increment.

The Definition of Done

The Definition of Done (DoD) is the commitment for the Increment. It is a formal description of the quality the Increment must have. When a backlog item meets the DoD, it becomes part of the Increment. When it does not, it cannot be released or even shown in the Review as finished. It returns to the Product Backlog for the Product Owner to re-evaluate.

A typical DoD for a web team might say: code is reviewed, automated tests pass, accessibility is checked, the change is deployed to a staging environment, and the help text is updated. The exact list belongs to the team. If the organization has a standard, every team must at least follow it. If there is none, the Scrum Team writes its own. When several teams work on one product, they share a single DoD.

The DoD is also a conversation tool. Without it, one developer's "done" means "it works on my machine" and another's means "it is in production". A shared DoD removes that gap, and tightening it over time is a natural outcome of the Retrospective.

The model below runs a Sprint's items against a Definition of Done. It reports what joins the Increment, what returns to the backlog, and whether the Sprint Goal was met.

JS Definition of Done check

Press Run (or Ctrl + Enter) to see the console output here.

No output.

Notice that the "Confirmation email" item is one criterion short and still does not count. That feels harsh, but it is the point: partial credit hides risk. A team that counts nearly-done work as done reports a velocity it cannot sustain, and discovers the missing work later at a much higher cost. Try adding "accessibility checked" to the second item and run it again to see the Increment grow.

Also notice that the real set of items in the Increment is not decided by the Sprint Goal alone. The goal says what the Sprint is for. The Definition of Done decides which of the work is finished. Both matter.

How the artifacts connect

The artifacts form a chain. The Product Goal shapes the Product Backlog. During Sprint Planning the team pulls the top items into the Sprint Backlog and writes a Sprint Goal that explains why. During the Sprint the Developers turn those items into an Increment that meets the Definition of Done. At the Review the team shows the Increment, and the Product Owner updates the Product Backlog based on what everyone learned. Then the loop starts again.

flowchart LR
  PG["Product Goal"] --> PB["Product Backlog"]
  PB -->|"Sprint Planning"| SB["Sprint Backlog<br/>(with Sprint Goal)"]
  SB -->|"Developers build"| INC["Increment<br/>(meets Definition of Done)"]
  INC -->|"Sprint Review"| PB

Work flows left to right; what the team learns flows back into the Product Backlog.

Transparency is the reason all this exists. The Scrum Guide says that artifacts must be transparent enough that people can inspect them and notice problems. If the backlog is a mess, the Sprint Backlog is hidden in someone's head, or "done" means different things to different people, nobody can make good decisions. Part of the Scrum Master's job is helping the team see that clearly.

Common mistakes

  • A backlog that is a dumping ground. Hundreds of old items nobody will ever build make the real priorities hard to see. Delete or archive what has no future.
  • Goals that are really task lists. If you can only describe the Sprint by listing tickets, you do not have a Sprint Goal yet.
  • Changing the Sprint Goal mid-Sprint. The plan can adapt, but the goal is the fixed point. If it has to change, the Sprint is probably cancelled.
  • A Definition of Done that is never applied. Either the team follows it for every item, or it is decoration.
  • Counting unfinished work. Partly done items do not belong in the Increment or in your reported progress.

Check your understanding

Quick check ยท 4 questions

of 4 answered You scored / 4 ยท perfect!

  1. 1. Which artifact does the Product Goal belong to?

    Each artifact has one commitment: Product Goal for the Product Backlog, Sprint Goal for the Sprint Backlog and Definition of Done for the Increment.
  2. 2. Who owns the Sprint Backlog?

    The Developers create the Sprint Backlog in Sprint Planning and update it during the Sprint, because it is their plan for delivering the Increment.
  3. 3. A story passes every item in the Definition of Done except accessibility checking. What happens at the end of the Sprint?

    Only work that meets the Definition of Done is part of the Increment. Unfinished items go back to the Product Backlog, where the Product Owner decides what to do with them.
  4. 4. Which statement best describes a good Sprint Goal?

    A Sprint Goal is a single, checkable objective. It lets the Developers negotiate scope while keeping the purpose of the Sprint intact.

Summary

  • Scrum has three artifacts, each with a commitment: Product Backlog (Product Goal), Sprint Backlog (Sprint Goal), Increment (Definition of Done).
  • The Product Backlog is one ordered, evolving list owned by the Product Owner. Refinement keeps the top items small and clear.
  • The Sprint Backlog is the Developers' plan: a Sprint Goal (why), selected items (what) and a plan (how). The plan may change, the goal should not.
  • An Increment is a usable step toward the Product Goal and only includes work that meets the Definition of Done.
  • The Definition of Done is a shared quality bar. Unfinished work returns to the Product Backlog.
  • The artifacts exist for transparency, so that the team and its stakeholders can inspect and adapt.

Next, learn how to write the items that fill the backlog in User Stories and Acceptance Criteria.