Table of Contents
What Are Project Dependencies?
Project dependencies are logical relationships between tasks in your project schedule. They define the order in which activities must be completed and help project managers understand which tasks can run in parallel and which must wait for others to finish.
Think of dependencies as the "rules" that govern your project timeline. Without proper dependencies, your Gantt chart becomes just a pretty timeline—with them, it becomes a powerful scheduling engine that can automatically adjust dates and prevent resource conflicts.
Why Dependencies Matter
- Prevent scheduling conflicts and resource overallocation
- Use Auto Adjustment feature to recalculate dates when needed (gives you complete control)
- Spot dependency conflicts and scheduling issues
- Improve project predictability and stakeholder communication
The Four Types of Dependencies
Project management recognizes four standard types of task dependencies, each serving different scheduling scenarios:
FS - Finish-to-Start
Most Common - Default Type
Task B cannot start until Task A finishes. The traditional sequential dependency. This is the default type when creating dependencies in our template.
Example: FS dependency showing sequential task flow
SS - Start-to-Start
Parallel Work
Task B cannot start until Task A starts. Both tasks can run concurrently after the start trigger.
Example: SS dependency with parallel task execution
FF - Finish-to-Finish
Synchronized Completion
Task B cannot finish until Task A finishes.
Example: FF dependency with synchronized completion
SF - Start-to-Finish
Rare Scenarios
Task B cannot finish until Task A starts. Used in just-in-time or handover scenarios.
Example: SF dependency for handover scenarios
Finish-to-Start (FS) Dependencies
Finish-to-Start (FS) is the most intuitive and commonly used dependency type. It represents the traditional sequential workflow where one task must be completely finished before the next can begin.
When to Use FS Dependencies:
✅ Perfect for FS Dependencies:
- Sequential Manufacturing: "Assemble Frame" must finish before "Paint Frame" can start
- Document Approval: "Draft Contract" must be complete before "Legal Review" begins
- Construction: "Pour Foundation" must finish before "Frame Walls" can start
- Software Development: "Design Database" must be complete before "Implement Database" begins
- Event Planning: "Book Venue" must finish before "Send Invitations" can start
How to Create Dependencies in QuickGantt
Creating Dependencies: Step-by-Step
- Select the predecessor task: Click the Gantt bar for the task that must happen first
- Select the dependent task: Click the Gantt bar for the task that depends on the first
- Dependency is created: QuickGantt automatically creates an FS (Finish-to-Start) dependency
- Modify if needed: Double-click the dependency line to change the type (SS, FF, SF)
Watch the Process:
FS Dependency Example: Website Development
FS dependency in practice: Sequential task execution
Why FS works here: Designers need complete wireframes to create accurate visual designs. Starting design work with incomplete wireframes leads to rework and scope creep.
Start-to-Start (SS) Dependencies
Start-to-Start (SS) dependencies enable parallel work by allowing Task B to begin as soon as Task A starts. This dependency type is crucial for optimizing project timelines and enabling concurrent activities.
When to Use SS Dependencies:
✅ Perfect for SS Dependencies:
- Documentation & Development: "Write Code" starts, then "Write Unit Tests" can start simultaneously
- Training & Implementation: "Begin System Rollout" triggers "Start User Training"
- Marketing Campaigns: "Launch Ad Campaign" allows "Social Media Promotion" to begin
- Research Projects: "Start Data Collection" enables "Begin Preliminary Analysis"
- Construction: "Begin Electrical Work" triggers "Start Plumbing Installation"
SS Dependency Example: Product Launch
SS dependency in practice: Parallel task execution
Why SS works here: Marketing team can begin planning and creating materials as soon as they know development has started, even though the product isn't finished yet.
Finish-to-Finish (FF) Dependencies
Finish-to-Finish (FF) dependencies ensure that Task B cannot finish until Task A finishes. Task B can finish at the same time as Task A or after Task A completes.
When to Use FF Dependencies:
✅ Perfect for FF Dependencies:
- Quality Assurance: "Testing" cannot finish until "Development" finishes
- Document Review: "Final Editing" must finish when "Content Writing" finishes
- Event Coordination: "Setup AV Equipment" finishes when "Setup Catering" finishes
- Manufacturing: "Quality Control" completes when "Production Line" completes
- Data Migration: "Data Validation" finishes when "Data Transfer" finishes
FF Dependency Example: Software Release
FF dependency in practice: Dependent task finish timing
Why FF works here: QA testing can begin partway through development, but cannot finish until development is complete.
Start-to-Finish (SF) Dependencies
Start-to-Finish (SF) is the rarest dependency type. Task B cannot finish until Task A starts. This creates scenarios where one activity must be initiated before another can be concluded.
When to Use SF Dependencies:
✅ Perfect for SF Dependencies:
- System Transitions: "Old System Operation" cannot finish until "New System Go-Live" starts
- Shift Handovers: "Night Shift" cannot end until "Day Shift" begins
- Just-in-Time Delivery: "Warehouse Storage" ends when "Customer Pickup" starts
- Security Protocols: "Temporary Access" finishes when "Permanent Access" starts
- Resource Transfers: "Equipment Rental" ends when "Equipment Purchase" begins
SF Dependency Example: System Migration
SF dependency in practice: Handover timing control
Why SF works here: Business continuity requires the old system to keep running until the exact moment the new system goes live.
Resolving Schedule Conflicts
When dependencies create scheduling conflicts, QuickGantt template helps you identify and resolve them. Red dependency lines indicate conflicts that need attention.
Red dependency lines indicate scheduling conflicts that need resolution
How to resolve: Use the Auto-rescheduler feature or manually adjust task dates to eliminate conflicts.
Best Practices for Dependencies
✅ Do's
- Start with FS dependencies - they're the most common and intuitive
- Use manual date adjustments when tasks need gaps between dependencies
- Review dependencies regularly as project scope changes
- Document the reasoning behind each dependency for future reference
❌ Don'ts
- Avoid unnecessary dependencies - they constrain scheduling flexibility
- Don't use SF dependencies unless absolutely necessary
- Never create circular dependencies (Task A depends on Task B, which depends on Task A)
- Don't over-constrain your schedule with too many dependencies
Common Mistakes to Avoid
Mistake #1: Using Wrong Dependency Types
Using FS for everything, even when SS or FF would be more appropriate.
Solution: Evaluate each relationship individually and choose the dependency type that best reflects the real-world constraint.
Mistake #2: Over-Constraining the Schedule
Adding dependencies where none exist, reducing schedule flexibility unnecessarily.
Solution: Ask "What would happen if these tasks ran in parallel?" If there's no real conflict, don't add a dependency.
Mistake #3: Not Updating Dependencies
Creating dependencies at project start but never reviewing them as the project evolves.
Solution: Review and update dependencies during regular project reviews, especially when scope changes occur.
Ready to Apply These Dependencies?
Now that you understand when to use FS, SS, FF, and SF dependencies, put your knowledge into practice with our free Excel Gantt chart template. It includes built-in dependency tracking and examples of all four dependency types.
✨ Template Features Shown in This Guide:
- Visual dependency creation by clicking Gantt bars
- Automatic conflict detection with red warning lines
- Auto-rescheduler for resolving dependency conflicts
- Support for all four dependency types (FS, SS, FF, SF)
Quick Reference Summary
When to Use Each Type
- FS (Most Common): Sequential work, traditional handoffs
- SS: Parallel work that starts together
- FF: Work that must finish together
- SF: Handover scenarios, system transitions
Key Reminders
- Start with FS, then optimize with other types
- Use manual scheduling when gaps are needed
- Avoid over-constraining your schedule
- Review dependencies regularly
- Document your reasoning