Gantt Chart: Components, Examples, and a Free In-Article Builder
The Gantt chart has been the default project schedule visual for over a hundred years. Most teams know what one looks like (horizontal bars on a timeline) and most have made one in Excel, MS Project, or a Gantt-specific tool. The chart is a strong visualization, but a weak project plan if treated as the plan itself. The bars are downstream of decisions made in the scope, the dependencies, and the durations.
This guide covers Gantt charts as they actually work in 2026. The 6 components every reader should be able to identify. The 1896 origin story (Karol Adamiecki, not Henry Gantt). A 6-step build process with a worked SaaS launch example. The honest comparison to Work Breakdown Structure, Critical Path Method, and project roadmaps. A no-fluff software list. Use the builder below to draft a Gantt with bars, dependencies, and a critical-path overlay as you read.
Gantt chart builder
Add tasks, durations, and dependencies. Bars and the critical path render automatically.
Quick answer. A Gantt chart is a horizontal bar chart that visualizes a project schedule. Each bar represents a task, positioned on a timeline by its start date and sized by its duration. The 3 main components are the timeline axis, the task bars, and the dependencies. Modern Gantt charts also include milestones, a today line, and a critical-path overlay.
Build the Gantt from a real Work Breakdown Structure, never the other way around.
What a Gantt chart is
A Gantt chart is a visualization of when work happens. Each task is a horizontal bar laid against a timeline axis. The bar's left edge marks the start date, its length marks the duration, and arrows or vertical alignment between bars mark dependencies. The chart answers one question well: across the project, which work happens when, and how do the pieces connect.
The Gantt does not answer what the deliverables are (that is a Work Breakdown Structure). It does not answer why the project exists (the project charter). It does not answer which sequence drives the schedule mathematically (the Critical Path Method). It is the visualization layer that sits on top of those underlying artifacts.
Treating the Gantt as if it were the plan is the most common reason teams end up debating bar positions while the actual scope drifts.
The components of a Gantt chart
Six elements show up in nearly every modern Gantt. A reader who can identify all six can read any Gantt in 30 seconds. A Gantt missing two or three of these is usually a slide, not a working tool.
The components of a Gantt chart
Hover a card below to spotlight it on the chart
The today line and the critical-path overlay are the two elements most often missing from kickoff Gantts. Adding them is a 10-minute upgrade that converts a static slide into something the team will actually re-open during execution.
A short history
The chart format predates Henry Gantt. The Polish engineer Karol Adamiecki published a similar concept (the harmonogram) in 1896, but his work appeared in Polish and Russian and went unnoticed in the West. Henry Gantt independently developed the modern bar-chart format around 1910 to 1915 while working on industrial production scheduling at Bethlehem Steel and the Frankford Arsenal during the First World War.
"The Gantt chart provided to industry a tool for the planning and control of work that was new and revolutionary. Its principles became the foundation upon which all subsequent scheduling techniques have been built." - Wallace Clark, "The Gantt Chart: A Working Tool of Management" (1922)
The chart spread quickly through manufacturing in the 1920s and 1930s, and into general project management after the Second World War. The 1950s brought CPM and PERT, which added the dependency math that modern Gantts now display as overlays. Software-era Gantts (MS Project in 1984, web tools from the 2000s onward) made the format collaborative, but the visual is essentially what Gantt and Adamiecki drew with paper and pencil.
How to make a Gantt chart in 6 steps
The process below produces the same chart whether you draw it on a whiteboard, build it in Excel, or use the builder at the top of this page. Six steps, walked here against a typical SaaS feature launch example.
- List the tasks from your WBS Pull the activity list from the project's Work Breakdown Structure. Each task on the Gantt is a Level 3 work package or a major Level 2 deliverable, depending on the chart's altitude. A Gantt built from invented activities is fiction. A Gantt built from a real WBS is load-bearing. Example tasks: A Spec doc, B Backend API, C Frontend UI, D QA testing, E Launch.
- Estimate durations Give each task a single duration in days, weeks, or whatever unit the project runs in. Pad estimates honestly. A Gantt full of three-day tasks that always take five is a disinformation tool. If durations have real uncertainty, use ranges or move to PERT-style three-point estimates and average them in. Example durations: A 5d, B 10d, C 8d, D 4d, E 2d.
- Map dependencies For each task, write down what must finish first. Most are finish-to-start. Be honest about which dependencies are real (B literally cannot start until A finishes) versus narrative (B usually starts after A). False dependencies inflate the schedule without anyone realizing. Example dependencies: B and C both need A. D needs both B and C. E needs D.
- Lay out the bars on a timeline Draw a horizontal axis with day or week ticks. Place each task as a bar, positioned by its earliest start (computed from dependencies) and sized by its duration. Tasks without predecessors start at day zero. Tasks with predecessors start at the latest finish of their predecessors. Example layout: A starts at day 0. B and C both start at day 5. D starts at day 15 (B finishes at 15). E starts at day 19 (D finishes at 19). Project ends at day 21.
- Highlight the critical path Run the forward and backward pass to compute float for each task. Tasks with zero float form the critical path. Color those bars in a distinct shade (usually red). Without the critical path overlay, the Gantt looks like a list of equal tasks. With it, the team knows which bars are load-bearing. Example critical path: A → B → D → E. C has 2 days of float because it runs in parallel with B and finishes earlier.
- Add milestones, today line, and owners Mark stakeholder-relevant moments as diamond milestones (kickoff, sign-off, launch). Add a vertical "today" line so anyone reading the chart can answer "are we on track" at a glance. Tag each bar with its owner. Update the today line and slip-affected bars weekly. A Gantt without these three elements is wallpaper within 30 days. Example: Launch milestone at day 21. Today line moves weekly. Owner labels: A spec writer, B backend engineer, C frontend engineer, D QA lead, E PM.
Steps 1 to 3 are the substantive work. Steps 4 to 6 are mechanical once 1 to 3 are honest. Most Gantt failures trace back to a missing task, an inflated duration, or a fake dependency in the first three steps.
Worked example: SaaS feature launch
Use the builder at the top of the article with its default brand-refresh setup. The chart renders as below: 4 tasks across 19 days, with the critical path highlighted in red and one task carrying float.
Worked example: brand refresh
4 tasks, 19 days, critical path A → B → C
What the project manager learns from this. Launch comms (D) can slip up to 4 days without consequence because it runs in parallel with the longer Design system (C) branch. Slipping C by 1 day pushes the launch milestone one day right.
If D slips by 5 days, the critical path moves to A → B → D and total duration becomes 20 days. The chart tells the team which slips matter and which ones do not, at the speed of a glance.
"Gantt charts are most useful when the team treats them as a communication tool. The act of reading the chart together, not the act of building it once, is where the value comes from." - PMI, A Guide to the Project Management Body of Knowledge (PMBOK Guide)
The bars and the today line answer the only two questions a stakeholder usually asks. Are we on track. What slips. The project manager can say "C slipped, this matters" or "D slipped, no action needed" within seconds of seeing the update. That is the operational value of a Gantt that is maintained, and the reason kickoff-only Gantts get ignored within a month.
Gantt vs WBS vs CPM vs roadmap
Four scheduling and scope methods get conflated in most project conversations. Each one answers a different question. Treating them as one bloated artifact is how teams end up with a 50-page document that nobody updates.
| Method | What it answers | Format | Best for |
|---|---|---|---|
| Work Breakdown Structure | What the deliverables areDecomposition only, no time | Tree or numbered outline | Defining scope before scheduling |
| Critical Path Method | What sequence drives the scheduleMath only, no calendar | Network diagram with float per task | Identifying which slips matter |
| Gantt chart | When each task happens on a calendarVisual schedule, tracks progress | Horizontal bars on a timeline | Communicating schedule, day-to-day execution |
| Project roadmap | Where the project is going at the phase levelHigh-level visual, monthly cadence | Timeline or now-next-later | Stakeholder alignment, board reviews |
The sequence in practice. The Work Breakdown Structure decomposes scope. The Critical Path Method computes which sequence drives the schedule mathematically. The Gantt chart visualizes that schedule on a calendar. The project roadmap shows the same picture at a higher altitude for stakeholders. Each one is the right tool for its specific job. The Gantt is the most visible, but it is downstream of the other three.
Gantt chart software compared
The software market splits into three categories: Gantt-only tools, Gantt views inside broader PM platforms, and slide-export tools for stakeholder-deck Gantts. The right pick depends on whether the chart is a kickoff artifact or a daily working tool.
| Tool | Best for | What it does well |
|---|---|---|
| Office TimelineFree + Pro from $59/mo | PowerPoint and slide-deck Gantts | Exports clean visuals to PowerPoint and PDF. Best when the deliverable is a stakeholder slide, not a live schedule. |
| TeamGanttFree up to 1 project, Pro from $19/user/mo | Collaborative web Gantts | Browser-native, drag bars, dependency arrows, comment threads. Best for teams that live in the chart and update daily. |
| SmartsheetFrom $9/user/mo | Spreadsheet-native teams | Spreadsheet rows with a Gantt view layered on top. Strong for finance and ops teams who already think in cells. |
| MS ProjectFrom $10/user/mo (cloud) | Enterprise schedules and resource leveling | Industry standard for large programs with hard dependencies, baselines, earned value. Steeper learning curve. |
| AsanaFree, Starter from $10.99/user/mo (Timeline view) | Teams already using Asana for tasks | Timeline view extends the task list into a Gantt. Good when the team already has tasks in Asana and wants a schedule overlay. |
The pattern most teams settle into. One person owns the Gantt. They update it weekly or at every phase boundary. The deliverable is either a screenshot pasted into the status review or a live link shared with the sponsor. Heavy live-Gantt usage past 30 to 50 bars almost always migrates to MS Project or a dedicated scheduling tool, regardless of what the team started with.
Common Gantt chart mistakes
Five patterns account for most failures we see in Gantts that get built and then abandoned. They are easy to spot in a draft chart if you know what to look for.
- Treating the Gantt as the project plan A Gantt chart is the visualization. The plan is the underlying scope, dependencies, owners, and durations. Teams that build the Gantt first and the plan never end up debating bar positions instead of debating the work. The Gantt should be the output of a real plan, not the plan itself.
- No critical path overlay A Gantt without critical-path highlighting tells the team every task looks equally important. It is not. Highlight the critical path in a distinct color so anyone reading the chart can see which slips matter. A 30-bar Gantt where every bar is the same shade is a slide, not a working tool.
- Ignoring resource conflicts The Gantt shows two tasks running in parallel. The schedule says they share an owner. The team finds out at week three that one person cannot do both at once. Run a resource-leveling check after the Gantt is drafted, or surface the conflict in the project plan and re-sequence accordingly.
- Building it once and never updating A Gantt drawn at kickoff is a one-shot artifact. By month two, durations have shifted, dependencies have changed, and the team is shipping against a chart no one trusts. Update at every phase boundary, every scope change, and any time a critical-path task slips.
- Hiding the today line Without a vertical "today" indicator, the Gantt does not communicate where the project actually stands. Stakeholders see colorful bars but cannot answer the only question they care about: are we on track. Add the today line. Update it weekly.
The first three are structural (Gantt as plan, no critical path, ignored resources). The last two are operational (one-shot artifact, no today line). Both kinds matter, and a Gantt that fails on either side stops being load-bearing within weeks.
When a Gantt chart is overkill
The Gantt is not load-bearing for every project. Three contexts where skipping it is the right call.
Projects under ~15 tasks. If the entire project fits on a sticky-note timeline, the Gantt is overhead. The schedule is obvious by inspection. A simple ordered task list with target dates does the same job in 5 minutes instead of an hour.
Projects with no hard dependencies. If activities can mostly run in parallel and the team is capacity-bound rather than dependency-bound, the Gantt produces a near-flat picture that maps to whatever task has the longest duration. The chart looks impressive but tells the team nothing they did not already know. Resource leveling is the more useful tool for this shape of project.
Sprint-internal agile work. Inside a 2-week sprint, the Gantt is overkill. The backlog and the burndown are the right artifacts. At the program level, where multiple agile teams have hard cross-team dependencies and fixed launch dates, Gantt-style schedules still apply. Use the right one at the right altitude.
Most projects do not fall into these three buckets. For mid-size to large projects with hard dependencies, fixed launch dates, and parallel workstreams, the Gantt is worth the hour it takes to set up. Maintenance runs about 10 minutes per week.
What we recommend
An honest disclosure first. Rock does not have a Gantt view. The product has List, Board, Calendar, and My Tasks views. We are not pretending otherwise, and we will not recommend Rock as a Gantt tool. The pattern that works for most teams is a clean split between where the Gantt is drawn and where the project actually runs.
For the Gantt itself, the builder at the top of this page is enough for most kickoff decks and weekly status reviews. Input the tasks, set durations and dependencies, screenshot the result, paste into the slide. Five minutes start to finish.
For ongoing programs that need dependency tracking, milestone reports, baselines, and stakeholder dashboards at scale, use a dedicated tool. Office Timeline for clean PowerPoint exports. TeamGantt for collaborative web Gantts. Smartsheet for spreadsheet-native teams. MS Project for enterprise schedules with resource leveling.
For the project workspace where the work actually gets done, that is the layer Rock fills. Each task on the Gantt becomes a Rock task with an owner, a status, and a chat thread next to it. The team chat sits next to the tasks. When a critical-path task slips, the conversation, the dependency, and the status update happen in the same space, not across three tools.
"The bars on the chart are the easy part. The work that goes into them is the hard part. The Gantt is most useful when the team has agreed on what they are looking at before anyone draws a single bar." - Nicolaas Spijker, Marketing Expert
Two failure modes to watch. First, the team treats the Gantt as the project plan. The Gantt is the visualization. The plan is the underlying scope and dependencies. Build the WBS first, the dependencies second, the Gantt last. Second, the team builds the Gantt once at kickoff and never updates it.
By month two, the chart no longer matches the project. Update at every phase boundary, every scope change, and any time a critical-path task slips. The today line is the cheapest update of all and the one that keeps the chart trustworthy.
FAQ
What are the 3 main components of a Gantt chart?
The timeline axis (days, weeks, or months across the top), the task bars (horizontal bars showing duration and position in time), and the dependencies (arrows or vertical alignment showing what blocks what). Most modern Gantt charts add three more: milestones (diamond markers for major events), the today line (vertical marker for current date), and a critical-path overlay (color highlighting the longest dependency chain).
How do I make a Gantt chart in Excel?
Build a table with task name, start date, duration, and dependency columns. Insert a stacked bar chart and use the start date as the invisible first series and duration as the visible bar. Reverse the axis so the first task is at the top. Excel does not auto-compute the critical path, so add a column for float manually or use a template. The widget at the top of this page does the same job without the spreadsheet gymnastics.
What is the purpose of a Gantt chart?
A Gantt chart visualizes when each task in a project happens on a calendar, and how the tasks connect through dependencies. Its main jobs are communicating the schedule to stakeholders at a glance and tracking progress against the planned dates. It is a visualization layer on top of the underlying project plan, not a replacement for it.
What are the disadvantages of a Gantt chart?
Gantt charts assume single-point duration estimates, ignore resource constraints unless leveling is added separately, become unwieldy past about 50 bars, and need constant updates to stay accurate. They communicate plans well but track real-time progress poorly, and a Gantt that is not maintained becomes wallpaper within a month.
Is a Gantt chart agile or waterfall?
Traditionally waterfall. Inside an agile sprint, a Gantt is overkill. But at the program level, where multiple agile teams have hard cross-team dependencies (release trains, hardening sprints, fixed launch dates), Gantt-style schedules still apply. The activities are epics and integration milestones rather than user stories. The Scaled Agile Framework calls this the program board.
Who invented the Gantt chart?
Henry Gantt developed the modern bar-chart format around 1910 to 1915, originally for industrial production scheduling. The Polish engineer Karol Adamiecki published a similar concept (the "harmonogram") in 1896, but his work was published in Polish and Russian and went unnoticed in the West. The chart is named for Gantt, but Adamiecki published first.
The right project tool keeps the schedule and the team conversation in the same place. Rock turns each Gantt task into a workspace task with owners, status, and chat next to it. One flat price, unlimited users, clients included. Get started for free.
