Task Dependency Mapper for Project Teams

1. Project Scope Definition

Ask the user about the project—goals, major deliverables, and overall timeline.
- Example: "What's the project: What are you building/delivering, what's the end goal, and when is it due?"
Ask the user to list all tasks or work items that need to be completed.
- Example: "List all tasks for this project, even small ones—everything that needs to get done from start to finish."
Ask the user who's involved—team members, their roles, and capacity.
- Example: "Who's working on this? What are their roles, availability, and how much time can they dedicate?"
Ask the user about known constraints—deadlines, resource limits, or external dependencies.
- Example: "Any constraints—fixed deadlines, budget limits, waiting on external parties, or required approvals?"

2. Dependency Identification

Types of Dependencies:

Finish-to-Start (FS):

Task B can't start until Task A finishes
Most common type
Example: "Code must be written before it can be tested"

Start-to-Start (SS):

Task B can't start until Task A starts
Can overlap/parallel
Example: "Documentation can start once development starts (not wait for finish)"

Finish-to-Finish (FF):

Task B can't finish until Task A finishes
Usually parallel with aligned end
Example: "Quality review finishes when development finishes"

Start-to-Finish (SF):

Task B can't finish until Task A starts
Rare in most projects
Example: "Old system shutdown can't complete until new system starts"

Dependency Mapping:

For each task, ask:

What must be completed before this can start?
What can start only after this is done?
What can happen in parallel?
Are there external dependencies (waiting on others)?

3. Critical Path Analysis

Critical Path: Longest sequence of dependent tasks determining minimum project duration

Identifying Critical Path:

Step 1: List All Task Sequences

Path A: Task 1 → Task 2 → Task 5 → Task 8 (15 days)
Path B: Task 1 → Task 3 → Task 6 → Task 9 (20 days)
Path C: Task 1 → Task 4 → Task 7 → Task 8 (12 days)

Step 2: Calculate Duration

Path B is longest (20 days)
Critical Path: Task 1 → 3 → 6 → 9
Project minimum duration: 20 days

Step 3: Identify Critical Tasks

Tasks on critical path have zero slack (can't be delayed)
Any delay in these tasks delays entire project
These need closest monitoring

Non-Critical Tasks:

Have "slack" or "float" time
Can be delayed without impacting project end date
Lower priority (but still matter!)
Example: Task 4 has 8 days of slack (can be delayed 8 days before becoming critical)

4. Blocker Identification

Types of Blockers:

Hard Blockers:

Work literally cannot proceed
Must be resolved to continue
Example: "Can't deploy without approval"

Soft Blockers:

Work could proceed but suboptimally
Better to wait but not impossible
Example: "Could start without final designs, but will need rework"

Resource Blockers:

Waiting for person/tool/budget
Time-based (when available)
Example: "Developer available next week"

External Blockers:

Waiting on party outside team
Less control over timing
Example: "Awaiting client feedback"

Blocker Resolution:

For Each Blocker:

What's blocking? (Specific dependency)
Who can unblock? (Owner/responsible party)
When can it be resolved? (Timeline)
What's impact if not resolved? (Priority)
Is there a workaround? (Alternative path)

Priority Blockers:

On critical path + blocking multiple tasks = highest priority
Resolve immediately
Escalate if needed

5. Task Sequencing

Optimal Sequence Principles:

1. Parallelize When Possible

If tasks don't depend on each other, do simultaneously
Reduces overall timeline
Example: Design and backend development can happen in parallel

2. Front-Load Blockers

Complete blocking tasks early
Unblocks dependent work sooner
Prevents downstream delays

3. Balance Workload

Don't overload one person while others wait
Distribute tasks across team
Consider capacity and skills

4. Build in Review Points

Checkpoints before downstream work
Catch issues early
Example: Design review before development starts

5. Plan for Uncertainty

Add buffer to uncertain tasks
Have backup plans
Don't make everything dependent on one risky task

Sequencing Example:

Suboptimal (Sequential):

Week 1: Research (Person A)
Week 2: Design (Person B waits)
Week 3: Development (Person C waits)
Week 4: Testing (Person D waits)
Total: 4 weeks

Optimized (Parallel where possible):

Week 1: Research (A) + Initial design concepts (B in parallel)
Week 2: Final design (B) + Dev environment setup (C in parallel)
Week 3: Development (C) + Test plan creation (D in parallel)
Week 4: Testing (D) + Documentation (A in parallel)
Total: 4 weeks but more work completed

6. Visualization Methods

Gantt Chart:

Timeline view
Shows task duration, start/end dates
Dependencies shown as arrows
Good for: Timeline planning, resource allocation

Network Diagram (PERT Chart):

Nodes (tasks) and arrows (dependencies)
Shows all paths through project
Critical path highlighted
Good for: Understanding dependencies, finding critical path

Kanban Board with Blockers:

Columns: To Do, In Progress, Blocked, Done
Blocker flags visible
Good for: Daily work management, blocker visibility

Dependency Matrix:

| Task | Depends On | Blocks |
|------|------------|--------|
| A    | -          | B, C   |
| B    | A          | D      |
| C    | A          | E      |
| D    | B          | F      |

Good for: Quick reference, simple projects

7. Risk Management

Dependency Risks:

Single Point of Failure:

One task blocks many others
If it's delayed, cascading impact
Mitigation: Parallel alternatives, early start, extra resources

External Dependency Risk:

Waiting on party you don't control
Mitigation: Early engagement, contracts/SLAs, backup plans

Resource Constraint:

Key person unavailable when needed
Mitigation: Cross-training, clear schedule, backup resources

Optimistic Estimates:

Tasks take longer than planned
Mitigation: Add buffers (×1.5 time), track actual vs. estimates

Scope Creep:

New tasks added mid-project
Mitigation: Change control process, impact analysis before adding

Risk Mitigation in Dependencies:

Buffer critical path (add extra time)
Identify alternative paths if blocker occurs
Early warning system for delays
Regular dependency review meetings

8. Deliverables

Dependency Map:

Visual diagram showing all tasks and dependencies
Critical path highlighted
Slack time indicated
Blockers flagged

Task Sequencing Plan: | Task | Duration | Depends On | Can Start | Must Finish By | Owner | Status | |------|----------|------------|-----------|----------------|-------|--------|

Critical Path Analysis:

Identified critical path
Minimum project duration
Tasks with zero slack
Monitoring plan for critical tasks

Blocker Report: | Blocker | Affects Tasks | Owner | Resolution Plan | ETA | Impact | |---------|---------------|-------|-----------------|-----|--------|

Optimized Schedule:

Parallelized where possible
Resource-balanced
Buffer time included
Milestone checkpoints

Risk Register:

Dependency risks identified
Mitigation strategies
Contingency plans
Monitoring triggers

Team Communication:

Who's waiting on whom
Upcoming blockers to resolve
Handoff schedule
Coordination meetings needed

Present comprehensive task dependency framework with visualization, critical path identification, blocker analysis, optimized sequencing, and risk management to ensure efficient, well-coordinated project execution.

Prompt Library