Marcus Andrey Study
Ler em português Library

Motion and Interaction · Step 2 · 6 min read

Choreography and stagger

When several things move at once, someone has to lead. How to choose the leader, offset the rest, stagger a list without making people wait for the last row, and write it all down as a timeline a developer can build.

One moving thing is an animation. Five moving things are a choreography, and without one they're just noise. When a page changes, a lot moves at once: the old content leaves, a container grows, a photo, a title and a list arrive. If they all start and stop together, the eye doesn't know where to go. If each starts a few milliseconds after the last, in an order that makes sense, the change reads like a sentence. That small offset is one of the cheapest ways to make an interface feel designed, and one of the easiest to overdo.

What you'll be able to do after reading:

  • Choose a leader and an order for a multi-part transition
  • Stagger a list so it guides the eye without making people wait
  • Keep a whole choreography inside a sensible total duration
  • Write a timeline spec a developer can build from

1. Who leads

NN/g notes that some animations "consist of several elements moving together or with slight offset timing", and that different parts of one object can move differently: their example is a menu icon whose top and bottom lines rotate into an X while the middle one fades (Page Laubheimer, Executing UX Animations, NN/g, 2020). That's choreography at its smallest. The questions are always the same:

  1. What leads? The element that carries the change: usually the one the person touched, or the container of the new content. It moves first and travels furthest.
  2. What follows? Content that belongs to the leader, like a card's title and text. It arrives a little after, so it reads as part of the leader.
  3. What gets out of the way? The old content. It leaves first and fast, so it doesn't compete with what's arriving.

Willenskomer names the first two as principles: offset and delay, which "defines object relationships and hierarchies when introducing new elements", and parenting, where linked objects move together so people see they belong together (Issara Willenskomer, The UX in Motion Manifesto, 2017). Disney's animators would recognise them as staging and follow-through (Motion principles for interfaces).


2. Stagger

Untick: they all leave together, faster.
Stagger: the same six rows, each fading and rising in 250 ms, with a different gap between starts. A small gap guides the eye; a big one makes people wait for the last row. Live CSS: transition-delay: calc(var(--i) * var(--gap)). With reduced motion on, the rows fade in together.

Load the three lists. Each row takes the same 250 ms to fade and rise. The only difference is the gap between one row's start and the next.

  • All at once is fine. It's one block arriving.
  • 40 ms apart reads as a list: the eye follows from top to bottom, and the last row starts at 200 ms. The whole list is done at 450 ms.
  • 150 ms apart is a queue. The last row waits 750 ms just to start, and the whole thing takes a full second. Now the motion is the content, and people are waiting for it.

The total is what matters. NN/g says that at 500 ms animations "start to feel like a real drag" (Laubheimer, NN/g, 2020), and a stagger adds up fast: gap × number of items + the duration of one. So:

  • Keep the gap small: a few tens of milliseconds, not hundreds.
  • Cap the count: stagger the first few visible items, then let the rest arrive together. A list of fifty rows shouldn't take two seconds to appear.
  • Follow the reading order: top to bottom, start to end. In a right-to-left language, that's right to left.
  • Leave together. Untick the demo: every row leaves at once, in 150 ms, with no delay. An exit doesn't need to be read.

3. The code behind the stagger

Each row gets its position as a custom property, each list its gap, and one rule multiplies them. This is the real CSS:

.mo-a-item:nth-child(1) { --i: 0; } .mo-a-item:nth-child(2) { --i: 1; } .mo-a-item:nth-child(3) { --i: 2; }
.mo-a-item:nth-child(4) { --i: 3; } .mo-a-item:nth-child(5) { --i: 4; } .mo-a-item:nth-child(6) { --i: 5; }
.mo-a-gap0 { --gap: 0ms; } .mo-a-gap40 { --gap: 40ms; } .mo-a-gap150 { --gap: 150ms; }
.mo-a-demo:has(.mo-a-go:checked) .mo-a-item { opacity: 1; transform: none; transition: opacity 250ms ease-out, transform 250ms ease-out; transition-delay: calc(var(--i) * var(--gap)); }

The delay sits only on the open state, which is why the rows leave together. With reduced motion on, the rows don't move and don't wait: they fade in together.

@media (prefers-reduced-motion: reduce) {
  .mo-a-demo:has(.mo-a-go:checked) .mo-a-item { transition: opacity 150ms ease-out; transition-delay: 0ms; }
}

4. Write it as a timeline

A choreography lives in time, so a picture of the end state doesn't describe it, and a video alone isn't enough either. NN/g's advice for complex animations is a timeline: every element that moves, the properties that change, the easing for each, and durations "in milliseconds, not frames", alongside a video of the motion for feel (Laubheimer, NN/g, 2020). Here's one for a card that opens into its page:

ElementWhat changesWhenEasing0100200300400 ms
Rest of the listFades out0 → 100 msease-in
CardGrows from its place to full screen0 → 300 mscubic-bezier(0.05, 0.7, 0.1, 1)
PhotoMoves and grows with the card0 → 300 mscubic-bezier(0.05, 0.7, 0.1, 1)
TitleFades in at its new place100 → 300 msease-out
Body textFades in150 → 350 msease-out
Close buttonFades in200 → 350 msease-out
A choreography spec for a card opening into its page: one leader (the card), the content following it, the old screen leaving first. 350 ms in all. This table is what a developer can build from; a video alone is not.Example spec: Marcus Andrey, CC BY 4.0. Easing: Material 3 emphasized decelerate.

Read it from top to bottom and you can see the whole plan: the old list gets out of the way in the first 100 ms; the card leads, with the photo attached to it; the title, then the text, then the close button follow. Everything ends by 350 ms. A developer can build that without guessing, and a reviewer can question one line ("does the close button need to wait 200 ms?") instead of the whole feeling.

When the card and its photo travel from the list into the page, that's a shared element transition, and Step 4 covers it in Shared element transitions.


5. Common mistakes

  • Everything moving at once, with no leader.
  • Long staggers on long lists, so the last item arrives seconds later.
  • Staggering the exit too, so leaving takes as long as arriving.
  • Content arriving before its container, so it seems to float in from nowhere.
  • A beautiful choreography handed over as a video, rebuilt from guesses.

6. Vocabulary

Term Meaning
Choreography The plan for how several elements move together in one change
Leader The element that carries the change and moves first
Offset A small difference in start time between related elements
Stagger Starting a series of similar items one after another, with an equal gap
Total duration From the first element's start to the last element's end
Timeline spec A table or chart of every element's start, end, properties and easing

7. Try it (no tools needed)

  1. Open an app's home screen or a search results page, and pull to refresh or reload.
  2. Watch what arrives first, what follows, and how long the last thing takes.
  3. Sketch it as a timeline on paper: one row per element, a bar for when it moves.

Reflection questions: Was there a clear leader? Was anything still moving after you had already started reading?


8. If you already practise

  • Add a "stagger" token: one gap and one maximum count, so lists stagger the same way everywhere.
  • Spec complex transitions as a timeline table, like the one above, and keep the video for feel.
  • In critique, ask "what leads?" before you discuss any curve or duration.

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.

Springs and physics · Anatomy of a microinteraction · Shared element transitions · Navigation transitions · Handoff to developers · Stagger and sequence rules

Saved only on this device.

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