Marcus Andrey Study
Ler em português Library

Motion and Interaction · For leads · 4 min read

Motion in design system governance

For leads: how to keep a product's motion consistent after the tokens ship. Who owns motion, how a new animation gets into the system, which rules keep the set small, and how to audit and retire motion over time.

Motion tokens don't keep a product consistent. People do, with a clear path for saying yes and a habit of saying "we already have that". Every team eventually wants something that moves a little differently. Without governance, each request becomes a one-off, and a year later the product has thirty animations and no system. A lead's job is to make the right path the easy one.

What you'll be able to do after reading:

  • Name who owns motion, and what they decide
  • Set up a path for new motion requests
  • Write the few rules that keep the motion set small
  • Audit, change and retire motion over time

1. A path from request to token

  1. 1Propose

    A team needs motion the system doesn't have. They write the job, not the animation.

    Any designer
  2. 2Check

    Can an existing token or pattern do the job? Most requests end here.

    System team, within a week
  3. 3Prototype

    Built in code with tokens, with its reduced-motion version, tested on a slow phone.

    Proposer and one engineer
  4. 4Decide

    Accept, adapt or decline, with the reason written down.

    Motion owner, in critique
  5. 5Release

    Token or pattern, spec card, demo, changelog line.

    System team

Every quarter: audit the product's motion against the system, and retire what nobody uses.

A path from "we need an animation" to a released motion token. Each step has an owner and most requests stop at step 2, which is the point: the system grows slowly, on purpose.Diagram: Marcus Andrey, CC BY 4.0.

The figure is a lightweight process that works for a team of five or fifty. Its most important step is the second: checking whether an existing token or pattern already does the job. Most requests stop there, and that's the system doing its work.

The first step matters too. Ask people to propose the job, not the animation: "people don't notice the filter was applied" rather than "I want the chips to bounce". A job can be solved with an existing pattern; a specific animation can only be accepted or refused.


2. Who owns motion

Motion sits between design and engineering, so it often belongs to nobody. Name an owner:

  • A motion owner, usually a designer with a strong engineering partner. They decide what enters the system and keep the principles.
  • The system team maintains tokens, pattern cards, demos and the change log (see Documenting motion in a design system).
  • Product teams use the tokens, propose new jobs and report what doesn't work.
  • Accessibility has a say on every new pattern's reduced-motion version, not a veto at the end.

Write the decision rights down. "Who decides if this ships with a bounce?" should have one answer.


3. Rules that keep it small

A handful of rules, each with a reason:

  • Tokens only. No raw ms or cubic-bezier() values in product code. A lint rule catches them; an exception needs a written reason.
  • Reuse before adding. A new semantic token is only added when no existing one can do the job.
  • No pattern without its reduced version. A proposal without one isn't ready for review (see Designing a reduced-motion version).
  • No pattern without a performance check. Built with transform and opacity, seen on a slow phone (see Motion, performance and budgets).
  • Expressive motion is rationed. Carbon separates productive motion for everyday work from expressive motion for significant moments (Carbon, Motion). Agree as a team which moments are expressive, and keep the list short.

Val Head recommends basing motion decisions on principles, so reviews don't come down to personal taste (Smashing Magazine, 2019). The rules above are those principles turned into checks.


4. Changing motion safely

A duration change doesn't break any code, but it changes how the whole product feels. Treat it like a visual change:

  • Announce it in the change log, with the reason: "motion.exit-large from 350 to 250 ms: sheets felt slow to close in testing".
  • Show before and after, as two demos running side by side.
  • Change in one place. If the tokens are set up in tiers, a change to one semantic token reaches every component that uses it (see Motion tokens).

5. Audit and retire

Every quarter, or before a major release:

  1. Walk the product's main flows and list what moves, the way Audit the motion in your product describes.
  2. Compare with the system. Which animations use raw values? Which patterns exist in code but not in the docs?
  3. Retire what nobody uses, or what two other tokens could cover. A smaller set is easier to learn and to keep consistent.
  4. Check reduced motion across the product with the setting on (see Audit a page for reduced motion).

6. Common mistakes

  • No named owner, so every motion question goes to whoever animated last.
  • A process so heavy that teams skip it and ship one-offs.
  • Accepting animations, not jobs, so the system fills with near-duplicates.
  • Reduced motion and performance checked after release, not before.
  • Changing a token without telling anyone, and hearing about it from users.

7. Try it (no tools needed)

  1. Think of the last animation your team added.
  2. Walk it through the five steps in the figure. Where would it have stopped?
  3. Write the one rule from section 3 that would have changed the outcome.

Reflection questions: Who on your team is the motion owner today, even if nobody said so? What would it take for them to have the time to do it well?


Checklist

Learn more

Books, courses and videos to go deeper

Book links go to Amazon. As an Amazon Associate I earn from qualifying purchases, at no extra cost to you.

Documenting motion in a design system · Motion tokens · Reviewing motion in critique · Motion, performance and budgets · What a design system is

Saved only on this device.

↑ ↓ to move · Enter to open · Esc to close