Cross-Team Dependencies | Reduce Blocking
Coordinate dependencies across teams to reduce blocking. GitScrum visualizes and tracks cross-team dependencies to keep multiple teams moving smoothly.
8 min read
Dependencies between teams cause delays. GitScrum helps visualize and track cross-team dependencies to minimize blocking.
Understanding Dependencies
Types of Dependencies
DEPENDENCY TYPES:
┌─────────────────────────────────────────────────────────────┐
│ │
│ TECHNICAL DEPENDENCIES: │
│ ─────────────────────── │
│ • API team must deliver endpoint before frontend can use │
│ • Database changes needed before feature work │
│ • Shared library update required │
│ │
│ RESOURCE DEPENDENCIES: │
│ ────────────────────── │
│ • Need specialist from another team │
│ • Shared infrastructure team must configure │
│ • Design resources shared across teams │
│ │
│ KNOWLEDGE DEPENDENCIES: │
│ ─────────────────────── │
│ • Need information from domain experts │
│ • Legacy system knowledge held by one person │
│ • Cross-team documentation needed │
│ │
│ PROCESS DEPENDENCIES: │
│ ───────────────────── │
│ • Approval from security team │
│ • Legal review for feature │
│ • External vendor involvement │
│ │
│ ─────────────────────────────────────────────────────────── │
│ │
│ DEPENDENCY DIRECTION: │
│ │
│ INCOMING: │
│ ┌─────────┐ │
│ │ Other │ ───→ Our work blocked until they deliver │
│ │ Team │ │
│ └─────────┘ │
│ │
│ OUTGOING: │
│ ┌─────────┐ │
│ │ Us │ ───→ Other team blocked until we deliver │
│ │ │ │
│ └─────────┘ │
│ │
│ Outgoing dependencies require commitment │
└─────────────────────────────────────────────────────────────┘
Identifying Dependencies
Early Detection
FINDING DEPENDENCIES:
┌─────────────────────────────────────────────────────────────┐
│ │
│ DURING BACKLOG REFINEMENT: │
│ ────────────────────────── │
│ Ask for each story: │
│ • "Do we need anything from another team?" │
│ • "Does another team need something from us?" │
│ • "Who else is affected by this work?" │
│ │
│ DURING SPRINT PLANNING: │
│ ─────────────────────── │
│ • Review dependencies for planned work │
│ • Confirm other team's availability │
│ • Plan around blocked items │
│ │
│ ─────────────────────────────────────────────────────────── │
│ │
│ DEPENDENCY CHECKLIST: │
│ ┌─────────────────────────────────────────────────────────┐│
│ │ STORY: STORY-456 ││
│ │ ││
│ │ DEPENDENCY CHECK: ││
│ │ ││
│ │ ☐ API changes needed? ││
│ │ If yes: Which team? When ready? ││
│ │ ││
│ │ ☐ Database changes needed? ││
│ │ If yes: Who approves? Migration timing? ││
│ │ ││
│ │ ☐ Design from another team? ││
│ │ If yes: When will design be finalized? ││
│ │ ││
│ │ ☐ Infrastructure/DevOps support? ││
│ │ If yes: Is it scheduled? Who to contact? ││
│ │ ││
│ │ ☐ External approvals (security, legal)? ││
│ │ If yes: Timeline? What do they need from us? ││
│ │ ││
│ │ IDENTIFIED DEPENDENCIES: ││
│ │ → Depends on: API-123 from Platform Team (Sprint 15) ││
│ │ → Blocks: STORY-789 for Mobile Team ││
│ └─────────────────────────────────────────────────────────┘│
└─────────────────────────────────────────────────────────────┘
Tracking Dependencies
Dependency Board
DEPENDENCY TRACKING:
┌─────────────────────────────────────────────────────────────┐
│ │
│ DEPENDENCY BOARD: │
│ │
│ OUR TEAM: Product Team │
│ │
│ INCOMING (We wait for them): │
│ ┌─────────────────────────────────────────────────────────┐│
│ │ DEPENDENCY FROM STATUS DUE ││
│ │ ────────── ──── ────── ─── ││
│ │ API-123 Platform 🟡 In prog Sprint 15 ││
│ │ DESIGN-45 Design Team 🟢 Done Sprint 14 ││
│ │ INFRA-89 DevOps 🔴 At risk Sprint 15 ││
│ └─────────────────────────────────────────────────────────┘│
│ │
│ OUTGOING (They wait for us): │
│ ┌─────────────────────────────────────────────────────────┐│
│ │ DEPENDENCY TO STATUS DUE ││
│ │ ────────── ── ────── ─── ││
│ │ AUTH-56 Mobile Team 🟢 Done Sprint 14 ││
│ │ DATA-78 Analytics 🟡 In prog Sprint 15 ││
│ └─────────────────────────────────────────────────────────┘│
│ │
│ ─────────────────────────────────────────────────────────── │
│ │
│ DEPENDENCY DETAIL: │
│ ┌─────────────────────────────────────────────────────────┐│
│ │ INFRA-89: Production environment setup ││
│ │ ││
│ │ PROVIDER: DevOps Team (@lead-ops) ││
│ │ NEEDED BY: Product Team ││
│ │ FOR STORY: STORY-456 ││
│ │ ││
│ │ STATUS: 🔴 At Risk ││
│ │ REASON: Resource constraint, competing priorities ││
│ │ ││
│ │ MITIGATION: ││
│ │ Escalated to both team leads ││
│ │ Exploring temporary workaround ││
│ │ ││
│ │ LAST UPDATE: Jan 22 - "May slip to Sprint 16" ││
│ └─────────────────────────────────────────────────────────┘│
└─────────────────────────────────────────────────────────────┘
Managing Dependencies
Communication
CROSS-TEAM COMMUNICATION:
┌─────────────────────────────────────────────────────────────┐
│ │
│ SCRUM OF SCRUMS: │
│ ──────────────── │
│ Representatives from each team meet regularly │
│ Share progress on dependencies │
│ Raise blockers and risks │
│ Coordinate timelines │
│ │
│ AGENDA: │
│ • What did we complete that others depend on? │
│ • What are we blocked on? │
│ • What might block others? │
│ │
│ ─────────────────────────────────────────────────────────── │
│ │
│ DEPENDENCY HANDOFFS: │
│ ┌─────────────────────────────────────────────────────────┐│
│ │ WHEN ACCEPTING DEPENDENCY: ││
│ │ ││
│ │ ☐ Clear specification of what's needed ││
│ │ ☐ Agreed format/interface ││
│ │ ☐ Confirmed delivery date ││
│ │ ☐ Point of contact established ││
│ │ ☐ How to get updates on progress ││
│ │ ││
│ │ WHEN DELIVERING DEPENDENCY: ││
│ │ ││
│ │ ☐ Notify dependent team immediately ││
│ │ ☐ Provide documentation/examples ││
│ │ ☐ Available for questions ││
│ │ ☐ Confirm it meets their needs ││
│ └─────────────────────────────────────────────────────────┘│
│ │
│ ESCALATION: │
│ ─────────── │
│ When dependency is at risk: │
│ 1. Direct team-to-team communication │
│ 2. Involve team leads if unresolved │
│ 3. Escalate to management if critical │
│ │
│ Early escalation, not last-minute surprises │
└─────────────────────────────────────────────────────────────┘
Risk Mitigation
HANDLING DEPENDENCY RISKS:
┌─────────────────────────────────────────────────────────────┐
│ │
│ RISK: DEPENDENCY MIGHT BE LATE │
│ ───────────────────────────── │
│ │
│ OPTION 1: REORDER WORK │
│ Work on independent stories first │
│ Start dependent work when dependency arrives │
│ │
│ OPTION 2: PARALLEL WORK │
│ Start with assumptions (mock API) │
│ Integrate when real dependency ready │
│ Risk: Rework if assumptions wrong │
│ │
│ OPTION 3: REDUCE SCOPE │
│ MVP version without full dependency │
│ Add full integration later │
│ │
│ OPTION 4: INTERNAL SOLUTION │
│ Build temporary workaround ourselves │
│ Replace with proper solution later │
│ Creates tech debt │
│ │
│ ─────────────────────────────────────────────────────────── │
│ │
│ WHEN DEPENDENCY FAILS: │
│ ┌─────────────────────────────────────────────────────────┐│
│ │ DEPENDENCY SLIP RESPONSE: ││
│ │ ││
│ │ SITUATION: ││
│ │ API-123 will be 2 sprints late ││
│ │ ││
│ │ IMPACT: ││
│ │ STORY-456, STORY-457, STORY-460 blocked ││
│ │ Sprint 15 goal at risk ││
│ │ ││
│ │ OPTIONS CONSIDERED: ││
│ │ 1. Wait (lose 2 sprints) ❌ ││
│ │ 2. Build mock API (enable parallel work) ✅ ││
│ │ 3. Rescope to remove dependency ⚠️ ││
│ │ ││
│ │ DECISION: ││
│ │ Build mock API, integrate when real API ready ││
│ │ Extra effort: 3 points ││
│ │ Approved by: @product-owner ││
│ └─────────────────────────────────────────────────────────┘│
└─────────────────────────────────────────────────────────────┘
Reducing Dependencies
Architectural Approaches
MINIMIZING DEPENDENCIES:
┌─────────────────────────────────────────────────────────────┐
│ │
│ LOOSE COUPLING: │
│ ─────────────── │
│ Design systems that can work independently │
│ Clear interfaces between components │
│ Changes in one don't require changes in others │
│ │
│ DEFINED CONTRACTS: │
│ ────────────────── │
│ Agree on API contracts up front │
│ Contract tests ensure compatibility │
│ Teams can develop in parallel │
│ │
│ AUTONOMOUS TEAMS: │
│ ──────────────── │
│ Teams own full stack of their domain │
│ Can build, test, deploy independently │
│ Minimize cross-team code ownership │
│ │
│ ─────────────────────────────────────────────────────────── │
│ │
│ BEFORE/AFTER: │
│ │
│ HIGHLY DEPENDENT: │
│ ┌─────────┐ ┌─────────┐ ┌─────────┐ │
│ │ Team A │───→│ Team B │───→│ Team C │ │
│ │ (Front) │ │ (Back) │ │ (Data) │ │
│ └─────────┘ └─────────┘ └─────────┘ │
│ Every feature needs all three teams │
│ │
│ AUTONOMOUS: │
│ ┌───────────────────────────────────────────────────┐ │
│ │ Product Team (full stack) │ │
│ │ Frontend + Backend + Data for their domain │ │
│ └───────────────────────────────────────────────────┘ │
│ Team can deliver features end-to-end │
│ │
│ DEPENDENCY REDUCTION QUESTIONS: │
│ • Can we restructure teams to reduce handoffs? │
│ • Can we define clearer interfaces? │
│ • Can we give teams more ownership? │
└─────────────────────────────────────────────────────────────┘