What are task dependencies in project management?
Short answer
A task dependency is a relationship where one task cannot start or finish until another task does. The most common is finish-to-start: the second task begins only after the first is done. Dependencies decide the order of work and, through the critical path, the earliest date a project can finish, so tracking them is what turns a task list into a schedule.
Last updated 19 October 2026. Written by the Kaneo team, who also build one of the tools mentioned.
The four types
| Type | Meaning | Example |
|---|---|---|
| Finish-to-start | B starts after A finishes | Write the copy, then build the page that uses it |
| Start-to-start | B starts after A starts | Testing starts once development has started on the first feature |
| Finish-to-finish | B finishes after A finishes | Documentation cannot be final until the feature is final |
| Start-to-finish | B finishes after A starts | The old system stays on until the new one goes live |
Which ones matter in practice
Finish-to-start covers the vast majority of real dependencies, and most teams only ever track that one. Start-to-start and finish-to-finish show up in parallel work such as testing alongside development. Start-to-finish is rare outside handovers and shift work.
If you are unsure which type a dependency is, model it as finish-to-start. It is the most conservative and the easiest for everyone to understand.
Other ways to classify dependencies
Internal or external
Internal dependencies sit inside the team and you control them. External ones depend on another team, a vendor, or a client, and are the ones that cause most surprise delays.
Mandatory or discretionary
Mandatory dependencies are physical or legal: you cannot test code that does not exist. Discretionary ones are choices, such as finishing design before any build starts, and can be relaxed to save time.
Resource dependencies
Two tasks that could run in parallel but need the same person. They look independent on paper and are not.
Lead and lag
Lag is a required wait between dependent tasks: concrete has to cure for a week before building on it, or a legal review needs five working days after submission. Lead is the opposite, an overlap where the second task starts before the first is fully done, such as starting frontend work once the API design is agreed rather than when the API is finished.
Using lead deliberately is one of the few ways to shorten a schedule without adding people. It works best on discretionary dependencies.
Keeping dependencies from stalling work
Walk the task list once and ask, for each task, what it waits for. It takes minutes and prevents the most common late surprise.
The longest chain of dependent tasks sets the finish date. Give it your most reliable people and its own buffer.
Chase external dependencies early
Ask the other team or vendor for a date as soon as you know you depend on them, and check in before it is due, not after.
Make blocked work visible
A task waiting on something should say so where everyone looks. Silent blocks are how a two-day wait becomes two weeks.
Tracking dependencies in Kaneo
Open a task's Relations and choose Blocks to link it to work that has to wait for it. The other task shows the inverse, blocked by, so whoever picks it up sees what it waits on. Choose Related for a connection that is not a dependency, and Remove relation to unlink tasks without deleting either.
Give dependent tasks start and due dates and check the order on the Gantt view, where you can drag bars to reschedule. Kaneo tracks finish-to-start style blocking; it does not model lead and lag or draw dependency lines on the chart.
Frequently asked
What is the most common type of task dependency?
Finish-to-start, where one task must be complete before the next can begin. Most project tools default to it, and many only support it.
What is the difference between a dependency and a constraint?
A dependency links two tasks. A constraint limits a task on its own, such as a fixed date it must start on or finish by. Both affect the schedule, but only dependencies create chains.
How do dependencies relate to the critical path?
The critical path is the longest chain of dependent tasks through the project. Without dependencies every task could run in parallel and there would be no chain to find.
What does blocked by mean on a task?
That the task is waiting for another task to be finished before it can proceed. It is the inverse of a blocks relationship.