Gantto allows you to easily add and remove dependencies between tasks. Dependencies are a very powerful tool, one that we believe is key in managing projects of medium to high complexity. However, dependencies often tend to confuse many of the users of various project management tools out there. One of our goals when designing Gantto was to simplify dependencies as much as possible while maintaining 100% of the capabilities that we believe you’ll need in 99% of your projects. We did this by:

  • supporting only one type of dependency, instead of the 4 that are theoretically possible. The reality is that you’ll hardly ever need anything past the main dependency used in practice by most PMs, i.e. finish to start dependencies (see below for more on FS dependencies).
  • focusing on optimizing the user experience of creating and removing dependencies between tasks.
Below you will learn how dependencies work in Gantto.

What are dependencies and why are they useful?

Dependencies are the relationships among tasks which determine the order in which activities need to be performed. By far the most common of such relationships is the Finish to Start dependencies (or FS dependencies). When create a FS dependency between task A and task B you are forcing task B to start when task A ends. What does this mean, practically?

  • if you move task A in time, task B will move to maintain the finish to start relationship, i.e. task B will always start when task A ends. The same happens if you move task B in time.
Still too theoretical sounding? Even more practically speaking
  • if you’re managing a project whose goal is to build a boat and then sail it across the ocean, it is safe to assume that task B “sail across the ocean” cannot start before task A “build the boat” is complete. If task A is running 6 months late, task B will also run six months late. A dependency between task A and task B will let you model this simple scenario
  • In practice dependencies become really useful when you’re managing projects that are simpler than two tasks since they allow you to understand the effect of one task slipping on other tasks, and ultimately on the overall end date for the project.

A note on building schedules forward vs. backward in time

In our own experience as project managers we have followed two main approaches when building schedules, which we will call forward in time and backward in time. Here is what we mean with these terms:

  • building a schedule “forward in time” typically happens when you know a project start date (e.g. the project needs to start in two weeks) but don’t have any major constraints on the project’s end date. In such case it is best to create a list of tasks, estimate their duration, set the first task’s start date to the given start date, create dependencies between tasks starting from earlier tasks and moving forward in time (thus the name), and evaluate how long the project will take to complete. While this approach may lead to more accurate schedules, not taking into account business constraints on the project’s end date may be unrealistic. Still. it is often good to have an estimate of what a project will really take as opposed to solely making a project fit in a given time frame.
  • building a schedule “backward in time” typically happens when you know a project end date (e.g. the product needs to be launched at a certain show on a certain date) but have some flexibility on the start date, or on the team size, or simply you have no choice (which sadly tends to be the most common scenario icon smile Constraints and Dependencies ). In such a case it is best to create a list of tasks, estimate their duration, set the last task’s end date to the given end date, and then create dependencies from the last task moving back in time, and evaluate whether the start date is feasible (i.e. it’s still in the future) or not. Often the answer will be “no” which leads to various hard discussions.
Each scenario has its pros and its cons, and in our experience, building a schedule is often an iterative process that involves both options.

Working with Gantto’s dependencies UI

Gantto supports both mouse based and keyboard / textual dependency creation. Using your mouse you can

If you prefer thinking of projects as spreadsheets where every row represents a task, Gantto supports this more traditional model as well while adding various visual cues that will hopefully make your life easier. In the following we will describe each one of these items.

Create dependencies between two tasks

You can create a dependency between task A and task B (i.e. make task’s B start after task A ends) by clicking on the dependency anchor to the right of task A, and dragging the dependency to task B. createDependencyBetweenTwoTasks Constraints and Dependencies Note that the color of dependency link changes as you drag it on top of various tasks. A green link means that the dependency you’re trying to create is allowed. A gray link means that the dependency you’re trying to create is not allowed (i.e. it leads to a circular dependency, i.e. a situation where two tasks depend on each other, which is clearly impossible).

Alternatively, you can create a dependency between task A and task B by clicking on the dependency anchor to the left of task B, and dragging the dependency to task A. While both operations create a FS dependency between task A and task B, the former process maintains task A in place and moves task B backward in time, while the latter process maintains task B in place and moves task A forward in time. Using the right anchor of the start task maintains the start task in place and thus is ideal to support creating schedules forward in time (see section above for more on this matter). Using the left anchor of the end task maintains the end task in place and thus is ideal to support creating schedules backward in time (again, see section above for more on this matter).

Remove dependencies between two tasks
Removing dependencies between two tasks in Gantto is extremeley simple. All you need to do is hover over the dependency you would like to remove and press on the red X button. So what happens if you have a very complicated web of overlapping dependencies? Simply hover over the dependency you’d like to delete by finding a part of it that is not overlapping with other dependencies, and once the dependency turns red delete it clicking on one of the red X buttons. deleteDependency Constraints and Dependencies
Create a new dependent task that comes after a given task
Given task A, you can add a new task B to the project that is dependent on task A by clicking on the dependency anchor to the right of task A. Gantto adds a new row under task A, creates a task B, and creates a dependency between task A and task B. Note that task A does not move in time, i.e. this supports creating schedules forward in time (see section above for more on this matter).
Create a new dependent task that comes before a given task
Given task B, you can add a new task A to the project that task B depends on by clicking on the dependency anchor to the left of task B. Gantto adds a new row above task B, create a new task A, and creates a dependency between task A and task B. Note that task B does not move in time, i.e. this supports creating schedules backward in time (see section above for more on this matter).
Create / remove dependencies between a list of selected tasks
The methods discussed above are great ways to create dependencies between two tasks. If you are dealing with more than two tasks, Gantto allows you to create dependencies between all of them by simply selecting them and clicking on the Top Ribbon Task -> Connect connect Constraints and Dependencies button. Note: this eliminates any previous dependencies between selected tasks and assumes a pure waterfall model, i.e. where the vertical order of the tasks matches their order in time. connectExample 600x97 Constraints and Dependencies You can also delete any dependencies between more than two selected tasks by clicking on the Top Ribbon Task -> Disconnect disconnect Constraints and Dependencies button. This command eliminates any dependencies and maintains all tasks in their current position.
Create / remove dependencies between tasks in spreadsheet mode
If you like to manage your projects through the spreadsheet view you can add a FS dependency between task A and task B by entering the row number for task A in the predecessor cell of task B. In order to help you avoid typing the wrong row number, Gantto supports an auto-complete feature that lets you type row numbers or task names in predecessor cells and then pick between a list of options. predecessorCell Constraints and Dependencies Moreover, if you are not sure about which tasks are feasible predecessors for the specific task that you’re editing, you can hold down the CTRL key (Windows) or CMD key (Macs) and Gantto will use the color green to color code all rows of feasible cells. Clicking on one of such rows adds it to the predecessor list for the task you’re editing and recomputes a new list of feasible predecessors which are, again, displayed in green. No green cells anywhere means no feasible predecessors for the current task. possiblePredecessorsUI Constraints and Dependencies

No related posts.