How to Create a Gantt Chart: A Practical Step-by-Step Guide
A Gantt chart is one of the simplest ways to turn a list of project tasks into an actual plan.
Instead of looking at a spreadsheet full of dates, you can see when work starts and finishes, which tasks overlap, what depends on what, and where delays are likely to cause problems.
But a useful Gantt chart isn't just a collection of coloured bars.
Here's how to build one properly.
1. Start with the work, not the dates
It's tempting to start a project plan by immediately assigning dates to everything.
Don't.
First, work out what actually needs to happen.
Break the project into its main phases, then break those phases into manageable tasks.
For a simple website launch, for example, you might start with:
- Discovery
- Design
- Development
- Testing
- Launch
You can then break those down further.
Design
- Create wireframes
- Review wireframes
- Produce visual designs
- Approve final designs
This creates a Work Breakdown Structure (WBS): essentially a hierarchy showing how the project is organised.
For larger projects, grouping work into parent tasks and subtasks also makes the plan much easier to navigate.
2. Add realistic durations
Once you know what needs to happen, estimate how long each task should take.
Try not to confuse duration with effort.
A task might require eight hours of someone's time but take five working days to complete because they are also working on other things.
Your Gantt chart should represent when the work is expected to happen, not simply the number of hours involved.
At this stage, don't worry about getting every date perfect. The relationships between tasks are often more important.
3. Connect tasks with dependencies
Dependencies are where a task cannot start, or finish, until something else happens.
For example:
Create wireframes → Approve wireframes → Produce visual designs
If wireframe approval is delayed, the design work should move accordingly.
The most common dependency is Finish-to-Start (FS): Task B cannot start until Task A finishes.
But there are four standard dependency types:
- Finish-to-Start (FS): Task B starts after Task A finishes.
- Start-to-Start (SS): Task B can start once Task A starts.
- Finish-to-Finish (FF): Task B cannot finish until Task A finishes.
- Start-to-Finish (SF): Task B cannot finish until Task A starts. This is much less common, but useful in some handover scenarios.
You can also add lag where there needs to be a gap between two activities.
For example, if paint needs two days to dry before the next task starts, that's a two-day lag rather than another project task.
Getting dependencies right is one of the most important parts of building a useful project plan.
4. Add milestones
Some things in a project aren't really tasks.
They're events.
A product launch, contract approval, go-live decision or regulatory deadline doesn't necessarily take several days to complete. It represents an important point in the plan.
That's what milestones are for.
On a Gantt chart they're normally shown as diamonds rather than bars.
Useful milestones might include:
- Requirements approved
- Design signed off
- Beta released
- Go-live approval
- Product launched
Avoid turning every minor event into a milestone. They work best when they highlight genuinely significant points in the project.
5. Assign people to the work
Once the structure of the plan makes sense, start thinking about who will actually do it.
Assigning people to tasks can expose problems that aren't obvious from the timeline alone.
You might discover that one developer is expected to work on four things simultaneously, while another has very little allocated.
That's why resource planning matters.
A schedule can be logically possible and still be impossible for the team delivering it.
Looking at workload and allocation alongside your schedule can help identify those problems before they affect delivery.
6. Look for the critical path
Not every late task makes the project late.
That's an important distinction.
Some tasks have flexibility. They can move by a few days without affecting the overall delivery date.
Others don't.
The sequence of tasks that determines the earliest possible completion date for the project is known as the critical path.
If a task on that path moves by three days, your project completion date may move by three days too.
Understanding which tasks actually drive the finish date helps you focus attention where it matters rather than treating every task as equally urgent.
7. Save a baseline
Once the plan has been agreed, save a snapshot of it.
This is your baseline.
As the project progresses, reality will inevitably start to differ from the original plan.
Tasks will finish early. Others will run late. Requirements will change. Dependencies will move.
Without a baseline, it's surprisingly difficult to answer a basic question:
Are we ahead or behind the plan we originally agreed?
Comparing your current schedule with the baseline lets you see how much the project has moved rather than constantly replacing yesterday's plan with today's.
8. Keep the plan alive
A Gantt chart shouldn't be something you create at the start of a project and then forget about.
Update it.
Record progress. Change dates when reality changes. Add newly discovered work. Review dependencies. Check resource allocation.
The goal isn't to make the original plan look correct.
The goal is to make the current plan useful.
A smaller plan that's updated regularly is far more valuable than a beautifully detailed 500-line schedule nobody trusts.
Start simple
Your first Gantt chart doesn't need hundreds of tasks.
Start with the major phases.
Break those into the tasks you actually need to manage.
Connect the important dependencies.
Add the milestones that matter.
Then refine the plan as you learn more.
That's really the point of a Gantt chart: not to predict the future perfectly, but to make the consequences of change visible when the future inevitably turns out differently.
Building your first Gantt chart in Gantto
If you want to put this into practice, you can build your first project plan in Gantto.
Gantto is a lightweight Gantt chart and project planning tool that runs locally in your browser. There's no account required and your project data doesn't need to be uploaded to a server.
You can create tasks and subtasks, build dependencies, add milestones, assign people, move work directly on the timeline and save the resulting project as a file you control.
The free version is enough to start building and managing a project plan.
If you want help with a particular feature, the Gantto User Guide walks through everything from creating your first task through to dependencies, resources, baselines, critical path, importing Microsoft Project files and sharing your plan.
Ready to try it?