35 UI & UX States Visual Guide (Checklist & Mockups)

A complete visual guide and practical checklist of 35 essential UI and UX states every website and app must design before shipping. Includes mobile mockups, rules, and quick tests.

By Vikas YadavPublished 19 Nov 202613 min read

Get the PDF

Free. No email or account needed. PDF · 2.5 MB

Download PDF

The preview only loads when you tap "Read PDF here", which saves mobile data. Download gives you the original PDF file.

Key takeaways

  • Design for edge cases (Empty, Loading, Error, Offline) before launch, not after user complaints.
  • Always provide clear visual feedback and recovery actions (e.g. Try Again, Clear Filters, Undo).
  • Never show unformatted errors, endless unlabelled spinners, or fake success messages.

35 UI & UX States Visual Guide: Complete Checklist

Before launching any website, mobile app, or software product, review these 35 essential UI/UX states. Most teams design only the "happy path" when data loads perfectly. When real users experience blank screens, network drops, unhandled errors, or lost form entries, they abandon the app.

Download the free visual PDF above to review visual mockups, rules, and quick tests for each state.


1. Basic UI States (1–10)

01. Empty State

  • When to use it: A new user opens a page before adding their first item (e.g. fresh account with no projects, zero bookmarks).
  • What to show: A clear message explaining what is missing, a simple explanation of what the page is for, and a prominent primary action button (e.g. "+ Create project").
  • What to avoid: A blank white screen, a button called "Click here", or treating a brand-new account like an error.
  • Quick check: Can a new user immediately understand what to do next? Tap "+ Create project" to ensure it opens the creation form.

02. Loading State

  • When to use it: The application is fetching data from the server or performing calculations.
  • What to show: Skeleton placeholders that mirror incoming cards and text, subtle shimmer animation, and consistent brand colors.
  • What to avoid: Blank white freeze, unlabelled infinite spinners, or blocking the entire screen for a small list update.
  • Quick check: Throttle network to Slow 3G and verify that no sudden layout shifts occur when content loads.

03. Saving State

  • When to use it: The user taps "Save" or "Update" and changes are being persisted to the backend.
  • What to show: An in-button spinner, temporary disabled state on the submit button, and clear "Saving changes..." feedback.
  • What to avoid: Allowing rapid repeated taps on "Save", leaving the button unchanged, or navigating away before the server confirms.
  • Quick check: Rapidly tap "Save" five times and verify only one single network request is dispatched.

04. Progress State

  • When to use it: Long-running operations such as large file uploads, data exports, or batch processing.
  • What to show: Real numerical progress bar, transferred bytes (e.g. 14.2 MB / 21.8 MB), and a clear "Cancel upload" option.
  • What to avoid: Fake progress bars that jump to 99% and freeze, or transfers that cannot be cancelled.
  • Quick check: Simulate network pauses and confirm the progress bar holds accurately rather than displaying fake numbers.

05. Error State

  • When to use it: A server crash, 500 error, bad API response, or network failure prevents data from loading.
  • What to show: Friendly human explanation of what went wrong, an instant "Try again" retry button, and support contact options.
  • What to avoid: Technical stack traces, raw JSON errors, or dead-end screens without a retry pathway.
  • Quick check: Reconnect your internet connection, tap "Try again", and confirm data loads cleanly.

06. Permission Denied

  • When to use it: A user attempts to visit an admin page, billing dashboard, or private record without required permissions.
  • What to show: The specific role required (e.g. Workspace Admin), who to contact to request access, and a safe navigation button back home.
  • What to avoid: Cold "403 Forbidden" errors, pretending the page does not exist, or trapping users with no navigation.
  • Quick check: Verify the user has a one-tap route to return to their dashboard or request access from an administrator.

07. Success State

  • When to use it: An important transaction completes (payment processed, invoice sent, account created).
  • What to show: High-contrast positive visual badge (green checkmark), transaction reference numbers, and logical next steps.
  • What to avoid: Silent success where the screen doesn't change, or full-page takeovers for minor non-critical updates.
  • Quick check: Verify the confirmation details (recipient, invoice ID, amount) accurately match the user's input.

