How to make a Gantt chart?

Most projects don’t fail because the work is hard. They fail because no one can see how the work fits together. Tasks live in rows, dates float in cells, and dependencies exist only in someone’s head. A Gantt chart replaces that guesswork with a visual timeline that shows what happens when.

Luckily, you don’t have to build one from scratch. Templates take care of the structure and formatting, letting you focus on the schedule itself instead of wrestling with setup.

This guide breaks down the steps behind a solid Gantt chart so you understand what you’re building. But, if you want a head start, grab the free Excel and Google Sheets templates on our Gantt chart template page.

Before making a Gantt chart

Most Gantt charts go sideways because they’re built too early. Planning first keeps the chart grounded, which is the same approach Wrike encourages: Define the work, then visualize it.

Clarify project scope and objectives

Before you list a single task, get clear on what you’re actually trying to deliver. Start by writing down what the project is responsible for delivering and where the boundaries are. What does success look like? What is explicitly out of scope? Timeline expectations, budget limits, and approval constraints all belong here. Even the best Gantt chart can’t compensate for unclear goals.

Break the work into tasks and subtasks

Once you know the target, you can start outlining the work required to achieve it. List all the work required to deliver the project, then break larger efforts into subtasks. If something feels vague or spans weeks, it probably needs to be split. This level of detail exposes dependencies early and prevents important work from being hidden inside catch-all tasks.

Estimate durations and assign clear owners

Now comes the part that people tend to rush and regret later. You should estimate task durations using past projects, then assign one owner per task. Shared ownership usually means delayed decisions and missed handoffs. Knowing who is responsible and how long the work should take is essential before placing anything on a timeline.

Map dependencies and set milestones

Here’s where your Gantt chart starts earning its keep. Identify which tasks must finish before others can begin. These dependencies determine the structure of your Gantt chart and show where delays will cascade. Then, define key milestones to mark significant progress points.

How to make a Gantt chart in Excel (Step by step)

Excel doesn’t advertise itself as a project management tool, but with the right setup, it can produce a perfectly usable Gantt chart. The key is to use a stacked bar chart and structure your data so that Excel does the visual work for you.

Step 1: Set up your task table

Before creating charts, we need to get the data right. Start with a simple table. You’ll need, at minimum:

Task name
Start date
Duration (in days)

Avoid using end dates at this stage. Duration gives you more flexibility when dates shift (and they will). Keep tasks in the order you expect them to run, even if you plan to refine dependencies later.

Step 2: Insert a stacked bar chart

Once your table is ready, select the “Start Date” and “Duration” columns. Then, go to “Insert” → “Bar Chart” → “Stacked Bar.” Excel will generate a chart that looks wrong. That’s expected. Right now, it’s just reading the numbers.

If Excel places tasks on the wrong axis, use “Switch Row/Column” until task names appear on the vertical axis.

Step 3: Hide the start date bars

This step is where the chart turns into a Gantt chart. The start date bars exist solely to position each task correctly on the timeline. Click the “Start Date Series,” open “Format Data Series,” and set the fill to “No Fill.”

The start date bars still exist, but they’re invisible. Their only job is to position each task correctly on the timeline, leaving the duration bars visible.

Step 4: Fix the date axis

Now make the timeline readable. Right-click the horizontal axis and open “Format Axis.” Set the minimum bound to your project’s actual start date. Adjust the major units to days or weeks, depending on the project length.

This step matters. A poorly scaled axis makes even a well-built Gantt chart hard to read.

Step 5: Reverse task order for readability

By default, Excel lists tasks from bottom to top, which feels backwards. Right-click the task axis, open “Format Axis,” and check “Categories in Reverse Order.” This puts the first task at the top, where people expect it.

Step 6: Clean up the chart

Remove unnecessary chart elements, such as legends, if they don’t add value. Adjust bar spacing so tasks are easy to distinguish. Use consistent colors and avoid heavy formatting that makes updates more difficult later.

A Gantt chart is a working tool, not a slide.

Step 7: Update and maintain the chart

When dates change, update the “Start Date” or “Duration” values in the table. The chart will adjust automatically. This is why planning and structure matter more than visual polish.

Excel Gantt charts are most effective for smaller projects or static plans. As complexity increases, manual updates and hidden dependencies become increasingly difficult to manage, which is where dedicated tools really start to earn their value.

