UX Note day 18 - 1001 errors in software that may hit your user everyday
Not all the error being reported by user. Most of them being ignored.
You designed something cool but suddenly, an error occurred and prevent the user from a task success. Does that matter?
ISO/IEC/IEEE 24765:2017 (Systems and software engineering vocabulary) defines an error as:
"A human action that produces an incorrect result, such as software containing a fault."
In these standardized definitions, there's often a distinction between:
Error: The human mistake or action that leads to a problem
Fault (or defect/bug): The manifestation of an error in the software
Failure: The observable incorrect behavior of the software when a fault is executed
Why do designers need to know this?
Why not?
If you remember this fire accident, you should know it was based on a complicated code that made humans slow in reaction. I hate oversimplified design by the West at this point. BUT look at this image of the Vietcombank app, you can be surprised by how the minimalist mind applied
No one knows what is this but it blocked my experience. No place to report this issue. In general, Error is a great test for how a considerate product development team handles wanted and unwanted flaws. Those replicate the unpredicted life we are living. So if you want to design the delight, you must be aware of your dark spots.
Error handling - from understanding the standard, the language with dev, the operation protocol to give the right message for user.
As designers, ensuring that software handles errors effectively is crucial—not just to pass compliance checks, but also to deliver an intuitive user experience.
Let’s briefly look at necessary international standards to guide error handling:
HTTP Status Codes (RFC 7231, RFC 6585): Help applications communicate clearly and consistently with users and other services.
ISO/IEC 25010: Provides guidelines for reliability, usability, and clarity in error handling, emphasizing fault tolerance and ease of recovery.
OWASP Guidelines: Promote secure handling of user input, error logging, and protecting sensitive user information.
Logging Standards (Syslog, Common Log Format): Offer clear, standardized log formats to simplify error analysis and debugging.
Exception Handling Best Practices: Encourage safe, language-specific methods to manage exceptions, ensuring sensitive information remains protected.
Accessibility Standards (WCAG): Guide designers in crafting error messages that are clear, readable, and accessible to all users, especially those with disabilities.
While these standards are essential foundations, what's more impactful is how your team manages error handling through clear and user-centric protocols.
Team-Focused Error Handling Protocols
For designers, "protocol" means creating clear rules on how errors are identified, communicated, and resolved, prioritizing user understanding and recovery. Designer should understand the common ground that the whole organization to give the right message. Otherwise, well, the case in France is one of the worst example I can find: Error message was too cryptic that the security team took too long to handle the issue right. Think how much millions can be saved if the message was clear?
Then what might happen when an error appear?
And when the error response from user reach the team, here is how everyone collaborate together:
So can designers like us do something to minimize the damage from the error? I think we can do a lot but not cover all error at the time we launch the product:
Being a close friend of the QA team is a super advantage.
Understand some common errors, aligning with components of a software ( listed down there, you can download it ).
For example, HTTP Status Codes: Common codes to communicate issues:
400 Bad Request: The input provided by the user isn't valid.
401 Unauthorized: The user needs to authenticate or re-login.
404 Not Found: The requested resource is unavailable.
500 Internal Server Error: Unexpected issue on the server.
503 Service Unavailable: Temporary downtime or overload.
Make an agreement with product team and other teams principles to handle the error. OR it can be as simple as a guide Custom System-Specific Codes: Should include clear, descriptive messaging to aid users in troubleshooting without overwhelming them with technical jargon.
Keep updating the error.
Conclusion: Designing for Errors as Part of the Experience
Effective error handling is not just a technical requirement but a crucial component of thoughtful design. When users encounter errors, the quality of your error handling directly impacts their overall experience and perception of your product.
Key Design Principles for Error Handling
1. Contextual Error Messages
Display errors in direct relation to the user's actions
Help users understand both what went wrong and why it matters
Maintain the user's context to reduce cognitive load
2. Visual Error Indicators
Use consistent visual language (color, icons, positioning) to signal errors
Ensure accessibility by not relying solely on color (following WCAG guidelines)
Scale visual prominence based on error severity
3. Clear, Actionable Guidance
Provide specific next steps rather than simply stating something went wrong
Use appropriate error message hierarchy:
Critical system errors: Full-screen or top banner notifications that prevent further interaction
Action-specific errors: Contextual messages near the point of failure
Performance issues: Unobtrusive toast messages that don't interrupt workflow
4. Preparing for the Unknown
Collaborate with QA, development, and business teams to identify potential error scenarios
Implement robust error reporting mechanisms to capture unforeseen issues
Create fallback error states that gracefully handle unexpected failures
Cross-Functional Collaboration
Error handling represents a critical intersection where design, development, and business concerns meet. Designers should:
Partner closely with QA teams to understand common failure patterns
Develop shared error handling protocols with development teams
Establish clear ownership of error message content and presentation
Create documentation for consistent error handling across the product
The Lasting Impact
Remember that while errors themselves may be temporary, their impact on user trust is lasting. Great error handling doesn't just minimize frustration—it demonstrates respect for your users and their goals. By transforming moments of potential frustration into opportunities for clarity and assistance, you transform errors from obstacles into stepping stones in the user journey.