Santa Claus, Project Manager

Seasoned project managers know all about the various ways project tasks can depend on each other. Finish-to-start, start-to-start, and so on. But do we really need all these different dependency types? Turns out it really depends on your PM tools. With Gigantt, for example, you don't.


But first let's recap on the different types of dependencies. Wikipedia actually does a pretty good job at it. Here's a shorter version. Also this version uses Santa Claus and is thus inherently better.

Finish-To-Start

Example: Santa can't deliver toys before his elves make them.

Start-To-Start

Example: Santa can't start performing quality inspection on toys before his elves start making them.

Finish-To-Finish

Same example: Santa can't finish inspecting toys before his elves finish making them.

Start-To-Finish

Example: A senior elf wants to retire, but first he has to spend some time training a new elf in his place. The new elf's training may go on after the senior elf retires, but there has to be some period of overlap.

This last example (F2S) also introduces a new variable into the mix - the amount of time those tasks must overlap. e.g. we could say that a retiring elf must train his replacement for at least a week.


Aside, then, from the purely logical connection between tasks, we can also talk about how they relate to each other over time. The terms used in such cases are normally lead and lag.

Lag & Lead

Santa has to rest for a week after delivering toys before he can start working on next year's toys.

The time between tasks is called a lag. A lead, on the other hand, refers to the period of time when tasks overlap. You can sometimes think of it as a negative lag. 


Example: Santa can start inspecting toys after the elves start making them. However, Santa first has to let the elves actually finish making at least a few toys before there are any toys to inspect, right? So we can define a one day lead between the time they start making their toys and the time he starts inspecting them.

Real easy to get a headache from all this stuff... Why can't we just have one simple type of dependency to rule them all?

The Gigantt Way

When Gigantt draws arrows between tasks it always means one thing - a classic Finish-to-Start connection. Most of the time that's enough. 

Then of course you can put tasks inside other tasks, which is basically a S2S or F2F dependency, although an implicit one. If a task contains other tasks then they can only start once their container starts, and their container can only finish once they're finished.

These are simple, intuitive dependencies and we find that they'll do the job most of the time. But every now and then we get questions, usually from experienced project managers, who miss all those other fancy dependencies and their lags and leads and what have you.


Could Gigantt still be useful if it doesn't let you define a negative lag in a finish-to-finish dependency? The answer is almost always "break up your tasks to smaller ones and you won't need anything more". In fact, if you do it this way you'll have a better plan, plus you won't need to bother with complicated dependency types. 


Let's see some example.

Case study: Negative lag in a Finish-To-Finish Dependency

A user asked us how he could model the following work-plan in Gigantt. His project has a long design stage before development can start. However, two months before the design is finished something else needs to start - provisioning (buying equipment). He wanted something that looks like this:

We asked him to explain why exactly provisioning can start two months before design finishes. He then explained that at a certain point during the design, once "preliminary design" is finished, the team already knows what sort of equipment they're going to need, and so they can provision it. At that point the solution was clear: break the big-old design task into smaller pieces. 

Not only is the plan now simpler, it's also safer. Why safer? Because that two-month lag was really just an implicit estimate. What if preliminary design took more than 50% of the total design time? What if it took 75%? A plan that relies on some fixed two-month lag would have been out-dated. But once we break it down to smaller parts we could easily see that provisioning is going to be delayed.


Let's see how some of the Santa examples above work out with simple F2S dependencies.

Start-to-Start:

You'll recall that a few toys need to be made before inspection can start. Alright, then let's break it down a bit. We'll split the first batch of toys into its own task and let inspection start after this new task finishes.

Bam! No more S2S with a lead. We can also track how much time the first batch took and use it to adjust our estimates.

Start-to-Finish:

Arguably the weirdest dependency of them all. So let's take the training period example we used earlier. Why should there be a week's overlap? Probably because there's some basic training without which the new elf can't start working, and this is estimated at a week's time. Great, let's model it.

Conclusion

It is our experience that almost all of the time when people say they need various types of dependencies it's for prolonged tasks. Tasks that take weeks or months. Gigantt's power is in enabling you to dive in, break tasks down and uncover hidden work and risks. Once your work chunks are much smaller there really isn't much you cannot model with simple Finish-to-Start dependencies and with tasks containing other tasks.


We're not saying these features are never needed. In some cases they are. But they're always a bit harder to grasp and they complicate your PM tools needlessly. If you can think of real-world examples please share them here. We welcome the discussion. But for the time being we're going to keep Gigantt simple and stick with plain old Finish-to-Start.