interaction design
Error tolerance
What is error tolerance in UX?
Error tolerance is designing so that when people make mistakes - and they will - the consequences are small and recoverable rather than catastrophic. Autosave, undo, drafts, confirmations on the genuinely destructive, and forgiving inputs all assume human error is normal and build the system to absorb it gracefully instead of punishing it.
Also known as: error tolerance, forgiving design, fault tolerance
Prefer to watch?
Watch the recap 1:02
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 good the design, so a forgiving system assumes that and makes mistakes cheap to undo. The toolkit: autosave and drafts (so a slip or crash doesn't lose work), undo and a generous "are you sure?" only where it counts, non-destructive defaults (move to trash, not permanent delete), and forgiving inputs that accept variations rather than rejecting them. Error tolerance pairs 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.