How to build tasks dependencies with durations in Google Sheets, ClickUp, Monday, Wrike, SmartSheet, Notion, and Coda
Tags: projectmanagement, productivity, tutorial
Published: 2020-10-05 15:19:57

---
title: How to build tasks dependencies with durations in Google Sheets, ClickUp, Monday, Wrike, SmartSheet, Notion, and Coda
description: This tutorial shows how Google Sheets, ClickUp, Monday.com, Wrike, Smartsheet, Notion, and Coda handle task dependencies for a project.
published: true
date: 2020-10-05 02:41:55 UTC
tags: projectmanagement, productivity, tutorial
canonical_url: https://coda.io/@atc/how-to-build-tasks-dependencies-with-durations-in-google-sheets-clickup-monday-wrike-smartsheet-notion-coda
cover_image: https://p-ZmF7dQ.b0.n0.cdn.getcloudapp.com/items/JrugXrvo/cover-image.jpg?v=2d8765c68e0b4ee4b94fe9a295069525
---

_This post originally appeared [_here_](https://coda.io/@atc/how-to-build-tasks-dependencies-with-durations-in-google-sheets-clickup-monday-wrike-smartsheet-notion-coda)_.

Your project may contain tasks that depend on each other. Sometimes a task cannot _start_ until its dependent (predecessor) task _finishes_, or maybe the task can _start_ when its dependent task _starts_ as well. As you manage tasks with these more complex [dependency types](https://en.wikipedia.org/wiki/Dependency_(project_management)) (FS, SF, SS, FF), you may find more specialized software or SaaS tool to help you plan and visualize these tasks.

## Goal of this post

This post doesn’t show the pros and cons of each platform, nor does it pick a “winner” that can handle this use case perfectly. Every team and project manager has their own unique use case and “[jobs to be done](https://jtbd.info/2-what-is-jobs-to-be-done-jtbd-796b82081cca).” My goal is to show how you can build and model the this list of requirements for your project’s tasks on each platform:

1. Task dependencies
2. Task end dates that factor in task durations
3. Task start dates that factor in the task’s dependent’s _finish_ date (Finish-to-Start)
4. Automatic cascading of task dates when “kickoff” task date changes
5. Gantt chart and other visualization of tasks and dependencies

The way I found the different platforms and SaaS tools mentioned in this post was from simply Googling things like `task dependencies software` and `best project management software task dependencies` and seeing which tools showed up in Google Adwords and on “top 10 “ lists.

_Jump straight to the video tutorial below. Open video in YouTube for timestamps to skip straight to a platform you’re interested in._

{% youtube 9_2u98Or5w0 %}

_Coda template in the tutorial is [_here_](https://coda.io/@atc/task-dependencies-with-durations)_.

The above bullet points don’t capture every facet of tasks and dependencies. I think most of the platforms I describe below can handle a majority of these use cases. You’ll have to explore each platform on your own to see if the platform can handle:

1. Your specific use case of task dependencies
2. Additional use cases beyond task dependencies your team may expand to in the future

With that said, let’s start with the granddaddy of them all when you’ve just launched a project and reach for the first tool you have at your disposal: Google Sheets.

## Google Sheets task dependencies

The list of tasks and dependencies in this Google Sheet will be the same list of tasks I try to replicate in every other platform. Copy the [Google Sheet](https://docs.google.com/spreadsheets/d/18vAcu79j6theak2mwwpQUSHyVCPAl8dp3dKnzFEaMR0/edit?usp=sharing) I show in this example if you want to use this for your own team.

![](https://cdn-images-1.medium.com/max/1024/0*VqUO0nRmxS6viWlp)

Coming from an Excel/Google Sheets background, I found this task management template pretty easy to set up. With some clever uses of data validation, formulas, and conditional formatting, you can get close to how other dedicated project management platforms handle task dependencies and visualization.

### Task dependencies

The `Dependency` column contains cells with the same [data validation rules](https://support.google.com/docs/answer/186103?co=GENIE.Platform%3DDesktop&hl=en) (dropdown list). The list of tasks you can choose is simply all of column A (your list of tasks). Here is what the settings look like for the data validation rules for each cell in column B:

![](https://cdn-images-1.medium.com/max/1024/0*-_l8NMJas7QWhJz1)

Columns C, D, and E are just other attributes related to a `Task Name`. `Task End Date` just takes the `Task Start Date` and adds the values in the `Duration (Days)` column. It may not seem like a difficult formula, but you’d be surprised as to how difficult it is to get a proper date format _after_ you’ve added a number (duration of task) to a date (task start date). You’ll see this crop up in the other platforms that don’t handle date and number format types well.

### Dependency start and end dates

`Dep Start Date` and `Dep End Date` are `VLOOKUP` formulas that search the same table and return back columns 6 and 7, respectively:

![](https://cdn-images-1.medium.com/max/1024/0*ITYDvdWkf06HD5Id)

Note how the lookup _value_ is column B (each task’s dependency).

### Finish-to-Start task start dates

To get each task’s `Task Start Date` to _start_ when its dependent task _finishes_, we simply set the `Task Start Date` column equal to the `Dep End Date` column. This could lead to a recursive situation if you accidentally select a `Dependency` that is the same as the `Task Name`:

![](https://cdn-images-1.medium.com/max/1024/0*Hl5MjUOmZZH7bXih)

### Cascading dates based on “kickoff” task start date

The “Instructor Shoot” task does not have any dependencies, and thus is our “kickoff” task. The `Task Start Date` for this task does not equal the `Dep End Date` column and is hard-coded. Therefore, when you edit that cell’s date, every other date will re-calculate or “cascade” down to reflect each task’s new start and end dates:

![](https://cdn-images-1.medium.com/max/1024/0*7bqDK89oSfALbI04)

Like I said before, this is already a lot of great task dependency functionality with just a few formulas.

### Gantt or timeline visualization of tasks

While a table view is great if you want to get specific dates for a task, visualizing these tasks on a gantt chart or some other visualization would be helpful. In order to build a simple visualization in Google Sheets, I put a number at the top representing each day of the month. You then write a formula in each cell below these numbers to see if that given task’s start and end dates _day of the month_ falls within that range of numbers. If it does, then you just put an “x” in that cell. Here’s what that looks like:

![](https://cdn-images-1.medium.com/max/927/0*figOaES0lr0jLZc3)

You then copy this formula for all the cells (from columns K and beyond). Then you can apply some basic conditional formatting so that you can see each of the “x” more clearly. This results in a hacky gantt or timeline visualization of all your tasks. As you change the kickoff task start date for the “Instructor Shoot” task, you’ll see the hacky gantt chart shift as well:

![](https://cdn-images-1.medium.com/max/1024/0*S5w3O4-gDuJgwBKS)

## ClickUp task dependencies

The List view in ClickUp looks similar to the Google Sheet (as in other platforms). You can sort by each column and there’s a very clear `Status` column for you to mark if the task is _Open_ or _Closed_. This may be helpful when you want to hide all the closed tasks.

![](https://cdn-images-1.medium.com/max/1024/0*mLv_WWzHHjZdg_pm)

### Task dependencies

In order to define each task’s dependency, you click on the 3 dots in the last “column” of the list and click on “Dependencies.” From there, you click on “Add waiting on task” to define which task this current task is “waiting for.”

![](https://cdn-images-1.medium.com/max/1024/0*erbMITVJ0cOccUai)

The pop-up that shows the various aspects of the dependency shows some useful information regarding that task. For instance, the “Instructor Shoot” task is _blocking_ three other tasks (this task is the predecessor or dependency for three other tasks).

![](https://cdn-images-1.medium.com/max/739/0*Qc_kLYY1Qa2LS-hK)

This pop-up is helpful because it’s color-coded and gives you a chance to audit your task list to see which task may be blocking the most number of tasks. Of course, you’d have to manually go through each task to see which tasks that current tasks blocks. One could argue that the Gantt view lets you see this more easily (see more below).

I found this YouTube video pretty helpful in terms of explaining the importance of task dependencies overall rather than explaining how to use ClickUp itself:

{% youtube PlY8zXaBG2Y %}

One final note about task dependencies in ClickUp is that a warning pops up if you try to close a task that is still “waiting” on other tasks. You don’t want to close something before its dependencies are done, so there’s a [ClickApp](https://docs.clickup.com/en/articles/2284789-reschedule-dependencies-clickapp) where you can toggle this feature on. It’s a nice warning to have for when you accidentally close a task you shouldn’t have:

![](https://cdn-images-1.medium.com/max/401/1*Qv7uA9QbsIbmkxcLgyw0lw.png)

### Calculating task end dates and durations

As far as I can tell, you need to manually select each task’s start date. This means you won’t get that cascading feature we saw with Google Sheets. I tried creating a Formula column to calculate a task’s end date based on the tasks’ _start date_ and its _duration_ (in days), and the formula editor is pretty basic:

![](https://cdn-images-1.medium.com/max/526/0*3DhPlBZy0tbq1_MS)

You can switch to the “Advanced Editor,” and start selecting other columns to create a more custom formula. My hunch for why this formula doesn’t work is because the `Duration` column is a _number_ column format and you’re trying to add this to a Date column format.

![](https://cdn-images-1.medium.com/max/624/0*CLvjZ6Vw9IXuHNI0)

Here’s the first instance where we see column formats getting in the way of writing a formula, which Google Sheets handles pretty seamlessly.

### Gantt visualization

I’ve found that most project management platforms have pretty robust visualizations of your tasks and dependencies. They just work right out of the box. In ClickUp, arrows show which tasks are dependencies of other tasks with these arrows (which you can drag-and-drop):

![](https://cdn-images-1.medium.com/max/1024/1*a-ZXZWU4nFcdCXhLMMmf3Q.gif)

For more complex projects, you can also toggle “Critical Path” and “Show Slack Time” to see this laid out on the gantt chart:

![](https://cdn-images-1.medium.com/max/888/0*2ki4mpx3MhaiaRiX)

## Monday.com task dependencies

_My free trial of Monday expired before I could take screenshots_ 😃_, so watch the video starting around 13:15 to see the walkthrough:_

{% youtube 9_2u98Or5w0 %}

### Task dependencies

[This article](https://support.monday.com/hc/en-us/articles/360007402599-How-to-set-dependencies-on-monday-com-) gets you pretty far with setting up task dependencies.

I was able to get pretty close to replicating the functionality of Google Sheets, but ran into similar issues as ClickUp in terms of being able to calculate task end dates and task dependency end dates. My guess is that it also has something to do with the date formats mixing in with various other column formats in the Table view in Monday. The reason is I had to start using a [Link to Item](https://support.monday.com/hc/en-us/articles/360000635139-The-Link-to-Item-Column) column type with the [Mirror](https://support.monday.com/hc/en-us/articles/360001733859-The-Mirror-Column) column type to “project out” the dependency’s start and end dates. Now you’re mixing dates, numbers, Link to Item, and Mirror column types which didn’t work out so well for the formula I was trying to build

As far as I can tell, you still need to set each task’s start date manually in order to get a calendar and gantt chart view that is useful for your team to look at. A nice error check (similar to the warning message when you close a dependency in ClickUp) is an Automation rule that prevents from you from setting a task start date _before_ that task’s dependency is done. This type of error check doesn’t need to exist in the Google Sheet because all the task start dates are formulaic and are dependent on each task’s predecessor.

## Wrike task dependencies

The table view in Wrike looks similar to ClickUp and Monday, but is starting to feel a little more spreadsheet-y. I didn’t include all the columns from the Google Sheet for simplicity’s sake. I easily copied and pasted from the Google Sheet into the table view in Wrike to build a similar looking table as Google Sheets. You’ll notice the different “tabs” at the top to quickly switch to a different view of your task list:

![](https://cdn-images-1.medium.com/max/1024/0*CQbqjoGGuucD6HZx)

### Task dependencies

Unlike Google Sheets, ClickUp, and Monday, Wrike takes a more traditional project management approach to defining a task’s dependency or predecessor. You’ll notice in the `Predecessors` column there are numbers and text like “2FS’ and “4F.” The number represents the _row_ of the dependency and the “FS” is “Finish-to-Start” [dependency type](https://en.wikipedia.org/wiki/Dependency_(project_management)).

You actually can’t edit the `Predecessors` column in the table view, only in the Gantt Chart view here:

![](https://cdn-images-1.medium.com/max/1024/0*mVwRYFMdwT_kaPKG)

Similar to ClickUp, you can drag-and-drop the bars in the Gantt chart view to change the dates of a given task and draw arrows to other tasks to create new dependencies:

![](https://cdn-images-1.medium.com/max/1024/0*Ob6GIOSRxciYCDTG)

### Cascading dates based on “kickoff” task

While you can pinpoint the dependency with the row number for each task and whether it’s a “FS” or “SF” dependency type, I don’t believe the start dates and durations cascade “down” similar to the functionality I built in Google Sheets. Based on this [help article](https://help.wrike.com/hc/en-us/articles/209604229-Dependencies-on-the-Gantt-Chart-), it appears the only way to do this is to hold the SHIFT key to move an entire “dependency chain” forward or backward in time. I think having a WYSIWIG editor on the Gantt chart view to achieve this same functionality would be a nice to have.

I was able to create this `Calc Due Date` column which simply takes the task’s `Start Date` and adds the `Duration` to it. The `Calc Due Date` column is a custom field that is a _Formula _type:

![](https://cdn-images-1.medium.com/max/396/0*euMS3y0PLDjz71Sy)

## Smartsheet task dependencies

Smartsheet is one of the more well known dedicated project management platforms out there. Their software looks and feels more like a spreadsheet than the other previous platforms (the “sheet” in their name might have been an indication). The grid view looks just like a spreadsheet with some “sticky” columns to the left for attachments, comments, and other attributes for a given task.

![](https://cdn-images-1.medium.com/max/1024/0*miOOwmAB_O9bbXkZ)

### Task dependencies

To incorporate dependencies for each task, you have to go to the Project Settings and explicitly enable Dependencies. Through these settings, it’s clear that Smartsheet has iterated over the years to provide users with a defined set of options when it comes to setting dependencies.

This has its tradeoffs. On one hand, you have this very powerful piece of software that does task dependencies really well and you know that they have thought about all the edge cases related to dependencies and due dates. On the other hand, you lose some flexibility (that you get with a Google Sheet) in terms of defining your own dependency “rules” and “project settings.” This decision to go with an opinionated piece of software like Smartsheet versus building something yourself goes beyond project management and task dependencies.

Ok rant over 😃. Let’s get back to Smartsheet. Once you’ve enabled dependencies, you need to select the column for your `Predecessor` as well as the column for `Duration`. I already have a column for `Duration` (which came from the Google Sheet) and I created a column called `Dependency`. This [help article](https://help.smartsheet.com/articles/765727-enabling-dependencies-using-predecessors#toc-work-with-duration-and-predecessors) also walks you through how to work with dependencies in Smartsheet in detail.

![](https://cdn-images-1.medium.com/max/948/0*cnBnjQm03yBGrnG4)

Similar to Wrike, you put the row number in the `Dependency` column for the task that is the dependency for that current ask. To get more specific with each dependency, you can click on the pencil icon to open up more settings for that dependency. Here is where you can define a more specific dependency type (e.g. SF, FF, SS):

![](https://cdn-images-1.medium.com/max/1024/0*qPT82jUnYCZ4EDO8)

### Cascading dates based on “kickoff” date

Unlike Google Sheets (or any of the other dedicated project management platforms so far), I didn’t have to create separate columns for a dependency’s start date or end date. Smartsheet automatically re-calculates the `Task Start Date` and `Task End Date` based on the date you select for your “kickoff” task (in this case “Instructor Shoot”). This is a nice built-in feature that removes the need for you to do a `VLOOKUP` in Google Sheets or struggle with creating a custom formula in ClickUp, Monday, or Wrike:

![](https://cdn-images-1.medium.com/max/1024/0*c8XYHbOP-dpOhPxW)

You also get an error message if you try to change the `Task Start Date` for any task that has a dependency. We see similar error checks in ClickUp and Wrike:

![](https://cdn-images-1.medium.com/max/948/0*_y1jMx4B_0BLbgQk)

### Gantt chart visualization

The gantt chart view is pretty similar to the other project management platforms. You can’t adjust the task start date (left side of the bar in the gantt chart) because you’ll run into the same error as beforeーmessing with a task’s start date means it will break the “chain” of dependencies/predecessors. The view doesn’t look that far off from the hacked up chart I was able to build in Google Sheets:

![](https://cdn-images-1.medium.com/max/1024/0*_QZnKlddQ1JQeHv_)

## Notion task dependencies

Tables in Notion act similar to the list/table views in ClickUp, Monday, Wrike, and Smartsheet in that the columns have specific types. This will lead to issues down the line because I try to mix column types in the formulas I write. Aside from this limitation, the table looks and feels like a spreadsheet and I was able to easily copy and paste into the table from Google Sheets:

![](https://cdn-images-1.medium.com/max/1024/0*JUIvwjQVXAmiLC1A)

### Task dependencies

The `Dependency` column is a [relation](https://www.notion.so/Relations-rollups-fd56bfc6a3f0471a9f0cc3110ff19a79) column type in Notion. This column type lets you “lookup” to other tables in your workspace, but you can also lookup to the same table. This is pretty similar to the data validation in Google Sheets. I can now select any task from the first column as the `Dependency` in the second column.

![](https://cdn-images-1.medium.com/max/1024/0*dAjij1WolqpTnBz9)

### Task and dependency start and end dates

Notion also has a formula language and I was able to create a `Task End Date` similar to what we have in Google Sheets. It’s simply `Task Start Date` plus the `Duration`. You can use the `dateAdd` function in Notion to make this work:

![](https://cdn-images-1.medium.com/max/902/0*XYqgkGDUf4fW0z4q)

In the Google Sheet, the `Task Start Date` needs to be built off of the `Dep End Date` column in order to get the “cascading” date effect when you select the date for the “kickoff” task. I started building out the `Dep Start Date` and `Dep End Date` columns by using a [Rollup](https://www.notion.so/Relations-rollups-fd56bfc6a3f0471a9f0cc3110ff19a79) column type. This allows you to “project” the task start and end dates for a given dependency:

![](https://cdn-images-1.medium.com/max/396/0*-PzyQ_aUNcWmqnGr)

With the `Dep Start Date` and `Dep End Date`, we’re getting close to mimicking the Google Sheets structure. Then came the issue of trying to build the formula for the `Task Start Date`. In the screenshot below, you’ll notice that there’s a “Type mismatch” error which leads me to believe that the Rollup column type in the `Dep End Date` column is messing up the formula:

![](https://cdn-images-1.medium.com/max/985/0*h4JNsRP1n4TTiYVp)

This formula looks to see if there is anything in the `Dependency` column. If that column is blank (which is the case for the “Instructor Shoot” task), then it just shows the value in `Task Start Date`. This is the date we want to use to “cascade” the dates down the table. If the `Task End Date` column was a date format type, I think this formula would work since that column affects the `Dep End Date` column. I tried looking at a few articles discussing date functions [here](https://www.reddit.com/r/Notion/comments/bx4zoz/date_property_formulas/), [here](https://www.reddit.com/r/Notion/comments/bxbvs2/date_formatting_for_formulas/), and [here](https://www.reddit.com/r/Notion/comments/gnmoyx/text_to_date_function_such_as_todate/), but couldn’t figure out a solution. If you find one, let me know!

After writing into support, I found out the `Task Start Date` formula I’m trying to write could potentially lead to a recursive loop situation, and that Notion formulas don’t currently support this type of use case. Similar to ClickUp, Monday, and Wrike, it looks like you have to manually enter in each task’s start date to build a proper view of your project. This YouTube video below also shows how to build dependencies which resembles the “waiting” and “blocking” concept in ClickUp:

{% youtube wfeGmBKh9xk %}

### Calendar visualization

I believe there is a gantt charts are still on Notion’s roadmap, so the only native view that would make sense for this project is the Calendar view. You can easily switch to this view by clicking the dropdown near the top-left of the table:

![](https://cdn-images-1.medium.com/max/1024/0*BaWrCC2X_6J_5SBd)

## Coda task dependencies

_Disclosure: I work at Coda._

Tables in Coda are similar to the “list” view in ClickUp, Monday, Smartsheet, and Wrike in that columns have specific format types. If you accidentally put a number in a text column, however, it’s not the end of the world and Coda won’t give you an error message. Formulas in Coda tables also get applied to the entire column (not just that specific row like in Google Sheets). You can see the actual template in [Task dependencies template](https://coda.io/d/How-to-build-tasks-dependencies-with-durations-in-Google-Sheets-_dMKabuC-9fk/Task-dependencies-template_suMK4) or follow the screenshots below.

![](https://cdn-images-1.medium.com/max/1024/0*kusBc5hCsT4Pjwcy)

### Task dependencies

Similar to Notion’s Relation column type, Coda has a [Lookup column type](https://help.coda.io/en/articles/1385997-using-lookups) that lets you “lookup” to another table in your doc or to the current table the column is in. In this case, the `Dependency` column is a lookup column to the “All Tasks” table:

![](https://cdn-images-1.medium.com/max/894/0*dT-Sg-BLcYHQRbPM)

Now I can select any task in the `Task Name` column as the dependent task in the `Dependency` column. Also similar to Notion, hovering over each value in the dropdown actually lets you see all the data related to that specific task:

![](https://cdn-images-1.medium.com/max/880/0*Kv1_yyoAdu_eERM4)

### Task/dependency start and end dates

In some of the project management platforms described above, writing formulas led to errors due to inconsistencies with column types. Notably, being able to add a number (from our `Duration (Days)` column) to a task’s start date is problematic since you are mixing date and number formats. Smartsheet handles this well given that it has strict rules around dependencies and task durations. Notion also is able to handle this scenario with their `dateAdd` function.

In Coda, the `Duration` column in our table is actually a custom duration column type. This means if you enter the number “3” in this column, the column will automatically convert that number to “3 days.” Therefore, adding `Task Start Date` with `Duration` yields another date as shown in the formula below:

![](https://cdn-images-1.medium.com/max/639/1*ZvjQuHRa1GzpCFYz6jaz9w.png)

If you recall in the Google Sheet, were able to add the task’s start date with a number and Google Sheets automatically converts the number to the “number of days” that task is supposed to take. No issues with mixing and matching column formats. Since Coda formulas apply to the entire column, you can use the name of the column in the formula instead of a specific cell reference (e.g. “D5”).

To get the dependency’s start date and end date like we have in the Google Sheets, we can simply reference the `Dependency` column and “project out” it’s start and end dates like so:

![](https://cdn-images-1.medium.com/max/1024/0*ZBktBeF9uSWPeT48)

The `Dependency` column contains the entire “row” of a given task in the first column of our table, so each column in this table is bound to whatever task you select in the `Dependency` column. This is similar to the Google Sheet where we do a `VLOOKUP` onto the same table to find the dependency task’s start and end dates. One could argue that the Coda formula is a bit easier to read since you don’t need to input a bunch of values or references into the formula

### Cascading dates with a “kickoff” date

Coda accounts for potential recursive situations, so you’re able to create this “cascading” list of dates similar to the functionality we have in the Google Sheet. In this case, I give the user the ability to input their own start date for the “kickoff” task (”Instructor Shoot”) as a date picker right above the table:

![](https://cdn-images-1.medium.com/max/794/1*L94YK03y3VUf2g8sS_z8ng.png)

This date picker is a [control](https://help.coda.io/en/articles/1223567-overview-of-controls) which you can assign a name to (similar to defined named ranges in Google Sheets). I named this date picker `firstTaskDate` which we’ll use in a formula in our table.

When I select new dates in the `firstTaskDate` date picker, you’ll see all the task and dependency dates automatically re-adjust based on the start date of the “Instructor Shoot” task. This is similar to adjusting the first hard-coded start date in Google Sheets, moving the “dependency chain” in Wrike, and shifting the gantt chart in Smartsheet:

![](https://cdn-images-1.medium.com/max/1024/0*ruet2yJJNg1PE6lG)

This all works because of the formula in the `Task Start Date` column. This is a formula I was not able to replicate in other dedicated project management software due to a mismatch in column format types and the potential for a recursive formula. The formula is an `IF` statement that checks to see if the `Dependency` column is blank. If it is, then it uses the `firstTaskDate` date picker value right above the table as the date for the “kickoff task.” Otherwise, it just takes the value in the `Dep End Date` column. We are modeling a simple Finish-to-Start scenario but we could easily write a more custom formula to account for SF, SS, and FF dependency types.

![](https://cdn-images-1.medium.com/max/1024/0*U-EOBh6hTQL0N7Qb)

The formula in Google Sheets is easier because we can simply reference the `Dep End Date` column without having to write an IF statement. But this comes at the cost of giving the user a clean user input to pick the date for the “kickoff” task. In Coda, it’s a date picker that goes right above the table with some helper text before it. In Google Sheets, you would have to format the hard-coded cell and perhaps put in a note for the user to know that this is the specific cell that the user needs to edit:

![](https://cdn-images-1.medium.com/max/885/0*-AUJuVlQhvBRrvQx)

### Gantt and calendar visualizations

Similar to other platforms, you can visualize a list of tasks and dependencies in different ways that make sense for how your team operates. The gantt chart view is not as robust and feature rich as ClickUp, Monday, Wrike, and Smartsheet. You cannot draw arrows from one task to another nor can you adjust task lengths by simply dragging and dropping the right and left boundaries of a bar on the chart. The reason for this is because each task’s start and end dates are fixed via formulas, so the tradeoff here is being able to have the “cascading” ability of dates (like you have in Coda and Google Sheets) versus the flexibility of editing each task’s dates one-by-one (as you have in ClickUp, Monday, and Wrike):

![](https://cdn-images-1.medium.com/max/1024/0*zbnNf9FgZxDWYNH0)

It’s a pretty bare bones gantt chart, but similar to other platforms you can hover over each bar and see all the data related to that specific task. When you adjust the date of the “kickoff” task, you’ll see the gantt chart automatically adjust because all these views are tied to each other.

The calendar view is pretty similar to all the other tools and similar to the gantt chart, is connect to your main table of tasks and dependencies:

![](https://cdn-images-1.medium.com/max/1024/0*9kBEIhFHr1LwlLLn)

## Conclusion

There are many other SaaS tools, platforms, and project management software I did not cover in this tutorial. Notably, Microsoft Project is something that came up during my research that I know many project management professionals have used for years to manage tasks and dependencies.

As I stated the top of this post, there is no “winner” that you can walk away with from this tutorial. Unlike other “top project management software” blog posts where you get a cursory view of each software’s pros and cons, this post explores the idiosyncrasies of task dependencies which may not even be relevant to your project. If you’re in the process of researching software and you need the software to accomplish a _very specific task_ for your team, you’ll unfortunately have to dig deep into the software to see if it does what you want it to do. Entire teams at large companies are dedicated to vetting these feature sets because once you’ve selected the software, the switching costs can be very high.

If you’ve read this far, hopefully I’ve helped you comprehend a nuance about each platform in relation to task dependencies. You’ll have to do additional testing on each platform to figure out if the platform is able to accomplish some other specific task related to how your team operates and the requirements of your project.

* * *