Every screen has at least four states — loading, empty, error and normal — yet mockups usually cover only the last one. A product feels premium when waiting is shown honestly (a skeleton or a progress bar), an empty screen points to the next step, an error explains how to fix it, and risky actions can be undone. Plan these states into the designs and the spec from day one; otherwise they end up as blank screens and “Something went wrong”.
After this you will be able to
- List the four screen states — loading, empty, error, ideal — and describe each one for your key screen
- Pick an indicator by wait time: nothing, a skeleton, an in-block spinner or a progress bar
- Write an error message using the pattern “what happened — why — what to do — nothing lost”
- Decide where undo should replace an “Are you sure?” dialog and where an optimistic UI fits
Know beforehand
Contents
Why states matter more than the “perfect screen”
In a presentation, the mockup looks flawless: the order list is full, the photos have loaded, the connection is fast. In real life, someone opens that same screen in an elevator with one bar of signal, on day one when there are no orders yet, or right when the payment provider fails to respond. Those are the moments when people decide whether to trust the product.
That's why on InterLAB projects we describe a set of states for every key screen, not a single view. It's cheap at the design stage and expensive to remember after launch, once the complaints are already coming in.
Loading: skeleton, spinner or progress bar
The right indicator depends on how long the wait is. For years Nielsen Norman Group has relied on three response-time thresholds:
0.1 s0.1 s
feels instantaneous — no indicator needed
1 s1 s
train of thought stays intact, but the delay is noticeable
10 s10 s
the limit before attention drifts away
Under 1 second
- What to show
- Nothing, or a subtle change on the button
- Why
- A spinner that flashes by causes more anxiety than reassurance
2–10 seconds, whole screen loading
- What to show
- Skeleton — grey placeholders where content will appear
- Why
- People see the page structure in advance
2–10 seconds, one block loading
- What to show
- A spinner inside that block
- Why
- The rest of the screen stays usable
Over 10 seconds
- What to show
- A progress bar with a percentage or time estimate
- Why
- Without a sense of progress, patience runs out
A skeleton screen is a wireframe of the page made of neutral blocks in place of headings, images and lines of text. It only works if it mirrors the real layout: a “skeleton” of three identical bars is no better than a spinner. For long operations — exporting a report, importing a price list, processing a video — it's more honest to show step-by-step progress: “120 of 400 items processed”.
Empty states that teach
An empty state is a screen with nothing to show yet. Nielsen Norman Group describes it as an opportunity to communicate system status, help people learn the product and offer a direct path to a key task. In practice it's usually an empty table that says “No data”.
The usual way
- “No data” in grey text
- An empty table with column headers
- A search with zero results and zero hints
- The user can't tell whether something broke or it's supposed to look like this
A better way
- One sentence on what will appear here and why it matters
- A primary button: “Add your first client”, “Import from Excel”
- For empty search results — typo checks, a reset-filters link, similar options
- An example of a filled screen or a short step-by-step hint
- First use — explain what the section is for and lead to the first action
- No results — help adjust the query instead of leaving a dead end
- All done — say it plainly when, for example, every request has been processed
- No access — explain whom to ask for permissions
Errors users can recover from
Errors are inevitable: connections drop, sessions expire, third-party services go silent. What separates a cheap product from a premium one is what happens next. The core of Nielsen Norman Group's error-message guidelines: the message is visible, written in plain language, names the problem precisely, offers a fix and preserves whatever the user has already entered.
What happened
No codes or jargon: “Your order couldn't be sent”, not “Error 502”.
Why
If the cause is known: “No internet connection” or “The card was declined by the bank”.
What to do
A concrete action: a “Try again” button, a link to support, another payment method.
Lose nothing
Entered data stays in the fields and the cart stays put. Nobody fills in a form twice.
Offline mode and optimistic UI
Mobile connections drop at the worst possible moment. Browsers can tell an app that the connection is gone (MDN documents the navigator.onLine property and the online/offline events), so the interface can say “You're offline — we'll update as soon as you're back” instead of spinning forever.
Optimistic UI goes a step further: it shows the result of an action immediately, before the server responds. A like fills in instantly, a task moves to “Done” without waiting. If the server returns an error, the change is rolled back gracefully and a clear notification appears.
- 01Tap
- 02Screen updates instantly
- 03Request to server
- 04Confirmation or rollback with a notice
- Good for frequent actions that almost always succeed: checkmarks, likes, dragging cards
- Not for payments, order submission or anything where a failure costs money — use an honest indicator there
- Unsent changes are best stored locally and synced once the connection returns
Undo instead of “Are you sure?”, and toasts
A confirmation dialog on every delete quickly becomes a reflex: people click “Yes” without reading. Nielsen Norman Group advises against confirmations for routine actions and recommends offering undo wherever possible. Delete an email, and a short “Email deleted” message with an “Undo” button appears at the bottom. Keep confirmations for actions that truly can't be reversed.
That short pop-up message is called a toast. It's a good fit for confirmations like “Saved”, “Link copied” or “Undo delete”. The rules are simple:
- One action per toast, and one toast on screen at a time
- It doesn't disappear while the pointer or focus is on it — otherwise there's no time to hit “Undo”
- Critical errors don't go in a toast — they stay on screen until resolved
- Screen readers must announce the message: WCAG covers this under status messages (4.1.3)
The best confirmation is the one you don't need, because the mistake can be undone with a single tap.
A checklist for the client
Run through it when reviewing designs or the first version of the product. If an item has no answer, discuss it with the team before development starts.
- Every key screen has designed states: loading, empty, error, normal
- Skeletons mirror the real layout, and long operations show progress
- Empty screens explain what will appear and lead to the first action
- Error messages say what to do and never wipe entered data
- Behaviour without an internet connection has been thought through
- Deleting and similar actions can be undone; confirmations are reserved for irreversible ones
- Toasts don't vanish from under the pointer and are announced to screen readers
Sources
- Nielsen Norman Group — Response Time Limits
- Nielsen Norman Group — Progress Indicators Make a Slow System Less Insufferable
- Nielsen Norman Group — Skeleton Screens 101
- Nielsen Norman Group — Designing Empty States in Complex Applications: 3 Guidelines
- Nielsen Norman Group — Error-Message Guidelines
- Nielsen Norman Group — Confirmation Dialogs Can Prevent User Errors
- MDN — Navigator: onLine property
- W3C WAI — Understanding SC 4.1.3: Status Messages