Refer to the Exhibit Practice Questions

Allowing external quality auditors and invited stakeholders to attend and provide direct feedback to the Scrum Team.

Why it fails: Scrum explicitly welcomes invited stakeholders and others whose feedback helps inspect the Increment; external auditors attending is permitted, not a violation. It tempts because audit involvement feels intrusive, yet the Sprint Review is an open working session, not a closed ceremony.

Allocating a 4-hour maximum timebox for a standard one-month Sprint duration as defined in the configuration.

Why it fails: Scrum prescribes a four-hour timebox for a one-month Sprint Review, so this allocation complies rather than violates. It tempts because long meetings seem excessive, but the timebox is a defined Scrum rule, and shortening it would breach the framework.

Requiring the presence of both the Product Owner and the Developers alongside stakeholders during the review session.

Why it fails: Scrum mandates that the Product Owner and Developers attend the Sprint Review alongside stakeholders; their presence is required, not a violation. This option is tempting because stakeholder-only reviews are common in traditional gate meetings, but excluding the team contradicts Scrum's inspect-and-adapt purpose.

Help management refine the formula used to calculate velocity so that team comparisons become mathematically fair and statistically accurate.

Why it fails: Velocity is a forecasting aid for one team, not a productivity metric; ranking teams on it drives point inflation and hides real impediments. Refining the formula cannot make cross-team comparison valid, since estimation baselines differ. The ScrumMaster should instead coach management to drop the ranking and use velocity only for the team's own sprint planning.

Instruct all development teams to artificially inflate their story point estimates so that every single team ties for the top ranking every month.

Why it fails: Instructing teams to inflate estimates corrupts the data and breaches Scrum values of openness and honesty, leaving the underlying misuse of velocity unaddressed. Inflating estimates is defensible only where teams genuinely re-estimate after learning, never as a coordinated tactic against management.

Publicly publish the salaries and individual performance reviews of the management team to create parity and force them to abandon their stack-ranking practice.

Why it fails: Publishing management salaries and reviews retaliates against leadership rather than addressing the metric misuse, damaging trust and your own credibility. Transparency of this kind belongs in governance or pay-equity initiatives, not in response to velocity being used as a performance ranking.

Ensure all teams prioritize coverage above new features.

Why it fails: Mandating a focus on a single metric at the expense of product value misrepresents the Scrum approach. The Scrum Master should encourage teams to balance quality with delivery. Prioritizing coverage over all else might lead to testing trivial code while leaving critical business logic untested and vulnerable to failure.

Publish the coverage results to create healthy competition.

Why it fails: Creating competition between teams is rarely healthy in an agile environment. It fosters silos and discourages the teams from sharing knowledge or helping one another. The Scrum Master should promote a culture of collaboration where teams learn from each other to improve quality across the whole organization.

Ask the Developers to stop tracking coverage for HR.

Why it fails: Simply stopping the tracking doesn't solve the underlying pressure from leadership. The Scrum Master needs to engage in a conversation about the purpose of the metric. By addressing the root cause of the pressure, the Scrum Master helps the organization align on better ways to measure improvement.

Enforce these policies strictly to maintain organizational compliance.

Why it fails: Enforcing counter-productive policies creates 'Zombie Scrum' where teams follow rituals without the underlying values. The Scrum Master's role is to challenge impediments to agility. Maintaining policies that prioritize control over delivery prevents the team from effectively using empirical process control to improve their product outcomes.

Ask the team to ignore the policies while continuing their work.

Why it fails: Ignoring corporate policy creates unnecessary risk and potential conflict for the development team. The Scrum Master must handle organizational impediments at the systemic level rather than encouraging developers to break rules. Sustainable change requires changing the policies themselves through leadership engagement, not through quiet defiance by the team.

Advise the PMO to attend the Sprint Review to gain transparency.

Why it fails: While the Sprint Review is an appropriate venue for stakeholders, the policy itself mandates a separate reporting structure that fragments the team's focus. Simply adding another meeting does not address the underlying, inefficient reporting requirements. The focus should be on eliminating the waste caused by redundant reporting structures.

Immediately send the escalation to upper management to clear the path.

Why it fails: Escalation should be a last resort. The Scrum Master should first attempt to facilitate collaboration between the teams to resolve the dependency. Bypassing direct communication undermines the professional relationship between teams and may create unnecessary friction or defensive behavior from the other team involved in the dependency issue.

Document the delay in the Sprint backlog and adjust the Sprint Goal accordingly.

Why it fails: Adjusting the goal without trying to solve the problem is premature. The Scrum Master must act as an advocate for the team to remove impediments. Simply documenting the failure ignores the active service required from a Scrum Master to help the team achieve their goals in the face of obstacles.

Tell the Product Owner that the current Sprint is now a failure and should be cancelled.

