All articles
Design & UXNovember 16, 2026 7 min read

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.

Most product teams spend weeks polishing the dashboard a power user sees on day 90, and roughly fifteen minutes on the screen a new user sees on day zero. That screen — the empty state — is the single highest-leverage surface in your product. It's where confused users decide whether you're worth another click.

Why empty states are the real onboarding

Tooltip tours get dismissed. Welcome modals get closed. Product videos get skipped. The one thing a new user cannot avoid is the screen that loads when they land in a feature with no data yet. That's your actual onboarding, whether you designed it that way or not.

In client audits we run, the pattern is depressingly consistent: an illustration of a cute cardboard box, the words "No items yet," and a button labelled "Create." Create what? Why? What happens next? The user bounces, and the PM blames activation metrics on the signup flow.

An empty state has three jobs, in this order:

  1. Reassure the user nothing is broken.
  2. Explain what belongs on this screen and why they'd want it there.
  3. Act — give them the shortest possible path to a non-empty state.

Skip any one of those and you've built a dead end.

The four kinds of empty, and why the distinction matters

Treating every zero-data screen the same is the root cause of most bad empty states. There are at least four distinct situations, and each wants a different design.

First-use empty

The user has never used this feature. They may not know what it does. This is the one that needs to teach — a short value statement, a preview of what a populated screen looks like, and a primary action with sample data if possible.

User-cleared empty

The user has used this feature before but currently has nothing in it. Think: inbox zero, all tasks completed, no active projects. This one should celebrate or acknowledge, not re-teach. Showing a tutorial to someone who just archived their last email is condescending.

Filtered empty

The data exists, but the user's current filter or search returns nothing. The correct response is to surface the filter state and offer a one-click reset. Nothing else. Do not show onboarding copy here — it implies the feature is broken.

Error-masquerading-as-empty

The API failed, the permission was revoked, or the query timed out, and your frontend fell back to the empty state. This is the worst offender because it lies to the user. Always distinguish real emptiness from a failed fetch, even if it means two separate components.

Anatomy of an empty state that works

We've converged on a fairly tight component structure across projects. Five slots, roughly in this order:

  • Visual anchor — a small illustration or icon, not a full-bleed hero. It signals "this is an intentional screen," not a loading glitch.
  • Headline — one sentence, present tense, describes the state. "You haven't added any clients yet." Not "Welcome!"
  • Explanation — one or two sentences on why this screen exists and what populates it.
  • Primary action — the single most likely next step, as a real button.
  • Secondary path — a lower-weight link to import, use a template, or learn more.

Here's a Tailwind + React version of the pattern we usually start from:

type EmptyStateProps = {
  icon: React.ReactNode;
  title: string;
  description: string;
  primaryAction: { label: string; onClick: () => void };
  secondaryAction?: { label: string; onClick: () => void };
};

export function EmptyState({
  icon,
  title,
  description,
  primaryAction,
  secondaryAction,
}: EmptyStateProps) {
  return (
    <div
      role="status"
      className="mx-auto flex max-w-md flex-col items-center
                 gap-4 px-6 py-12 text-center"
    >
      <div className="text-slate-400" aria-hidden="true">
        {icon}
      </div>
      <h2 className="text-lg font-semibold text-slate-900">
        {title}
      </h2>
      <p className="text-sm text-slate-600">{description}</p>
      <div className="mt-2 flex flex-col items-center gap-2">
        <button
          type="button"
          onClick={primaryAction.onClick}
          className="rounded-md bg-slate-900 px-4 py-2
                     text-sm font-medium text-white
                     hover:bg-slate-800 focus-visible:outline
                     focus-visible:outline-2 focus-visible:outline-offset-2
                     focus-visible:outline-slate-900"
        >
          {primaryAction.label}
        </button>
        {secondaryAction && (
          <button
            type="button"
            onClick={secondaryAction.onClick}
            className="text-sm text-slate-600 underline
                       underline-offset-4 hover:text-slate-900"
          >
            {secondaryAction.label}
          </button>
        )}
      </div>
    </div>
  );
}

