Agile & Project Management

Scaling Agile: SAFe, LeSS, Nexus and What Actually Breaks

Advanced8 min readUpdated

Scaling frameworks exist because coordination costs grow faster than team count, not because agile stops working. This guide identifies what actually breaks at scale, compares SAFe, LeSS, Nexus and the descaling argument, explains ARTs and PI planning in current SAFe terms, and gives a fair account of why heavyweight scaling is controversial.

What you will learn

  • Identify the specific coordination problems that appear when several teams share a product
  • Apply lightweight patterns — dependency mapping, communities of practice, sync forums — before adopting a framework
  • Describe how SAFe is structured today, including ARTs, planning intervals and lean portfolio management
  • Compare SAFe, LeSS, Nexus and the team-topologies alternative by what each optimises for
  • Judge when a scaling framework helps and when reducing dependencies is the better answer

Almost everything difficult about delivering software with many teams is a coordination problem rather than an agile problem. A single team of eight can hold the whole picture in a fifteen-minute conversation. Ten teams building one product cannot, and the number of possible pairwise conversations grows as the square of the team count, so at some point the coordination cost dominates.

Scaling frameworks are attempts to manage that cost. They are also, more than any other topic in agile practice, an industry — heavily certified, heavily marketed and heavily criticised. This guide separates the problems from the products: what genuinely breaks at scale, what the lightweight patterns are, how the major frameworks differ, and where the criticisms land. It assumes familiarity with the Scrum framework at the single-team level.

What actually breaks

Six specific failures show up as team count rises, and it is worth naming them because a framework that does not address the one you have will not help.

Dependencies. Team A cannot finish until Team B provides an endpoint that is not in Team B's plan. Every such link converts into waiting, and waiting is invisible in per-team metrics — each team looks busy while the product delivers nothing.

Integration. Teams that only integrate their work at the end of a quarter discover incompatibilities at the worst possible moment. Integration frequency is the single strongest predictor of whether multi-team delivery goes well, which makes a shared delivery pipeline a prerequisite rather than a nicety.

Backlog fragmentation. Each team keeps its own list, ordered by its own stakeholder. There is no longer a single answer to what the product should do next, and local optimisation quietly beats product value.

Architecture drift. Without a shared view, teams solve the same problem four different ways, or one team's design decision blocks another's. The pull toward independently deployable components is strong here, which is why scaling conversations and microservices conversations tend to arrive together.

Diluted accountability. With several product owners and several backlogs, nobody owns the product outcome. Escalation replaces decision-making.

Inconsistent quality bars. One team's "done" includes automated tests and a deployment; another's means a merged pull request. The increment is only as trustworthy as its weakest contributor.

Lightweight patterns, before frameworks

Most organisations should exhaust these before buying a framework.

  • Dependency mapping. Before a planning cycle, list every cross-team dependency with the two teams, the deliverable and the date needed. Visible dependencies get negotiated; invisible ones become excuses. The most valuable outcome is usually the decision to remove a dependency by moving a person or a boundary.
  • Scrum of Scrums. A short, frequent sync with one representative per team. It works when the representative is a working developer who knows the real state, and degrades into a status meeting when it becomes a gathering of managers.
  • Joint refinement and joint reviews. One refinement session where teams look at upcoming items together catches the dependency that would otherwise surface mid-sprint. One combined review of the integrated product prevents four demonstrations of things that do not fit together.
  • Communities of practice. Voluntary cross-team groups — testers, front-end developers, security — that agree standards and share techniques without owning delivery. Cheap and effective at reducing drift.
  • A shared definition of done. The single highest-leverage agreement across teams, and the one most often skipped.
  • Architectural boundaries that match team boundaries. The cheapest dependency is the one that no longer exists. Restructuring so that each team owns a deployable slice removes more coordination cost than any meeting cadence can.

SAFe as it stands today

The Scaled Agile Framework is the most widely adopted of the formal options, and also the most heavily criticised. It is worth describing accurately.

SAFe assembles established practices — Scrum at team level, Kanban for flow, lean product development, and an explicit portfolio governance layer — into one prescriptive operating model. It has evolved continuously rather than through occasional numbered releases: the framework site now publishes monthly updates, organises its content into five disciplines (leadership and culture, team and technical agility, product development flow, large solution integration and delivery, and lean portfolio management) rather than the older four configurations of Essential, Large Solution, Portfolio and Full SAFe, and in 2026 added an AI-native operating model alongside the core one. Certification course versions are now identified by release year and month rather than a framework version number.

The structural ideas that matter in practice have been stable:

ConceptWhat it is
Agile Release TrainA long-lived team of teams, typically 50–125 people, that plans, builds and releases together on a shared cadence
Planning IntervalThe ART's cycle, typically 8–12 weeks — usually four or five iterations plus an innovation and planning iteration
PI planningA two-day event where every team on the train plans the interval together, surfaces dependencies and agrees objectives
Release Train EngineerThe facilitator of the train — the Scrum Master equivalent at ART level
Product ManagementOwns the ART backlog of features, above the team-level product owners
System Team and System DemoShared infrastructure and a regular demonstration of the integrated solution
Development value streamThe end-to-end flow from concept to cash that ARTs are organised around, and increasingly what gets funded instead of projects
Lean portfolio managementEpics, investment guardrails and funding decisions at the portfolio level

