Access code

This case study requires a six-digit access code. If you do not have one, contact me and ask.

Design Operations

Design culture does not come from advocacy. It comes from infrastructure: the cadences, records, and review structures that let designers do their best work inside organizations that run on governance.

  • Team Structure
  • Rituals & Reviews
  • Decision Logs
  • Mentoring

How I work here

The cadences are explicit: weekly design syncs with business owners, cross-domain reviews aligning UX, data, and engineering, and quarterly sessions where progress and dependencies are presented to leadership in operational terms. On the procurement platform, that structure is what kept three concurrent validation axes from becoming a bottleneck.

Documentation is the team's memory. Decision logs and dual-documented components turn design into an auditable process, which in a compliance-driven culture is worth more than any argument about craft.

I lead the way I like being led: pairing with earlier-career designers on the hardest surfaces, and setting review structures that hold quality when I am not in the room. Parallel workstreams demand design-ops discipline; shared documentation and unambiguous ownership are not optional at scale.

Cadences that keep design fast

Process earns its keep when it removes ambiguity, not when it adds ceremony. The core set is small: a weekly sync where in-progress work meets the people who own the business problem, a cross-domain review where design, data, and engineering reconcile their views of the same feature, and a periodic session where progress and dependencies are presented to leadership in operational terms.

Each ritual carries decision rights: who is consulted, who decides, what gets recorded. The agenda states the decision being asked for, the log records the one made, and a review that cannot conclude anything gets folded into one that can. Meetings that only report status are the first thing this discipline deletes.

Documentation is the team's memory

Teams re-litigate decisions they cannot find. Decision logs fix that: the option chosen, the options declined, and the reasoning, kept where the work lives rather than in slides. Paired with spec standards (states, content rules, accessibility criteria), they make design auditable, and in governed organizations auditability converts directly into latitude.

Documentation is also what survives personnel change. A team whose reasoning is written down can absorb new designers, rotate ownership, and disagree productively. A team whose reasoning lives in one person's head has a bus factor of one.

Growing designers inside the work

Mentoring happens in the work, not beside it: pairing on the hardest surfaces, critique that addresses the reasoning rather than the pixels, review structures that hold quality without requiring the lead in every room. The aim is a team whose judgment compounds, so the operating system runs when nobody is watching it.

The same structures set the quality bar: a definition of done that includes documentation and accessibility, and feedback loops with engineering that treat handoff as a conversation rather than a delivery.

What this covers

  • Review structures and decision rights
  • Decision logs and documentation standards
  • Rituals that reconcile UX, data, and engineering
  • Critique and pairing formats
  • Handoff models and definition of done
  • Onboarding paths for new designers
  • Quality bars, accessibility included
  • Leadership reporting in operational terms

Questions, briefly

How is DesignOps different from a design system?
The design system governs the product's components; DesignOps governs the team's decisions. One is product infrastructure, the other organizational infrastructure. They fail the same way, through undocumented deviation, which is why both run on records rather than memory.
What is the smallest useful design process?
A weekly review with decision rights, a decision log, and a written definition of done. Most teams need little more; most process bloat comes from adding rituals instead of attaching decisions to the ones that already exist.
Does process slow senior teams down?
Bad process does. The test is whether a ritual removes ambiguity: who decides, what was decided, what done means. Process that answers those questions makes senior teams faster, because they stop paying the tax of re-alignment.