Gantt Chart Guide: How to Read One, Build One, and Find the Critical Path

Quick answer: A Gantt chart is a bar chart of a project schedule. Tasks run down the left, dates run across the top, and each task is a bar showing when it starts and ends. Arrows between bars show which tasks depend on which. The longest connected chain of bars is the critical path.

Most Gantt chart guides stop at “here’s a bar, here’s a timeline.” That gets you a picture, not a schedule.

The difference is the part almost nobody explains: which bars can slip, and which can’t. Take the example in this guide. A 15-day furniture order can slip by 11 days with no effect on the finish date. A 6-day IT setup can’t slip by a single day.

You cannot see that by looking at the bars. You work it out with a calculation that takes about ten minutes, and this guide walks through it with real numbers.

What Is a Gantt Chart?

A Gantt chart is a picture of a project schedule, drawn as horizontal bars.

• Tasks run down the left-hand side, one per row
• Dates run across the top
• Each bar starts on the day its task starts and ends on the day it finishes
• Arrows between bars show which task has to wait for which

A longer bar means a longer task. Bars that sit side by side at the same point on the timeline are tasks happening at the same time.

That’s the whole format. A Gantt chart in project management has survived for over a century because it answers two questions at a glance: what is happening this week? and what is this task waiting for?

What a Gantt chart is good at

Question	Does a Gantt chart answer it?
What’s happening in week 6?	Yes, immediately
What is this task waiting on?	Yes, if dependencies are drawn
When does the project finish?	Yes
Which tasks can’t slip?	Only if you calculate it
Who is overloaded?	Not really — you need a resource view
Why are we doing this?	No — that’s the charter

A Gantt chart shows when. It doesn’t show why, and it only shows who if you add a column for it.

One correction worth making early

You’ll often read that a Gantt chart “is the critical path method.” It isn’t.

A Gantt chart is a way of drawing a schedule. The critical path method is a way of calculating one. You can draw a Gantt chart with no critical path at all, which is exactly what most hand-made ones are. The calculation is covered further down, and it’s the thing that turns a picture into a schedule.

Who Invented the Gantt Chart?

Henry Gantt, an American mechanical engineer, developed these charts in the 1910s while working on production scheduling. They were used to plan manufacturing output during the First World War, including at the Frankford Arsenal, and his name stuck to the format.

But he wasn’t first.

Karol Adamiecki, a Polish engineer, created an almost identical tool in 1896 — around 14 years earlier. He called it a harmonogram. He published it in Polish and Russian, and it didn’t reach English-speaking industry, so the format carries Gantt’s name instead.

	Karol Adamiecki	Henry Gantt
When	1896	1910s
Name for it	Harmonogram	Gantt chart
Published in	Polish, Russian	English
Whose name stuck	—	His

It’s a small piece of history, but it makes a useful point. This format was invented twice, independently, by two engineers solving the same problem. The problem is older than any software, and so is the answer.

What Are the Parts of a Gantt Chart?

Part	What it is	Why it matters
Task list	The rows down the left	The spine of the chart
Timeline	The dates across the top	Days, weeks or months, depending on project length
Bars	One per task	Length = duration
Dependency arrows	Lines between bars	Show what waits for what
Milestones	Usually a diamond	A zero-length event, not a task
Summary bars	A bracket spanning child tasks	Rolls up a group of tasks into one row
Today line	A vertical line	Shows where you are right now
Progress shading	A darker fill inside a bar	How much of that task is done
Baseline bars	A faint second bar	The plan you originally agreed
Owner column	A name beside each row	Who’s doing it

Milestones vs tasks

This trips people up constantly.

	Task	Milestone
Takes time	Yes	No — zero duration
Drawn as	A bar	A diamond
Example	“Build the pages” (10 days)	“Site live”
Has an owner who does work	Yes	Someone confirms it, nobody “does” it

A milestone is a checkpoint, not a piece of work. If your milestone has a duration, it’s a task wearing the wrong shape.

Good milestones mark moments where something changes: a sign-off, a handover, a go-live. Five to eight of them across a project is usually about right.

How Do You Read a Gantt Chart?

Read it in this order. It takes about a minute.

1. Look at the timeline scale. Is this chart in days, weeks or months? Everything else depends on knowing that.
2. Find the today line. Everything to its left should be done or in progress.
3. Find the longest bars. These are your big risks, because a long bar is a long time to be wrong about.
4. Follow the arrows from left to right. This tells you the chain of work.
5. Look for bars with nothing before them. These can start now.
6. Look at the last bar. Its end date is the project finish date.
7. Check the progress shading against the today line. A bar that’s half past the today line but only 20% shaded is late.

