DEV Community

Swipe Again
Swipe Again

Posted on

Stripe Retries the Charge. It Does Not Chase the Reason.

Stripe's retry machinery is genuinely good at the thing it was built for: presenting a charge again. What it cannot do — what no processor can do from inside the transaction — is chase the reason the charge failed. That gap, between retrying a payment and resolving a failure, is where Stripe-based subscriptions quietly lose customers they believe they have already handled.

Walk through the common failures and the gap shows its shape. An expired card will fail every retry until a human replaces it; the machinery can attempt it eight times and the ninth attempt fails identically. A card replaced after fraud often has its new details sitting in the network's updater service, invisible to a retry schedule that never checks. Insufficient funds resolves on the customer's payday, a date the processor does not know. A generic decline may need the customer to confirm the charge with their bank. In each case the missing step is not another attempt. It is information, timing, or a person — none of which a retry ladder supplies.

This is why involuntary churn on Stripe so often surprises operators who assumed the stack had it covered. The dashboard shows attempts; attempts feel like effort; effort feels like coverage. But coverage is measured in reasons resolved, not attempts made, and the two numbers diverge exactly on the failures worth most. The anatomy is drawn out in stripe dunning, including which failure families Stripe's native tools handle well and which they structurally cannot.

The practical response is additive, not adversarial. Keep the native retries for the failures they genuinely fix — the transient, the mistimed-by-hours, the gateway hiccup. Then build the missing layer beside them: failure detection that classifies by decline code, outreach timed to the reason rather than the calendar, card-update paths that arrive while the subscriber still cares, and timing that respects paydays and quiet hours. Where the layer and the native machinery overlap, coordinate them, so the customer never gets a dunning email in the same hour an automatic retry quietly succeeds.

Measure the layer by its own number: recoveries among failures the native schedule had already finished with. That is the population this work exists for, and its recovery rate — not the blended one — tells you whether the gap is closing. Most Stripe businesses that compute it for the first time find a pool they did not know they were losing, made entirely of subscribers who never chose to leave.

A concrete sequence shows the layer at work. Day zero: the renewal fails with an expired-card code, and instead of queueing a blind retry, the system sends a short note naming the problem and linking to a hosted update page the subscriber can finish from the email, on a phone, without a password hunt. Day two: no action yet, so a second note arrives with a different subject and one new fact — the date access actually pauses. Day five: the subscriber updates the card, and the charge is attempted immediately against the new details rather than waiting for the original schedule to come back around, because a fresh card is the strongest recovery signal there is and it decays by the day. Total processor retries wasted on a dead card: zero. Total messages: two. That is the shape of resolving a reason instead of repeating an attempt.

Multiply that shape across the failure families and the layer's design rule emerges: every decline code gets its own small playbook, written in advance, measured separately. The expired-card playbook will post the best recovery rate; the insufficient-funds playbook will be won or lost on timing; the generic-decline playbook will teach you the most about your subscriber base. Run them as separate programs sharing one queue, and the blended churn number finally decomposes into problems you can actually assign, price, and fix.


Published by Swipe Again — failed payment recovery at a flat $179/mo.

Top comments (0)