An operating system for the role — a head-start from a friend

You run the work. The system runs the overhead.

A light operating model for an ambiguous role: drop into very different initiatives, diagnose or build, make it work, hand it back cleanly — and keep visibility without ever calling a status meeting. This is how you cover the missing PM seat without becoming the PM. Tell me where it breaks.

You're reading Phase 6, early. A record you can ask, instead of a doc you won't read.

The operating model

Six phases, two modes — diagnose or build

This is not a process to impose on Adam's team — it is how you are thinking about running your piece, captured from everything you talked through, so it survives contact with the messy middle. The role is ambiguous by design: the teams you direct change every initiative, the work sits on top of everyone's day job, and you own the framing and the handover, not anyone's roadmap. So this is a flexible spine, not a fixed pipeline. It flexes between diagnosing a problem and building something new, and it dials up or down per initiative. The one genuinely novel move is the medium itself: your own thesis is that nobody reads the three-page document — they skim half and ask again — so this site lets people ask an assistant instead of reading. Everything below is yours to keep, sharpen, and hand to anyone who wants to tear it apart.

1 Intake A gate, not an inbox — decide whether and how to take work on, and frame it before any planning.
InputsSponsor and decision-maker; the problem in one sentence; desired outcome and how you will know; hard deadline versus soft; people you can realistically release and their managers; the success metric and its current baseline; diagnose or build; who loses something if this succeeds.
OutputA one-page Intake Brief plus a logged triage decision: take, defer, decline or redirect, with a one-line rationale.
StandardOne front door. All work applies through the same form so it stops arriving ad hoc. The power of the front door is not tidiness — it is the evidenced no.

The first decision at the door is diagnose or build, because they need different teams, timeframes and exit criteria — a diagnosis ends in a recommendation and a decision-maker; a build ends in a working thing and an owner. A single intake form alone only makes the queue tidy, so it carries a light triage rubric: a weighted view of sponsor commitment, strategic fit, expected impact and feasibility given current portfolio load, resolving to take, defer, decline or redirect with the reason logged. Capture the political shape here too — who benefits and who loses time, control, headcount or scope — because on cross-team platform work that single question surfaces the resistance that otherwise sinks the initiative at handover. Critically, the handover acceptance criteria and the named receiving owner are co-authored now, at the start, not discovered at the end. Every number is yours to fill: [your success metric and its baseline], [the hard deadline], [what is explicitly out of scope].

2 Plan Turn the framed objective into a sequenced plan and secure the people via the buy-in cascade.
InputsThe intake brief; the buy-in cascade — leadership names the established partners, you confirm org-level buy-in, then you secure the management-layer support that actually releases people's time.
OutputA sequenced plan with milestones and roles; a power/interest stakeholder map; a RAPID chart for the few consequential decisions; a written, lightweight commitment per contributor.
StandardCapacity is borrowed, not owned. You secure the manager who owns the person's time, not just the person.

Because the work sits on top of day jobs, the real constraint is capacity, not tasks — so the cascade produces a visible, lightweight commitment per contributor naming the person, their manager, the agreed time (roughly [hrs/week per contributor]) and the duration. That is what you point back to when a day-job priority spikes and capacity gets withdrawn, and it makes the manager, not you, the owner of the trade-off. Two stakeholder artefacts ground the plan: a power/interest map (so the cascade targets the right managers, not just the willing ones) and a RAPID decision-rights chart for the three to five consequential decisions — who Recommends, has Input, Agrees, Decides and Performs — with the Decider named explicitly. The most expensive failures are decisions everyone assumed someone else owned. Keep RACI for the delivery-task layer inside a single workstream; use RAPID for the decisions that matter.

3 Mobilise Get everyone aligned and the workspace ready before the kickoff meeting — so the kickoff is alignment, not setup.
InputsConfirmed team and re-confirmed manager-agreed time; access and permissions; the comms and documentation standards; the day-one risks, assumptions and dependencies.
OutputA stood-up project space — the recommended five-folder scaffold — plus a kickoff pack covering the what, how, when, roles and responsibilities, intros and ways of working.
StandardA minimum shared spine whose only job is to make autonomy safe: one comms channel, one place decisions and actions get logged, one definition of done. The five-folder scaffold is the recommended default that delivers it — rename or reshape it freely, provided the decisions-and-actions log and the handover folder exist. Everything else the team shapes.

