All articles
Design & UXNovember 18, 2026 6 min read

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.

Open any shipping SaaS product and you'll find error messages that read like court transcripts. "Invalid input." "Something went wrong." "Error 500." The user did nothing wrong, the system failed to communicate, and somehow the copy still manages to sound like it's the user's fault.

Error messages are the one piece of UI you only see when things are already bad. They deserve more than a stringified exception.

Why Error Copy Is Usually Terrible

Error messages tend to be written three times, by three different people, none of whom talk to each other:

  1. The backend engineer writes the first version as an exception message, intended for logs.
  2. The frontend engineer surfaces that string because the API returned it and the ticket said "show error."
  3. The designer never sees it, because error states weren't in the Figma file.

The result is copy that leaks implementation details ("ValidationError: field 'email' failed regex /^[^@]+@..."), assigns blame without context ("You entered an invalid value"), or tells the user absolutely nothing ("An error occurred").

In our experience auditing products before a redesign, roughly a third of all error strings in a codebase were either untranslated technical exceptions or variations of "something went wrong." That's not an edge case. That's the primary error experience.

The Three Questions Every Error Must Answer

Before you touch tone or microcopy, make sure every error message answers three things in order:

  • What happened? Not the stack trace — the human consequence.
  • Why did it happen? Whose action or inaction caused it.
  • What can the user do next? A concrete action, ideally one click away.

A message that answers all three is already better than 90% of what's shipping. Compare:

❌ "Payment failed."

✅ "Your card was declined by the bank. Try a different card, or contact your bank to authorize the charge."

The second version is longer. It's also usable.

The Blame Audit

Read every error string in your product out loud, and ask: who sounds at fault? Count the "you"s. If the user caused it and can fix it, "you" is fine. If the server exploded, "you" is gaslighting.

Here's a quick reframing table we use in audits:

Blames userReframed
You entered an invalid emailThis doesn't look like a valid email address
You must accept the termsPlease accept the terms to continue
Invalid passwordThat password doesn't match our records
You are not authorizedThis account doesn't have access to that page
Request failedWe couldn't reach the server. Retrying…

Notice the pattern: when the system or situation is the subject, the sentence stops accusing.

Four Severity Tiers, Four Different Treatments

Not every error deserves the same real estate. A missing character in a form field and a dropped database connection are not the same event, and shouldn't share a component.

We use four tiers:

1. Field-level validation

Inline, under the field, triggered on blur or submit (never on every keystroke — see our earlier piece on validation timing). Short, specific, no icon needed if the field itself is styled as invalid.

<div className="flex flex-col gap-1">
  <label htmlFor="email" className="text-sm font-medium">
    Work email
  </label>
  <input
    id="email"
    aria-invalid={!!error}
    aria-describedby={error ? 'email-error' : undefined}
    className={`rounded-md border px-3 py-2 ${
      error ? 'border-red-500' : 'border-neutral-300'
    }`}
  />
  {error && (
    <p id="email-error" className="text-sm text-red-600">
      {error}
    </p>
  )}
</div>

The aria-describedby association is the part most teams skip. Screen readers need the error programmatically tied to the input, not just visually adjacent.

2. Form-level errors

When submission fails for reasons the user can't see field-by-field (duplicate account, rate limiting, server rejection), surface a single summary at the top of the form. Include a direct action — resend, retry, contact support.

3. Page-level errors

The data you needed didn't load. The page can't render its core function. This is a full state swap, not a banner. Show what the user was trying to do, what blocked it, and a retry button. Never dump them to a blank screen with a tooltip.

4. Global failures

Auth expired. Network dropped. Server is down. These are app-wide and should use a persistent affordance — a top banner, a modal, or an offline indicator. Critically: don't block the UI if the user can still do useful offline work.

The Copy Framework: Situation, Reason, Action

Structure every non-trivial error message in three beats:

  1. Situation — what state the system is in
  2. Reason — what caused it (if known and useful)
  3. Action — what the user can do right now

Example for an expired upload:

Situation: Your upload didn't finish. Reason: The connection dropped after 2 minutes. Action: [Resume upload] or [Start over]

You don't need to label the beats. You just need to hit them.

When to Skip the Reason

If the reason is technical noise the user can't act on ("ECONNREFUSED on port 5432"), omit it. If the reason is useful ("your session expired after 30 minutes of inactivity"), include it, because it tells the user how to prevent recurrence.

A good test: would a non-technical friend reading this message understand why they should care? If not, cut the reason and keep the action.

Tone: Calm, Specific, Not Cute

Error states are the worst place to deploy brand personality. A whimsical 404 is fine. A whimsical "oops! something went wonky 🙈" on a failed payment is a support ticket.

A few rules we enforce in design system docs:

  • No exclamation points. You're not excited. Neither is the user.
  • No apologies longer than two words. "Sorry —" is enough. "We're so, so sorry about this!" is suspicious.
  • No blame-shifting to vague systems. "The system wouldn't let us" is worse than "We couldn't."
  • No emoji in destructive or financial contexts. Ever.
  • Match the severity. A failed save is annoying. A failed payment is stressful. Copy should reflect that gap.

Accessibility Isn't Optional Here

Error messages are where accessibility bugs go to hide, because sighted QA sees red text and ticks the box. A few non-negotiables:

  • Errors must be announced to assistive tech. Use role="alert" or a live region for dynamic errors, and aria-describedby for field-level ones.
  • Color is not enough. Red text on white hits contrast easily; red icon on gray background often doesn't. Target WCAG AA minimum (4.5:1 for body text).
  • Don't rely on border color alone to indicate an invalid field. Pair it with an icon or inline message.
  • Focus should move to the first invalid field on submit, or to the error summary. Users shouldn't have to scroll to find what broke.
<div role="alert" aria-live="polite" className="...">
  <p className="font-medium">We couldn't save your changes.</p>
  <p className="text-sm">Check your connection and try again.</p>
  <button onClick={retry}>Retry</button>
</div>

aria-live="polite" waits for a pause before announcing, which is right for most non-urgent errors. Reserve "assertive" for things that genuinely interrupt — security prompts, data loss warnings.

Instrument Your Errors

The last piece most teams miss: you can't improve error UX you can't measure. Every error state should log:

  • The error code or category
  • The route or component where it appeared
  • Whether the user acted on it (clicked retry, closed, navigated away)

If 40% of users hit "something went wrong" and immediately close the tab, you don't have an error message — you have a churn funnel. Instrumenting errors lets you prioritize which ones to rewrite first, instead of auditing all 300 of them at once.

Where We'd Start

If you're staring at a codebase full of "Invalid input" strings, don't try to fix everything. Do this instead:

  1. Export every error string in your app to a spreadsheet. Grep is fine.
  2. Sort by frequency using your analytics or logs. The top 20 account for most of the pain.
  3. Rewrite those 20 using Situation / Reason / Action, and run them past one person who isn't on the engineering team.
  4. Add role="alert" and aria-describedby where they're missing.
  5. Ship, measure retry rates, repeat.

Error messages are a design surface, not a technical afterthought. Treat them that way and your support inbox will notice before your users do. If you want help auditing yours, that's the kind of work our design and UX team does on most product engagements.

#UX Writing#Design Systems#Accessibility#Forms

Want a team like ours?

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

Start a project