Simyl
simylflow
Course Home
Module 5: Cadences & Continuous Improvement
Lesson 5 of 5
8 min

Scaling Kanban Across Teams

Approaches for coordinating Kanban across multiple teams and services.

1Scaling Philosophy

Kanban scales differently than Scrum-based frameworks (SAFe, LeSS, etc.).

Scrum scaling: Scale the framework. Add layers, roles, ceremonies.

Kanban scaling: Scale the principles. Each service manages its own flow, coordinated through shared agreements and metrics.

Key insight: You don't need a "Scaled Kanban Framework." You need:

  • Each team/service using Kanban
  • Coordination mechanisms between them
  • Portfolio visibility across services

2Team-of-Teams Coordination

When multiple Kanban teams depend on each other:

Visualize dependencies:

  • Mark items that need other teams
  • Show blocker reasons including cross-team waits
  • Track handoff times between teams

Operations Review:

  • Regular cadence with representatives from all teams
  • Review cross-team flow
  • Address recurring dependency issues
  • Agree on shared policies

Portfolio Kanban:

  • A higher-level board showing work across teams
  • Epics or initiatives as work items
  • WIP limits at the portfolio level
  • Used for strategic prioritization

Shared agreements:

  • SLAs between teams
  • Handoff protocols
  • Escalation paths
  • Communication norms

The goal isn't to create a uniform process across teams. It's to ensure work flows smoothly across team boundaries. Teams can have different boards as long as handoffs work.

3What to Avoid

Common scaling mistakes:

Mandating uniformity: "All teams must use the same board structure." Different teams have different workflows. Let them optimize locally.

Adding layers: "We need a Program Board, a Portfolio Board, a Strategy Board..." Layers add overhead. Add the minimum structure for coordination.

Ignoring dependencies: "Each team will manage their own flow." Works until cross-team work grinds to a halt. Make dependencies visible early.

Forgetting the customer: "All 12 teams have great flow metrics." But the customer still waits 6 months for a feature because it bounced between teams.

The test: Does a customer request flow smoothly from intake to delivery, even when it touches multiple teams? If yes, scaling is working. If no, there's work to do.

Good Scaling

Three teams each run their own Kanban boards. A monthly Operations Review identifies handoff problems. They agree on a shared SLA for cross-team requests. Lead time for cross-team work drops 30%.

Bad Scaling

Organization implements SAFe-like PI planning on top of Kanban teams. Trains, ARTs, and ceremonies proliferate. Teams spend more time in coordination meetings than doing work. Nobody mentions flow anymore.

4Portfolio Kanban

For coordinating across many teams and initiatives:

Portfolio Board:

  • Work items are epics, initiatives, or programs
  • Columns represent stages across multiple teams
  • WIP limits prevent organizational overload
  • Flow metrics at the portfolio level

Who uses it:

  • Product leadership
  • Program managers
  • Team leads

Cadence:

  • Portfolio replenishment (monthly)
  • Portfolio review (bi-weekly)
  • Strategy alignment (quarterly)

Connection to teams:

  • Portfolio items break down into team-level items
  • Team flow rolls up to portfolio metrics
  • Priorities cascade from portfolio to teams

Key insight: Portfolio Kanban isn't about controlling teams. It's about creating visibility and limiting organizational WIP. When the portfolio is overloaded, everything slows down—just like at the team level.

Key Takeaways
  • Kanban scales through principles and coordination, not frameworks
  • Visualize dependencies and handoffs between teams
  • Operations Review and shared agreements enable coordination
  • Portfolio Kanban limits organizational WIP
  • Avoid mandating uniformity or adding unnecessary layers
Common Pitfalls to Avoid
  • Mandating identical boards across different teams
  • Adding coordination layers that consume more time than they save
  • Optimizing team flow while ignoring cross-team bottlenecks
  • Forgetting that customer experience spans multiple teams