interaction design
Error tolerance
What is error tolerance in UX?
Error tolerance means designing systems so that when users make mistakes - and they will - the fallout is minimal and reversible, not disastrous. Features like autosave, undo, drafts, confirmation prompts for destructive actions, and flexible inputs all acknowledge that human error is inevitable and build the system to handle it gently rather than harshly.
Also known as: error tolerance, forgiving design, fault tolerance
Prefer to watch?
Watch the recap 0:29
The demo
You've written something you care about. Now imagine fat-fingering the “Clear” button. First in an unforgiving design, then a tolerant one. Same slip - see how differently it ends.
What this demo shows (text version)
You have a note you care about, and you accidentally hit the "Clear" button. In the unforgiving design the note is wiped instantly and permanently, with no way back - one slip destroys your work. In the tolerant design the same Clear has already autosaved a draft and shows an "Undo" toast, so the identical mistake costs you nothing: one tap and your note is back.
That's error tolerance: since people will make mistakes, you design so the consequences are small and recoverable - autosave, undo, soft deletes, forgiving inputs - rather than catastrophic. It pairs with error prevention and clear recovery, and it makes people bolder and calmer. Mature UX isn't error-proof; it's error-forgiving.
People will make errors no matter how well the design, so a forgiving system accepts that and makes mistakes easy to undo. The toolkit: autosave and drafts (so a slip or crash doesn’t lose work), undo and generous confirmation only where it matters, non-destructive defaults (move to trash, not permanent delete), and forgiving inputs that accept variations rather than rejecting them. Error tolerance works with error prevention (stop avoidable mistakes) and clear recovery (help people fix what slips through). The mark of mature UX isn’t an interface that’s impossible to get wrong - it’s one where getting it wrong costs almost nothing.
In the unforgiving version one slip wiped your work for good; in the tolerant one the same slip was a shrug - undo, or it was autosaved anyway. Same human error, wildly different cost. That's error tolerance: you can't stop people making mistakes, but you can design so mistakes barely matter. Recoverable beats irreversible almost every time.
Error tolerance accepts that human error is inevitable and shifts the goal from "prevent all mistakes" to "make mistakes survivable". Key techniques: undo/redo, autosave and version history, soft deletes (trash with restore) instead of permanent ones, confirmations reserved for truly destructive or irreversible actions, drafts that persist across sessions and crashes, and forgiving input parsing (accepting different formats rather than rejecting). It complements error prevention (forcing functions, constraints) and error recovery (clear, actionable error messages).
It also reduces the anxiety that makes people hesitant and slow. When users know they can undo, they explore and act with confidence; when every action feels final, they freeze or avoid features entirely. Forgiving systems thus improve both safety and usability, and they soften the spotlight effect - people fear looking foolish, and a system that quietly absorbs slips lowers the stakes.
Build tolerance in by default: prefer reversible actions, make undo the primary safety net (it's less interruptive than a confirmation), keep destructive operations recoverable, autosave relentlessly, and validate kindly. Reserve hard confirmations and forcing functions for the rare actions that are both consequential and irreversible. Measured by outcomes, a tolerant design loses far less user work and trust to the everyday slips that no amount of prevention fully eliminates.
Error tolerance means designing systems so users can make mistakes without serious consequences - try the demo to see how it works. It’s not about preventing errors, but making them recoverable - that’s why the demo lets you simulate and reverse actions easily.