@Autowired]
+@After(event = CqnService.EVENT_CREATE, entity = Bookings_.CDS_NAME)
+void notifyXFlights(Listawait is still needed
+> Even though processing is asynchronous, you still need to `await` because the message is written to the database within the current transaction.
+
+The `xflights` connection here stands in for any remote service you've configured under `cds.requires`. The complete setup of the *xtravels* application and the *xflights* service it consumes lives in the [*@capire/xtravels*](https://github.com/capire/xtravels) sample.
+
+A queued call changes *when* work happens and *what the caller can expect back*:
+
+- A **direct** call returns the remote service's result (or error) before the local transaction commits.
+- A **queued** call writes the message to the queue inside the local transaction and returns. The actual remote dispatch happens after commit, in the background.
+
+> [!warning] Queued calls discard the direct return value
+> A queued service persists the request and returns after the message is stored, not after the remote operation finishes. Any return value from `send()` or `run()` is therefore not available to the caller. To act on the outcome, register a [callback handler](#callbacks) on `#succeeded` or `#failed`.
+
+To get the original synchronous service from a queued proxy:
+
+::: code-group
+```js [Node.js]
+const xflights = cds.unqueued(qd_xflights)
+```
+```java [Java]
+CqnService xflights = OutboxService.unboxed(outboxedXFlights);
+```
+:::
+
+
+### By Configuration
+
+ > [!note] Node.js only
+ > Outboxing required services by configuration is available in Node.js only.
+
+To outbox a required service centrally, without touching handler code, set a flag on its configuration. Every call from your handlers is then queued automatically.
+
+::: code-group
+```json [Node.js - package.json]
+{
+ "cds": {
+ "requires": {
+ "messaging": {
+ "outboxed": true
+ }
+ }
+ }
+}
+```
+:::
+
+This is the typical setup for **technical services**, such as messaging and audit logging, where every emit must be durable. CAP enables it by default for those services (see [*Auto-Outboxed Services*](#auto-outboxed-services) below).
+
+For **business services**, however, a class-level flag is usually too coarse. Remote integrations called from domain handlers typically need *some* calls outboxed, for example, the post-commit notification to *xflights*, while others stay synchronous (a read-through query, a probe before commit). For finer control, prefer the programmatic path with `cds.queued()` or `srv.schedule()`.
+
+
+### Auto-Outboxed Services
+
+Some services are outboxed automatically, so you don't need to wrap or configure them:
+
+| Service | Description |
+|---------|-------------|
+| `cds.MessagingService` | All messaging services |
+| `cds.AuditLogService` | Audit log events |
+
+This ensures that messaging and audit log events are sent reliably and never lost because of transaction rollbacks. They use the persistent queue by default.
+
+[Learn more about auto-outboxed services in Node.js.](../../node.js/event-queues#queueing-a-service){.learn-more}
+[Learn more about auto-outboxed services in Java.](../../java/event-queues#default-outbox-services){.learn-more}
+
+
+### Callbacks