Study guide

9.1 Scaling Fundamentals & Nexus Framework

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

9.1 Scaling Fundamentals & Nexus Framework

Key Takeaways Explain This Topic AI

Descale first: simplify the product, decouple the architecture, and remove dependencies before adding teams; the Nexus Guide calls scaling down an important practice.

Regardless of team count, the core Scrum rule remains immutable: One Product has exactly One Product Backlog curated by One Product Owner.

Scrum.org's Nexus Framework scales Scrum for 3 to 9 Scrum Teams working collaboratively to produce a single integrated Increment every Sprint.

The Nexus Integration Team (NIT) is accountable for ensuring an integrated Increment is produced at least every Sprint, acting as coaches and facilitators rather than an integration silo.

Individual Scrum Teams retain complete accountability for developing and integrating their work; the NIT never absorbs the testing or coding responsibilities of the teams.

Last updated: October 2026

Scaling Fundamentals & Nexus Framework

Important

Scope note: Scaling Scrum and Nexus are not among the focus areas Scrum.org lists for PSM II; they are tested directly by Scaled Professional Scrum (SPS). This section and 9.2 are supporting context for PSM II scenarios that involve several teams working on one product.

Note

The most effective way to scale Scrum is often not to scale at all. Professional agility prioritizes descaling—reducing organizational complexity, decoupling monolithic architectures, and streamlining value delivery—before multiplying the number of teams.

Descale First: Simplify Before Adding Teams

When organizations encounter sluggish delivery, mounting defect counts, or expanding market demands, their default instinct is frequently to hire more developers and spin up additional teams. In complex product development, however, scaling headcount is rarely a linear accelerant. More often, it acts as an organizational drag coefficient.

This counterintuitive reality is grounded in solid systems dynamics and organizational communication theory:

