Marcus Andrey Study
Ler em português Library

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

  1. Under 0.1 sFeels instant. Show the result. The press state is the only feedback needed.
  2. 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.
  3. 1 to 10 sAttention starts to drift. A skeleton for a whole page, a spinner for one part, with words: "Loading comments…"
  4. Over 10 sPeople turn to something else. A percent-done bar, what's happening, a time estimate, and a way to cancel.
How long the wait is decides what to show. The three limits come from Jakob Nielsen (1993), building on work from 1968 and 1991; the choice of indicator in each band follows NN/g's later guidance on progress indicators and skeleton screens.Diagram: Marcus Andrey, CC BY 4.0. Sources: NN/g, Response Times: The 3 Important Limits; Progress Indicators Make a Slow System Less Insufferable (2014); Skeleton Screens 101 (2023).

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:


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
The same 4-second wait, three ways. Press play: the skeleton shimmers in the shape of the page, the spinner turns, the bar fills at an even, honest pace, then the content arrives. With reduced motion the shimmer stops, the spinner fades instead of turning and the content just appears; the bar still fills, because its movement is the information.Live CSS, no script. Which one when: NN/g, Skeleton Screens 101 (2023). Demo: Marcus Andrey, CC BY 4.0.

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.

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)

  1. Time three waits in an app you use: opening it, searching, saving.
  2. For each, write what it shows at 0.1 s, 1 s and 10 s.
  3. 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

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.

Interface states: empty, loading, error, success · Anatomy of a microinteraction · Duration: how long is right · Motion performance · How people think

Saved only on this device.

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