A blank table can mean several things.

There may be no orders yet. A filter may have hidden them. The account may not have permission to see them. Or the request may have failed.

If every case produces the same “Nothing here” message, the interface has removed information the user needs.

Empty state UX design starts with a simple job: explain why a space is empty and, when possible, show what the user can do next.

That requires more than an illustration and a friendly sentence. It requires the interface to know which state it is showing.

An empty screen is not one state

Consider an order dashboard. The table contains no rows in each of these situations:

SituationWhat the user needs to knowUseful next step
A new account has no ordersNo orders exist yetExplain how orders arrive
A search found no matchesThe search completed without a matchChange the search
Filters removed all visible resultsThe current filters are too restrictiveAdjust or clear filters
All tasks are completeThere is nothing left in this queueContinue elsewhere, if relevant
Data could not be loadedThe service could not retrieve the informationRetry when appropriate
Access is restrictedThe account cannot see the informationExplain the available access route

The layout can be shared. The message should reflect the actual condition.

A service failure is not proof that the account has no orders. A filtered list is not proof that the underlying list is empty. Treating them as the same state can lead users to make the wrong decision.

Atlassian’s design guidance describes empty states as a way to show that there is nothing to display and provide context about what comes next. The exact wording and action still depend on the product and the situation.

Start with the question the user is trying to answer

An empty state should fit the task around it.

Someone opening an orders page may be asking, “Has a new order arrived?” Someone opening a saved items page may be asking, “Where did I put that product?”

The same generic message helps neither of them.

Compare:

Nothing to see here
Get started by exploring the platform.

With:

No saved items yet
Save an item to find it here later.
Browse items

The second version names the missing content, explains how the space is populated and offers a relevant action.

That action must exist and be available to the user. If the person cannot add items, do not show a button that leads to a permission error.

A useful empty state can be built from three parts:

  1. What is the current condition?
  2. Why is the user seeing it, when the reason is known?
  3. What can the user do next, if anything?

Not every state needs a button. An empty notification list can simply say there are no new notifications. Adding “Explore features” to fill the space may distract from the task.

Distinguish first use from ongoing use

A first-use state introduces an unfamiliar area of the product.

No projects yet
Create a project to organize your tasks and files.
Create project

That copy is appropriate only if the user has permission to create a project and creating one is the intended way to populate the list.

Now consider an existing account with projects hidden by a filter:

No projects match these filters
Change the filters to see other projects.
Clear filters

“Create project” would be misleading here. The user may already have dozens of projects and only needs to change the view.

The design decision depends on the available evidence. If the frontend only receives an empty array, it may not know whether there are no projects at all or none match the active filters. That distinction needs to be represented in the product’s data and API behavior, not invented in the copy.

Design no-result states around the user’s input

A search result is empty because a particular query did not produce a match. Preserve that context.

No results for “invoice template”
Check the spelling or try a broader search.

Keep the original query visible in the search field. If filters are active, show which ones are applied and let the user change them.

For example:

No orders found
There are no results for “Berlin” with the status Cancelled.
Clear status filter

This is more useful than clearing the query automatically or removing every filter without warning.

Only show the parts of the query that the interface can safely display. Search terms can contain personal or sensitive information, so avoid placing them in analytics events or logs without a reason and an appropriate privacy decision.

Suggestions also need to match actual capabilities. “Try a different spelling” is reasonable guidance. “Search by customer name” is useful only if customer names are searchable.

Keep service errors separate from empty data

A failed request should not produce a cheerful empty-state message.

Compare:

No orders yet
Your new orders will appear here.

With:

Orders could not be loaded
Check your connection and try again.
Try again

The second message is appropriate only if checking the connection is a meaningful step. If the application knows the service is unavailable, say that instead. Do not blame the user’s connection when the cause is unknown.

Also decide what happens to data already on screen. If a refresh fails and older results remain visible, label them as potentially outdated rather than replacing them with an empty table. If the product cannot tell when the data was last updated, do not invent a timestamp.

For a full service failure, GOV.UK’s design guidance recommends explaining the problem, giving an appropriate recovery route and telling users what happened to their answers when they were in the middle of a transaction. That is guidance for its own services, but the distinction between a failed service and missing content applies broadly.

Be precise about permissions

