.png&w=3840&q=75)
Question bank
Advanced Certified Scrum Developer (A-CSD)
42 Advanced Certified Scrum Developer (A-CSD) questions with the correct answer and a written explanation, organised across 6 exam domains.
- 42 questions
- 6 domains
- Foundation level
certilumQuestion index
Jump straight to any question. Answers and explanations are inline.
Agile Engineering Practices
8 questions in this domain
- Question 1Single Choice
In the A-CSD context, what does the principle of Collective Ownership of the Increment primarily mean?
- AEach developer is solely accountable for their assigned code modules.
- BThe whole development group is collectively accountable for quality and seamless integration.Correct answer
- CThe Product Owner is accountable for the quality of every Increment.
- DThe Scrum Master must ensure that every code change is personally reviewed.
Why this is the answer
Collective ownership means no single person is responsible for a piece of code; the entire team ensures every item meets the Definition of Done and integrates seamlessly.
- Question 2Multiple Select
Which two behaviors reflect Developer self-management and task autonomy in the A-CSD framework?
- AWaiting for the Project Manager to assign each task.
- BDeciding how to turn Product Backlog items into Increments of value.Correct answer
- CManaging their own workload and identifying dependencies.Correct answer
- DEscalating every technical adjustment to the Product Owner for approval.
Why this is the answer
Advanced Developers decide how to turn Backlog items into value, manage their own workload, and adjust their technical approach without waiting for manager assignments.
- Question 3Interactive
Based on the code block, which A-CSD engineering accountability is most directly threatened for the development team?
- ACollective ownership of the IncrementCorrect answer
- BAdherence to the Definition of Done
- CNegotiating technical debt
- DArchitectural runway management
Why this is the answer
The comment shows that only one developer understands the logic, creating a knowledge silo and a single point of failure, so collective ownership is violated.
- Question 4Single Choice
What does the Managerial Fallacy refer to in the A-CSD material?
- AAssuming a Project Manager or Scrum Master is responsible for ensuring developers follow technical standards.Correct answer
- BBelieving that developers should not manage their own workload.
- CThinking the Product Owner should define the Definition of Done.
- DAssuming all technical decisions require business approval.
Why this is the answer
The Managerial Fallacy is assuming that a Project Manager or Scrum Master enforces technical standards and task completion instead of the Developers themselves.
- Question 5Multiple Select
Which three activities are part of Technical Backlog Refinement according to the playbook?
- ACollaborating with the Product Owner to decompose complex storiesCorrect answer
- BIdentifying dependencies and clarifying technical constraintsCorrect answer
- CEnsuring the Definition of Ready is metCorrect answer
- DReplacing the Product Owner's priorities with technical preferences
Why this is the answer
Technical Backlog Refinement is a collaboration with the PO to decompose stories, identify dependencies, clarify constraints, and meet the Definition of Ready before the Sprint.
- Question 6Interactive
If a developer proposes the database change in the code block without informing the Product Owner, which trap is being committed?
- AThe Silo FallacyCorrect answer
- BThe Translator Gap
- COwnership Confusion
- DThe Task-Oriented Trap
Why this is the answer
The Silo Fallacy is the assumption that technical decisions such as schema changes have no business impact and require no Product Owner awareness.
- Question 7Single Choice
What is the Definition of Done in the A-CSD framework?
- AIt is the primary measure of accountability for the Increment.Correct answer
- BIt is an optional checklist for the Product Owner.
- CIt is a suggestion to be applied only when time permits.
- DIt is a documentation artifact maintained by the Scrum Master.
Why this is the answer
The Definition of Done is the primary measure of accountability; no item may be marked Done unless every specified criterion has been satisfied.
- Question 8Multiple Select
Which three impacts are associated with neglecting technical debt, as described in the A-CSD material?
- AA codebase that becomes harder to maintain.Correct answer
- BReduced delivery velocity.Correct answer
- CIncreased defect rates.Correct answer
- DA guarantee of more business features.
Why this is the answer
Neglecting technical debt makes the codebase harder to maintain and can reduce velocity and increase defect rates, threatening the product's long-term viability.
Scrum Artifacts
7 questions in this domain
- Question 9Single Choice
In the context of Scrum, what does collective ownership of the Increment mean for the development team?
- AEveryone is accountable for overall qualityCorrect answer
- BEach developer owns one module
- CThe Product Owner owns quality
- DThe Scrum Master fixes defects
Why this is the answer
Collective ownership means all developers share accountability for the quality of the whole Increment, not for isolated pieces.
- Question 10Multiple Select
Which two actions reflect self-management for an advanced Scrum developer when delivering value during a Sprint?
- ADeciding how to turn Product Backlog items into IncrementsCorrect answer
- BWaiting for a manager to assign tasks
- CManaging workload and identifying dependenciesCorrect answer
- DEscalating all decisions to the Product Owner
Why this is the answer
Advanced developers decide how to build Increments, manage their workload, identify dependencies, and adjust their technical approach during the Sprint.
- Question 11Interactive
Review the code block and identify which Scrum accountability principle is violated by the logic shown.
- AAdherence to the Definition of DoneCorrect answer
- BCollective ownership
- CTechnical refactoring
- DNFR integration
Why this is the answer
The code marks an item as Done without satisfying all Definition of Done criteria, violating the primary measure of team accountability.
- Question 12Single Choice
According to Scrum, what is the primary measure of accountability for a Scrum team's Increment?
- AThe Definition of DoneCorrect answer
- BThe Sprint velocity
- CThe Product Owner's approval
- DNumber of automated tests
Why this is the answer
The Definition of Done is the primary measure; no item is Done unless every DoD criterion is met.
- Question 13Multiple Select
Which two practices help prevent technical knowledge from being siloed in a Scrum team of developers?
- AConducting rigorous peer reviewsCorrect answer
- BMentoring teammatesCorrect answer
- CKeeping code knowledge within each specialty
- DAvoiding collaboration to save time
Why this is the answer
Peer reviews and mentoring spread knowledge, reduce silos, and prevent single points of failure within the team.
- Question 14Interactive
Review the code block. Which trap occurs when a developer makes this database change without informing the Product Owner?
- ASilo FallacyCorrect answer
- BTranslator Gap
- CTask-Oriented Trap
- DManagerial Fallacy
Why this is the answer
The Silo Fallacy assumes technical decisions such as database changes have no business impact; they require Product Owner awareness.
- Question 15Single Choice
Who is the only person with authority to change the Product Backlog according to Scrum?
- AThe Product OwnerCorrect answer
- BAny developer
- CThe Scrum Master
- DThe development manager
Why this is the answer
Even though developers own the Sprint Backlog, the Product Backlog is changed only by the Product Owner.
Scrum Events
8 questions in this domain
- Question 16Single Choice
According to the playbook, in the context of the Advanced Certified Scrum Developer, what is the primary measure of developer accountability?
- AThe Definition of DoneCorrect answer
- BThe number of completed tasks
- CThe Product Owner's satisfaction
- DThe Sprint burndown chart
Why this is the answer
The Definition of Done is the primary measure of accountability. Developers must ensure every criterion is met before any item is considered Done.
- Question 17Multiple Select
Which of the following are presented in the playbook as accountability traps that developers should avoid? Select all that apply.
- AManagerial FallacyCorrect answer
- BTask-Oriented TrapCorrect answer
- CSilo AssumptionCorrect answer
- DCollective Ownership
Why this is the answer
The Managerial Fallacy, Task-Oriented Trap, and Silo Assumption are the accountability traps listed in the playbook. Collective Ownership is a positive practice, not a trap.
- Question 18Interactive
Read the developer comment in the code block. Which accountability principle from the playbook is contradicted by the comment?
- ACollective ownership of the IncrementCorrect answer
- BAdherence to Definition of Done
- CNFR Integration
- DArchitectural Runway Management
Why this is the answer
The comment reflects a siloed mindset, which violates the principle of collective ownership of the whole Increment.
- Question 19Single Choice
When collaborating with the Product Owner in a Scrum event, how should an A-CSD developer communicate technical debt?
- ATranslate technical risks into business termsCorrect answer
- BUse detailed technical jargon only
- CAvoid mentioning debt until it blocks work
- DAsk the Scrum Master to fix the debt
Why this is the answer
A-CSD developers translate technical debt into business terms so the Product Owner can prioritize maintenance and refactoring alongside new features.
- Question 20Multiple Select
According to the playbook, which activities are part of Technical Backlog Refinement? Select all that apply.
- ACollaborating with the PO to decompose user storiesCorrect answer
- BIdentifying dependencies among technical tasksCorrect answer
- CEnsuring the Definition of Ready is metCorrect answer
- DAssigning work by the manager
Why this is the answer
Technical Backlog Refinement includes decomposing user stories, identifying dependencies, and ensuring Definition of Ready. Assigning work by a manager is not part of it.
- Question 21Interactive
Review the code block. Which two practices would help the developer communicate this performance issue effectively to the Product Owner? Select all that apply.
- ATranslate the issue into business termsCorrect answer
- BIgnore the performance concern
- CInclude NFRs like latency in the Product BacklogCorrect answer
- DAsk the Project Manager to assign the work
Why this is the answer
Developers should turn performance issues into business impact and ensure NFRs such as latency are represented in the Product Backlog. Ignoring or delegating the issue is not advised.
- Question 22Single Choice
According to the playbook, what does the phrase 'collective ownership of the Increment' mean for developers?
- AThe entire team is accountable for the whole IncrementCorrect answer
- BEach developer owns their assigned code only
- CThe Product Owner reviews all code changes
- DThe Scrum Master fixes all defects
Why this is the answer
Collective ownership means the entire group is accountable for the quality and integration of the Increment, not only for individual modules.
- Question 23Multiple Select
Which statements reflect the playbook's guidance on peer review and knowledge sharing? Select all that apply.
- AConduct rigorous peer reviewsCorrect answer
- BMentor one another to avoid siloed knowledgeCorrect answer
- CReduce single points of failure within the teamCorrect answer
- DLimit code knowledge to the original specialist
Why this is the answer
Peer reviews and mentoring reduce knowledge silos and single points of failure. Restricting code knowledge to one specialist contradicts the playbook.
Scrum Roles
7 questions in this domain
- Question 24Single Choice
What is the core meaning of collective ownership of the Increment in Scrum?
- AEach developer owns a specific module
- BThe team collectively ensures Increment qualityCorrect answer
- CThe Scrum Master owns integration quality
- DOnly senior developers guarantee quality
Why this is the answer
Collective ownership means no single person owns a code area; the whole team is accountable for Increment quality and Definition of Done adherence.
- Question 25Multiple Select
Which accountabilities are part of self-management for Advanced Scrum Developers?
- ADeciding how to deliver Product Backlog valueCorrect answer
- BWaiting for a manager to assign tasks
- CManaging workload and identifying dependenciesCorrect answer
- DAdjusting technical approach during the SprintCorrect answer
Why this is the answer
Self-management includes deciding how to deliver value, managing workload, identifying dependencies, and adjusting technical approach without waiting for manager assignment.
- Question 26Interactive
Review the provided code snippet. What accountability violation is represented?
- AFailing to adhere to the Definition of DoneCorrect answer
- BDelaying the Sprint Retrospective
- CAssigning work to the Product Owner
- DHiding technical debt from stakeholders
Why this is the answer
The code marks an item Done based on some checks rather than every Definition of Done criterion, violating the primary measure of accountability.
- Question 27Single Choice
What is the managerial fallacy in Scrum?
- AAssuming a manager ensures technical qualityCorrect answer
- BDevelopers deciding how to accomplish Sprint work
- CThe Product Owner prioritizing the Product Backlog
- DThe team conducting peer reviews
Why this is the answer
The managerial fallacy incorrectly places responsibility for developer task completion and technical standards on a Scrum Master or Project Manager.
- Question 28Multiple Select
Which activities are part of Technical Backlog Refinement with the Product Owner?
- ADecomposing user stories into technical tasksCorrect answer
- BIdentifying dependencies and ensuring Definition of ReadyCorrect answer
- CClarifying technical constraints earlyCorrect answer
- DAssigning story points to the Product Owner
Why this is the answer
Developers collaborate with the Product Owner to decompose stories, identify dependencies, meet Definition of Ready, and clarify technical constraints.
- Question 29Interactive
Review the code snippet. Which Product Owner collaboration trap is being demonstrated?
- AThe Translator GapCorrect answer
- BThe Silo Fallacy
- COwnership Confusion
- DThe Managerial Fallacy
Why this is the answer
The developer explains technical debt using database-specific jargon, creating a lack of shared understanding with the Product Owner. This is the Translator Gap.
- Question 30Single Choice
How should Developers communicate technical debt to a Product Owner?
- ATranslating technical risk into business impactCorrect answer
- BAvoiding any mention of technical debt
- CUsing complex code jargon with the Product Owner
- DLetting the Scrum Master prioritize debt alone
Why this is the answer
Developers must translate technical debt into business impact, such as reduced velocity and higher defect rates, to align prioritization with the Product Owner.
Scrum Theory & Values
6 questions in this domain
- Question 31Single Choice
In Scrum, what is the primary measure of a team's accountability for the quality of the Increment?
- ADefinition of DoneCorrect answer
- BSprint Review feedback
- CProduct Owner approval
- DNumber of completed tasks
Why this is the answer
The Definition of Done is the primary measure of accountability; developers must satisfy every criterion before an item can be considered Done.
- Question 32Multiple Select
Which practices help a team build collective ownership of the Increment rather than relying on individual specialists?
- APerforming rigorous peer reviewsCorrect answer
- BCoaching one another to prevent knowledge silosCorrect answer
- CAvoiding review of code outside your specialty
- DEscalating every defect to a single senior developer
Why this is the answer
Collective ownership requires peer reviews and mentoring across the team so technical knowledge is not siloed and no single point of failure remains.
- Question 33Interactive
Using the doneCriteria list in the code_block, if a feature satisfies only three of the four criteria, what action should the team take?
- ARefuse to call it Done until all criteria are metCorrect answer
- BMark it Done if the Product Owner agrees
- CMark it Done because most criteria are satisfied
- DMove the unmet criterion to the next Sprint and still call it Done
Why this is the answer
The Definition of Done is binary; a team must meet every criterion before an item can be transparently marked as Done.
- Question 34Single Choice
What is the mistake called when a team measures success by completing tickets instead of producing a high-quality, usable Increment?
- AThe Task-Oriented TrapCorrect answer
- BThe Managerial Fallacy
- CThe Silo Assumption
- DOwnership Confusion
Why this is the answer
The Task-Oriented Trap occurs when the team focuses on completing specific tickets rather than delivering a high-quality Increment that meets the Definition of Done.
- Question 35Multiple Select
Which activities are part of technical backlog refinement with the Product Owner?
- ADecomposing user stories into actionable technical tasksCorrect answer
- BIdentifying dependencies that could block future SprintsCorrect answer
- CGuaranteeing that no technical debt will ever be introduced
- DClarifying technical constraints before the Sprint beginsCorrect answer
Why this is the answer
Technical backlog refinement focuses on breaking down stories, identifying dependencies, and clarifying constraints early so downstream Sprint bottlenecks are avoided.
- Question 36Interactive
Read the infrastructure status in the code_block. What should the developers discuss with the Product Owner to prevent an architectural cliff?
- AAdd infrastructure enablement work to the Product Backlog with the Product OwnerCorrect answer
- BProceed with the feature and design the payment integration later
- CTreat the infrastructure as a purely technical decision and ignore the Product Owner
- DCancel the Sprint and stop all planning with the Product Owner
Why this is the answer
Developers must work with the Product Owner to ensure the system has enough infrastructure to support upcoming business features, preventing architectural cliffs.
Team Collaboration & Technical Practices
6 questions in this domain
- Question 37Single Choice
According to the Scrum Alliance, which group is collectively accountable for the quality of the Increment?
- AThe Product Owner
- BThe Scrum Master
- CThe DevelopersCorrect answer
- DThe Stakeholders
Why this is the answer
Developers are collectively accountable for the quality of the Increment; the whole group ensures every item meets the Definition of Done and integrates seamlessly into the product.
- Question 38Multiple Select
Which responsibilities reflect the developers' commitment to technical excellence and team growth? Select all that apply.
- AProactively manage technical debt by refactoring the codebaseCorrect answer
- BEnsure the Definition of Done is met for all completed itemsCorrect answer
- CWait for a project manager to assign technical tasks
- DConduct rigorous peer reviews and mentor colleaguesCorrect answer
Why this is the answer
Advanced Developers are accountable for technical practices, DoD adherence, peer reviews, and knowledge sharing. Waiting for a project manager would reflect the Managerial Fallacy.
- Question 39Interactive
Review the developer comment in the code block. Which accountability misconception is being demonstrated?
- ACollective Ownership
- BManagerial Fallacy
- CSilo AssumptionCorrect answer
- DTask-Oriented Trap
Why this is the answer
The statement reflects the Silo Assumption: believing a specialist is only accountable for their specific module instead of recognizing collective accountability for the whole system.
- Question 40Single Choice
What is the primary measure of accountability for Developers in Scrum?
- AThe Sprint Backlog
- BThe Product Owner's request
- CThe Definition of DoneCorrect answer
- DThe number of story points completed
Why this is the answer
The Definition of Done is the primary measure of accountability. Developers must ensure no item is marked Done unless it meets every single criterion in the DoD.
- Question 41Multiple Select
Which practices demonstrate proper collaboration between Developers and the Product Owner during Product Backlog refinement? Select all that apply.
- ADecomposing complex user stories into actionable technical tasksCorrect answer
- BTranslating technical risks into business terms to prioritize refactoringCorrect answer
- CIncluding non-functional requirements such as scalability in the Product BacklogCorrect answer
- DMaking unapproved changes to the Product Backlog using Sprint Backlog authority
Why this is the answer
Developers collaborate with the Product Owner by decomposing stories, negotiating technical debt in business terms, and integrating non-functional requirements. Changing the Product Backlog without PO consultation is a form of ownership confusion.
- Question 42Interactive
Read the statement in the code block. Which trap is the developer falling into?
- AThe Silo FallacyCorrect answer
- BThe Translator Gap
- CThe Task-Oriented Trap
- DThe Managerial Fallacy
Why this is the answer
The statement demonstrates the Silo Fallacy: assuming technical decisions are purely technical and do not require Product Owner awareness, even when they have business impact.
Frequently asked questions
Everything about the Advanced Certified Scrum Developer (A-CSD) question bank and how to use it.