# Loading Indicator: Show Users the System Is Working, Clearly and Consistently

> A loading indicator tells people to wait. Learn when to use a spinner, progress bar, or skeleton screen, and how to build one that works for everyone.

**In short:** A loading indicator tells people to wait, using a spinner, progress bar or skeleton screen, and a design system builds it to work for everyone.

From "Design systems", a free course by Venkat R. Murty: https://designervenkat.online/learn/design-systems/loading-indicator

## What You Will Learn

Every product makes people wait sometimes. A file uploads, a feed fills with posts, or a form sends its answers. A loading indicator is the signal that tells people the system is busy and they should wait. In a design system, you build this signal once as a shared component, and you write rules for when each type should appear. By the end of this lesson you will be able to choose the right type, set timing rules, define variants, sizes, and states, and make the indicator work for people who use screen readers.

- **Loading indicator:** A visual or text signal that tells people the system is busy and they should wait.
- **Spinner:** A small rotating symbol. It shows that something is happening, but not how far along it is.
- **Progress bar:** A bar that fills as work gets done. It is only honest when it tracks real progress.
- **Skeleton screen:** Grey, empty shapes that copy a page’s layout and show where content will appear.
- **Determinate:** The system knows the total amount of work, so it can show a true percentage.
- **Indeterminate:** The system knows work is happening but cannot say how long it will take.
- **Variant:** A version of one component made for a different job, such as a small spinner for a button.
- **State:** What the indicator is doing at a given moment, such as idle, loading, done, or failed.
- **Layout shift:** When things jump to new positions on the screen after content arrives.
- **Flicker:** A signal that flashes on and off so fast that it only adds noise.
- **Screen reader:** Software that reads screen text out loud for people who cannot see the screen well.
- **Reduced motion:** A device setting that asks apps to limit movement and animation.

## What does a loading indicator do?

A loading indicator does two jobs. First, it stops the screen from looking frozen. Second, it sets expectations about what comes next. A blank screen with no signal makes people wonder whether the app is broken, and some of them will leave. A good indicator answers two questions at once: is the system working, and what is coming? A design system keeps those answers in one place, so each product team does not invent its own version of the wait.

## How do you choose the right type?

There are three main types. Pick one by asking two questions. How long will the wait be? Can the system measure how far along it is? Then ask what is loading: one small action, one area of a page, or a whole page.

- **Spinner:** Best for short waits where the length is unknown, such as a button that is submitting a form or a small search.
- **Progress bar:** Best when the system can measure real progress, such as a large upload, an export, or a multi-step import.
- **Skeleton screen:** Best when a whole page or list is loading and its layout is predictable, such as a feed of cards.

### When should you use a spinner?

A spinner suits a small action where the wait is brief and nobody can tell how long it will take. Examples include a Save button, a small search, or one number that refreshes. A spinner shows activity, not progress, so it should not become the default for every loading state. Keep spinners small, and place them where the result will appear. Avoid showing several spinners on one page, because they compete for attention.

### When should you use a progress bar?

A progress bar fits work that the system can measure, such as a big upload or a multi-step import. Designers call this a determinate indicator, because the total amount of work is known. When the total is not known, use an indeterminate indicator instead, such as a spinner with a short status message.

> **Tip:** Never fake a progress bar. A bar that moves on a timer and then stalls near 100 percent teaches people not to trust the whole product. Connect the bar to real progress data, or do not use a bar.

### When should you use a skeleton screen?

A skeleton screen shows grey shapes that match the final page. Each image gets a block, and each line of text gets a bar. Nielsen Norman Group, a well-known user research firm, describes skeleton screens as a placeholder for a loading page, used for full-page loads. The shapes give people a sense of the page structure, which helps them feel the wait is shorter. A skeleton is not worth the effort for a single number or a small icon. A spinner is simpler there.

## When to Show an Indicator

Timing decides whether an indicator should appear at all. Guides do not agree on exact numbers, so treat these bands as starting points and test them with your own product.

- **Under about one second:** Usually show nothing. An indicator that appears this fast only adds noise. One guide puts the threshold for feeling instant at 0.3 seconds.
- **About one to ten seconds:** Show a spinner for a short, unknown wait, or a skeleton for a page layout.
- **Over about ten seconds:** Show a progress indicator with a percentage or a status message.

> **Tip:** Add a short delay before the indicator appears. Fast loads then show nothing at all, which avoids flicker. Guides warn that a spinner which flashes for only about 80 milliseconds creates more noise than reassurance.

## Variants, Sizes, and States

Before you build the component, define its parts. A variant is a version made for a different job. A size is a named dimension, such as small or large. A state is what the indicator is doing at a given moment. Writing these down means teams pick from a fixed set instead of guessing.

### Variants and Sizes