Why it fails: Canceling a Sprint is a drastic measure and should only be done if the Sprint Goal becomes obsolete. A single dependency is rarely a reason to scrap an entire Sprint. The Scrum Master's duty is to help the team overcome obstacles, not to prematurely call for a Sprint cancellation.

Advise the team to extend their Sprint length to 24 days to accommodate the audit.

Why it fails: Extending the Sprint is a temporary fix that does not solve the underlying issue of slow, gated security processes. It slows down the feedback loop, which is contrary to the benefits of Scrum. This approach accepts the impediment as permanent rather than working to change the organizational process, which hinders the organization's agility.

Ask the security department to waive the audit for all Scrum Teams.

Why it fails: Asking for a waiver ignores the legitimate need for security and will likely be rejected by the organization. The Scrum Master must influence the process, not just ask for exemptions. This approach is naive and fails to provide a constructive, sustainable solution that addresses the organization's security concerns while also meeting the team's needs.

Report the security department to the CEO for blocking the team's progress.

Why it fails: Escalating aggressively without first attempting collaborative, educational solutions is a destructive tactic. It creates conflict and defensiveness, making it harder to solve the problem. The Scrum Master should seek to influence and coach, not use executive power to punish other departments. This approach is unlikely to produce the desired organizational change and process improvement.

The team size is too small; they need more developers.

Why it fails: A team of 10 is within the recommended size. Adding more people would likely increase coordination overhead and make the communication issues worse, not better. The problem is not the number of people, but how they are organized and how they collaborate on the work items themselves.

The Product Owner is not providing clear requirements for the backend work.

Why it fails: While it is possible the requirements are unclear, the issue of 'waiting' is primarily a technical and collaborative bottleneck. Attributing this to the Product Owner is a guess that doesn't solve the structural problem of the team being organized into functional silos instead of being a cross-functional unit.

The Scrum Master failed to assign the backend work to the frontend developers.

Why it fails: Assigning work is not the Scrum Master's role. If the Scrum Master started assigning tasks, it would further entrench the command-and-control behavior that limits the team's autonomy. The solution is for the team to recognize their need to share knowledge and cross-train to remove these internal dependencies.

Reassign tasks to individual team members to increase accountability and boost the output for the next Sprint.

Why it fails: Scrum teams are self-organizing and cross-functional; assigning tasks individually undermines team ownership and collaboration. When the Scrum Master interferes with task distribution, it reduces the team's autonomy and creates a top-down management style that contradicts Scrum principles. Teams should own their planning and execution process to ensure long-term success.

Report the performance discrepancy to senior management to request additional staffing for the upcoming Sprint.

Why it fails: Escalating internal team performance metrics to management is a violation of the team's trust and autonomy. The Scrum Master serves the team internally; seeking external intervention for velocity issues treats the symptoms rather than the root cause. Effective Scrum teams handle their own challenges through empirical process control and reflection.

Adjust the team's definition of done to allow for smaller story point increments to inflate future velocity.

Why it fails: Manipulating the Definition of Done to inflate velocity is a dishonest practice that creates technical debt and hides quality issues. Velocity is a planning tool, not a performance metric. By artificially inflating these numbers, the team loses the ability to accurately forecast future work, leading to unrealistic stakeholder expectations.

Enforce the policy strictly by blocking the Sprint Planning if items are missing estimates.

Why it fails: Strict enforcement by the Scrum Master creates an adversarial relationship with the Developers. The Scrum Master is a servant-leader, not a policy enforcer. If the team finds the policy difficult to follow, there should be a discussion about its utility and how it can be simplified or improved.

Change the policy to remove the requirement for value estimates to speed up the planning process.

Why it fails: Changing a policy without consulting the team and the Product Owner ignores the collaborative nature of Scrum. The Product Owner and Developers need to agree on what information is necessary for effective planning. Arbitrary changes made by the Scrum Master undermine the team's ownership of their process.

Ask the Product Owner to provide all estimates themselves so the Developers can focus on building.

Why it fails: The Product Owner cannot accurately estimate the effort required for development work; that is the responsibility of the Developers. This separation of concerns is vital for accurate planning. If the Product Owner estimates effort, the plan will be based on inaccurate data, leading to failed sprints.

The event was a failure because the Product Owner must attend every meeting.

Why it fails: The Scrum Guide does not mandate the Product Owner's attendance at the Daily Scrum. If the Developers can effectively synchronize and plan their work, the event is successful. Stating it was a failure ignores the goal of the meeting and incorrectly applies rules not found within the Scrum framework itself.

The Scrum Master should report the Product Owner for missing the required event.

Why it fails: There is no requirement to report the Product Owner. The Scrum Master should focus on whether the team was able to achieve the purpose of the Daily Scrum. Reporting someone for a non-violation creates unnecessary conflict and demonstrates a misunderstanding of the actual requirements and accountabilities described in the Scrum Guide.

The Scrum Master should cancel the meeting if the Product Owner cannot attend.