Communication Paths (Brooks's formula): A group of n n n people has n ( n − 1 ) / 2 n(n - 1) / 2 n ( n − 1 ) /2 potential one-to-one communication paths. A team of 7 has 7 × 6 / 2 = 21 7 \times 6 / 2 = 21 7 × 6/2 = 21 paths; 35 people (five teams of seven) have 35 × 34 / 2 = 595 35 \times 34 / 2 = 595 35 × 34/2 = 595 . People grew fivefold, but paths grew more than twenty-eightfold—the growth is quadratic, not linear. The Nexus Guide makes the same point: "Scaling-down, reducing the number of people who work on something, can be an important practice in delivering more value."

Brooks' Law: As Fred Brooks famously observed in The Mythical Man-Month , adding manpower to a late software project makes it later. New team members require mentoring from existing high performers, communication overhead spikes, and architectural consistency degrades.

The Friction of Dependencies: Every additional team introduces handoffs, queue wait times, merge conflicts, and political boundaries. When work must traverse multiple team boundaries to reach production, cycle times stretch and transparency erodes.

The Descaling Imperative

Before adding teams, an organization should aggressively pursue descaling . Descaling involves systematically simplifying the product, architecture, and organizational structure to maximize the throughput of existing teams:

Decouple Architecture: Refactor monolithic, tightly coupled systems into modular, loosely coupled architectures with clean interface contracts (e.g., Domain-Driven Design and microservices). When codebases are decoupled, individual teams can develop, test, and deploy features independently without stepping on each other's toes.

Prune Product Scope: Eliminate low-value features. Customer usage data (for example, EBM's customer usage index) usually reveals features that are rarely used; delivering fewer, higher-impact features reduces the workload without adding headcount.

Automate Continuous Integration and Delivery (CI/CD): Replace manual testing, cumbersome deployment sign-offs, and manual configuration with automated build, test, and release pipelines. Often, a single team supported by modern automated engineering practices can outperform three teams bogged down by manual testing gates.

Dismantle Specialized Functional Silos: Eliminate handoffs between separate architecture, UX, database, and QA departments. Transforming existing teams into true end-to-end, cross-functional units often yields immediate productivity gains that eliminate the perceived need for scaling.

Scaling should only be pursued when market opportunity or product breadth genuinely exceeds the physical capacity of a single high-performing cross-functional team, and the work cannot be partitioned into distinct, independent products.

Foundational Scaling Rules: One Product, One Backlog, One Product Owner

When scaling Scrum across multiple teams, organizations frequently attempt to invent complex governance structures, committees, and multi-layered backlogs. Scrum maintains radical simplicity even at scale:

1 Product ⟺ 1 Product Backlog ⟺ 1 Product Owner \text{1 Product} \iff \text{1 Product Backlog} \iff \text{1 Product Owner} 1 Product ⟺ 1 Product Backlog ⟺ 1 Product Owner

No matter whether 3, 5, or 8 Scrum Teams are building a product, these immutable rules apply:

Scaling Dimension Empirical Scrum Rule Common Enterprise Anti-Pattern

Product Backlog Exactly One Product Backlog containing all work for the product. Creating a separate Product Backlog per team, leading to fragmented priorities, duplicated work, and local optimization.

Product Owner Exactly One Product Owner accountable for the product's value and backlog ordering. Appointing a committee of POs, or creating a hierarchy of "Component POs" and "Proxy POs" reporting to a "Chief PO" who acts as a bureaucratic bottleneck.

The Increment Exactly One integrated Increment produced every Sprint, representing the combined work of all teams. Allowing each team to produce its own un-integrated component increment, deferring integration to an end-of-year "hardening" phase.

Definition of Done One Definition of Done for the Integrated Increment, for which the Nexus Integration Team is responsible; all teams adhere to it and may make their own more stringent, but never less. Allowing each team to define its own weaker Definition of Done, hiding architectural debt and incomplete testing.

Why Multiple Backlogs and Product Owners Destroy Agility

Splitting a single product into multiple team-specific Product Backlogs creates artificial boundaries. Teams become territorial over "their" backlog, optimizing for their own local velocity rather than the holistic value of the product. High-priority customer items sit idle because Team A's backlog is full, while Team B works on low-value trivialities simply because they must keep their backlog active.

Similarly, dividing Product Ownership among multiple individuals dilutes accountability. When trade-offs between competing features arise, multiple Product Owners engage in political infighting. Having a single Product Owner ensures clear, unambiguous accountability for strategic trade-offs, return on investment, and product vision. To manage the workload, the Product Owner delegates refinement activities, technical analysis, and backlog item elaboration to the Developers across the teams, while retaining ultimate authority over ordering and acceptance.

The Nexus Framework: Scrum.org's Scaled Scrum Architecture

Ken Schwaber and Scrum.org developed the Nexus Framework (current guide: January 2021) as a lightweight way to scale Scrum. Rather than adding elaborate layers of management, Nexus functions as an exoskeleton that wraps around standard Scrum, preserving the core framework while providing the minimal necessary coordination mechanics.

Key Parameters of Nexus

Team Capacity: A Nexus is designed for approximately 3 to 9 Scrum Teams working from a single Product Backlog.

Lower Boundary (Why not 2 teams?): With only 2 teams, the overhead of formal scaling ceremonies is rarely justified; two teams can coordinate through direct daily collaboration and shared backlog refinement.

Upper Boundary (Why not 15+ teams?): Beyond 9 teams, coordination overhead and cognitive complexity overwhelm human collaboration. Organizations with more than 9 teams should partition the problem domain into separate, autonomous products, each with its own Nexus or individual Scrum Team.

Core Objective: The Nexus Guide describes the goal as delivering an integrated, valuable, useful product Increment at least once every Sprint that meets the Definition of Done.

The Nexus Integration Team (NIT): Accountability, Composition, and Stance

The central structural innovation of the Nexus Framework is the Nexus Integration Team (NIT) . The NIT provides the focus and accountability required to ensure that multi-team collaboration results in a unified, working product rather than a pile of incompatible code fragments.

Accountabilities of the NIT

The Nexus Integration Team is accountable for ensuring that a clean, integrated Increment is produced at least every Sprint. This includes:

Establishing and evolving the technical infrastructure, continuous integration pipelines, and automated test environments necessary for multi-team integration.

Making cross-team dependencies, architectural bottlenecks, and integration failures transparent across the Nexus.

Coaching, consulting, and guiding individual Scrum Teams on how to resolve dependencies and integrate their work continuously.

Composition of the NIT

The NIT is a cross-functional team composed of:

The Product Owner: The exact same Product Owner who owns the single Nexus Product Backlog. The PO ensures that integration decisions align with product value and business priority.

A Scrum Master: Accountable for the overall effectiveness of the Nexus and the NIT. The Nexus Scrum Master coaches all teams and leaders on Nexus mechanics, dependency management, and empiricism.

Nexus Integration Team Members: Experienced professionals with deep expertise in systems architecture, continuous delivery, automated regression testing, security, and infrastructure. These members are frequently drawn directly from the individual Scrum Teams within the Nexus.

Important

The Nexus Guide states that membership in the Nexus Integration Team takes precedence over individual Scrum Team membership; as long as their NIT responsibility is satisfied, members can work in their Scrum Teams. Membership is also dynamic. Team members may step into the NIT for several Sprints to tackle acute cross-team architectural hurdles—such as migrating a shared database or implementing contract testing—and then return their primary focus to their individual Scrum Teams once the challenge is resolved.

Critical Anti-Pattern: The NIT as a Testing or Integration Silo

The most pervasive and damaging anti-pattern in scaled Scrum is treating the Nexus Integration Team as an isolated "integration team," "QA department," or "DevOps silo." In this dysfunctional anti-pattern, individual Scrum Teams write code in isolation and toss it over the fence to the NIT at the end of the Sprint, expecting the NIT to merge, test, and deploy the software. Traditional Anti-Pattern: The NIT as a Downstream Silo

  • [ Team 1 ] ---> (Unintegrated Code) ---\
  • [ Team 2 ] ---> (Unintegrated Code) ----+---> [ NIT / QA Silo ] ---> Bottleneck / Merge Hell
  • [ Team 3 ] ---> (Unintegrated Code) ---/

Why this anti-pattern proves catastrophic:

Destroys Team Accountability: When a separate team is responsible for integration, individual Scrum Teams stop caring about integration debt, merge conflicts, or backwards compatibility. They declare items "done on my machine" and blame the NIT when production breaks.

Creates Massive Queue Delays: The NIT becomes a severe organizational bottleneck at the end of every Sprint, overwhelmed by hundreds of merge conflicts and broken regression suites.

Hides Transparency: Integration failures remain concealed until the final days of the Sprint, leaving no time for empirical adaptation.

The Correct Stance: Coaches, Facilitators, and Enablers

In true Nexus agility, the individual Scrum Teams are responsible for integrating their own work . If code does not integrate cleanly into the shared mainline branch, it is not Done.

The NIT's stance is servant leadership:

They do not do the integration work for the teams; they coach and enable the teams to do it themselves.

They provide automated CI/CD tools, shared test harnesses, and architectural guidance.

If an integration emergency occurs, the NIT does not step in as heroic problem-solvers to fix the code in secret. Instead, they facilitate cross-team collaboration, pairing developers from the affected teams to resolve the root architectural incompatibility.

Loading diagram... The Nexus Framework Structural Hierarchy