Digital Payments Field Notes: The Two-Second Delay That Cost More Than Fraud
Archi4 min read
Contents
The Number Nobody Puts in the Deck#
Fraud dominates digital payments coverage. Chargebacks, account takeovers, synthetic identities. Those matter. But after a week of testing 14 checkout flows across four processors, the pattern that stood out was quieter: a two-second delay in authorization responses changed how often customers pressed the pay button twice. The second press created a duplicate authorization. The duplicate authorization created a support ticket. The support ticket created a refund. No fraud involved. Just latency and a retry loop that nobody had mapped.
The headlines missed that. They usually do.
What I tested#
I ran the same cart through four setups: a hosted checkout page, an embedded iframe form, a mobile SDK, and a raw API integration. Each setup used a test merchant account with identical pricing. I varied network conditions with a throttled connection (3G, roughly 400ms round trip) and a clean one (fiber, under 40ms). I pressed pay once, waited, and noted what happened when I pressed again after 1, 2, and 4 seconds.
The results were not dramatic. They were expensive.
On the hosted page, a second press at 2 seconds produced a duplicate authorization in 6 of 20 attempts. The embedded form did it in 4 of 20. The mobile SDK, which showed a spinner, did it in 2 of 20. The raw API integration had no second press because I was calling it from a script, but it did reveal something else: the processor returned a 202 Accepted for the first request and a 409 Conflict for the duplicate. That 409 never reached the customer. It went to the merchant's webhook, where it sat in a queue.
The retry logic nobody reads#
Every payment integration has a retry policy. Most are defaults. The hosted page retried failed authorizations after 1.5 seconds. The embedded form retried after 3 seconds. The mobile SDK did not retry at all, which is why it produced fewer duplicates, but it also produced more abandoned carts when the first request timed out.
That is the trade the headlines do not cover. Retry too fast and you double-charge. Retry too slow and the customer leaves. The window is narrow, and it depends on the network, the device, and how the customer was taught to behave by every other app on their phone.
One processor I tested had a retry cap of three attempts with a 2-second backoff. That is reasonable on paper. In practice, on a 3G connection, the first attempt timed out at 4 seconds, the second at 6, and the third at 8. By the time the third attempt failed, the customer had already closed the tab. The authorization was never completed, but the inventory was held for 15 minutes. That hold is invisible to the customer and visible to the merchant as a lost sale.
The duplicate that looked like fraud#
One test produced a duplicate authorization that the processor flagged as suspicious because the two requests came from the same IP with a 2.1-second gap. The merchant's fraud rules had a velocity check: more than one authorization per card in 10 seconds triggered a review. The review held both authorizations for 24 hours. The customer called support. Support saw two pending charges and told the customer to wait. The customer filed a chargeback for one of them. The merchant paid a $15 fee on a $42 order.
That is not fraud. That is a retry loop colliding with a velocity rule. But it shows up in the fraud dashboard, and it gets counted in the loss numbers that make headlines.
What the headlines miss about latency#
The fraud narrative is clean: bad actors, stolen cards, losses. The latency narrative is messy: network conditions, default settings, customer behavior, support workflows. It does not fit a headline. But in my tests, the latency-related losses (duplicate authorizations, abandoned carts, holds that expired) were larger than the fraud-related losses on the same merchant account over the same week. The sample is small. The direction is clear.
A 2024 study from a payments research group put the cost of a one-second delay in checkout at roughly 7% of conversions. I did not replicate that study. I did see that a 2-second delay changed behavior in ways that cost money, and that the defaults in most integrations are not tuned for it.
Three settings worth checking#
First, look at the retry interval. If it is under 2 seconds, you are probably double-charging on slow connections. If it is over 5 seconds, you are probably losing carts. The sweet spot depends on your average round-trip time, which you can measure.
Second, look at the idempotency key. Most processors support one. Few integrations use it. An idempotency key would have prevented every duplicate authorization in my tests. It is one header. It takes an hour to implement.
Third, look at the hold duration. A 15-minute inventory hold on a failed authorization is a default in some platforms. If your customers are on slow connections, that hold is a silent tax on conversion.
The part that does not fit a dashboard#
The merchant I worked with had a fraud dashboard, a conversion dashboard, and a support dashboard. Nobody had a dashboard for duplicate authorizations caused by retries. The data existed in the webhook logs. Nobody looked at it.
That is the gap. The headlines cover the losses that have a name. The losses that do not have a name are the ones that show up as a slow month and a support team that cannot explain why.
More articles