Keep context through cards, lists, and filters
Filtering, sorting, and reordering change both content and position. Good continuity lets the eye follow the change and trust the result.
Cards, lists, and filters often change at once: items arrive, leave, reorder, refresh, and contract. People need a trackable causal chain that tells them what they acted on, where it went, and why surrounding content changed too.
Decide whether people need to track one object, the order of a list, or the filtered result as a whole.
Implementation path
- 01
Keep a recognisable anchor
Keep identity and spatial cues on the acted-on card so people do not have to find it again.
- 02
Sequence changes in batches
Use short intervals to establish reading order, and cap the total time for larger lists.
- 03
Explain the filtered result
Keep the active criteria and result count visible as the result set contracts.
Let people recognise the same object first
Continuity starts with object identity. When a card is selected, dragged, or filtered, its title, thumbnail, boundary, and relative position should persist where possible. Even when size changes, keep main recognition cues on screen. When a task card opens into detail, its title and primary color can continue in the new layout; when filtering leaves three results, keep the active filter and count visible so people can connect the reduced list to the choice they just made.
Identity cues also help with updates. New items from collaboration, polling, or background sync should not blend into the item a person just touched. A new item can enter lightly from the list edge with a brief New marker that explains its source; an updated item can change only the relevant field instead of flashing the whole card. People attribute every change to their own action, someone else’s action, or a system refresh. Clearer cues reduce that burden.
Let entrance, movement, and exit share one timeline
List changes can feel chaotic because entrance, exit, and movement happen together. The key is a shared rhythm. Let departing items reduce their presence, move retained items to their new places, then reveal incoming items. They do not need frame-by-frame serialization; their starts and ends simply need a clear order. For lists under ten items, 120–220 ms often completes a clean reorder. With more items, shorten per-item delay so the final item does not settle much later than the first.
Visual movement should reflect the data change. After sorting, cards should travel toward the places they truly occupy; if using crossfade, overlap old and new positions long enough for the eye to establish correspondence. Keeping the container’s height stable matters too. Large height jumps can look like a page reload rather than a filtered result. On small screens, continuity also means controlling scroll position: keep the area a person just touched near the viewport whenever possible.
Keep criteria, counts, and empty states through filtering
Filter motion carries an explanatory responsibility. When someone chooses Completed or enters a query, the list shrinks, ordering can change, and counts update. Show the active filter chip, query, and result count before or alongside the list change, so people see the rule before the result. If cards simply vanish, the page can resemble a fault; when criteria, count, and cards update together, the contraction reads as controlled.
An empty state belongs to continuity as well. Zero results are not the end of the list; the state should receive the active criteria: say No projects match budget and offer Clear filters or another path. Its entrance does not need a large bounce—one fade with a stable placeholder is enough. When results change rapidly, avoid replaying a full entrance and exit every time. During continuous typing, use shorter transitions and let the final result settle once input pauses.
Give refresh, sorting, and dragging distinct signals
Refresh, sorting, and dragging all move cards, yet they mean different things. Refresh says the system received new data; sorting expresses a new comparison rule; dragging confirms that a person directly changed order. Refresh benefits from a light cue and local update, sorting from showing the active rule and a whole-list reorder, and dragging from pickup, placeholder, and drop states. Treating all three as cards flying around removes the user’s ability to understand why change occurred.
In implementation, make the source of change part of state. Let the list container know whether the current change is filter, sort, refresh, or drag, and let each mode trigger only its necessary visual rule. This also improves testing: verify result count and focus during filtering, final order during sorting, and keyboard and touch paths during dragging. Motion becomes visible output of state change, validated alongside business logic rather than treated as decoration floating above it.
Make continuity part of list-component acceptance
A list component can turn continuity into explicit rules: how object identity persists, when container height may change, when criteria and counts update, the limit for travel and total duration, and which actions an empty state receives. New pages can then use the component without repeatedly guessing how animation should work. Design review asks whether people can track the change; engineering review checks final data order and focus. Both perspectives revolve around the same contract.
Review with realistic data scale. A beautiful move across three cards can turn into delay across fifty search results. Test continuous typing, multi-condition filtering, sorting, and an update while mobile scrolling; then enable reduced motion and confirm that rules, counts, and focus remain clear. Good continuity does not require every object to perform a full animation. It requires every change to have an origin, a result, and room for the next action.
List continuity checklist
- The acted-on object retains recognisable cuesTitle, thumbnail, color block, or relative position continues in the new state.
- Filter rule and result count are visible togetherShow the rule before the list contracts or reorders.
- Exit, movement, and entrance share a short rhythmCap total duration for larger sets and avoid delay queues.
- Empty state explains criteria and offers a next stepRetain query or criteria and offer clear or replacement actions.
- Refresh, sort, and drag are distinguishableEach source uses its own state and acceptance path.
Case: project filtering updates count before cards contract
Active criteria and match count sit above the list; retained items move while departing items only fade.
.result-list { display: grid; gap: 12px; }
.result-card { transition: transform 180ms ease-out, opacity 140ms ease-out; }
.result-card[data-visibility="leaving"] { opacity: 0; transform: scale(.985); pointer-events: none; }
.result-meta[data-updating="true"] { color: var(--motion-ink); }
.result-empty { min-height: 160px; opacity: 0; visibility: hidden; transition: opacity 140ms ease-out; }
.result-list[data-empty="true"] + .result-empty { opacity: 1; visibility: visible; }
@media (prefers-reduced-motion: reduce) { .result-card, .result-empty { transition-duration: 1ms; } }Departing items avoid large travel so the real movement of retained items is easier to read. The match count changes first through data-updating, establishing that the rule has taken effect; the empty state reserves height so the page does not suddenly collapse.