The scaffold is a recommended, opinionated default, not a fourth non-negotiable — the team can rename or reshape it as long as two folders survive: the decisions-and-actions log that the status-scrape reads, and the continuously-built handover folder. The default five: 01_Charter (intake brief, sponsor, success metric), 02_Plan (sequence, milestones, roles), 03_Working (where the actual artefacts live), 04_Decisions_and_Actions (the log the status-scrape reads), 05_Handover (built up continuously across the project, so closeout is assembly, not authorship). Seed three things at kickoff: a RAID log with the obvious day-one risks, assumptions and dependencies; escalation paths agreed in the room (what escalates, to whom, how fast, and a default that a blocked dependency unresolved for [N] days auto-escalates to the management layer); and the handover acceptance criteria co-authored with the receiving owner. The tension between minimal intervention and non-negotiable standards is resolved out loud: the standards are deliberately tiny and exist solely so people never get pinged for status. The rule that makes the one-channel discipline stick without policing where people chat: people can talk anywhere, but a decision is not real until it lands in the decisions log.

4 Execute Teams deliver; you keep visibility without micromanaging and without status meetings — by managing by exception.
InputsThe disciplined documentation the team already keeps — progress, decisions, open actions, issues, risks, assumptions and dependencies (the team-site method).
OutputA pushed weekly status digest scraped from the record: what moved, what was decided, what is blocked, what is at risk — never a meeting.
StandardThe trade: keep three things current — decisions made, open actions, blockers and risks — and you will never put a status meeting on a calendar. If it is documented, you will find it.

The system does not surface status; it surfaces exceptions — a slipped milestone, a red RAID item, a dependency blocked longer than [N] days, or a workstream that has gone silent. Silence is itself a signal: the most dangerous status is the absence of one, so a stream that has not updated gets flagged. You only enter a conversation when a tolerance is breached — management by exception, in the PRINCE2 sense. A contributor going dark is treated as an escalation back to their manager via the cascade, not a personal chase, which protects you from being blamed for slippage that is actually an upstream capacity withdrawal. This is what visibility without status meetings means in craft terms: status is a pull from where work already happens, not a tax on the people doing it.

5 Closeout / Handover Hand back to the business cleanly against a bar agreed up front, and capture the lessons — verify, do not negotiate.
InputsThe full project record; the handover acceptance criteria co-authored at Intake/Plan; closeout feedback — what worked, what was poor, what you would change if you started again tomorrow.
OutputA templated handover pack plus the QBR/EBR view for leadership, identical every time.
StandardA handover threshold the receiving owner signs against a pre-agreed Definition of Done — with a defined post-handover support window that has an explicit end date.

The handover pack verifies against the criteria agreed at Mobilise; it does not invent the bar at the end. It contains the SOP (the refined how-it-works), the decision log (what was chosen and why), the RAID at handover (what is still open and who owns it now), the closeout retro, sign-off against the agreed Definition of Done, and the named receiving owner. The checklist the owner signs: a named accountable owner has accepted; the SOP exists and the owner has executed it once unaided; the success metric is instrumented and someone is watching it; the escalation path and on-call are named; and there is a support window with an explicit end date — you stay on call for [support window length], then it is fully theirs. That last item is what stops a hand-back team from silently owning the work forever. For an inner-source-style handover the threshold should also answer some operating-governance questions — confirm these with Adam and Danica rather than assuming them: who the named maintainers are and whether they have agreed to the maintainer load; what the contribution, review and merge process is; how security and quality gates apply to contributors from outside the owning team; who owns triage of incoming contributions; and whether handed back means the platform team accepts ongoing ownership of code other teams keep changing. Add a benefits-realisation check-back date so the outcome, not just the clean handover, gets verified.

6 Portfolio A bird's-eye view across all initiatives, lightweight post-handover health tracking, and a reusable learnings library.
InputsThe project records across all live and handed-back initiatives; the structured closeout retros and decision logs.
OutputA one-line-per-initiative portfolio register, a people heat-map, a cross-initiative dependency view, and a queryable learnings library — generated, never hand-maintained.
StandardGenerated, not maintained. If it needs manual upkeep it will die. It scales up only when the portfolio earns it.

