---
title: 'How to Use Airtable Timeline and Gantt Views for Project Scheduling'
description: 'Build Airtable project schedules with Timeline and Gantt views — date fields, dependencies, critical path, grouping by team, and automations that keep dates in sync.'
canonical_url: 'https://www.business-automated.com/tutorials/airtable-timeline-gantt-views-guide'
md_url: 'https://www.business-automated.com/tutorials/airtable-timeline-gantt-views-guide.md'
last_updated: 2026-06-25
---

A Gantt chart is the project manager's spreadsheet. Without one, a team has tasks and dates floating in a list. With one, they have a schedule — bars on a timeline, arrows showing what blocks what, a critical path showing where slippage costs the deadline. [Airtable's](/airtable-consultant) Timeline and Gantt views give you that schedule on top of a real relational database, so the schedule and the data behind it never drift apart.

This guide covers how Airtable Timeline and Gantt views work in 2026, the field setup behind them, how to add dependencies and milestones, and the schedule patterns we deploy for agency, construction, and product launch projects.

## Timeline vs Gantt: One View, Two Layouts

Airtable used to have two distinct view types — Timeline and Gantt — with overlapping features. In 2026, the platform consolidated most functionality into the Timeline view with a switchable layout. You pick **Standard layout** for grouped horizontal bars on a calendar, or **Gantt layout** for dependency arrows, milestones, and critical path.

The Gantt view as a separate view type still exists for backward compatibility but new bases default to Timeline with the Gantt layout option. Functionally, you can think of them as a single view with a toggle.

| Layout            | Best for                                 | Required fields                              |
| ----------------- | ---------------------------------------- | -------------------------------------------- |
| Timeline standard | Editorial calendars, multi-team roadmaps | Start + End date, optional group field       |
| Gantt layout      | Project schedules with task dependencies | Start + End date, self-linked Dependencies   |

For a broader survey of every view type in Airtable, see our [custom views guide](/tutorials/airtable-custom-views-guide).

## Prerequisites: Date Fields and Self-Links

Every Timeline or Gantt view needs three things:

1. **A Start Date field.** Date type, no time component unless your tasks span hours.
2. **An End Date field.** Same date type as Start. Airtable refuses to use mismatched formats.
3. **For dependencies — a self-linked record field.** A field on the Tasks table that links back to Tasks. This stores predecessor/successor relationships.

A common mistake is using one Date field and a Duration formula to compute the End Date. That works, but the Gantt layout cannot drag the end of the bar to extend a task — the formula owns the value, not the user. Use two real Date fields and let a separate formula compute Duration if you need to display it.

Optional but recommended:

- A **single-select Phase field** for grouping (Discovery, Build, Launch).
- A **collaborator Owner field** for assignment.
- A **single-select or checkbox Milestone flag** for zero-duration markers.
- A **percent Progress field** for in-bar progress fills.

## Step 1: Create the Timeline View

From a Tasks table with Start Date and End Date fields:

1. Click **+** in the view sidebar.
2. Choose **Timeline**.
3. Name the view (e.g. `Project Schedule — Gantt`).
4. Pick the Start and End date fields when prompted.
5. Choose a Group-by field (Phase, Project, or Team).
6. Click **Done**.

You land on a horizontal calendar with one bar per record. The default zoom is week-level — scroll horizontally to move through time, or use the **Zoom** control to switch to day, month, or quarter views.

## Step 2: Switch to Gantt Layout (When You Need Dependencies)

Open the view's settings panel and find **Layout**. Choose **Gantt**. The view shifts so each record gets its own row, with the bar positioned by Start and End dates. Records without dates appear in a sidebar; drag them onto the timeline to schedule them.

The Gantt layout adds three things the standard Timeline layout does not have:

- **Dependency arrows** between linked tasks.
- **Critical path highlighting** once enough dependencies are set.
- **Milestone diamonds** for zero-duration markers.

If you do not need any of these, stick with the standard layout — it scales to more records per screen because it stacks bars into lanes.

## Step 3: Configure Dependencies

Add a linked record field on the Tasks table that points to Tasks (self-link). Name it `Predecessors` or `Successors` depending on which direction you want to author dependencies. Most teams use Predecessors — you set the field on Task B to list "Task A," meaning Task A must finish before Task B starts.

In the Gantt layout settings, expand **Dependencies** and select that linked field. Airtable now draws arrows between bars. The base of the arrow sits at the predecessor record; the head points to the successor.

