107 - Developers

Goal

Understand the Developers' accountability as the professionals responsible for creating valuable, usable product increments every Sprint by exploring how self-management, collaboration, engineering excellence, and shared ownership enable successful product development.

By the end of this chapter, readers should understand that Scrum Developers are not simply software programmers, but cross-functional professionals who collaborate to transform product ideas into high-quality increments that deliver customer value.

Reading Time

Mind Map

Developers
│
├── Self-Management
│
├── Collaboration
│
├── Engineering Excellence
│
├── Quality Ownership
│
├── Sprint Planning
│
├── Daily Collaboration
│
├── Continuous Improvement
│
└── Valuable Increment

Table of Contents

1. Introduction

2. Why Developers Exist

   • 2.1 Creating Valuable Increments
   • 2.2 Shared Accountability
   • 2.3 Self-Management

3. Developer Accountabilities

   • Sprint Planning
   • Daily Collaboration
   • Engineering Excellence
   • Quality Ownership
   • Continuous Improvement

4. Developers in Modern Software Engineering

   • DevOps
   • Platform Engineering
   • Cloud Native
   • AI-Assisted Development
   • Engineering Culture

5. Common Misconceptions

6. 💼 In Practice

7. 💡 Did You Know?

8. 📝 Key Takeaways

9. 📚 Further Reading

1. Introduction

When people hear the word Developer, they often think of someone who writes code.

In Scrum, the term has a much broader meaning.

Developers are the professionals within the Scrum Team who are committed to creating a valuable, usable Increment every Sprint.

Depending on the product, this may include software engineers, QA engineers, UX designers, security specialists, DevOps engineers, data engineers, technical writers, or any other professionals required to create a complete product increment.

This distinction is important.

Scrum does not organize work around job titles.

It organizes work around delivering customer value.

Developers therefore share accountability for the Increment rather than owning isolated technical tasks.

Their responsibility extends beyond implementation.

They collaborate to plan, design, build, test, integrate, validate, and continuously improve the product.

Modern software engineering further expands this accountability.

Developers increasingly participate in product discovery, operational excellence, automation, observability, and continuous improvement throughout the entire product lifecycle.

The goal is not simply to write software.

The goal is to create valuable outcomes for customers.

2. Why Developers Exist

🎯 Core Idea

Developers exist to create valuable, usable product increments every Sprint through collaboration, self-management, and engineering excellence.

Complex products cannot be created through isolated individual effort.

They require professionals with diverse skills working together toward a shared objective.

Scrum therefore defines Developers as a collective accountability responsible for transforming product ideas into usable increments.

Their success is measured not by individual productivity but by the value delivered by the team.

2.1 Creating Valuable Increments

The primary responsibility of Developers is to create a usable Increment every Sprint.

A usable Increment is more than completed code.

It is work that meets the team's Definition of Done and contributes meaningful value to the product.

Creating valuable increments includes activities such as:

• Designing solutions.
• Developing software.
• Testing functionality.
• Validating quality.
• Integrating changes.
• Improving maintainability.
• Ensuring the Increment is usable.

Developers therefore focus on delivering completed product outcomes rather than partially finished work.

📖 Scrum Guide Perspective

Developers are the people in the Scrum Team who are committed to creating any aspect of a usable Increment each Sprint.

Scrum intentionally defines Developers by their accountability rather than by their profession.

2.2 Shared Accountability

Scrum intentionally avoids assigning ownership of individual tasks.

Instead, Developers share accountability for delivering the Sprint Goal and creating the Increment.

This means:

• Quality belongs to the team.
• Delivery belongs to the team.
• Technical excellence belongs to the team.
• Continuous improvement belongs to the team.

Shared accountability encourages collaboration instead of local optimization.

Rather than asking:

"Whose bug is this?"

Scrum Teams ask:

"How do we improve the product together?"

This mindset strengthens ownership and reduces unnecessary handoffs.

2.3 Self-Management

Developers decide how best to accomplish the Sprint Goal.

Rather than receiving detailed task assignments, they organize their own work.

Self-management includes decisions about:

• Technical approaches.
• Task distribution.
• Collaboration.
• Engineering practices.
• Daily planning.
• Continuous improvement.

This autonomy enables Developers to respond quickly as new information emerges throughout the Sprint.

Self-management does not eliminate accountability.

It strengthens it.

Traditional Developer vs Scrum Developer

🔗 How These Concepts Work Together