The one thing people get wrong when reading

Bars that look urgent often aren’t. A long bar starting soon feels like the most pressing thing on the chart. Sometimes it’s the least.

The office-move example further down has exactly this trap. The 15-day furniture order looks like the scariest bar on the chart. It has 11 days of slack. The 6-day IT setup looks minor, and it has none.

Reading the bars gets you a feeling. Calculating the float gets you the truth.

What Are the Four Types of Task Dependencies?

A dependency is a rule about the order of two tasks. There are four kinds, and most people only know the first.

Type	Short	Rule	Example
Finish-to-Start	FS	B can’t start until A finishes	Can’t paint until the plastering is done
Start-to-Start	SS	B can’t start until A starts	IT cabling can’t start until the building work starts
Finish-to-Finish	FF	B can’t finish until A finishes	Testing can’t finish until development finishes
Start-to-Finish	SF	B can’t finish until A starts	The old system can’t be switched off until the new one goes live

Which ones you’ll actually use

Finish-to-Start is about 90% of real dependencies. It’s the default in every tool, and if you only ever use FS you’ll model most projects correctly.

Start-to-Start is the useful second one. It lets two tasks run in parallel with a staggered beginning, which is how most overlapping work really behaves.

Finish-to-Finish shows up in testing and review work, where the second task shadows the first.

Start-to-Finish is genuinely rare. The classic example is a handover: the night shift can’t finish until the day shift starts. If you think you need SF, check first whether you’ve got the two tasks the wrong way round — that’s usually what’s happened.

The mistake to avoid

Don’t drag bars into position by hand instead of setting a dependency.

A bar you dragged looks identical to a bar that’s properly linked. The difference appears when something slips: linked bars move automatically, dragged bars stay where you put them and quietly become wrong.

If your chart has no arrows, it isn’t a schedule. It’s a drawing of one.

What Are Lag and Lead Time?

Sometimes a dependency isn’t “immediately after.” Lag and lead handle the gap.

Term	What it means	Written as	Example
Lag	A forced wait between two tasks	FS + 3 days	Concrete has to cure for 3 days before you build on it
Lead	An allowed overlap	FS − 2 days	Start writing the copy 2 days before the design is finished

How to use them well

Lag is for physical or contractual waits. Curing, drying, shipping, a 14-day notice period, a review board that only meets on Thursdays. These are real delays that no amount of effort removes, and they belong in the schedule as lag.

Lead is for deliberate overlap. Starting a task slightly early because you can work with a near-final input.

One warning on lead time. Every lead is a small bet that the first task won’t change much. Two days of lead on a design that then gets reworked means two days of wasted copywriting. Use lead where the input is stable, and keep it out of your critical chain where you can.

Don’t use lag to hide a missing task. If you’ve put a 5-day lag between “design approved” and “build starts,” ask what happens in those five days. Usually it’s real work — procurement, onboarding, a handover — and it deserves its own row.

What Does a Gantt Chart Example Look Like?

Here’s a complete 10-task schedule for an office move. Durations are in working days, and day 0 is the start.

ID	Task	Duration	Depends on
A	Agree requirements and budget	3	—
B	Find and shortlist spaces	10	A
C	Sign the lease	5	B
D	Design the fit-out	8	C
E	Order furniture	15	D
F	Do the building work	20	D
G	Set up IT and network	6	F
H	Pack the old office	4	C
I	Move everything	2	E, G, H
J	Unpack and settle in	3	I

All dependencies here are Finish-to-Start.

How the bars sit on the timeline

Task	Starts day	Ends day	Notes
A	0	3	Nothing before it
B	3	13
C	13	18
D	18	26
E	26	41	Runs alongside F
F	26	46	Runs alongside E
G	46	52	Waits for F
H	18	22	Runs alongside D, E and F
I	52	54	Waits for the latest of E, G and H
J	54	57

The project takes 57 working days.

Three things to notice in that table:

E and F both start on day 26. They both depend on D, and neither depends on the other, so they run in parallel. This is the single most common misreading of a Gantt chart — people assume each bar starts where the previous one ends. Parallel bars overlap, and that overlap is where the time savings live.

H starts on day 18, long before it’s needed. Packing only depends on the lease being signed. It could start much later, which the float calculation will quantify exactly.