The usual variants are the spinner, the progress bar, the skeleton, and an inline status message. Spinners often come in small, medium, and large sizes. One guide suggests small spinners of about 16 to 24 pixels, placed where the result will appear. Skeleton pieces should come as reusable parts, such as a text line, an avatar, a card, and a table row. Each piece should have the same dimensions as the real component it stands in for. Progress bars need a full, clearly visible track so the empty part is easy to see.

### States

- **Idle:** No indicator. The content is ready and nothing is loading. Every other state is compared against this one.
- **Loading:** The indicator is visible, and the area that is changing is marked as busy for assistive software.
- **Resolved:** Real content replaces the indicator, and the busy mark is removed so the finished area is not left looking unfinished.
- **Error:** A short message and a retry option replace the indicator. Every loading state needs a plan for failure, so the indicator never stays on forever.

### Placement

- **Inline:** Put a small indicator next to the part that is changing, such as one section of a list or one counter. Place it where the new content will appear.
- **In a button:** A small spinner inside the button shows that a submit is working. The rest of the page stays usable. The full button design belongs to the Button lesson.
- **Full page:** Use a skeleton for a full-page load. Avoid a centered spinner on an empty screen, because it gives no hint of the final layout.

## Avoiding Flicker and Layout Shift

Two problems ruin loading states, even when the system is working well. Flicker happens when a signal flashes too quickly to help. Layout shift happens when content jumps after the real data arrives, so people lose their place on the page. The steps below keep both problems out of the component.

1. **Add a short delay:** Wait a moment before the indicator appears. Loads that finish inside that moment never show a flashing signal.
2. **Match the size:** Build each placeholder at the same width and height as the real content, so the page does not change shape when data arrives.
3. **Swap in place:** Replace each placeholder with its real content in the same spot. Do this one section at a time, instead of resetting the whole screen.
4. **Keep old content visible:** When data is being refreshed and older content is already on screen, keep that content and add a small refresh marker. Do not replace it with a skeleton.
5. **Consider optimistic UI:** Optimistic UI shows the expected result straight away and corrects it only if the request fails. Use it for quick actions that almost always succeed.

## Accessibility Rules

A loading state that only people who can see it understand leaves screen reader users in silence. The rules below belong in the component itself, so every product gets them without extra work.

- **Announce the start and the end:** Use a status message, which is a text area that screen readers read out politely (the role is named status). Say something like Loading videos once at the start and once at the end, not on every animation frame.
- **Mark the busy area:** Set the busy flag (aria-busy) on the area that is updating, then remove it when content arrives. A flag left on after loading gives software a false picture.
- **Hide the decoration:** Spinners and skeleton shapes carry no meaning on their own. Hide the shapes from screen readers, and give the spinner a text label such as Loading.
- **Describe progress in words:** A progress bar should expose its current value along with a readable text version, such as 40 percent complete, so people who cannot see the bar still know where it stands.
- **Respect reduced motion:** When a user turns on reduced motion, show a still skeleton or a static indicator. Never rely on animation alone to show that something is loading. Pair motion with words.
- **Keep contrast high:** Skeleton blocks and progress tracks need enough contrast with the background so that people with low vision can see them. Check their colors against your color rules.

## Worked Example: A Video Feed

Imagine a video app with a home feed of cards. Each card has a thumbnail, a title, and a channel name. This is a teaching example, not a copy of any real product. Here is how the rules above apply, step by step.

1. **Pick the type:** The feed is a full list with a known layout, so the right choice is a skeleton screen. A spinner would leave the layout a mystery.
2. **Build the placeholders:** Make a grey block for each thumbnail, two bars for each title, and a short bar for the channel name. Give every placeholder the same width and height as the real card.
3. **Place them:** Show about one screen of placeholder cards where the real feed will appear. Do not center a spinner on an empty page.
4. **Swap in real cards:** As each card’s data arrives, replace its placeholder in the same spot. The page does not jump, because the grey shapes already held the right space.
5. **Respect reduced motion:** Users who turn on reduced motion see still grey shapes, with no shimmer.
6. **Announce and clean up:** Announce Loading videos once, mark the feed as busy while it loads, and remove the busy mark when the cards are in. Hide the grey shapes from screen readers.
7. **Plan the failure:** If the feed cannot load, replace the placeholders with a short message and a retry button.

Compare this with a lone spinner in the middle of an empty screen. The spinner says that something is happening, but it gives no hint of what the page will look like. When the cards finally appear, the whole page jumps. The skeleton does both jobs at once: it shows the wait and the coming layout.

> **Tip:** Keep skeleton colors neutral. The grey shapes do not need to match the real images, and bright placeholders compete with the content.

## Check Yourself

Try these three scenarios. Each one needs the rules in this lesson.

**Quick check:** In your design system, a user taps Save. The request usually finishes in under 300 milliseconds, but sometimes takes 5 seconds. Which behavior should the loading indicator specify?

A. Show a full-page spinner right away, so the user always sees that something is happening.
B. Show nothing for the first second. If the save is still running, show a small spinner inside the Save button with a short text status, and keep the rest of the page usable.
C. Show a progress bar that fills from 0 to 100 percent on every save, so the wait always looks measured.
D. Show no indicator at all, because saves are usually fast and a slow save is rare.

