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.

One pair of tasks can carry more than one link. Design and build that kick off together and must also land together is genuinely two relationships, so you add an SS and an FF between the same pair and the scheduler honours both. What Onplana refuses is the same type twice on one pair, which is a duplicate rather than a second relationship: that comes back as “A dependency of this type already exists between the selected tasks.”

Lag and lead time

Every link takes an optional Lag. 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 much. Links with lag show the offset next to the type, for example FS +2d.

Type the lag in days, hours or weeks: pick the unit beside the Lag box. A week is five working days, and a day is the project’s working day. Onplana keeps the lag as working time, not as the unit you typed, so a lag that is a whole number of days reads back in days and anything finer reads back in hours. A lag typed as 2 weeks reads back as 10 days, and 4 hours stays 4 hours.

You set the lag in two places:

• On the Gantt chart: double-click an arrow, or right-click it and choose Edit dependency…. The Edit dependency box has the link’s Type and its Lag with the unit beside it. Save moves the tasks that follow.
• In the task form: the lag box and unit on each row of the dependencies section (see Change a link’s type or lag).

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, hours or weeks if you need one. Lag defaults to 0.

3. Add the link. It immediately appears on both tasks and draws as an arrow on the Gantt chart, whatever its type: the arrow leaves the predecessor’s start or finish and reaches the successor’s start or finish, so FS, SS, FF, and SF links each read the way they work. A printed or saved PDF of the chart draws finish-to-start arrows only; its footer counts the other links it left out.

Type links into the Predecessors column

On the Gantt, the Predecessors column lists each task’s links by row ID, the way Microsoft Project and Onplana Schedule write them, for example “3FS+2d, 5SS”. You can type into it to add, change or remove a task’s links in one go.

1. Open the project’s Gantt, open View > Columns and turn on Predecessors. Turn on ID too, so you can see each row’s number.

2. Click the task’s Predecessors cell and type its links, separated by commas. Each link is the row ID, an optional type (FS, SS, FF or SF; leave it out for finish-to-start) and an optional lag in d, h or w, such as “3FS+2d”, “5SS” or “7FF-4h”.

3. Press Enter, or click away, to save. Esc puts the cell back as it was.

What to expect:

• The cell is the whole list. A link you leave out is removed, a link you change is changed, and a new row ID is added. A link that is already there with the same type and lag is left alone.
• One edit, one Undo. However many links an edit changes, a single Undo, labelled “Undo predecessors change”, puts them all back.
• A refused edit stays in the cell. If Onplana cannot take what you typed, the cell keeps your text with a red outline and a warning icon; point at it to read why, such as “No task has the ID 12.”, “A task cannot follow itself (ID 4).” or a circular chain. Fix the text and save again, or press Esc. If part of an edit was saved before the refusal, that part stays, and Undo takes it back.
• Links to other projects are not shown. A predecessor in another project has no row ID here, so the cell neither shows it nor removes it. It stays on the task’s dependencies section.
• The column is saved in your Gantt views, like the other columns.

Editing the column needs the Manage task dependencies permission. By default the project’s owners, managers and members have it, and contributors and viewers see the column read only. Organization admins can always edit it.

Remove a link

The reliable way is the same place you created it, and it differs between the web app and the desktop app.

1. In the web app, open either task, expand More in the properties rail, and use the remove button on the link’s row under Predecessors or Successors. The link disappears from both tasks at once, because a dependency is one record shared between them. While More is folded it lists what it holds, so you can confirm Dependencies is in there before opening it.

2. In Onplana Schedule, edit the Predecessors cell in the grid and delete the entry, the same way you would in Microsoft Project. The Task details panel deliberately does not repeat the control: predecessors live in the grid, where they already edit.

You can also delete a link on the chart itself. Click the arrow to select it, and a round red delete button appears on the successor’s bar, at the end the arrow attaches to. The button is not on the arrow you clicked, so look at the bar rather than at the arrow.

Look at the bar, not the arrow