I waits for the latest of three things. E finishes day 41, H finishes day 22, G finishes day 52. The move can’t start until day 52, because a task with several predecessors waits for whichever finishes last. That “whichever is latest” rule is the heart of the whole calculation.

How Do You Find the Critical Path on a Gantt Chart?

The critical path is the longest connected chain of tasks through the project. It sets the finish date, and nothing on it can slip without pushing that date out.

You find it in two passes. The method works on any project Gantt chart, by hand or in software.

Pass 1 — the forward pass (earliest dates)

Work left to right. Two rules:

• Early Start (ES) = the latest Early Finish of everything it depends on. With no predecessors, ES = 0.
• Early Finish (EF) = ES + duration

Task	Duration	ES	EF	Working
A	3	0	3	Starts at zero
B	10	3	13	After A
C	5	13	18	After B
D	8	18	26	After C
E	15	26	41	After D
F	20	26	46	After D
G	6	46	52	After F
H	4	18	22	After C
I	2	52	54	max(41, 52, 22) = 52
J	3	54	57	After I

The project finishes on day 57. That’s the EF of the last task.

Pass 2 — the backward pass (latest dates)

Now work right to left, starting from day 57. Two rules:

• Late Finish (LF) = the earliest Late Start of everything that depends on it. For the last task, LF = 57.
• Late Start (LS) = LF − duration

Task	Duration	LF	LS	Working
J	3	57	54	Last task
I	2	54	52	Before J
G	6	52	46	Before I
H	4	52	48	Before I
E	15	52	37	Before I
F	20	46	26	Before G
D	8	26	18	min(37, 26) = 26
C	5	18	13	min(18, 48) = 18
B	10	13	3	Before C
A	3	3	0	Before B

Pass 3 — the float, and the answer

Total float = LS − ES. Anything with zero float is on the critical path.

Task	ES	LS	Total float	On critical path?
A	0	0	0	Yes
B	3	3	0	Yes
C	13	13	0	Yes
D	18	18	0	Yes
E	26	37	11	No
F	26	26	0	Yes
G	46	46	0	Yes
H	18	48	30	No
I	52	52	0	Yes
J	54	54	0	Yes

The critical path is A → B → C → D → F → G → I → J.

Check it: 3 + 10 + 5 + 8 + 20 + 6 + 2 + 3 = 57 days, which matches the project duration exactly. If your critical path durations don’t add up to your project length, you’ve made an arithmetic slip somewhere.

Two checks that catch mistakes

Check 1 — float two ways. Total float also equals LF − EF. For task E: 52 − 41 = 11. Same answer. If the two methods disagree, recheck that row.

Check 2 — the critical path must be continuous. It runs unbroken from a task with no predecessors to the final task. A “critical path” with a gap in it is a miscalculation, not a discovery.

What Is Float, and Why Does It Change Your Priorities?

Float — also called slack — is how long a task can slip without pushing the finish date.

Look at what the calculation just told us about the office move:

Task	Duration	Float	What it means
Order furniture (E)	15 days	11 days	Can start 11 days late. Nothing happens
Pack the old office (H)	4 days	30 days	Can start a month late
Set up IT (G)	6 days	0 days	One day late = the whole project is one day late
Building work (F)	20 days	0 days	Same

Why this matters more than the chart

Looking at the bars, the furniture order is the scariest thing on the schedule. It’s 15 days long, it’s expensive, and it starts early. Every instinct says chase it.

The calculation says chase the IT setup instead. It’s 6 days, it’s cheap, it looks minor, and it has zero float. A one-day delay there costs you a day of the project. A one-day delay on furniture costs you nothing.

That inversion is the single most valuable thing a Gantt chart can tell you, and you only get it by doing the maths.

Total float vs free float

	Total float	Free float
Definition	Slip without delaying the project	Slip without delaying the next task
Formula	LS − ES	Earliest ES of successors − EF
Which is bigger	Always equal or bigger	Never exceeds total float

Total float is shared along a path. If two tasks sit on the same non-critical chain with 11 days between them and the finish date, they share those 11 days. The first one to slip eats into the second one’s cushion. Free float is the portion a task can use entirely on its own.

For task E in our example, total float and free float are both 11, because E’s only successor is the move. On longer parallel branches they diverge, and that’s when free float becomes the number you actually manage to.

Three rules for using float

1. Protect the zero-float tasks. These are the ones to check daily.
2. Spend float deliberately, not accidentally. 30 days of float on packing is a resource you can use — move that team onto something critical instead.
3. Recalculate after every change. Float moves. A delay on a non-critical branch can consume all its slack and create a new critical path, which is how projects get surprised.

