The moment after you hit send

Everyone who sends documents for signature eventually has the same small panic: the envelope is already out, and something is wrong. The price has a typo. You attached last week's draft. A clause changed in review thirty seconds after you clicked send. Or the deal simply fell through and the open request is now noise. The instinct is to fire off an email — "ignore the last one, signing a new copy" — but that leaves two live documents, an ambiguous record, and a signer who doesn't know which one counts.

There's a disciplined way to handle each of these, and the right move depends on one question: has anyone signed yet?

Void: stop a request that shouldn't complete

Voiding an envelope cancels it. The signing links stop working, the document can no longer be signed, and the envelope's final state is recorded as voided. Use it when the request should not be completed at all — a dead deal, a duplicate send, a document with a material error you can't fix in place.

The important part is what voiding does to the record. It doesn't erase the envelope; it closes it with a reason. That reason matters: a voided envelope with "superseded by corrected version" written on it is self-explanatory a year later, while one voided silently is a question mark. Capture why you voided, because the audit trail keeps the void as its own event, and a clear reason is what turns "this looks suspicious" into "this was routine housekeeping."

Two things worth knowing before you void:

  • You can void before or after partial signatures. If two of three signers have already signed and the deal collapses, voiding stops the third and marks the whole envelope dead. The signatures already collected remain in the record as having occurred — they're just attached to an envelope that never completed.
  • Voiding does not refund the credit. As everywhere in the product, a credit is consumed when the envelope is sent, not when it completes — so a voided envelope already spent its credit. That's a reason to get the document right before sending, not a reason to avoid voiding when you should.

Correct: fix an envelope that's still in flight

Sometimes you don't want to kill the request — you just need to fix something and keep it moving. The clean pattern for an in-flight envelope is void-and-resend: void the flawed envelope with a clear reason, then send a corrected one, ideally from the template the original came from so the layout and routing are identical and you only change what was wrong.

Resist two tempting shortcuts that quietly poison the record:

  1. Don't ask the signer to "just cross it out and initial." A hand-edited mark on an electronic document defeats the integrity guarantee — the whole point is that the document fingerprint matches exactly what was agreed. Change the document, not the signed artifact.
  2. Don't leave the old envelope open "just in case." Two live requests for the same agreement is exactly how a counterparty signs the wrong version. Void the old one before the new one goes out, so at any moment there is exactly one document that can be signed.

If a signer has already completed the original and only then do you discover an error, you can't edit a completed document — its seal is the proof it's unchanged. The honest path is a new, corrected envelope plus, where appropriate, a short amendment that references the first. Both stay in the record; nothing is rewritten after the fact.

Resend: when nothing's wrong, the signer just went quiet

Not every "I need to resend this" is a correction. Often the document is fine and the signer simply never acted. Don't void and recreate for that — you'll burn a credit and reset the history. Instead, lean on the tools built for silence: turn on automatic reminders and a hard expiration so the platform nudges the stragglers on a cadence and the request closes itself one way or the other. A reminder is a re-send of the same envelope, so it costs no extra credit and keeps one continuous audit trail.

Reach for void-and-resend only when the document or recipients must change. Reach for reminders when only time has passed.

Build the correction step into your process

The teams that handle this gracefully don't rely on catching errors after send — they make sending the wrong thing harder in the first place:

  • Send a test envelope to yourself for any new or high-stakes document before it goes to the counterparty, exactly as you would before a bulk send. Most "I need to void this" moments are caught here for free.
  • Standardize on templates so the document that goes out is the approved one, with fields and routing already correct, rather than a fresh upload assembled under time pressure.
  • Watch the unhappy path in your automations. If you react to signing events with webhooks, handle envelope.voided and envelope.declined, not just envelope.completed — a voided agreement should be reconciled out of your pipeline, not left sitting as "pending" forever.

The takeaway

After you've sent a document, the right move is rarely an apologetic email. If the request shouldn't complete, void it with a clear reason. If it needs a fix while in flight, void and resend a corrected copy from a template, never two live versions at once. If the signer just went quiet, let reminders and expiration do the chasing. Each path leaves a clean, single-threaded record — which is the whole reason you're signing electronically instead of faxing.

This article is general guidance, not legal advice. For requirements specific to your document or jurisdiction, consult qualified counsel.