Memorisely
Motion Design

How to build a motion system

Principles, duration and easing tokens, and patterns that keep motion consistent across a product.

Zander Whitehurst

8 min read

Most products do not have a motion problem. They have a consistency problem. One team uses a 300ms slide for their drawer, another uses a 150ms fade for theirs, and a third has copied a bouncy spring from a library demo. Each decision made sense on its own, but together they make the product feel stitched together.

A motion system fixes that. Just as a design system gives teams shared colours, type and spacing, a motion system gives them shared durations, easing curves and patterns. It turns motion from a series of one off choices into a language the whole product speaks.

Start with principles

Before you define a single token, decide what you want motion to feel like in your product. Principles are short statements that guide decisions when the tokens and patterns do not cover a situation.

Good motion principles are specific enough to settle arguments. "Motion should be delightful" does not help anyone choose between two options. Something like these is far more useful:

  • Responsive first. Motion should react to input immediately and never make people wait.
  • Purposeful. Every animation should provide feedback, orientation or continuity. Decoration is the exception, not the rule.
  • Calm. Movement should be small and quick. We prefer subtle shifts over dramatic entrances.
  • Spatially consistent. Things leave the way they came in, and related elements share a direction.

Three or four principles is plenty. Write them down, share them with your team and refer to them in design reviews. When someone proposes a new animation, the first question should be whether it fits the principles.

Principles only help when they are specific enough to choose between two options.

Define duration tokens

Duration tokens give your team a small, named set of timings instead of an endless range of numbers. A simple scale might look like this:

  • Fast, 100ms. Hover states, colour changes, small toggles and micro feedback.
  • Base, 200ms. Most component transitions, such as dropdowns, tooltips and tabs.
  • Slow, 300ms. Larger movements like modals, drawers and sheets.
Three or four named timings cover almost every transition in a product.

Some systems add an extra slow step, around 400ms to 500ms, for full page transitions or large layout changes. Resist adding too many. Every extra token is another decision people have to make, and the point of a system is to make decisions easier.

Name tokens by role rather than by value. duration-fast survives a change from 100ms to 120ms. duration-100 becomes a lie the moment you adjust it.

Define easing tokens

Easing tokens work the same way. A small set of named curves covers almost every situation:

  • Ease out. For elements entering the screen or responding to input. Something like cubic-bezier(0.22, 1, 0.36, 1).
  • Ease in. For elements leaving the screen. Something like cubic-bezier(0.55, 0, 1, 0.45).
  • Ease in out. For elements moving from one place to another while staying on screen. Something like cubic-bezier(0.65, 0, 0.35, 1).

If your product uses springs, add one or two named spring presets too, such as a gentle spring for layout changes and a snappier one for gestures. Treat them as first class tokens with names, not as magic numbers buried in components.

In code, tokens are often simplest as CSS custom properties:

:root {
  --duration-fast: 100ms;
  --duration-base: 200ms;
  --duration-slow: 300ms;

  --ease-out: cubic-bezier(0.22, 1, 0.36, 1);
  --ease-in: cubic-bezier(0.55, 0, 1, 0.45);
  --ease-in-out: cubic-bezier(0.65, 0, 0.35, 1);
}

.dropdown {
  transition: opacity var(--duration-base) var(--ease-out),
    transform var(--duration-base) var(--ease-out);
}

Create patterns for enter and exit

Tokens are the vocabulary. Patterns are the sentences. A pattern combines a duration, an easing curve and a set of properties into a reusable recipe for a common situation.

The most important patterns cover how things enter and leave:

  1. Fade. Opacity from 0 to 1. Useful for tooltips and content swaps where direction does not matter.
  2. Fade and rise. Opacity plus a small upward translateY, often 4px to 8px. Great for cards, toasts and dropdowns.
  3. Scale in. Opacity plus a scale from around 0.95 to 1. Works well for popovers and modals, ideally with the transform origin set to where the element was triggered from.
  4. Slide. A full translateX or translateY from off screen. Reserved for drawers, sheets and panels that live at an edge.