Developers collaborate to create valuable increments.

Shared accountability strengthens ownership.

Self-management enables faster decisions.

Engineering excellence sustains quality.

Together, these characteristics allow Scrum Teams to deliver customer value continuously.

⚙️ Engineering Insight

Software is written by individuals.

Great products are built by teams.

🧩 Concept Connection

The Product Owner determines what creates value.

The Scrum Master helps the team become more effective.

Developers transform those decisions into valuable, usable product increments.

3. Developer Accountabilities

🎯 Core Idea

Developers are accountable not only for building software, but for continuously improving how valuable software is created.

Modern Developers contribute throughout the product lifecycle.

Their accountability extends beyond implementation into planning, collaboration, quality, engineering excellence, and continuous improvement.

They own the Increment—not individual tasks.

Sprint Planning

Developers actively participate in Sprint Planning.

They collaborate with the Product Owner to understand:

• The Sprint Goal.
• Product Backlog Items.
• Technical considerations.
• Dependencies.
• Risks.

They then determine how the selected work can be transformed into a usable Increment.

Planning is therefore a collaborative engineering activity rather than a management exercise.

Daily Collaboration

Complex software development requires constant communication.

Developers collaborate throughout the Sprint by:

• Sharing knowledge.
• Solving problems together.
• Coordinating work.
• Reviewing designs.
• Supporting teammates.
• Adapting plans as new information emerges.

The Daily Scrum provides one opportunity for synchronization.

Collaboration, however, happens continuously.

Engineering Excellence

Technical excellence enables sustainable agility.

Developers continuously improve engineering practices such as:

• Test-Driven Development.
• Pair Programming.
• Continuous Integration.
• Refactoring.
• Automation.
• Coding Standards.
• Code Reviews.

These practices reduce defects, improve maintainability, and enable frequent delivery of high-quality increments.

Engineering excellence is not optional.

It directly supports empirical product development.

Quality Ownership

Quality belongs to the entire Scrum Team.

Developers do not "throw work over the wall" to another department.

Instead, they collectively own:

• Functional quality.
• Reliability.
• Maintainability.
• Security.
• Performance.
• Usability.

This shared ownership encourages building quality into the product rather than inspecting quality afterward.

Continuous Improvement

Every Sprint creates opportunities to improve both the product and the engineering process.

Developers continuously refine:

• Collaboration.
• Engineering practices.
• Automation.
• Architecture.
• Development workflow.
• Product quality.

Small improvements accumulate over time, increasing both delivery capability and customer value.

Continuous improvement is therefore part of everyday engineering work—not an occasional initiative.

Developer Responsibilities at a Glance

🔗 How These Responsibilities Work Together

Planning aligns the team.

Daily collaboration keeps work synchronized.

Engineering excellence enables sustainable delivery.

Quality ownership protects customer value.

Continuous improvement strengthens the team's ability to deliver future increments.

Together, these responsibilities allow Developers to consistently create valuable, usable product increments.

⚙️ Engineering Insight

Great Developers don't optimize for individual productivity.

They optimize for product quality, team collaboration, and continuous delivery.

4. Developers in Modern Software Engineering

🎯 Core Idea

Modern Developers contribute throughout the entire product lifecycle.

Their accountability extends far beyond writing code to include deployment, operations, automation, quality, continuous learning, and customer value.

Software engineering has evolved significantly since Scrum was first introduced.

Today's Developers work in environments that emphasize continuous delivery, cloud platforms, automation, observability, and rapid customer feedback.

Rather than specializing exclusively in implementation, Developers increasingly participate in every stage of product development—from discovery to production.

This broader accountability strengthens Empiricism by shortening feedback loops and enabling continuous improvement.

DevOps

DevOps extends the Developer's responsibility beyond implementation.

Instead of handing completed work to Operations, Developers increasingly collaborate throughout the software lifecycle.

This includes:

• Continuous Integration.
• Continuous Delivery.
• Deployment automation.
• Monitoring.
• Incident response.
• Operational improvements.

Owning software in production enables Developers to learn directly from customer usage and operational feedback.

This accelerates both product and engineering improvement.

Platform Engineering

As engineering organizations grow, Platform Teams provide shared capabilities that allow Product Teams to deliver software more efficiently.

Examples include:

• CI/CD platforms.
• Internal developer portals.
• Infrastructure automation.
• Security platforms.
• Observability tooling.

