Build a Gantt Chart Free: A 10-Minute Walkthrough

Open a blank spreadsheet. In the next ten minutes, you are going to turn a task list into a schedule that actually tells you when the project finishes, not just what needs doing.

You can build a Gantt chart free, in five moves: list the tasks, estimate durations, link the dependencies, assign one owner per task, then read off the critical path that falls out of the links. None of that requires a paid tool. It requires doing the five moves in that order, because doing them out of order is exactly how a schedule turns into a set of hopeful-looking bars that nobody trusts by week three.

The direct answer: build a Gantt chart free by listing tasks, estimating duration for each in days, linking the tasks that genuinely cannot start until another finishes, assigning a single owner per task, then tracing the longest chain of linked tasks front to back. That longest chain is the critical path, and it sets the minimum time the project can take. A spreadsheet holds all five inputs; a dedicated tool adds automatic recalculation when something changes.

What You Need Before You Start

Gather three things before opening any tool. First, a task list broken small enough that each item is 1 to 10 days of work; anything longer hides its own internal schedule risk, anything shorter belongs on a checklist instead. Second, a rough duration estimate per task, from historical data, a similar past project, or the person who will actually do the work; a single confident number beats a padded range nobody believes. Third, a straight answer to "what has to finish before this can start" for every task, because that answer is the dependency link the whole chart hangs on.

Build a Gantt Chart in 10 Minutes: Step by Step

1. List every task with no dates attached. Write the full list first, unconstrained by time. Mixing "what needs doing" with "when it happens" in the same pass is the single most common reason task lists come out incomplete: the moment you start assigning dates, you stop thinking about scope and start thinking about the calendar.
2. Estimate each task's duration in days. Use whatever's fastest and most honest: a similar task from a past project, or the assignee's own estimate. Don't confuse duration (calendar days) with effort (work hours); an 8-hour task assigned to someone working half-time on your project has a 2-day duration, not a 1-day one.
3. Link the tasks that genuinely depend on each other. For each task, ask what has to finish before it can start. Most links are Finish-to-Start. Resist linking tasks just because they happen to be next on the list; an unnecessary dependency over-constrains the schedule and manufactures a false critical path.
4. Assign one clear owner per task. A task with two owners has none; a task with zero owners is a wish. If a task genuinely needs two people, split it into two tasks with one owner each rather than leaving the ownership ambiguous.
5. Trace the critical path and read off the finish date. Follow every path of linked tasks from the first task to the last, add up the durations along each path, and the longest total is the critical path. That total is your project's minimum duration; everything not on that path has float, room to slip a little without moving the end date.

The diagram below shows how those five inputs become bars on a timeline, in the order they need to happen.

Where the Time Actually Goes

Step	Typical time (15 to 25 tasks)	The mistake that costs the most time later
List tasks	3 minutes	Mixing scope and scheduling in one pass, so the list comes out incomplete
Estimate durations	2 minutes	Estimating effort (work hours) instead of duration (calendar days)
Link dependencies	3 minutes	Linking tasks that are merely sequential in the list, not actually dependent
Assign owners	1 minute	Leaving a task with two owners or none
Trace critical path	1 minute	Eyeballing the longest-looking bar instead of adding up every path

Most of the ten minutes goes into listing and linking, which tracks: those are the two steps where a rushed pass produces a schedule that looks complete and isn't. Estimating and assigning owners are fast because they're single facts per task, not judgment calls about the whole plan.

Where a Manual Gantt Chart Caps Out

A spreadsheet or whiteboard version does the job for a small, mostly-sequential project, and it is worth building one by hand at least once, because the exercise makes the five inputs concrete instead of abstract. It caps out in three specific ways. Moving one task does not move its dependents automatically, so every schedule change means manually re-checking every downstream date. There is no baseline to compare against, so "are we ahead or behind" has no stored answer, only a guess. And past roughly 30 to 40 tasks, redrawing the chart by hand after every change stops being realistic, which is usually the point where a team quietly stops updating it at all. The Gantt Litmus Test covers this distinction in more depth: a chart that recalculates automatically is a schedule, one that doesn't is a drawing of one.

Once dependencies are actually linked, the critical path method, developed at DuPont in the 1950s for exactly this problem, is what turns a stack of bars into an answer to "when do we actually finish." Onplana's free Gantt chart builder takes the same five inputs covered above directly in the browser and updates the bars live as you enter them, useful once you outgrow redrawing a spreadsheet by hand. For a deeper look at what a Gantt chart is actually built from, dependency types, baselines, and the anatomy of the two panels, see what a Gantt chart is and the mechanics of the critical path method that Step 5 above is a compressed version of. Both sit in the wider scheduling fundamentals library alongside the rest of this series.

Build your Gantt chart in the browser, free Enter the same five inputs above directly in Onplana's Gantt view and watch the bars update live as you add tasks and links. No credit card required to start. → Open the free Gantt chart builder