AWS Lambda + Fargate Hybrid Architecture: 2026 Decision Guide

Q: What is the rule of thumb for choosing between Lambda and Fargate?

If a workload runs sustained at 1 vCPU-equivalent of utilisation or more on a 24×7 basis, Fargate is cheaper. If it is sporadic with average utilisation below 25 per cent of a vCPU, Lambda is cheaper. The band between 25 per cent and 100 per cent is where hybrid routing wins. Numerically: a single 1 vCPU / 2 GB Fargate task in us-east-1 costs roughly $60 per month, which is the cost of about 18 million 200ms / 1 GB Lambda invocations. So below roughly 7 RPS sustained for that workload shape, Lambda wins; above it, Fargate wins. The arithmetic shifts with request duration and memory footprint — a 5-second request at 4 GB memory hits the Fargate-cheaper threshold at only 200,000 requests per month because Lambda is paying for memory and time linearly while Fargate amortises memory across all concurrent requests on the task.

Q: How big a problem are Lambda cold starts in 2026?

Cold starts are dramatically improved from 2020 but are not eliminated. A typical Node.js Lambda with no provisioned concurrency cold-starts in 200-600ms, which is acceptable for many APIs. A Python Lambda with heavy ML imports (numpy, transformers) cold-starts in 2-8 seconds even with SnapStart, which is acceptable for batch but problematic for synchronous user-facing APIs. A JVM Lambda without SnapStart cold-starts in 3-10 seconds. Provisioned concurrency removes cold starts but reintroduces idle billing — at $0.000004 per provisioned-concurrency-second, holding 100 instances warm 24×7 costs roughly $1,000 per month per GB of memory before any actual invocations. The pragmatic position is: provisioned concurrency for a small number of latency-critical endpoints, on-demand for everything else, and Fargate for any workload where cold starts are a recurring source of pain. SnapStart for Node.js has been signalled by AWS but is not generally available in 2026.

Q: Can Fargate run AI inference workloads?

Fargate runs CPU-bound AI inference well — a quantised 1-7B parameter LLM, embedding generation, classical ML models, computer vision on CPU all work fine on Fargate with appropriate memory allocation (typically 8-16 GB) and the model loaded once at task start. The big gap in 2026 is GPU support: Fargate does not offer GPU instance types, and AWS has signalled but not delivered GPU on Fargate. For GPU inference the correct landing zone is ECS-on-EC2 with G or P instances, EKS with GPU node groups, SageMaker for managed serving, or Bedrock for foundation-model inference as a service. Some teams use Fargate as the API layer (request validation, authentication, response shaping) with the GPU inference offloaded to a separate ECS-on-EC2 service called over a private endpoint — this preserves the Fargate operational model for the bulk of the application while accommodating the GPU workload where it must run.

Q: How does the hybrid routing pattern actually work?

The cleanest implementation uses an Application Load Balancer with multiple target groups: one or more Fargate target groups for the hot, sustained-traffic paths (typically the home page, the catalog, search, the cart, checkout) and a Lambda target group for the cold, sporadic paths (admin endpoints, settings, reports, webhook receivers, OAuth callbacks). ALB routing rules direct each request to the appropriate target group based on URL path, host header, or HTTP method. The same NestJS application is deployed to both runtimes — a Fargate container that runs the Nest app directly, and a Lambda package that wraps the Nest app with serverless-express. Event sources that arrive natively (S3, SQS, EventBridge schedules) go directly to Lambda. Multi-step workflows that mix quick Lambda steps and long-running Fargate steps are orchestrated by Step Functions, which has native states for both Lambda invocations and ECS Run-Task. The ALB carries about $20-50/month of fixed cost, which is recovered the moment the cold-path Lambda offload saves more than that.

Q: How do I deploy the same NestJS application to both Lambda and Fargate?

