↑↓ to moveEnter to openAll results →

    Dependencies are the programme: manage the joins between plans

    Most programme slips start at a join between two plans that nobody owns. Declare dependencies at every level, make both sides agree the date, compute the critical path across projects, and price every slip before you accept it.

    STRATEGY EXECUTIONSlips travelat the joins

    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.

    Project A: data platform Build interface Interface: Mar to May Platform live uses A's float, end date holds: green the join: an email, no owner B's plan never hears of it Project B: customer portal Build portal Integration test Go-live green until the week testing starts Declared, owned and dated, the join puts A's slip on B's plan the day it moves.
    Each plan is green on its own terms, and the slip travels through a join that neither plan records.

    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.

    What-if delay simulator: a 45-day delay on one activity moves the programme end date and extends two people's assignments
    What-if simulator. The effect of a change on the end date and the people on the work, before anyone commits.

    Questions for your next review

    1. Which dependencies between our projects have a named owner on each side and a date both sides agreed?
    2. Which cross-project links sit on the programme's critical path, and when did this board last look at them by name?
    3. For the last five approved date changes, what did each one move downstream, and did the approver see it?
    4. 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.

    Hany Amer
    Written byHany AmerFounder and CEO, Lodestar

    Hany is a strategy and transformation executive with a technical background in software and AI. He has advised C-suites at a top-three strategy consulting firm (MBB) and independently, and has run transformation programmes of more than USD 1 billion.

    Connect on LinkedIn

    See it on your own programme.

    Send us a slice of your portfolio and we load it before the session, from strategy down to task.