Skip to main content
Operational Portfolio Gate Pack — Machine‑Readable Artifact Checklists, Routing Table CSV and Evidence JSON Schemas

Operational Portfolio Gate Pack — Machine‑Readable Artifact Checklists, Routing Table CSV and Evidence JSON Schemas

A drop‑in artifact pack your PPM tooling can actually ingest — not another PDF nobody imports

Most gate frameworks die in a slide deck. Someone writes a beautiful 40‑page governance manual, it gets approved, and six months later the actual gate decisions are happening over Slack with a spreadsheet nobody trusts. The rationale was fine. The problem was no machine‑readable layer existed that your workflow tool could pick up and enforce.

This pack skips that. It assumes you already know why gates matter and have lifecycle guidance in place — if not, the systems-first operational portfolio lifecycle with evidence and SLAs post covers the reasoning layer. Here we're handing you the actual artifacts: CSV checklists per stage, a complete routing table, a role/authority matrix, the minimum lineage fields you need, and JSON schemas for the evidence packages that have to show up at each gate.

Everything below is built to be copy‑pasted into Jira, ServiceNow, Planview, Smartsheet, or whatever PPM layer you're running. Sample rows included. No governance sermon.

Why most PMO gate artifact checklist attempts never get imported

Before the templates, one blunt observation — because it shapes how the pack is structured.

The checklists that fail share a pattern: they're written for humans to read, not systems to parse. A line like "Confirm stakeholder alignment is sufficient before proceeding" can't be imported, can't be validated, and can't trigger routing. There's no field. There's no owner. There's no pass/fail condition a tool can evaluate.

  1. Every checklist item has a discrete state (notstarted / inprogress / complete / waived) a tool can store
  2. Every gate transition has an explicit owner or queue, not a vague "the board decides"
  3. Every required piece of evidence has a schema, so the tool can reject an incomplete submission instead of a human noticing it later

When those three things exist as structured data, your workflow engine does the nagging. When they don't, you're back to someone manually chasing evidence the night before a gate review.

The whole pack is built around rows and schemas, not prose.

Stage‑by‑stage checklist rows (CSV)

Here's the core checklist format. One row per item. The gate and itemid columns let you filter per stage inside your tool. The evidencekey column is the glue — it ties a checklist item to a specific evidence artifact defined later in the JSON schemas.

`` gate,itemid,itemtext,ownerrole,state,mandatory,evidencekey,slahours,waiverauthority G1-Intake,G1-01,Business case captured with named sponsor,BA,notstarted,TRUE,bizcasev1,24,PMO-Lead G1-Intake,G1-02,Rough order cost range recorded,Finance-Partner,notstarted,TRUE,costromv1,24,Finance-Lead G1-Intake,G1-03,Strategic fit score assigned,Portfolio-Analyst,notstarted,TRUE,fitscorev1,48,PMO-Lead G2-Plan,G2-01,Dependency list drafted and linked,PM,notstarted,TRUE,dependencymapv1,48,PMO-Lead G2-Plan,G2-02,Resource request submitted to capacity queue,PM,notstarted,TRUE,resourcereqv1,48,Resource-Mgr G2-Plan,G2-03,Risk register seeded with top 5 risks,PM,notstarted,FALSE,riskregisterv1,72,PMO-Lead G3-Fund,G3-01,Detailed cost-to-complete attached,Finance-Partner,notstarted,TRUE,ctcv1,48,Finance-Lead G3-Fund,G3-02,Funding slice mapped to CapEx/OpEx,Finance-Partner,notstarted,TRUE,fundingsplitv1,48,Finance-Lead G3-Fund,G3-03,Benefit hypothesis with measurable KPI,Sponsor,notstarted,TRUE,benefithypov1,72,Portfolio-Board G4-Build,G4-01,Acceptance tests defined and signed,QA-Lead,notstarted,TRUE,accepttestsv1,96,Delivery-Lead G4-Build,G4-02,Change-freeze windows acknowledged,PM,notstarted,FALSE,freezeackv1,48,PMO-Lead G5-Release,G5-01,Rollback plan attached and tested,Release-Mgr,notstarted,TRUE,rollbackv1,48,Delivery-Lead G5-Release,G5-02,Security/compliance sign-off attached,Security-Lead,notstarted,TRUE,secsignoffv1,72,CISO-Delegate G6-Benefit,G6-01,Baseline metrics captured pre-go-live,Benefits-Owner,notstarted,TRUE,baselinemetricsv1,72,Portfolio-Board G6-Benefit,G6-02,Reconciliation date scheduled,Finance-Partner,notstarted,TRUE,reconschedule_v1,48,Finance-Lead ``