An access restriction and an empty collection can look identical if the interface hides unavailable data.

If the product can safely disclose the restriction, say so:

You do not have access to this project
Ask a project administrator to review your access.

Do not offer “Request access” unless that action is actually supported.

There is also a security boundary. Some systems deliberately avoid confirming whether a resource exists to someone who is not authorized to view it. In that case, the wording and response behavior should follow the product’s security design.

The interface should not reveal private project names, customer records or account details just to make an empty state more descriptive.

Use actions that resolve the actual condition

The strongest action is usually the one that changes the condition behind the empty state.

ConditionAction that may helpAction to question
No saved itemsBrowse itemsContact support
No results with active filtersAdjust or clear filtersCreate a new account
Failed data requestRetry the requestAdd a new record
Missing accessFollow the supported access processRetry repeatedly
Completed task queueReturn to relevant work, if neededAdd an unrelated task

A button is not automatically useful because it fills a gap in the layout.

If an action has consequences, describe them. “Clear filters” should remove filters, not also delete the search term or reset the selected workspace unless that behavior is explicit.

For actions that change data, use labels that name the change. “Delete saved search” is clearer than “Reset” when the action permanently removes something.

Make the state available beyond its visual design

A well-written message still needs to be perceivable and usable.

Start with ordinary HTML structure: a meaningful heading where appropriate, readable text and a real button or link for the action. Do not rely on an icon, color or illustration to explain the condition.

Dynamic updates need additional attention. If a search updates results on the same page without moving focus, a brief message such as “No results returned” may qualify as a status message under WCAG. The message needs to be programmatically available to assistive technologies. The result list itself and the brief status message are not necessarily the same thing.

One possible approach is a status region that exists before the update:

<p id="search-status" role="status" aria-atomic="true"></p>

After the search completes, the application can update its text to something like:

No results for “invoice template”.

W3C documents role="status" as a technique for presenting status messages without moving focus. Its implicit live setting is polite, and W3C advises explicitly setting aria-atomic="true" when the entire message needs to be announced consistently. This is one technique, not a complete accessibility solution.

Keep the live announcement concise. Avoid placing a large interactive empty-state component inside the live region, where an update could cause unnecessary or repeated announcements.

Test the flow with a keyboard and the screen readers and browsers your product supports. Check that the message appears at the right time, that users can reach any action, and that changing filters does not create a stream of repetitive announcements.

Treat copy and behavior as one specification

A state cannot be designed reliably if its trigger is missing.

For each important collection, document the condition, message and action together:

TriggerMessageActionImplementation note
Initial request is pendingLoading ordersNoneDo not claim the list is empty yet
Request succeeds with no ordersNo orders yetNone, or an approved setup actionOnly show after a successful response
Filtered request returns no matchesNo orders match these filtersClear filtersPreserve other user input unless specified
Request failsOrders could not be loadedTry againKeep prior data when the product supports it
User lacks permissionAccess message approved for this resourceSupported access routeAvoid disclosing protected information

This is a practical specification, not a universal list of required states. A particular product may need separate states for expired subscriptions, archived records, background processing or partial results.

The important part is that the design names the trigger. If two cases require different messages but the implementation cannot distinguish them, that gap is a product requirement.

Test the transitions, not just the static screen

A polished empty-state mockup can still fail once real data and user actions are involved.

Test at least these transitions:

  1. Open the page while the request is still loading.
  2. Return an empty successful response.
  3. Add or receive one item and confirm the empty state disappears.
  4. Apply a filter that produces no results.
  5. Clear that filter and confirm the results return.
  6. Fail the request and confirm the error is not presented as empty data.
  7. Repeat the flow with restricted permissions.
  8. Check the messages and actions with a keyboard and assistive technology.

Include slow responses and repeated actions. For example, if someone changes a filter twice quickly, an older response should not overwrite the result of the newer selection.

Check the language against what the system actually knows. “No orders exist” is a stronger claim than “No orders match this view.” The first requires evidence about the full collection; the second may only require a successful filtered query.

Give the empty space a job

An empty state is part of the product’s explanation of itself.

It tells people whether they need to create something, change a search, wait for a service or ask for access. Sometimes it simply confirms that their work is complete.

The useful design decision is not how to decorate the space. It is which information the user needs before taking the next step.