How Do You Build a Gantt Chart in 7 Steps?

You can start from a blank Gantt chart template or a tool, but the seven steps are the same either way.

Step	What you do	Time on a medium project
1	List the tasks — nouns and verbs, no durations yet	1–2 hours
2	Group them into phases and add summary rows	30 minutes
3	Estimate durations, asking the people who’ll do the work	1–2 hours
4	Set dependencies, using the four types	1 hour
5	Add milestones at the sign-offs and handovers	15 minutes
6	Assign owners, one per task	30 minutes
7	Calculate the critical path and float, then save a baseline	30 minutes

Where people go wrong at each step

Step 1 — too much detail. Aim for 20 to 60 rows on a normal project. Anything you’d finish in under half a day doesn’t need its own bar.

Step 3 — estimating alone. Durations you invented are fiction. Ask the person who’ll do the work, and ask them for a range, not a single number.

Step 4 — dragging instead of linking. Covered above, and it’s the most common fatal error.

Step 6 — two owners on one task. One accountable owner per row. Two names means nobody.

Step 7 — skipping the baseline. Without a saved baseline you can never answer “are we behind?” — because you’ve overwritten the thing you’d compare against.

How long should the tasks be?

Project length	Good task duration
Under 1 month	0.5–2 days
1–6 months	2–10 days
6–18 months	1–4 weeks
Over 18 months	Plan the first phase in detail, the rest in months

The rule behind the table is simple. A task should be short enough that you’d notice it slipping while you can still react. On a two-year programme, a four-week task is fine. On a three-week project, it’s the whole schedule.

How Do You Go From a Task List to a Gantt Chart?

A Gantt chart is bad at telling you what the work is. It’s good at telling you when. So the task list has to come from somewhere else first.

Document	What it gives the Gantt chart
Project charter	The scope boundary — what’s in
Project scope statement	The deliverables that become phases
Scope management plan	The rule for what happens when scope changes
Work breakdown structure	The task rows themselves
Contingency plan	Where your schedule reserve sits

The order is: scope, then breakdown, then schedule. Build the chart first and you’ll be inventing scope with a mouse, one bar at a time.

The handover from breakdown to chart

A work breakdown structure gives you work packages — the smallest pieces of work with one owner each. Those become your Gantt rows, one to one. Then you add the three things a breakdown deliberately leaves out:

Add	Why the breakdown doesn’t have it
Durations	A breakdown is about scope, not time
Dependencies	A breakdown is a hierarchy, not a sequence
Dates	Dates come from durations plus dependencies

If you find yourself adding new work while building the chart, stop. That work wasn’t in the breakdown. So it wasn’t in the scope either. It needs a conversation, not a bar.

Why Do Gantt Charts Fail?

Eight reasons, in rough order of how often they happen.

1. Nobody updates it. A chart that’s two weeks stale is actively misleading, because people still trust it. Update it weekly or take it down.
2. Too many rows. A 400-row chart is unreadable and unmaintainable. It becomes a document nobody opens.
3. No dependencies. Bars dragged into place look right and behave wrong. Nothing moves when something slips.
4. No baseline. You can’t measure variance against a plan you’ve overwritten.
5. No float calculated. Every bar looks equally urgent, so attention goes to the biggest bar instead of the critical one.
6. 100% resource loading. Every person booked solid every day, with no allowance for illness, holidays or the other project they’re on. This schedule fails in week two.
7. Built by one person alone. The people doing the work never agreed to the durations, so they don’t own them.
8. Treated as a promise rather than a plan. A schedule is the best current estimate. The moment it becomes a commitment nobody can revise, people start reporting green on a task that’s three weeks late.

The honest limitation

A Gantt chart is bad at uncertainty. A bar has a start and an end, drawn with the same confident edges whether that duration is a near-certainty or a wild guess.

Nothing in the format shows you which is which. That’s why high-uncertainty work — research, early-stage design, anything you’ve never done before — sits badly in a Gantt chart. The usual fixes:

• Plan the near term in detail and the far term in phases only
• Keep a named schedule reserve as its own bar, rather than padding every task secretly
• Re-plan at phase boundaries instead of defending a chart drawn nine months ago

Padding every individual task is the worst option, because the padding is invisible, unmanaged, and gets consumed by the first task that runs late.

Gantt Chart vs Kanban vs Roadmap: Which Should You Use?

