Gantt chart: what it is, how to make one, and how to find the critical path.

A Gantt chart is a horizontal bar chart in which each project task appears as a bar: it starts on the start date, ends on the end date, and is linked to the tasks that depend on it. Looking at it, you can see in seconds when the project ends, what's happening at the same time, and what will slip if one stage slides.

It's the best-known schedule format in the world, and also one of the most misused. Plenty of people build a beautiful Gantt at the start of a project, never open it again, and when the client comes asking, discover the chart has nothing to do with reality. This guide shows how to build one that works, how to find the critical path, and when not to use a Gantt.

What a Gantt chart is and where it comes from

The name comes from Henry Gantt, an American engineer and consultant who popularized this type of chart in the 1910s, applied to production planning in factories. The idea of drawing tasks as bars on a time scale existed before him, but it was Gantt's work that spread it through the industrial world and, later, through construction and engineering projects.

The format's strength is in combining two pieces of information in one drawing: when each thing happens (the bar's position and length) and in what order (the dependency arrows). A date spreadsheet shows the first; only the chart shows the second in a way the eye understands without effort.

What a Gantt is for

A Gantt solves four problems that a task list alone doesn't:

• Predicting the end date. By adding up durations and dependencies, you arrive at a date you can defend in front of the client, not a guess.
• Showing the effect of delays. "If the approval slips a week, when does delivery land?" is a question the chart answers at a glance.
• Avoiding scheduling conflicts. Seeing the stacked bars, you notice the same person is assigned to three tasks in the same week.
• Aligning people who aren't in the day to day. The director, the client, and the investor won't read fifty tasks, but they understand a timeline with five milestones.

It's a typical tool for projects with dates and sequence: construction, system rollouts, launches, events, office moves, audits. An accounting firm in Belo Horizonte migrating its client base to a new system by December has everything it needs to use one: each stage (registration, history import, training, cutover) depends on the previous one, and there's an end date.

The elements of a Gantt

Time axis

At the top, a ruler of days, weeks, or months. The scale should match the project: a 14-month construction job fits in weeks; the launch of a 3-week campaign calls for days.

Task bars

Each task is a bar. The length is the duration; the position, the start and end. Many charts fill part of the bar to show the percent complete, so progress appears right in the drawing.

Summary tasks (grouping tasks)

Larger stages, like "foundation" or "website design," group several smaller tasks. The summary bar spans from the start of the first to the end of the last. They let the chart fit on one screen without losing the detail underneath.

Dependencies

Arrows linking one bar to another. They say that one task can only start (or finish) after another starts or finishes. It's the element that turns a drawing of bars into a real plan, and it's explained in the next section.

Milestones

Zero-duration points, drawn as diamonds, that represent dates that matter: "client approves the design," "key handover," "go-live." A milestone consumes no time or effort; it marks a decision or a delivery.

Today line

A vertical line that marks the current date. Everything to the left of it that isn't complete is late. It's the simplest element and the one that does the most to get the chart looked at.

Types of dependencies between tasks

A dependency defines the relationship between the end or start of two tasks. There are four classic types:

In practice, the vast majority of dependencies in an ordinary project are finish-to-start. Start with those and only use the other types when there's a clear reason. One caution: a dependency means "can't start before," not "it would be better to do it in this order." Linking tasks by preference fills the chart with false arrows, and the plan starts moving in ways nobody can explain.

Critical path: what sets the end date

The critical path is the sequence of chained tasks with the longest total duration. Since each task in the sequence waits for the previous one, the project can't finish before their sum. Any delay in a critical path task pushes the end date by the same amount. Tasks outside it have float: they can slip up to a point without moving the delivery.

A simple numeric example

An agency in Florianópolis builds a client's website. The tasks, with durations in business days and finish-to-start dependencies:

There are two paths from start to finish:

• A, B, D: 3 + 5 + 2 = 10 days
• A, C, D: 3 + 4 + 2 = 9 days

The project takes 10 days, because task D only starts when both B and C are done, and B takes longer. The critical path is A, B, D. Task C has 1 day of float: it can take 5 days instead of 4 without moving the delivery. If development (B) slips 2 days, delivery moves to day 12. If copywriting (C) slips 1 day, nothing changes.

That's why the critical path guides where to spend your attention. The weekly meeting should first ask, "is any critical task at risk?" A delay off the path deserves care, but isn't urgent; a delay on it is the end date slipping.

The critical path changes

It isn't fixed. If copywriting (C) balloons to 7 days, the A, C, D path adds up to 12 days and becomes the new critical path, and task B gains float. That's why the calculation has to be redone with every change, and it's the main reason to build a Gantt in a tool instead of a spreadsheet: the math is repetitive and fails without warning.

How to build a Gantt, step by step

