Motion and Interaction · Step 3 · 7 min read
Feedback while waiting
Waiting is part of every product. What to show at 0.1, 1 and 10 seconds, when a skeleton beats a spinner, why a progress bar should be honest, and what forty years of research say about making waits feel shorter without lying.
The worst wait is the silent one. When you press a button and nothing changes, you don't know if the app heard you, is working, or froze. So you press again, and now you've ordered twice. Feedback while waiting answers one question, "is something happening?", and for long waits a second one, "how long?". Motion is how most of those answers are drawn.
What you'll be able to do after reading:
- Match the feedback to the length of the wait: 0.1, 1 and 10 seconds
- Choose between a skeleton, a spinner and a progress bar
- Design a progress bar that feels fast and stays honest
- Make loading states work with reduced motion and screen readers
1. The length of the wait decides
- Under 0.1 sFeels instant. Show the result. The press state is the only feedback needed.
- 0.1 to 1 sNoticed, but the train of thought holds. Usually no indicator; a spinner that flashes for half a second only adds noise.
- 1 to 10 sAttention starts to drift. A skeleton for a whole page, a spinner for one part, with words: "Loading comments…"
- Over 10 sPeople turn to something else. A percent-done bar, what's happening, a time estimate, and a way to cancel.
These limits are old and still right. Jakob Nielsen wrote them down in 1993, building on research from 1968 and 1991: 0.1 second feels instant, 1 second keeps the flow of thought even though people notice the delay, and 10 seconds is about the limit of attention; beyond it people need to know when the computer expects to be done (NN/g, Response Times: The 3 Important Limits).
Two practical rules follow:
- Always answer the press at once. Even if the result takes five seconds, the button should look pressed straight away (Interactive states: hover, press, focus). NN/g's advice: give immediate feedback, then show a progress indicator for anything longer than about one second (NN/g, Progress Indicators Make a Slow System Less Insufferable, 2014).
- Don't flash an indicator for a fast action. A spinner that appears for 300 ms is noise: people see something flicker and wonder what they missed.
2. Three ways to wait
- SkeletonA whole page loading: shows the shape of what's coming
- SpinnerOne part loading, 2 to 10 seconds: says only "working"
- Progress barA process with an end: shows how much is done
NN/g's guidance, in short (NN/g, Skeleton Screens 101, 2023):
- Skeleton screen: for a whole page loading, in under 10 seconds. Grey blocks in the shape of the page help people build a picture of what's coming, so the page seems to settle into place instead of appearing all at once. A skeleton that shows only the header and footer, with no content shapes, is "essentially equivalent to a spinner".
- Spinner (looped animation): for one part of the page, a card, a comment list, in about 2 to 10 seconds. It says "working" and nothing else, so add words: "Loading comments…".
- Progress bar (percent-done): for anything over 10 seconds, and for processes like uploads and conversions, where a skeleton makes no sense. Add what's happening, an estimate, and a way to cancel.
Apple agrees from the other side: when you can, use a determinate indicator, because it helps people decide whether to wait, do something else or give up (Apple HIG, Progress indicators).
3. Moving means alive
An indicator that stops moving looks like a frozen app. Apple's guidelines say to keep progress indicators moving, because people associate a stationary one with a stalled process (Apple HIG, Progress indicators). That's motion doing its most basic job: showing that the system is alive.
But "moving" can be small. The spinner in the figure turns once a second; the skeleton's shimmer crosses in 1.5 seconds. Under reduced motion the shimmer stops (a still skeleton still shows the shape of the page) and the spinner fades slowly instead of turning. The page keeps saying "working" without spinning anything.
4. Progress bars and perceived time
A progress bar has a promise built in: it shows how much is done. People read its speed as a forecast, which is why the way it moves matters as much as the real duration.
- Brad Myers' paper at CHI 1985 is the classic case for percent-done indicators (Myers, 1985, doi:10.1145/317456.317459), and Nielsen cites it for the 10-second rule.
- Chris Harrison and colleagues showed people pairs of progress bars of the same real duration that moved in different ways. Bars that paused near the end were judged slower; bars that sped up towards the end were preferred; the end of the wait counted more than the beginning (Harrison, Amento, Kuznetsov and Bell, UIST 2007, doi:10.1145/1294211.1294231).
- In a follow-up, a bar with ribbing that moved backwards and slowed down made people judge the wait about 11% shorter than a plain solid bar of the same duration (Harrison, Yeo and Hudson, CHI 2010, doi:10.1145/1753326.1753556).
What to do with that, honestly: don't make the bar lie. Apple warns that showing 90% in five seconds and the last 10% in five minutes "can even feel deceptive" (Apple HIG, Progress indicators). Use the research to remove what feels slow (long stalls at the end, a bar that jumps back), not to fake speed. The figure's bar moves at an even, linear pace, because its 4 seconds are known.
5. The code that runs
The indicator is shown for the length of the wait, then the content fades in over 200 ms. These are the rules from the figure, as they run:
.mo-b-wait:has(.mo-b-go:checked) .mo-b-wait__ind { animation: mo-b-show 4s; }
.mo-b-wait:has(.mo-b-go:checked) .mo-b-wait__content { animation: mo-b-arrive 200ms ease-out 4s backwards; }
.mo-b-wait:has(.mo-b-go:checked) .mo-b-skel::after { animation: mo-b-shimmer 1.5s linear infinite; }
.mo-b-wait:has(.mo-b-go:checked) .mo-b-spin { animation: mo-b-spin 1s linear infinite; }
.mo-b-wait:has(.mo-b-go:checked) .mo-b-bar--run i { animation: mo-b-fill 4s linear forwards; }
@media (prefers-reduced-motion: reduce) {
.mo-b-wait:has(.mo-b-go:checked) .mo-b-skel::after { animation: none; } /* a still skeleton */
.mo-b-wait:has(.mo-b-go:checked) .mo-b-spin { animation: mo-b-pulse 1.5s ease-in-out infinite; } /* no spinning: a slow fade */
.mo-b-wait:has(.mo-b-go:checked) .mo-b-wait__content { animation-duration: 1ms; } /* the content just appears */
}
In a real product the timing comes from the request, not from a fixed 4 seconds, and two more things matter:
- Say it to screen readers. A spinner is silent. Put the words ("Loading comments…", then "3 comments loaded") in a status message so assistive technology can announce them without moving focus (W3C, Understanding 4.1.3 Status Messages). For real progress, the native
<progress>element has the semantics built in (MDN, progress). - Don't loop forever. If a wait runs much longer than expected, change the message: say what's slow and offer a way out.
6. Common mistakes
- No feedback at all for the first second, so people press twice.
- A spinner for a 20-second upload: no way to know whether to wait.
- A full-screen spinner blocking the page when only one card is loading.
- A bar that races to 90% and sits there.
- A shimmer that keeps going under reduced motion, or a spinner with no words for screen readers.
7. Vocabulary
| Term | Meaning |
|---|---|
| Response time | The time from a person's action to the system's answer |
| Skeleton screen | Grey placeholders in the shape of the page that's loading |
| Spinner | A looped animation that says "working" but not how long |
| Determinate indicator | Shows how much is done: a percent-done bar or ring |
| Indeterminate indicator | Shows only that something is happening |
| Perceived duration | How long a wait feels, which isn't always how long it is |
8. Try it (no tools needed)
- Time three waits in an app you use: opening it, searching, saving.
- For each, write what it shows at 0.1 s, 1 s and 10 s.
- Mark any wait over 10 seconds with no estimate and no way to cancel.
Reflection questions: Which wait in your product makes people press twice? What would it cost to show a skeleton instead of a blank screen there?
9. If you already practise
- Make the loading state part of every component spec, next to empty, error and success (Interface states: empty, loading, error, success).
- Ask engineering for real timing data (median and slowest 5%) before choosing an indicator: design for the slow case.
- Put the indicator thresholds (show nothing under 1 s, a spinner up to 10 s, a bar beyond) in your design system, so teams stop deciding them screen by screen.
Checklist
Learn more
- Jakob Nielsen, Response Times: The 3 Important Limits (NN/g, from Usability Engineering, 1993)
- Katie Sherwin, Progress Indicators Make a Slow System Less Insufferable (NN/g, 2014)
- Samhita Tankala, Skeleton Screens 101 (NN/g, 2023)
- Apple, Human Interface Guidelines: Progress indicators
- Papers: Myers, 1985 · Harrison et al., 2007 (the author's page) · Harrison, Yeo and Hudson, 2010 (the author's page)
Books, courses and videos to go deeper
- Designing and Engineering Time: The Psychology of Time Perception in SoftwareSteven C. SeowBook · Addison-Wesley, 2008 (Amazon)
- Usability EngineeringJakob NielsenBook · Academic Press, 1993 (Amazon)
Book links go to Amazon. As an Amazon Associate I earn from qualifying purchases, at no extra cost to you.
Related
Interface states: empty, loading, error, success · Anatomy of a microinteraction · Duration: how long is right · Motion performance · How people think