You can also draw dependencies visually. Hover over a bar's edge and a connector dot appears. Drag from that dot to another bar and Airtable creates the dependency for you — no need to open a record to set the field manually.

| Dependency type | Meaning                                            | When to use                                  |
| --------------- | -------------------------------------------------- | -------------------------------------------- |
| End-to-Start    | Successor starts when predecessor ends (default)   | Most software and creative work              |
| Start-to-Start  | Successor starts when predecessor starts           | Parallel work that must launch together      |
| End-to-End      | Successor ends when predecessor ends               | Sync deadlines across coupled deliverables   |
| Start-to-End    | Successor ends when predecessor starts (rare)      | Phased handoffs (one stops as another opens) |

## Step 4: Enable Date Auto-Shift

This is the feature that separates a static Gantt chart from a live project schedule. Without it, moving Task A later does nothing to Task B. With it, Task B and every task downstream of B shift by the same amount automatically.

Open the linked dependency field's configuration. Toggle **Date dependencies** on. Choose the default relationship type (usually End-to-Start). Save.

Now drag Task A two weeks to the right. Every successor cascades. Drag it back and they cascade back. This is the daily-driver behavior for most project managers — but turn it off if your team negotiates each date manually, because the cascade can be aggressive.

For Airtable's full documentation on this behavior, see [Date dependencies in Airtable](https://support.airtable.com/docs/date-dependencies-in-airtable).

## Step 5: Mark Milestones

Milestones are zero-duration markers — a launch date, a contract signing, a review checkpoint. They appear as diamonds rather than bars on the Gantt layout.

Add a checkbox field called `Milestone` to the Tasks table. In the Gantt view's record settings, choose this field as the milestone flag. Tick the box on any record where Start Date equals End Date and you want a diamond marker.

A typical project has 5-15 milestones — kickoff, design approval, build complete, UAT sign-off, launch. They give the schedule a heartbeat that the team can rally around without poring over every bar.

## Step 6: Surface the Critical Path

Once dependencies are configured, Airtable computes the critical path automatically — the longest chain of dependent tasks that determines the project's earliest possible end date. Tasks on the critical path are highlighted (usually red); tasks off the critical path have float.

Use the critical path to focus management attention. A task with two weeks of float can slip a few days without consequence. A critical-path task that slips one day pushes the launch one day. The two deserve very different levels of escalation.

## Real-World Schedule Patterns

Four schedule templates we deploy in client projects.

### Agency Project Schedule

Table: `Tasks`. Linked to `Projects`, `Clients`, and `Owner`. Single-select Phase: Discovery, Design, Build, QA, Launch. Self-linked `Predecessors`. End-to-Start dependencies with auto-shift on. Group by Phase, sort by Start Date.

Each project lives in one Gantt view filtered to that project. A separate `All Projects` Timeline view groups by Project to show every active engagement on one screen. The PM uses the per-project Gantt for daily coordination; the agency principal uses the all-projects Timeline for resource planning.

Combine this with our [project management tutorial](/tutorials/airtable-project-management) for the full setup.

### Content Calendar (Timeline Standard)

Table: `Content`. Linked to `Channels` and `Authors`. Start Date = Publish Date − write time. End Date = Publish Date. Group by Channel (Blog, Newsletter, Social). No dependencies needed — articles are independent.

The Standard Timeline layout shines here because grouping by Channel produces clean horizontal lanes per channel. The editor sees a month at a glance and spots scheduling gaps. Slide a bar to reschedule the publish date and an automation updates the linked publishing platform.

### Construction Project Schedule

Table: `Activities`. Linked to `Trades`, `Subcontractors`, and self-linked `Predecessors`. Phases: Sitework, Foundation, Framing, MEP, Finishes, Inspections. Date dependencies on. Critical path enforced.

Construction is the canonical Gantt use case because nearly every activity blocks another — you cannot frame until the foundation cures. Group by Trade so the GC sees each sub's workload separately. A Milestone field flags inspections, draw-ready dates, and substantial completion. Rollups on the Projects table show critical-path duration and earliest completion date.

### Product Launch Schedule

Table: `Workstreams`. Linked to `Launch` and self-linked Predecessors. Group by Team (Eng, Marketing, Sales, Support, Legal). Each workstream has 5-15 tasks; the launch milestone is the convergence point.

The Gantt layout shows every team's contribution flowing toward the launch date. Cross-team dependencies (Marketing cannot finalize messaging until Eng confirms feature scope) become arrows that surface coordination needs. A separate Interface dashboard rolls up percent-complete by team for the launch lead.

