Skip to content

Drawing dependencies on the canvas

When one task can't start until another finishes, that's a dependency. The canvas lets you draw and remove dependencies directly — no need to open the detail panel.

Each task on the canvas has two small ports on its sides:

  • Right side — blocks (this task blocks something else)
  • Left side — blocked by (something else blocks this task)

To add a dependency:

  1. Hover the task you want to be the blocker until its right-side port appears.
  2. Click and drag from the right port across to the left-side port of the task you want to mark as blocked.
  3. Release. The new dashed arrow appears.

The arrow always points from the blocker to the blocked task — same direction the work has to flow.

What if the drop is refused?

If a drag would create a circular dependency (e.g. A blocks B, B blocks C, and you try to make C block A), every task that's part of the would-be loop tints red while you drag. The drop is refused; nothing happens on release.

This includes the task you're dragging from — you can't draw a dependency from a task to itself.

Remove a dependency

  1. Hover the dashed arrow you want to remove.
  2. A small red × appears at the middle of the arrow.
  3. Click it. The arrow disappears, and a "Dependency removed — Ctrl+Z to restore" toast appears in the corner.

Press Ctrl+Z (or Cmd+Z on macOS) to undo if you removed the wrong one.

What about parent / child relationships?

Parent / child edges (the arrows running up and down between tasks) work the same way, just using the top and bottom ports on each task.

To change a task's parent:

  1. Hover the task whose parent you want to change. Its top port appears.
  2. Click and drag from the top port to the bottom port of a new parent.
  3. Release. The old parent → child arrow disappears; a new one appears.

To detach a task (make it a top-level task with no parent):

  1. Hover the task. Its top port appears.
  2. Click and drag from the top port out into empty canvas.
  3. Release. The parent arrow disappears.

Both actions are reversible — Ctrl+Z puts the old parent back.

If a drop would create a circular parent relationship (e.g. dragging a parent onto one of its own children), every task that's part of the would-be loop tints red and the drop is refused — same affordance as the dependency cycle case.

Change a task's parent in the List view

You can also re-parent by dragging rows in the List view — handy when you're working through the tree as a list rather than on the canvas.

To make one task a child of another:

  1. Press and drag a task's row (grab anywhere on the row; a plain click still opens the task).
  2. Drag it onto the row you want to be its new parent — that row highlights as you hover it.
  3. Release. The dragged task (and everything under it) moves under the new parent. Drop onto a section row to file it under that section.

To detach a task (make it top-level with no parent):

  1. Start dragging any row. A "↥ Move to top level (no parent)" strip appears at the top of the list.
  2. Drop the row onto that strip.

As with the canvas, a drop that would create a loop (dropping a task onto its own sub-tree) is refused — those rows dim and won't accept the drop — and every move is reversible with Ctrl+Z (Cmd+Z on macOS). If someone else moves the same task while you're dragging, your move is undone with a note so nothing is lost.

Who can edit dependencies?

Anyone with editor or admin access to the project. If your role is read-only, the side ports and the × glyph won't appear; you'll still see every dependency on the canvas, just not the controls to change them.