Tool	Shows	Best for	Weak at
Gantt chart	Tasks over time, with dependencies	Fixed-scope work with a real deadline	Changing scope, uncertainty
Kanban board	Work by status, in columns	Continuous flow and ongoing work	Dates and dependencies
Roadmap	Themes by quarter	Communicating direction upward	Day-to-day execution
Milestone chart	Key dates only	Executive reporting	Any actual planning
Burndown chart	Work remaining over time	Sprint progress	Dependencies
PERT chart	The dependency network	Seeing the structure of the sequence	Reading it at a glance

How to choose

• Deadline that can’t move, scope that’s known? Gantt chart.
• Steady stream of similar work? Kanban board.
• Explaining the year to a board? Roadmap, with a milestone chart underneath.
• Need to see the dependency structure clearly? PERT, then draw the Gantt from it.

They’re not rivals. A common and sensible setup is a Gantt chart for the overall schedule and dependencies, a Kanban board for what the team touches daily, and a milestone chart for the steering group. Each audience gets the view that answers their question.

Is a Gantt Chart Still Useful for Agile Teams?

Yes, but not for the sprint.

Use it for	Don’t use it for
Hard external dates — a conference, a regulatory deadline	What the team does this sprint
Dependencies on other teams or suppliers	Ordering the backlog
Release and launch sequencing	Daily task management
Showing stakeholders how the quarters line up	Committing to task-level dates months out

The useful split: a Gantt chart for the boundaries, a board for the work inside them.

A Gantt chart handles cross-team dependencies, supplier lead times and immovable launch dates well. A board handles all three badly. What happens inside a two-week sprint changes too fast for bars, and that’s what the board is for. See agile task management and planning for that side, and scrum team practices for how the two fit together.

What not to do: publish a Gantt chart with task-level bars for the next nine months of an agile team’s work. It will be wrong within a fortnight, and because it looks authoritative, people will plan around it anyway.

What Tools Can You Build a Gantt Chart In?

Tool type	Good for	Watch out for
Spreadsheets	Small charts, full control, no licence needed	No real dependency engine — bars won’t move when something slips
Project management platforms	Dependencies, baselines, critical path, resources	Charts quietly grow past the point of usefulness
Dedicated scheduling software	Large, dependency-heavy programmes	Steep learning curve, usually overkill under 100 tasks
Diagram and whiteboard tools	A quick visual for a presentation	It’s a picture, not a schedule — it calculates nothing

Four features worth more than the brand name:

• A real dependency engine. When a task slips, everything downstream moves on its own. Without this you don’t have a schedule.
• Baseline saving. So “are we behind?” has an answer.
• Automatic critical path and float. Doing it by hand teaches you how it works; doing it by hand every week is a waste of your time.
• A resource view. To catch the person booked twice on the same Tuesday.

If you’re under about 30 tasks, a spreadsheet is fine — just do the float calculation by hand using the method above. Past that, the lack of a dependency engine will cost you more time than a tool would. Our project management tools page covers the wider set, and the project control process guide covers what to do with the chart once the project is running.

How Does Writegenic AI Fit In?

A Gantt chart on its own doesn’t explain itself. Around every schedule sits a pile of writing. The task list it came from. The assumptions behind the durations. The weekly update. And the awkward note explaining why the finish date moved.

Writegenic AI can help you:

• Draft the task list from your scope or charter, ready to become rows
• Write the schedule assumptions — the durations you estimated and why
• Turn the chart into a written summary for people who won’t open the file
• Draft the weekly schedule update, including what moved and what it affected
• Write the delay explanation when a critical-path task slips
• Draft the milestone descriptions so each one has a clear completion test

It also helps with the documents that come before the chart. The project charter. The project scope. And the contingency plan where your schedule reserve lives.

Explore AI for project management or sharpen your instructions with the prompt generator.

Draft with the tool, keep the judgement. AI can write up a schedule clearly and quickly. It cannot tell you that your builder always runs two weeks late, that the client’s legal team takes a month in August, or that the developer who gave you a five-day estimate was being optimistic to be polite. Those three things will decide whether your dates hold, and all three live in your knowledge of the people involved, not in the chart.

Try Writegenic AI free

Frequently Asked Questions

Related reading:

• Project Charter Templates With Real Examples
• How to Write a Project Scope Using AI
• Scope Management Plan: Guide + Template
• Contingency Plan in Project Management
• Project Control Process: Steps + Template
• Agile Task Management and Planning