Task dependencies: types, lag, and the dependency map

4 min read · Updated Aug 24, 2026

Dependencies are what let Current compute a real schedule instead of just a list of dates — one task's timing drives another's. Add a dependency from the task drawer, or by dragging one task to another on the Dependencies map.

The dependency map — every task is a node with connection dots on its edges. Drag from one dot to another to link two tasks. Unlinked tasks lay out as a tidy grid, and the stat cards up top count tasks, critical-path tasks, and milestones.

The four dependency types

Current supports all four standard project-scheduling dependency types:

Type	Plain-language meaning
Finish → Start	This task starts once the other one finishes — the most common link.
Start → Start	Both tasks start at the same time.
Finish → Finish	This task can't finish until the other one finishes.
Start → Finish	This task finishes when the other one starts — rarely used.

Adding lag

Every dependency can carry a lag — a number of working days added (or subtracted, for lead time) between the two tasks. A lag of +2 days means the successor waits two extra working days after the dependency is satisfied; a negative lag lets the successor start early.

1
Open the task and go to Dependencies
From the task drawer, or click a task on the Dependencies map.
2
Pick the other task
Choose whether it's a predecessor (this task waits on it) or a successor (it waits on this task).
3
Choose the type
Finish → Start is the default and covers most cases.
4
Set lag if needed
Leave at 0 for back-to-back, or add days for a required gap (e.g. waiting for hardware to arrive).

The Dependencies map

The Dependencies view lays out every task and its links as a visual graph, auto-arranged left to right. Tasks on the critical path are highlighted in red with a thicker, animated edge; links between tasks in different projects are shown as dashed purple edges. A diagnostics panel flags tasks that are on the critical path, overdue, forecast to slip, an at-risk milestone, missing dependencies entirely, carrying invalid dates, or missing a work estimate. Tasks with no links yet sit in a grid below the network, ready to be linked.

Draw a link on the map

Every task on the map has two dots on its border: one on the right edge, one on the left. Drag from the right dot of the task that comes first to the left dot of the task that waits on it. Both dots turn purple when you hover a task, and the line snaps back mid-drag if the target can't take the link.

Dropping opens a short confirmation rather than writing straight away. It spells the direction out in both task names, offers the four types with "Start after it finishes" already picked, and takes a lag in working days — 0 by default, or a negative number to let the successor start early. Add dependency writes the link and the map redraws with it; Cancel writes nothing. When the two tasks live in different projects the dialog says so, because Current then schedules around the link on both sides.

Note

One entry per person in the map's filter

The map's assignee filter lists each teammate once. Someone whose work is part PSA-synced and part Current-native used to appear twice, with each entry hiding the other half of their tasks; picking their name now matches everything that's theirs. Two different people with exactly the same full name share a single entry.

Working with dependencies in the task drawer

Open a task and its Dependencies section lists what it's waiting on and, under "Waiting on this", the tasks waiting on it. Every row is a real, clickable link that always shows the actual task name — never a generic "task" placeholder, even when the other task was archived or removed.

＋Click any dependency row to jump straight to that task; a Back control returns you to where you started.
＋A task that no longer exists reads "Deleted task", and an archived task carries an (archived) tag — so a broken or hidden link is obvious instead of mysterious.
＋A dependency on a task in another project shows that project's name next to it, so a cross-project link is never ambiguous.
＋Remove buttons are always visible on every row — including the "Waiting on this" rows — and the add-dependency picker shows a clear loading state instead of disappearing while it loads.

Note

Removing a link happens in the drawer, not on the map

The map draws links; it doesn't delete them. Open the task — click its node, or open it from any list — and each row under "Waits on" or "Waiting on this" carries a small trash button.

Note

Who can change a task's dependencies

You can add or remove what a task waits on if you can manage projects (Project Manager and up) OR you are the assignee of the task that's doing the waiting. That means an engineer can now manage their own task's predecessors without a PM stepping in — but changing what waits on someone else's task still needs project-manage rights.

How circular dependencies are blocked

Current checks every new dependency before it's added: it traces forward from the task you're about to make dependent, and if that trace ever loops back to the task you started from, the link would create a cycle — an impossible schedule where two tasks each wait on the other. Current blocks the add and tells you it would create a dependency loop, and a task can't (indirectly) wait on itself. The same check runs on a map drag, and again in the database underneath, so a link that slipped past the browser is still refused.

The other refusals you can meet

＋The two tasks are already linked, or already linked the other way round.
＋A task can't wait on itself.
＋You dragged the wrong way — Current asks you to drag from a task's right dot to another task's left dot.
＋You don't have rights to that link: a project manager can add it, or you can add one on a task you're assigned to.

Note

A link can't cross two different project types

A dependency has to stay inside one sync type: Current refuses a link between a PSA-synced project and a Current-native one, because scheduling it would mean arbitrating between two different sources of truth. Two Autotask-synced projects link fine, and so do two Current-native ones. When it's refused, the dialog stays open with your type and lag intact so you can point the link somewhere else.

Note

Cross-project dependencies

A task in one project can depend on a task in another — useful for shared milestones like a company-wide cutover. When you're working in the dependency map or a What-if scenario, a linked task that lives in a different project is treated as a fixed point: Current schedules around it but never quietly moves it, so you can't reshape work you don't own without meaning to. Just double-check that both projects' owners are aware; a change on one side can still move dates on the other.

Was this helpful?

← Previous

Organize work with phases and tasks

What is a critical path (and how Current finds it)