08. No Results State

  • When to use it: A search query or active filter combination yields zero matching records.
  • What to show: The exact search query and active filters, helpful search suggestions, and a "Clear filters" button.
  • What to avoid: Confusing this with an Empty State (new user), leaving a completely blank list, or forcing manual backspacing.
  • Quick check: Tap "Clear filters" and ensure all standard records immediately reappear.

09. Validation State

  • When to use it: A user enters an invalid email format, weak password, or leaves mandatory fields empty.
  • What to show: High-contrast red field border, clear corrective text directly below the field, and instant live re-validation upon correction.
  • What to avoid: Flashing errors prematurely before the user finishes typing, vague messages like "Invalid data", or clearing entered passwords.
  • Quick check: Fix the email formatting and verify the red outline clears instantly.

10. Warning State

  • When to use it: Permanent or destructive operations (deleting a project, downgrading an account, purging records).
  • What to show: Prominent amber/red warning icon, specific consequences of proceeding (e.g. 42 files deleted), and distinct button hierarchy.
  • What to avoid: Vague "Are you sure?" prompts, hiding consequences, or making the destructive action look like the safe default.
  • Quick check: Ensure Cancel is the safest and most obvious choice, and tapping outside the modal safely dismisses it.

2. User Action States (11–20)

11. Offline State

  • When to use it: The device loses internet connectivity (Wi-Fi off, flight mode, poor reception).
  • What to show: Persistent top offline indicator banner, access to locally cached records, and reassurance that drafts are safe.
  • What to avoid: Crashing the application, showing a white blank screen, or losing unsaved edits made while offline.
  • Quick check: Turn on Airplane mode and verify notes or cached dashboards remain readable and editable.

12. Reconnecting State

  • When to use it: The network connection drops momentarily and the app is attempting an automatic reconnect.
  • What to show: Top reconnecting notification banner, attempt counter (Attempt 2 of 5), and a manual "Retry now" shortcut.
  • What to avoid: Flickering between connected and disconnected modals, or resetting user input on reconnection.
  • Quick check: Restore internet connection and verify the status banner auto-dismisses without requiring a full page refresh.

13. Session Expired

  • When to use it: An authentication token or session cookie times out due to inactivity.
  • What to show: Reassuring security reason, pre-filled user email address, password prompt, and seamless return to current work.
  • What to avoid: Hard redirecting to the homepage and wiping typed form contents, or unhandled 401 exceptions.
  • Quick check: Log back in after a session timeout and confirm you return directly to the exact form you were editing.

14. Unsaved Changes

  • When to use it: The user attempts to navigate away, close a tab, or tap Back while form fields contain unsaved edits.
  • What to show: Warning that edits will be lost, name of the modified document, and three choices: Save, Discard, or Stay.
  • What to avoid: Allowing users to close forms with zero warning, or using ambiguous "Yes/No" options.
  • Quick check: Make an edit, click Back, select "Stay on this page", and verify typed text is fully intact.

15. Partial Success

  • When to use it: Batch operations (e.g. uploading 10 images) where some items succeed and others fail.
  • What to show: Exact counts of successes and failures, specific error reasons per failed item, and a "Retry failed items" button.
  • What to avoid: Marking the entire batch as a complete failure, or forcing users to re-upload files that already succeeded.
  • Quick check: Tap "Retry failed" and verify only the failed records are re-submitted.

16. Disabled State

  • When to use it: An action cannot be executed until prerequisites are met (e.g. agreeing to terms, filling address).
  • What to show: Reduced visual opacity, not-allowed cursor, helpful inline helper text explaining what is missing, and instant activation once fulfilled.
  • What to avoid: Mystery disabled buttons with zero explanation, or hiding the button entirely.
  • Quick check: Complete the missing requirement and verify the button turns into an active blue button immediately.

17. Confirmation State

  • When to use it: High-impact human decisions (removing a team member, revoking API credentials).
  • What to show: Explicitly named subject, immediate real-world consequence, and clear action verbs ("Remove member" vs "Cancel").
  • What to avoid: Using confirmation dialogs for routine, reversible actions (which creates click-blindness).
  • Quick check: Ensure pressing Escape or clicking the backdrop safely cancels the action.

