Creating Gantt Charts
Gantt charts are widely used in business to describe and monitor all kinds of projects according to the rules of project management. In today's world they are usually created by computer applications, such as Microsoft® Project, Primavera Project Planner® and MindView. Here, we refer to such applications as Gantt applications. Different Gantt applications have different features and capabilities: in the discussion below we describe some of the more common ones.
The first thing you will need before setting up a Gantt chart is a detailed project plan. A project plan is a series of interdependent tasks that need to be performed in a particular order. When moving into a new office for instance, you cannot start redesigning the office space before the lease agreement has been signed.
Project plans have a specific start date, corresponding to the start of the first task (for instance defining the requirements for the new office), and a specific end date, corresponding to the end of the last task (for instance moving in).
One way to create a project plan is to use a work breakdown structure, a technique for splitting tasks into sub-tasks and creating a task hierarchy. Gantt applications will generally allow you to reflect the project hierarchy in the Gantt's task list at the left of the chart.
Mind mapping software, which encourages creative thinking, will help you to develop a work breakdown structure and ensure that nothing is omitted from the overall project plan. If the mind mapping software incorporates Gantt charting (i.e. MindView), it will allow you to enter data as you develop the plan, saving time later. Make sure your plan is as complete as possible and its assumptions are realistic.
Once the project plan is complete, enter the data into the Gantt application that will create the chart:
How to Create a Gantt Chart
- Define the project settings, such as its start date, end date and scheduling mode. The most common scheduling mode is forwards from the project start date. In this mode the default is for tasks to start as soon as possible, which means that the whole project finishes at the earliest possible date.
- Define the project calendar. This sets the number of working days in the week, the number of working hours in the day, and so on.
- Enter or edit task names and durations.
- Set up a global resources list and assign resources to tasks. Although you can often define the resources as you need them, it is usually quicker to start by setting up a global resources list from which you can then select resources to assign to the various project tasks. See Including resources in a Gantt chart.
- Create links to specify the dependencies between the project tasks. See Linking tasks in a Gantt chart.
- Set constraints on the tasks as necessary. See Adding constraints to a Gantt chart.
- Make final adjustments to the project plan. See Enhancing a Gantt chart.
- Once the project has actually started, inspect it at regular intervals to detect potential problems or scheduling conflicts and make any corrections required. See Reviewing a project using a Gantt chart.
Note: If you used mind mapping software that incorporates Gantt chart creation during the planning stage, much of this data will already be in place.
With all the data entered, the Gantt application displays the chart. Any change in the timing of a task affects all the tasks that depend on it. If a task runs ahead of schedule, the Gantt application automatically recalculates the dates of all the tasks that depend on it in order to take advantage of the time gained. Conversely, if a task is delayed, all the tasks that depend on it are automatically rescheduled, which may or may not impact the overall end date of the project.
By using the Gantt display you can build and manage complete project plans in this standard, well-defined format. You can easily add or remove tasks, set or adjust the duration of tasks (length of bars), link tasks (for example to make one task follow immediately after another), and add constraints (for example to specify that a task must end no later than a given date).
To help you get started, some Gantt applications include various ready-made project plans for common business activities (for example, organizing a tradeshow, producing a publication, launching a product). You can use these for training purposes, or as a basis for your own project plans.
Linking Tasks in a Gantt chart
Project plans normally require tasks to be performed in a specific order. For instance, a publication must be written and proofread before it can be printed. To achieve this, the Gantt application lets you link tasks so that they depend on each other.
By default, tasks are usually linked in a 'Finish to Start' relationship (dependency), which means that the first task you select (the predecessor task) must end before the next task you select (the successor task) can start, and so on.
This is typically represented on the Gantt chart by lines with arrowheads joining each task to its successor. The arrowhead indicates the direction of the link: it goes from the predecessor to the successor.
A task can have more than one predecessor. In this case its start date is determined by the predecessor link that gives it the latest start date. As dates and times change during the course of the project, the predecessor link that determines the start date of the task may also change.
Gantt chart multiple predecessors
Similarly a task can have several successors. In this case the task determines the start date of all its successor tasks.
When you are scheduling a project plan from its start date the Gantt application calculates the end date of the project automatically, on the basis of the task durations, the task dependencies and the project calendar.
The possibility of linking tasks in this way is what makes project management software particularly powerful: you can change the duration of one or more tasks, add a task or remove a task from a chain of linked tasks, and all the dates are recalculated automatically so as to maintain the task dependencies you have defined.
Other Link Types
There are four possible relationships (dependencies) between tasks:
- Finish to Start (FS) - the default: The task cannot start before its predecessor ends, although it may start later. This is the most common type of relationship, and is described above.
- Start to Start (SS): The task cannot start until the predecessor starts, although it may start later. This can be useful if you have a task whose start date depends on the start date of another task.
- Finish to Finish (FF): The task cannot end before the predecessor ends, although it may end later.
- Start to Finish (SF): The task cannot end before the predecessor starts, although it may end later. This task relationship is rarely used.
The following project plan for the preparation of a publication illustrates all these kinds of relationships.
In this example:
- The writing task follows on directly from the planning task. If the end date of planning changes, so will the start of writing. This is the normal Finish to Start relationship.
- The editing task starts some way through the writing task. The writers and the editors work together as a team until the text is complete. Their tasks effectively end at the same time. If the end date of writing changes, so will the end date of editing. This is a Finish to Finish relationship.
- The creation of artwork depends on the start of writing. In this case a lag has been introduced so that it doesn't start exactly when writing starts. Even so, if the start of writing changes, so will the start of artwork creation. This is a Start to Start relationship.
- The final changes task depends on the end of artwork creation, but an overlap is included so that it actually begins two working days before the end date of artwork creation. If artwork creation is delayed, so will be the start of final changes. This is the normal Finish to Start relationship.
- Printing starts after final changes are complete. This is also a Finish to Start relationship.
- The transferring of paper from the warehouse to the printers must be complete in order for printing to start, but is not related to any of the preceding tasks. The printers have limited storage capacity and do not want the paper to arrive until it is needed ('just in time' or JIT scheduling), so the start of printing drives the delivery of paper. If the start of printing changes for some reason, so will the end date for getting paper to the printers. This is a Start to Finish relationship.
Here each task has a single predecessor, the simplest arrangement. However, a task can have several predecessors. In such situations you will need to think carefully about possible undesirable consequences. For example, if you added another predecessor to the "Paper to printers" task above, it would be possible for that predecessor to push out "Paper to printers" so that its end date was later than the start of printing.
Using Lag and Lead Times in a Gantt Chart
When linking tasks you can add a lead or lag time to extend a link backwards or forwards so that the successor task starts earlier or later than it otherwise would. For a default 'Finish to Start' link, this either introduces an overlap (lead time), so that the successor task starts before its predecessor ends, or it introduces a delay (lag time) that makes the successor task start some time after its predecessor ends.
When planning the production of a marketing brochure for instance, you could use lead time to make the creation of artwork start a few days before the writing phase is over. The two tasks are however still linked, which means that a delay of the writing phase will also delay the creation of the artwork.
Adding Constraints to a Gantt Chart
Constraints define the degree of flexibility available to the Gantt application when scheduling or rescheduling a task by imposing restrictions on its start or end date. The following task constraint types offer different degrees of flexibility.
Two "constraints" are actually so flexible that they are not generally regarded as constraints at all:
- As Soon As Possible (ASAP): This is generally the default constraint when you schedule your project from its start date, as is normally the case. You should try to keep this default whenever possible as it gives the software the most scheduling flexibility. If you apply this constraint to an unlinked task, the task will be scheduled to start at the project start date. If you apply it to a linked task, it will start as soon as the dependencies with its predecessor tasks will allow.
- As Late As Possible (ALAP): This is generally the default constraint when you schedule your project from its end date. If you apply this constraint to an unlinked task, the task will be scheduled so that its end date coincides with the end date of the overall project. If you apply it to a task linked to a successor task, the task will be scheduled to end when the successor needs to start. On the whole, you should avoid this constraint as it does not leave any slack time to deal with possible problems. Any delay on the task is likely to impact the overall end date.
The following constraints all restrict the Gantt application's flexibility when scheduling tasks. Although you might be tempted to use them if you are new to project management, you need to make sure you understand the implications. Keeping their use to a minimum (especially the last two) will allow you to take full advantage of the automatic scheduling possibilities.
- Start No Earlier Than (SNET): This means that the task, whether linked or not, may not start before the given date. However, the Gantt application still has the flexibility to start the task later than the given date.
- Start No Later Than (SNLT): This means that the task, whether linked or not, may not start later than the given date. However, the Gantt application still has the flexibility to start the task earlier than the given date.
- Finish No Earlier Than (FNET): This means that the task, whether linked or not, may not end before the given date. However, the Gantt application still has the flexibility to end the task later than the given date.
- Finish No Later Than (FNLT): This means that the task, whether linked or not, may not end later than the given date. However, the Gantt application still has the flexibility to end the task earlier than the given date.
- Must Start On (MSO): This rigid constraint means that the task, whether linked or not, must start on the given date. Even if the preceding task is completed earlier, the Gantt application cannot pull in the constrained task to take advantage of the time gained.
- Must Finish On (MFO): This rigid constraint means that the task, whether linked or not, must end on the given date. As above, even if the preceding task is completed earlier, the Gantt application cannot pull in the constrained task to take advantage of the time gained.
If you decide to apply one of these constraints to a task, it is good practice to attach a note or a comment to the task to explain why you did so. If the constraint causes scheduling conflicts later on as your project evolves, you will be able to refer to the note to decide whether to keep the constraint, change it or remove it altogether.
Such notes also allow you to distinguish easily between the tasks you have constrained yourself deliberately and the tasks you may have constrained inadvertently by moving their task bar or editing their start or end date manually.
The effect of a constraint is not always obvious when you schedule your project plan from its end date, so take care to check that it does give the result you want.
The following example shows some tasks in the preparation of a brochure for a mail shot. The mail shot is scheduled for September 10th. The tasks are linked, but we have set a 'Must Finish On' constraint on the printing task for September 7th, the latest date that will allow the mailing to go ahead on the following Monday, September 10th.
The constraint, as usual, overrides the link. By setting a 'Must Finish On' constraint for September 7th, we have effectively moved the task out so that it ends exactly on September 7th, regardless of whether it could have been completed earlier or not.
The problem with this is that if the printing task takes longer than expected, the mailing date will be missed. It would be much better to take advantage of the unused time after the end of the corrections task to get started with printing. However, we still need to keep an eye on the September 7th deadline. To do this, we remove the constraint from the printing task, so that the link will determine its start date, and add a deadline marker instead.
Now there is a useful three day gap between the end of printing and the deadline, and the deadline is clearly indicated. The deadline indicator will warn us if the task moves past its deadline.
Interaction between task dependency links and constraints
Constraints combine with task dependency links to affect the timing of tasks. In some cases, applying a constraint to a task, in addition to a task relationship, may create a scheduling conflict. In most Gantt applications, when such a conflict arises the constraint takes precedence over the task dependency.
Let us consider the example below. Here the "Print" task is linked to the "Final changes" task with the default 'Finish to Start' relationship. The "Final changes" task ends on Oct 1st. In normal circumstances, this would mean that the "Print" task cannot start before Oct 2nd.
However, because you imperatively need the printed materials on Sept 28th for a training session, you have set a 'Must Finish On' constraint on the "Print" task for Sept 28th, as evidenced by the constraint indicator. Since the constraint set on a task always overrides any relationship it may have with other tasks, the start date of the "Print" task has been rescheduled automatically to end on Sept 28th.
Gantt chart constraints and dependencies
In this case the constraint has led to an illogical relationship with the predecessor task: printing is now scheduled to start before final changes are complete. In this example, the software flags this as a possible problem using an icon, which shows that a link has been overridden by a constraint.
If you later decide to remove the constraint, for instance because the training session has been postponed, the task dependency link is enforced again, as shown here:
Gantt chart reapply dependencies
Including resources in a Gantt chart
Many Gantt applications allow you to assign resources to your tasks and project plans. Resources can be people, materials, equipment, budget amounts, or anything else. Typically, you might enter the names of people who will work on the tasks as resources.
The Gantt display will indicate the resources that have been assigned to each task. You may also be able to enter additional information, for example:
- Where the resource is a person or a team, the amount of time that the person or team will spend on the task. This is usually designated as a percentage, 100% signifying one person full time. So you would enter 250% for a team of three people where one of the people will be working only 50% of the time.
- Where the resource is a material, the amount needed for the task. For a material such as sand it might be 50 tons.
- The cost of the resource. In the case of a person this could be a dollars per hour figure. For a material such as sand it might be dollars per ton, for electricity dollars per kWh.
- The rate of consumption of a material resource. Some resources have a fixed cost but for others the cost depends on the duration of the task. For example, heating might be estimated in kWh per day.
Some Gantt applications will adjust the length of each Gantt bar (task duration) according to the amount of work the people assigned to the task can provide. Overuse of resources may be flagged, as when a schedule change makes two tasks involving the same team of people overlap.
Enhancing a Gantt Chart
Gantt applications generally include features to make your Gantt chart easier to use. These vary from application to application; here are some examples:
- Adding explanatory notes to tasks. This is especially useful for tasks that have constraints. Constraints override links and can lead to illogicalities or schedule conflicts in the plan, so you will need to keep an eye on them.
- Highlighting the critical path in order to see at a glance the tasks that are currently directly affecting your project end date. In a project plan, the critical path corresponds to the tasks or chain of linked tasks that cannot be delayed without delaying the entire project. A task lies on the critical path if a change to its start date or duration affects the end date of the project (or the start date if you are scheduling from the end of the project). Keeping a close eye on the status of your critical tasks at any time is therefore key to good project management. If the overall project duration is too long, the only way to make it shorter and bring in its end date is to shorten the critical path.
- Setting milestones or deadlines to mark key dates. A milestone is a task with zero duration. It appears on the Gantt chart as milestone symbol. Milestones are generally used to indicate important dates on the project plan, often key events or goals. For example, you might use milestones to mark desired completion dates, or project review meetings.
Gantt chart highlighting critical path
A deadline marker does not affect any of the Gantt calculations, but places a visible marker on the Gantt chart as a reminder. In most Gantt applications an indicator will warn you if a task moves past its deadline marker.
Gantt chart deadlines passing
- Giving tasks priorities.
- Showing a percentage completion for any task, visible on the task bar.
- Customizing the appearance of the project plan on the Gantt chart, for example the color of task bars, the display (or not) of informational labels.
Reviewing a project using a Gantt chart
It's a good idea to review your project plan regularly in order to locate conflicts or other problems. You can then make appropriate changes to remove them.
Here are some questions to ask yourself:
- Is the project on course? View the end date of the last task on the Gantt chart. Check that it looks reasonable.
- Has any task overshot its deadline? If so, you will need to take action: extend or remove the deadline, allow more time for the task or assign more people to it.
- Are all the links between tasks necessary? By unlinking tasks that don't actually depend on each other, you will make use of all the slack time available, thereby shortening your schedule and maximizing its flexibility.
- Consider whether some tasks could overlap each other to reduce the overall duration of the project. If so, assign appropriate lead times (see Using lag and lead times in a Gantt chart). Another possibility is to redefine some of your 'Finish to Start' relationships to either 'Finish to Finish' or 'Start to Start' if the logic of your schedule allows it.
- Are the constraints working as you expect? If you have been adding an explanatory note to every constraint you set, read the notes to check that your intentions are still being met. And look for tasks that have a constraint but no note: these may have been created inadvertently and be causing trouble. Also, because constraints generally override links, they can introduce schedule conflicts.
- Do the tasks that have constraints fall where you expect them to? Do they fit logically with the other tasks around them? Check that their start and end dates are neither too early nor too late.
- Are there unexpected overlaps or gaps between linked tasks? Often this is caused by a rigid constraint on one or other of the tasks. However, remember that overlaps and gaps can also be caused by intentional lead or lag times.