In short
- A dependency between two teams belongs to nobody until both sides agree its date.
- The programme's critical path runs through the joins between plans.
- Show what a slip moves downstream before anyone approves it.
The programme board meets on the first Monday of the month. The data platform project reports green. The customer portal project reports green. Both project managers are capable, and both are telling the truth about their own plans.
Three weeks earlier, the platform team moved the delivery of an interface from March to May. Inside their plan it was a sensible call. The interface had slack against their own end date, and their go-live did not move. Nobody told the portal team, because nothing in either plan said they needed to. The portal team found out in the week their integration testing was meant to start.
The date that mattered lived in neither plan. It lived in an email and in one line of a steering committee minute from the year before. That is where many programmes keep the thing that decides whether they finish on time.
What goes wrong
A large programme is a set of plans and a set of joins between them. Each plan has an owner, a scheduler and a status. The joins usually have none of these. Four mechanisms follow, and they feed each other.
The join belongs to nobody. A project manager owns the work inside the plan. A promise to deliver something to another team sits at the edge of it, as a note in a task name or an interface agreement in a shared folder. When it moves, nobody is accountable for telling the other side, and nobody on the other side is accountable for asking.
Float is local. The supplying team sees slack between the interface and its own end date. That slack is real for them. For the receiving team it does not exist, because their next step starts on the day the interface arrives. A slip that uses the supplier's float leaves the supplier green and moves the receiver's most urgent work. Status is worked out one project at a time, so the slip cannot show on either report.
The critical path stops at the edge of each plan. Every scheduler shows a critical path, and each one is computed inside a single file. The path that decides the programme's end date runs through the joins: from one team's deliverable into another team's test, and from there into a third team's launch. If nobody computes the path across the plans, the programme has forty critical paths and no way to tell which one is real.
Slips are accepted before they are priced. A date change is usually requested and agreed by the people who own the plan that moves. The form shows the effect on that plan. The effect downstream is not on the form, so the approver signs off a few weeks on one project and, without knowing it, a few months on the programme.
Under all four sits a quieter problem. Many dependencies are never written down as dependencies at all. Two projects need the same specialist in the same month. A contract has to be signed before a supplier can start. One regulator's approval gates three launches. These show up in task descriptions, risk logs and meeting notes, and nowhere as a link a scheduler can read.
What good looks like
The fix is to treat each join as an object in its own right, with the same discipline as the work on either side of it. Five moves get most of the way.
Declare dependencies at every level
Write the join down where it actually sits. Some are between projects: the portal cannot launch until the platform is live. Some are between milestones in different plans: integration testing starts when the interface is delivered. Some are between tasks inside one plan. Record the type, usually finish-to-start, sometimes start-to-start or finish-to-finish, and any lag, such as ten days for the receiving team to set up. A link recorded at the wrong level hides as much as it shows. A project-to-project link can bury the one milestone that matters.
Give each dependency an owner and a date both sides agreed
A dependency that one team declares on another team's plan is a request until the other team accepts it. Make the acceptance explicit. From then on the date belongs to both teams, and the supplying team cannot move it without the receiving team knowing. Many programmes skip this step, and it is the step that turns a note into a commitment.
Compute the critical path across the programme
Once the joins are recorded, the critical path can run through them. Look at it for the programme as a whole, and review the few cross-project links on it by name at the board. A project that is green on its own plan and sits on the programme's critical path deserves more attention than an amber project with months of float.
Price a slip before you accept it
Every request to move a date on a linked milestone should show what it moves downstream: the new programme end date, the activities that shift and the people whose assignments stretch. Then the approver is deciding on the real cost. Sometimes the answer is still yes. It is a different yes when the room can see that a three-week slip on one project costs two months at the end.
Look for the dependencies nobody declared
Every quarter, read the programme for links that should exist and do not: shared people, shared contracts, shared data, approvals that gate more than one project, risks that name another team. For each one, decide whether to declare it, raise it as a risk, or dismiss it with the reason written down. This is where the surprises come from, and it gets harder to do by hand as the programme grows.
Start with the joins between teams
Nobody needs every task link in the programme on the first day. Start with the joins that cross from one team to another, because those are the ones no single plan can see. Ask each project manager for the three things they need from someone else and the three things someone else needs from them. Match the lists. Where they do not match, one side is counting on a date the other side does not know it owes.
If you are moving schedules into a new portfolio layer, as I describe in after Project Online, bring the links across with the plans. A roll-up of schedules without the links between them puts the same forty critical paths in one place.
In Lodestar, a dependency is its own record, between projects or between activities, with its type and its lag. One that reaches into another team's project stays a proposal until that team accepts it. The critical path runs across the programme, the delay simulator shows what a slip moves before anyone commits, and the Polaris Dependency Hunter reads tasks, documents and risks for links nobody declared. The planning page has the detail.

Questions for your next review
- Which dependencies between our projects have a named owner on each side and a date both sides agreed?
- Which cross-project links sit on the programme's critical path, and when did this board last look at them by name?
- For the last five approved date changes, what did each one move downstream, and did the approver see it?
- Which shared people, contracts or approvals gate more than one project and appear nowhere as a dependency?
Programmes rarely fail inside a well-run project. They fail at the joins between two of them, where a slip can travel for weeks with nobody watching it.
