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:
- 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.
- 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.
- 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
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:
| Element | What changes | When | Easing | 0100200300400 ms |
|---|---|---|---|---|
| Rest of the list | Fades out | 0 → 100 ms | ease-in | |
| Card | Grows from its place to full screen | 0 → 300 ms | cubic-bezier(0.05, 0.7, 0.1, 1) | |
| Photo | Moves and grows with the card | 0 → 300 ms | cubic-bezier(0.05, 0.7, 0.1, 1) | |
| Title | Fades in at its new place | 100 → 300 ms | ease-out | |
| Body text | Fades in | 150 → 350 ms | ease-out | |
| Close button | Fades in | 200 → 350 ms | ease-out |
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)
- Open an app's home screen or a search results page, and pull to refresh or reload.
- Watch what arrives first, what follows, and how long the last thing takes.
- 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
- Page Laubheimer, Executing UX Animations: Duration and Motion Characteristics (NN/g, 2020)
- Issara Willenskomer, Creating Usability with Motion: The UX in Motion Manifesto (2017)
- MDN: transition-delay · Using CSS custom properties
Books, courses and videos to go deeper
- Designing Interface AnimationVal HeadBook · Rosenfeld Media, 2016 (Amazon)
- Disney Animation: The Illusion of LifeFrank Thomas and Ollie JohnstonBook · Abbeville Press, 1981 (Amazon)
Book links go to Amazon. As an Amazon Associate I earn from qualifying purchases, at no extra cost to you.
Related
Springs and physics · Anatomy of a microinteraction · Shared element transitions · Navigation transitions · Handoff to developers · Stagger and sequence rules