18. Timeout State

  • When to use it: External payment gateways, bank webhooks, or third-party APIs take too long to reply.
  • What to show: Explicit timeout message, caution against duplicate submissions, and a "Check status" verification button.
  • What to avoid: Infinite unhandled spinners, or allowing users to accidentally double-charge credit cards.
  • Quick check: Ensure payment action buttons remain locked while checking transaction status.

19. Conflict State

  • When to use it: Concurrent collaborative edits where another teammate saved changes while you were editing.
  • What to show: Name of the teammate and timestamp of competing edit, side-by-side diff, and options to merge or save as copy.
  • What to avoid: Silently overwriting someone else's work (last-write-wins data loss), or discarding the local user's draft.
  • Quick check: Select "Save as copy" and verify both versions exist safely without data loss.

20. Upload / Download State

  • When to use it: Multi-file media management, document uploads, or large archive downloads.
  • What to show: Per-file progress bars, transfer speeds (MB/s), thumbnail previews, and individual pause/cancel controls.
  • What to avoid: A single generic progress bar hiding individual file errors.
  • Quick check: Cancel a single file in the queue and verify remaining files continue transferring normally.

3. System & Workflow States (21–30)

21. Background Processing

  • When to use it: Heavy asynchronous tasks that take 30+ seconds (video encoding, generating 10,000-row CSV exports).
  • What to show: Reassurance that the user can safely navigate away, estimated duration (~2 minutes), and notification method (email / in-app bell).
  • What to avoid: Forcing users to wait on a frozen screen, or aborting the job if the user switches tabs.
  • Quick check: Navigate to another screen during export and verify you receive an alert when the job completes.

22. Cancelled State

  • When to use it: The user voluntarily aborts an in-progress export, transfer, or workflow.
  • What to show: Explicit confirmation that cancellation succeeded, reassurance that no partial changes were saved, and a restart button.
  • What to avoid: Ambiguity over whether changes were partially committed, or leaving orphaned temporary files.
  • Quick check: Tap "Start again" and verify the flow initializes with clean default settings.

23. Maintenance State

  • When to use it: Scheduled database upgrades, infrastructure migrations, or planned downtime.
  • What to show: Friendly non-error explanation, estimated return time in UTC and local timezone, and a link to an external status page.
  • What to avoid: Generic 500 error screens, or hosting the status page on the same down server.
  • Quick check: Verify the status page link opens an independently hosted uptime dashboard.

24. First-Time User

  • When to use it: A brand-new registered user lands on the dashboard for the very first time.
  • What to show: Warm personalized welcome, focused 3-step checklist to achieve first value, and a single prominent activation button.
  • What to avoid: Bombarding users with 15 modal tooltips, dumping them onto a blank screen, or hiding the skip button.
  • Quick check: Ensure a clear "Skip for now" link exists for experienced users who prefer self-directed exploration.

25. Completion State

  • When to use it: Completing a multi-step workflow (setup wizard, KYC verification, store launch).
  • What to show: Celebratory visual icon, summary of key milestones reached, and a direct launchpad button into the active workspace.
  • What to avoid: Anti-climactic silent endings that leave users wondering what to do next.
  • Quick check: Tap "Go to dashboard" and verify the setup wizard does not show again.

26. Hover / Focus / Pressed

  • When to use it: Interactive buttons and links across mouse, touch, and keyboard navigation.
  • What to show: Subtle hover elevation on cursor hover, depressed scale on touch tap, and a high-contrast 2px/3px focus ring on Tab.
  • What to avoid: Removing outline: none without providing an accessible alternative, or having zero touch feedback on mobile.
  • Quick check: Press Tab on keyboard and verify a crisp high-contrast focus outline wraps the active button.