Why it fails: Canceling the meeting prevents the Developers from coordinating their work. The Developers are the ones who need to synchronize, not the Product Owner. Canceling the meeting based on the Product Owner's absence would be a significant disservice to the Developers, who rely on the event for their daily planning activities.

Instruct the Scrum Team to work on lower priority tasks while waiting.

Why it fails: This approach ignores the impediment and does not resolve the systemic issue affecting the Product Backlog. By shifting focus, the team fails to deliver the highest value items, leading to missed goals. The Scrum Master should focus on clearing the path for the team's planned work instead of bypassing.

Take over the tasks assigned to the Infrastructure Team to speed up delivery.

Why it fails: A Scrum Master should not become a surrogate developer or take on technical tasks. This creates a dependency on the Scrum Master, hinders the team's self-organization, and ignores the long-term need for better cross-departmental coordination. The goal is to improve organizational processes, not to perform technical work personally.

Update the impediment log and wait for the Infrastructure Team to respond.

Why it fails: Passive tracking of impediments does not constitute active removal. The Scrum Master must lead the effort to resolve external blockers. By waiting for the other team, you allow the negative impact on the Sprint to continue, which undermines the organization's commitment to supporting the Scrum Team's delivery cycle.

Advise the Product Owner to address the 'Database Migration' first to clear the complex technical debt.

Why it fails: Prioritizing low-value items just because they are complex is a common trap. While technical debt matters, it should be balanced against the need for high-value delivery. Starting with high-value items ensures that the team delivers a usable product increment that stakeholders can see and provide feedback on.

Tell the Product Owner to group all items by type and complete the lowest complexity items first.

Why it fails: Prioritizing based on complexity rather than value is contrary to Scrum's focus on maximizing product value. Finishing small tasks quickly does not guarantee that the most important business needs are met. The Product Owner must order the backlog based on a strategic view of value and risk.

Recommend that the Scrum Master randomly select the order to ensure the team stays motivated and focused.

Why it fails: Random selection ignores the business purpose of the product and undermines the Product Owner's accountability. Team motivation comes from working on meaningful, high-impact tasks, not from arbitrary assignment. Strategic ordering is essential for the team to understand why they are working on specific features.

The log format is incorrect for reporting purposes.

Why it fails: The format is irrelevant compared to the actual content of the actions. The issue is that velocity and individual performance are being tracked, which is a major violation of the Scrum ethos. Focusing on the format misses the fundamental damage being done to the team's culture and self-management capabilities.

The Scrum Master is tracking the wrong metrics.

Why it fails: The problem isn't just the 'wrong' metrics; it is the act of using any metrics for command-and-control purposes. Even if they were tracking different metrics, using them for management oversight would still be an anti-pattern. The core issue is the misuse of data for management-driven performance assessment, not the data itself.

The logging system is not capturing enough information.

Why it fails: Capturing more information is not the priority here; stopping the harmful practices is. The logging system is irrelevant when the actions being logged are fundamentally detrimental to the team's agility. The Scrum Master needs to change their behavior, not upgrade their logging system to track these bad practices further.

Create a detailed project plan to track individual tasks.

Why it fails: Detailed individual task plans are a command-and-control practice that discourages self-management. Scrum teams should focus on the collective goal and shared progress. A project plan often becomes a static document that fails to capture the dynamic reality of development, thus working against the needed transparency and team autonomy.

Ask the Product Owner to provide daily status updates to stakeholders.

Why it fails: Daily status updates to stakeholders create an unnecessary layer of reporting that distracts the Product Owner. Transparency should be inherent in the process itself, such as through the Increment or the Sprint Backlog, rather than through external reports. This approach keeps the focus on delivery instead of administrative overhead.

Assign a lead developer to monitor everyone's progress.

Why it fails: Assigning a lead to monitor progress undermines self-management and team cohesion. Scrum teams are cross-functional and self-managing, meaning they should collectively take responsibility for their progress. This hierarchical structure creates dependency and reduces the psychological safety required for the team to be honest about their challenges and blockers.

The velocity is too low for the size of the team.

Why it fails: Velocity is a measure of how much work a team can complete, not a performance metric to be compared against others. Stable velocity indicates a predictable process, which is a positive sign. Focusing on velocity rather than value and collaboration misinterprets the purpose of the Scrum framework entirely.

The Scrum Master is not resolving enough impediments.

Why it fails: There is no benchmark for the number of impediments a Scrum Master should resolve. Resolving three impediments is neither good nor bad in isolation. The focus should be on whether those impediments were blocking the team and if they were removed in a timely manner to maintain flow.

The Developers are not taking enough responsibility for the product vision.

Why it fails: Developers are accountable for the Sprint Backlog and building the Increment, but the Product Owner is responsible for the product vision. Expecting Developers to handle the product vision shifts accountability inappropriately and distracts them from their primary goal of creating a usable, high-quality increment every single Sprint.