When an order is accepted but your systems disagree

Sparkler Soft19 November 20267 min read
Two software systems show different states for one booking: confirmation pending on the left and accepted on the right, linked by a reconciliation process.

A customer confirms a booking. The provider accepts it, but the response never reaches your application. Your screen shows a timeout. The provider already has a reservation. A second click could create a second booking.

The immediate problem is uncertainty: what happened, what can the customer safely do next, and who can resolve the disagreement? Treating every timeout as a failed booking leaves those questions unanswered.

This article uses a fictional booking service to illustrate integration design. It is not a client case study or a claim about a particular provider.

1. Separate the business outcome from the network outcome

A timeout means the caller did not receive a response within its waiting period. It does not, by itself, prove whether the remote operation succeeded. Even a successful HTTP exchange may describe an operation that is still processing: interpret the provider’s documented business status, not the transport result alone.

Start with three questions: Which system owns the booking? What evidence confirms its outcome? How can you find that evidence when the normal response is missing? The provider may own the reservation while your application owns the customer workflow. Record both responsibilities.

Sequence diagram: the application sends a booking request, the provider accepts it, the response is lost, and a later lookup by the same reference confirms the existing booking.
The provider can accept a booking even when its response is lost. Reconciliation uses the same operation reference to establish the outcome.

2. Give uncertainty an explicit state

The following is a proposed application model, not a universal API specification. Map it to the actual provider contract. “Not found” is conclusive only when the provider guarantees that the lookup is complete and sufficiently current; an eventually consistent search may simply be too early.

Suggested booking operation states
Application stateEvidence availableCustomer messagePermitted next action
SubmittingA durable local operation exists; no final provider result yet.We are submitting your booking.Prevent parallel submissions for the same intent.
Pending confirmationRequest may have reached provider; final outcome unknown.We are checking your booking. Please do not submit it again.Reconcile by reference; no unrestricted create retry.
ConfirmedDocumented success evidence and a matching provider record.Your booking is confirmed.Show the reference; fulfil once.
RejectedDocumented final rejection of this operation.Your booking was not accepted.Explain the reason; allow a new attempt when appropriate.
Needs reviewAutomated checks reached their limit or evidence conflicts.We are checking this with support.Assign an owner and investigate; do not silently convert to rejected.

Store the local operation before sending the request. Keep the operation ID stable across recovery attempts for the same intent. Disable repeated clicks in the interface, but also enforce concurrency control on the backend: another device, worker or network retry can bypass a button.

3. Establish what the provider actually supports

  • Lookup: Can you search by a reference supplied before the create request? A provider ID returned only in the lost response cannot be your only recovery key.
  • Idempotency: Which operations accept a key, how long is it retained, and what happens when the same key is reused with different parameters or during an in-flight request?
  • Status: Which responses are final, and can a lookup temporarily omit a newly created record?
  • Notifications: How are events authenticated, identified, retried and ordered? Can you retrieve current state if an event is late or missing?
  • Limits: What rate limits, backoff guidance and escalation routes apply to recovery?

An idempotency key is useful only when the provider implements the relevant guarantees. For a recovery retry, reuse the same key and request meaning within those rules. A new key can represent a new operation. Do not assume that adding a key to an unsupported API makes it safe.

Background: Amazon Builders’ Library explains why caller-provided request identifiers matter for safe retries. ↗Provider example: Stripe documents its own key retention, parameter checks and retry behaviour. Check your booking provider separately. ↗

4. Build a recovery process with an owner and a stopping point

For operations still awaiting confirmation, a worker can query the provider by the agreed reference. Choose its schedule, retry limit and maximum investigation age from the provider’s behaviour and your service requirements. Apply bounded backoff, respect rate limits, and record the next check. A worker that retries forever is not an operational plan.

Process notifications as evidence about the operation. Authenticate them using the provider’s documented mechanism, record a stable event identity where available, and prevent repeated processing from causing duplicate downstream actions. A late event must not blindly overwrite newer authoritative evidence.

Stripe’s webhook guide is one concrete example of a provider documenting duplicate events and event ordering. ↗

When the automatic process cannot establish the outcome, move the operation to a review queue with a named owner, evidence and escalation deadline. If the provider has neither a reliable lookup nor safe retry semantics, that is a scope constraint. It may require a manual process or a different API arrangement before launch.

5. Give support a record they can act on

A support screen should connect the customer-facing order to the remote operation and its investigation history. The following synthetic example shows a booking after a lookup has resolved the uncertainty. The times and identifiers are illustrative.

Local operation:       op_demo_1042
Customer order:        order_demo_208
Provider reference:    booking_demo_731
Correlation reference: client_demo_1042
Create attempts:       1
Initial observation:   response timeout
Last verified result:  accepted, from provider lookup
Evidence observed at:  2026-11-19T09:16:00Z
Application state:     confirmed
Resolution:            linked existing provider booking; no new create
Review owner:          unassigned (resolved automatically)

While the result is unknown, the provider reference may be empty. Preserve the correlation reference, observation times and attempts instead of inventing a booking ID. Limit access to customer data and avoid placing credentials, payment details or full private payloads in a general support log.

Separate “refresh provider status” from “create booking” in the interface. For manual corrections, record the operator, evidence, previous state and reason. Apply corrections with a conditional state/version update or an appropriate lock, so that a support action and a late notification cannot overwrite each other.

6. Test disagreement before accepting the integration

Use a safe test environment and verify both systems, including the number of bookings created. A mocked response can test your application logic; it cannot establish undocumented behaviour of the real provider. Record that distinction in acceptance evidence.

  • Explicit rejection: no success is shown, the rejection reason is recorded, and no booking is created.
  • Accepted operation, lost response: the UI enters pending confirmation; reconciliation finds the original booking; the total remains one.
  • Repeated click or concurrent request: backend controls and documented provider semantics prevent duplicate creation for the same intent.
  • Late confirmation: the event resolves uncertainty without creating another booking or triggering fulfilment twice.
  • Duplicate or out-of-order event: processing follows the documented ordering/version rules or retrieves current authoritative state.
  • Worker interruption: after restart, the saved operation resumes investigation without losing its reference or inventing a new intent.
  • Exhausted recovery: the operation reaches a review queue with evidence, owner and an agreed escalation path.
  • Manual correction during a late update: conflicting writes are detected, and the final decision has an audit trail.

7. Scope the first deliverable around one complete operation

A useful first delivery package can cover one booking operation, durable correlation records, an explicit state model, a recovery worker and a limited support view. Include authenticated notification handling where the provider supports it. Agree the acceptance scenarios, operational owner and evidence of completion before estimating.

Keep payment, cancellation and refund states separate unless they are explicitly included. A confirmed reservation does not automatically establish that a payment settled, a refund completed or a downstream fulfilment succeeded.

If your team is manually comparing two systems, bring one specific example to the discussion: the systems involved, the operation that disagreed, available API documentation and what support had to do. That is enough to start identifying the recovery path and the missing evidence.

Sparkler Soft can help define and implement the backend, API integration and operator interface for that workflow. Tell us which two systems disagree and which action currently needs manual investigation.

Share
SS

Sparkler Soft

Company editorial

Practical guidance on software project planning and working with a development partner.

LinkedIn →

Related Articles

Business

From backlog to a usable workflow

Walk through a complete user journey, inspect a failed integration and turn observations into requirements, owners and decisions before estimating development.

Sparkler Soft6 Nov 20263 min read

Have a similar challenge?

Tell us about your project — we'll tell you honestly whether we can help.