CSD
Coming Soon
Expected availability announced soon
This course is in active development. Preview the scope below and create a free account to be notified the moment it goes live.
CSD
The Certified Scrum Developer (CSD) course teaches developers how to apply Scrum principles, test‑driven development, refactoring, continuous integration, and collaborative practices to deliver high‑quality software efficiently.
Who Should Take This
It is intended for software engineers, developers, and quality‑assurance professionals who work in agile teams and have at least one year of practical coding experience. These learners seek to deepen their understanding of Scrum‑aligned engineering practices, improve code quality, and accelerate delivery through automation and teamwork.
What's Covered
1
Domain 1: Scrum Framework for Developers
2
Domain 2: Test-Driven Development and Testing
3
Domain 3: Refactoring and Code Quality
4
Domain 4: Continuous Integration and Delivery
5
Domain 5: Collaborative Development
6
Domain 6: Architecture and Design in Agile
7
Domain 7: Version Control and Build Practices
What's Included in AccelaStudy® AI
Adaptive Knowledge Graph
Practice Questions
Lesson Modules
Console Simulator Labs
Exam Tips & Strategy
20 Activity Formats
Course Outline
61 learning goals
1
Domain 1: Scrum Framework for Developers
3 topics
Developer accountability in Scrum
- Describe the Developers accountability in Scrum including creating a plan for the Sprint (Sprint Backlog), instilling quality by adhering to the Definition of Done, and adapting the plan daily.
- Describe self-management for Developers including the authority to decide who does the work, how the work is done, and how the team internally organizes.
- Apply Sprint Backlog management techniques to forecast a sustainable amount of work, decompose items into daily tasks, and track progress toward the Sprint Goal.
- Analyze the impact of overcommitment and undercommitment in Sprint Planning on team morale, stakeholder trust, and delivery predictability.
Scrum events from Developer perspective
- Describe how Developers participate in each Scrum event including Sprint Planning for forecasting, Daily Scrum for synchronization, Sprint Review for demonstration, and Retrospective for improvement.
- Apply Daily Scrum practices to synchronize work with teammates, identify blockers early, and adapt the Sprint Backlog plan based on emerging information.
- Apply Sprint Retrospective participation techniques to identify technical practice improvements, tooling enhancements, and collaboration changes that the team can implement.
- Analyze the effectiveness of Sprint events from the Developer perspective to identify events that provide value versus events that feel like overhead.
Definition of Done and quality
- Describe the Definition of Done as the shared quality standard that every Increment must meet, including coding standards, testing requirements, and documentation expectations.
- Apply Definition of Done adherence practices to ensure every completed item meets quality standards before being considered part of the Increment.
- Analyze the relationship between Definition of Done rigor and delivery velocity, explaining how investing in quality standards improves long-term throughput.
2
Domain 2: Test-Driven Development and Testing
3 topics
Test-Driven Development
- Describe the TDD cycle of Red-Green-Refactor including writing a failing test, making it pass with minimal code, and refactoring to improve design while keeping tests green.
- Apply TDD practices to develop new features by writing tests before implementation code, using test failures to guide design decisions and validate expected behavior.
- Analyze the benefits and challenges of TDD including improved design feedback, regression safety, documentation through tests, and the learning curve for teams new to the practice.
Testing strategies
- Describe the test pyramid including unit tests, integration tests, and end-to-end tests, explaining the rationale for investing more in fast, isolated unit tests.
- Apply test automation strategies to build a comprehensive test suite that provides rapid feedback on code changes and supports continuous integration practices.
- Apply acceptance test-driven development to collaborate with the Product Owner on defining executable acceptance criteria that verify business requirements are met.
- Analyze test suite health metrics including execution time, flakiness rate, coverage distribution, and maintenance cost to identify testing strategy improvements.
Behavior-Driven Development
- Describe BDD as a collaborative approach using Given-When-Then scenarios to specify expected system behavior in business-readable language.
- Apply BDD scenario writing to create shared specifications that bridge communication between Product Owner, Developers, and testers during backlog refinement.
3
Domain 3: Refactoring and Code Quality
3 topics
Refactoring principles
- Describe refactoring as the process of improving code structure without changing external behavior, using established refactoring patterns to reduce complexity and improve maintainability.
- Apply common refactoring techniques including extract method, rename variable, move function, and introduce parameter object to improve code readability and design.
- Apply code smell detection to identify code that indicates design problems including long methods, large classes, feature envy, and shotgun surgery.
- Analyze when to refactor versus when to rewrite by evaluating code complexity, test coverage, business criticality, and team understanding of the existing codebase.
Technical debt management
- Describe technical debt as the accumulated cost of shortcuts and suboptimal decisions that increase future development effort, distinguishing deliberate from accidental debt.
- Apply technical debt identification practices to make existing debt visible, categorized, and communicable to the Product Owner for prioritization decisions.
- Analyze the relationship between technical debt accumulation and delivery velocity degradation to build the case for sustained quality investment.
Design principles
- Describe SOLID design principles including Single Responsibility, Open-Closed, Liskov Substitution, Interface Segregation, and Dependency Inversion and their application to agile software design.
- Apply emergent design practices to evolve software architecture incrementally through refactoring rather than upfront big design, letting the architecture emerge from iterative development.
- Analyze the tradeoffs between upfront architectural design and emergent design to determine the appropriate balance for different project contexts and risk profiles.
4
Domain 4: Continuous Integration and Delivery
2 topics
Continuous integration
- Describe continuous integration as the practice of merging all developer working copies to a shared mainline frequently, with automated build and test verification on every merge.
- Apply CI practices including frequent commits, automated builds, fast feedback on test failures, and maintaining a green build as the team's top priority.
- Apply branching strategies appropriate for CI including trunk-based development and short-lived feature branches that minimize integration risk and merge conflicts.
- Analyze CI pipeline effectiveness by evaluating build times, failure rates, feedback speed, and integration frequency to identify improvement opportunities.
Continuous delivery and deployment
- Describe continuous delivery as keeping the codebase in a deployable state at all times, enabling release decisions to be business decisions rather than technical constraints.
- Apply deployment automation practices to reduce deployment risk, increase deployment frequency, and enable rapid rollback when issues are detected.
- Analyze deployment frequency, lead time for changes, change failure rate, and mean time to recovery to assess the team's continuous delivery maturity.
5
Domain 5: Collaborative Development
4 topics
Pair programming and mob programming
- Describe pair programming as two developers working at one workstation with defined driver and navigator roles, and mob programming as the whole team working on the same thing.
- Apply pair programming techniques including regular role rotation, communication protocols, and task selection criteria to maximize the benefits of collaborative coding.
- Analyze the costs and benefits of pair and mob programming including knowledge sharing, code quality, productivity effects, and team member satisfaction.
Code reviews and knowledge sharing
- Describe code review practices including pull request reviews, pre-commit reviews, and over-the-shoulder reviews, explaining their role in quality assurance and knowledge transfer.
- Apply effective code review techniques that balance thoroughness with speed, focusing on design, logic, and maintainability rather than stylistic preferences.
- Apply collective code ownership practices to ensure any team member can modify any part of the codebase, reducing bus factor risk and enabling flexible task assignment.
- Analyze knowledge distribution within the team using metrics like bus factor, code authorship distribution, and review participation to identify knowledge concentration risks.
Cross-functional collaboration
- Describe cross-functional team skills including development, testing, UX design, and documentation capabilities that enable the team to deliver a complete Increment.
- Apply T-shaped skill development to broaden individual capabilities beyond primary expertise, enabling more flexible task assignment and reducing team bottlenecks.
- Analyze team skill gaps that prevent independent Increment delivery and determine strategies for building missing capabilities through training, pairing, and practice.
Documentation and knowledge management
- Describe living documentation practices including self-documenting code, automated API documentation, and architecture decision records as alternatives to separate documentation artifacts.
- Apply documentation-as-code practices to maintain technical documentation alongside source code, ensuring documentation stays current through the same review and CI processes.
6
Domain 6: Architecture and Design in Agile
2 topics
Evolutionary architecture
- Describe evolutionary architecture as an approach where architecture decisions emerge incrementally through development rather than being fully specified upfront.
- Apply architectural decision records to document key design decisions, their rationale, and alternatives considered, maintaining architectural knowledge as the system evolves.
- Analyze the fitness functions approach to evolutionary architecture where automated tests verify that architectural properties are maintained as the system changes.
Simple design and YAGNI
- Describe the four rules of simple design: passes all tests, reveals intention, has no duplication, and has fewest elements, as a guide for iterative design improvement.
- Apply YAGNI (You Aren't Gonna Need It) principle to avoid premature optimization and speculative generality, implementing only what is needed for current requirements.
- Analyze the tension between future-proofing designs and YAGNI discipline to determine appropriate design investment levels for different levels of requirement uncertainty.
7
Domain 7: Version Control and Build Practices
2 topics
Version control practices
- Describe version control best practices including meaningful commit messages, atomic commits, and branching conventions that support team collaboration and continuous integration.
- Apply trunk-based development practices including short-lived feature branches, frequent integration, and feature toggles to minimize merge conflicts and integration delays.
- Analyze branching strategy effectiveness by evaluating merge frequency, conflict rates, and integration lead times to determine optimal branching approaches for the team.
Build automation
- Describe build automation principles including reproducible builds, dependency management, and build artifact versioning that support reliable continuous integration.
- Apply automated build pipeline configuration to create fast, reliable build processes that provide immediate feedback on code quality and test results.
- Analyze build pipeline performance by evaluating build times, failure patterns, and feedback latency to identify optimization opportunities that improve developer productivity.
Scope
Included Topics
- All topics in the Scrum Alliance CSD learning objectives aligned to the Scrum Guide (2020): Scrum framework from the Developer perspective, agile engineering practices, and collaborative development within Scrum teams.
- Scrum framework fundamentals as they apply to Developers including Sprint Backlog management, Daily Scrum participation, Increment creation, and adherence to the Definition of Done.
- Agile engineering practices including Test-Driven Development, refactoring, continuous integration, pair programming, code reviews, and sustainable technical practices.
- Software design principles in agile contexts including SOLID principles, emergent design, evolutionary architecture, and managing technical debt proactively.
- Collaborative development practices including collective code ownership, knowledge sharing, cross-functional skill development, and effective communication within the Scrum team.
- Quality assurance in Scrum including test automation strategies, acceptance test-driven development, behavior-driven development, and continuous testing integration.
Not Covered
- Advanced engineering leadership and multi-team technical coordination covered by A-CSD and CSP-D certifications.
- ScrumMaster-specific facilitation, coaching, and organizational change techniques covered by the Scrum Master track.
- Product Owner-specific backlog management, prioritization, and stakeholder engagement covered by the Product Owner track.
- Specific programming language syntax, framework configurations, or platform-specific implementation details.
- Infrastructure administration, cloud architecture, and DevOps pipeline construction beyond their relevance to agile development practices.
Official Exam Page
Learn more at Scrum Alliance
CSD is coming soon
Adaptive learning that maps your knowledge and closes your gaps.
Create Free Account to Be Notified