ClientPlatformProviderlaunch intentcreate allocationresponse lostlookup by operation IDresolved outcomeunknown ≠ failed
A missing response branches to reconciliation. It does not rewind an already committed session. Synthetic design, not a vendor protocol. Scroll the diagram horizontally for detail.

A launch button describes a user intention, not a completed distributed transaction. Between that button and usable content, several services may independently accept work, change state, or lose a response. Start an integration design by naming those boundaries. Otherwise, a harmless-looking retry can create a second session while the first is already running.

This guide constructs a hypothetical session-launch flow. It is a design exercise, not documentation for a commercial platform. The client is a browser, the platform owns session records, and a provider allocates a content session. We assume authenticated server-to-server communication, a durable platform database and an external provider that supports a stable operation reference. None of those properties should be assumed when reading a real integration contract.

Name the owners

The browser owns presentation and user intent. It can request a launch and show progress, but it should not invent authoritative session state. The platform owns the mapping from one accepted intent to one platform session. The provider owns its own allocation. A tracing system observes the journey; it does not decide whether a session exists.

Write down an invariant before drawing arrows: one accepted launch intent maps to at most one active platform session. This is narrower than promising one allocation across every system. That broader promise depends on the provider’s behavior and the platform’s reconciliation strategy. An invariant that cannot be checked at a named boundary is difficult to test and easy to oversell.

Boundary Durable fact Uncertain observation
Browser → platform Intent accepted under an operation ID Browser stopped waiting
Platform → provider Provider allocation recorded Response did not arrive
Platform → browser Platform session is ready Browser received the response

Walk the successful sequence

First, the browser submits a launch intent with a client-generated reference. The platform validates identity, content availability and the intended operation before reserving a session record. Validation errors return a useful terminal outcome rather than entering the delivery retry queue.

Second, the platform records a pending operation and issues the provider request. A durable handoff matters here: if a process exits between writing the operation and dispatching it, another worker must be able to find the unfinished work. In this example, an outbox row and the pending session are written in the same local database transaction.

Third, the provider returns a synthetic allocation reference. The platform stores that reference, moves the session to ready and returns the launch location. The browser can now navigate. This example deliberately omits credentials; a real launch address may contain sensitive capabilities and should not be copied into routine logs.

{
  "example": true,
  "operation_id": "launch-example-017",
  "content_id": "puzzle-example-04",
  "state": "ready",
  "launch_uri": "https://example.invalid/session/example-017"
}

The field names are invented for this manual. Valid JSON does not establish an API contract: required fields, allowed state transitions, authentication and expiry are separate decisions. JSON’s serialization rules are specified in RFC 8259; the session semantics above are our own.

The response disappears

Now interrupt the sequence after the provider creates its allocation but before the platform receives the response. The platform sees a timeout. It cannot distinguish a missing allocation from a missing acknowledgement using that timeout alone. Marking the session failed and issuing an unrelated create request risks two allocations.

Instead, preserve the original operation reference and move the platform record to an explicit unknown state. Query the provider by that reference if the contract supports it, or repeat a request only when its application semantics make repetition safe. HTTP defines idempotency in terms of the intended server effect; a POST does not become safe to repeat merely because a client timed out. See RFC 9110, section 9.2.2.

The browser also needs a recovery path. In this example it receives a pending result with a status location, then polls the platform’s local operation record. Closing a tab does not cancel the provider allocation. Cancellation would be another explicit operation with its own outcome and reconciliation requirements.

Spend a latency budget

Suppose an illustrative user-facing budget is two seconds. Spending the full two seconds waiting for the provider leaves nothing for local validation, database writes or the response trip. Allocate a shorter downstream deadline, reserve time for local completion, and make the pending state understandable to the user.

That budget is a product assumption, not a measured service guarantee. A slower provider may require an asynchronous launch experience. Rejecting work quickly improves predictability but can reject operations that would eventually succeed. Waiting longer reduces visible pending states but consumes connection capacity. Choose using measured workload and a clearly defined acceptable outcome.

Do not hold a database lock while waiting on a remote allocation. Store a claim with a bounded lease or another explicit ownership mechanism, release local locks, and perform the remote call. Recovery must handle the possibility that the worker continues after its lease expires; a lease alone is not a duplicate-effect defense.

Reproduce the failure

Build a local provider stub with a durable allocation counter. Have it commit the allocation, then deliberately drop the response. Submit the same launch intent twice. The expected result is one platform operation and a recoverable reference to the first allocation, not two silently unrelated sessions.

Next, crash the dispatcher after the outbox commit but before sending. Restart it and check that the pending work is discovered. Then crash after sending but before marking the outbox delivered. The repeated dispatch must preserve the same intent identity. These tests target different uncertainty windows; one generic timeout test will miss the distinction.

Also test a changed content ID under the same operation reference. The receiver should reject the mismatch or apply another explicitly documented policy, never return a previous result as though it described the new request. Verify that an expired operation remains distinguishable from an operation that never existed.

Where this model stops

This flow does not implement authorization, real game execution, accounting or provider-specific launch security. It assumes the team can inspect durable operation state and that a reconciliation mechanism exists. If a provider offers neither repeat-safe creation nor lookup by a stable reference, document the unresolved window and route it to operational review.

Continue with callbacks and retries to separate delivery from processing. The idempotency guide then puts the duplicate-effect boundary inside a transaction. For terminology, compare timeout with acknowledgement: they describe observations, not interchangeable facts about committed work.