A few design choices worth flagging, because they're the difference between a list that works and one that generates arguments:

  1. mandatory is a real boolean, not a tone. When it's TRUE, your tool blocks the transition. When FALSE, the item is tracked but doesn't gate. People fight endlessly over what counts as "important." A boolean ends the fight.
  2. waiver_authority is on every row. The most common gate stall is nobody knowing who can waive a specific item. Put it on the row and the escalation self‑resolves.
  3. sla_hours is per item, not per gate. A ROM cost estimate and a full cost‑to‑complete don't deserve the same clock. Item‑level SLAs stop the whole gate from inheriting the slowest task's timeline.

One thing worth avoiding: don't let item_text grow into a paragraph. If an item needs explanation, that belongs in the evidence schema, not the checklist row. Rows should scan in under three seconds.

The routing table CSV

This is the piece most packs skip, and it's the one that actually makes gates run without a human air‑traffic‑controller. The routing table defines what happens on every transition: who it goes to, what triggers it, the SLA, where it escalates, who holds decision authority, and which evidence snapshot gets frozen at that moment.

`` transition,trigger,rolequeue,slahours,escalationpath,decisionauthority,evidencesnapshotkeys Intake->Plan,allG1mandatorycomplete,PMO-Review-Queue,24,PMO-Lead>Portfolio-Board,PMO-Lead,"bizcasev1,costromv1,fitscorev1" Plan->Fund,allG2mandatorycomplete,Finance-Review-Queue,48,Finance-Lead>CFO-Delegate,Portfolio-Board,"dependencymapv1,resourcereqv1,ctcv1" Fund->Build,fundingapproved,Delivery-Intake-Queue,48,Delivery-Lead>PMO-Lead,Portfolio-Board,"fundingsplitv1,benefithypov1" Build->Release,allG4mandatorycomplete,Release-Review-Queue,72,Release-Mgr>Delivery-Lead,Delivery-Lead,"accepttestsv1,rollbackv1" Release->Benefit,goliveconfirmed,Benefits-Queue,48,Benefits-Owner>Portfolio-Board,Portfolio-Board,"secsignoffv1,baselinemetricsv1" Any->Hold,slabreachx2,PMO-Escalation-Queue,4,PMO-Lead>Portfolio-Board,PMO-Lead,"currentgatesnapshot" Any->Reject,mandatorywaiveddenied,PMO-Review-Queue,24,PMO-Lead>Portfolio-Board,Portfolio-Board,"currentgatesnapshot" ``

Read the trigger column carefully — these are conditions your workflow engine evaluates, not instructions a person follows. allG2mandatory_complete is something your tool can literally compute by checking checklist states. The routing fires automatically when the data condition is met.

The evidencesnapshotkeys column is the sleeper feature. At each transition, the system freezes a copy of those specific evidence artifacts as they existed at that moment. That's what saves you in an audit eight months later when someone asks what the cost‑to‑complete looked like when funding was approved. You don't reconstruct it. You pull the snapshot.

Notice the two special transitions at the bottom. Any->Hold fires when an SLA breaches twice — a cheap, mechanical way to surface stuck work without a human watching clocks. The 4‑hour SLA on that escalation row is deliberately tight because a stalled gate costs more the longer it sits.

Role and delegated authority matrix

The routing table references roles. This matrix defines what those roles can actually do, including delegation, so there's no ambiguity when someone's on vacation.

RoleCan Approve GateCan Waive MandatoryCan Delegate ToDelegation Cap
PMO-LeadG1, G2G1, G2 non-finance itemsPortfolio-Analyst1 gate level
Finance-Lead—Any finance itemFinance-PartnerROM items only
Portfolio-BoardG3, G5, G6Any item, loggedPMO-Lead (interim)72h, 1 project
Delivery-LeadG4G4 non-security itemsRelease-Mgr1 gate level
CISO-Delegate—Security itemsSecurity-LeadLogged, 24h
Sponsor————