PI planning is the element practitioners most often defend even when they dislike the rest. Putting every team in one place for two days to plan the same interval, draw dependencies on a board and commit to shared objectives solves the dependency and alignment problems directly, and the social effect of a hundred people agreeing a plan face to face is hard to replicate asynchronously. It is also expensive — two days times a hundred people, every quarter — which is exactly the trade-off you should evaluate rather than assume.

The alternatives

LeSS takes the opposite approach: scale by removing, not adding. Up to eight teams share one product owner, one product backlog, one definition of done and one sprint, with sprint planning split into a shared part and per-team parts, and one overall retrospective. There are no new roles and no extra backlogs. LeSS is intellectually coherent and demands genuine organisational change — a single empowered product owner over eight teams is not something most hierarchies will grant — which is why adoption is far lower than its quality would suggest.

Nexus is the minimal extension of Scrum for three to nine teams. It adds one thing: a Nexus integration team accountable for the integrated increment, plus a refinement practice that identifies cross-team dependencies before they bite. If you already run Scrum well and your only problem is integration, it is the smallest step that helps.

Team topologies thinking argues the problem is structural. Organise into stream-aligned teams that own a slice end to end, supported by platform teams, enabling teams and complicated-subsystem teams, and define the interaction modes between them. It offers no ceremonies at all, which makes it complementary rather than competing — many organisations run SAFe or LeSS mechanics on top of a topology-driven structure.

Descaling is the honest fourth option: reduce the number of teams that must coordinate, by splitting the product, redrawing service boundaries, or accepting a smaller scope. It is the least marketable answer and often the correct one.

FrameworkAddsSuitsMain risk
SAFeRoles, events, backlogs, portfolio governanceLarge regulated enterprises with existing hierarchyProcess weight; teams lose autonomy
LeSSAlmost nothing; removes structureOrganisations willing to change reporting linesRequires real authority change to work
NexusOne integration teamThree to nine mature Scrum teamsDoes not address portfolio or funding
Team topologiesA structural vocabularyAny size; complements the othersNot a delivery process on its own

The criticisms, fairly stated

The case against heavyweight scaling deserves a proper hearing rather than dismissal.

The strongest argument is that adding coordination structure treats the symptom. If teams need a two-day event every quarter to resolve dependencies, the dependencies are the problem, and the event makes them tolerable enough that nobody fixes the architecture. A second argument is that prescriptive frameworks re-create the phase gates and hand-offs that iterative delivery was meant to remove, with new names — a quarterly plan committed by a hundred people is a plan that is expensive to change, which sits awkwardly with responding to change over following a plan. A third is commercial: certification revenue creates an incentive to make frameworks elaborate, and organisations frequently buy training instead of changing how they fund and structure work.

There are also genuine defences. Large organisations do need a way to align investment with delivery, and "just have fewer dependencies" is not actionable advice for a company with a thirty-year-old core system. A framework provides a shared vocabulary and a starting configuration that is better than the ad-hoc arrangement it replaces. And the alternative in many enterprises is not elegant descaling but a return to annual releases.

The practical test is whether the structure is reducing over time. An adoption where the number of coordination meetings falls each year, because dependencies were removed rather than managed, is working. One where the machinery only grows has become the process it was meant to replace. Whatever the framework, forecasting across many teams still rests on the same measured throughput described in estimation and planning, not on the confidence of a plan produced in a large room.

Key takeaways

  • Scaling problems are coordination problems: dependencies, integration, fragmented backlogs, architecture drift, diluted ownership and inconsistent quality bars.
  • Try dependency mapping, joint refinement, communities of practice and a shared definition of done before adopting a framework; they are cheap and address the same failures.
  • SAFe now evolves continuously and organises its guidance into five disciplines; the durable ideas are the Agile Release Train, the 8–12 week planning interval, PI planning and value-stream funding.
  • LeSS scales by removing structure, Nexus adds only an integration team, and team topologies supplies structure rather than ceremonies — they optimise for different constraints.
  • The sharpest criticism is that coordination machinery makes dependencies tolerable instead of removing them; judge an adoption by whether the machinery shrinks over time.
  • The cheapest dependency is the one that does not exist, so redrawing architectural and team boundaries usually beats any meeting cadence.

Sources and further reading

Frequently asked questions

At how many teams do you need a scaling framework?
Two or three teams on one product can usually coordinate with a shared backlog, a joint refinement session and a weekly sync. Beyond about five, informal coordination consumes more time than the work and something more structured is warranted. The number matters less than the dependency density: eight teams working on genuinely separate services need far less machinery than three teams editing the same module.
Is SAFe still agile?
It depends what you count. SAFe keeps short iterations, working software, retrospectives and demonstrations, and adds planning and governance layers that the Agile Manifesto authors would not recognise. Practitioners who value team autonomy above all see the layers as a reintroduction of the process weight agile was reacting against; practitioners in large regulated organisations see them as the price of getting any iterative delivery approved at all.
What is the difference between LeSS and SAFe?
LeSS scales by removing structure: one product owner, one product backlog, one definition of done and one sprint across up to eight teams, with almost no new roles. SAFe scales by adding structure: additional backlogs, roles, planning events and portfolio governance. LeSS demands deep organisational change to work; SAFe can be adopted on top of an existing hierarchy, which is both its appeal and the source of most criticism.
Does the Spotify model work as a scaling framework?
It was never intended as one. The widely copied article described how one company was organised at one moment, and people at that company have since said publicly that it did not work as written even there. Squads, tribes, chapters and guilds are useful vocabulary for thinking about matrix structure and communities of practice, but copying the diagram does not transfer the engineering culture that made it function.