**Answer:** B. Most saves finish before the first second, so showing nothing avoids flicker. When a save really is slow, a small inline spinner with a text status shows that the button is working without blocking the page. A full-page block would overreact, a fake progress bar would mislead, and no indicator would leave slow saves looking frozen.

**Quick check:** A dashboard’s cards take about three seconds to load. The layout never changes: four cards in a row, each with a title and a chart. Which indicator fits best?

A. A skeleton screen with four placeholder cards whose title and chart shapes match the final cards.
B. A single spinner in the center of the empty page.
C. A progress bar that fills on a timer for three seconds.
D. A tiny spinner next to each number, with no placeholder for the charts.

**Answer:** A. The layout is predictable and the wait is only a few seconds, so matching placeholders show what is coming and prevent a jump. A centered spinner gives no layout hint, and a timer-driven bar is fake progress. Tiny spinners leave the charts unexplained.

**Quick check:** A team builds an export progress bar that always reaches 100 percent in eight seconds, whatever the server is doing. Testers find that big exports stall on the server for a minute. What should the designer change?

A. Make the bar move faster, so it reaches 100 percent in four seconds.
B. Tie the bar to the real progress reported by the export job. If the job cannot report progress, use an indeterminate indicator with a status message.
C. Add a second progress bar under the first to show more detail.
D. Replace the bar with a skeleton screen of the export page.

**Answer:** B. A progress bar must show real progress. If the system cannot measure the work, an honest indeterminate indicator with a clear message is better than a bar that lies. Speeding up a fake bar or adding another one keeps the lie, and a skeleton screen does not show progress for a job.

## Key Takeaways

A loading indicator is a shared component with clear rules. Match the type to the job: spinners for short unknown waits, progress bars for measured work, and skeleton screens for page layouts. Use timing rules so fast loads show nothing and slow loads never go silent. Define the variants, sizes, and states once, and build the accessibility rules in: status messages, a busy flag, hidden decoration, reduced motion, and good contrast. Other lessons cover the Button, Toast messages, accessibility testing, and measuring how often indicators are used.

## Sources

- [Nielsen Norman Group: Skeleton Screens 101](https://www.nngroup.com/articles/skeleton-screens/)
- [Carbon Design System: Loading pattern](https://v10.carbondesignsystem.com/patterns/loading-pattern/)
- [Nielsen Norman Group post on X about indicator choice](https://x.com/NNgroup/status/1834298272694886578)
- [The Plus Addons: Skeleton Loading Screen (summary of NN/G guidance)](https://theplusaddons.com/blog/skeleton-loading-screen/)
- [Eleken: Spinner UI designer's guide](https://www.eleken.co/blog-posts/spinner-ui)
- [OneThing: Skeleton Screens vs Loading Spinners](https://www.onething.design/post/skeleton-screens-vs-loading-spinners)
- [SaaS UI: Loading and Skeleton UX Patterns](https://www.saasui.design/blog/saas-loading-skeleton-ux-patterns)
- [Smart Interface Design Patterns: Designing Better Loading and Progress UX](https://smart-interface-design-patterns.com/articles/designing-better-loading-progress-ux/)
- [OpenReplay: A Quick Guide to Loading Indicators in Web Apps](https://blog.openreplay.com/quick-guide-loading-indicators-web-apps/)
- [UI Guides: How to Design Loading States](https://www.uiguides.com/guides/how-to-design-loading-states)
- [Originux: Loading State and Skeleton Screen Design Best Practices](https://www.originux.com/resources/blog/loading-state-skeleton-screen-design-best-practices/)
- [A11y Examples: Accessible Loading States](https://a11y-examples.com/examples/loading-states/)
- [Kompassify: Loading States in UX](https://kompassify.com/blog/loading-state-ux-guide)
- [Inspoai: Loading State Design](https://www.inspoai.io/blogs/loading-state-design)
- [Fat Cow: How to Design a Skeleton Loading Screen](https://www.fatcowwebdesign.com/how-to-design-a-skeleton-loading-screen-css-techniques-and-ux-best-practices/)
- [02UI: Loading and skeleton](https://02ui.com/components/loading-and-skeleton/)
- [Mironsoft: Skeleton Screens vs. Spinners](https://www.mironsoft.de/en/blog/skeleton-screens-vs-spinners-designing-loading-states-for-ux)
- [Emplifi Soul: Loading pattern](https://soul.emplifi.io/latest/patterns/patterns/loading-2wuAysTL)
- [Kirkoc: Loading Experience, Skeleton Screens and Progress Indicators](https://kirkoc.com/en/blog/yukleme-deneyimi-skeleton-ve-ilerleme-gostergeleri/)
- [CSS Loading Loop: Accessible Loading Indicators](https://css-spinners.com/accessible-loading-indicators/)
