The retry path is a second send path

Our send path was the careful one. It had channel routing, quiet hours, a file lock on the lead registry, tests. It was the path we'd thought about. Then the original send started failing for a few leads — transient provider hiccups — so we built the retry path in an afternoon. It worked. The failed sends got retried. We moved on.

Two weeks later, the retry path had eaten a lead and texted a customer who'd asked for email. The careful path was fine. The afterthought was the problem.

The rewrite that ate a lead

The retry worker's job was simple: read the dead-letter queue, re-attempt each failed send, update the lead registry. To do that, it read the registry file into memory, applied its updates, and wrote the whole file back out.

No lock. The send path took a file lock before touching the registry; the retry path — written in an afternoon, remember — didn't.

Most of the time, nothing else touched the file during the retry's read-modify-write window, and everything was fine. But one morning a new lead arrived mid-retry. The intake wrote the new lead to the registry; seconds later, the retry worker finished its rewrite from the stale in-memory copy — the one from before the new lead existed. The new lead was gone. Not flagged, not errored. Just absent from the file, as if it had never arrived.

The verification trap: we tested the retry worker end to end and it worked perfectly — because in tests, nothing else touches the registry mid-retry. Concurrency bugs don't reproduce in a quiet room. The lock wasn't missing because we didn't know about locking; it was missing because the retry was "just a small script," and small scripts don't get the invariants.

The fix was one line's worth of work: take the same file lock the send path takes, on the retry path. The lesson cost more.

The retry that texted the email people

The send path routed carefully by channel: SMS leads got texts, email-preference leads got emails, quiet hours were honored. All of that logic lived in the send path.

The retry path had none of it. When a send failed, the failure record stored the lead ID and the error — not the channel preference. So the retry worker did the only thing it knew how to do: sent the default SMS template. To everyone. Including the leads who had explicitly asked for email.

Nobody had told the retry path about channel preferences because nobody had thought the retry path needed to know. The original send was "the real logic"; the retry was "just re-running it." But it wasn't re-running it — it was a second, dumber implementation of it, missing every decision the first one had made.

The fix: the failure record now stores the channel preference alongside the error, and the retry respects it. Email-preference failures don't get auto-retried as texts at all — they get flagged for manual handling instead of a wrong-channel blast. A retry that sends the wrong thing to the right person is worse than no retry.

Your retry is a second implementation of everything

Here's the theme, stated plainly: the retry path is a second send path, and it needs every invariant the first one has. Locking. Channel routing. Quiet hours. Idempotency. All of it.

Most teams build the send path carefully and dash off the retry as an afterthought — a small script, a cron job, a "we'll harden it later." But the retry runs against the same customers, the same data file, the same 3 AM. On a normal day it's a quiet background worker. On a bad day — the day the primary path is failing and the retry queue is full — it is the primary path, handling your most fragile traffic with your least careful code.

That's the inversion worth sitting with: the retry path matters most exactly when conditions are worst, and it's the code you thought about least.

Checklist

Lock the retry path like the send path. If the primary path takes a lock on shared state, the retry takes the same lock. Read-modify-write without a lock is data loss with extra steps.
Carry the full context into the failure record. Channel preference, template choice, quiet-hours state — everything the send path decided must be available to the retry. A failure record with just an ID and an error is an invitation to re-send wrong.
Never let the retry do something the send path wouldn't. If the send path wouldn't text an email-preference lead, the retry doesn't either. The retry's permissions are a subset of the send path's, never a superset.
Honor quiet hours on every path. A retry firing at 3 AM is still a 3 AM text, no matter which script sent it.
Test the retry under contention, not in a quiet room. Run it while the intake is writing. Race the two paths deliberately. Concurrency bugs hide from sequential tests.
Review the retry with the same rigor as the send path. Code-review it, checklist it, on-call for it. "Just a small script" is how the invariants get lost.