Developers collaborate closely with Platform Teams while remaining accountable for delivering valuable product increments.

Platform Engineering reduces cognitive load, allowing Developers to focus on solving customer problems instead of managing infrastructure.

Cloud Native

Cloud-native technologies have transformed how modern software is developed and operated.

Developers increasingly build systems that are:

• Scalable.
• Resilient.
• Observable.
• Automated.
• Continuously deployable.

Cloud-native engineering encourages smaller deployments, faster feedback, and greater operational visibility.

These capabilities strengthen the empirical learning cycle by making experimentation safer and more frequent.

AI-Assisted Development

Artificial Intelligence is becoming an important engineering tool.

Modern Developers use AI to assist with activities such as:

• Code generation.
• Unit testing.
• Documentation.
• Refactoring.
• Code reviews.
• Debugging.
• Learning unfamiliar technologies.

AI increases productivity by automating repetitive tasks.

However, Developers remain accountable for:

• Product quality.
• Architectural decisions.
• Engineering trade-offs.
• Security.
• Customer value.

AI augments engineering capability.

It does not replace engineering responsibility.

Engineering Culture

High-performing engineering teams are distinguished not only by technical expertise but also by culture.

Healthy engineering cultures encourage:

• Collaboration.
• Shared ownership.
• Continuous learning.
• Experimentation.
• Constructive feedback.
• Psychological safety.

Developers contribute to this culture by sharing knowledge, reviewing one another's work, and continuously improving both technical practices and team interactions.

Strong engineering culture enables sustainable delivery over the long term.

Modern Developer Evolution

Developer
      │
      ▼
Engineering Excellence
      │
      ▼
DevOps
      │
      ▼
Cloud Native
      │
      ▼
AI-Assisted Development
      │
      ▼
Continuous Learning
      │
      ▼
Customer Value

Modern Developers continuously expand their capabilities while maintaining a constant focus on delivering valuable increments.

Comparison

🔗 How These Concepts Work Together

DevOps shortens feedback loops.

Platform Engineering removes unnecessary complexity.

Cloud-native technologies improve scalability and resilience.

AI accelerates engineering activities.

A strong engineering culture enables all of these practices to succeed.

Together, they allow Developers to continuously deliver high-quality product increments.

⚙️ Engineering Insight

Modern Developers are no longer responsible only for writing software.

They are responsible for helping software succeed in production.

5. Common Misconceptions

The Scrum Guide deliberately defines Developers by their accountability rather than their profession.

Despite this, the role is frequently misunderstood.

Developers are programmers

Scrum Developers include anyone responsible for creating a usable Increment.

Depending on the product, this may include:

• Software Engineers.
• QA Engineers.
• UX Designers.
• DevOps Engineers.
• Security Engineers.
• Data Engineers.
• Technical Writers.

Developer describes an accountability—not a job title.

Developers only write code

Writing code is only one activity involved in creating a valuable Increment.

Developers also contribute to:

• Design.
• Testing.
• Automation.
• Architecture.
• Deployment.
• Monitoring.
• Continuous improvement.

Modern software engineering extends well beyond implementation.

Developers receive tasks from the Product Owner

The Product Owner determines priorities.

Developers determine how the work will be accomplished.

Scrum Teams are self-managing.

Developers organize their own work in pursuit of the Sprint Goal.

Quality belongs to QA

Quality belongs to the entire Scrum Team.

Testing is important, but quality is created through engineering practices such as:

• Test automation.
• Continuous Integration.
• Code Reviews.
• Pair Programming.
• Refactoring.
• Definition of Done.

Quality is built into the Increment—not inspected afterward.

Developers only care about technology

Modern Developers increasingly understand:

• Customer problems.
• Product goals.
• Business outcomes.
• User experience.
• Operational performance.

Technical excellence and customer value are complementary rather than competing priorities.

AI will replace Developers

AI automates repetitive engineering activities.

Developers continue to provide:

• Creativity.
• Architectural thinking.
• Product understanding.
• Collaboration.
• Judgment.
• Accountability.

AI changes how software is built.

It does not remove the need for skilled engineering professionals.

🔗 Common Theme

Every misconception reduces Developers to technical specialists.

Scrum defines Developers as professionals collectively accountable for creating valuable, usable product increments.

⚙️ Engineering Insight

Developers do not own code.

They own the Increment.

6. 💼 In Practice

Case Study: From Specialists to Product Engineers