27. Instant Update & Undo

  • When to use it: Optimistic UI updates (toggling a task, liking a post, changing a status).
  • What to show: Instant visual state change without waiting for network roundtrip, subtle Undo floating toast, and graceful rollback if the API rejects.
  • What to avoid: Freezing the UI on every click waiting for an API response, or failing silently without rolling back.
  • Quick check: Simulate an API failure and confirm the checkbox reverts to its original state with a notification.

28. Undo State

  • When to use it: Reversible deletions (moving an email to trash, deleting a row).
  • What to show: Instant action notification, prominent high-contrast Undo button, and a visible 6-to-10 second timer.
  • What to avoid: Interrupting everyday actions with annoying confirmation dialogs (use Undo instead).
  • Quick check: Tap "Undo" and verify the removed item returns immediately to its exact list position.

29. Too Many Requests

  • When to use it: Rate limiting (HTTP 429) on login attempts, OTP requests, or search queries.
  • What to show: Transparent security explanation, live countdown timer showing seconds remaining, and auto-unlocking submit button.
  • What to avoid: Silent lockouts where users click repeatedly without knowing why, or permanent lockouts without recovery.
  • Quick check: Wait out the countdown and verify the button automatically re-enables without a page reload.

30. Waiting in Queue

  • When to use it: High-traffic ticket sales, AI generation queues, or flash sales.
  • What to show: Real queue position number (#14 in line), realistic estimated wait time, and advice to keep the window open.
  • What to avoid: Fake spinning animations that pretend processing is immediate, or losing queue position on accidental reload.
  • Quick check: Refresh the browser and verify the queue session cookie retains your exact spot in line.

4. Advanced UI States (31–35)

31. Old Data State

  • When to use it: Cached analytics dashboards, financial rates, or offline-read views.
  • What to show: Clear timestamp stating when data was last updated, an obvious "Refresh now" button, and warning if data is stale.
  • What to avoid: Presenting cached numbers as real-time truth, or hiding cache timestamps in deep settings.
  • Quick check: Tap "Refresh now" and verify both the data and the timestamp update immediately.

32. Sync State

  • When to use it: Cloud-synced apps (notes, docs, collaborative project boards).
  • What to show: Continuous status indicator (Syncing, Synced, or Sync Failed), and clear distinction between local save and cloud sync.
  • What to avoid: Claiming "Saved" when edits haven't reached the server, or blocking typing while syncing.
  • Quick check: Type rapidly and verify typing remains smooth while background sync runs.

33. Multi-Step Form

  • When to use it: Long workflows (loan applications, onboarding, checkout wizards) split across stages.
  • What to show: Numbered progress indicator, safe Back button that preserves previous entries, and per-step auto-save.
  • What to avoid: Resetting previous answers if the user taps "Back", or hiding how many steps remain.
  • Quick check: Click "Back" to Step 1 and verify all entered fields remain fully filled.

34. Accessibility State

  • When to use it: Ensuring the interface meets WCAG accessibility standards for all users.
  • What to show: Minimum 4.5:1 contrast ratio, 48px touch targets, descriptive screen-reader aria-labels on icon buttons, and visible keyboard outlines.
  • What to avoid: Low-contrast light gray text, unlabelled icon buttons, or trapping keyboard focus inside modals.
  • Quick check: Navigate and activate buttons using only keyboard Tab + Enter and VoiceOver.

35. Update Required

  • When to use it: Breaking API deprecations, critical security patches, or mandatory mobile app upgrades.
  • What to show: Transparent reason for the mandatory update, direct link to the App Store / Play Store, and version highlights.
  • What to avoid: Abrupt application crashes without explanation, or trapping users on a broken screen without a store link.
  • Quick check: Tap "Update on App Store" and confirm it opens the native store listing directly.
All resources
App DevelopmentFeatured

A More Secure Android Referral System

A three-page guide on why simple referral codes are easy to abuse, which Google Play tools make them safer, and what to fix before you launch.

Updated 9 Oct 2026
Security & PrivacyFeatured

Application Security & Anti-Reverse Engineering Playbook

Complete roadmap to protect your mobile app and web application's source code, core logic, proprietary assets, and brand name from reverse engineering, APK repackaging, and copycats.

Updated 20 Nov 2026