The Nexus Framework

Scaled Professional Scrum · Scrum.org
SECTION I

What is Nexus?

Nexus is a framework for developing and sustaining scaled product delivery. It builds upon Scrum, extending it only where absolutely necessary to minimize and manage dependencies between 3–9 Scrum Teams working from a single Product Backlog to build an Integrated Increment.

Nexus was developed by Ken Schwaber and Scrum.org — the same people behind Scrum. It is deliberately minimal: Nexus adds exactly one new accountability (the Nexus Integration Team), a handful of extended events, and a few additional artifacts. Everything else is standard Scrum.

The core insight of Nexus is that the primary challenge of scaling Scrum is managing dependencies — dependencies in requirements, domain knowledge, and software/code. When these dependencies are minimized and managed, multiple teams can deliver a single, integrated product increment every Sprint.

Nexus preserves and enhances Scrum’s foundational bottom-up intelligence and empiricism. It does not add management layers, coordination roles, or ceremony overhead. Instead, it creates transparency around dependencies and provides accountability for integration.

Next
Nexus Theory
SECTION II

Nexus Theory

Nexus is founded on the same empirical process control theory as Scrum — transparency, inspection, and adaptation. At scale, the impact of incomplete transparency or flawed decisions is magnified, making empiricism even more critical.

Dependency Management

The fundamental challenge Nexus addresses. Dependencies exist in three domains: requirements (stories that depend on other stories), knowledge (expertise needed across teams), and software artifacts (shared code and test suites). Nexus makes these visible and provides mechanisms to minimize them.

Integration as First-Class Concern

In single-team Scrum, integration is relatively simple. At scale, integration becomes the primary source of complexity. Nexus creates explicit accountability for integration through the Nexus Integration Team and makes integration state visible through the Integrated Increment.

Cross-Team Refinement

The Product Backlog must be understood at a level where dependencies can be detected and minimized. Cross-team refinement is the primary mechanism for reducing dependencies before they become Sprint-level problems.

Minimal Extension

Nexus extends Scrum only where absolutely necessary. It does not prescribe engineering practices, organizational structures, or coordination ceremonies beyond what’s needed for integration. Teams retain full Scrum autonomy within the Nexus structure.

Previous
What is Nexus?
Next
Nexus Integration Team
SECTION III

Nexus Integration Team

The Nexus Integration Team (NIT) is the single new accountability Nexus adds to Scrum. It is accountable for ensuring that a done Integrated Increment — the combined work of all teams — is produced at least once every Sprint.

The NIT consists of the Product Owner, a Scrum Master, and one or more Integration Team Members. These members may also be members of individual Scrum Teams, but their NIT membership takes precedence — ensuring integration issues are resolved first.

Composition

The NIT includes the Product Owner (who ensures backlog ordering reduces dependencies), a Scrum Master (who ensures Nexus events and Scrum are enacted), and members drawn from Scrum Teams who have the skills needed to resolve integration challenges — coaching, architecture, testing, CI/CD.

Accountability

The NIT is accountable for the Integrated Increment. This doesn’t mean they do all the integration work — it means they ensure it happens. They coach teams, resolve cross-team technical issues, establish integration practices, and raise transparency around integration state.

Not a Management Layer

The NIT does not assign work, manage teams, or make product decisions beyond integration. It exists to solve the integration problem — not to coordinate, direct, or govern. Teams remain self-managing within the Nexus.

Previous
Nexus Theory
Next
Nexus Events
SECTION IV

Nexus Events

Nexus events extend, wrap around, or replace Scrum events to serve both the overall Nexus and each individual team. All teams share a common Sprint.

Nexus Sprint Planning

Representatives from each Scrum Team meet to discuss and review the Product Backlog, identify dependencies, and coordinate work across teams. After the Nexus-level planning, each team conducts its own Sprint Planning. The outcome: each team has a Sprint Backlog, and the Nexus has a Nexus Sprint Backlog showing cross-team work and dependencies.

Nexus Daily Scrum

Representatives from each team meet daily to identify integration issues and dependencies discovered since the last sync. The focus is on cross-team concerns — not status. Teams then conduct their own Daily Scrums, incorporating any insights from the Nexus Daily Scrum.

Nexus Sprint Review

Replaces individual team Sprint Reviews. The entire Nexus presents the Integrated Increment to stakeholders and discusses progress toward the Product Goal. Feedback informs Product Backlog adaptation. One review for the whole product.

Nexus Sprint Retrospective

Three parts: (1) representatives identify cross-Nexus issues, (2) each team holds its own retrospective incorporating Nexus-level themes, (3) representatives reconvene to agree on shared improvement actions. This ensures both team-level and Nexus-level improvements.

Previous
Nexus Integration Team
Next
Nexus Artifacts
SECTION V

Nexus Artifacts

Nexus extends Scrum’s artifacts with a few additions that create transparency around cross-team coordination and integration.

Product Backlog → Product Goal

A single Product Backlog for the entire Nexus. As items are refined, indicators show which team will most likely do each item. The Product Backlog must be refined to a level where dependencies are visible and can be minimized. The Product Owner is accountable for the backlog.

Nexus Sprint Backlog → Nexus Sprint Goal

Composed of the Nexus Sprint Goal (why), the selected Product Backlog items for all teams (what), and a plan showing dependencies between teams. It makes cross-team work visible and provides transparency into integration status during the Sprint.

Integrated Increment → Definition of Done

The combined work of all Scrum Teams, integrated and verified against a shared Definition of Done. The NIT is responsible for ensuring the Definition of Done can be applied to the Integrated Increment. Individual teams may apply a more stringent DoD but cannot apply less.

Previous
Nexus Events
Next
Scaling Patterns
SECTION VI

Scaling Patterns

Nexus provides patterns for managing the primary scaling challenges: dependency reduction, cross-team refinement, integration automation, and organizational alignment.

Dependency Reduction

The primary strategy is to reduce dependencies, not manage them. This happens through cross-team refinement (detecting and designing away dependencies before Sprint Planning), team composition (organizing teams to minimize handoffs), and architecture (modular design that decouples team work).

Cross-Team Refinement

Product Backlog refinement in Nexus explicitly includes dependency identification. Teams refine together when items span multiple teams. The goal: when Sprint Planning arrives, dependencies are already known and minimized.

Continuous Integration

Technical practices — especially continuous integration and automated testing — are essential for producing a real Integrated Increment every Sprint. Without automation, integration becomes the bottleneck that prevents scaling.

Team Organization

To minimize dependencies, teams should be organized around software architecture and domain knowledge boundaries. When team boundaries align with code and requirement boundaries, cross-team coupling decreases naturally.

Previous
Nexus Artifacts