The hidden dependencies that can make or break a project
A programme can look solid — detailed activities, clear responsibilities, logic all the way through — and still be sitting on a dependency nobody's properly identified. I've seen it happen on a recent review: the relationship was there but it just wasn't the right one. That's often more dangerous than a missing link, because it looks fine on screen right up until it isn't.
We tend to think of dependencies as the links between activities in a programme. But the real dependency is sometimes more subtle than that — an activity can have what looks like the correct predecessor while the actual work depends on something else entirely. Reviewing a programme properly isn't just checking that activities are linked. It's checking whether those links represent how the work will actually happen.
Here are five things worth doing to find the dependencies that don't show up on first read.
1. Look beyond the activity itself
It's easy, when reviewing an activity, to focus on whatever sits immediately before it in the programme. The more useful question is: what actually needs to happen before this work can start? That could be another piece of work finishing, supporting elements being installed, information becoming available, or simply access to an area.
On a recent review, I found a relationship that didn't reflect the real dependency. The activity was linked to one piece of work, but the physical sequence showed it should have depended on a frame and wall being completed instead. The relationship wasn't missing — it was just wrong.
Tip: Don't ask "does this have a predecessor?" Ask "is this the thing that genuinely needs to happen first?"
2. Look for dependencies between different parts of the work
Dependencies get harder to spot once several workstreams are running in parallel. One part of the work can depend on another even when the two activities look fairly independent on their own.
In that same review, I added relationships to make sure a later stage could only start once the necessary earlier work was done, and others to properly link a sequence so the intended system order was represented correctly. Dependencies don't always sit neatly one activity at a time — sometimes you have to look at the group.
Tip: Step back and ask what a whole group of activities depends on, not just the one in front of you.
3. Test whether the programme reflects the physical sequence
A programme can be logically sound and still not represent how the work will actually be delivered. This matters a lot in construction, where the physical sequence creates dependencies that aren't obvious from the activity descriptions alone.
An activity might look ready to start because its scheduled predecessor has finished — but if the physical arrangement means something else needs to happen first, the programme isn't telling the full story. This is where reviewing the logic against an understanding of the actual work earns its keep.
Tip: Don't review logic in isolation. Test it against the sequence the work will physically follow.
4. Ask what happens if a dependency moves
Finding a dependency is only the start. The better question is: what happens if it moves?
A small shift in one activity can ripple through several that follow it. During the review, I added some relationships specifically so later work would move with the preceding sequence rather than drifting independently. That matters most in tightly connected sequences, where one change rarely stays contained.
Tip: For the dependencies that matter, ask — if this moves five days, what else should move with it?
5. Don't be afraid to remove a relationship
Reviews tend to focus on finding missing logic. Sometimes the better move is removing a relationship. An unnecessary predecessor can mislead just as easily as a missing one — making activities look more dependent than they are, and hiding the sequence in which the work could actually be delivered.
In this review, I removed a predecessor because a group of systems-related activities didn't need to depend on what they'd been linked to, and added a more appropriate relationship elsewhere. Good logic isn't about having more relationships. It's about having the right ones.
Tip: Challenge both sides — "what should depend on this?" and "should this really depend on that?"
The dependency you don't see can be the one that matters most
A good programme doesn't just connect activities — it gives a realistic picture of how the project is meant to be delivered. That means looking past whether an activity has a predecessor and asking whether that relationship reflects the real one.
Sometimes it's a missing relationship. Sometimes it's the wrong one. Sometimes it needs removing altogether. The most useful reviews aren't the ones that add the most logic — they're the ones that get the logic right.
Because once a project starts moving, knowing what actually depends on what is often the difference between catching a problem early and finding out about it once the work's already been affected.
0 comments
Log in to post a comment, or create an account if you don't have one already.