A single NestJS source tree produces two CI artefacts: a container image (built via a standard Dockerfile, runs node dist/main.js, deployed to ECR for Fargate) and a Lambda package (the same compiled output wrapped with @vendia/serverless-express or @codegenie/serverless-express, deployed to S3 or as a Lambda container image). The Lambda handler bootstraps the Nest app once on cold start and reuses it across warm invocations — typically 30-50 lines of glue code alongside the standard main.ts. The same controllers, services, modules, DTOs, guards, interceptors, and pipes are used by both runtimes. The only deployment-specific bits are: configuration source (env vars vs Secrets Manager), database connection strategy (direct pool for Fargate, RDS Proxy in front of Lambda to absorb connection churn), and observability initialisation. Bundle size and module-loading cost matter on Lambda — use esbuild rather than tsc, prune unused dependencies aggressively, lazy-load heavy modules where possible. The CI pipeline deploys both artefacts on every commit; the ALB routing rules decide which artefact serves which traffic.

Q: What does the Lambda + Fargate hybrid actually cost for a real API?

For a representative API at 50 million requests/month, 250ms average duration, 512 MB average memory, with 80% of traffic on five hot endpoints and 20% on the long-tail cold endpoints, in us-east-1 in 2026: all-Lambda on-demand costs roughly $1,750/month; all-Fargate with 8 sustained tasks costs roughly $480/month; all-Fargate auto-scaled (4-12 tasks) costs roughly $420/month; hybrid with Fargate for hot paths and Lambda for cold paths costs roughly $310/month; hybrid auto-scaled (Fargate 3-8 tasks plus Lambda for cold) costs roughly $280/month. The hybrid is about 84% cheaper than all-Lambda and 33% cheaper than all-Fargate auto-scaled for this traffic shape. At 5 million requests/month with the same shape, Lambda-only becomes the cheapest. At 500 million/month, all-Fargate becomes competitive again. The hybrid wins in the broad middle band that contains most production APIs. ALB ($20-50/month), CloudWatch Logs ($5-15/month), and possibly NAT Gateway ($30-100/month if Lambda needs VPC access) are the additional fixed costs that sit on top of compute.

Q: How do I observe a hybrid Lambda + Fargate architecture?

Trace propagation across runtimes is the highest-leverage observability investment. AWS X-Ray, OpenTelemetry to a collector, Datadog APM, Honeycomb, or New Relic all propagate trace context from ALB through Fargate through Lambda through Step Functions, giving one trace ID per request across all hops. Without it, the on-call engineer reads three log streams (Lambda per-function, Fargate per-service, ALB access logs in S3) and tries to correlate by timestamp and request ID — the unhappy path. Ship all logs to a single backend with a consistent JSON schema including trace ID, runtime tag (lambda/fargate), service name, request ID. Application-level metrics (request rate, error rate, p50/p95/p99 latency per endpoint) should be runtime-agnostic and aggregated per service rather than per runtime. Cost observability is its own discipline: a Lambda function whose runtime drifts from 100ms to 2 seconds doubles its cost invisibly to latency monitoring; CloudWatch Lambda Insights, Container Insights for Fargate, and weekly Cost Explorer review with month-over-month threshold alerts catch this before it becomes a quarterly bill surprise.

Q: When does the hybrid pattern not make sense?

Three cases where the hybrid is overkill or wrong. First, pure event-driven workloads with no synchronous API surface — a pipeline that consumes from SQS, processes, and writes to S3 or DynamoDB has no need for an ALB or for Fargate; Lambda handles it natively, scales on demand, costs nothing when idle. Second, single-tenant or internal workloads with very predictable, sustained, low-volume traffic — an internal tool with 50-100 active users producing 0.5 RPS sustained is cheaper as a single Fargate task than as Lambda with provisioned concurrency, and the hybrid complexity is unjustified. Third, GPU-bound AI inference — neither Lambda nor Fargate has GPU in 2026, so the hybrid choice is irrelevant; the answer is ECS-on-EC2 GPU, EKS with GPU node groups, SageMaker, or Bedrock. The hybrid earns its keep when traffic is variable, the hot/cold split is meaningful, and the cost arithmetic on at least one of the single-runtime options becomes painful. For a typical mid-sized public API in 2026, that is most of the time.