How to make a Gantt chart in Google Sheets

Google Sheets gives you two solid paths: the classic stacked bar chart (more control, more set-up options) and the newer timeline view (faster, cleaner, fewer knobs). If you’re building something you’ll maintain and adjust, stacked bars hold up better. If you need a readable schedule fast, timeline is hard to beat.

Stacked bar method

If you want the Gantt chart to behave like a spreadsheet-driven tool, start here.

1) Set up your data table
Create columns like:

Task
Start date
End date (or duration, depending on what you have)

If you have an end date, add a duration (days) column. A common formula is:

=End-Start

If you want the bar to include both the start and end dates (typical for day-based plans), use:

=End-Start+1

2) Insert the stacked bar chart
Select “Task,” “Start date,” and “Duration” (not “End date”), then go to “Insert” → “Chart.” In the Chart editor, set “Chart type: Stacked bar chart.”

If Sheets guesses wrong (it often does), just force the chart type. Also, make sure your Task labels are being used as the categories.

3) Hide the “Start date” series
This is the move that turns a stacked bar into a Gantt chart. The start date series is only there to offset the taskbar along the timeline.

In the Chart editor:

Go to “Customize” → “Series”
Choose the “Start date” series
Set the fill color to transparent (or match the background), so it disappears

Now, only the duration bars are visible, positioned correctly on the timeline.

4) Make the timeline readable
Got to “Customize” → “Horizontal axis,” and adjust formatting so dates are clear. If the axis range is awkward (too zoomed out, too cramped), your data range is usually the cause. A practical fix is to:

Ensure start dates are real date values (not text)
Avoid blank rows in the chart range
Keep your project window tight (don’t include stray dates months away)

5) Put tasks in a sensible order
Sheets will display tasks in the order they appear in your table. If it appears backwards, reorder the rows in the sheet rather than adjusting chart settings. It’s simpler, and it keeps the chart predictable when you add tasks later.

Timeline feature

If you’re trying to get out of spreadsheet jail quickly, this is the quickest exit.

1) Prep a simple table
Timeline works best with:

Task
Start date
End date

Setting an owner, status, or project/category is optional but useful.

Make sure the date columns are formatted as dates. Timeline is picky about date-looking text.

2) Insert a timeline
Select your table, then go to “Insert” → “Timeline.” Sheets will automatically generate a timeline view.

From there, you can:

Adjust the visible time range (days, weeks, months)
Group or color by fields like owner/project (depending on your setup)
Filter to show a subset of work

NOTE: The timeline is not ideal for managing dependencies. You won’t get real dependency handling, and formatting is intentionally limited. Treat it like a clean schedule view, rather than a comprehensive planning system.

Which one should you use?

If the plan is going to change frequently, the stacked bar setup is more durable because it’s driven by your data model (start + duration). If you need something fast that looks good for sharing updates, Timeline is the better option, as long as you’re not relying on it to manage dependencies.

How to make a Gantt chart in Wrike

At a certain point, spreadsheets stop saving time and start consuming it. As tasks multiply and dependencies stack up, keeping a Gantt chart accurate becomes an arduous maintenance job. Wrike handles this differently by tying the Gantt chart directly to the work, which makes it easier to manage once projects get complex.

Start with tasks

Instead of building a chart first, you begin by defining the work. Create tasks, organize them into folders or projects, and assign owners. Each task includes start and due dates, so the Gantt chart forms automatically from real project data. That means you’re not formatting bars or fixing formulas — you’re actually planning the project.

Add dates and dependencies

Once tasks exist, setting dates is straightforward. Wrike places each task on the timeline as soon as dates are added. Dependencies are created by linking tasks directly in the Gantt view, which shows which work must be completed before another task can begin. When a date changes, dependent tasks shift accordingly, without requiring manual recalculation.

Use milestones to mark key checkpoints

Not every important moment in a project has a duration. Wrike lets you mark tasks as milestones, which appear as distinct points on the Gantt chart. These are useful for approvals, launches, or handoffs, giving you visibility into progress without overloading the timeline.

Adjust the plan without rebuilding it

When priorities change, you can drag tasks on the Gantt chart to reschedule them, shift entire phases, or rebalance workloads. Because dependencies and ownership are already defined, the schedule updates automatically. The chart stays accurate without needing to be rebuilt from scratch.