For the dashboard setup, see our [Interface Designer guide](/tutorials/airtable-interface-designer-guide).

## Grouping, Filtering, and Coloring

The three controls that make a Timeline scannable.

**Grouping.** Group by Team, Phase, Project, or Owner. Each group becomes a horizontal section on the Timeline. Without grouping, 50 bars stack into a wall.

**Filtering.** Always filter to active work. `End Date >= today` hides completed tasks. `Project = current project` keeps a per-project view focused. For a portfolio-level Timeline, filter to active projects only.

**Coloring.** Color by Phase, Owner, or Status. The standard pattern is color-by-Phase so each project section visually matches the others — Discovery bars are blue, Build bars are green, Launch bars are red. Conditional coloring (red if End Date < today and Status != Done) flags overdue tasks instantly.

## Automations That Keep the Schedule Honest

A Gantt chart goes stale fast without automation. Three patterns that keep it honest.

| Trigger                                       | Action                                                          |
| --------------------------------------------- | --------------------------------------------------------------- |
| Task End Date < today AND Status != Done      | Notify Owner in Slack, flag record as overdue                   |
| Milestone hit (Status = Done)                 | Post to launch channel, update project's `Last Milestone` field |
| Critical-path task slips by more than 3 days  | Email project manager with cascade summary                      |

Use **When record matches conditions** triggers rather than **When updated** so the automation fires only on the precise transition. See our [automation guide](/tutorials/airtable-automation-guide) for the full pattern catalog.

## Common Mistakes

Five issues we fix on most rescue projects.

**Using one date field and a duration formula for End Date.** The formula owns the value, so you cannot drag the bar's end. Always use two real date fields.

**Linking dependencies to the wrong field type.** Dependencies must be a self-linked record field on the same table. Linking to a separate Tasks table or using a single-select instead breaks the Gantt layout's arrow rendering.

**Not grouping the Timeline.** A view with 80 tasks and no grouping is one giant wall. Group by Phase, Team, or Project and the view becomes scannable.

**Auto-shift on when the team negotiates dates.** If every move on the chart cascades downstream, the schedule starts arguing with the team. Turn auto-shift off until the team is ready for it.

**Treating milestones as tasks.** A two-day "Launch" task with start and end dates is not a milestone. Use the checkbox flag and set Start = End so it renders as a diamond.

## Troubleshooting

Quick fixes for the issues that come up most often.

- **Bars do not appear on the Timeline.** The record has no Start Date or no End Date. Add both dates; the bar shows up immediately.
- **Dependency arrow is missing.** Confirm the dependency field is a self-linked field on the same table, not a link to a separate Tasks-2 table.
- **Critical path is not highlighted.** Critical path requires at least one chain of two or more dependent tasks. With only independent tasks, every task is its own critical path and Airtable does not color them.
- **Drag-to-reschedule is locked.** The view is read-only or shared via a read-only link. Open the editable collaborator view.
- **End Date is before Start Date.** Airtable refuses to render reversed bars. Fix the dates first; the bar appears once the order is correct.

## When to Choose Something Else

Airtable Gantt is excellent for projects with up to a few hundred tasks and moderate dependency complexity. For larger or more specialized workloads, other tools fit better:

| Project type                              | Better tool                       |
| ----------------------------------------- | --------------------------------- |
| Construction with thousands of activities | Microsoft Project, Primavera P6   |
| Agile sprint planning                     | Jira (with roadmap add-on)        |
| Resource-leveled production schedules     | Smartsheet, Microsoft Project     |
| Multi-project portfolio with rollups      | Asana, Monday.com, or Airtable + Interface dashboards |

For most agency, marketing, content, and product launch work, Airtable Gantt is the right fit because the schedule is one tab of a larger system that also holds clients, budgets, and deliverables.

## Where to Go Next

Timeline and Gantt views are most powerful when paired with the rest of the Airtable stack. Pair them with a project management base built on [linked records](/tutorials/airtable-linked-records-explained), expose schedule status to clients through an [Interface dashboard](/tutorials/airtable-interface-designer-guide), and add automations that nudge owners when their tasks slip.

For the official Airtable spec, see the [Timeline view documentation](https://support.airtable.com/docs/timeline-view-overview) and the [Gantt layout reference](https://support.airtable.com/docs/gantt-layout-in-timeline-view).


## Sitemap

See the full [sitemap](/sitemap.md) for all pages.