In Scrum, the Development Team commits to the amount of work they can deliver in a Sprint, aligned with the Definition of Done. This shapes sprint scope, maintains quality, and reinforces self‑organization and accountability as increments become releasable.

Multiple Choice

How much work must a Development Team do on a Product Backlog item selected for a Sprint?

The Development Team must complete the amount of work they have committed to delivering during the Sprint in alignment with their definition of "Done." This commitment is established during the Sprint Planning meeting, where the team selects the items from the Product Backlog they believe they can complete during the Sprint. The definition of "Done" provides a clear understanding of what it means for work to be complete. It can include aspects such as code quality, testing, documentation, and any other criteria necessary for an increment to be considered potentially releasable. By adhering to this definition, the team ensures that the work they deliver meets quality standards and truly adds value to the product. This choice highlights the self-organizing nature of Development Teams and emphasizes accountability for their commitments, reflecting a core principle of Scrum where the team takes ownership of its work.

If you’ve spent time with Scrum, you’ve heard about the magic number: the Sprint is a fixed timebox, and the Development Team takes items from the Product Backlog they believe they can finish in that window. But what exactly does “finish” mean, and how much work should a team put into a Product Backlog item during a Sprint? The short answer is simple, and it’s grounded in the team’s own standards: as much work as the Development Team has committed to delivering according to their definition of Done.

Let’s unpack that so it lands in a practical, everyday way.

The heartbeat of Sprint Planning: choosing a realistic chunk

Sprint Planning isn’t a theoretical exercise. It’s where the team glances at the horizon of the upcoming Sprint, checks capacity, and then chooses a set of Product Backlog items they believe can be completed within the timebox. This is the moment where risk meets reality: what can we truly finish, not what would be nice to finish?

That self-governing vibe is at the core of Scrum. The Development Team is responsible for its own work. There’s no micromanagement telling them, “Do X more because you promised it.” Instead, the team decides the scope based on a practical assessment of effort, complexity, dependencies, and the quality gates they want to hit.

The definition of Done: the north star of quality

What does “finished” actually mean? That’s where the Definition of Done (DoD) comes in. The DoD is a shared understanding within the team (and often with stakeholders) of what it means for an Increment to be releasable. It isn’t a single line item on a checklist; it’s a compact, working agreement about quality and completeness.

Think of the DoD as the product’s internal compass. It might include criteria like:

  • Code is written, reviewed, and integrated into the main branch.

  • Automated tests pass, with a target coverage level.

  • Documentation updated, user-facing help prepared, or release notes drafted.

  • Manual testing executed for critical paths, with no critical defects outstanding.

  • Security checks run and vulnerabilities addressed.

Because the DoD is shared, it creates a clear, objective signal: when a backlog item meets the DoD, it’s considered done. When a backlog item doesn’t, it’s not done—no clever loopholes, no emotional saving maneuvers, just a clean line in the sand.

The link between “how much” and “what we commit to”

Now, the question of how much work a team must do links directly to the commitment made during Sprint Planning. The team commits to delivering a certain amount of work within the Sprint, guided by the DoD. That means:

  • They pick items they believe they can complete within the Sprint timeframe.

  • They define the exact work they commit to finishing, according to the DoD.

  • They hold themselves accountable to that commitment, not to someone else’s expectations.

This internal commitment is a reflection of trust, capability, and a shared understanding of what “done” looks like. It’s not about piling on more tasks to prove something to a manager or a product owner. It’s about delivering value you can stand behind, increment after increment.

Why the DoD matters more than arbitrary totals

Let’s pause and contrast two ways people sometimes think about Sprint scope.

A. “Cram as much as we can into the Sprint and figure it out later.”

This approach invites churn, hidden risks, and a fragile Increment. You’ll end up with partially finished work, flaky quality, and a sprint review that reveals skeletons where you hoped for a polished product. That’s not a good look for a team that wants to be trustworthy and predictable.

B. “Agree on a clear set of work to complete, all measured against the Definition of Done.”

This is the healthier path. It creates transparency. It supports sustainable velocity. It gives the Product Owner a real signal about progress and risk. And it gives the team the space to focus on quality, not just quantity.