Know when a dedicated tool is the better choice

If your project has a handful of tasks and a few changes, a spreadsheet may be enough. Once you’re managing multiple dependencies, frequent updates, or cross-functional teams, the overhead quickly adds up. Wrike’s Gantt chart works best when the project itself is the source of truth, rather than a separate file that constantly requires updates.

Best practices for effective Gantt charts

A Gantt chart shows its weaknesses the moment something changes. A date slips, a dependency breaks, and suddenly the plan unravels. The difference comes down to how the chart is built and maintained.

The following are the best practices for effective Gantt charts:

Keep tasks small enough to manage: Break work down so progress is visible, and delays surface early. Smaller tasks make dependencies easier to spot and timelines easier to adjust.
Plan around durations: When everything is driven by end dates, even small changes can cause significant recalculations. Focusing on durations also makes resource conflicts easier to see when work overlaps.
Be selective with dependencies: It’s tempting to link everything to everything else. Don’t. Only add dependencies where work cannot start until something else is finished.
Make ownership explicit: Every task needs one clear owner, even if multiple people contribute. Shared ownership often means delayed decisions and fuzzy accountability.
Use milestones as signals: Milestones work best when they mark real decision points, such as approvals, launches, or handoffs. Too many milestones make it harder to spot what matters.
Treat the chart as a living plan: A Gantt chart that isn’t updated quickly becomes misleading. When dates or priorities change, update the chart immediately.
Choose the right tool for the job: Spreadsheets are fine for simple plans. As dependencies and change frequency increase, manual upkeep becomes the bottleneck. Use a tool that supports rescheduling and collaboration.

Common mistakes to avoid

A Gantt chart can be technically correct and still useless. It can show dates, bars, and dependencies, and somehow explain nothing about what’s actually happening. That usually isn’t bad luck or bad software, but a collection of common mistakes. These include:

Turning the Gantt chart into a giant to-do list: If everything is a bar, nothing stands out.
Dependency spaghetti: Link only what’s truly blocked, or one small change will detonate the whole schedule.
Best-case durations: Hope is not a planning method. Use real history, and add a buffer where risk is known.
Week-long “miscellaneous” tasks: Vague work slips quietly. Split it until the outcome is obvious.
Tasks with no owner: “We’re on it” often means no one is on it. One task, one accountable person.
A chart that never gets updated: The plan diverges, people continue to follow the picture, and confusion prevails.
Formatting tricks you can’t maintain: Clever formulas and color-coding are cute, but make sure they’re usable and realistic.
Using spreadsheets for projects that behave like systems: Lots of dependencies + frequent change = unnecessary manual upkeep.

Make the Gantt chart work for you

Whatever tool you choose, the principles remain the same. Plan the work first, build realistic timelines, keep ownership clear, and update the chart as the project evolves. Do that consistently, and your Gantt chart becomes a reliable planning tool your team will thank you for.

For smaller or more predictable projects, Excel or Google Sheets can be enough. With the right structure, they provide a clear timeline and a solid foundation for planning. As projects grow and change more often, the time spent maintaining a spreadsheet-based Gantt chart adds up quickly.

That’s where dedicated software like Wrike starts to make sense. When tasks, dates, and dependencies are all in one place, the Gantt chart remains accurate without requiring constant manual effort.

FAQs

How long does it take to build a basic Gantt chart?

If the project is already planned, a basic Gantt chart takes 30–60 minutes to build in Excel or Google Sheets. Most of the time is spent defining tasks and dependencies rather than creating the chart itself.

Do I need special software, or is Excel/Google Sheets enough?

Spreadsheets are enough for small or stable projects with few dependencies. Once plans start changing frequently or involve multiple people, dedicated tools reduce manual updates and errors.

What’s the difference between a Gantt chart and a simple project timeline?

A project timeline shows when things happen. A Gantt chart shows how tasks depend on each other and what breaks when dates move.

How detailed should my Gantt chart be?

It should be detailed enough to make progress and delays visible, but not so granular that maintenance becomes the work. If a task hides risk or spans weeks, it’s too large.

How often should I update my Gantt chart?

Update it whenever dates, scope, or dependencies change. If the chart doesn’t reflect current reality, it ceases to be a useful planning tool, but tools like Wrike update Gantt charts automatically.