Each pattern is a reusable recipe matched to the situations it suits best.

For each pattern, define both the entrance and the exit. Exits are usually shorter and use ease in rather than ease out. A modal might enter at duration-slow with ease-out and leave at duration-base with ease-in.

You will also want patterns for staggered lists, layout changes and shared element transitions, but start with enter and exit. They cover most of what a product needs.

Document it properly

A motion system nobody can find is not a system. Documentation does not need to be elaborate, but it does need to exist in a place your team already looks.

Good motion documentation includes:

  • The principles, in a few sentences each, with examples of what they mean in practice.
  • The tokens, with names, values and guidance on when to use each one.
  • The patterns, ideally with a live demo. Motion is very hard to understand from a static description, so show it moving.
  • Do and do not examples, especially for common mistakes like over long durations or animating layout properties.

Short video clips or embedded prototypes make an enormous difference. A two second loop of the correct modal entrance is worth more than a paragraph explaining it.

Principles, tokens, moving examples and mistakes, all in the place your team already looks.

Share between Figma and code

The hardest part of a motion system is keeping design and engineering in sync. Designers prototype in Figma, engineers build in CSS or a library like Motion, and the numbers drift apart unless someone actively keeps them aligned.

A few things help:

  • Use the same names everywhere. If engineering calls it duration-base, the Figma prototype settings and the documentation should too.
  • Store values in Figma variables. Number variables for durations make it easier to reference tokens when building prototypes, even if Figma cannot yet apply them to every transition automatically.
  • Pick one source of truth. Usually this is the code tokens file. Design documentation should reference it rather than maintaining its own copy.
  • Review motion together. Add a quick motion check to design and code reviews, where a designer looks at the built interaction in the browser rather than only in the prototype.

AI tools are making this much easier. You can describe a pattern to Claude, paste in your tokens file and get a working component that uses the right values, which closes the gap between prototype and production. Our AI UI Motion Skills give Claude this kind of guidance out of the box.

Keep it consistent over time

Systems decay. New features arrive with new animations, deadlines push people towards whatever is quickest, and before long the drift returns.

A few habits keep things healthy. Audit the product every few months by recording key flows and watching them back to back. Look for durations and curves that do not match the tokens. Make the right thing the easy thing by baking patterns into shared components, so engineers get correct motion for free. And give someone ownership, even if it is only a few hours a month.

When I helped one team set up their first motion system, we started by screen recording every modal, drawer and dropdown in their product and putting the clips side by side. There were eleven different timings for what was essentially the same pattern. Nobody had noticed because each one had shipped months apart. Seeing them together did more to win support for the system than any slide deck could have.

Start small

You do not need a complete motion system on day one. Write three principles, define three durations and three curves, and document fade and rise for entrances and exits. That alone will make your product feel noticeably more coherent.

If you want to go deeper and build a system with guidance from people who do this every day, the AI Motion Design bootcamp covers tokens, patterns and the handoff between Figma and code in detail. Then grow the system as real needs appear. The best motion systems are not designed in one go. They evolve with the product.

Keep reading

View all
View all

Optimize your AI for better experiences, not AI slop.

View all

AI Prototyping Skills

Prototype with AI using clean UI patterns and guardrails so flows feel product-grade, not generic template slop.

$99

AI UI Motion Skills

Motion and micro-interaction patterns that make AI-built UI feel designed, polished, and trustworthy in real products.

$99

Fix AI Slop Skills

Spot AI slop early and fix type, spacing, and components so your product looks intentional, not like a template.

$99

AI Responsive Design Skills

Responsive layout patterns for rails, sidebars, and breakpoints so AI-generated UI adapts cleanly from narrow to wide.

$99

AI Dark Mode Skills

Dark theme tokens, contrast, and surfaces that keep AI-generated UI readable and product-grade, not flat gray on black.

$99

AI Color Token Skills

Neutral and primary ramps with clear steps so AI palettes stay systematic, not a random set of accent hex codes.

$99
View all