The button sits just outside the edge of the successor’s bar rather than on the arrow you clicked, which is the only part of this that is hard to guess. The arrow itself gives no hover cue, so if nothing appears to happen, check that the arrow took the click before concluding it is not clickable.

Two things stop the chart gesture working at all, and both are silent:

• In Onplana Schedule, the chart is read only until you start editing. Clicking an arrow in view mode does nothing, by design. Use the Predecessors cell, or switch to editing first.
• In the web app, changing links needs permission. If your role does not have Manage task dependencies, the chart refuses the change with “You do not have permission to change dependencies on this project.”

Change a link’s type or lag

You can change a link without removing it. In the web app, open either task, expand More in the properties rail, and find the link’s row under Predecessors or Successors. If you may manage dependencies on the project, the row has:

• The type (FS, SS, FF or SF). Pick another and it saves straight away.
• The lag, a number and its unit (days, hours or weeks). Type the number and press Enter, or move away from the box, to save it; press Escape to put back the value it had. A negative number is lead time.

Only what you changed is sent, so a lag kept in hours stays in hours when you change the type. The change shows on both tasks, and the successor and the tasks after it are rescheduled as they would be for a new link. A type change that would close a loop is refused, as a new link would be (see Circular dependency protection). If the two tasks already have a link of the type you pick, the change is refused too.

A connected AI assistant can make the same change with the update_dependency tool, and undo it.

On the Gantt chart, double-click the arrow, or right-click it and choose Edit dependency…, to change the type or lag there (see Lag and lead time). To join a different pair of tasks, remove the link and draw a new one.

Links on a parent task

A parent task can take its dates from its subtasks (see Dates from subtasks). When it does, a link on the parent works through its subtasks:

• A link into the parent constrains each of its subtasks, so none of them starts before the predecessor allows.
• A link out of the parent waits on all of its subtasks, so the successor follows the last of them to finish.

The parent then has no float or critical flag of its own; its subtasks carry them. A parent set by hand keeps its own dates and is scheduled as a task of its own, as every parent was before.

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.

Scheduling constraints

A dependency says what a task waits for. A constraint says what its dates have to be, whatever the dependencies work out to. Open the task, expand More in the properties column, and set Scheduling Constraint. A task carrying anything other than the default shows its code next to More even while that section is closed, so a pinned date is visible without going looking for it.

All eight Microsoft Project constraints are here, and they group by what they actually do to the schedule:

Constraint	What it does
As Soon As Possible	The default, and not really a constraint: the task starts as early as its predecessors allow.
As Late As Possible	Slides the task as late as it can go, spending its own float rather than banking it.
Start No Earlier Than, Finish No Earlier Than	Push the early dates forward. Nothing may be scheduled before this.
Start No Later Than, Finish No Later Than	Bound the late dates. The plan has to reach the task by then.
Must Start On, Must Finish On	Pin both ends to one day, early and late together.

The six that name a date need one, so a date field appears when you pick one of them. The two “as possible” options take none, and the field disappears.

The difference between those two middle rows matters more than it reads. A “no earlier than” constraint moves work later and the plan absorbs it. A “no later than” constraint moves nothing: it sets a date the plan has to meet, and when the work does not fit, the shortfall surfaces as negative float instead of a task quietly sliding somewhere it does not belong.

Tip

Plans brought over from Microsoft Project before Onplana modelled all eight arrived with their constraints flattened to the nearest of the four we stored then. So if every constraint in a migrated schedule is As Soon As Possible, Start No Earlier Than, Finish No Later Than or Must Start On, it may not be showing you what its author actually wrote. Running the import again brings the original eight across.

When a constraint moves a task

Setting a constraint does not move the task you set it on. It takes effect the next time that task is rescheduled, which happens when a task it depends on moves, or when you press Recalculate (only the second, when the project’s automatic scheduling is off). Then a “no earlier than” constraint holds the task at or after its date, and a “must” constraint pins it. A task with no predecessors is never moved by the scheduler, whatever its constraint.

