Select topic
Table of contents
Task dependencies are tools that allow us to define and track complicated task relationships in projects.
Depending on the project, there are several task dependencies to choose from. However, they all have the same purpose. They define how tasks in a project relate and clarify their order. In this post, we’ll cover dependencies types, explain what SS, SF, FS, and FF mean, provide examples of dependent tasks, and more.
In project management, task dependencies are really important. They help you understand how tasks are linked together and determine the order in which tasks must be completed. Knowing these dependencies allows you to manage your project more efficiently and meet your deadlines.

When it comes to task dependency types, there are two main schools of thought.
The first approach categorizes dependencies into 4 distinct types. They are based on when a Successor task follows a Predecessor task.
The four types are as follows:
This approach is found in most project management guides and is closely related to visualizing projects on a Gantt chart.
The second way to define task dependency types is to look at how the tasks depend on each other. Is the dependency resource, people, project, or team-based? Managing such relationships will vary by type and it will require specific skills.

Let’s discuss both these approaches in detail for more context.
Here, you will find a top 3 short-list of tools that have the best functionality around dependencies. The best visual project management tools post can provide a detailed comparison. Read more in that write-up to find out how we compare tools against each other.
Another way to understand task dependencies is to analyze the start and finish dates of the dependent tasks. The two important terms to know here are the Predecessor and the Successor.
Now that we have clarified this terminology let’s look into the 4 types of such dependencies.

Finish to Start is the simplest and most common out of the four dependency types. As such, you will see the use of such dependencies in most projects.
The Finish to Start dependency states that – the Predecessor task must be finished before a Successor task can be started. In other words, one task must be finished before the other task can start.

Finish to Start Dependency Example
Imagine you are responsible for the construction of a new building. In such a case, a finish-to-start example could be the relationship between tasks ‘Get building permissions’ and ‘Lay foundation’. Before starting to lay the foundation of your new building, you would have to get all of the building permits. In other words, you would have to finish one task before starting another.
The Finish to Finish is a little more complicated. It states that the Successor task cannot be finished before the Predecessor task is finished.
This is usually applied to tasks that are being worked on at the same time, but one of them cannot be truly finished before the other one is complete. Contrary to the previous task relationship, project management professionals sometimes debate the use of this and the following two dependencies. Raising the question of the necessity for such relationships. However, I will cover them to give you the full picture.

Finish to Finish Dependency Example
Now, let’s go back to the example of our building and, this time, think about working on the interior. At this stage, many things are happening simultaneously. For example, ‘Put in drywall’ and ‘Put in the electrical installation’. Both tasks will be done at the same time. But, the electrical installation can’t be finished before the drywalls are in. This creates a finish-to-finish dependency.
This third type of task dependency is similar to the previous one. Start to Start states that the Successor task cannot be started before the Predecessor task has been started.
This often relates to tasks being worked on simultaneously. However, it is important to start one task before the other.

Start to Start Dependency Example
In our building example, let’s say it is time to ‘Paint the exterior’. This task cannot start before the task ‘Assemble scaffolding’ has been started as well. Both tasks can be and are being worked on at the same time. But, scaffolding must start before the painting can begin.
Lastly, the Start to Finish dependency states that the Successor task can’t be finished before the Predecessor task starts.
This is the most complicated and most debated dependency out of the four. Some project managers say it should not be used at all, and others defend its usage and benefits. I will leave it up to you to decide if you want to use this. In short, this rule says the next task must continue until the previous task is ready to start.

Start to Finish Dependency Example
In our building, tasks ‘Provide building administration’ and ‘Handover building administration’ have Start to Finish dependency. The first is the Successor and the second is the Predecessor. Here, the company that built the building must keep running it. They must do so until the chosen supplier is ready to take over. The Successor task is completed before the Predecessor. This is the hardest dependency to use and understand.
One way to categorize is by looking at what these dependencies talk about. In such a case, we can say that most tasks are dependent on one of the following 4:
Resource-based task dependencies talk about tasks that have to share the same resource.
For example, if specific machinery is needed to complete tasks, only a certain number of tasks can be worked on at the same time. This creates a dependency. A new task can only start once the previous one has finished.
In such cases, teams usually draw visual links between tasks. Thus indicating their relationship.

