A-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.
A-CSD
The Advanced Certified Scrum Developer exam validates expertise in advanced testing, refactoring legacy code, agile architecture, DevOps integration, and technical leadership, enabling developers to deliver high‑quality, scalable solutions within Scrum teams.
Who Should Take This
It is intended for software engineers, senior developers, or technical leads who have at least twelve months of hands‑on experience working in Scrum teams. These professionals seek to deepen their mastery of testing, refactoring, architecture, and DevOps practices to drive technical excellence and strategic delivery in agile environments.
What's Covered
1
Domain 1: Advanced Testing Practices
2
Domain 2: Advanced Refactoring and Legacy Code
3
Domain 3: Architecture for Agility
4
Domain 4: DevOps Integration
5
Domain 5: Technical Leadership
6
Domain 6: Security in Agile Development
7
Domain 7: Performance and Scalability
What's Included in AccelaStudy® AI
Adaptive Knowledge Graph
Practice Questions
Lesson Modules
Console Simulator Labs
Exam Tips & Strategy
20 Activity Formats
Course Outline
60 learning goals
1
Domain 1: Advanced Testing Practices
3 topics
Advanced TDD
- Apply outside-in TDD starting from acceptance tests and driving implementation through progressively more detailed unit tests, creating a comprehensive test harness.
- Apply test double strategies including mocks, stubs, fakes, and spies to isolate units under test while maintaining meaningful behavioral verification.
- Analyze test design quality by evaluating test readability, brittleness, execution speed, and diagnostic value to maintain a sustainable and valuable test suite.
Testing legacy systems
- Apply characterization testing to document existing behavior of legacy code before modifying it, creating a safety net for subsequent refactoring.
- Apply seam identification techniques to find points in legacy code where behavior can be altered for testing without modifying the production code structure.
- Analyze legacy code testing strategies to determine the most cost-effective approach for adding test coverage considering code complexity, risk, and team familiarity.
- Design incremental test coverage improvement plans for legacy systems that prioritize high-risk and frequently changed areas over comprehensive but unfocused coverage.
Contract and integration testing
- Apply contract testing practices to verify service interactions without requiring full integration environments, using consumer-driven contracts for API boundary verification.
- Analyze integration testing strategies to balance confidence in system correctness with test execution speed and maintenance cost across the test pyramid.
2
Domain 2: Advanced Refactoring and Legacy Code
2 topics
Legacy code transformation
- Apply the strangler fig pattern to incrementally replace legacy system components with new implementations while maintaining continuous system operation.
- Apply branch by abstraction to introduce parallel implementations behind an abstraction layer, enabling gradual migration without big-bang rewrites.
- Analyze legacy system migration risk by evaluating code coupling, data dependencies, and operational constraints to determine safe migration sequencing.
- Design legacy modernization strategies that balance business continuity with technical improvement, creating a phased approach with measurable milestones.
Advanced refactoring techniques
- Apply safe refactoring under pressure techniques including small steps, frequent commits, and automated refactoring tools to improve code quality within Sprint constraints.
- Apply dependency breaking techniques to decouple tightly coupled code components, creating clear module boundaries that enable independent testing and deployment.
- Analyze refactoring impact on system behavior using pre-existing tests and automated verification to ensure refactoring preserves correctness while improving design.
- Design a refactoring practice adoption strategy for teams new to systematic refactoring, incorporating kata exercises, pair refactoring sessions, and measurable quality metrics.
3
Domain 3: Architecture for Agility
4 topics
Modular design strategies
- Apply modular monolith architecture patterns to organize code into well-bounded modules with clear interfaces while maintaining deployment simplicity.
- Apply API-first design to define service interfaces before implementation, enabling parallel development and establishing clear contracts between system components.
- Analyze architectural boundaries to determine appropriate module granularity, balancing independent deployability with operational complexity and data consistency requirements.
- Design evolutionary architecture strategies using fitness functions that automatically verify architectural properties as the system evolves across multiple Sprints.
Microservices considerations
- Apply microservices architecture evaluation criteria to determine when microservices provide genuine benefits versus when a modular monolith better serves team and product needs.
- Analyze the operational complexity tradeoffs of microservices including distributed system challenges, data consistency, observability, and deployment orchestration.
- Design service decomposition strategies that align service boundaries with team boundaries and business capabilities to minimize cross-team coordination overhead.
Event-driven architecture
- Apply event-driven architecture patterns including event sourcing and CQRS to design systems with clear separation of write and read concerns for complex domains.
- Analyze the tradeoffs of event-driven architectures including eventual consistency, debugging complexity, and event schema evolution to determine appropriate use cases.
Data management in agile
- Apply database migration strategies that support continuous delivery including versioned schema migrations, backward-compatible changes, and zero-downtime deployments.
- Analyze data architecture decisions including relational vs. document vs. graph database selection based on access patterns, consistency requirements, and team expertise.
4
Domain 4: DevOps Integration
2 topics
Infrastructure and deployment automation
- Apply infrastructure as code practices to manage deployment environments through version-controlled configuration, enabling reproducible and auditable infrastructure changes.
- Apply feature flag techniques to decouple deployment from release, enabling continuous deployment to production while controlling feature visibility for different user segments.
- Apply canary deployment and blue-green deployment strategies to reduce release risk by gradually exposing changes to production traffic with automated rollback capability.
- Analyze deployment pipeline metrics including deployment frequency, lead time, failure rate, and recovery time to evaluate and improve continuous delivery maturity.
Monitoring and observability
- Apply observability practices including structured logging, distributed tracing, and metrics collection to gain insight into production system behavior and performance.
- Apply production readiness reviews to evaluate whether new features meet operational requirements including monitoring, alerting, scaling, and failure recovery.
- Analyze production incident patterns to identify systemic reliability issues and design improvements that prevent recurrence rather than just addressing individual incidents.
- Design on-call and incident response processes that integrate with Scrum team workflows, balancing production support responsibilities with Sprint delivery commitments.
5
Domain 5: Technical Leadership
3 topics
Influencing technical decisions
- Apply technical decision-making frameworks to evaluate architectural options, tool selections, and practice adoption using criteria including reversibility, risk, and learning value.
- Apply architectural decision record practices to document significant technical decisions with context, options considered, and rationale for team knowledge sharing.
- Analyze the impact of technical decisions on team velocity, code maintainability, and system operability to make evidence-based recommendations for technical direction.
Engineering culture and mentoring
- Apply mentoring practices to help junior developers adopt engineering practices including TDD, refactoring, and clean code through pairing, code review, and structured learning.
- Apply engineering practice adoption strategies including coding dojos, hackathons, and practice communities to build team-wide technical capability and enthusiasm.
- Analyze team engineering culture by evaluating practice adoption rates, code quality trends, and technical learning investment to identify culture improvement opportunities.
- Design a technical excellence roadmap that progressively raises engineering practice standards across the team through structured learning, practice, and feedback.
- Design engineering excellence assessment rubrics that teams can use for self-evaluation, tracking practice maturity across testing, CI/CD, architecture, and collaboration dimensions.
Technical debt advocacy
- Apply technical debt quantification techniques to translate code quality issues into business impact terms that Product Owners and stakeholders can understand and prioritize.
- Analyze technical debt trends using static analysis metrics, code complexity measures, and developer feedback to identify high-impact debt reduction opportunities.
- Design technical debt reduction strategies that integrate debt repayment into regular Sprint work through refactoring budgets, quality Gates, and boy scout rule adoption.
6
Domain 6: Security in Agile Development
2 topics
Secure development practices
- Apply secure coding practices including input validation, output encoding, and authentication handling to prevent common vulnerabilities during development.
- Apply threat modeling techniques to identify security risks early in the design process, integrating security analysis into Sprint refinement and planning.
- Analyze security testing integration strategies including SAST, DAST, and dependency scanning to determine appropriate security gates in the CI/CD pipeline.
- Design a DevSecOps approach that embeds security practices into the development workflow, making security a shared responsibility rather than a gate at the end.
Compliance and regulatory considerations
- Apply compliance-as-code practices to automate regulatory requirement verification, reducing manual audit overhead while maintaining continuous compliance.
- Analyze the impact of regulatory requirements on agile development practices to determine how to maintain agility while satisfying compliance obligations.
7
Domain 7: Performance and Scalability
2 topics
Performance engineering
- Apply performance testing practices including load testing, stress testing, and performance profiling integrated into the Sprint cadence to catch performance regressions early.
- Apply performance budgeting techniques to set and enforce performance targets for response times, throughput, and resource consumption as part of the Definition of Done.
- Analyze performance test results to identify bottlenecks, resource contention, and scalability limits, recommending targeted optimization strategies based on empirical data.
Scalability patterns
- Apply horizontal and vertical scaling patterns to design systems that can accommodate growth in users, data volume, and transaction throughput.
- Apply caching, asynchronous processing, and database optimization strategies to improve system performance within existing infrastructure constraints.
- Analyze scalability requirements and growth projections to determine the appropriate scaling strategy considering cost, complexity, and time-to-implementation tradeoffs.
- Design capacity planning approaches that anticipate growth requirements and integrate capacity assessment into the Sprint review process for stakeholder visibility.
Scope
Included Topics
- All topics in the Scrum Alliance A-CSD learning objectives: advanced engineering practices, technical leadership within Scrum teams, architecture for agility, and DevOps integration.
- Advanced TDD practices including outside-in TDD, test doubles and mocking strategies, and testing legacy code through characterization tests and approval testing.
- Advanced refactoring techniques including working with legacy code, strangler fig pattern, branch by abstraction, and safe refactoring under time pressure.
- Architecture for agility including microservices considerations, modular monolith design, API-first development, and managing architectural boundaries in evolving systems.
- DevOps practices integration including infrastructure as code, monitoring and observability, feature flags, canary deployments, and production readiness reviews.
- Technical leadership including influencing technical decisions, building engineering culture, mentoring junior developers, and advocating for technical excellence within Scrum teams.
Not Covered
- Foundational Scrum framework and basic engineering practices covered by CSD certification.
- Enterprise-level architecture governance and technical strategy covered by CSP-D certification.
- ScrumMaster and Product Owner track competencies including facilitation, coaching, and product strategy.
- Specific programming language syntax, framework configurations, or vendor-specific platform details.
- Project management, budgeting, and organizational change management techniques.
Official Exam Page
Learn more at Scrum Alliance
A-CSD is coming soon
Adaptive learning that maps your knowledge and closes your gaps.
Create Free Account to Be Notified