Latest / 5 Minute UX / Error Messages and Error Handling: How to Evaluate Effectively
Transcript
- 0:08This lesson is Error Messages and Error Handling: How to
- 0:11Evaluate Effectively. Let's get started.
- 0:19Think about the last time you hit a dead end. You just spent
- 0:22three sprints building a dashboard nobody opens because
- 0:25the onboarding flow broke. That frustration? It’s rarely about
- 0:28the feature. It’s about the error message. An error message
- 0:31is the interface’s last chance to save the interaction. It’s
- 0:34not just a notification. It’s a recovery tool. Most teams treat
- 0:37it as an afterthought. They dump system codes on users. Remember
- 0:40when you submitted a form and saw “Error 404: Not Found”? No
- 0:43context. No help. Just confusion. You felt stuck. You
- 0:46didn’t know if it was you, the network, or the system. That
- 0:49vague, system-centric language fails user needs. It shifts the
- 0:52blame to the user. When teams do this well, trust follows.
- 0:55Users stay engaged. They fix the issue and move on. The reverse
- 0:58pattern shows up as abandoned carts, support tickets, and
- 1:00churn. The goal is simple. Shift from system-centric codes
- 1:03to user-centric guidance. Evaluate every message for
- 1:06clarity, responsibility, and solution orientation. Ask: Is it
- 1:09clear? Does it take responsibility? Does it offer a
- 1:11solution? That’s your Fix on Error Messages!
- 1:19It starts with identifying the three core criteria for high-
- 1:22quality error messages: clarity, responsibility, and solution.
- 1:24These aren't just nice-to-have features. They are the
- 1:27structural pillars that determine whether an error stops
- 1:29a user or helps them move forward. When you evaluate an
- 1:31interface, you’re looking for these specific signals. If
- 1:34they’re missing, the experience breaks down. Clarity means
- 1:36using plain language that anyone can understand. It explicitly
- 1:39rejects technical jargon, internal code numbers, or
- 1:41system-centric terminology. Think about the last time you
- 1:44saw "Error 404" or a database timeout code. That language
- 1:46tells you nothing about what happened in your context. It
- 1:49forces you to become a translator between the machine
- 1:51and your goal. The field notes that vague language creates
- 1:53immediate friction. Users don’t care about the server state;
- 1:56they care about their task. So, if the message requires a
- 1:58dictionary or a developer to decode, it has already failed
- 2:01its primary purpose. Clarity removes that cognitive load
- 2:03instantly. Next, look at responsibility. This criterion
- 2:06demands that the system explains what went wrong without blaming
- 2:08the user. It’s a subtle but critical shift in tone. Instead
- 2:11of saying "You entered an invalid format," a responsible
- 2:13message says "We couldn’t recognize that date format." The
- 2:16difference is ownership. Blaming the user creates defensiveness
- 2:19and frustration. Taking responsibility builds trust,
- 2:21even when things go wrong. Experienced researchers observe
- 2:23that this tone shift de- escalates tension. It signals
- 2:26that the system is a partner, not an adversary. When teams get
- 2:28this right, users feel supported rather than judged. That small
- 2:31linguistic pivot changes the entire emotional weight of the
- 2:33interaction. Finally, every quality error message must
- 2:36provide a solution. It needs to offer a specific, actionable
- 2:38next step to resolve the issue. Telling someone something is
- 2:41wrong is useless if they don’t know how to fix it. A good
- 2:43solution might be "Please check your internet connection and try
- 2:46again," or "Contact support with reference number 123." It gives
- 2:49the user a clear path forward. Without this, the error is a
- 2:51dead end. The user is stuck, guessing, or abandoning the task
- 2:54entirely. Actionable feedback turns a moment of failure into a
- 2:57moment of progress. It respects the user’s time and intent.
- 2:59These three criteria work together. Clarity ensures they
- 3:02understand the problem. Responsibility ensures they
- 3:04don’t feel attacked. Solution ensures they can move on. When
- 3:06you apply this evaluation framework, you’re not just
- 3:09critiquing text. You’re auditing the system’s empathy and
- 3:11utility. This is how you separate functional interfaces
- 3:14from truly helpful ones.
- 3:19Let’s say you’re reviewing a login screen and see the message
- 3:22“Invalid Input.” It’s short, sure. But it’s useless. The user
- 3:25has no idea what went wrong, who caused it, or how to fix it.
- 3:27This is the classic failure of vague, system-centric language.
- 3:30It shifts the burden of interpretation onto the user,
- 3:32which kills trust and slows down task completion. Now, look at
- 3:35the alternative: “Please enter a valid email address with an @
- 3:38symbol.” This message does three things right. First, it
- 3:40identifies the specific field—the email address. Second,
- 3:43it explains the rule clearly—you need the @ symbol. Third, it
- 3:45guides the correction by showing exactly what’s missing. This is
- 3:48solution-oriented design in action. When you apply the
- 3:50evaluation framework, you’re checking for these three core
- 3:53criteria: clarity, responsibility, and solution
- 3:55orientation. Clarity means the message is plain English, not
- 3:58code speak. Responsibility means it doesn’t blame the user
- 4:00unfairly. Solution orientation means it tells them how to move
- 4:03forward. If a message misses any of these, it’s a quality issue.
- 4:06Here’s how this works in practice. You read the error
- 4:08message and ask: Does it tell me what field is broken? Does it
- 4:11explain why? Does it show me how to fix it? If the answer to any
- 4:14of these is no, you flag it. For instance, “Error 404” fails all
- 4:16three. It’s unclear, it’s system-centric, and it offers no
- 4:19path forward. The good example we looked at—“Please enter a
- 4:22valid email address with an @ symbol”—passes every check. It’s
- 4:24clear about the field. It’s responsible in its tone. And
- 4:27it’s solution-oriented by specifying the missing
- 4:29character. This is the standard you should hold against every
- 4:32error message you critique. Experienced researchers note
- 4:34that teams who enforce this triad see fewer support tickets.
- 4:37Why? Because users don’t get stuck. They self-correct. The
- 4:39trade-off is minor upfront effort in writing better copy
- 4:42versus major downstream savings in customer support and user
- 4:44frustration. So, when you’re giving feedback, don’t just say
- 4:47“this is bad.” Say “this lacks solution orientation.” Point out
- 4:50exactly which criterion is missing. Is it clarity? Is it
- 4:52responsibility? Is it the lack of a clear next step? By naming
- 4:55the specific failure mode, you give designers a actionable
- 4:57target for improvement. Remember, your goal is to
- 5:00evaluate error messages for clarity, responsibility, and
- 5:02solution orientation. Every message is a chance to either
- 5:05build trust or break it. Choose the words that guide, not the
- 5:07ones that confuse. That’s how you turn error states into
- 5:10helpful interactions.
- 5:16Consider your last project. Pause and think about the error
- 5:18messages you shipped. Did they actually help the user, or just
- 5:21state a problem? This is where we apply the evaluation
- 5:24framework to critique a sample error message. It’s time to test
- 5:27your skills against the three core criteria: clarity,
- 5:30responsibility, and solution. Look at this common example:
- 5:32"System Failure. Try again later." Run your evaluation
- 5:35checklist. Does it explain the cause? No. Does it offer a
- 5:38solution? No. This is vague, system-centric language that
- 5:41fails user needs. It leaves the user guessing and frustrated.
- 5:43You’ve likely seen this pattern cause support tickets to spike.
- 5:47So, how do you fix it? Add context and a timeline. Change
- 5:49it to: "Our server is down. Check back in ten minutes." Now
- 5:52you’ve taken responsibility. You’ve provided clarity on what
- 5:55happened. And you’ve offered a concrete next step. This shifts
- 5:58the experience from dead-end to helpful. When you evaluate for
- 6:01these three pillars, your feedback becomes actionable.
- 6:04You’ll catch the issues before users do. Practice this critique
- 6:07on your next design review. It builds the habit of solution-
- 6:10oriented thinking.
- 6:16Here’s your Fix on Error Message Evaluation! Stop guessing if
- 6:19your error messages are helpful. Most teams ship system-centric
- 6:22errors that blame the user. You just spent three sprints on a
- 6:25feature where users rage-quit because of a cryptic code.
- 6:28That’s the cost of ignoring clarity. When you evaluate for
- 6:31clarity, responsibility, and solution, the data shifts. Users
- 6:33feel supported, not confused. They stay in the flow. The
- 6:36field notes that vague language creates friction. Clear language
- 6:39builds trust. Audit one current error message in your project.
- 6:42Check it against those three criteria. Rewrite one vague
- 6:45error to be user-centric before your next review. That’s your
- 6:48Fix on Error Message Evaluation!
- 6:52Welcome to The Take. I'm joined by a fellow practitioner and
- 6:55together we're going to dig into Error Messages and Error
- 6:58Handling: How to Evaluate Effectively — what it means in
- 7:00practice and what's worth remembering.
- 7:03[HOST] That shift from blaming the user to taking
- 7:06responsibility is deceptively hard to implement. [LEARNER] It
- 7:09is. Engineers often view error codes as neutral facts, not
- 7:12social signals. [HOST] Exactly. They forget that "Error 404"
- 7:16feels like a judgment to a stressed user. [LEARNER] I’ve
- 7:19seen teams resist changing copy because they think it’s just
- 7:22polishing. [HOST] But clarity isn’t polish. It’s functional
- 7:25design that prevents support tickets. [LEARNER] True. If the
- 7:28message doesn’t offer a solution, the user is just stuck
- 7:31guessing. [HOST] And now we've AI generating these messages
- 7:34dynamically based on context. [LEARNER] That’s a double-edged
- 7:38sword. AI can draft empathetic copy, but it can also
- 7:41hallucinate solutions. [HOST] Right. You still need humans to
- 7:44audit for that specific solution orientation. [LEARNER]
- 7:47Otherwise, the AI might suggest a fix that doesn’t actually
- 7:50exist in the system. [HOST] So the framework remains vital. We
- 7:53evaluate the output, not just the generation. [LEARNER]
- 7:56Agreed. The criteria for quality don’t change just because the
- 8:00writer is a bot. [HOST] Keep that lens tight. Bad errors
- 8:03break trust, regardless of who wrote them.