Back to all articlesLead capture

Prevent repeat submissions when visitors are unsure a form worked

Alactic Editorial10 min read

Prepared with AI assistance by Alactic Editorial. Examples identified as hypothetical are illustrative, not customer results.

A visitor presses Submit, sees no clear change, and presses again. The second click may create another record even though the visitor only intended one enquiry. Disabling the button helps, but it cannot resolve a refreshed page or a response that disappears after the server has already accepted the form.

To prevent duplicate contact form submissions, give each submission attempt a stable identity, show whether it is submitting, confirmed, failed, or unknown, and make retries reuse that identity until the outcome is resolved. The interface should explain what the visitor can safely do next; the receiving system should enforce the repeat-submission rule.

This is a submission reliability problem, not a contact-matching problem. The same person may legitimately send separate enquiries. The goal is to avoid creating multiple records for one intended submission—not to suppress every form with a familiar email address.

1. Define what counts as one submission attempt

Start with a rule your form owner and receiving-system owner can both explain: one intended submission has one attempt identifier. Repeated delivery of that attempt should return the existing outcome rather than create another record.

An attempt identifier is not a contact identifier. It should not be derived solely from an email address, phone number, or name. Those values describe the person; they do not establish whether two requests represent the same enquiry.

Consider a fictional visitor asking about onboarding, then returning later to ask about a different service. Both requests may belong to the same contact, but they are separate submissions. Conversely, two identical requests arriving moments apart may be one attempt delivered twice.

  • Same attempt, unchanged content: reuse the existing identifier and outcome.
  • Confirmed attempt, new enquiry: create a new identifier through an explicit new-enquiry action.
  • Unknown attempt: preserve the identifier while checking its status or retrying safely.
  • Changed content during an unresolved attempt: do not silently treat it as a retry. Resolve the earlier attempt or explain that the changed form would be a separate enquiry.

Document when the identifier is created, where it survives navigation, and how long the receiving system remembers it. A retry is safe only while the system can still recognise the original attempt.

2. Give each state an honest meaning

The four outcome-related states need different messages and different permitted actions. A ready-to-submit form sits outside these states until the visitor begins an attempt.

Submitting

The request has started, but there is no authoritative result yet. Show a visible progress message immediately, prevent repeated activation of Submit, and preserve entered values. Do not claim receipt merely because the browser sent a request.

Confirmed

The receiving system has durably accepted the submission at the boundary your team has defined. Explain what was received and what happens next. If a later CRM transfer is separate, do not make the confirmation imply that transfer has completed.

Failed

The system knows the attempt was not accepted. An explicit validation rejection before any record is created can qualify. Explain the issue, retain the visitor's work where appropriate, and offer a correction or retry path. A generic connection error is not sufficient evidence of failure.

Unknown

The browser cannot establish whether the submission was accepted. A timeout, interrupted connection, or missing response can produce this state. Say that the outcome is uncertain and offer a status check or an identifier-preserving retry. Do not tell the visitor to start again with a fresh attempt.

Messages should be available to assistive technology, not communicated only through colour or a spinner. Keep controls labelled and errors understandable. W3C's form validation guidance also makes an important distinction: browser checks do not replace validation on the server.

3. Use this filled submission-state decision table

Fictional worked example: A service enquiry form uses attempt identifier ENQ-A7. Its receiving service records an accepted attempt and its enquiry together. The browser retains enough information to recover that attempt after navigation. These are hypothetical design choices, not claims about an existing product.

The decision table below is presented as labelled rows so each scenario can be copied into a test ticket. All visitor messages and acceptance tests are hypothetical.

  1. Scenario: double click while sending.
    State: Submitting.
    Decision: Ignore repeated activation in the interface. If concurrent requests still arrive, both carry ENQ-A7; the receiving service accepts it once.
    Visitor message: “Sending your enquiry. Please wait for confirmation.”
    Acceptance test: Trigger two near-simultaneous requests with the same identifier and content. One enquiry exists, and both responses resolve to that enquiry's outcome.

  2. Scenario: refresh while sending.
    State: Unknown on return until checked.
    Decision: Restore the attempt reference and check its outcome. Do not automatically create a fresh attempt.
    Visitor message: “Checking whether your enquiry was received.”
    Acceptance test: Refresh after sending but before confirmation. The restored page finds the accepted enquiry or offers a same-attempt retry; it does not silently submit a new enquiry.

  3. Scenario: browser Back after confirmation.
    State: Confirmed once reconciled with the stored outcome.
    Decision: Restore the receipt rather than an active version of the old Submit action. Offer a separate new-enquiry action.
    Visitor message: “This enquiry has already been received. Start a new enquiry if you need to send something different.”
    Acceptance test: Confirm, navigate away, then return with Back. A stale or repeated request using ENQ-A7 still produces no additional enquiry.

  4. Scenario: response lost after receipt.
    State: Unknown in the browser; accepted on the server.
    Decision: Check status or retry with ENQ-A7. Return the recorded acceptance instead of creating again.
    Visitor message: “We could not confirm the result. Check the status of this enquiry before starting another.”
    Acceptance test: Accept the form, then deliberately drop the response in a test environment. A same-attempt retry retrieves confirmation, with one enquiry stored.

  5. Scenario: server rejects invalid input before acceptance.
    State: Failed.
    Decision: Identify the fields to correct. Under this example's rule, no identifier is bound to accepted content until validation succeeds, so the corrected form can use ENQ-A7.
    Visitor message: “Your enquiry was not submitted. Please correct the highlighted fields and try again.”
    Acceptance test: Submit invalid input, then correct it. The rejected request creates no enquiry; the valid request creates one.

  6. Scenario: content changes after an uncertain result.
    State: Unknown for the original attempt.
    Decision: Do not overwrite the content associated with an accepted or in-progress identifier. Resolve the original attempt first.
    Visitor message: “The earlier enquiry may already have been received. Check its status before sending these changes separately.”
    Acceptance test: Reuse an accepted identifier with different content. The service rejects the mismatch without creating a second enquiry or altering the first.