Dependencies between people are similar to resource-based ones. In this case, however, certain tasks have to wait because there is limited manpower.
To picture these bonds, most project managers rely on advanced software for project or workload management. It allows us to understand the capacity of each team member and assign adequate workload to each.

Learn more about workload management.
Another type of relationship is found when there are dependencies between projects.
This task dependency in project management can happen due to various reasons. One project’s progress may be dependent on another project’s outcome. They may share resources or facilities. Either way, such projects become dependent on each other and must be coordinated.
To visualize dependencies like this, most teams use Gantt charts or Timeline views. These views show many projects on one screen. Allowing them to understand their relationships and make well-informed decisions.

If you are looking for such a tool, take a look at the best project timeline management tools.
Last but not least, the dependency type on this list is between teams.
Similarly to projects, teams often have to share resources and are closely related to each other’s work. Thus, it comes as no surprise that we can find task relationships between different teams.
Just like with the previous type, most teams use the workload view and Gantt charts to visualize such relationships.
Like what you see? Pick your solution from the best project planning tools list.
Setting and managing task dependencies differs by the project management methodology you use.
If you are after the traditional look, such as in the examples above, you will use the Gantt view most. You can use the Gantt chart to plan out tasks or phases of a project in a calendar-like view. You can draw dependencies between them to show important relationships and order. This view is great for long-term planning. It shows the exact dates when the project will finish.
Better project management tools can set task dependencies. They can reschedule them. This way, the dependent tasks are rescheduled if one task is late. This gives you a clear sense of when the project will be done. One thing to note with automatic rescheduling is that most tools will stay true to the original slack. (The difference between the finish date of the predecessor and the start date of the successor)
So, if Slack was first set at 2 days, it would stay at 2 days even after the rescheduling happens.
Another standard view in the project management field is a List. Small teams usually use this approach to task management. It’s also used when managing part of a larger project. However, it can prove useful in various scenarios. This approach’s significant advantage is seeing many fields of info for all tasks.
In tools like Teamhood, you can add fields. These include: status, schedule, assignee, estimate, budget, and dependencies. Also, the task creator, create date, item age, and any custom fields (like contract value). In this view, task dependencies use special symbols. These symbols show if a task is waiting on ❗ or blocking ⛔ another task. To see the task in question, you simply click on the icon.

Finally, more managers want to add dependency management to their Agile or Kanban boards. This visual management tool is very useful. It has proven especially helpful for helping teams manage their workload. So, it’s no surprise that Kanban board tools now also have task dependency features.
Like with the List view, on a Kanban board, you will not see lines going from one task to another. They would define task dependency. Instead, the work item cards will have symbols. They will show if a work item is waiting on something ❗ or blocking something ⛔. Open the item details to see more details on each dependency or add a new one.

Using dependencies in your projects has several clear benefits.
Continue learning:
Curious to try out task dependency management for your project? Teamhood supports all three views discussed above—Gantt, List, and Kanban. This provides a good option for those wanting to mix Kanban Gantt in their application.
Moreover, you can use all three views for your project simultaneously.
In project management, there are four types of dependencies:
Finish-to-Start (FS): A task cannot start until the previous task is completed
Finish-to-Finish (FF): A task cannot finish until the previous task is finished
Start-to-Start (SS): A task cannot start until the previous task has started
Start-to-Finish (SF): A task cannot finish until the previous task has started
An example of a dependent task pattern is when Task B depends on Task A. Task B cannot start until Task A is completed, and Task A cannot finish until Task B has started.
The most common type of dependency is the Finish-to-Start (FS) dependency, where a task cannot start until the previous task is completed.
To manage dependencies, you can use project management tools like Gantt charts or dependency diagrams. These tools help visualize the relationships between tasks and ensure that tasks are completed in the correct order. Additionally, you can use software development tools like npm or Yarn to manage dependencies in your codebase.