Design Governance OS
An operating system to scale design quality in digital products and services—under real constraints—without bureaucracy.
Decision rights. Rituals. Quality gates. Patterns. Escalations. State models. AI/agent workflows.
The goal is simple: ship faster, with fewer regrets.
What this is
Design Governance OS is the minimum viable management system I use to run design at scale:
- Clarity: what we’re solving, for whom, and what “good” means
- Control: decision integrity, traceability, and risk-aware delivery
- Speed: fewer loops, fewer surprises, more confident releases
- Learning: explicit feedback loops that change what we do next
It is not “process”. It’s an operating model—designed like a product.
Why you need it
Two constraints define modern design leadership:
- Digital is networked
- The interface is no longer the boundary
So governance must cover state, policy, permissions, evidence, escalation, auditability—not just UI consistency.
You rarely “own the whole product”. You join an ecosystem: platforms, APIs, partners, regulators, vendors. Governance is how you keep coherence when ownership is distributed.
With agentic AI, the UX layer can migrate to the user side: agents orchestrate, choose, and act. Brand chrome collapses. Screens become optional.
When you need it
You need governance when any of these are true:
- Multiple teams ship to one experience (fragmentation risk)
- Regulated or high-stakes flows (error cost is real)
- Ecosystems and vendors (you don’t own the whole stack)
- Global scale (local layers vs common core)
- Agentic AI enters workflows (UX moves beyond screens)
If you’re a VP/Director, governance is how you scale judgment—not just output.
Design Governance OS — the core principle set
This OS is built on four foundations (see references):
Management is a design problem
Management innovation beats bureaucracy. Favor transparency, distributed decision-making, and human energy over control theatre.
Innovative cultures are paradoxes
- Tolerance for failure but not incompetence
- Willingness to experiment and highly disciplined
- Psychologically safe and brutally candid
- Collaboration and individual accountability
- Flat and strong leadership
Culture change is breaking a social contract. Expect resistance.
Rigor, honesty, and “the form is”
Quality is not what a product “seems”. It is what it is.
Governance creates the conditions where teams can build “honest” products—structurally sound, not cosmetically persuasive.
Method + playful experimentation
Creativity comes after constraints. Prototype with models. Test. Choose the simplest viable solution.
Play is not chaos. It’s structured exploration—welcoming error and diversity to find the exact form.
The OS in one page
Design Governance OS runs as three loops:
Loop 1
Direction
- Strategy and intent are explicit
- Constraints are real and named
- Success is measurable
Loop 2
Delivery
- Small batches, clear ownership, rapid convergence
- Fewer “review ceremonies”, more decision artifacts
- State and edge cases designed early, not at the end
Loop 3
Governance
- Decision rights are explicit
- Patterns evolve with rules
- Escalation exists and is usable
- Evidence is visible (why this, why now)
Governance primitives
These are the building blocks. Lightweight by design.
1
Decision rights
- Product direction vs experience direction
- Pattern ownership vs local exceptions
- Risk acceptance authority (privacy/security/AI)
Rule: if decision rights are unclear, you don’t have autonomy—you have noise.
2
Critique rituals
- Regular cadence
- Clear entry criteria
- “Brutally candid, psychologically safe”
- No drive-by opinions; use a memo
3
Quality gates
- Pre-commit checks for key flows
- Release criteria for high-stakes journeys
- Accessibility, recoverability, compliance usability (not just compliance)
4
Pattern evolution rules
- Adoption rules (when required vs optional)
- Exception process (how to deviate safely)
- Versioning and deprecation rules
- Evidence-backed changes
5
Escalation paths
- When a decision is blocked
- When risk is unclear
- When cross-team impact is likely
If escalation is political, teams hide problems until launch.
6
State model first
- Happy path is not a plan
- Exceptions are where trust is won or lost
- Recoverability is a design requirement
7
Agentic workflows (new default)
- Autonomy gradients (progressive autonomy)
- Handoff and override (human-in-the-loop by design)
- Policy visibility (guardrails users and operators can understand)
- Audit trail UX (usable by ops/compliance, not only machines)
What “good” looks like
If the OS is working, you see:
- Fewer late-stage reversals
- Faster cross-team alignment
- Consistent product language without homogenized thinking
- Patterns that evolve without breaking teams
- High-trust flows that remain understandable under stress
- Agentic systems that don’t fail silently
Metrics that matter
Governance must be measurable.
Leading indicators
- Decision cycle time (from question → decision)
- Rework rate after critique (should go down)
- Pattern adoption rate vs exception rate
- % flows with defined states + recovery paths
- AI incidents avoided by design (guardrail catches)
Lagging indicators
- Support debt (tickets, escalations, time-to-resolution)
- Delivery predictability (slippage due to design ambiguity)
- Trust signals (drop-offs at consent steps, dispute rates)
- Compliance outcomes with operational usability
How I work with leaders
I typically contribute in three modes (often combined):
Mode 1
Design leadership operating model
- Governance, decision rights, rituals, team topology
- Org design is part of the product
Mode 2
Opportunity-to-product acceleration
- Research → framing → prototyping → service/product definition → delivery alignment
- Agile, sprints, iteration—without theatre
Mode 3
Portfolio framing (VP-level)
- Where to play / where not to
- Horizons, risk appetite, investment logic, measures of progress
I’ve facilitated 250+ workshops, from tight exec sessions to multi-stakeholder forums—always oriented to decisions and delivery-ready outputs.
If you want to use this
- Start with one team + one critical journey
- Implement: decision memo + state model + one quality gate
- Ship. Measure. Iterate.
- Expand only when the loop is working
Governance only scales when it’s earned by usefulness.
References
I did not come up with this from thin air. This is the result of over 20 years’ experience designing digital solutions, life experience, and—crucially—standing on the shoulders of giants such as:
- Gary Hamel — this is where my management innovation and anti-bureaucracy stance comes from
- Gary P. Pisano — The hard truth about innovative cultures; I use this as a neat framework for setting team rules
- Enzo Mari — rigor, honesty of form, didactic practice; really, my basic first principles
- Bruno Munari — method, constraints-first creativity, playful experimentation; because you need to be methodically crazy, at heart
Contact
Let’s discuss a leadership role, advisory work, or a complex product challenge.