Study guide
7.4 Managing Technical Risk, Technical Debt & Engineering Excellence
Professional Scrum Master II PSM II
Track your progress as you read
Finished sections get a check mark.
1 Chapter 1: Exam Overview, Empiricism & Advanced Framework Mechanics
1.1 PSM II Assessment Architecture, Scoring, and Advanced Mindset 1.2 Empiricism in Complex Environments 1.3 Living the Scrum Values Under Pressure
2 Chapter 2: Scrum Accountabilities & Team Self-Management
2.1 The Three Accountabilities in Deep Context 2.2 Fostering Self-Managing & Cross-Functional Teams 2.3 Anti-Patterns in Accountabilities
3 Chapter 3: The 8 Stances of the Scrum Master
3.1 Core Enabling Stances: Servant Leader & Manager 3.2 Developing Stances: Teacher, Mentor & Coach 3.3 Delivery Stances: Facilitator & Impediment Remover 3.4 Transformational Stance: Change Agent & Ineffective Stances
4 Chapter 4: Advanced Team Dynamics & Psychological Safety
4.1 Building Psychological Safety & Trust 4.2 Navigating Team Development & Dysfunctions 4.3 Conflict Resolution & Liberating Structures
5 Chapter 5: Managing Products with Agility & Product Owner Coaching
5.1 Coaching the Product Owner on Vision & Product Goal 5.2 Product Backlog Health, Ordering & Splitting 5.3 Stakeholder Engagement & Collaboration Without Feature Factories
6 Chapter 6: Evidence-Based Management (EBM) & Agility Metrics
6.1 EBM Framework Architecture & Strategic Loop 6.2 Market Value: Current Value (CV) & Unrealized Value (UV) 6.3 Organizational Capability: Time-to-Market (T2M) & Ability to Innovate (A2I) 6.4 Designing Agility Metrics vs. Vanity Metrics
7 Chapter 7: Artifacts, Commitments & Definition of Done
7.1 The Three Commitments & Empirical Artifact Transparency 7.2 Crafting and Evolving the Definition of Done 7.3 Definition of Done in Regulated & Complex Environments 7.4 Managing Technical Risk, Technical Debt & Engineering Excellence
8 Chapter 8: Advanced Events & Facilitation in Practice
8.1 Advanced Sprint Planning & Meaningful Sprint Goals 8.2 The Daily Scrum & Sprint Review as Empirical Feedback Loops 8.3 Actionable Sprint Retrospectives & Continuous Improvement
9 Chapter 9: Scaling Scrum & Organizational Agility
9.1 Scaling Fundamentals & Nexus Framework 9.2 Nexus Events & Multi-Team Dependency Management 9.3 Organizational Design, Culture & Removing Impediments Beyond the Team 9.4 Agile Budgeting, Contracts & Governance
7.4 Managing Technical Risk, Technical Debt & Engineering Excellence
Key Takeaways Explain This Topic AI
Managing Technical Risk is the PSM II focus area from Developing and Delivering Products Professionally: risks range from the ability to deliver to performance and security, and must be made transparent.
Unaddressed technical debt compounds like financial interest, systematically degrading velocity, inflating defect escape rates, destabilizing production environments, and causing developer burnout.
Routine technical debt prevention belongs in the Definition of Done, while large refactoring and risk-reduction work must be visible on the Product Backlog.
Extreme Programming (XP) engineering practices—such as Test-Driven Development (TDD), Pair Programming, Continuous Integration, and Automated Refactoring—provide the technical discipline required to sustain Scrum's empirical process control.
Advanced Scrum Masters coach Product Owners on the economic imperatives of technical excellence, demonstrating how technical hygiene directly accelerates Time-to-Market (T2M) and liberates capacity for the Ability to Innovate (A2I).
Last updated: October 2026
7.4 Managing Technical Risk, Technical Debt & Engineering Excellence
Note
In 1992, software pioneer Ward Cunningham coined the metaphor of "Technical Debt" to explain to non-technical business managers why software development inevitably slows down over time if code quality is neglected. In professional Scrum, managing technical debt is not a luxury or a developer indulgence—it is an economic imperative that determines the survival of the product.
Managing Technical Risk: The Official PSM II Focus Area
Scrum.org's PSM II page lists Managing Technical Risk as the one focus area it draws from the Developing and Delivering Products Professionally competency. Scrum.org describes it this way: all products have an inherent set of risks, ranging from the ability to deliver to technical risks associated with performance and security; practitioners should understand what technical risks are, how to manage them effectively in an empirical process, and how to apply practices that make risks transparent.
Technical risk Example Empirical response
Ability to deliver / integration Can the team integrate with a legacy system or third-party API at all? Order a thin end-to-end slice or a timeboxed spike early, and inspect the result
Performance & scalability Will checkout survive peak seasonal load? Put load thresholds in the Definition of Done or acceptance criteria; test with production-like data every Sprint
Security & privacy Vulnerable dependencies; personal-data exposure Automated security scanning in the Definition of Done; threat discussion during refinement
Architecture & technical debt Fragile modules that make every change slow Make debt visible on the Product Backlog; refactor continuously
Dependencies & skills One specialist or one vendor component everyone waits for Cross-skilling, pairing, contract tests
Four principles answer most PSM II technical-risk scenarios:
Make risk transparent. Risks belong where the Scrum Team and stakeholders can inspect them—on the Product Backlog (as items, spikes, or acceptance criteria), in the Definition of Done (as non-functional standards), and in Sprint Review conversations—not in a private register nobody reads.
Reduce risk early with working software. In complex work, the cheapest way to reduce a technical risk is to build something small that proves or disproves the assumption. When the Developers explain a risk in terms of value and cost of delay, the Product Owner can order risky items early.
Let every Increment cap the exposure. A Done, usable Increment every Sprint limits how long any wrong technical bet can stay hidden to one Sprint—one month at most.
Respect accountabilities. Developers identify technical risks and decide how to mitigate them; the Product Owner orders the Product Backlog with that information; the Scrum Master makes sure risks are not hidden and that organizational impediments (such as no production-like test environment) are removed.
A scenario in which a team quietly accepts a risk, or defers performance or security testing to a later phase, is testing this focus area: the professional answer makes the risk visible and deals with it inside the Sprint cadence.
The Economics of Technical Debt: Ward Cunningham's Metaphor
Ward Cunningham drew an explicit parallel between taking out a financial loan and taking engineering shortcuts in software development:
"Shipping first time code is like going into debt. A little debt speeds development so long as it is paid back promptly with a rewrite... The danger occurs when the debt is not repaid. Every minute spent on not-quite-right code counts as interest on that debt. Entire engineering organizations can be brought to a stand-still under the debt load of an unconsolidated implementation, object-oriented or otherwise."
Deliberate vs. Inadvertent, Prudent vs. Reckless
Martin Fowler's widely used Technical Debt Quadrant separates two questions: was the debt taken on deliberately or inadvertently , and was the decision prudent or reckless ?
Reckless Prudent
Deliberate "We don't have time for design or tests." "We must ship now to test this hypothesis, and we'll pay the debt down right after we learn."
Inadvertent Poor practices nobody recognized as poor "Now we know how we should have built it"—learning that only came from building
Only deliberate, prudent debt is a legitimate business decision, and only if it is made transparent (for example, as an item on the Product Backlog) and actually repaid. Reckless debt—whether deliberate or not—is the main driver of enterprise software rot.
The compounding spiral usually runs like this:
Shortcuts taken: automated tests skipped; quick-and-dirty patches.
Codebase fragility: small changes trigger unexpected side effects.
Escaped defects surge: production incidents multiply; hotfixes mount.
Firefighting dominates: a growing share of every Sprint goes to fixing bugs.
Velocity and morale collapse: Developers burn out; the Ability to Innovate falls.
Executive frustration: leaders demand faster delivery, and the cycle repeats.
When technical debt is ignored, the "compounding interest" consumes the team's entire capacity. Features that used to take three days now take four weeks because developers must navigate a labyrinth of brittle, undocumented spaghetti code.
Making Technical Debt Visible and Measurable
Technical debt thrives in darkness. When technical rot is hidden from stakeholders, leadership assumes that software development is simple and cannot understand why delivery speed is slowing down. The Scrum Master guides the team to make technical debt visible through two primary mechanisms:
1. Routine Hygiene via the Definition of Done
Everyday technical debt prevention must not require special permission from the Product Owner or business stakeholders. Writing clean code, modularizing functions, executing automated unit tests, and conducting peer reviews are intrinsic to professional craftsmanship . These practices are non-negotiable standards codified directly within the Definition of Done . The team never asks: "May we write unit tests this Sprint?" High quality is built into every Product Backlog item by default.
2. Strategic Refactoring on the Product Backlog
When a team inherits massive legacy debt—such as an outdated monolithic database, obsolete frameworks, or modules requiring complete architectural decomposition—remediation cannot be absorbed into routine daily tasks. These major initiatives must be made transparent as Product Backlog items .
However, developers must avoid formulating technical debt in obscure, jargon-heavy language (e.g., "Refactor UserService.java to utilize Spring Dependency Injection" ). Instead, items must be expressed in terms of business value, risk reduction, and economic impact :
"Decouple the User Authentication service to isolate payment processing: eliminates multi-hour deployment downtime, reduces regression testing time from 3 days to 15 minutes, and enables PCI-DSS automated compliance audits."
3. Tracking Technical Debt via EBM Metrics
In Evidence-Based Management (EBM), technical debt manifests directly within the Organizational Capability dimension:
Technical Debt: One of the EBM Guide's example Ability to Innovate measures—the extra development and testing work created by "quick and dirty" solutions.
Defect Trends & Escaped Defects: Increasing defect arrival rates signal an uninspected accumulation of debt.
Mean Time to Repair (MTTR): Rising MTTR indicates brittle code that is difficult to diagnose and patch.
Release Stabilization Period: Any required manual stabilization phase before release is empirical proof of unaddressed technical debt.
The Symbiosis of Scrum and Extreme Programming (XP)
A critical insight for the PSM II assessment is understanding why Scrum alone is insufficient for sustained software agility . Scrum provides the organizational framework, empirical feedback loops, events, and accountabilities—but it intentionally omits prescriptive software engineering practices.
If a Scrum Team adopts all Scrum events and accountabilities but practices obsolete waterfall engineering (manual testing, long-lived feature branches, no refactoring), they will simply "produce bad software faster." To achieve true business agility, Scrum must be paired with the rigorous technical practices of Extreme Programming (XP) :
- Layer Contributes Examples
- Scrum Empirical management framework Sprint Planning, Daily Scrum, Sprint Review, Sprint Retrospective
- Extreme Programming (XP) Technical excellence engine TDD, pair programming, CI/CD, refactoring, simple design
- Together Sustainable business agility Done Increments every Sprint without a stabilization phase
Core XP Practices in Professional Scrum:
Test-Driven Development (TDD): Developers write automated unit tests before writing production code, following the strict Red-Green-Refactor cycle. TDD forces modular software architecture, provides living documentation, and creates an automated regression safety net that enables fearless refactoring.
Acceptance Test-Driven Development (ATDD) & Behavior-Driven Development (BDD): The Product Owner, Developers, and testers collaborate to formulate automated acceptance criteria before development begins, ensuring shared understanding of business intent.
Continuous Integration (CI) & Trunk-Based Development: Developers merge code into the mainline trunk multiple times a day. Every commit triggers an automated build and test pipeline, detecting merge conflicts and regressions within minutes rather than weeks.
Pair Programming & Mob/Ensemble Programming: Two or more developers collaborate at a single workstation (or virtual session) on complex code. This provides continuous peer review, dramatically lowers defect injection, disseminates architectural knowledge, and eliminates single points of failure.
Continuous Refactoring: Relentlessly cleaning, modularizing, and optimizing existing code without altering its external functional behavior.
Coaching the Product Owner on the Economics of Technical Excellence
A common organizational conflict occurs when a feature-focused Product Owner resists technical improvements, viewing refactoring as "engineering overhead that delivers zero customer value." An advanced Scrum Master does not allow developers to engage in secret refactoring, nor do they allow the Product Owner to run a feature factory. The Scrum Master coaches the Product Owner using economic arguments anchored in EBM :
1. The Cost of Delay and Quality Trade-offs
The Scrum Master demonstrates that delivering five low-quality features today that inject ten production bugs tomorrow is economically destructive. The team will spend much of next quarter firefighting those bugs, resulting in a severe collapse of Time-to-Market (T2M) for future high-priority features.
2. Ability to Innovate (A2I) as a Competitive Weapon
If competitors can launch a new market experiment in three days while our team requires six weeks because of architectural spaghetti, our product will lose market share. Investing a consistent share of every Sprint's capacity in technical debt remediation directly preserves the organization's Ability to Innovate (A2I) .
3. Establishing Sustainable Velocity
Velocity is not an engine that can be redlined indefinitely. Professional Scrum requires working at a sustainable pace . Coaching the Product Owner to allocate dedicated capacity in every Sprint for technical debt remediation and automated tooling stabilizes cycle times, improves developer happiness, and ensures long-term commercial predictability.
Comprehensive Reference: Technical Debt Management Lifecycle
The table below outlines the end-to-end lifecycle for identifying, tracking, and eliminating technical debt in professional Scrum:
Lifecycle Stage Operational Mechanism Role Accountabilities Tangible Artifact / Metric
Prevention Rigorous Definition of Done; automated CI build gates; TDD Developers enforce quality; PO respects DoD boundaries Automated unit tests with meaningful assertions; no unresolved high-severity security findings
Identification Static analysis scans; code review; production telemetry Developers detect code rot; PO observes defect trends Static-analysis technical debt estimates; defect arrival rate tracking
Transparency Slicing architectural refactoring into business-value PBIs Developers articulate business impact; PO orders backlog Product Backlog items with clear ROI (e.g., cycle time reduction)
Remediation Continuous refactoring in every Sprint; a consistent capacity allocation agreed with the PO Developers execute refactoring; PO balances new features Shrinking technical debt; decreasing Mean Time to Repair (MTTR)
Governance EBM Organizational Capability tracking during Sprint Reviews Scrum Team and leadership inspect capability health Improved Time-to-Market (T2M) and surge in Innovation Rate (A2I)