Or: The Emotional Damage of a Bad Error Message
I was standing at the airport, trying to check in on my phone.
The form was long, the screen was small, and I was already stressed.
I tapped through field after field – name, passport number, confirmation code – and then I hit the button.
Nothing happened.
I scrolled. No error message. Tried again. Still nothing.
Eventually, I found the issue.
A tiny field, halfway up the page, marked in red.
No hint. No message. No explanation.
Just: You did it wrong.
I wasn’t the failure here. The form was.
The emotional weight of a bad form
Forms are everywhere.
We use them to book flights, buy groceries, apply for jobs, and access services.
They’re often the gatekeepers between us and the thing we need.
And yet, they’re some of the most frustrating parts of the web – especially when they go wrong.
For people with cognitive impairments, poor eyesight, screen reader users, and anyone on a mobile device or under stress, a poorly designed form can be the thing that breaks them.
A vague error message doesn’t just cost time. It can cost trust.
What’s wrong? Seriously – what went wrong?
The number one rule of form errors: Tell people what happened.
Vague messages like “There was a problem with your submission” are useless.
So are little red borders with no text.
Or messages hidden at the top of the page, out of sight and out of context.
If someone makes a mistake, they need:
- A clear message that says what’s wrong
- An explanation of how to fix it
- Focus returned to the problem field
- Visible and audible cues (like screen reader announcements)
People shouldn’t have to guess.
They shouldn’t have to scroll.
The problem isn’t the person. It’s the form.
Let people fix the problem
Error recovery is not optional – it’s essential. That means making it easy for users to fix whatever went wrong.
Here’s what that looks like in practice:
- Inline error messages right next to the field
- Clear labels like “Please enter a valid phone number, including the area code”
- ARIA roles (like aria-describedby) to announce error messages to screen readers
- Focus that returns to the first invalid field when the form is submitted
- And if the user tries again? Let them know the error’s been resolved.
Good forms don’t just yell “WRONG!”
They offer a gentle, helpful nudge: “Here’s what I need. Let’s try again.”
Timing matters
Some forms validate fields immediately, while you’re still typing. Others wait until you hit Submit and then throw everything at you at once.
Both approaches can be painful if they’re not done well.
- Too early and users feel nagged: “I’m not done yet!”
- Too late and users feel ambushed: “Why didn’t you say so before I submitted?”
The best forms strike a balance:
- Validate on blur (when the user leaves the field)
- Wait to show errors until you’re reasonably sure they’re done
- Or give the user control, like a “Check this field” button, or clear live validation cues
It’s about rhythm. Timing. Respect. Just like any good conversation.
The redundant rage of repeated entry
There’s a special kind of frustration that comes from typing your entire address into a form…
…and then being asked to do it all over again.
Line by line. For your billing address.
Which is exactly the same.
If you’ve ever shouted, “IT’S THE SAME AS ABOVE” at your screen, you know the pain.
A simple checkbox – “Same as shipping” – can save time, effort, and sanity.
It’s not just a convenience.
It’s accessibility.
Repeated tasks are hard for people with motor impairments, fatigue, or executive dysfunction. Reducing friction helps everyone.
Error prevention: Better than error recovery
Want to know the best error message?
The one that never appears.
You can prevent many common mistakes just by setting things up well:
- Use the correct input type (email, tel, url) so the mobile keyboard matches
- Provide formatting hints (e.g. “MM/DD/YYYY”) next to the field
- Use autocomplete attributes to speed things up
- Break complex tasks into manageable steps (multi-step forms > giant walls of fields)
Help people succeed, and they won’t need to recover.
Accessible authentication shouldn’t be a nightmare
Let’s talk logins.
It should be simple. Familiar. Low-stress.
But instead we get:
- CAPTCHA puzzles with unreadable letters
- Emoji-based verification tools (seriously?)
- Password reset loops with inaccessible instructions
- “Verify by phone” options that don’t support screen readers
Good authentication is secure and accessible.
One of my favorite methods?
Magic links – email-based one-time login links.
No remembering passwords.
No jumping through hoops.
Just: “Click here and you’re in.”
That’s the kind of frictionless experience we should all be aiming for.
Don’t punish people for needing help
Forms are deeply personal.
They collect information about who we are, what we want, where we live.
They make people vulnerable.
And when a form is hostile, confusing, or unforgiving?
It can make people feel like the failure is theirs.
But it’s not.
If a form confuses someone, it’s the form’s fault.
If someone gives up, it’s the form’s design.
Remember, you’re not just collecting data. You’re interacting with a human being.
Quick checklist: Are your forms working with your users?
- Do your error messages say what went wrong and how to fix it?
- Are they placed where users can see them – visually and with a screen reader?
- Can people fix issues without starting over?
- Do you prevent mistakes where possible (input types, autocomplete, format hints)?
- Have you tested your forms with a keyboard, a screen reader, a phone, and a phone’s screen reader?
Kindness looks like labels. And hints. And second chances.
Forms aren’t neutral.
They can feel like gates or walls.
A handshake – or a slap on the wrist.
They’re moments of interaction.
Of vulnerability. Of trust.
So treat them like conversations.
Make them kind. Clear. Forgiving.
Because forms are people, too.