The reality check: velocity is a guide, not a weapon

Velocity—how much work a team completes in a Sprint—helps teams forecast, but it’s not a weapon to wield against others or oneself. It’s a visibility tool. If you chase velocity for its own sake, you lose sight of the product’s real value and the people doing the work. If you use velocity to plan realistically, it becomes a compass that points you toward steady, meaningful progress.

So, how much work is that, exactly?

The practical answer is: as much work as the Development Team has committed to delivering in the Sprint, measured against the Definition of Done. The DoD defines what “done” means, and the team’s commitment defines how much work they believe they can complete in the time available. The two together anchor the Sprint’s scope.

A few concrete scenarios to bring this to life

  • A small, focused backlog item with a tight DoD might be completed by a compact team in a few days. The team marks it done when all DoD criteria are met, and it’s ready for release if the Product Owner approves.

  • A larger item, perhaps a new feature with multiple integrations, might require several related tasks. The team may split it into smaller backlog items or still commit to a single item only if it’s clear they can meet the DoD for all related tasks within the Sprint.

  • A backlog item with known technical debt attached might force the team to renegotiate scope during Sprint Planning. If they can’t meet the DoD for all aspects, they might lower the target, split the work, or re-prioritize with the Product Owner for later Sprints.

The human side: trust, collaboration, and ownership

One of Scrum’s greatest strengths is the autonomy granted to the Development Team. That autonomy comes with responsibility. Teams don’t just passively execute; they own the process, the quality, and the value they’re delivering.

That ownership isn’t a performance competition. It’s a collaboration with the Product Owner to ensure the product evolves in meaningful ways. The Product Owner provides clarity on what matters to users and the business, but the Team decides how to turn that clarity into a real, shippable increment.

Kadence and rhythm: the flow from Planning to Increment

The rhythm matters. Good teams plan with a realistic cadence, commit to a coherent set of work, and then execute with focus. They maintain a steady pace, not a sprint of ferries across a raging sea. The Definition of Done acts like a lighthouse, guiding each item from “work in progress” to “done.” And the Release Planning (when it happens) uses that settled, incrementally completed work to decide what’s worth releasing and when.

What to watch for as you grow your Scrum practice

  • Clear DoD: Make sure the team has a well-understood, testable DoD. If the DoD is vague, it’s easy for “done” to drift into the land of vague promises rather than solid, releasable increments.

  • Realistic commitments: Encourage honest conversations about capacity. If velocity looks spiky, dig into why—are there blockers, external dependencies, or tech debt that needs attention?

  • Shared understanding with the Product Owner: The Product Owner clarifies what features are valuable. The team translates that into concrete work items that meet the DoD. If there’s misalignment, it’s healthier to talk it through early rather than at the sprint boundary.

  • Incremental quality: Don’t outsource quality to the end. Build it into the daily work. That often means investing in tests, reviews, and automation early rather than as an afterthought.

A quick analogy to keep it relatable

Think of a Sprint like planning a road trip. You pick a destination (the backlog item or set of items), you estimate your fuel and time, and you decide what you’ll fix on the way (quality gates and DoD criteria). You don’t pack everything you own; you pack what you need to get you to the next rest stop safely. When you arrive, you want your car clean and ready for the next leg. The DoD is the car’s checklist, and the team’s commitment is the fuel plan—the amount you’re sure you can carry and use without leaving the trunk full of stuff you didn’t need.

The takeaway

The essence is straightforward: during a Sprint, the Development Team works on as much as they have committed to delivering, and the yardstick for completion is the Definition of Done. That pairing—commitment anchored by the DoD—keeps the work meaningful, the increments reliable, and the product steadily growing in value. It’s not about chasing pressure or meeting someone else’s arbitrary target; it’s about building trust through transparent, disciplined, self-organized teamwork.

If you’re new to this way of working, give the DoD a close look and watch how it reframes the word done. You’ll notice work flows with intention, quality becomes a shared standard, and the whole process starts to feel like a natural, cooperative rhythm rather than a rigid, ticking clock. And that’s a pretty satisfying way to deliver something genuinely useful, increment by increment.