Typing a date does the same job for you. On a task that depends on others, a start date you type is kept as Start No Earlier Than at that date (a typed finish as Finish No Earlier Than), as Microsoft Project does, so a later change up the chain cannot pull it back earlier. It shows in the task’s Scheduling Constraint, where you can clear it.

Where the plan cannot honour a constraint, the Gantt lists it under Scheduling Constraint Violations above the chart, naming the task and the exact miss, for example “Scheduled to start 12 May but must start on 5 May”.

Reading float, including below zero

Float is how long a task can slip before it moves the project’s finish, and each bar’s tooltip on the Gantt gives you the number:

• N days of float, shading green to blue to amber as the number shrinks, is room you have.
• Critical, no float is zero. Any slip here moves the end date.
• N days over-committed, in a deeper red, is float below zero.

That last one is the payoff for modelling constraints properly. Negative float means the network cannot reach a date something has already promised, whether that is a “no later than” constraint, a deadline, or the project finish itself. Three days over-committed means precisely that: the chain needs three days it does not have. No amount of rescheduling inside the plan recovers them, so read it as a prompt to change the promise, the scope, or the resourcing rather than the dates.

Deadlines are a promise, not a constraint

Hard Deadline is a separate field on the task, meant for the contractual or compliance date rather than the one you are working to. It blocks nothing and moves nothing. It works by narrowing the room the task has: the scheduler counts the deadline among the dates the plan must reach, so missing one shows up as negative float on that task and on the chain feeding it. On the Gantt the deadline is also drawn on the task’s row, green while the finish is on or before it and red once the finish is past it, and the bar’s hover card says the task “finishes after it”.

So use a deadline for a date you have promised but do not want argued with, and a “finish no later than” constraint when you want the miss called out by name in the violations list.

See and set constraints across the plan

Opening tasks one at a time is a slow way to find out which ones are pinned. Three views show constraints side by side, and the Grid sets them on many tasks at once.

See them in a column. The List and the Grid have a Scheduling constraint column, and the Gantt has a Constraint column. All three are off until you turn them on from Columns in that view. A cell reads like “Must Start On: Oct 3, 2026”, and is read only: edit a single task’s constraint in the task itself, or many at once from the Grid (below). You can sort by the column, and on the Gantt filter it by text.

See it on the bar. Point at a bar on the Gantt and the text that appears names the constraint, for example “Must Start On: Oct 3, 2026”, with no column turned on.

Group the List by it. In the List, choose Group by > Constraint. Every task is grouped, subtasks included, because constraints usually sit on the work under a phase rather than on the phase. Groups follow the order of the task form’s constraint list, with No constraint last.

Set or clear it on many tasks from the Grid.

1. Open the Grid and select the rows (click, Ctrl-click or Shift-click; see Change several tasks at once).

2. Open the Constraint… menu in the Grid toolbar and pick a type, or Clear constraint.

3. A message says how many tasks changed, with an Undo button that puts every row back as it was.

How the Grid sets them:

• Each task keeps its own date. A start constraint (Must Start On, Start No Earlier Than, Start No Later Than) takes each task’s own start date, and a finish constraint (Must Finish On, Finish No Earlier Than, Finish No Later Than) its own due date. The menu says which, for example “Must Start On (each task’s start date)”. Tasks are pinned where they already sit rather than moved onto one shared day. As Late As Possible needs no date.
• Summary rows are skipped when setting, because a constraint belongs on the work under a phase. Clear constraint does clear them, which is how you unpin the phases of an imported plan.
• A task without the date it needs is skipped, and a message counts how many were left alone. Nothing is guessed.
• The menu is there for people who can edit tasks in the project.

Pin sparingly

A Must Start On or Must Finish On constraint pins the task, so its dependencies no longer move it: when the work ahead of it slips, the pinned task stays put and the conflict shows up as a violation or as negative float instead. The schedule quality checks count Must Start On, Must Finish On, Start No Later Than and Finish No Later Than as hard constraints, and flag a plan where more than 5% of the unfinished tasks carry one.