4. Make the receiving service enforce the rule

Button behaviour is a usability control, not a reliable record-creation boundary. A stale page, another tab, or a repeated network request can bypass it. Backend idempotency is an architectural option: repeated requests for one attempt produce one durable acceptance outcome.

The important requirement is atomicity. Checking whether an identifier exists and then creating a record in separate, unprotected steps leaves a race: two requests can both see nothing and both create. Use an atomic uniqueness mechanism or an equivalent transactional design appropriate to the receiving system.

  • Scope identifiers: bind them to the appropriate form and receiving account so unrelated attempts cannot collide.
  • Bind accepted content: distinguish an unchanged retry from reuse of an identifier with different input.
  • Handle in-progress attempts: a concurrent request should wait, receive a pending result, or retrieve the completed outcome—not create another record.
  • Keep the outcome: remember enough to recognise retries throughout the supported recovery period.

Protect downstream effects too. If acceptance queues a CRM handoff or a staff notification, replaying the same accepted attempt should not enqueue that work again. Each separate processing stage needs a repeat-handling rule; deduplicating only the initial form record leaves other duplication paths open.

These are recommended architectural controls, not asserted product capabilities. Establish which part of your actual form-to-record workflow can enforce them before choosing the implementation.

5. Make unknown outcomes recoverable

The unknown state is where a helpful-looking retry button can cause the most damage. If it generates a fresh identifier, it turns an uncertain outcome into a possible second enquiry.

Prefer a status check when available. If the service supports safe repeated submission, a retry can resend the unchanged content with the same identifier. Keep that distinction out of the visitor's technical workload: the interface should preserve the identifier automatically rather than ask the visitor to copy it.

A status lookup must not expose enquiry details merely because someone has a reference. Apply suitable access controls or narrowly scoped recovery credentials, and reveal only what the recovery task needs. OWASP's object-level authorization guidance explains why possession of an object identifier alone is not authorization.

If recovery information is missing or expired, say so honestly. Offer a human contact route and explain that the earlier enquiry may have arrived. Do not describe a newly generated attempt as a guaranteed duplicate-free retry. Also avoid storing full form contents indefinitely in the browser merely to support recovery; decide what information is necessary and how it is cleared.

6. Separate receipt from later processing

Choose a confirmation boundary the system can prove. If the form service has safely accepted an enquiry but a downstream transfer is pending, “We received your enquiry” may be accurate; “Your enquiry is now assigned to an adviser” may not be.

Maintain separate internal states for receipt and downstream processing. When a later transfer fails, retry that transfer against the original accepted submission rather than asking the visitor to fill out the form again.

This separation also prevents confirmation-page visits from triggering operational work. Refreshing a receipt should retrieve information, not create another enquiry, send another acknowledgement, or restart routing. A redirect to a receipt page can reduce browser reposting, but it does not replace server-side repeat handling.

Likewise, rate limiting is not a substitute for attempt identity. Blocking frequent requests can slow repeated clicks, yet still leave the visitor uncertain about whether the first request succeeded. A waiting instruction should preserve the original attempt and its recovery path.

7. Check the trade-offs before release

Overly aggressive suppression can hide legitimate demand. Never use “same email within a short period” as the sole rule for discarding enquiries. It cannot reliably distinguish a retry from a separate request.

Longer identifier retention supports longer recovery periods but adds storage and lifecycle work. Shorter retention reduces that burden but limits how long an old request can safely be recognised. Align browser recovery with server retention: the interface must not advertise safe retries beyond the service's supported period.

Disabling Submit indefinitely creates another failure mode. When the outcome becomes unknown, replace the waiting state with an explicit recovery action. Preserve valid field values after correctable failures, and make any unavoidable loss of input clear before the visitor restarts.

Finally, test Back navigation with restored page state, not only a freshly loaded page. The visible interface may be stale even when the server's acceptance record is correct. Reconcile the two before enabling another submission.

8. Run a focused acceptance check

For the next release, assign one owner to the browser states and one to the receiving-service rules. Use the fictional decision rows as a shared test plan, replacing their details with your actual confirmation boundary and retention policy.

  1. Run every row, including concurrent requests and deliberate response loss.
  2. Inspect the receiving records and downstream jobs, not just the success screen.
  3. Verify that one attempt produces one acceptance and no repeated downstream work.
  4. Submit a separate enquiry from the same person and confirm it is not suppressed.
  5. Check that each uncertain outcome offers recovery without silently creating a new attempt.

Record repeated requests recognised, unresolved unknown outcomes, mismatched-identifier requests, and confirmed extra records from a single attempt. Keep those measures separate from duplicate-contact counts. The immediate success criterion is observable: each tested attempt has one recorded outcome, and the visitor can understand what to do when that outcome is not yet known.

Lead captureForm designSubmission reliabilityData quality

Put the next conversation to work.

Explore Alactic Communications for WhatsApp conversations, campaigns and AI-assisted workflows. Choose the product and plan that fit your team.

Explore Communications