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:
- The backend engineer writes the first version as an exception message, intended for logs.
- The frontend engineer surfaces that string because the API returned it and the ticket said "show error."
- 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 user | Reframed |
|---|---|
| You entered an invalid email | This doesn't look like a valid email address |
| You must accept the terms | Please accept the terms to continue |
| Invalid password | That password doesn't match our records |
| You are not authorized | This account doesn't have access to that page |
| Request failed | We 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:
- Situation — what state the system is in
- Reason — what caused it (if known and useful)
- 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, andaria-describedbyfor 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:
- Export every error string in your app to a spreadsheet. Grep is fine.
- Sort by frequency using your analytics or logs. The top 20 account for most of the pain.
- Rewrite those 20 using Situation / Reason / Action, and run them past one person who isn't on the engineering team.
- Add
role="alert"andaria-describedbywhere they're missing. - 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.
Want a team like ours?
72Technologies builds production software for the kind of teams who actually read this blog.
Start a projectKeep reading
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.
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.
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.
