A product operating model is the explicit set of principles, rituals, artifacts, and decision rights a team can lean on to make most calls without escalating to you. Design it well and it replaces your judgment-in-the-room with codified defaults — so scaling means building better defaults, not sitting in more meetings.
Quick answer: A product operating model = principles (why we decide) + rituals (when decisions happen) + artifacts (what gets produced) + decision rights (who owns each call). Design all four on purpose and teams stop needing you for roughly 90% of decisions.
Most directors scale the wrong lever. They add more syncs, more review gates, more "just loop me in" requests — and end up more load-bearing, not less. A real operating model inverts that: it's infrastructure your org runs on when you're in back-to-back meetings, on a plane, or simply not in the room. Everything below is built to be codified once and reused hundreds of times.
What a Product Operating Model Actually Is
A product operating model is the combination of four elements: principles that describe how your org reasons about tradeoffs, rituals that create predictable moments for decisions, artifacts that document standards so nobody reinvents them, and decision rights that name who owns each call. Miss any one of the four and defaults quietly collapse back to "ask the director."
Each element does a different job, and none of them substitutes for the others. A principle without a ritual is a poster on the wall. A ritual without decision rights turns into a meeting where everyone talks and nobody decides. Here's what each one actually looks like in practice.
Principles — the why
Principles are the 4-6 tradeoffs your org has already resolved, stated plainly enough that a PM two levels down can apply them without asking. Examples: "we ship narrow and iterate over shipping broad and polishing," or "retention problems outrank acquisition problems when both are true." Vague values statements ("we're customer-obsessed") don't count — a principle only works if it resolves a real tension.
Rituals — the when
Rituals are the recurring moments where a category of decision is supposed to get made — a weekly triage, a monthly roadmap review, a quarterly bet-sizing session. If a ritual doesn't exist for a recurring decision type, that decision defaults to whoever's loudest or whoever happens to catch you in the hallway. The operating cadence and rhythms a director sets is really the ritual layer of the model made concrete.
Artifacts — the what
Artifacts are the standard documents and templates that carry the model's logic forward: a PRD template, a roadmap review deck, a discovery brief, a decision log. A good artifact does the thinking so the author doesn't have to reinvent structure every time — it just needs filling in, not designing from scratch.
Decision rights — the who
Decision rights name, for each recurring decision type, who recommends, who has to agree, and who has final say. Without this layer, rituals produce discussion but not resolution — everyone leaves the room assuming someone else will decide. We'll build a starter version of this below.
Operating Model vs. ProductOps-as-a-Team: Why the Distinction Matters
A product operating model is a system of defaults every team follows; ProductOps is one possible team that helps build and maintain that system. You can run a strong operating model with zero ProductOps hires, and you can hire a ProductOps team that never actually changes how decisions get made. The model is the goal — the team is optional infrastructure.
Melissa Perri and Denise Tilles, in their book on the discipline, make this distinction explicit: ProductOps as a function exists to scale the operations of product management — tooling, data pipelines, onboarding, reporting cadences — while the operating model itself is the org's shared decision logic, which any director can start building alone, with no dedicated headcount at all. Confusing the two is how orgs end up hiring a ProductOps lead and then wondering, a year later, why nothing about how decisions get made has actually changed.
| Dimension | Product Operating Model | ProductOps (the team) |
|---|---|---|
| What it is | Shared defaults: principles, rituals, artifacts, decision rights | A function that builds tooling, data, and process support |
| Who owns it | Every PM and cross-functional lead, championed by the director | Typically 1-3 dedicated people (or zero) |
| Requires headcount? | No — can run on templates, rituals, and discipline alone | Yes, dedicated capacity |
| Failure mode without it | Every decision escalates; the director becomes the bottleneck | Tools and dashboards get built that nobody adopts, because decision rights were never clarified |
| When to invest | Immediately, at any org size | Once repetitive operational load — onboarding, reporting, tool admin — justifies dedicated capacity, commonly somewhere past 15-20 PMs |
The practical takeaway: fix the model first. Deciding whether ProductOps deserves its own headcount is really a team-boundary and org-design question — you're drawing a line around a new function, and that line only makes sense once the decisions it's meant to support are already defined.
A Starter Decision-Rights Framework: RAPID and DACI
Decision rights fail most often not because nobody thought about them, but because they're implicit — everyone has a slightly different mental model of who actually decides. RAPID (Recommend, Agree, Perform, Input, Decide), developed by Bain & Company, and DACI (Driver, Approver, Contributors, Informed), which originated at Intuit and was popularized by Atlassian, are both real, widely used tools for making that model explicit. Pick one org-wide; don't run both.
Both frameworks solve the same core problem from slightly different angles:
| Role | RAPID | DACI | What it means |
|---|---|---|---|
| Drives the process | Recommend | Driver | Owns pulling together the proposal and running it to a decision |
| Must sign off before it moves | Agree | Approver | Can block; typically legal, finance, security, or a peer lead with veto-worthy stake |
| Does the resulting work | Perform | (implicit in Driver's team) | Executes once the decision is made |
| Consulted, not a blocker | Input | Contributors | Gives context and opinions but doesn't have to sign off |
| Makes the final call | Decide | Informed owns the call; others just kept in the loop | One named person, not a committee |
A few rules of thumb for standing this up without turning it into more bureaucracy:
- Name a person, not a title, for the Decide/Approver role on each recurring decision type — "the director" as a catch-all just recreates the bottleneck.
- Keep Agree/Approver short. Every additional required sign-off is a place a decision can silently stall; two or three is normal, five is a design flaw.
- Reserve the full framework for decisions that matter. Not every choice needs a RAPID chart. Amazon founder Jeff Bezos's now-widely-cited distinction between one-way-door decisions (hard to reverse, worth real deliberation) and two-way-door decisions (cheap to reverse, should be made fast by whoever's closest to the problem) is a useful filter — apply RAPID or DACI to one-way doors, and let individual PMs decide two-way doors on their own judgment.
- Publish the chart somewhere durable — a wiki page, not a slide that was shown once in a meeting six months ago.
McKinsey's long-running research into organizational decision-making backs up why this is worth the setup cost: companies rated highly effective at decision-making are, across multiple survey waves, roughly twice as likely to report strong financial performance as those rated ineffective — and the single biggest driver respondents cite isn't smarter people, it's clarity about who actually decides.
Encoding a Discovery Standard So Teams Stop Asking Permission
A discovery standard is a pre-agreed answer to the questions PMs otherwise ask you one at a time: how much evidence is enough, which methods count, and when discovery is "done" enough to start scoping. Encode it once as a checklist or gate, and a PM can self-certify readiness instead of booking time on your calendar to ask.
Here's a concrete example a director could actually ship this quarter. For any initiative above a defined impact or effort threshold, require, before scoping begins:
- A minimum of 5 customer conversations, structured around a Jobs to Be Done framing rather than open-ended chat, so evidence is comparable across PMs.
- A validated problem statement that names the job, the current workaround, and why it's currently unsatisfactory.
- A customer journey view showing where the emotional low point sits relative to the proposed fix — so the team can see whether they're solving the actual moment of pain or a nearby symptom.
- A one-line confidence rating (high/medium/low) the PM assigns themselves, with low-confidence work routed to a lightweight review rather than blocked outright.
Teresa Torres, author of Continuous Discovery Habits, argues for a related standard that's become common in strong product orgs: at least one customer touchpoint every single week, for every product trio, independent of any specific project. That cadence is itself a discovery standard — it turns "should we talk to customers about this" from a judgment call into a default nobody has to argue for.
The before/after is the clearest way to see what encoding actually buys you:
| Question | Without a standard (ask permission) | With a standard (encoded default) |
|---|---|---|
| Is this worth researching? | PM emails director, waits for a reply | Threshold is pre-defined by impact/effort; PM self-serves the answer |
| How many customers is enough? | Varies by whoever's asked, inconsistent across teams | Fixed minimum (e.g., 5 conversations), same bar everywhere |
| When is discovery "done"? | Ends when the director says stop | Ends when the checklist is satisfied |
| What if confidence is low? | Escalates to a meeting | Routes to a lightweight peer review, no director required |
Once a standard like this exists, your job in most discovery conversations shifts from gatekeeper to spot-checker — you're auditing a sample of the work against the standard, not personally approving each instance.
Rituals and Artifacts That Keep the Model Alive Between Meetings
A model only survives contact with a busy quarter if its rituals are cheap to run and its artifacts are good enough that people actually reach for them instead of freelancing. Pick one durable weekly, one monthly, and one quarterly ritual and staff them with clear decision rights — more than that, and the calendar itself becomes the bottleneck you were trying to remove.
The operating cadence a director sets is where rituals actually live day to day: a weekly triage where two-way-door prioritization calls get made by the PM lead, a monthly roadmap review where one-way-door bets get an Approver sign-off, and a quarterly reset where principles themselves get revisited rather than assumed permanent.
Artifacts do the quieter half of the work — a good template means a PM never has to decide "what goes in a PRD" from scratch, which is exactly the kind of low-value decision an operating model should absorb. This is one place worth being concrete about tooling rather than hand-waving it.
Rolling Out the Model Without Losing the Room
The rollout mistake most directors make is announcing the whole model at once, in a deck, with no pilot. A model earns trust by proving itself on one decision type before it gets applied everywhere — start narrow, let the first ritual and its decision rights actually work, then expand.
A sequence that tends to hold up in practice:
- Pick one recurring decision that currently escalates to you too often — roadmap reprioritization is a common first target.
- Assign RAPID or DACI roles to it explicitly, name real people, and publish the chart.
- Run it for one full cycle before adding a second decision type to the model.
- Retire your own habitual override. If you keep quietly re-deciding things after the named Decide-holder has already decided, the model never actually takes hold — the team learns your override, not the chart.
- Expand to the next decision type only once the first one is running without you.
None of this works if the people you're delegating to don't have the judgment to fill the gap you're leaving. That's why an operating model and a hiring bar are the same conversation in disguise — interviewing for judgment, not just experience is what makes it safe to hand a Decide role to someone two levels down. A model built for a team you don't yet have is just a nice document.
If you're rethinking the operating model as part of a broader look at what the role covers, it's worth zooming out — the complete guide to the director of product role covers where operating-model design sits alongside hiring, strategy, and stakeholder management as the core of the job.
Key Takeaways
- A product operating model has four required parts — principles, rituals, artifacts, decision rights — and skipping any one collapses defaults back to "ask the director."
- ProductOps-as-a-team is optional infrastructure, not the model itself — you can build a strong operating model with zero dedicated headcount, and a ProductOps hire without a clear model just builds tools nobody adopts.
- RAPID and DACI are real, well-tested decision-rights frameworks — pick one, name real people (not titles) for the Decide/Approver role, and reserve the full process for one-way-door decisions.
- A discovery standard turns "can I research this" into a self-serve checklist — a minimum evidence bar, a JTBD-based conversation count, and a confidence rating remove most of the permission-asking.
- Rituals need artifacts to survive busy quarters — a standardized spec or PRD format is one of the highest-leverage artifacts a director can codify, since it removes a recurring low-value decision from every PM's plate.
- Rollout is sequential, not a single announcement — pilot one decision type, retire your own habit of overriding it, then expand.
- The model only works with the right people under it — codifying decision rights is inseparable from hiring PMs who exercise good judgment.
Frequently Asked Questions
What's the difference between a product operating model and a roadmap process?
A roadmap process is one artifact inside a broader operating model, covering a single decision type (what ships when). The operating model is the full system — principles, rituals, artifacts, and decision rights — that governs every recurring decision type, of which roadmapping is just one.
Do we need a dedicated ProductOps team before we can build an operating model?
No. An operating model can run entirely on templates, named decision rights, and disciplined rituals with zero dedicated headcount. ProductOps becomes worth hiring once the operational load of maintaining those systems — tooling, reporting, onboarding — outgrows what a director and their PM leads can sustain alongside their day jobs.
How many decision-rights frameworks should a product org run at once?
One. Running RAPID in one part of the org and DACI in another creates translation overhead with no real benefit — pick whichever your leadership team already recognizes (often DACI if you're Atlassian-adjacent tooling-wise, RAPID if a consulting background is common) and apply it consistently.
How long does it realistically take to roll out an operating model?
Expect one full cycle per decision type before it's running without you — for a weekly ritual, that's roughly a month to trust the first decision type, then incremental expansion. Trying to launch principles, rituals, artifacts, and decision rights for every decision type simultaneously is the most common way rollouts stall.
What should a director codify first if nothing is written down yet?
Start with whichever single decision currently causes the most escalations to your inbox or calendar — for most growing orgs that's roadmap reprioritization or scope cuts near a launch. Naming decision rights for that one decision, then adding a lightweight ritual around it, delivers the fastest visible relief.