Short summary

Every correction has a cost to the user: time, effort, re-entered information, uncertainty about whether the fix worked. When that cost exceeds the cost of the original error, users stop correcting and start abandoning. The point is reached more often than teams realise, because correction cost accumulates from small design decisions that each look reasonable in isolation. A correction flow that requires a phone call, a re-entry of previously supplied information, or a wait with no visibility has already crossed the line for most users.

The calculation users are making

When a user hits an error, they run an instinctual mental calculation, usually without noticing they are doing it. What will it cost me to fix this, against what I get for fixing it, against what it costs me to walk away.

Most of the time the calculation favours the option of correcting. The error is small, the fix is obvious, and the goal is worth it. But the calculation is sensitive to specific things, and design decisions affect all of them. How much of what I already did will I have to do again? How long will this take? Will I know when it has worked? Do I have to leave this service and do something else, like phone someone, to resolve it?

Once the answer to any of those becomes unfavourable enough, the result of the calculation flips. The user stops correcting and starts abandoning, or in a service they cannot abandon, they contact support instead. Both outcomes are more expensive to the organisation than the error was.

Where correction cost accumulates

Correction cost is rarely created by one bad decision. It accumulates from several small ones, each of them defensible on its own.

  • Re-entry of information already supplied: A correction that clears fields the user already completed multiplies the effort of the fix well beyond the error itself.
  • Loss of position in the journey: Being returned to the start, or to an ambiguous point, adds navigation work on top of correction work.
  • Handoff to another channel: An error that can only be resolved by phone converts a two-minute fix into a task that has to be scheduled around opening hours.
  • No visibility of resolution: If the user cannot tell whether the correction worked, they either repeat it or contact support to check. Both result in additional cost.
  • Unstated duration: A correction that involves waiting, with no indication of how long, is impossible to plan around, so users treat it as indefinite.

Each of these is a design decision. None of them are usually made deliberately as a decision about correction cost, because correction cost is not something most teams measure or discuss.

The error that costs less than the fix

The clearest signal that a correction flow has become too costly is when users start working around the flow rather than using it.

Users who abandon a partially completed application and start a new one, rather than correcting the existing one, are telling you that starting over is cheaper than fixing the one they started. Users who contact support to change a single field are telling you the self-service correction path costs more than a phone call. Users who submit a form they know is wrong, intending to fix it later, are telling you that the correction available before submission costs more than the consequences of submitting incorrectly.

Each of these behaviours is visible in service data if anyone looks for it, and each is usually recorded as something else. Duplicate applications look like a data quality problem. Support contacts about single-field changes look like a support volume problem. Both are correction design problems appearing somewhere the design team is not looking.

Designing corrections that stay cheap

Keeping correction cost below error cost is mostly a matter of a few structural commitments, applied consistently:

  • Preserve what the user already gave you. A correction should require changing the thing that is wrong and nothing else. Any field the user has to re-enter is cost added for no benefit to them.
  • Keep the correction in the same place as the error. Sending a user elsewhere, whether to another part of the service or to a different channel entirely, adds cost that is often larger than the correction itself.
  • Confirm the correction explicitly. A user who cannot tell whether the fix worked will either repeat it or seek confirmation elsewhere. A clear statement that the change has been applied closes the loop.
  • State the duration of anything that takes time. If a correction requires a wait, say how long. An unstated wait is treated as indefinite, and indefinite waits produce abandonment.

Test the correction path with the same rigour as the forward path. A correction flow that has never been observed with a real user is a guess about a moment when users are least tolerant of your guesswork.

Instead of asking whether users can correct their mistakes, ask what correcting this specific mistake costs them, and whether that cost is lower than the cost of giving up.

Frequently asked questions

Why do users abandon a service after making a mistake?

Users abandon after a mistake when correcting it costs more than walking away. The calculation is sensitive to how much previously entered information has to be re-supplied, how long the fix will take, whether the user will know it worked, and whether resolving it requires leaving the service to phone someone. Once any of these becomes unfavourable enough, abandoning or contacting support becomes the cheaper option.

What makes a correction flow expensive for users?

Correction cost accumulates from several small design decisions: clearing fields the user already completed, returning them to an ambiguous position in the journey, requiring a handoff to another channel such as a phone call, giving no confirmation that the correction worked, and involving waits of unstated duration. Each is defensible in isolation and together they can make correcting more expensive than the original error.

How can you tell if your correction flows are too costly?

Look for users working around the correction path rather than using it. Duplicate applications suggest starting over is cheaper than fixing. Support contacts about single-field changes suggest self-service correction costs more than a phone call. Users submitting forms they know are wrong suggest pre-submission correction costs more than the consequences of submitting incorrectly. These signals usually sit in data that is categorised as something else.

How do you design a correction flow that users will actually use?

Preserve everything the user already supplied so only the incorrect item needs changing, keep the correction in the same place as the error rather than sending users elsewhere, confirm explicitly that the change has been applied, state the duration of any wait the correction involves (if any), and test the correction path with the same rigour applied to the forward journey.