---
title: "Operating Serverless APIs: Cold Starts, Idempotency, and Asynchronous Handoffs - API7.ai"
description: "Design serverless API paths that bound cold-start latency, preserve idempotency, and distinguish accepted asynchronous work from completed outcomes."
url: "https://api7.ai/learning-center/api-gateway-guide/operating-serverless-apis-gateway"
---

[Skip to article](#column-content)

Column contentsAPI Gateway Guide

[API Gateway Guide](https://api7.ai/learning-center/api-gateway-guide)

Search this column

01 Gateway Fundamentals

[View this topic · 10](https://api7.ai/learning-center/api-gateway-guide?topic=fundamentals)[1. What Is an API Gateway? API Gateway Software and Use Cases](https://api7.ai/learning-center/api-gateway-guide/what-is-an-api-gateway)[2. Why Do Modern Architectures Need an API Gateway?](https://api7.ai/learning-center/api-gateway-guide/why-do-modern-architectures-need-api-gateway)[3. Reverse Proxy vs Load Balancer vs API Gateway](https://api7.ai/learning-center/api-gateway-guide/api-gateway-vs-reverse-proxy-vs-load-balancer)[4. API Gateway and Microservices: Decoupling and Traffic Management](https://api7.ai/learning-center/api-gateway-guide/api-gateway-and-microservices)[5. Understanding Core API Gateway Features](https://api7.ai/learning-center/api-gateway-guide/core-api-gateway-features)[6. Open Source vs. Commercial API Gateways: How to Choose the Right One?](https://api7.ai/learning-center/api-gateway-guide/open-source-vs-commercial-api-gateway)[7. API Gateway vs Service Mesh: How to Choose?](https://api7.ai/learning-center/api-gateway-guide/api-gateway-vs-service-mesh)[8. Envoy vs NGINX, Java, and Go for API Gateways](https://api7.ai/learning-center/api-gateway-guide/nginx-vs-envoy-vs-java-vs-go)[9. Core Concepts of API Gateway: Service, Route, Upstream, Plugin, and Consumer](https://api7.ai/learning-center/api-gateway-guide/core-concepts-of-api-gateway)[10. API Gateway Comparison: Apache APISIX vs. Kong vs. Traefik vs. KrakenD vs. Tyk](https://api7.ai/learning-center/api-gateway-guide/api-gateway-comparison-apisix-kong-traefik-krakend-tyk)

02 Gateway Architecture and Design

[View this topic · 10](https://api7.ai/learning-center/api-gateway-guide?topic=architecture)[11. Deep Dive into API Gateway Architecture: Core Components and Design Principles](https://api7.ai/learning-center/api-gateway-guide/api-gateway-architecture)[12. Choosing the Right API Gateway for Your Architecture](https://api7.ai/learning-center/api-gateway-guide/api-gateway-monolithic-vs-microservices)[13. How to Architect an API Gateway for High Availability (HA)?](https://api7.ai/learning-center/api-gateway-guide/api-gateway-high-availability)[14. API Gateway Plugin Architecture: How to Extend and Customize Your API Gateway](https://api7.ai/learning-center/api-gateway-guide/api-gateway-plugin-system)[15. How Event-Driven Architecture (EDA) Works with API Gateway?](https://api7.ai/learning-center/api-gateway-guide/api-gateway-event-driven-architecture)[16. API Gateway Request Lifecycle Explained](https://api7.ai/learning-center/api-gateway-guide/api-gateway-request-lifecycle-explained)[17. Cloud-Native API Gateway on Kubernetes](https://api7.ai/learning-center/api-gateway-guide/cloud-native-api-gateway-kubernetes)[18. API Gateway Control Plane vs. Data Plane](https://api7.ai/learning-center/api-gateway-guide/api-gateway-control-plane-vs-data-plane)[19. How API Gateways Work with GitOps: Automating API Management](https://api7.ai/learning-center/api-gateway-guide/api-gateway-gitops-integration)[20. How to Perform A/B Testing and Canary Releases with an API Gateway](https://api7.ai/learning-center/api-gateway-guide/ab-testing-canary-release-api-gateway)

03 Gateway Setup and Traffic Handling

[View this topic · 10](https://api7.ai/learning-center/api-gateway-guide?topic=traffic-protocols)[21. How to Deploy an API Gateway on Kubernetes: Step-by-Step Guide for Engineers](https://api7.ai/learning-center/api-gateway-guide/deploy-api-gateway-on-kubernetes)[22. Hands-on Setup with Apache APISIX API Gateway](https://api7.ai/learning-center/api-gateway-guide/api-gateway-getting-started-guide)[23. API Gateway Auth: OAuth 2.0, JWT & OIDC with APISIX](https://api7.ai/learning-center/api-gateway-guide/api-gateway-authentication-apache-apisix-oauth-jwt-oidc)[24. Mastering Traffic Control: Efficiently Managing API Requests with Gateways](https://api7.ai/learning-center/api-gateway-guide/api-gateway-traffic-control-strategies)[25. Building Reliable API Gateways with Logging and Monitoring](https://api7.ai/learning-center/api-gateway-guide/api-gateway-logging-monitoring-best-practices)[26. Dynamic Routing in API Gateways: Best Practices for Flexible Traffic Management](https://api7.ai/learning-center/api-gateway-guide/api-gateway-dynamic-routing-management)[27. How API Gateways Support WebSocket](https://api7.ai/learning-center/api-gateway-guide/how-api-gateways-support-websocket)[28. API Gateway for GraphQL: Security, Cost, and Caching](https://api7.ai/learning-center/api-gateway-guide/api-gateway-handle-graphql)[29. How API Gateways Handle HTTP/3 QUIC Requests](https://api7.ai/learning-center/api-gateway-guide/api-gateway-http3-quic)[30. How API Gateways Handle MQTT Requests](https://api7.ai/learning-center/api-gateway-guide/api-gateway-mqtt)

04 Gateway Integrations, AI, and MCP

[View this topic · 10](https://api7.ai/learning-center/api-gateway-guide?topic=ai-mcp)[31. How API Gateways Handle gRPC Requests](https://api7.ai/learning-center/api-gateway-guide/api-gateway-grpc-support)[32. How API Gateways Implement Custom Plugins](https://api7.ai/learning-center/api-gateway-guide/api-gateway-custom-plugins)[33. How API Gateways Integrate with Kafka](https://api7.ai/learning-center/api-gateway-guide/api-gateway-kafka-integration)[34. How to Implement API Aggregation in API Gateways](https://api7.ai/learning-center/api-gateway-guide/api-gateway-api-aggregation)[35. How API Gateways Enable Serverless Architecture](https://api7.ai/learning-center/api-gateway-guide/api-gateway-serverless-architecture)[36. How API Gateways Proxy LLM Requests](https://api7.ai/learning-center/api-gateway-guide/api-gateway-proxy-llm-requests)[37. How API Gateways Enhance MCP Servers](https://api7.ai/learning-center/api-gateway-guide/api-gateway-enhance-mcp-server)[38. MCP Gateway vs MCP Proxy vs AI Gateway vs API Gateway](https://api7.ai/learning-center/api-gateway-guide/ai-gateway-vs-mcp-gateway-vs-api-gateway)[39. What Is an AI Gateway? Architecture and Benefits](https://api7.ai/learning-center/api-gateway-guide/what-is-an-ai-gateway)[40. What Is an MCP Gateway? Architecture, Use Cases & How It Works (2026 Guide)](https://api7.ai/learning-center/api-gateway-guide/what-is-mcp-gateway)

05 Gateway Performance

[View this topic · 10](https://api7.ai/learning-center/api-gateway-guide?topic=performance)[41. How API Gateway Reduces Latency: Performance Optimization Strategies](https://api7.ai/learning-center/api-gateway-guide/how-api-gateway-reduces-latency)[42. API Gateway Caching Strategy: Comprehensive Analysis and Implementation Guide](https://api7.ai/learning-center/api-gateway-guide/api-gateway-caching-strategy-analysis)[43. How to Optimize API Gateway Load Balancing: Advanced Strategies and Best Practices](https://api7.ai/learning-center/api-gateway-guide/how-to-optimize-api-gateway-load-balancing)[44. How API Gateway Efficiently Handles Large-Scale Traffic: Architecture and Strategies](https://api7.ai/learning-center/api-gateway-guide/how-api-gateway-handles-large-scale-traffic)[45. How to Improve API Gateway QoS: Traffic Classes, Capacity Protection, and SLOs](https://api7.ai/learning-center/api-gateway-guide/api-gateway-quality-of-service)[46. API Gateway Log Storage: Pipelines, Retention, Security, and Cost](https://api7.ai/learning-center/api-gateway-guide/api-gateway-log-storage)[47. API Gateway Timeouts and Retries: Safe Policies and APISIX Configuration](https://api7.ai/learning-center/api-gateway-guide/api-gateway-timeouts-retries)[48. API Gateway Concurrency Control: Capacity Budgets, Backpressure, and Load Shedding](https://api7.ai/learning-center/api-gateway-guide/api-gateway-concurrency-control)[49. Asynchronous API Gateway Patterns: Queues, Callbacks, and Performance Boundaries](https://api7.ai/learning-center/api-gateway-guide/asynchronous-api-gateway-patterns)[50. API Gateway TLS Performance: Handshakes, Session Reuse, and Measurement](https://api7.ai/learning-center/api-gateway-guide/api-gateway-tls-performance)

06 Gateway Security

[View this topic · 10](https://api7.ai/learning-center/api-gateway-guide?topic=security)[51. DDoS Defense at the API Gateway: Layered Controls and Failure Planning](https://api7.ai/learning-center/api-gateway-guide/api-gateway-ddos-defense)[52. Distributed API Gateway Rate Limiting: Local vs Redis Counters and Accuracy Trade-offs](https://api7.ai/learning-center/api-gateway-guide/distributed-api-gateway-rate-limiting)[53. API Gateway IP Allowlist and Denylist Management: Trust, Proxies, and Operations](https://api7.ai/learning-center/api-gateway-guide/api-gateway-ip-allowlist-denylist-management)[54. API Gateway Security Scanning: What to Test and How to Operationalize Findings](https://api7.ai/learning-center/api-gateway-guide/api-gateway-security-scanning)[55. SQL Injection and XSS at the API Gateway: Detection Limits and Defense in Depth](https://api7.ai/learning-center/api-gateway-guide/sql-injection-xss-api-gateway)[56. API Access Log Auditing: Evidence, Integrity, Retention, and Review](https://api7.ai/learning-center/api-gateway-guide/api-access-log-auditing)[57. Preventing API Scraping and Abuse: Identity, Behavioral Signals, and Rate Controls](https://api7.ai/learning-center/api-gateway-guide/prevent-api-scraping-abuse)[58. API Gateway mTLS: Client Identity, Certificate Rotation, and APISIX Configuration](https://api7.ai/learning-center/api-gateway-guide/api-gateway-mtls)[59. Fine-Grained API Gateway Authorization: RBAC, ABAC, and External Policy Decisions](https://api7.ai/learning-center/api-gateway-guide/fine-grained-api-gateway-authorization)[60. API Gateway and WAF Reference Architecture: Ownership, Header Trust, and Failure Modes](https://api7.ai/learning-center/api-gateway-guide/api-gateway-waf-reference-architecture)

07 Gateway Ecosystem and Comparisons

[View this topic · 10](https://api7.ai/learning-center/api-gateway-guide?topic=ecosystem)[61. Apache APISIX vs Kong: Migration, Operations, and Team Fit](https://api7.ai/learning-center/api-gateway-guide/apache-apisix-vs-kong)[62. Traefik vs Kong vs APISIX: A Reproducible API Gateway Benchmark Method](https://api7.ai/learning-center/api-gateway-guide/traefik-kong-apisix-benchmark-method)[63. Amazon API Gateway Explained: Deployment Models, Trade-offs, and Use Cases](https://api7.ai/learning-center/api-gateway-guide/amazon-api-gateway-explained)[64. API Gateway and Istio: Clear North-South and East-West Boundaries](https://api7.ai/learning-center/api-gateway-guide/api-gateway-istio)[65. API Gateway with NGINX: Layering, Ownership, and Migration Patterns](https://api7.ai/learning-center/api-gateway-guide/api-gateway-nginx)[66. API Gateway with Envoy: Deployment Patterns and Policy Ownership](https://api7.ai/learning-center/api-gateway-guide/api-gateway-envoy)[67. API Gateway with Cloudflare API Shield: Edge and Origin Security Boundaries](https://api7.ai/learning-center/api-gateway-guide/api-gateway-cloudflare-api-shield)[68. Apigee vs MuleSoft vs Amazon API Gateway: A Decision Framework](https://api7.ai/learning-center/api-gateway-guide/apigee-mulesoft-amazon-api-gateway)[69. Should an API Gateway Connect Directly to a Database? Patterns and Risks](https://api7.ai/learning-center/api-gateway-guide/api-gateway-database-access-patterns)[70. API Gateway Architecture for Large-Scale SaaS Platforms](https://api7.ai/learning-center/api-gateway-guide/api-gateway-large-scale-saas-architecture)

08 Industry Applications and Integrations

[View this topic · 10](https://api7.ai/learning-center/api-gateway-guide?topic=applications)[71. API Gateway CI/CD: Validation, Promotion, and Safe Rollback](https://api7.ai/learning-center/api-gateway-guide/api-gateway-ci-cd)[72. API Gateways for AI and ML Inference: Traffic, Security, and Observability](https://api7.ai/learning-center/api-gateway-guide/api-gateways-ai-ml-inference)[73. API Gateway Architecture for Financial Services: Controls and Failure Boundaries](https://api7.ai/learning-center/api-gateway-guide/api-gateway-financial-services)[74. API Gateway Architecture for E-Commerce: Checkout Reliability and Traffic Peaks](https://api7.ai/learning-center/api-gateway-guide/api-gateway-ecommerce)[75. API Gateways for Mobile Applications: Authentication, Payloads, and Versioning](https://api7.ai/learning-center/api-gateway-guide/api-gateways-mobile-applications)[76. API Gateways for Web3 Applications: RPC Traffic, Identity, and Abuse Controls](https://api7.ai/learning-center/api-gateway-guide/api-gateways-web3-applications)[77. OpenAPI-Driven API Gateway Operations: Import, Validation, and Drift Control](https://api7.ai/learning-center/api-gateway-guide/openapi-driven-api-gateway-operations)[78. gRPC-Web and gRPC Transcoding Through an API Gateway](https://api7.ai/learning-center/api-gateway-guide/grpc-web-grpc-transcoding-api-gateway)[79. API Gateway Pricing and Cost Optimization: A Workload-Based Model](https://api7.ai/learning-center/api-gateway-guide/api-gateway-pricing-cost-optimization)[80. Evaluating API Gateway Directions: Evidence and Architectural Impact](https://api7.ai/learning-center/api-gateway-guide/api-gateway-trends)

09 Advanced Gateway Applications

[View this topic · 10](https://api7.ai/learning-center/api-gateway-guide?topic=operations)[81. API Gateways in Zero Trust Architecture: Identity, Policy, and Limits](https://api7.ai/learning-center/api-gateway-guide/api-gateways-zero-trust-architecture)[82. API Gateway Log Analytics: Correlation, Queries, and Operational Signals](https://api7.ai/learning-center/api-gateway-guide/api-gateway-log-analytics)[83. From API Sprawl to Governed Delivery: The Gateway's Role in Modernization](https://api7.ai/learning-center/api-gateway-guide/api-gateway-modernization)[84. API Monetization at the Gateway: Plans, Metering, Entitlements, and Billing Boundaries](https://api7.ai/learning-center/api-gateway-guide/api-monetization-gateway)[85. Safe AI-Assisted API Gateway Optimization: Recommendations, Guardrails, and Approval](https://api7.ai/learning-center/api-gateway-guide/ai-assisted-api-gateway-optimization)[86. API Gateways for Low-Code and No-Code Integration: Governance and Safety](https://api7.ai/learning-center/api-gateway-guide/api-gateways-low-code-no-code-integration)[87. API Gateway and CIAM Integration: Token Validation, Consent, and Identity Context](https://api7.ai/learning-center/api-gateway-guide/api-gateway-ciam-integration)[88. Elastic API Gateway Scaling: Signals, Capacity, and Safe Scale-In](https://api7.ai/learning-center/api-gateway-guide/elastic-api-gateway-scaling)[89. Multi-Tenant SaaS API Gateways: Isolation, Quotas, and Tenant-Aware Policy](https://api7.ai/learning-center/api-gateway-guide/multi-tenant-saas-api-gateway-policy)[90. API Gateway DevSecOps: Policy as Code, Testing, and Runtime Feedback](https://api7.ai/learning-center/api-gateway-guide/api-gateway-devsecops)

10 Platform Engineering and Planning

[View this topic · 10](https://api7.ai/learning-center/api-gateway-guide?topic=platform-governance)[91. API Discovery and Documentation at the Gateway: Inventory, Ownership, and Drift](https://api7.ai/learning-center/api-gateway-guide/api-discovery-documentation-gateway)[92. WebAssembly Plugins for API Gateways: Portability, Isolation, and APISIX Boundaries](https://api7.ai/learning-center/api-gateway-guide/api-gateway-webassembly-plugins)[93. Monitoring API Gateways with Prometheus and Grafana: Metrics, Dashboards, and Alerts](https://api7.ai/learning-center/api-gateway-guide/monitor-api-gateways-prometheus-grafana)[94. API Gateway Reliability Engineering: SLOs, Failure Isolation, and Incident Response](https://api7.ai/learning-center/api-gateway-guide/api-gateway-reliability-engineering)[95. API Gateways for Edge AI Inference: Routing, Constraints, and Observability](https://api7.ai/learning-center/api-gateway-guide/api-gateways-edge-ai-inference)[96. Reducing Cloud Cost with API Gateway Controls: Measurement Before Optimization](https://api7.ai/learning-center/api-gateway-guide/reducing-cloud-cost-api-gateway-controls)[97. Improving API Developer Experience with Gateway Standards and Self-Service](https://api7.ai/learning-center/api-gateway-guide/improving-api-developer-experience-gateway-self-service)[98. API Gateway Change Management: Compatibility, Progressive Delivery, and Rollback](https://api7.ai/learning-center/api-gateway-guide/api-gateway-change-management-rollback)[99. Operating Serverless APIs: Cold Starts, Idempotency, and Asynchronous Handoffs](https://api7.ai/learning-center/api-gateway-guide/operating-serverless-apis-gateway)[100. Planning an API Gateway Roadmap for the Next Five Years](https://api7.ai/learning-center/api-gateway-guide/planning-api-gateway-roadmap-next-five-years)

[API Gateway Guide](https://api7.ai/learning-center/api-gateway-guide)[Platform Engineering and Planning](https://api7.ai/learning-center/api-gateway-guide?topic=platform-governance)

On this page

On this page

- [Key Takeaways](#key-takeaways)

- [Choose the Interaction Contract First](#choose-the-interaction-contract-first)

- [Separate the Actors](#separate-the-actors)

- [Budget Cold Starts Explicitly](#budget-cold-starts-explicitly)

- [Example: Proxy a Bounded Function Endpoint](#example-proxy-a-bounded-function-endpoint)

- [Design a Durable Asynchronous Handoff](#design-a-durable-asynchronous-handoff)

- [Make Idempotency an Application Invariant](#make-idempotency-an-application-invariant)

- [Understand Cloud Retry Semantics](#understand-cloud-retry-semantics)

- [Handle Synchronous Unknown Outcomes](#handle-synchronous-unknown-outcomes)

- [Observe Every Stage](#observe-every-stage)

- [Serverless API Checklist](#serverless-api-checklist)

- [FAQ](#faq)

  - [Can an API gateway eliminate Lambda cold starts?](#can-an-api-gateway-eliminate-lambda-cold-starts)
  - [Does `202 Accepted` mean the function succeeded?](#does-202-accepted-mean-the-function-succeeded)
  - [Is an idempotency header enough to prevent duplicate effects?](#is-an-idempotency-header-enough-to-prevent-duplicate-effects)

- [Next Steps](#next-steps)

Article 99

# Operating Serverless APIs: Cold Starts, Idempotency, and Asynchronous Handoffs

API7.ai

October 29, 2026

An API gateway can authenticate and bound a serverless request, route it to a function or submission service, and expose a stable client contract. It cannot remove cold starts, make a timed-out invocation safe to repeat, or turn queue acceptance into proof that business work completed.

Design synchronous and asynchronous APIs as different contracts. Synchronous calls need a deadline that includes gateway and function startup. Asynchronous calls need a durable operation identity, status model, duplicate handling, retention policy, and terminal failure path.

## Key Takeaways

- Choose synchronous execution only when the complete latency distribution fits the client deadline.
- Treat a gateway timeout as an unknown outcome if function execution may already have started.
- Put idempotency in the application state transition, not only in a gateway header.
- Return `202 Accepted` only after durable handoff and provide an operation-status contract.
- Separate gateway admission, cloud queue acceptance, function execution, and business completion.
- Test cold, warm, throttled, duplicate, expired, and replayed requests.

## Choose the Interaction Contract First

| Contract                | Client receives                                    | Use when                                                     | Main failure to design                         |
| ----------------------- | -------------------------------------------------- | ------------------------------------------------------------ | ---------------------------------------------- |
| Synchronous             | Final operation response                           | Work reliably finishes inside the total deadline             | Timeout after execution began                  |
| Asynchronous submission | Operation ID and status location                   | Work is long-running, bursty, or retryable in the background | Accepted but later failed or expired           |
| Event ingestion         | Acknowledgement that an event entered the platform | Producer does not need a request-correlated result           | Duplicate delivery and ordering                |
| Callback or webhook     | Later result pushed to consumer                    | Consumer can authenticate callbacks and handle retries       | Spoofed, duplicated, or undeliverable callback |

Do not hide a long-running synchronous function behind a larger gateway timeout. That consumes client, gateway, and function capacity while making recovery ambiguous.

## Separate the Actors

```
flowchart LR
    C[Authenticated client] --> G[API gateway]
    G -->|short synchronous request| F[Function endpoint]
    G -->|validated submission| S[Submission service]
    S -->|durable enqueue| Q[Managed queue or event service]
    Q --> W[Function worker]
    W --> D[Idempotent state transition]
    D --> O[Operation status store]
    C -->|poll operation ID| G
    G --> O
    F -. execution result .-> G
    Q -. acceptance and delivery evidence .-> M[Operations telemetry]
    W -. execution and terminal outcome .-> M
```

The gateway admits and routes. The submission service owns durable enqueue and operation creation. The queue or cloud service decides delivery. The function executes. The application state store decides whether a duplicate changes state. Keep these responsibilities distinct in prose, metrics, and incident response.

## Budget Cold Starts Explicitly

A cold invocation may include environment allocation, runtime initialization, dependency loading, network setup, and application initialization before handler work begins. Measure each function version with production-like package size, memory, networking, region, and dependencies.

For a synchronous route, budget:

```
client deadline > gateway processing + connection + platform queue/startup + function execution + response transfer + recovery margin
```

Provisioned concurrency can prepare AWS Lambda execution environments ahead of invocation, but it adds cost and can spill over when demand exceeds the provisioned level. Pin callers to the version or alias that owns the provisioned capacity; invoking another version does not use that pool. Treat this as a measured latency/cost choice, not a promise that every request is warm.

## Example: Proxy a Bounded Function Endpoint

Apache APISIX 3.19.0's pinned [`aws-lambda` plugin source](https://github.com/apache/apisix/blob/3.19.0/apisix/plugins/aws-lambda.lua) uses the shared [`generic-upstream` implementation](https://github.com/apache/apisix/blob/3.19.0/apisix/plugins/serverless/generic-upstream.lua) to call a configured function URL or API endpoint. The following Route body is a runnable-shape example; replace the placeholder URI and configure cloud authentication through an approved secret path.

```
{
  "uri": "/reports/preview",
  "plugins": {
    "aws-lambda": {
      "function_uri": "https://example-id.lambda-url.us-east-1.on.aws/preview",
      "timeout": 2500,
      "max_req_body_size": 1048576,
      "ssl_verify": true,
      "keepalive": true,
      "keepalive_timeout": 60000,
      "keepalive_pool": 20
    }
  }
}
```

The plugin buffers the request body up to `max_req_body_size`; a body-read error, including an oversized body, returns HTTP 400. If the upstream request itself fails, the generic implementation returns HTTP 503. A function response with status 400 or above is passed through rather than automatically retried by this plugin path.

Its behavior-changing Booleans are explicit:

| Parameter    | Default | `true` path                                                            | `false` path and trust boundary                                                                            |
| ------------ | ------- | ---------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------- |
| `ssl_verify` | `true`  | Verifies the TLS server certificate for `function_uri`                 | Disables server-certificate verification; encryption alone no longer proves the intended endpoint identity |
| `keepalive`  | `true`  | Reuses eligible upstream connections and applies pool/timeout settings | Does not reuse the connection; pool settings do not apply                                                  |

The plugin source also preserves a caller-supplied `Authorization` or `x-api-key` header instead of overwriting it with configured cloud authorization. Strip or reject untrusted client cloud-credential headers before this plugin, or prove that passing them is the intended contract. Do not let the caller select `function_uri`, region, or cloud service.

This proxy path is still synchronous HTTP from APISIX's perspective. It does not by itself create a durable asynchronous operation.

## Design a Durable Asynchronous Handoff

A safe submission sequence is:

1. authenticate the caller and map it to server-side policy;
2. validate payload size, schema, and operation type;
3. require or issue a stable idempotency key;
4. create an operation record with a unique ID;
5. durably enqueue the work and commit the accepted state;
6. return `202 Accepted` with the operation ID and status URL;
7. process the message idempotently;
8. write a terminal success or failure state;
9. expire payload and status data under a documented retention policy.

If operation creation and queue publication cannot be atomic, use a transactional outbox or another recovery design. Do not return `202` after merely starting an in-memory task.

Example response:

```
HTTP/1.1 202 Accepted
Content-Type: application/json
Location: /operations/op_01JEXAMPLE
Retry-After: 3

{"operation_id":"op_01JEXAMPLE","status":"accepted"}
```

`accepted` means the platform durably accepted responsibility under the stated retention and retry contract. It does not mean the function ran or the business action succeeded.

## Make Idempotency an Application Invariant

An idempotency key is useful only when the application binds it to:

- authenticated caller or tenant;
- operation type and canonical request fingerprint;
- stored result or terminal state;
- retention window;
- conflict behavior when the same key carries a different payload.

The gateway may validate presence and format, but the state-changing service must atomically enforce the key with the business transition. A caller-supplied key is a correlation value, not trusted identity. Namespace it with authenticated context.

For a duplicate request, return the original operation or result when the fingerprint matches. Return a conflict when the same key is reused for different work. Test concurrent duplicates, not only sequential retries.

## Understand Cloud Retry Semantics

For AWS Lambda Event Functions, [asynchronous invocation](https://docs.aws.amazon.com/lambda/latest/dg/invocation-async.html) queues the event and returns `202` when Lambda accepts it. AWS documents that function errors are retried twice by default, while throttling and system errors may be retried for up to six hours by default. The queue is eventually consistent, so duplicate delivery is possible even without a function error.

These are Lambda service semantics, not APISIX plugin enforcement. Configure maximum event age, retries, and an on-failure destination or dead-letter path for the selected function. Keep the handler idempotent even when retries are reduced.

## Handle Synchronous Unknown Outcomes

When the gateway times out, ask whether the function could still be running or could have committed a side effect. If yes, the result is ambiguous. Do not automatically replay a payment, message, or provisioning request without an idempotency invariant and status lookup.

Return an operation identifier early when the workflow can outlive the connection. For genuinely synchronous operations, keep the total retry budget inside the client deadline and retry only when the method and application semantics permit it.

## Observe Every Stage

Track separately:

- gateway admits, rejects, timeouts, and upstream statuses;
- submission acceptance and enqueue latency;
- queue age, backlog, redelivery, and expiry;
- cold/warm initialization and function duration;
- concurrency throttling and provider errors;
- idempotency hits, conflicts, and duplicate suppression;
- business success, failure, and ambiguous state;
- callback attempts and terminal delivery.

Use bounded labels such as API, operation type, function alias, environment, and terminal status. Keep request IDs, user IDs, and idempotency keys out of Prometheus labels; store them in access-controlled logs or traces when policy permits.

## Serverless API Checklist

- Is the API explicitly synchronous, asynchronous, event-based, or callback-based?
- Does the total synchronous deadline include cold startup and recovery margin?
- Can a timeout occur after side effects begin, and how is that ambiguity resolved?
- Is durable handoff complete before returning `202 Accepted`?
- Is the idempotency key namespaced by authenticated identity and request fingerprint?
- Are queue retries, duplicate delivery, expiry, and terminal failure configured and tested?
- Are `ssl_verify` and `keepalive` defaults and both paths documented?
- Are untrusted client cloud-authorization headers stripped or intentionally accepted?
- Can operators correlate gateway, queue, function, and business outcomes?
- Does rollback preserve compatible function aliases, event schemas, credentials, and status records?

## FAQ

### Can an API gateway eliminate Lambda cold starts?

No. It can keep upstream connections warm and route to a prepared alias, but execution-environment readiness belongs to the serverless platform and function configuration.

### Does `202 Accepted` mean the function succeeded?

No. It means the chosen submission boundary accepted the work. Provide a status contract and terminal failure path.

### Is an idempotency header enough to prevent duplicate effects?

No. The application must atomically bind the key to authenticated context, request meaning, and the business state transition.

## Next Steps

Apply [safe timeout and retry policy](https://api7.ai/learning-center/api-gateway-guide/api-gateway-timeouts-retries), design [asynchronous gateway patterns](https://api7.ai/learning-center/api-gateway-guide/asynchronous-api-gateway-patterns), and deliver changes through [gateway change management](https://api7.ai/learning-center/api-gateway-guide/api-gateway-change-management-rollback).

[Previous article**API Gateway Change Management: Compatibility, Progressive Delivery, and Rollback**](https://api7.ai/learning-center/api-gateway-guide/api-gateway-change-management-rollback)[Next article**Planning an API Gateway Roadmap for the Next Five Years**](https://api7.ai/learning-center/api-gateway-guide/planning-api-gateway-roadmap-next-five-years)

On this page

- [Key Takeaways](#key-takeaways)

- [Choose the Interaction Contract First](#choose-the-interaction-contract-first)

- [Separate the Actors](#separate-the-actors)

- [Budget Cold Starts Explicitly](#budget-cold-starts-explicitly)

- [Example: Proxy a Bounded Function Endpoint](#example-proxy-a-bounded-function-endpoint)

- [Design a Durable Asynchronous Handoff](#design-a-durable-asynchronous-handoff)

- [Make Idempotency an Application Invariant](#make-idempotency-an-application-invariant)

- [Understand Cloud Retry Semantics](#understand-cloud-retry-semantics)

- [Handle Synchronous Unknown Outcomes](#handle-synchronous-unknown-outcomes)

- [Observe Every Stage](#observe-every-stage)

- [Serverless API Checklist](#serverless-api-checklist)

- [FAQ](#faq)

  - [Can an API gateway eliminate Lambda cold starts?](#can-an-api-gateway-eliminate-lambda-cold-starts)
  - [Does `202 Accepted` mean the function succeeded?](#does-202-accepted-mean-the-function-succeeded)
  - [Is an idempotency header enough to prevent duplicate effects?](#is-an-idempotency-header-enough-to-prevent-duplicate-effects)

- [Next Steps](#next-steps)
