Description

A focused course, tailored for you

The Launch-Readiness Review Playbook for Tech Program Managers

Run the readiness review where the dependency map, the risk register, and the OKR rollup all survive the exec table without rework.

Your readiness review is in 72 hours. The dependency map has three new cross-team edges since last week, two risks are still scored from the previous milestone, and the OKR rollup pulls from a sheet someone in another org maintains. You either spend the next two days reconciling all of it by hand, or the director runs the meeting for you.

$199 one-time

Tailored to your situation. Access within 24 hours. 30-day money-back.

Includes a hand-built implementation playbook delivered alongside course access, generated for your specific situation.

Why this course

Tech program management at scale lives or dies on three artefacts that have to agree with each other: the dependency map across the teams in your program, the risk register with current scores and owners, and the OKR rollup that ties the program back to the org's quarterly goals. When any one of those is stale, the readiness review becomes a debug session. The exec table reads the gap, the team reopens decisions that were already made, and the next milestone slips by the time it takes to recover the meeting. The skill is keeping all three artefacts current and consistent so the review is short, the decisions stick, and the program moves.

What you walk away with

Run a readiness review where the dependency map, risk register, and OKR rollup all agree without rework.
Score risks in a way engineering accepts and execs re-read.
Build a dependency graph that survives a re-org without manual rebuild.
Write the one-line risk callout that gets the exec response you actually need.
Keep the OKR rollup current without weekly chasing across orgs.

The 12 modules

Module 1. The readiness-review shape that holds up at the exec table

Walk through what an exec actually reads on a readiness slide and the four artefacts that have to be consistent before the meeting starts. Cover the difference between the readiness review the team runs and the readiness review the director runs, and the one decision the meeting is actually for. Set the standard that the rest of the course works toward.

Module 2. Building a dependency map that does not go stale in a week

Cover how to model cross-team dependencies so the map updates from the systems engineering already uses rather than from a weekly chase. Walk through edge types, owner tagging, and the convention for a dependency that has moved from soft to hard. Include the template for the dependency map you would put on the readiness slide.

Module 3. The risk register that engineering will accept

Risk scoring at a tech program scale fails when engineering reads it as theatre. Walk through the scoring convention that survives an engineering review, the columns that have to exist, and the cadence for re-scoring. Cover how to write the one-line risk description that captures the technical reality without flattening it.

Module 4. OKR rollups that do not get rewritten in the readiness meeting

Cover the rollup structure that ties team-level OKRs to program-level OKRs to org-level OKRs without the manual reconciliation that usually happens before every review. Walk through the source-of-truth convention, the update cadence, and the format for the OKR slide that an exec can read in 30 seconds.

Module 5. The one-line risk callout that gets the exec response

An exec reads risk callouts the way you read commit messages. Walk through the structure of a risk callout that lands: what is at risk, the trigger, the unblocker, and the owner. Cover the difference between a callout that gets you the help you need and one that gets you a longer meeting. Include 20 worked examples.

Module 6. Cross-team escalation without burning the relationship

When a dependency is slipping, the escalation path matters as much as the escalation itself. Walk through the escalation ladder, the language for the first message, and the convention for keeping the engineering teams on the same side of the table. Cover how to escalate without putting the program manager in the middle as a blocker.

Module 7. Launch gates and the readiness checklist that holds

Cover the launch gate structure: what each gate is for, who signs it, what evidence the gate requires, and the convention for a gate that is conditionally passed. Walk through the readiness checklist that maps to the gates and the rule for when a gate can be re-opened.

Module 8. Status reporting that survives a director skip-level

Status reports get read at three altitudes: by the team, by the director, by the skip-level. Walk through the status report shape that holds across all three reads, the convention for what gets included and what gets cut, and the cadence that does not turn into a writing job.

Module 9. Program-level metrics that an engineering org will trust

Cover the metrics a tech program reports against: throughput, dependency-blocker count, risk-burn, launch-readiness score. Walk through the definition for each, the source data, and the convention for reporting them. Include the dashboard template you would attach to the readiness review.

Module 10. Working with engineering leads without owning their work

Program managers do not own engineering work, but they own the program outcome. Walk through the working convention with engineering leads that gives the program manager visibility without making the engineering lead feel managed. Cover the meeting cadence, the artefact ownership, and the rule for who writes what.

Module 11. Re-orgs, scope shifts, and program continuity

Programs survive re-orgs by having artefacts that do not depend on a specific org chart. Walk through how to structure the dependency map, the risk register, and the OKR rollup so they survive a team moving, a director changing, or the program splitting. Cover the migration runbook for the first 30 days after a re-org.

