Fast is a feeling: perceived speed beats measured speed
10 October 2026 2 min read
People judge speed by when the interface answers, not when the server finishes. Optimistic updates move the answer to zero, and send you the bill as a rollback you have to design.
- Perceived performance
- Motion
- Resilience
A server that answers in 1.2 seconds feels slow. An interface that answers in zero milliseconds and quietly corrects itself a second later feels instant. It is the same server and the same network. Only the moment the screen changes is different.
Wait for the server
1200 ms until you see anything
Waits for the server before it answers.
Optimistic
0 ms until you see the result
Answers at once and syncs in the background.
Press both buttons with the default latency. Then drag the latency up and try again. The left button gets worse with every step. The right one does not change at all.
Two clocks
There is the measured clock: how long the request takes. And there is the felt clock: how long until something on the screen changes. Users only have access to the second one. The numbers usually quoted for it come from Jakob Nielsen's summary of older research: about 0.1 seconds feels instant, about 1 second keeps the train of thought going, and about 10 seconds loses the user's attention.
That gives you a practical ladder for what to show:
- Under 100 ms: show nothing extra. The result is the feedback.
- 100 ms to 1 s: react at the control that was pressed. A pressed state, a disabled button. No spinner.
- 1 to 10 s: show progress that says what is happening, not just that something is.
- Over 10 s: let go of the user. Run it in the background and tell them when it is done.
Spinners are an expense
A spinner that appears for 80 milliseconds is worse than no spinner. It adds a flicker the user notices and cannot explain. A reasonable rule of thumb is to delay the spinner by about 200 ms, and once it has appeared, keep it for at least 400 ms. The goal is that fast requests look like nothing happened, and slow ones look like something is being done.
Optimistic updates
The right-hand button does something different. It assumes the save will work, shows the result immediately, and syncs in the background. For actions that almost always succeed, like toggling a favourite or saving a draft, this is the biggest perceived speed-up available, and it costs no server work at all.
The bill arrives when the assumption is wrong. Tick Server fails in the demo and press both buttons again. The left button makes you wait and then tells you. The right button has already told you it worked, and now has to take it back.
That moment is a design task, not an error handler:
- Say what happened and that the change is back: "Couldn't save. Your change is back."
- Put the interface back to what it was, not to a blank state.
- Do not use it for actions that cannot be undone, such as payments or deletions.
Pending is a state
Whatever you choose, the button needs to know it is pending. A second tap during a pending request should do nothing, not send the request twice. If that sounds like the state machine argument, it is: idle, pending, done and failed are four states with explicit transitions, not three booleans.
Measure the right thing
Most dashboards track time to complete. Add time to feedback: the time between the tap and the first visible change. It is the number that users actually experience, and the one you can improve without touching the backend.
Related
- Micro-feedback and perceived speed One button, three states and a spring. Change the network latency and the stiffness and feel why a button that answers at once feels faster than one that is.
- The card that becomes the page A list card opens a detail page. Cut or morph? The same flow built twice, with the View Transitions API and a fallback that costs nothing.