When Users Give Up

There is a story designers tell themselves about users who abandon a product. The story goes like this: those users weren’t really that motivated. They hit one small obstacle and gave up. If they’d actually cared about the outcome, they would have pushed through. The product just weeded out the people who weren’t serious.

This story is comfortable. It puts the failure on the user’s character rather than the design’s construction. And it is wrong in a way that matters enormously, because it means designers keep building the same broken experiences and blaming the people who couldn’t get through them.

On October 1, 2013, millions of Americans tried to use HealthCare.gov to sign up for health insurance. These were not casual visitors with mild curiosity. Many of them needed coverage. Some hadn’t had insurance in years. The motivation was real. Four million people visited the site on day one. By evening, six people had successfully enrolled. The rest hit errors, timeouts, broken account creation flows, and messages that explained nothing. And then they stopped trying.

The question is why. Not why the site failed technically. That story is well documented and political and complicated. The question is why people with genuine need, facing a problem they could have solved by calling a phone number or visiting an office, simply gave up entirely. The answer is not about motivation. It is about what repeated, uncontrollable failure does to the human brain.

What the dogs already knew

In 1967, Martin Seligman and Steven Maier were running experiments at the University of Pennsylvania that were supposed to study fear conditioning in dogs. They put dogs in harnesses and administered mild electric shocks. Later, they moved the dogs to a box where jumping a low partition would end the shocks. Most dogs figured this out quickly. But the dogs that had been given inescapable shocks in the harness, shocks they had no way to stop, mostly just lay down and waited for the pain to stop. They could have escaped. They didn’t try.

Seligman and Maier called this learned helplessness. The dogs had learned, through repeated exposure to outcomes they couldn’t control, that nothing they did made any difference. That learning transferred to the new situation, even though the new situation was completely different and escape was genuinely possible. The expectation of failure was now the dog’s operating assumption.

Almost fifty years later, Maier and Seligman returned to the research with better tools and found something that reframes the whole phenomenon. Their 2016 paper in Psychological Review concluded that the passivity they had observed was not actually learned at all. “Passivity in response to shock is not learned. It is the default, unlearned response to prolonged aversive events.” The brain defaults to giving up. What has to be learned, actively, through successful action, is the belief that effort works. The organism learns control, or it doesn’t. Without that learning, passivity is where it stays.

This reframing changes what designers should be afraid of. Every time a user hits an error they can’t understand, a flow that dies with no recovery path, a form that rejects their input without explaining why, they are getting a dose of uncontrollable failure. One dose probably doesn’t do much. But the effects accumulate, and they transfer. Hiroto and Seligman showed in 1975 that learned helplessness in humans generalizes across situations. People who had been exposed to inescapable noise later failed to solve cognitive problems they would otherwise have solved easily. The helplessness didn’t stay attached to the original source. It spread. For a product, this means a broken onboarding doesn’t just cost you that session. It trains users to expect failure in every session that follows.

Six enrollments

The HealthCare.gov numbers are staggering when you sit with them. Four million people on day one, six completions. Not six percent. Six people. The rest encountered a site that returned errors throughout the account creation process, timed out under load, and offered messages so vague that users had no way to know whether the problem was on their end or the government’s. The site was taken offline by the first weekend for emergency repairs.

By some estimates, only one percent of visitors during the first week managed to enroll. Consumer Reports, not a political publication but a consumer protection one, advised Americans to stay away from the site for at least a month. The HHS Office of Inspector General’s report later confirmed what the numbers already showed: large numbers of people abandoned the process entirely, including people who were legally entitled to subsidized coverage and genuinely needed it.

The errors themselves were not the whole problem. Errors happen. What turned those errors into abandonment was the absence of recovery. A message that says something went wrong, with no explanation of what, no indication of whether to wait or try again or call a number, with no path forward at all, that message is not neutral. It is a dose of uncontrollable failure. The user tried. The outcome was bad. Their response made no difference to the outcome. Each iteration of this pattern pushed them further toward the default state: stop trying.

The technical team eventually fixed the site. But the people who had learned, across multiple failed sessions in October 2013, that HealthCare.gov was a system where their effort didn’t matter, many of them did not come back. Their helplessness had already been learned.

The First Failure Test

Most designers spend their time thinking about what happens when things work. They design the happy path with care and leave the error states as an afterthought, a few generic messages slotted in late in the process. This is exactly backwards. The error states are where helplessness is built or prevented. The happy path is where users go when your product is working. The error states are where they go when it isn’t, which is precisely when their decision about whether to keep trying gets made.

Before releasing any user-facing flow, run the First Failure Test. Go through the flow and deliberately trigger every error state you can find. For each one, ask a single question: does the user have a specific action they can take right now? Not a vague acknowledgment of what went wrong. Not an apology. A specific, concrete, immediately available next step.

“Something went wrong” is not an action. “Try again later” is not an action. “Contact support” without a direct link or number is not an action. These messages put the user in exactly the position that produces helplessness: outcome that is bad, response that changes nothing.

What reverses the mechanism isn’t the absence of failure. It is the presence of control. Seligman’s research showed that even in situations where negative outcomes couldn’t be prevented entirely, people who retained a sense of agency over their responses didn’t develop helplessness in the same way. The error message that says “Your session timed out. Click here to pick up where you left off” is not just better copy. It is a return of control to the user at exactly the moment they need it. Run this test before you ship. Run it on every state your product can reach. The question is always the same: does the user have somewhere to go from here? If they don’t, you are building a machine that teaches people to quit.

Abandonment is not a user problem. It is a design output. The user didn’t quit. You taught them to.

⸻