Study guide
3.1 Developers Accountability & Self-Management
Certified ScrumMaster CSM
Track your progress as you read
Finished sections get a check mark.
1 Chapter 1: Agile Foundations, Scrum Theory & Empirical Process Control
1.1 Agile Manifesto & Lean Thinking 1.2 Empirical Process Control 1.3 Complex Adaptive Systems & Cynefin Framework 1.4 Scrum Framework Overview & Core Rules 1.5 Iterative & Incremental Delivery 1.6 Partial Scrum Adoption & Its Consequences
2 Chapter 2: The Five Scrum Values & Cultural Mindset
2.1 Commitment & Focus 2.2 Openness & Respect 2.3 Courage & Ethical Leadership
3 Chapter 3: Scrum Team Accountabilities & Dynamics
3.1 Developers Accountability & Self-Management 3.2 Product Owner Accountability & Business Value 3.3 Scrum Master Accountability & Servant Leadership 3.4 Team Characteristics, Size & Cross-Functionality 3.5 How the Scrum Team Interacts Across a Sprint 3.6 Why Scrum Has No Project Manager
4 Chapter 4: The Five Scrum Events & Timeboxing
4.1 The Sprint Container & Goal Preservation 4.2 Sprint Planning Event 4.3 Daily Scrum Event & Micro-Planning 4.4 The Sprint Review 4.5 The Sprint Retrospective 4.6 Effects of Skipping the Sprint Retrospective 4.7 Choosing a Suitable Sprint Length 4.8 Inspect & Adapt at Every Scrum Event
5 Chapter 5: Scrum Artifacts, Commitments & Definition of Done
5.1 Product Backlog & Product Goal 5.2 Sprint Backlog & Sprint Goal 5.3 Increment & Definition of Done 5.4 Multi-Team DoD & Technical Debt Management 5.5 Product Backlog Refinement 5.6 Product Backlog Item Attributes & Ordering 5.7 Creating & Evolving the Definition of Done
6 Chapter 6: Scrum Master Core Competencies, Servant Leadership & Coaching
6.1 Facilitation & Professional Coaching Techniques 6.2 Removing Impediments & Root Cause Analysis 6.3 Servant Leadership & Organizational Change 6.4 Agile Metrics, Velocity Traps & Scaling Basics 6.5 Development Practices That Protect the Increment 6.6 Serving the Product Owner 6.7 Organizational Design Change from Adopting Scrum
7 Chapter 7: The CSM Test — Format, Logistics & Official Blueprint
7.1 CSM Test Format & Scoring 7.2 Course Prerequisite, Attempts & Renewal 7.3 The Official Learning Objectives Blueprint
3.1 Developers Accountability & Self-Management
Key Takeaways Explain This Topic AI
Developers are the members of the Scrum Team committed to creating any aspect of a usable Increment each Sprint.
Developers are accountable for creating the Sprint Backlog, instilling quality by adhering to a Definition of Done, adapting their plan daily toward the Sprint Goal, and holding each other accountable as professionals.
Scrum recognizes no sub-teams, sub-roles, or internal hierarchies among Developers, regardless of specialized domains such as testing, architecture, or design.
Self-management empowers Developers to autonomously decide who performs what tasks, when, and how, within the overall framework boundaries.
Neither the Scrum Master nor the Product Owner assigns work to Developers or dictates technical execution details.
Last updated: August 2026
3.1 Developers Accountability & Self-Management
Quick Answer: Developers are the people on the Scrum Team committed to creating any usable Increment each Sprint. They are fully accountable for creating the Sprint Backlog, instilling quality through the Definition of Done, adapting plans daily during the Daily Scrum, and self-managing how work is accomplished without titles, sub-teams, or micro-management.
In the Scrum framework, the term Developers does not refer solely to software engineers or programmers. Instead, Developers encompasses all team members who work directly to produce a usable, valuable Increment of product during a Sprint. Whether building software, designing hardware, crafting marketing campaigns, or authoring complex legal documents, anyone committed to creating the increment is a Developer.
Understanding the accountabilities of Developers is central to passing the Certified ScrumMaster (CSM) examination. Scrum shifts authority away from traditional management and assigns full technical ownership and self-management to the Developers.
The Core Accountabilities of Developers
According to the official 2020 Scrum Guide, Developers are always accountable for four specific outcomes:
Creating a plan for the Sprint (the Sprint Backlog) — Developers own the Sprint Backlog completely. While the Product Owner establishes priority and proposes a Sprint Goal, only the Developers determine how many Product Backlog items they can pull into the Sprint and how those items will be decomposed into actionable daily work.
Instilling quality by adhering to a Definition of Done — Quality is non-negotiable in Scrum. Developers must ensure that all work produced meets the agreed-upon Definition of Done (DoD) before it can be considered part of an Increment. Cutting corners on testing, documentation, or security to hit a deadline violates Scrum accountabilities.
Adapting their plan each day toward the Sprint Goal — During the Daily Scrum , Developers inspect their progress toward the Sprint Goal and adapt their tactical plan for the next day of work. The Sprint Backlog is a living document modified continuously by the Developers throughout the Sprint.
Holding each other accountable as professionals — Accountability in Scrum is peer-to-peer, not top-down. Developers do not wait for a manager to enforce standards or track task completion; they hold one another responsible for quality, commitment, and collaboration.
Self-Management vs. Traditional Management
Legacy project management frameworks rely on project managers or functional leads to assign tasks, monitor individual activity, and direct workflow. Scrum replaces this command-and-control paradigm with self-management .
Self-managing teams autonomously decide who will do what , when , and how work will be completed.
Who: Developers decide among themselves who takes ownership of specific tasks. Work is pulled by Developers when they have capacity, rather than pushed onto them by managers.
What: While the Product Owner defines what items are valuable, Developers decide what technical tasks must be executed to complete those items.
When: Developers determine the sequence and execution order of technical tasks during the Sprint.
How: Technical implementation, architecture, design patterns, and engineering practices belong exclusively to the Developers. Traditional Management (Push): Manager --> Assigns Task --> Developer
- Scrum Self-Management (Pull): Developers <-- Pull Items from Sprint Backlog <-- Based on Capacity
- The Absence of Sub-Teams and Functional Titles
One of the most frequently tested concepts on the CSM exam is Scrum's strict rule regarding team structure:
Scrum recognizes no sub-teams or functional titles for Developers, regardless of the work being done by the team.
In traditional organizations, a project team might consist of separate sub-silos: front-end developers, back-end developers, database administrators (DBAs), quality assurance (QA) testers, and UX/UI designers. When bugs occur or deadlines are missed, these sub-teams often point fingers at each other.
Scrum eliminates functional silos entirely. On a Scrum Team:
Everyone contributing to the Increment holds the single accountable role of Developer .
There are no "QA Leads," "Senior Architects," or "DBA Sub-teams" recognized by Scrum.
Specialized skills are recognized and valued, but responsibility for quality and delivery is shared collectively .
If a user story passes all coding but lacks automated tests at the end of the Sprint, the entire team failed to deliver an Increment—the blame cannot be shifted onto a designated "testing department."
Estimation, Capacity, and Technical Ownership
Because Developers are accountable for turning Product Backlog items into usable Increments, they are the only people permitted to estimate the effort required for backlog items.
The Product Owner can influence Developers by helping them understand trade-offs and acceptance criteria, but the Developers make the final estimate.
Neither the Product Owner nor the Scrum Master can force Developers to accept more work than they estimate they can handle during a Sprint.
Developers inspect their past performance (velocity), current capacity, and Definition of Done to determine Sprint Backlog scope during Sprint Planning.
Comparison: Traditional Teams vs. Scrum Developers
- Dimension Traditional Software Team Scrum Developers
- Role Titles DBA, QA Tester, Front-End Engineer, Architect Single role: Developer
- Work Assignment Assigned by Project Manager or Tech Lead Self-assigned / Pulled by Developers
- Planning Ownership Project Manager creates Gantt chart Developers create and own the Sprint Backlog
Quality Responsibility QA Department validates after handoff Developers collectively enforce Definition of Done
- Accountability Individual accountability to functional managers Peer-to-peer accountability within the team
- Estimation Estimated by Tech Lead or Manager Estimated exclusively by the Developers
- Real-World Scrum Scenarios
- Scenario A: The Product Owner Directs Task Allocation
During Sprint Planning, the Product Owner notices that a critical feature is assigned to a junior developer. The Product Owner interrupts and orders the senior engineer to take over the task to guarantee completion. CSM Analysis: This violates Scrum principles. The Product Owner owns the what (Product Backlog ordering), but Developers own the how and who . The Scrum Master must intervene to educate the Product Owner that Developers self-manage task distribution.
Scenario B: "Not My Job" Syndrome
On Day 8 of a 10-day Sprint, a developer finishes coding their assigned feature and announces in the Daily Scrum that they have no work left, ignoring three un-tested features waiting in the QA column. CSM Analysis: This reflects a failure of self-management and peer accountability. In Scrum, Developers do not hand off work across internal boundaries; they collaborate across technical disciplines to bring backlog items across the Definition of Done finish line.
CSM Exam Traps & Watchouts
⚠️ Exam Trap 1: Assuming "Developer" means only software programmers. On the CSM exam, UX designers, testers, writers, and hardware engineers are ALL Developers if they contribute to the Increment.
⚠️ Exam Trap 2: Believing the Scrum Master assigns tasks when developers are idle. The Scrum Master NEVER assigns work. Developers pull work autonomously.
⚠️ Exam Trap 3: Thinking a Tech Lead or System Architect can override the Developers' estimate or capacity during Sprint Planning. The Developers own workload selection based on their self-assessed capacity.
⚠️ Exam Trap 4: Confusing Sprint Backlog ownership. The Product Owner owns the Product Backlog, but the Developers exclusively own the Sprint Backlog.