by The Scrum Framework :
- The Scrum framework consists of Scrum Teams and their associated accountabilities, artifacts, events and rules as defined in the Scrum Guide.
The Scrum accountabilities
- Product Owner
- Developers
- Scrum Master
Developers definition
- Developers are the people in the Scrum Team that are committed to creating any aspect of a usable Increment each Sprint.
- The specific skills needed by the Developers are often broad and will vary with the domain of work.
- However, the Developers are always accountable for:
● Creating a plan for the Sprint, the Sprint Backlog;
● Instilling quality by adhering to a Definition of Done (DoD);
● Adapting their plan each day toward the Sprint Goal; and,
● Holding each other accountable as professional
Developers accountability
- The Developers within the Scrum Team are accountable for managing, organizing, and doing all development work required to create a usable Increment of Product every Sprint.
- Developers are the people in the Scrum Team that are committed to creating any aspect of a usable Increment each Sprint.
- The specific skills needed by the Developers are often broad and will vary with the domain of work.
- Everyone who do the work is known as a Developer regardless of the work being done by the person : Developer = any member of the Scrum Team who do the work regardless of technical, functional, or other speciality.
- Developers structured and empowered by the organization to organize and manage their own work.
- Developers having all of the skills necessary to create a product Increment makes them a cross-functional team.
- Accountability of creating an Increment each sprint belongs to the Developers as a whole.
- The Developers works to forecast the functionality that will be developed during the Sprint.
- The Developers decides how to turn the Sprint Goal and Product Backlog items into a “done” Product Increment during the Sprint.
- The Developers approaches the “how” of getting the work done by designing the system/work needed to convert the Product Backlog into a working Product Increment.
Developers accountability summary
● Creating a plan for the Sprint, the Sprint Backlog;
● Instilling quality by adhering to a Definition of Done (DoD);
● Adapting their plan each day toward the Sprint Goal; and,
● Holding each other accountable as professionals.
Developers Self-organization
- Self-Organization is the management principle that teams autonomously organize their work.
- This happens within boundaries and against given goals.
- The Developers are self-organized to undertake the work in the Sprint Backlog during the Sprint Planning and (as needed) throughout the Sprint, Developers choose how to best accomplish work, rather than having external direction :
- The Developers are self-organizing within the Scrum Team and accountable for managing, organizing, and doing all work required to create a usable increment of Product every Sprint.
- Developers are self-organized and can decided how to turn the Product Backlog into an Increment of potentially releasable functionality.
- The Developers have many characteristics as following :
- Have no titles,
- Preferably full-time,
- With no sub-teams,
- Autonomous,
- Self-organizing
- and Cross-functional.
- The Developers are self-organizing so can add or remove members by itself :
- There is no hierarchical management manner in removing a member in the Scrum, for example, hiring manager, CEO, or other top managers.
- In addition, if removing a member converts to an impediment, the Scrum Master can intervene to help the Development Team removing that person.
- Because there is no such role as a “Project Manager”, the Developers themselves are self-governing and responsible for managing and execution of their own work.
- Self-organizing Developers have many responsibilities as following :
- Developing and creating Increments,
- Estimating the Product Backlog Items and tasks,
- Selecting Items for the Sprint Backlog,
- Decomposing Sprint Backlog Items to tasks,
- Measuring Sprint performance, and productivity,
- Calculating Velocity,
- Resolving team internal conflicts,
- Composing / Refining the Definition of Done (DoD),
- Making technical decisions, etc.
- The Developers are self-organizing and assign tasks to themselves with an agreement by all teammates.
- In addition, nobody (e.g. the Product Owner, the Scrum Master, or a Manager) should assign tasks to them or order them how to do their work.
- Developers should be fast and nimble through its productive processes and individuals’ skills not by working overtime or organizational policies or forces :
- Overtime is a symptom that there are some problems in the process or environment.
- On the other hand, establishing a balance between work and personal life leads to better productivity that occurs via a sustainable pace.
- This sustainable pace is usually between 6 to 8 hours per day.
- The Developers are self-organizing which means they manage all required work to implement and convert the Product Backlog into the usable and potentially releasable Increments without receiving orders from outside the team.
- In addition, the Developers know best about creating usable Increments so they decide all technical concerns as a whole.
- Developers are self-organizing and no one tells them how to perform work and turn the Product Backlog into Increments of potentially releasable functionalities.
- In addition, Developers are cross-functional with all required skills to create a product Increment.
- Cross-Functional means that the characteristics of a team holding that all the skills required to successfully produce a releasable Increment in a Sprint are available within the Team.
- Developers having all competencies needed to accomplish work without depending on external resources.
- Cross-functionality means the Developers as a whole should have all the required skills to create potentially releasable Increments without any dependency on others outside the team.
- Individual Developers may have some specialized skills or some focused areas of expertise but they do not need to be cross-functional one by one.
- Developers is responsible for doing all the required tasks to create a potentially releasable Increment.
- Writing tests like other tasks is a part of the development.
- On the other hand, each Scrum Team should be cross-functional so having a dependency on other teams violates this rule.
- Therefore, the Developers is responsible for writing tests.
- In addition, within Developers, there is no title and no sub-team.
- All members are a Developer.
- Therefore, having an architect role or architecture sub-team is not acceptable.
- There is no assigned Role (e.g. QA) who conducts the Test Cases, Developers are responsible for writing and executing the Test Cases.
- There is no assigned Role (e.g. a software architect) who makes sure a consistent architecture is developed.
How many Developers ?
- The optimal size for Developers is 3-9 people but is not mandatory.
- Who is included when counting the size ?
- Only the people executing the work in the Sprint Backlog, usually excludes the Product Owner and Scrum Master.
Developers practice
- 5 activities that are the responsibility of the Developers in Scrum :
- 1. Volunteer for tasks
- 2. Forecasts delivery of PBIs
- 3. Designs Software
- 4. Provides Estimates
- 5. Makes technical decisions
- Remember, all the test cases and testing is performed by Developers.
- Scrum does not approve roles such as Quality Analyst or Sub Teams (Testing Team, Business Team etc).
- The Developers decides how it will build the functionalities into a “Done” Product Increment during the Sprint.
- Developers do write tests and documentations in Scrum.
- There are no special designated Testers or Documenters in a Scrum Team.
- Developers are responsible for writing test and documentation.
Whole Team
- Whole Team means that all skills that are required to turn the selected items into a releasable software must be on the team, present across all the team members.
More informations for the Scrum PSD certification here.
Updated 02/09/2021
