How Should You Design Loading, Empty, and Error States?
Good mobile app loading, empty and error state design answers three questions: what is happening, what happened to my work, and what can I do next? Give each screen a useful response when content is unavailable, and each failed action a clear recovery path. Distinguish a first visit from an unsuccessful search, show loading feedback where work is happening, and preserve input wherever it is safe to do so.
Which states should you plan for each screen?
Start with the main job of the screen. Then describe what users should see before, during and after that job, including when it cannot finish.
For a saved-items screen, “nothing to show” could mean a new account, a filter with no matches, or a failed request. Give these situations different messages and actions.
| Situation | What the screen should explain | Useful next step |
|---|---|---|
| First visit | No items have been added yet | Add the first item |
| No search results | Nothing matches this search | Edit the search or clear filters |
| Initial loading | Content is being fetched | Wait, with a way to leave |
| Refreshing existing content | An update is in progress | Keep reading existing content |
| Loading failed | Content could not be retrieved | Try again |
| Saving failed | The change has not been confirmed | Review status or retry safely |
| Access unavailable | This account cannot open the content | Sign in or request access |
Include these states when deciding how to scope an app MVP. Treat them as part of completing a feature, with acceptance criteria alongside the successful journey.
What should a first-use empty state say?
Explain what belongs on the screen and offer a practical way to begin.
For an app that helps people organise projects, an illustrative message might be:
“No projects yet. Create a project to keep its tasks together.”
The main button could say “Create project.” This gives the user context and an action without requiring a separate tutorial.
Keep the explanation specific to the screen. “Nothing here” leaves the user to work out whether they should add something, change a setting or wait.
Avoid presenting invented sample records as the user's own information. If examples help explain the feature, label them clearly and keep the action for creating real content easy to find.
Also consider people who cannot create content. A team member waiting for an invitation needs a different next step from an account owner setting up their first project.
How should loading feedback work?
Place feedback close to the work it describes. When a user saves a form, change the button label to “Saving…” and prevent another submission while that attempt is pending. When a list loads, show feedback in the list area.
Choose the indicator according to what you can honestly show:
- Use a simple activity indicator when completion progress is unknown.
- Use a progress bar when the app can measure completed work against a known total.
- Use placeholder shapes when they help explain the layout that will appear.
- Use a text label when the operation needs context, such as “Uploading attachment…”
Do not show a made-up percentage or a successful result before the action is confirmed.
For a refresh, keep existing content visible when it remains useful. If freshness matters, label it as previously loaded information. Do not leave old content looking current after an update fails.
Plan how loading ends. Include success, failure and cancellation where relevant, plus a response when the wait exceeds what the product is prepared to support.
How do you write an error message with a next step?
Write the message around the user's task. Explain what could not be completed, clarify the status of their work, and offer an action.
For example:
“We couldn't save your changes. Your edits are still here. Try saving again.”
Use that wording only when the edits really remain available and another attempt is appropriate.
Match the message to what the app knows. If a request fails for an unknown reason, do not blame the user's connection. If a field needs correction, name the field and explain the accepted input.
Put field errors beside the relevant field. Put a loading failure in the affected content area. Reserve a full-screen message for a problem that prevents the whole screen from being used.
Give controls meaningful labels: “Try again,” “Edit email” or “Return to projects.” “OK” acknowledges a message but does not explain how to continue.
When is a retry action appropriate?
Offer retry when repeating the action can reasonably help. A failed content request may need “Try again.” An invalid address needs editing. An expired session needs sign-in.
Before offering retry for an action that creates, sends or charges something, account for an uncertain outcome. The app might have lost the response after the action completed. Do not claim that nothing happened unless that status is known.
Design a distinct response for this case:
“We couldn't confirm whether your request was submitted. Check its status before submitting again.”
Provide a status-check action if the product supports one. Do not instruct users to check a place that does not exist.
After another failed attempt, keep a useful way out: return to the previous screen, save a draft, or contact support where available. Explain what each option preserves.
What input should survive a failure?
Preserve ordinary form input after validation errors, failed saves and interrupted requests wherever it is safe to do so. Keep valid fields filled while highlighting the fields that need attention.
Decide what preservation means:
- Does the input remain while the screen stays open?
- Will it survive leaving and returning?
- Is it saved as a draft?
- Will it remain after closing the app?
- When and how can the user discard it?
Make promises that match the behaviour. “Your edits are still on this screen” and “Draft saved” describe different outcomes.
Treat passwords, payment details and other sensitive information separately. Do not keep every value simply to avoid re-entry. Define which information may be retained, where, and for how long.
If leaving will discard unsaved work, explain that at the decision point and provide a clear way to keep editing.
What does a complete recovery flow look like?
Consider an illustrative appointment-request form.
The user enters a preferred slot and a message, then selects “Send request.” The button changes to “Sending…” and prevents another submission.
If a field is invalid, the form identifies it, explains the correction and preserves the other entries.
If the app confirms that submission failed, it keeps the message and offers a safe retry. If the outcome is unknown, it explains that uncertainty and offers a way to check the request status.
After confirmed success, the screen says “Request sent” and explains where to view it. It should not say “Appointment confirmed” when the request still needs approval.
This sequence defines the state of both the interface and the user's work.
Which common mistakes should you avoid?
Using one empty screen for every situation. A first visit, a failed load and an empty search need different explanations.
Offering retry for every error. Some problems require changed input, renewed access or a status check.
Clearing the form after failure. Preserve suitable input so users can correct or retry their work.
Showing endless loading. Define an exit from the waiting state and explain what remains possible.
Relying on colour or animation alone. Include text that identifies the state, and make messages and controls accessible to assistive technology.
Designing only the full-screen failure. Plan partial failures too, such as an unavailable attachment while the rest of the page remains usable.
How should you review these states before release?
Walk through each screen with this checklist:
- Can a new user tell what belongs here?
- Does an empty search offer a way to change the query?
- Does loading feedback identify the action in progress?
- Can users leave a waiting screen?
- Does an error explain the status of their work?
- Is the recovery action appropriate and safe?
- Does suitable input survive the failed attempt?
- Can users understand the state without relying on colour or motion?
Turn these scenarios into release checks. The guide to testing an Android app before release provides a useful next step for planning that verification. For a worked example in a billing app, see designing GST invoice screens for a billing app.
What else should you know about unavailable content?
Does every loading state need a skeleton screen?
No. Use one when the placeholder layout helps users understand what is arriving. A button label or simple loading message may be enough for a small action.
Should an empty state always include a button?
No. Include an action when the user can usefully take one. A read-only history screen may simply explain when records will appear.
Should an error disappear automatically?
Keep messages that require a decision or correction available long enough to act on. Avoid making a brief notification the only place users can learn why an important action failed.
Can these states wait until after the first release?
Include the states needed to complete and recover from each released feature. Keep their design simple, but define what users see when the successful path is unavailable. For a screen that relies on these states, see designing mobile app search and filters.