Dependency Tracking Overview
Dependency tracking ensures visibility of task relationships, identifies blocking issues early, and enables better resource planning and risk mitigation.
When to Use Multi-team projects and programs Complex technical integrations Cross-organizational initiatives Identifying critical path items Resource allocation planning Preventing schedule delays Onboarding new team members Instructions 1. Dependency Mapping
Dependency mapping and tracking
class DependencyTracker: DEPENDENCY_TYPES = { 'Finish-to-Start': 'Task B cannot start until Task A is complete', 'Start-to-Start': 'Task B cannot start until Task A starts', 'Finish-to-Finish': 'Task B cannot finish until Task A is complete', 'Start-to-Finish': 'Task B cannot finish until Task A starts' }
def __init__(self):
self.tasks = []
self.dependencies = []
self.critical_path = []
def create_dependency_map(self, tasks):
"""Create visual dependency network"""
dependency_graph = {
'nodes': [],
'edges': [],
'critical_items': []
}
for task in tasks:
dependency_graph['nodes'].append({
'id': task.id,
'name': task.name,
'duration': task.duration,
'owner': task.owner,
'status': task.status
})
for blocker in task.blocked_by:
dependency_graph['edges'].append({
'from': blocker,
'to': task.id,
'type': 'Finish-to-Start',
'lag': 0 # days between tasks
})
return dependency_graph
def analyze_critical_path(self, tasks):
"""Identify longest chain of dependent tasks"""
paths = self.find_all_paths(tasks)
critical_path = max(paths, key=len)
return {
'critical_items': critical_path,
'total_duration': sum(t.duration for t in critical_path),
'slack_available': 0,
'any_delay_impacts_schedule': True,
'monitoring_frequency': 'Daily'
}
def identify_blocking_dependencies(self, tasks):
"""Find tasks that block other work"""
blocking_tasks = {}
for task in tasks:
blocked_count = sum(1 for t in tasks if task.id in t.blocked_by)
if blocked_count > 0:
blocking_tasks[task.id] = {
'task': task.name,
'blocking_count': blocked_count,
'blocked_tasks': [t.id for t in tasks if task.id in t.blocked_by],
'status': task.status,
'due_date': task.due_date,
'risk_level': 'High' if blocked_count > 3 else 'Medium'
}
return blocking_tasks
def find_circular_dependencies(self, tasks):
"""Detect circular dependency chains"""
cycles = []
for task in tasks:
visited = set()
if self.has_cycle(task, visited, tasks):
cycles.append({
'cycle': visited,
'severity': 'Critical',
'action': 'Resolve immediately'
})
return cycles
def has_cycle(self, task, visited, tasks):
visited.add(task.id)
for blocker_id in task.blocked_by:
blocker = next(t for t in tasks if t.id == blocker_id)
if blocker.id in visited:
return True
if self.has_cycle(blocker, visited, tasks):
return True
visited.remove(task.id)
return False
- Dependency Management Board Dependency Tracking Dashboard:
Project: Platform Migration Q1 2025
Critical Path (Blocking Progress):
Task: Database Migration ID: TASK-101 Owner: Data Team Duration: 20 days Status: In Progress (50%) Due Date: Feb 28, 2025 Blocked By: Schema validation (TASK-95) - DUE TODAY Blocks: 6 downstream tasks Risk Level: HIGH Action Items: - Daily standup with Data Team - Schema validation must complete by EOD - Have rollback plan ready
Task: API Contract Finalization ID: TASK-102 Owner: Backend Team Duration: 10 days Status: Pending (Blocked) Depends On: Database Migration (TASK-101) Blocks: Frontend implementation (TASK-103), Testing (TASK-104) Slack Time: 0 days (critical) Early Start: Mar 1, 2025 Action Items: - Start draft specifications now - Review with Frontend team - Have alternative approach ready
High-Risk Dependencies:
Dependency: Third-party Integration From: Payment Service API (vendor) To: Checkout System (TASK-150) Type: External/Uncontrollable Status: At Risk (Vendor delay reported) Mitigation: Mock service implementation, alternative vendor identified Escalation Owner: Product Manager
By Team Dependencies:
Backend Team: - Database migration → API development - Schema design → Data layer implementation External: Awaiting Payment Gateway API docs
Frontend Team: - API contracts → UI implementation - Design system → Component development Dependency on Backend: API contract specs (scheduled Feb 20)
DevOps Team: - Infrastructure provisioning → Testing environment - Kubernetes setup → Staging deployment External: Cloud provider quota approval
- Dependency Resolution // Handling and resolving dependency issues
class DependencyResolution { resolveDependencyConflict(blocker, blocked) { return { conflict: { blocking_task: blocker.name, blocked_task: blocked.name, reason: 'Circular dependency detected' }, resolution_options: [ { option: 'Parallelize Work', description: 'Identify independent portions that can proceed', effort: 'Medium', timeline: 'Can save 5 days' }, { option: 'Remove/Defer Blocker', description: 'Defer non-critical requirements', effort: 'Low', timeline: 'Immediate' }, { option: 'Create Interim Deliverable', description: 'Deliver partial results to unblock downstream', effort: 'High', timeline: 'Can save 8 days' } ] }; }
breakDependency(dependency) { return { current_state: dependency, break_strategies: [ { strategy: 'Remove unnecessary dependency', action: 'Refactor to eliminate requirement', risk: 'Low if verified' }, { strategy: 'Mock/Stub external dependency', action: 'Create temporary implementation', risk: 'Medium - ensures compatibility' }, { strategy: 'Parallel development', action: 'Make assumptions, validate later', risk: 'Medium - rework possible' }, { strategy: 'Resource addition', action: 'Parallelize work streams', risk: 'Low but costly' } ] }; }
handleBlockedTask(task) { return { task_id: task.id, status: 'Blocked', blocker: task.blocked_by[0], time_blocked: task.calculateBlockedDuration(), actions: [ 'Notify team of blockage', 'Escalate if critical path', 'Identify alternative work', 'Schedule resolution meeting', 'Track blocker closure date' ], escalation: { immediate: task.is_critical_path, owner: task.program_manager, frequency: 'Daily standup until resolved' } }; } }
- Dependency Dashboard Metrics Key Metrics:
Critical Path Health: - Items on Critical Path: 12 - At-Risk Items: 2 (17%) - Completed: 4 (33%) - On Track: 6 (50%) - Behind: 2 (17%)
Dependency Status: - Total Dependencies: 28 - Resolved: 18 - Active: 8 - At Risk: 2 - Circular: 0 (Good!)
Blocking Impact: - Tasks Currently Blocked: 3 - Team Members Idle: 2 - Blocked Effort (person-hours): 24 - Estimated Cost of Blockage: $2,400
Escalations: - Open: 1 (Database migration dependency) - Resolved This Week: 0 - Average Resolution Time: 2.3 days
Best Practices ✅ DO Map dependencies early in planning Update dependency tracking weekly Identify and monitor critical path items Proactively communicate blockers Have contingency plans for key dependencies Break complex dependencies into smaller pieces Track external dependencies separately Escalate blocked critical path items immediately Remove unnecessary dependencies Build in buffer time for risky dependencies ❌ DON'T Ignore external dependencies Leave circular dependencies unresolved Assume dependencies will "work out" Skip daily monitoring of critical path Communicate issues only in status meetings Create too many dependencies (couples systems) Forget to document dependency rationale Avoid escalating blocked critical work Plan at 100% utilization (no buffer for dependencies) Treat all dependencies as equal priority Dependency Management Tips Color-code by risk level in tracking tools Weekly review of blocked/at-risk items Maintain updated dependency diagram Escalate after 1 day of blockage on critical path Build 15-20% buffer for risky dependencies