Link task dependencies

A task list without dependencies is just a checklist; a task list with dependencies is a schedule. The arrows you draw between tasks are what let the Gantt chart compute the critical path, what surface scope creep when you compare to a baseline, and what let MS Project imports come across with the original logic intact. Wiring them is a five-second action per link, but the discipline of wiring them at all is what separates projects that finish on time from projects that surprise everyone.

The four link types

Onplana supports the four standard dependency types, the same set you know from Microsoft Project:

• Finish-to-Start (FS): the predecessor must finish before the successor starts. This is the default and covers most real cases.
• Start-to-Start (SS): the successor cannot start until the predecessor has started. Useful for work that runs in parallel after a shared kickoff.
• Finish-to-Finish (FF): the successor cannot finish until the predecessor finishes. Useful for activities that must wrap up together.
• Start-to-Finish (SF): the successor cannot finish until the predecessor starts. Rare, but it exists for shift-handover style work.

Lag and lead time

Every link takes an optional Lag value in days. A positive lag adds a waiting period (“start two days after the design finishes”); a negative lag is lead time, letting the successor overlap the predecessor by that many days. Links with lag show the offset next to the type, for example FS +2d.

Link two tasks

1. Open the task and find its dependencies section. It has two lists: Predecessors (tasks this one waits on) and the tasks blocked by this one.

2. Pick the other task, choose the link type (FS, SS, FF, or SF), and set a lag in days if you need one. Lag defaults to 0.

3. Add the link. It immediately appears on both tasks and as an arrow on the Gantt chart.

Circular dependency protection

Onplana refuses any link that would create a loop. If task A waits on B, and B waits on C, then linking C to wait on A would mean nothing can ever start; the app rejects it with the message “This dependency would create a circular chain”. The check walks the whole dependency graph, so it catches indirect loops through any number of intermediate tasks, not just direct A-to-B-to-A pairs.

Note

On extremely large dependency graphs the safety check itself has a limit (500 tasks in the walked subgraph by default). If you hit this, your schedule likely has more linkage than it needs, the app asks you to simplify rather than risk validating with stale data.

Best practices

1. Default to Finish-to-Start; reach for the others only when needed. FS is the type ~95% of real-world dependencies should be. SS, FF, and SF exist for real cases but are often picked for “looks right at the moment” reasons that don’t survive a replanning session. If you can describe the dependency as “X must finish before Y starts,” it’s FS.
2. Use lag for handovers, not slack. Positive lag is for real waiting time (curing concrete, regulatory cooling-off, batch processing). Don’t use lag to “buy yourself room”, pad the task’s own estimate instead, where it shows up in the capacity math.
3. Wire dependencies before capturing the baseline. The baseline records the dependency graph along with the dates. If you capture a baseline first, then wire dependencies, the baseline doesn’t have the structure it needs to be useful for drift detection. Order: tasks → estimates → dependencies → baseline.
4. Treat circular-chain rejections as a planning bug, not a tool bug. When Onplana rejects a link as circular, the schedule has a logic problem: somewhere in the chain you already established Z → A, and you’re now trying to add A → Z. The fix is to reconsider which dependency is real and remove the redundant one.

Troubleshooting / common pitfalls

• My dependency picker is empty. The picker only shows tasks from the same project. Cross-project dependencies are not supported in this UI; for cross-project sequencing, use milestones as the handoff points (one milestone per project, marked done when the project hands off).
• The arrow on the Gantt looks wrong. Common cause: the lag is negative when it should be positive (or vice versa). Open the link in the task’s edit view and check the lag sign. Onplana renders lag positions on the arrow itself, so the visual cue is consistent.
• I added an FS link but the successor still has a date before the predecessor finishes. Dependencies are a recorded constraint, not auto-scheduling. The Gantt highlights the conflict (the arrow turns red) but doesn’t move the dates for you. Either drag the successor forward, or use the Auto-Schedule button on the Gantt to propagate dates against the constraint graph.
• Onplana rejected a link as “circular” but my plan is small. Walk the chain backward from the task you’re trying to add the link to. The cycle is usually two or three hops out and easy to miss, Onplana’s check catches indirect loops, not just direct A-to-B-to-A.
• “GRAPH_TOO_LARGE” error. The cycle check is bounded at 500 tasks in the walked subgraph. If your schedule has linkage going through a thousand tasks, the project probably has more dependencies than it needs, collapse pass-through chains (A → B → C where B has no real work) into direct links.

How this combines with other features

• Dependencies + Gantt. The Gantt is where dependencies become visible; the dependency arrows make schedule conflicts obvious in seconds. The Gantt also exposes the critical path (computed from dependencies), which is the only useful signal for deciding which task slippage matters. See Plan on the Gantt chart.
• Dependencies + Baseline. Capture a baseline once dependencies are wired and dates feel right. The baseline records the dependency structure, so a later “the critical path changed” question can be answered against the original plan, not just the current state. See Capture and compare baselines.
• Dependencies + Auto-Schedule. The Gantt’s Auto-Schedule button reads the dependency graph (types + lag + working calendar) and propagates earliest-start dates from project start. Useful after a major replanning session when you’ve moved several tasks manually and want the cascade computed for you.
• Dependencies + Import. .mpp and Project Online imports preserve the dependency graph with link type and lag intact. After import, the Gantt’s critical path computation matches what you would have seen in MS Project. See Import from Microsoft Project.

Coming from another tool

Tool	Dependency mapping
Microsoft Project	Same four link types (FS/SS/FF/SF) and lag-in-days convention
Asana	Asana has FS only; SS/FF/SF imports map to FS in Asana, but Onplana preserves the original
Jira	Jira issue links (“blocks”, “is blocked by”) map to FS dependencies in Onplana
ClickUp	Same four link types; ClickUp lag is in working days, same as Onplana
Primavera P6	Identical four link types + lag; .xer imports preserve all four

FAQs

Do dependencies move dates automatically? No. A dependency is a recorded constraint, not an auto-scheduler. The Gantt chart draws the arrows so conflicts are visible, and you decide how to reschedule. The Auto-Schedule button on the Gantt does the mass propagation when you want it.

Are dependencies imported from Microsoft Project? Yes. Links from an imported plan come across with their type and lag intact. See Import from Microsoft Project.

Can I link tasks in different projects? The dependency picker offers tasks from the same project, so links are created within one project. For cross-project sequencing, track the relationship at the milestone level in each project.

What’s the maximum lag I can set? There’s no hard upper limit; the value is days. Practical lag is usually 0-30 days. If you find yourself setting a 90-day lag, the “waiting time” probably deserves to be its own task instead.

Can I bulk-create dependencies? Not from the UI today. The MCP API supports link_dependency calls which let connected AI agents wire dependencies in bulk based on patterns you describe. See Connect an external agent.

Why is my critical path empty after I wired dependencies? The critical path is computed from the entire dependency graph; if no task has both a predecessor and a successor (i.e., the graph is a loose forest, not a connected tree), there’s no chain to compute. Wire dependencies through the schedule and the path appears.

Can I see all dependencies in a list? The Gantt is the strongest visual surface for the full graph. The list view of each project doesn’t yet have a “Dependencies” column, but every task’s edit view shows its predecessors and successors inline.

Related

• Plan on the Gantt chart, where the arrows live visually
• Capture and compare baselines, the right next step after wiring dependencies
• Import a Microsoft Project file, bring dependencies in from an existing plan