A few notes on that snippet. The role="status" makes screen readers announce the state change when the component mounts after a fetch resolves to an empty result — small thing, large impact for assistive tech. The icon is aria-hidden because the title already describes the state. Focus styles are explicit and visible; this is not the place to be clever with outline-none.

Copywriting: the part everyone gets wrong

Designers obsess over the illustration. Users read the text. Three rules we enforce in every design review:

Name the noun. "No items" is lazy. "No invoices," "No saved searches," "No team members" — the specificity tells the user they're in the right place.

Describe the populated state, not the empty one. Compare:

No reports yet.

with:

Reports let you share dashboards as weekly PDFs. Create one to get started.

The second version teaches the feature in the moment of highest intent — when the user just clicked into it.

Match the button verb to the headline. If the headline says "You haven't added any clients," the button says "Add client," not "Get started" or "Continue." This sounds obvious until you audit your own product.

A quick war story

On one B2B dashboard we worked on, the "Integrations" tab had an empty state that said "Connect your first integration" with a button labelled "Browse integrations." Activation on that tab was under 8%. We changed the headline to name three specific tools the user had mentioned during signup ("Connect Slack, HubSpot, or Stripe to sync contacts automatically") and replaced the single button with three logo-tagged quick-connect buttons. Activation on that tab roughly tripled over the next quarter. Same feature, same backend, different empty state.

We're not claiming every empty state redesign does that. But when the baseline is "generic illustration plus vague button," the ceiling is high.

Sample data, templates, and the "borrow a starting point" pattern

The hardest part of a blank canvas is the blank. Any feature where the user has to construct something — a workflow, a dashboard, a form, a project — benefits from offering a starting point instead of a blank slate.

Three flavours, in increasing effort:

  • Sample data toggle. A "Show me an example" link that populates the screen with read-only demo data. Low cost to build, lets the user understand the shape of a filled state.
  • Templates. Two to five pre-built starting points tailored to common use cases. Requires content work but pays back forever.
  • Guided first creation. A short flow that asks two or three questions and generates a starter object. Highest effort, highest conversion for complex features.

Pick based on how much structural variety the feature has. A notes app doesn't need templates. A CRM pipeline does.

Accessibility and motion considerations

A few things that routinely get missed:

  • Don't animate the illustration on loop. It draws the eye away from the text that actually matters, and it's distracting for users with vestibular sensitivities. A single entrance animation under 300ms is fine; respect prefers-reduced-motion.
  • Announce state transitions. When a list goes from loading to empty, assistive tech should hear the change. The role="status" pattern above handles this, but test it with VoiceOver or NVDA.
  • Contrast on muted illustrations. Empty-state art tends to be pastel and low-contrast by convention. That's fine for decoration, but make sure any text inside the illustration — or icons that convey meaning — meets at least WCAG AA against the background.
  • Keyboard order. The primary action should be the next tab stop after the page's main navigation, not buried behind the illustration or a secondary link.

Where we'd start

If you're staring at a product with a dozen half-baked empty states, don't try to redesign them all at once. Run this instead:

  1. List every empty state in the product. You'll find more than you expected — filter results, search results, archived views, permission-blocked views.
  2. Tag each one as first-use, user-cleared, filtered, or error. Most products have no error-distinct variants; add them first because they're the ones silently killing trust.
  3. For the top three screens by traffic, rewrite the headline to name the noun and the description to describe the populated state. Ship that this sprint.
  4. Only then invest in illustrations, templates, or sample data.

Empty states are cheap to improve and expensive to ignore. Treat them like the onboarding surface they already are, and the rest of your activation funnel starts making more sense. If you want a second pair of eyes on your zero-data screens, our team does this kind of work on product design engagements regularly — usually with surprising results on activation dashboards no one wanted to look at.

#UX#Design Systems#Onboarding#Frontend

Want a team like ours?

72Technologies builds production software for the kind of teams who actually read this blog.

Start a project