The mistake people make here is treating delegation as informal. Someone says "cover for me" and suddenly a person with no logged authority is approving a funding gate. Every delegation needs a cap and a log entry. The Delegation Cap column is what prevents a temporary stand‑in from quietly becoming a permanent shadow approver — which is exactly how decision rights erode over a few quarters.

The Sponsor row is intentionally empty on approval authority. Sponsors provide evidence and hypotheses; they don't self‑approve their own gates. That separation is small but it's the difference between governance and theater.

Minimum lineage data model

You don't need a 60‑field data model to trace decisions. You need these. Any fewer and you can't reconstruct who decided what. Any more and nobody fills them in.

`` projectid (string, required) gateid (string, required) transitionid (string, required) decidedby (userId, required) decidedon (timestamp, required) decisionoutcome (enum: approve|reject|hold|waive) evidencesnapshotid (string, required) waiverreason (string, nullable) delegatedfrom (userId, nullable) sla_met (boolean, required) ``

The field doing the heavy lifting is evidencesnapshotid. It points at the frozen bundle from the routing table. Store this one field reliably on every transition and you can answer almost any audit question by dereferencing the snapshot — no need to store the whole decision context inline.

A pattern worth copying: make waiverreason a required string only when decisionoutcome = waive. Conditional‑required beats always‑required, because forcing a reason on every approval trains people to type "n/a" everywhere, which fills your lineage data with noise.

JSON schemas for mandatory evidence packages

Each evidence_key from the checklist maps to a schema. Your tool validates the submission against it before allowing the transition. Here are two of the gate‑critical ones.

Cost‑to‑complete (ctc_v1) — required at Fund gate:

``json { "$schema": "http://json-schema.org/draft-07/schema#", "title": "ctcv1", "type": "object", "required": ["projectid", "ctcamount", "currency", "confidence", "asofdate", "preparedby"], "properties": { "projectid": { "type": "string" }, "ctcamount": { "type": "number", "minimum": 0 }, "currency": { "type": "string", "minLength": 3, "maxLength": 3 }, "confidence": { "type": "string", "enum": ["low", "medium", "high"] }, "asofdate": { "type": "string", "format": "date" }, "assumptions": { "type": "array", "items": { "type": "string" } }, "prepared_by": { "type": "string" } } } ``

Acceptance tests (accepttestsv1) — required at Build gate:

``json { "$schema": "http://json-schema.org/draft-07/schema#", "title": "accepttestsv1", "type": "object", "required": ["projectid", "tests", "signedby", "signedon"], "properties": { "projectid": { "type": "string" }, "tests": { "type": "array", "minItems": 1, "items": { "type": "object", "required": ["testid", "description", "passcriteria"], "properties": { "testid": { "type": "string" }, "description": { "type": "string" }, "passcriteria": { "type": "string" }, "result": { "type": "string", "enum": ["pass", "fail", "pending"] } } } }, "signedby": { "type": "string" }, "signedon": { "type": "string", "format": "date" } } } ``

The minItems: 1 on the tests array is intentional. Without it, someone submits an acceptance‑test package with an empty array and the schema technically validates. That exact gap has let releases through with "acceptance tests defined" checked and zero tests actually written. Schema validation is only as good as the constraints you bother to add.

Keep confidence as an enum rather than a free number. A ROM estimate labeled "73% confident" implies precision nobody actually has. low/medium/high is honest and it routes better — you can set a rule that low confidence at the Fund gate escalates to the board automatically.

Import guidance

The order you load things matters, because the pieces reference each other. Load them out of order and you'll spend time cleaning up broken references.

  1. Load the role/authority matrix first. Everything else references roles. If Finance-Partner doesn't exist as a role in your tool, the checklist rows pointing at it will fail validation.
  2. Load the evidence JSON schemas next. Register each schema by its title so the evidence_key columns resolve.
  3. Load the checklist CSV. Map ownerrole to your tool's role field and evidencekey to the registered schemas.
  4. Load the routing table last. It depends on both checklist states and evidence keys already existing.
  5. Run one dry‑run project through all gates with dummy data before you turn on mandatory blocking. Turn blocking on gate‑by‑gate, not all at once — a big‑bang enforcement switch usually causes a revolt in week one.

