Task Dependencies: Manage Task Relationships and Project Flow

Last Updated: July 1, 2025
Feature Status: Stable
User Level: Intermediate
Estimated Reading Time: 8 minutes

Overview

Task dependencies help you define relationships between tasks, ensuring work happens in the right order. When you set dependencies, you're telling Commander which tasks must be completed (or started) before others can begin, creating a logical flow for your projects.

What You'll Learn

How to create predecessor and successor relationships between tasks
Understanding the four types of task dependencies
Best practices for managing complex project workflows
How to avoid circular dependencies and bottlenecks

Before You Start

You need edit permissions on the taskboard
Tasks should already be created in your project
Understanding of your project's workflow sequence

Quick Start

TL;DR Version

Open any task in the task detail view
Scroll to the "Dependencies" section
Search for and select a task to add as a dependency
Choose the dependency type (Finish-to-Start is most common)

Result: Tasks now have a defined relationship that helps team members understand work order.

Step-by-Step Guide

Step 1: Access Task Dependencies

Click on any task card in your taskboard to open the task detail view
Scroll down to find the "Dependencies" section (it has a chain link icon)
The section shows any existing dependencies and allows you to add new ones

💡 Tip: Dependencies appear as a dedicated section in the task sidebar, separate from other task details.

Step 2: Add a New Dependency

In the Dependencies section, you'll see a dropdown menu and search field
First, select the dependency type from the dropdown:
- Finish-to-Start (FS): Most common - the predecessor task must finish before this task can start
- Start-to-Start (SS): This task can't start until the predecessor starts
- Finish-to-Finish (FF): This task can't finish until the predecessor finishes
- Start-to-Finish (SF): This task can't finish until the predecessor starts
Type in the search field to find the task you want to link
Click the task name when it appears in the search results

⚠️ Important: You cannot create circular dependencies (Task A depends on Task B, which depends on Task A). Commander will prevent this and show an error message.

Step 3: Review Your Dependencies

Once added, dependencies appear in two lists:

Predecessors (Orange): Tasks that must be completed before this task

Shows completion status with green checkmarks or orange circles
Displays the dependency type (FS, SS, etc.)
Click the X to remove the dependency

Successors (Teal): Tasks that depend on this task being completed

Shows which tasks are waiting for this one
Helps you understand the impact of delays

✅ Success: You'll see your dependencies listed with clear visual indicators of their status and type.

Understanding Dependency Types

Finish-to-Start (FS) - Most Common

Use when: Task B cannot begin until Task A is completely finished Example: "Write requirements" → "Begin development" Visual: Orange circle changes to green checkmark when predecessor completes

Start-to-Start (SS)

Use when: Task B cannot start until Task A has started (but A doesn't need to finish) Example: "Begin testing" can start when "Development begins" (parallel work)

Finish-to-Finish (FF)

Use when: Task B cannot finish until Task A finishes Example: "Documentation" cannot finish until "Development" finishes

Start-to-Finish (SF) - Rarely Used

Use when: Task B cannot finish until Task A starts Example: Night shift cannot end until day shift starts

Advanced Features

Dependency Chains

You can create complex chains: Task A → Task B → Task C → Task D

Each task shows its immediate predecessors and successors
The system prevents circular references automatically
Use this for linear workflows with multiple stages

Parallel Dependencies

One task can have multiple predecessors or successors:

Multiple Predecessors: Task C depends on both Task A AND Task B finishing
Multiple Successors: Task A completion triggers both Task B AND Task C

Tips & Best Practices

Do's

✅ Start simple: Use Finish-to-Start (FS) for most dependencies - it's intuitive and covers 80% of use cases
✅ Document why: Use task descriptions to explain why dependencies exist, especially for complex relationships
✅ Review regularly: Dependencies can become outdated as projects evolve - review and clean up periodically

Don'ts

❌ Over-constrain: Don't add dependencies for tasks that could run in parallel - it slows down project velocity
❌ Create bottlenecks: Avoid having too many tasks depend on a single person or resource
❌ Ignore completion status: If a predecessor is stuck, address it quickly to prevent downstream delays

Pro Tips

🚀 Use for priority: Team members can focus on tasks with completed predecessors first
🚀 Identify critical path: Tasks with the most successors are often on the critical path
🚀 Communicate changes: When removing dependencies, let the team know why the workflow changed

Troubleshooting

Common Issues

"This dependency already exists" Error

Symptoms: Error message when trying to add a dependency that's already been created Solution: Check both the Predecessors and Successors sections - the relationship might already exist in the opposite direction

Cannot Find Task in Search

Symptoms: Task doesn't appear when searching to add as dependency Solution:

Ensure the task exists in the same project
Try searching by partial name or key words
Check that you have permission to view the task

Circular Dependency Warning

Symptoms: Error message preventing you from adding a dependency Solution: This is intentional protection. Review your task relationships to ensure they create a logical flow, not a loop.

Still Need Help?

If you're still experiencing issues:

Check our Task Management FAQ
Contact support with:
- Screenshot of the dependency error
- Names of the tasks you're trying to link
- Description of your intended workflow

Related Features

Workflows

This feature is commonly used with:

Project Planning: Create Tasks → Set Dependencies → Assign Team
Status Updates: Update Progress → Check Dependencies → Unblock Successors

Examples

Example 1: Website Development Project

Scenario: Building a new website with clear sequential steps

Dependencies Setup:

"Gather Requirements" (no dependencies)
"Create Wireframes" depends on "Gather Requirements" (FS)
"Design Mockups" depends on "Create Wireframes" (FS)
"Frontend Development" depends on "Design Mockups" (FS)
"Content Writing" depends on "Gather Requirements" (FS) - can happen parallel to design
"Integration Testing" depends on "Frontend Development" AND "Content Writing" (FS)

Result: Clear workflow where each phase builds on the previous, with some parallel work possible.

Example 2: Event Planning

Scenario: Organizing a conference with multiple parallel tracks