1. Define the scope and the final milestone. What will be delivered and by what date the client expects it. Without this, the schedule is decoration.
2. Break the work into tasks. Use a WBS so you don't forget anything. The rule of thumb: tasks between 1 and 10 days. Smaller than that is too much detail; bigger hides problems.
3. Estimate each task's duration. Ask for the estimate from whoever will do the work, not whoever will chase it. Add buffer where there's uncertainty.
4. Link the dependencies. For each task, ask "what has to be done before this can start?" Record only the real dependencies.
5. Assign owners. One person per task. A Gantt with no owner is a drawing.
6. Mark the milestones. Client approvals, partial deliveries, contractual dates. These are the points you defend in meetings.
7. Identify the critical path. Add up the durations of each sequence and see which is longest. That's the stretch where you can't give an inch.
8. Review once a week. Update progress, move what changed, and check whether the critical path switched. Fifteen minutes is enough; if it takes more, the chart is too detailed.

There's a starting point in the project schedule template, and, for construction, in the construction schedule template. The post how to build a schedule your team will meet covers the human side of the subject.

Construction example: a builder in Curitiba

To see how a Gantt behaves in a more chained case, imagine a construction company in Curitiba renovating a building's facade. The core of the schedule has these stages:

1. Project approval at the condominium owners' meeting (milestone)
2. Scaffolding contracted (depends on 1)
3. Scaffolding assembled (depends on 2)
4. Plaster repair (depends on 3)
5. Plaster curing, with waiting time (depends on 4)
6. Painting (depends on 5)
7. Scaffolding removal and handover (depends on 6)

Here almost everything is a queue: the critical path is the whole project, and any delay shifts the delivery. It's the kind of project where a Gantt is indispensable, because the question "if rain delays the painting by five days, when do I deliver?" has to be answered on the spot, not over the weekend in a spreadsheet.

How to read a Gantt in 30 seconds

When someone opens your Gantt in a meeting, train the eye to always follow the same order:

1. Find the today line. It's the reference point. Everything to the left should be done.
2. Look for incomplete bars to its left. Each one is a delay. The farther from the line, the older.
3. See whether any of them is on the critical path. If so, the end date is already at risk.
4. Look at the upcoming milestones. Are they holding? What has to happen before each one?
5. Check the workload. Is there any week with too many bars for the same person?

If the whole meeting fits in these five questions, the Gantt is doing its job. If someone needs ten minutes just to understand the chart, it's too detailed or out of date.

Gantt or Kanban?

The two don't compete; they answer different questions. A Gantt answers "when does it finish and what happens if this slips." Kanban answers "where does the work stand today and where is it stuck." A Gantt is good for the month and bad for Tuesday; the board, the opposite.

Use a Gantt when there are dependencies with a promised date: construction, rollouts, campaigns with client approval. Use only the board when the work is continuous flow with no end date, like support and maintenance. And if you have both needs, use both on the same tasks. The full comparison is in Kanban or Gantt?, and the general context is in the project management guide.

The most common mistakes when making a Gantt

• Too much detail. Two hundred bars nobody updates. Keep the Gantt at the level you can defend; the rest lives in a list or on a board.
• No dependencies. Without arrows, it's a colorful calendar. It calculates nothing and warns about nothing.
• Made-up dependencies. The opposite: linking everything to everything "for organization." The chart locks up and nobody knows why.
• Estimates with no buffer. All tasks in the best case add up to a deadline that doesn't exist. Add float to uncertain stages, especially those that depend on the client.
• No owner. The bar slips and nobody feels responsible for it.
• Not updating. The most common mistake of all. An outdated Gantt is fiction, and it's always the version the client looks at.
• Ignoring the critical path. Treating every delay as equal and spending energy on a task with float while the critical one slips.
• Forgetting weekends and holidays. Duration in business days versus calendar days changes the end date. Define the rule before you start.

Gantt in Excel or in a tool?

You can make a Gantt in Excel, and for a small, one-person project with no changes, it works. The usual method is to build a table with start and duration and turn it into a stacked bar chart, making the first series invisible. There are also ready-made spreadsheets, with conditional formatting that paints each task's cells.

The problem starts with the first change:

The spreadsheet wins on cost and familiarity. The tool wins on everything that depends on recalculating: dependencies, critical path, workload per person, and delay alerts. To choose between them, it's worth reading how to choose project management software.

How to do it in Tasskee

Tasskee's Gantt schedule is part of the Pro plan, and the 15-day trial, no credit card, already unlocks it. Each project task becomes a bar on the timeline as soon as it gets a date, so you don't have to build the schedule from scratch.

1. Create the project's tasks with an assignee and a date. The ones already in the project show up on the timeline on their own. If the plan is in a document or meeting minutes, you can import the text and turn it into tasks with AI.
2. Drag the bar to reschedule. Date changed? Pull the bar. Tasks linked to it adjust and you see the effect before promising anything to the client.
3. Link the dependencies. A task starts only after the previous one finishes, and the timeline shows the chain.
4. Mark the milestones. Highlight the dates that can't slip: client approval, partial delivery, go-live.
5. See the critical path. Tasskee highlights the sequence of tasks that sets the end date, so you know where you can't give an inch.
6. Track progress on the bar itself. Progress appears on the timeline, and completing the task on the board updates the schedule, because they're the same task in different views.

Since list and Kanban board are on all plans, including Free, many teams start with the board and add the schedule when the first date question comes up that the board can't answer. For short cycles on the same tasks, there are sprints. And if the client needs to follow the schedule without taking up a user seat, the guest portal shows whatever you release from the project.