Keep the view to three flags, not a dashboard sprawl: initiative health (RAG, derived from milestones and RAID, not self-reported); a people heat-map flagging anyone load-bearing on three or more initiatives — the silent-bottleneck detector, since the same competent people get pulled into everything, quietly overload and become the bottleneck no single project's docs reveal; and cross-initiative dependencies. The portfolio register is one row per initiative: name, sponsor, diagnose-or-build, current phase, accountable owner, RAG, handover date, support-window-ends date. The benefits-realisation check carries the Phase 1 success metrics through to a post-handover interval ([30/60/90 days] — your call) so leadership's first question, did it work, has an answer beyond we handed it over cleanly. The learnings library is a by-product of every templated closeout, not a curation job — which is exactly why an adjacent team (Manufacturing reusing AEC's playbook) can stop relearning the same lessons. Two views of the same rows: the exec QBR sees outcomes, health and risk; the next delivery team sees decisions, what broke, and what they would do differently.

The automation engine — what you could build over time

One engine. Three faces. The messy middle handled by AI.

Inputs arrive in every flavour — transcripts from Teams, Zoom, Salesforce and customer calls, plus Jira, wikis, product boards and git — and different consumers want different outputs in different formats. You want a linear process with one standardised output every time, with AI handling the messy middle, without controlling how anyone works. The honest constraint that makes it credible: you do not change where people work — you mirror it into one normalised record.

01

Ingest

Two tiers, stated plainly. Tier 1 today: a drop-zone — a watched folder or channel where transcripts and exports are dropped, zero integration, respects existing permissions, works immediately. Tier 2 later, one system at a time and each with its own security sign-off: read-only connectors to the highest-value source first (the meeting-transcript system, because that is where decisions and actions are spoken). Staleness detection lives here too — no input from a workstream is itself an output.

02

Normalise

Every input collapses into one common schema — the artefact the whole engine rests on. A record is { project, date, source_link, type (progress | decision | action | issue | risk | assumption | dependency), summary, owner, status, due/target, confidence }. Risks, assumptions and dependencies are first-class fields, not afterthoughts — without them you can never produce a real RAID-backed status or a learnings library, only a tidy activity report. This schema IS the where-we-document standard from Phase 3, written so a machine can read it; agree it once and never re-litigate it.

03

AI processing

The model maps the normalised records to the right output template. It is extractive-and-templating, not generative-from-nothing: it summarises and renders, it does not invent. Every generated statement carries its source record forward (the source_link field), so a QBR or handover pack can be trusted and audited. Where a field is missing, the AI asks for it rather than silently inferring — gaps surface as gaps.

04

Standard outputs

One engine, three faces, depending on which window it reads. Phase 4 reads the team-site and emits the weekly status. Phase 5 reads the whole project record and emits the SOP, the templated handover pack and the QBR/EBR. Phase 6 reads across projects and emits the portfolio view and the per-persona learnings library. You do not build three tools — you build one engine and point it at a wider window.

05

Delivery

The document plus a 90-second cheat-code clip — the skim layer for the people who will not read three pages. Staged honestly: v1 is a five-bullet TL;DR and a 150-word script at the top of every doc (costs nothing, lands the value now); v2 is a synthetic voiceover over the key figures rendered to a short video; v3 is a fully automated clip per output. The video is polish, never a day-one prerequisite. The microsite you are reading is this delivery model working: ask, do not read.

Intake briefWeekly status updateSOPQBR / EBR viewHandover pack
Delivery — ask, don't read

Default delivery is the document plus a 90-second cheat-code clip and an assistant people can simply ask — because nobody reads the three-page doc; they skim half and ask again. The microsite is that delivery model made real and is, in effect, Phase 6 demonstrated early: a normalised record store you can ask questions of. A human approves every leadership-facing output before it ships, and the trust dial turns from manual (heavy editing) to assisted (spot-check) to exception-only (review flags) as accuracy is proven. The model is never the final author of anything leadership sees.

Start here — the first build

Start here, this month, with no new infrastructure: pick one live initiative, take its weekly meeting transcript or the team-site notes, run it through a fixed prompt that extracts the seven record types and renders a one-page status brief, you edit it and post it. That is the whole v1 — one input, one output, one human approving. Measure two things only: did it save you an hour, and did people stop asking where are we. If that single loop holds, every later phase is justified. Do not build the platform; build the one loop that proves the platform is worth building.

Governance

Conceptual future state, subject to Autodesk security review and the tooling Autodesk already runs. The model runs inside an approved, governed stack — zero data retention, no training on internal data, no consumer accounts, nothing pasted into unmanaged tools. Derived artefacts inherit the source system's permissions: if you cannot see the team-site, you cannot see its generated status — no new place for data to leak. At v1 almost none of this is custom software: the drop-zone is a folder, the normaliser and templater are a well-engineered prompt against a governed model, the store is the team-site you already mandate. The rare assets are the operating model and the schema — which is exactly why you, the operator, own this, not an engineering team. Built to pass a security review, not to need an exception.

The boardroom version

The same thinking, as a deck

When you want to put this in front of Adam, here it is in Autodesk's own language — fourteen slides covering the operating model and the automation, ready to present. Flip through it here, open it full screen, or take the file.

The first ninety days

Confirm first. Harden nothing until you have.

30First 30 days
  • Confirm the current state first — how Adam's team actually runs Taito (booster/jetpack), the inner-source model and the onboarding experience today — and harden nothing until you have.
  • Run intake on whatever is already live, deciding diagnose-or-build for each, and publish the single intake form as the front door.
  • Stand up the recommended five-folder scaffold and the minimum shared spine: one comms channel, one place decisions and actions get logged, one definition of done.
  • Get Adam's answers on the open questions: who assigns work, who owns the PM gap until it is solved, and where things live.
60By 60 days
  • Run a real kickoff to the template, seeding the RAID log, escalation paths and co-authored handover acceptance criteria in the room.
  • Start scraping status from the documentation instead of holding status meetings — push the first weekly digest and let silence flag itself.
  • Draft the first templated handover SOP, with the signed threshold and the support window that has an explicit end date.
  • Make the recommendation on the missing project-manager seat — framed as how the system already covers the function, not a request for headcount.
90By 90 days
  • Stand up the lightweight portfolio strip — one row per initiative — plus the people heat-map that flags anyone load-bearing on three or more initiatives.
  • Pilot the automation on a single output (status or handover) for one initiative, human-approved, on the drop-zone — no connectors.
  • Show the cheat-code clip and this assistant as proof the delivery model works.
  • Begin the learnings library as the filed by-product of the first closeout, and set the first benefits-realisation check-back date.
The PM seat

There's no project manager — this is how you cover it

There is no project manager on the team today, and you flagged that you will otherwise absorb that role yourself. This operating system is the answer, not a complaint: the intake form, the scaffold, the doc-scrape status method and the templated handover ARE the PM function, systematised. You are not asking for a PM on day one; you are building the system so the team does not need a full-time one for routine coordination — and so that when a PM is eventually added, they inherit a running machine instead of chaos. That is a far stronger thing to put in front of a director than a request for headcount.

Ask it anything

Don't read the doc. Interrogate it.

This assistant knows the whole operating system — the phases, the buy-in cascade, running execution without status meetings, the templated handover, the portfolio view, and the automation you could build. Ask it the way your stakeholders will.

Ask me about your operating system — intake, the buy-in cascade, running execution without status meetings, the templated handover, the portfolio view, or the automation engine you could build over time. Everything here is what you talked through, captured and written up — and you are getting it by asking, not by reading a three-page doc, which is the whole idea. Where shall we start?

Grounded only in Emi's operating system. It won't invent facts about Autodesk or anyone's roadmap.

One last thing

Built for you to tear apart

This is a starting point built for you to tear apart, not a doctrine to adopt. The standards are light on purpose, the automation is what you build over time rather than day one, and every number on every page is yours to set. The questions worth putting to the team: where does this break against how you actually work, what is the one standard worth making non-negotiable, what should you drop, and who owns the PM gap until it is solved. And the proof is already in your hands — you reached these answers by asking an assistant, not by reading the three-page doc. The medium proves the message.