Synchronous versus asynchronous SAP integration: What does success mean?
A manufacturer's operational integration submits an order request whose synchronous or asynchronous contract changes what the initial response establishes.
START HERE · NO PRIOR TOPIC KNOWLEDGE NEEDED
What it is. Why it matters.
A synchronous exchange waits for a response during the request. An asynchronous exchange accepts work for later processing, so an initial response may not describe the final business outcome.
Completely new to SAP?
Manufacturers use SAP to connect work such as buying components, recording inventory, planning production, shipping equipment and accounting for costs. SAP S/4HANA is an enterprise resource planning system: it connects these activities through shared business data.
Integration connects applications so they can exchange information. A delivered message still needs the receiving application to understand and accept its business meaning.
A transaction code, or t-code, is a shortcut to a task in classic SAP GUI. Fiori apps provide another way to work. Names and screens depend on the product and release; you do not need a live system to learn the concepts in this guide.

Scope and source-review notes
Scope and evidence
Source review by FAST SAP SOLUTIONS® editorial. This badge describes our editorial review; it does not represent SAP certification or independent endorsement.
SAP integration communication patterns with current Cloud Integration ProcessDirect/JMS guidance and an explicitly fictional order-status contract. Legacy PI bridge behavior is identified separately; adapter and API acknowledgment meanings depend on their actual contract.
Documentation review on 14 November 2026 using official SAP sources and indexed official excerpts where full Help text was unavailable. Scope and service or release differences are explained in the lesson. All datasets, requests and checks are illustrative; no customer SAP runtime execution or measured results are claimed.
A MANUFACTURING EXAMPLE
Define success for a manufacturing order handoff
What did the response promise?
Read the example values
- Synchronous pattern
- Response during request
- Asynchronous pattern
- Accepted for later work
- Initial result
- Accepted
- Final document
- Check subsequent outcome
Words you’ll meet in this guide
- Message
- A package of information sent between systems.
- Payload
- The business content carried in a request or message.
- API
- A defined interface for another program to use.
- Receiver
- The system to which a message or request is sent.
- HTTP
- The request-and-response protocol used by web applications and APIs.
- JMS
- Java Message Service: a standard messaging API used with supported queue services.
Preview the practical steps
SEE THE CONNECTION
See it in a simple example.
A small example to make the idea concrete.
Define success for a manufacturing order handoff
A manufacturer's operational integration submits an order request whose synchronous or asynchronous contract changes what the initial response establishes.
Define what success promises before choosing a communication pattern
A synchronous exchange waits for a response in the calling interaction.
Separate acceptance, execution and business completion
A request can be authenticated and accepted before a receiver validates its business data.
Worked case: order request REQ-700 has two possible contracts
Imagine external order reference REF_700 for 250 EUR.
Define success for a manufacturing order handoff
A manufacturer's operational integration submits an order request whose synchronous or asynchronous contract changes what the initial response establishes.
Distinguish acceptance from final business completion before displaying a completed status to the requesting plant team.
| Reader | Business question | Evidence to carry forward |
|---|---|---|
| SAP developers and application teams supporting manufacturers | Define success for a manufacturing order handoff | Distinguish acceptance from final business completion before displaying a completed status to the requesting plant team. |
01 Define what success promises before choosing a communication pattern
A synchronous exchange waits for a response in the calling interaction. An asynchronous exchange separates acceptance from later processing or outcome delivery. Neither label alone proves that a business document exists. Read the actual contract: a response may mean transport receipt, durable acceptance, business rejection or completed business processing. [1] [2]
This tutorial is for SAP integration developers and application owners designing request/response and queued flows. It uses current Cloud Integration communication guidance and a fictional order contract. Adapter support and service APIs vary by product and version. The older PI sync/async bridge is discussed only as an architectural example, not a configuration recipe for Cloud Integration.
02 Separate acceptance, execution and business completion
A request can be authenticated and accepted before a receiver validates its business data. It can be persisted in a queue before a worker calls the receiver. The receiver can create a document before the caller receives confirmation. These checkpoints are distinct, so “sent successfully” is too vague for an operational state.
Use explicit states such as accepted, processing, completed, rejected and uncertain where they fit the interface. Define who owns each transition and what evidence establishes it. A Cloud Integration processing status is one observation within that design. It should not be presented as a substitute for the receiver’s business result when the contract separates them.
03 Worked case: order request REQ-700 has two possible contracts
Imagine external order reference REF_700 for 250 EUR. In a synchronous design, the client waits for the receiver’s application response carrying the created order identity or an explicit rejection. In an asynchronous design, the endpoint returns acceptance for request REQ-700, and a later status query or callback reports whether order SO-9700 was created.
The authored response below illustrates the second contract. The status URL and fields are fictional application design, not a released SAP order API. At the moment of acceptance, displaying “Order SO-9700 created” would be incorrect because no final document identity has yet been established.
| Later state | Business evidence | User-facing meaning |
|---|---|---|
| Processing | Worker has not supplied a final result | Request remains in progress |
| Completed | SO-9700 created for REF_700 | Business creation confirmed |
| Rejected | Supplier/customer or another rule failed | Accepted request did not create the order |
| Uncertain | Receiver outcome cannot yet be established | Reconcile before another create |
HTTP/1.1 202 Accepted
Content-Type: application/json
{"requestId":"REQ-700","externalReference":"REF_700","status":"Accepted","statusUrl":"/requests/REQ-700"}04 Choose synchronous behavior when the caller needs an immediate result
A synchronous pattern can be appropriate for a short operation whose outcome the caller needs to continue, such as a permitted lookup or an application validation. The caller must still inspect the response contract. HTTP 200 with a business-rejection body can be a technically successful response that did not perform the desired action.
Define timeouts and expected response duration for the complete path, including proxies and dependent systems. Increasing one timeout does not automatically change every upstream deadline. If a write times out, the receiver might have committed already. A synchronous interaction therefore needs an uncertainty and retry design just as an asynchronous one does.
05 Choose asynchronous behavior with a durable result-tracking design
Asynchronous processing can decouple sender availability from a slower or temporarily unavailable receiver. SAP’s JMS retry example persists work, returns 202 and continues processing later. That documented example does not mean every endpoint returning 202 has durably stored work; the service contract must state its acceptance guarantee. [2]
For REQ-700, define how the sender finds the final result and how long that result remains available. Decide whether it polls a supported status resource, receives an authenticated callback or relies on an agreed operational acknowledgment. A queue without result correlation leaves users knowing only that something was accepted. The design is incomplete if rejected work has no owner or discoverable outcome.
Define cancellation separately from acceptance and completion. A caller closing a browser or timing out does not prove queued work was canceled. If the fictional REQ-700 contract supports a cancellation request, specify when it is still effective and what happens after SO-9700 already exists. A later business reversal is a different operation from stopping unprocessed work.
Also define result-retention behavior. If a status record expires before the sender reconciles a timed-out request, an unknown request response must not be interpreted automatically as permission to create again. Keep the operation identity and receiver lookup strategy aligned with the longest supported retry/reconciliation window.
06 Keep request, message and document identities connected
Use separate identities for their actual purpose. REF_700 identifies the intended business operation, REQ-700 identifies the accepted application request and SO-9700 identifies the created business document. Middleware can also have its own message-processing ID. Do not assume those identifiers are interchangeable or globally unique without their system/tenant context.
Persist the relationship through the supported application design. A callback must identify the original request and be authenticated under the agreed contract. A status response should describe the current state of that request rather than merely report that a similarly named order exists somewhere. If a callback arrives twice or after a status poll already completed the request, handling should remain consistent and idempotent.
07 Assign retry responsibility and protect against duplicate effects
Choose who retries each failed boundary: sender, middleware, receiver worker or a combination with clear responsibilities. If both sender and middleware retry independently without stable identity, a temporary outage can create several copies of the same business instruction. Durable delivery and duplicate protection need to be designed together.
For REF_700, an identical retry should reuse the agreed operation identity. If the receiver already created SO-9700, a supported idempotent repeat or lookup should reconcile that result. Generating a new external reference because the first response was lost can bypass duplicate recognition and create another order. A new business instruction requires an explicit new-intent decision, not a troubleshooting shortcut.
08 Understand synchronous and asynchronous flow-to-flow boundaries
SAP recommends ProcessDirect for synchronous communication between Cloud Integration flows and JMS queues for asynchronous flow-to-flow communication in the documented tenant-local scenarios. The synchronous caller waits for the called flow to finish; an asynchronous caller does not wait for a business response. Use the documented adapter and runtime support rather than routing internal calls through unnecessary public endpoints. [1]
A process can mix these boundaries. An inbound asynchronous worker can make a synchronous receiver call, then record the later business result. An HTTP request can also wait on an internal process. Describe each boundary separately so an acceptance at one level is not mistaken for completion at another.
09 Treat sync/async bridging as a pattern with explicit correlation
The legacy PI documentation describes a bridge receiving a synchronous request, sending asynchronous work and correlating a later response back to the waiting caller. That illustrates the need for correlation and waiting-state ownership. Its Business Process Engine configuration is technology-specific and should not be copied into a different modern runtime. [3]
If considering a bridge, ask whether the caller can wait for the possible processing duration and whether a timeout loses only the response or also the ability to discover the final result. A bridge cannot eliminate an uncertain receiver commit. A separate accepted-request resource may be more appropriate when processing naturally exceeds an interactive caller’s deadline.
10 Troubleshoot the first state that lacks evidence
Use the contract to determine what the observed response proves. A successful send, a successful flow and a final business document can be three different rows in the same request ledger.
| Observation | Question | Next evidence |
|---|---|---|
| 202 returned, no document yet | Was only acceptance promised? | Request status and worker/receiver outcome |
| Synchronous timeout | Could the receiver have committed? | Stable-reference lookup and receiver evidence |
| Flow Completed, business rejection | Was response content interpreted? | Business result fields and error-handling branch |
| Queued work never finishes | Where is the accepted request now? | Queue disposition, worker log and recovery owner |
| Callback missing | Did processing or outcome delivery fail? | Request state and callback delivery evidence |
| Duplicate document after retry | Was operation identity preserved? | Sender/middleware retry keys and receiver contract |
11 Test accepted, completed, rejected and uncertain outcomes
For the positive synchronous test, verify the response identifies the intended created object and a receiver lookup confirms it. For the positive asynchronous test, verify acceptance first, then the later transition to completed with the correct document identity. Do not collapse those assertions into one “HTTP request passed” check.
For a negative fixture, submit a business-invalid but structurally permitted request and verify a clear rejection path. If accepted asynchronously, the later status must become rejected with a safe actionable reason. For a boundary fixture, make the receiver unavailable temporarily and observe the documented retry and request-state behavior without creating duplicate business effects.
Test a lost response after commit, a duplicate callback, an unknown request ID and a result that arrives after the caller’s timeout. These cases reveal whether correlation and recovery are usable. Where a test is only designed rather than executed, label it as proposed and keep the exact expected state transitions in the review.
12 Communicate progress and operational ownership precisely
User-facing text should reflect evidence: “Request accepted” before final processing, “Order created” only when the contract confirms creation and “Action required” for an owned rejection. An indeterminate spinner with no request reference makes support harder even if the queue itself is durable.
Operations should know the accepted-work retention, completion expectation, alert conditions and supported replay scope. A slow request is not necessarily failed; an old accepted request without progress still needs investigation. Record actual timestamps for acceptance, processing and business result so observed latency can be compared with the agreed requirement.
What closes the design? Pattern per boundary, meaning of each acknowledgment, stable correlation, final-result discovery, retry/idempotency behavior and positive/negative failure tests. The related Completed-response, JMS and idempotency lessons develop those mechanisms without treating communication style as a universal success guarantee.
Related services and next steps
Primary sources
Found this useful?
Share this guide with your network, or leave a like.
Your like is saved in this browser.