# How program management coordinates many projects

> A process map exported from forks.world (https://forks.world). Author: Brian. Source: https://forks.world/p/cmv0kq30l0027jv06342ezamt
> It describes who does what, in what order, and with which technology. Read the plain-language sections first; the JSON at the end is the exact, complete data.

## Summary

- 24 steps across 3 layers
- Persona: Program sponsor, Program manager, Project managers, Governance board, Benefits owner

## Pain points

Where this process hurts, worst first:

- **Track dependencies and shared risks** (How program management coordinates many projects; painful): Dependencies between projects are where programs quietly slip

## How to read this file

- A process is made of **layers**. The main layer is the top level; any step of kind `subprocess` opens a detail layer with its own lanes and steps.
- **Lanes** are either persona (people/roles) or technology (systems). Each step belongs to one lane; `using` lists tools a person uses for that step.
- Step kinds: `start`, `task`, `decision` (its arrows carry the answer as a label), `subprocess`, `end`.

## How program management coordinates many projects

Lanes:
- Program sponsor: person / role (id `sponsor`)
- Program manager: person / role (id `pgm`)
- Project managers: person / role (id `proj`)
- Governance board: person / role (id `pmo`)
- Benefits owner: person / role (id `benefits`)

Steps, in the order they run:

1. **A strategic goal needs several projects at once** [start; Program sponsor; id `g1`]
   - then Define the program vision and the expected benefits
2. **Define the program vision and the expected benefits** [task; Program manager; id `g2`]
   - then Is the program approved?
3. **Is the program approved?** [decision; Governance board; id `g3`]
   - if "Yes" go to Break it into projects and set a roadmap; if "No" go to Revise the case
4. **Break it into projects and set a roadmap** [subprocess; Program manager; id `g4`], opens the detail layer "The program roadmap"
   - then The projects run in parallel
5. **The projects run in parallel** [task; Project managers; id `g5`]
   - then Track dependencies and shared risks
6. **Track dependencies and shared risks** [subprocess; Program manager; id `g6`] ⚠ PAIN POINT (painful): Dependencies between projects are where programs quietly slip, opens the detail layer "Managing dependencies"
   - then Does a project threaten the whole program?
7. **Does a project threaten the whole program?** [decision; Program manager; id `g7`]
   - if "Yes" go to Rebalance resources or change the roadmap; if "No" go to Stage-gate review at each milestone
8. **Rebalance resources or change the roadmap** [task; Program manager; id `g8`]
   - then Stage-gate review at each milestone
9. **Stage-gate review at each milestone** [task; Governance board; id `g9`]
   - then Does it pass the gate?
10. **Does it pass the gate?** [decision; Governance board; id `g10`]
   - if "Yes" go to Deliver the capabilities; if "No" go to Rebalance resources or change the roadmap
11. **Deliver the capabilities** [task; Project managers; id `g11`]
   - then Benefits realization: did the goal really improve?
12. **Benefits realization: did the goal really improve?** [task; Benefits owner; id `g12`]
   - then Were the benefits achieved?
13. **Were the benefits achieved?** [decision; Benefits owner; id `g13`]
   - if "Yes" go to Close the program; if "Partly" go to Plan follow-up projects
14. **Close the program** [end; Program sponsor; id `g14`]
15. **Plan follow-up projects** [end; Program manager; id `g15`]
16. **Revise the case** [task; Program sponsor; id `g3a`]
   - then Define the program vision and the expected benefits

```mermaid
flowchart LR
  subgraph l_sponsor["Program sponsor"]
    n_g1(["A strategic goal needs several projects at once"])
    n_g3a["Revise the case"]
    n_g14(["Close the program"])
  end
  subgraph l_pgm["Program manager"]
    n_g2["Define the program vision and the expected benefits"]
    n_g4[["Break it into projects and set a roadmap"]]
    n_g6[["Track dependencies and shared risks"]]
    n_g7{"Does a project threaten the whole program?"}
    n_g8["Rebalance resources or change the roadmap"]
    n_g15(["Plan follow-up projects"])
  end
  subgraph l_proj["Project managers"]
    n_g5["The projects run in parallel"]
    n_g11["Deliver the capabilities"]
  end
  subgraph l_pmo["Governance board"]
    n_g3{"Is the program approved?"}
    n_g9["Stage-gate review at each milestone"]
    n_g10{"Does it pass the gate?"}
  end
  subgraph l_benefits["Benefits owner"]
    n_g12["Benefits realization: did the goal really improve?"]
    n_g13{"Were the benefits achieved?"}
  end
  n_g1 --> n_g2
  n_g2 --> n_g3
  n_g3 -->|"Yes"| n_g4
  n_g3 -->|"No"| n_g3a
  n_g3a --> n_g2
  n_g4 --> n_g5
  n_g5 --> n_g6
  n_g6 --> n_g7
  n_g7 -->|"Yes"| n_g8
  n_g7 -->|"No"| n_g9
  n_g8 --> n_g9
  n_g9 --> n_g10
  n_g10 -->|"Yes"| n_g11
  n_g10 -->|"No"| n_g8
  n_g11 --> n_g12
  n_g12 --> n_g13
  n_g13 -->|"Yes"| n_g14
  n_g13 -->|"Partly"| n_g15
```

### Managing dependencies (detail of step "Track dependencies and shared risks")

Lanes:
- Program manager: person / role (id `pgm`)
- Project managers: person / role (id `proj`)

Steps, in the order they run:

1. **Map which project needs what from whom** [start; Program manager; id `d1`]
   - then Is there a conflict over people or timing?
2. **Is there a conflict over people or timing?** [decision; Program manager; id `d2`]
   - if "Yes" go to Negotiate and re-sequence; if "No" go to Update the dependency log
3. **Negotiate and re-sequence** [task; Program manager; id `d3`]
   - then Update the dependency log
4. **Update the dependency log** [end; Program manager; id `d4`]

```mermaid
flowchart LR
  subgraph l_pgm["Program manager"]
    n_d1(["Map which project needs what from whom"])
    n_d2{"Is there a conflict over people or timing?"}
    n_d3["Negotiate and re-sequence"]
    n_d4(["Update the dependency log"])
  end
  n_d1 --> n_d2
  n_d2 -->|"Yes"| n_d3
  n_d2 -->|"No"| n_d4
  n_d3 --> n_d4
```

### The program roadmap (detail of step "Break it into projects and set a roadmap")

Lanes:
- Program manager: person / role (id `pgm`)

Steps, in the order they run:

1. **List the projects and their outputs** [start; Program manager; id `r1`]
   - then Order them by dependency
2. **Order them by dependency** [task; Program manager; id `r2`]
   - then Mark the milestones the business cares about
3. **Mark the milestones the business cares about** [task; Program manager; id `r3`]
   - then Publish one integrated roadmap
4. **Publish one integrated roadmap** [end; Program manager; id `r4`]

```mermaid
flowchart LR
  subgraph l_pgm["Program manager"]
    n_r1(["List the projects and their outputs"])
    n_r2["Order them by dependency"]
    n_r3["Mark the milestones the business cares about"]
    n_r4(["Publish one integrated roadmap"])
  end
  n_r1 --> n_r2
  n_r2 --> n_r3
  n_r3 --> n_r4
```

## Full data (JSON)

```json
{
  "title": "How program management coordinates many projects",
  "maps": {
    "m_dep": {
      "id": "m_dep",
      "lanes": [
        {
          "id": "pgm",
          "name": "Program manager",
          "type": "person"
        },
        {
          "id": "proj",
          "name": "Project managers",
          "type": "person"
        }
      ],
      "steps": [
        {
          "id": "d1",
          "kind": "start",
          "lane": "pgm",
          "next": [
            {
              "to": "d2"
            }
          ],
          "uses": [],
          "label": "Map which project needs what from whom"
        },
        {
          "id": "d2",
          "kind": "decision",
          "lane": "pgm",
          "next": [
            {
              "to": "d3",
              "label": "Yes"
            },
            {
              "to": "d4",
              "label": "No"
            }
          ],
          "uses": [],
          "label": "Is there a conflict over people or timing?"
        },
        {
          "id": "d3",
          "kind": "task",
          "lane": "pgm",
          "next": [
            {
              "to": "d4"
            }
          ],
          "uses": [],
          "label": "Negotiate and re-sequence"
        },
        {
          "id": "d4",
          "kind": "end",
          "lane": "pgm",
          "next": [],
          "uses": [],
          "label": "Update the dependency log"
        }
      ],
      "title": "Managing dependencies",
      "parent": {
        "map": "m_root",
        "step": "g6"
      }
    },
    "m_road": {
      "id": "m_road",
      "lanes": [
        {
          "id": "pgm",
          "name": "Program manager",
          "type": "person"
        }
      ],
      "steps": [
        {
          "id": "r1",
          "kind": "start",
          "lane": "pgm",
          "next": [
            {
              "to": "r2"
            }
          ],
          "uses": [],
          "label": "List the projects and their outputs"
        },
        {
          "id": "r2",
          "kind": "task",
          "lane": "pgm",
          "next": [
            {
              "to": "r3"
            }
          ],
          "uses": [],
          "label": "Order them by dependency"
        },
        {
          "id": "r3",
          "kind": "task",
          "lane": "pgm",
          "next": [
            {
              "to": "r4"
            }
          ],
          "uses": [],
          "label": "Mark the milestones the business cares about"
        },
        {
          "id": "r4",
          "kind": "end",
          "lane": "pgm",
          "next": [],
          "uses": [],
          "label": "Publish one integrated roadmap"
        }
      ],
      "title": "The program roadmap",
      "parent": {
        "map": "m_root",
        "step": "g4"
      }
    },
    "m_root": {
      "id": "m_root",
      "lanes": [
        {
          "id": "sponsor",
          "name": "Program sponsor",
          "type": "person"
        },
        {
          "id": "pgm",
          "name": "Program manager",
          "type": "person"
        },
        {
          "id": "proj",
          "name": "Project managers",
          "type": "person"
        },
        {
          "id": "pmo",
          "name": "Governance board",
          "type": "person"
        },
        {
          "id": "benefits",
          "name": "Benefits owner",
          "type": "person"
        }
      ],
      "steps": [
        {
          "id": "g1",
          "kind": "start",
          "lane": "sponsor",
          "next": [
            {
              "to": "g2"
            }
          ],
          "uses": [],
          "label": "A strategic goal needs several projects at once"
        },
        {
          "id": "g2",
          "kind": "task",
          "lane": "pgm",
          "next": [
            {
              "to": "g3"
            }
          ],
          "uses": [],
          "label": "Define the program vision and the expected benefits"
        },
        {
          "id": "g3",
          "kind": "decision",
          "lane": "pmo",
          "next": [
            {
              "to": "g4",
              "label": "Yes"
            },
            {
              "to": "g3a",
              "label": "No"
            }
          ],
          "uses": [],
          "label": "Is the program approved?"
        },
        {
          "id": "g3a",
          "kind": "task",
          "lane": "sponsor",
          "next": [
            {
              "to": "g2"
            }
          ],
          "uses": [],
          "label": "Revise the case"
        },
        {
          "id": "g4",
          "kind": "subprocess",
          "lane": "pgm",
          "next": [
            {
              "to": "g5"
            }
          ],
          "uses": [],
          "child": "m_road",
          "label": "Break it into projects and set a roadmap"
        },
        {
          "id": "g5",
          "kind": "task",
          "lane": "proj",
          "next": [
            {
              "to": "g6"
            }
          ],
          "uses": [],
          "label": "The projects run in parallel"
        },
        {
          "id": "g6",
          "kind": "subprocess",
          "lane": "pgm",
          "next": [
            {
              "to": "g7"
            }
          ],
          "pain": {
            "note": "Dependencies between projects are where programs quietly slip",
            "level": 2
          },
          "uses": [],
          "child": "m_dep",
          "label": "Track dependencies and shared risks"
        },
        {
          "id": "g7",
          "kind": "decision",
          "lane": "pgm",
          "next": [
            {
              "to": "g8",
              "label": "Yes"
            },
            {
              "to": "g9",
              "label": "No"
            }
          ],
          "uses": [],
          "label": "Does a project threaten the whole program?"
        },
        {
          "id": "g8",
          "kind": "task",
          "lane": "pgm",
          "next": [
            {
              "to": "g9"
            }
          ],
          "uses": [],
          "label": "Rebalance resources or change the roadmap"
        },
        {
          "id": "g9",
          "kind": "task",
          "lane": "pmo",
          "next": [
            {
              "to": "g10"
            }
          ],
          "uses": [],
          "label": "Stage-gate review at each milestone"
        },
        {
          "id": "g10",
          "kind": "decision",
          "lane": "pmo",
          "next": [
            {
              "to": "g11",
              "label": "Yes"
            },
            {
              "to": "g8",
              "label": "No"
            }
          ],
          "uses": [],
          "label": "Does it pass the gate?"
        },
        {
          "id": "g11",
          "kind": "task",
          "lane": "proj",
          "next": [
            {
              "to": "g12"
            }
          ],
          "uses": [],
          "label": "Deliver the capabilities"
        },
        {
          "id": "g12",
          "kind": "task",
          "lane": "benefits",
          "next": [
            {
              "to": "g13"
            }
          ],
          "uses": [],
          "label": "Benefits realization: did the goal really improve?"
        },
        {
          "id": "g13",
          "kind": "decision",
          "lane": "benefits",
          "next": [
            {
              "to": "g14",
              "label": "Yes"
            },
            {
              "to": "g15",
              "label": "Partly"
            }
          ],
          "uses": [],
          "label": "Were the benefits achieved?"
        },
        {
          "id": "g15",
          "kind": "end",
          "lane": "pgm",
          "next": [],
          "uses": [],
          "label": "Plan follow-up projects"
        },
        {
          "id": "g14",
          "kind": "end",
          "lane": "sponsor",
          "next": [],
          "uses": [],
          "label": "Close the program"
        }
      ],
      "title": "How program management coordinates many projects",
      "parent": null
    }
  }
}
```