Appearance

Intro to Timeline Dependencies ​

Video Placeholder Duration: 4-6 minutes Topics covered: What are dependencies, dependency types, creating dependencies, timeline visualization

What are Timeline Dependencies? ​

Timeline Dependencies define relationships between work items where one task depends on another. They help you understand which tasks must complete before others can start, preventing scheduling conflicts and bottlenecks.

Why Dependencies Matter ​

Without dependencies:

  • Work might start before prerequisites are ready
  • Deadlines set unrealistically
  • Team blocked waiting for dependencies

With dependencies:

  • Clear sequence of work
  • Realistic scheduling
  • Blockers visible immediately

Dependency Types ​

Plane supports three dependency relationship types:

Finish-to-Start (FS) ​

Most common

Task B cannot start until Task A finishes.

Example: "Build API" can't start until "Design API" is done.

Start-to-Start (SS) ​

Tasks start together but can progress independently.

Example: "Write Documentation" can start when "Build Feature" starts.

Finish-to-Finish (FF) ​

Tasks must complete together.

Example: "Testing" must finish when "Development" finishes.

Prerequisites ​

For dependencies to work:

  1. Work items must have Start Date set
  2. Work items must have Due Date set
  3. View in Timeline Layout to see dependency lines

Creating Dependencies ​

Method 1: Relations Property ​

  1. Open a work item
  2. Go to Relations section
  3. Add a relation:
    • Blocking — This item blocks another
    • Blocked by — This item is blocked by another

Method 2: Timeline Drag ​

In Timeline view:

  1. Hover over a work item
  2. Click and drag the connector point
  3. Connect to the dependent item
  4. Dependency line appears

Viewing Dependencies ​

Timeline Layout ​

The Timeline (Gantt) view is the best way to visualize dependencies:

Jan 1       Jan 8       Jan 15      Jan 22
|-----------|-----------|-----------|
[===Task A===]
              ↘
               [===Task B===]
                            ↘
                             [===Task C===]

Dependency Lines ​

  • Normal lines: Valid dependencies
  • Red lines: Conflicts (dates don't align)

Conflict Detection ​

Red lines indicate scheduling problems:

  • Task B is scheduled to start before Task A ends
  • Dependencies can't be satisfied with current dates

Auto-Adjustment ​

When you move tasks on the timeline:

  • Dependent tasks adjust automatically
  • Maintains the dependency relationship
  • Cascades changes through the chain

Example ​

Before: Task A (Jan 1-5) → Task B (Jan 6-10)
Move Task A to Jan 3-7
After: Task B automatically shifts to Jan 8-12

Managing Dependencies ​

View All Dependencies ​

  1. Open work item detail
  2. Check Relations section
  3. See all blocking/blocked relationships

Remove a Dependency ​

  1. Open the work item
  2. Go to Relations
  3. Click the X next to the dependency
  4. Confirm removal

Circular Dependencies ​

Plane prevents circular dependencies:

  • A → B → C → A (not allowed)
  • System warns when this would occur

Dependency Best Practices ​

Be Specific ​

Only create dependencies when truly necessary:

  • ✅ Build API before Build UI (real dependency)
  • ❌ Design icon before Write docs (not dependent)

Check for Conflicts ​

Regularly review Timeline view for:

  • Red conflict lines
  • Unrealistic schedules
  • Bottleneck tasks (many dependencies)

Update When Scope Changes ​

When work changes:

  • Review and update dependencies
  • Remove outdated relationships
  • Add new dependencies as discovered

Don't Over-Depend ​

Too many dependencies:

  • Makes planning rigid
  • Small delays cascade everywhere
  • Consider which are truly blocking

Dependency Patterns ​

Sequential Chain ​

Design → Develop → Test → Deploy

Common for phased work.

Parallel with Convergence ​

     → Build Feature A ↘
Start                    → Integration → Deploy
     → Build Feature B ↗

Multiple streams meeting at a point.

Resource Dependency ​

Task A (Alice) → Task B (Alice)

Same person, sequential work.

Key Takeaways ​

  • Dependencies show which tasks block others
  • Three types: Finish-to-Start, Start-to-Start, Finish-to-Finish
  • Requires Start Date and Due Date on work items
  • Create via Relations property or drag in Timeline view
  • Red lines indicate scheduling conflicts
  • Dependent tasks auto-adjust when you move items
  • Don't over-create dependencies — only true blockers

Next Steps ​

Mark key dates and deliverables with Milestones.

Next Lesson: Intro to Milestones

Plane University

Made with love by Plane