Scaled Agile Frameworks
Scaled agile frameworks organize several teams working on one product or connected products. They provide different ways to align priorities, handle dependencies, and inspect an integrated result.
itEngineering leadership and delivery management | OpenSkills.info
Course pathWalk it in order
Look it upDip in anytime
Go furtherLeaves this page
Don't Panic
Don't Panic: Scaled Agile Frameworks
Several agile teams can finish their assigned work and still fail to deliver one usable result. That is the problem scaled agile frameworks address. They provide ways to align priorities, expose cross-team dependencies, and inspect the combined product. The recurring trick is that a completed board is evidence about a board. It is not necessarily evidence about a product.
Before acquiring a framework's vocabulary, draw one customer-visible change from request to working result. Find the point where it waits for another team, a specialist, an interface, or a decision. That wait is more informative than the number of people in the planning meeting. A framework is useful when it shortens the path from that wait to a decision and a done increment, meaning combined work that meets a shared quality condition.
SAFe groups teams in a long-lived Agile Release Train. The train aligns on a mission, plans a shared interval, and inspects integrated behavior in system demos. It also offers portfolio and large-solution guidance when the train is only part of the delivery boundary. The planning interval is a forecast, so the demo has the last word. A beautifully synchronized plan cannot demonstrate a working interface.
LeSS keeps one product in view. One Product Owner orders one backlog, and feature teams work across components to finish a shared product increment. This can remove handoffs that a larger coordination calendar would keep scheduling. The awkward part is that an organization may have to move skills and decision authority, not merely rename teams.
Nexus starts with several Scrum teams and asks whether they can create one Integrated Increment each Sprint. Its Integration Team helps the teams make that happen. It is a useful answer when integration is the immediate failure, provided the original teams still build compatible, done work. Sending every unfinished item to an integration group would give the queue a title, not a solution.
Scrum@Scale gives product priorities and process obstacles different routes. Its Product Owner Cycle handles the former; its Scrum Master Cycle handles the latter. If a decision is delayed, ask which path owns it and whether that path reaches someone who can act. A meeting without authority has excellent attendance and limited effect.
The surprise is how often the framework choice is really a boundary choice. One team that can own and release its product may need no scaling layer. Several teams sharing one product may need feature-team skills or a common Definition of Done before they need another dashboard. Watch blocker age, unfinished carryover, and the first usable combined slice. Those observations tell you whether the design is helping.
The Intro explains each framework's structure and where it fits. The Slides show the comparison in one pass. Use the Cheatsheet when you need a decision rule, then use the Practice Reference and Exercise to test a real or fictional delivery path. The official links take you from this map to each framework's exact rules.
Where this skill leads
Relevant careers
See how this topic contributes to broader role-level skill maps.
Sources
- https://framework.scaledagile.com/
Supports
- Official SAFe operating model and configuration map
- https://framework.scaledagile.com/agile-release-train
Supports
- ART structure, roles, shared mission, and delivery
- https://framework.scaledagile.com/pi-planning/
Supports
- PI Planning purpose, outputs, and cadence
- https://framework.scaledagile.com/wsjf/
Supports
- WSJF definition and relative cost-of-delay calculation
- https://framework.scaledagile.com/whats-new-in-safe
Supports
- Official SAFe changes and update-source page
- https://less.works/less/framework
Supports
- LeSS one-product structure, feature teams, and common increment
- https://less.works/less/rules
Supports
- LeSS organizational rules and cross-team coordination
- https://www.scrum.org/resources/online-nexus-guide
Supports
- Nexus Integration Team, events, and Integrated Increment
- https://www.scrumatscale.com/scrum-at-scale-guide-online/
Supports
- Scrum@Scale Product Owner and Scrum Master cycles
- https://less.works/case-studies/vesecurity
Supports
- Practitioner case study of feature-team adoption and unfinished Done
- https://github.com/awesome-selfhosted/awesome-selfhosted/blob/master/README.md
Supports
- Discovery list naming Tuleap and Taiga
- https://www.tuleap.org/
Supports
- Tuleap product and program views
- https://docs.tuleap.com/user-guide/program-management.html
Supports
- Tuleap SAFe program management
- https://www.taiga.io/
Supports
- Taiga team Scrum and Kanban planning
- https://www.atlassian.com/software/jira-align
Supports
- Jira Align program and portfolio planning
- https://docs.digital.ai/agility/docs/plan
Supports
- Digital.ai Agility PI Planning and portfolio views
- https://www.broadcom.com/products/software/value-stream-management/rally
Supports
- Rally portfolio, program, and team visibility
- https://www.planview.com/products-solutions/solutions/enterprise-agile-planning/agile-program-management/
Supports
- Planview ART and program board support
- https://help.piplanning.io/en/articles/86246-what-is-piplanning-io
Supports
- piplanning.io shared planning support
