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.
-
Every checklist item has a discrete state (notstarted / inprogress / complete / waived) a tool can store
-
Every gate transition has an explicit owner or queue, not a vague "the board decides"
-
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.
Stop losing track of critical projects.
GoProjy helps you monitor, prioritize, and deliver projects on time—seamlessly.
- Unified portfolio visibility
- Real-time resource tracking
- Milestone & risk alerts
No credit card required
``
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:
-
mandatoryis 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. -
waiver_authorityis 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. -
sla_hoursis 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.
| Role | Can Approve Gate | Can Waive Mandatory | Can Delegate To | Delegation Cap |
|---|---|---|---|---|
| PMO-Lead | G1, G2 | G1, G2 non-finance items | Portfolio-Analyst | 1 gate level |
| Finance-Lead | — | Any finance item | Finance-Partner | ROM items only |
| Portfolio-Board | G3, G5, G6 | Any item, logged | PMO-Lead (interim) | 72h, 1 project |
| Delivery-Lead | G4 | G4 non-security items | Release-Mgr | 1 gate level |
| CISO-Delegate | — | Security items | Security-Lead | Logged, 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.
-
Load the role/authority matrix first. Everything else references roles. If
Finance-Partnerdoesn't exist as a role in your tool, the checklist rows pointing at it will fail validation. -
Load the evidence JSON schemas next. Register each schema by its
titleso theevidence_keycolumns resolve. -
Load the checklist CSV. Map
ownerroleto your tool's role field andevidencekeyto the registered schemas. -
Load the routing table last. It depends on both checklist states and evidence keys already existing.
-
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.
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:
-
Gate pass‑through rate on first submission — rising means evidence is getting prepared correctly upstream
-
Average SLA breach count per gate — should trend down within the first two months
-
Waiver rate per gate — a high, sticky waiver rate means a mandatory item is miscategorized and should be reclassified, not endlessly waived
-
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.
Ready to elevate your project delivery?
Join over 2,500 project teams using GoProjy to optimize resources, reduce risks, and drive portfolio success.