Skeleton Screens vs Spinners vs Nothing: A 2026 Decision Guide
Skeletons aren't a universal upgrade over spinners, and sometimes the best loading state is no loading state at all. Here's how to pick the right one based on wait time, layout stability, and user intent.
Skeleton screens became the default loading pattern around 2018, and ever since, every design review has had someone saying "let's replace the spinner with a skeleton." That's lazy advice. Skeletons, spinners, and showing nothing at all each solve different problems, and picking the wrong one can make your app feel slower than it actually is.
This is the framework we use on client projects when a page has a loading state to design.
The three options, honestly
Before we get into when to use what, let's be precise about what each pattern actually is.
Spinner: an indeterminate animation that says "something is happening, I don't know when it'll finish." Cheap to implement, universally understood, visually generic.
Skeleton screen: a low-fidelity preview of the layout that will appear, usually animated with a shimmer or pulse. Tells the user "content is coming, and here's roughly where it'll land."
Nothing (optimistic or instant render): either you render the final UI immediately with cached/optimistic data, or you wait a short beat and render the real thing without showing any intermediate state.
Each has a cost. Spinners feel slower than they are because they give the eye nothing to anchor on. Skeletons cost design and engineering time, and they lie if the real layout doesn't match. "Nothing" risks a flash of blank screen if your wait is longer than you thought.
The decision framework
In our experience, three variables decide the answer: expected wait time, layout predictability, and user intent.
Expected wait time
We bucket waits into four ranges. These aren't hard science — they come from Nielsen's old latency thresholds plus what we've measured on real apps — but they're a useful starting point.
- Under ~100ms: the user won't perceive a delay. Show nothing. Any loading indicator here is noise and can actually cause a flicker.
- ~100ms to ~400ms: the sweet spot for a delayed indicator. Show nothing for the first 200–300ms, then reveal a skeleton or spinner if the request hasn't resolved.
- ~400ms to ~2s: definitely show something. This is where skeletons shine.
- Over ~2s: you need progress, not just activity. Consider a progress bar, step indicator, or streaming partial content.
The mistake we see most often is showing a skeleton for a 150ms request. The skeleton appears, animates one shimmer cycle, and disappears. The user's brain registers it as a glitch.
// A delayed loading state — don't show anything for the first 250ms
function useDelayedLoading(isLoading: boolean, delayMs = 250) {
const [showLoader, setShowLoader] = useState(false);
useEffect(() => {
if (!isLoading) {
setShowLoader(false);
return;
}
const t = setTimeout(() => setShowLoader(true), delayMs);
return () => clearTimeout(t);
}, [isLoading, delayMs]);
return showLoader;
}
This one hook eliminates about 80% of the "jittery loading" complaints we get on audits.
Layout predictability
Skeletons are a promise. You're telling the user "the real content will occupy roughly this space, in roughly this shape." If you can't keep that promise, don't make it.
Use skeletons when:
- You know the number of items (e.g. a paginated list of 20)
- You know the rough dimensions of each item (card height, avatar size, text lines)
- The layout doesn't shift dramatically based on content
Use a spinner when:
- The result could be 0 items or 500 items
- Items vary wildly in size (user-generated content, mixed media feeds)
- The entire page structure depends on the response (e.g. a dashboard that renders different widgets per user)
A skeleton that shows three cards and then renders twelve feels worse than a spinner. The user has already mentally committed to the shape.
User intent
This one gets overlooked. What is the user trying to do?
- Browsing / exploring: skeletons work well. The user is scanning, and the skeleton gives them something to scan.
- Hunting for a specific thing: spinners can be better. The user doesn't care about the layout; they want the answer. A skeleton delays the moment they can verify "did my search work?"
- Submitting / committing: use button-level pending states, not full-page skeletons. The user knows what they clicked; they just need confirmation it worked.
Where skeletons go wrong
We've shipped skeletons we regretted. Here are the patterns to avoid.
The "generic grey box" skeleton
If your skeleton is three rounded rectangles stacked vertically, it's not telling the user anything a spinner wouldn't. The whole point of a skeleton is to prime the user's visual system for the specific content. Match the real layout: avatar circles should be circles, headlines should be wider than body text, buttons should sit where buttons will sit.
The mismatched skeleton
Skeletons drift. The real UI evolves, the skeleton doesn't, and six months later the skeleton shows a layout that no longer exists. Then there's a jarring reflow when the real content loads.
Fix: build skeletons from the same component primitives as the real UI. If your Card component accepts a loading prop that swaps text for shimmer bars, the skeleton can't drift.
function UserCard({ user, loading }: Props) {
return (
<div className="flex gap-3 p-4">
<Avatar src={user?.avatar} loading={loading} />
<div className="flex-1 space-y-2">
<TextLine width="60%" loading={loading}>
{user?.name}
</TextLine>
<TextLine width="40%" loading={loading} muted>
{user?.role}
</TextLine>
</div>
</div>
);
}
One component, two states, zero drift.
The forever-shimmering skeleton
If your request fails, the skeleton keeps shimmering. The user has no idea anything is wrong. Always wire your loading states to a timeout — if the request hasn't resolved in, say, 10 seconds, swap to an error state with a retry.
Skeletons on cached content
This one is painful. Users navigate back to a page they just visited, and instead of seeing the content instantly (you have it cached!), they see a skeleton flash. This happens constantly with naive React Query or SWR setups that treat every mount as a cold fetch.
If you have stale data, render it. Revalidate in the background. Only show a loading state if there's literally nothing to show.
Streaming changes the math
In 2026, with React Server Components, Next.js streaming, and Suspense boundaries being genuinely usable, the "all or nothing" loading model is dead. You can render the shell instantly, stream in the header, then the sidebar, then the main content, each with its own Suspense fallback.
This changes how you should think about skeletons. They're no longer page-level — they're boundary-level. A good pattern:
- Shell: renders instantly from the server, no fallback needed
- Above-the-fold content: tight skeleton that matches the real layout exactly
- Below-the-fold content: can use a simpler skeleton or even just a spinner, since the user may not see it
The performance win isn't the skeleton itself — it's that the user sees something real (nav, header, breadcrumbs) in under 100ms, and the skeletons are just filling in the gaps.
Accessibility, briefly
Whatever you pick, screen reader users need to know what's happening. A silently shimmering skeleton is invisible to them.
- Wrap loading regions in
aria-busy="true"while loading - Include a visually hidden
<span>Loading results</span>or usearia-live="polite"to announce when content arrives - Don't rely on animation alone — respect
prefers-reduced-motionand swap shimmer for a static muted state
@media (prefers-reduced-motion: reduce) {
.skeleton {
animation: none;
background: var(--color-surface-muted);
}
}
A quick cheat sheet
| Situation | Use |
|---|---|
| Request likely under 200ms | Nothing (with delayed fallback) |
| Known layout, 200ms–2s wait | Skeleton matching real layout |
| Unknown layout or result count | Spinner |
| Over 2s wait | Progress indicator or streaming |
| Form submission | Button-level pending state |
| Returning to cached page | Stale content, background refetch |
| Search results | Spinner + instant results as they stream |
Where we'd start
If you're auditing an existing app, do this in order:
- Measure your actual wait times. Open DevTools, throttle to Fast 3G, and time your top five loading states. You'll likely find half of them are under 300ms and don't need any indicator at all.
- Add a
useDelayedLoadinghook and apply it everywhere you currently show a spinner or skeleton immediately. - Find one list view where the skeleton doesn't match the real layout, and refactor it to share components.
- Check what happens on your slowest page when the network fails. If your skeleton shimmers forever, fix that first.
If you want a second pair of eyes on your loading patterns or a broader design system audit, that's the kind of work our design and UX team does regularly.
Want a team like ours?
72Technologies builds production software for the kind of teams who actually read this blog.
Start a projectKeep reading
Designing Error Messages That Don't Blame the User
Most error copy is written by backend exceptions and shipped unchanged. Here's a working framework for error messages that tell users what happened, what to do next, and whose fault it actually is.
Empty States Are Your Best Onboarding: Designing the Zero-Data Screen
The empty state is the first screen most users actually read. Here's how to design zero-data screens that teach, convert, and stop looking like bugs.
Focus Rings in 2026: Stop Hiding Them, Start Designing Them
Focus rings are the most-deleted accessibility feature in modern design systems. Here's how to design ones that keep keyboard users safe without making your brand team cry.