There is no setting that gives new tasks a constraint: every new task starts as As Soon As Possible.

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. Sequence with dependencies, pin with constraints, and in that order. A constraint is a fixed date, so every one you add is a piece of the schedule that can no longer respond to the plan changing around it. Most “this task must be in March” feelings are really a dependency nobody wired. Save constraints for dates the outside world sets: a delivery window, a regulator, a venue booking.
5. 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 does not list the task I want. The picker only shows tasks from the same project. A dependency can still span two separate projects, and the schedule honours it, but the picker will not create one: those links arrive by moving a task that already has dependencies, or from an AI agent or the API. See “Can I link tasks in different projects?” below. If you would rather keep two plans apart, milestones work as handoff points, one 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; the link list there shows the offset next to the type. The arrow itself does not render the lag.
• I linked two tasks but see no arrow. Every link type draws as an arrow on the Gantt chart, so check whether the predecessor is filtered out of the chart (done tasks hidden, another assignee selected, or a collapsed subtask). In a PDF of the chart only finish-to-start links draw, and the footer counts the rest.
• I added an FS link but the successor still has a date before the predecessor finishes. Adding a link reschedules the successor and everything after it, so this means the successor is held where it is: it carries a Must Start On or Must Finish On constraint, or it has no dates at all (an undated task is left undated until you press Recalculate). Clear the constraint or set the dates, and the link takes over.
• 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 + Suggest schedule. Suggest schedule has the AI propose dates that meet a deadline you give it, and every proposal is checked against each link, its type and its lag before you see it. To re-run the dependency network on its own, with no deadline, use Recalculate.
• Dependencies + Import. .mpp and Project Online imports preserve the dependency graph with link type and lag intact, and all eight constraint types plus each task’s deadline come across as themselves rather than being flattened into the nearest thing we supported. 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), the same lag-in-days convention, and all eight constraint types
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? Yes, along the chain you changed. Creating or removing a link, or changing a task’s dates, duration or constraint, reschedules the tasks that depend on it, directly or further down the chain. Tasks in other chains never move, and a save that changes no date (a title, a status, an assignee) moves nothing. Three things stay put deliberately: the task you just edited, any task with no predecessors at all (those dates are yours, not the network’s), and a successor you left undated on purpose. Recalculate now, in the Gantt’s Schedule menu, re-runs the whole project on demand and does fill in those undated tasks. Suggest schedule, in the AI menu, is a different tool: the AI-assisted planner, not this. To keep every date where you put it, turn the project’s automatic scheduling off: links are still saved and drawn, and only Recalculate moves tasks to match them.

What does “3 days over-committed” mean on a task? Its float is negative by three days, so the plan cannot reach a date something has promised. See Reading float, including below zero.

Are dependencies imported from Microsoft Project? Yes. Links from an imported plan come across with their type and lag intact, and so do task constraints and deadlines, all eight constraint types rather than the closest match. See Import from Microsoft Project.

Can I link tasks in different projects, or integrate two separate projects? Yes, and the schedule honours it: a task waiting on a task in another project is scheduled after it finishes. If you meant integrating Onplana with another system such as Microsoft or Google, that is a different kind of integration, see Connect Google and Microsoft. Two things are worth knowing. The dependency picker offers tasks from the current project only, so these links come from moving a task that already had dependencies, from an AI agent, or from the API. And the link works one way: Onplana schedules one project at a time, so the project holding the predecessor is scheduled without reference to the one that follows it, and a change there reaches the follower the next time the follower is recalculated. If two files are really one schedule, put them in one project instead, see Combine several schedule files.

What’s the maximum lag I can set? There’s no hard upper limit, in days, hours or weeks. 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? On the Gantt, type them into the Predecessors column, one task at a time, several links per task (see Type links into the Predecessors column). The MCP API also 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? On the Gantt, turn on the ID and Predecessors columns in View > Columns: every task’s links are listed in its row, by row ID. The list view of each project doesn’t 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