A software organization separated engineering work into specialized departments:

• Development.
• QA.
• Operations.
• Security.

Each department optimized its own work.

Unfortunately, delivery remained slow.

Every handoff introduced delays.

Production issues often required multiple teams to coordinate before problems could be resolved.

The organization adopted cross-functional Scrum Teams.

Step 1 — Build Cross-Functional Teams

Each Scrum Team included the skills required to deliver complete product increments.

Dependencies between departments decreased significantly.

Step 2 — Share Quality Ownership

Rather than relying on QA as the final quality gate, Developers adopted:

• Test automation.
• Continuous Integration.
• Pair Programming.
• Code Reviews.
• Definition of Done.

Quality became everyone's responsibility.

Step 3 — Extend Ownership to Production

Developers gained visibility into:

• Monitoring dashboards.
• Operational metrics.
• Production incidents.
• Customer behaviour.

Engineering decisions increasingly reflected real-world product usage.

Results

Within several months, the organization observed:

• Faster releases.
• Higher product quality.
• Reduced defects.
• Better collaboration.
• Improved customer satisfaction.

Lessons Learned

The team concluded that:

• Cross-functional collaboration reduced delivery friction.
• Shared ownership improved product quality.
• Operational feedback accelerated learning.
• Engineering excellence enabled sustainable delivery.
• Customer value increased when Developers owned the entire Increment.

Remember

Great Developers do not simply deliver software.

They continuously improve the system that creates valuable software.

7. 💡 Did You Know?

The Scrum Guide deliberately uses the word "Developers"

The term Developer was intentionally chosen to represent anyone who contributes to creating a usable Increment—not only software programmers.

Modern engineering increasingly emphasizes ownership

High-performing engineering organizations encourage Developers to own software from development through production.

This reduces handoffs and accelerates learning.

Engineering excellence enables agility

Agile practices alone cannot compensate for weak engineering practices.

Continuous Integration, automation, testing, and refactoring are essential for sustaining rapid delivery.

DevOps reinforces Scrum principles

Although DevOps is not part of Scrum, both emphasize:

• Collaboration.
• Shared ownership.
• Continuous improvement.
• Fast feedback.
• Customer value.

AI is changing engineering workflows

AI tools increasingly support Developers with implementation, testing, documentation, and analysis.

The most valuable engineering skills increasingly include critical thinking, collaboration, architecture, and product understanding.

8. 📝 Key Takeaways

After completing this chapter, you should understand that:

• Developers are accountable for creating valuable, usable product increments every Sprint.
• Scrum Developers represent a cross-functional accountability rather than a specific profession.
• Shared accountability strengthens collaboration and product quality.
• Self-management enables Developers to organize their own work.
• Engineering excellence supports sustainable agility.
• Quality belongs to the entire Scrum Team.
• Modern Developers contribute throughout the software lifecycle, including deployment, operations, and continuous improvement.
• DevOps, Platform Engineering, Cloud Native technologies, and AI strengthen Developer capabilities.
• Great Developers optimize customer value rather than individual productivity.

Remember

Developers are not accountable for writing software.

They are accountable for creating valuable, usable Increments every Sprint.

9. 📚 Further Reading

Continue With

The next chapter explores the artifact that connects product strategy with delivery.

• 108 - Product Backlog

You'll examine:

• Product Backlog purpose
• Product Backlog Items
• Ordering
• Refinement
• Emergence
• Product Goals

Related Topics

Scrum

• Scrum Guide — Ken Schwaber & Jeff Sutherland
• Essential Scrum — Kenneth S. Rubin

Engineering Excellence

• Extreme Programming Explained — Kent Beck
• Accelerate — Nicole Forsgren, Jez Humble & Gene Kim
• Continuous Delivery — Jez Humble & David Farley

DevOps

• The DevOps Handbook — Gene Kim, Jez Humble, Patrick Debois & John Willis

Architecture

• Building Evolutionary Architectures — Neal Ford, Rebecca Parsons & Patrick Kua
• Team Topologies — Matthew Skelton & Manuel Pais

Looking Ahead

This chapter explored who creates valuable product increments.

The next chapter examines how product work is made transparent and ordered through the Product Backlog, connecting product strategy, customer value, and Sprint execution.

Next Chapter

108 - Product Backlog

Discover how the Product Backlog serves as the single, evolving source of work for the Scrum Team, enabling transparency, prioritization, empirical planning, and continuous product evolution.