For CSV import into most PPM tools, keep quoted fields (the comma‑separated snapshot keys) intact and verify your tool isn't silently splitting them on the inner commas. That's the most common import bug with this format.

Process diagram

This flow shows the recommended import order and the dry-run validation step.

When this pack fits — and when it doesn't

This makes sense when you're running enough projects that manual gate chasing has become someone's unofficial full‑time job, and when your PPM or workflow tool can store custom fields and evaluate transition conditions. If you've got 30+ active projects and a governance manual nobody imports, this is exactly the gap to close.

This is a bad idea when you have fewer than roughly eight active projects. At that scale, the overhead of maintaining schemas and routing tables outweighs the benefit — a shared spreadsheet and a weekly standup genuinely works better. Don't industrialize a problem you don't have yet.

Who should not do this: teams whose tool can't store structured custom fields or trigger on conditions. If your "PPM tool" is a shared folder of spreadsheets, importing JSON schemas into it is pointless. Fix the tooling foundation first, then come back.

A realistic before/after

A mid‑sized infrastructure PMO — around 40 active projects, four portfolio analysts — was spending most of the two days before each monthly gate review manually collecting evidence and confirming who had signed what. Gate reviews routinely ran long because half the "complete" items turned out to be missing an artifact, and three or four decisions a quarter got reopened because nobody could find the evidence as it looked at approval time.

After loading a version of this pack into their existing workflow tool and switching on mandatory blocking gate‑by‑gate over about six weeks, the pre‑review scramble dropped to a few hours. Mostly because incomplete evidence couldn't reach the review in the first place — the tool rejected it upstream. Reopened decisions fell to roughly one a quarter, and those were genuine scope changes rather than lost paperwork. Nobody added headcount. They just stopped chasing things manually.

The analysts' comment afterward was the useful part: the win wasn't the dashboards, it was that arguments about "who was supposed to approve this" basically stopped, because the authority was a field on the row.

Lightweight KPIs to watch adoption

Don't over‑instrument this. Four signals tell you whether the pack is actually being used or just technically installed:

  1. Gate pass‑through rate on first submission — rising means evidence is getting prepared correctly upstream
  2. Average SLA breach count per gate — should trend down within the first two months
  3. Waiver rate per gate — a high, sticky waiver rate means a mandatory item is miscategorized and should be reclassified, not endlessly waived
  4. Snapshot retrieval success in audits — the one that proves the lineage layer is real

If waivers on a specific item stay high for more than a couple of cycles, that item is in the wrong column. Fix the mandatory flag rather than letting people route around it — a rule everyone waives isn't a rule, it's just friction.

Closing note

Gate frameworks fail not because of bad intent but because they live as prose in a document instead of as rows, conditions, and schemas inside the tool where work actually moves. Everything in this pack is deliberately boring and structured for that reason — booleans, enums, required fields, snapshot keys.

Load the role matrix, register the schemas, import the checklists, wire the routing table, and let the tool do the chasing you've been doing by hand. Start with one dry‑run project, enforce one gate at a time, and watch the first‑submission pass rate. That number will tell you faster than any dashboard whether the pack actually took.

Gate frameworks fail not because of bad intent but because they live as prose in a document instead of as rows, conditions, and schemas inside the tool where work actually moves. Everything in this pack is deliberately boring and structured for that reason — booleans, enums, required fields, snapshot keys.

Load the role matrix, register the schemas, import the checklists, wire the routing table, and let the tool do the chasing you've been doing by hand. Start with one dry‑run project, enforce one gate at a time, and watch the first‑submission pass rate. That number will tell you faster than any dashboard whether the pack actually took.

Built for Project Leaders Tailored tools for portfolio planning & execution
Save Time Automate status updates and streamline workflows
Mitigate Risks Early detection with proactive alerts and analytics
Drive Results Maximize ROI through data-driven prioritization