Module 12. Closing a program and writing the post-launch

Cover the close-out: what gets archived, what gets migrated to the operational owner, and the post-launch document that captures what the next program manager would want to know. Walk through the template for the post-launch, the convention for documenting decisions, and the handover meeting structure.

How this addresses your situation

Specific modules that map to what you said you are dealing with.

Readiness review in 72 hours and the dependency map is stale: modules 1, 2, 7 give you the artefacts and the gate structure to recover.

Risk register is being ignored by engineering: modules 3, 5, 6 give you the scoring convention, callout language, and escalation path.

OKR rollup is getting rewritten every quarter: modules 4, 8, 9 give you the rollup structure, status reporting cadence, and metric definitions.

Re-org just hit and the program lost two team leads: modules 10, 11, 12 give you the working convention, continuity playbook, and close-out structure.

What you get with this course

Twelve written modules with worked examples for each, in the Art of Service learning environment.
Readiness slide template with the four artefacts pre-wired.
Dependency map template with edge-type and owner-tag conventions.
Risk register template with scoring convention and re-score cadence.
OKR rollup template with source-of-truth convention.
Twenty worked one-line risk callout examples.
Hand-built implementation playbook tailored to your program shape after purchase.

What you will have in hand by Day 1, Week 1, Month 1

Within 24 hours: learning environment access provisioned and the tailored implementation playbook delivered.

Weeks 1 to 2: modules 1 to 4 cover the four artefacts and how they fit together.

Weeks 3 to 4: modules 5 to 8 cover the language and cadence that makes the artefacts land at the exec table.

Weeks 5 to 6: modules 9 to 12 cover the metrics, the working convention, the re-org continuity playbook, and the close-out.

Before and after

Before

The readiness review is a debug session. The dependency map, risk register, and OKR rollup do not agree with each other. The director rewrites the risk language in the meeting. The team starts the next milestone behind because the review took two days to recover from.

After

The readiness review is short. The four artefacts agree. The director re-reads the risk callouts you wrote, gives the unblocker, and the program moves. The next readiness review starts from the same artefacts, not from scratch.

What happens if you do not address this

Without a consistent set of artefacts, every readiness review becomes a live reconciliation exercise. The exec read of the program is shaped by whatever happens in the meeting rather than by the artefacts the program manager owns. Decisions get reopened, milestones slip, and the program manager becomes the bottleneck rather than the orchestrator.

Who it is for

Built for the program manager running a multi-team technical program inside a large engineering org. The person who owns the dependency map, the risk register, and the OKR rollup, and is accountable for the readiness reviews where execs gate launch. Comfortable with engineering teams, fluent in OKRs, responsible for the artefacts that show whether the program is on track.

Who this is NOT for. Not for individual contributors with no cross-team coordination responsibility. Not for product managers focused on customer discovery and roadmap shape. Not for project managers running a single team's sprint cadence with no cross-program dependencies. Not for portfolio managers above the program layer who consume rollups rather than produce them.

How it arrives

Text-based course in the Art of Service learning environment, plus downloadable templates and worked examples for every module, plus the hand-built implementation playbook delivered alongside course access.

Time investment. Roughly 6 weeks at 3 to 4 hours per week, including running one of your real readiness reviews against the templates.

Why $199 is the right number

PMI program management content covers the discipline at a generic level and does not address the specific shape of a tech-org readiness review. Internal PgM training inside a large engineering org assumes you already know the artefacts. Generic risk management content treats risk registers as a compliance exercise rather than an exec-table communication tool. This course is built around the readiness review as the moment that matters, with the four artefacts as the deliverables.

FAQ

Is this for a specific industry?

Built around tech program management, where the readiness review and the dependency map across engineering teams are the central artefacts. Useful in any sector where engineering programs are managed at scale.

Does this assume a specific tooling stack?

No. The templates work in whichever tools your org standardises on. The conventions are tool-agnostic.

What is in the hand-built implementation playbook?

After purchase you get a playbook tailored to your program shape: the artefacts adapted to your org's review cadence, your dependency types, your OKR rollup structure, and the readiness gate format your director expects.

How is this delivered?

Written modules in the Art of Service learning environment, downloadable templates, and the hand-built implementation playbook delivered alongside course access.

What if I run programs across multiple orgs?

Module 11 covers cross-org program continuity and re-org survival. The dependency map and OKR rollup templates are designed to span org boundaries.

30-day money-back guarantee. If after a week of working through the materials this is not what you needed, reply to the receipt email and a full refund is processed. No questions, no forms.

Within 24 hours your account in the learning environment is provisioned and the tailored implementation playbook is delivered alongside it.