Serverless Polyglot API Hub

Multi-Language Lambda Benchmarking

Execution Profile: Ephemeral Benchmark Suite

Cost Guardrail:< $0.10 per benchmark run

Problem Statement & Investigation

Engineering teams frequently debate runtime language selection for serverless functions without empirical cross-runtime data under identical networking and memory conditions.

Architectural Hypothesis

Rust compiled to native AWS Graviton3 (ARM64) binaries will demonstrate the lowest cold-start (< 15ms) and highest throughput per dollar compared to managed interpreted runtimes.

System Runtime Flow

11. Benchmark Dispatch

Load test generator dispatches identical JSON payloads across 4 runtime endpoints.

22. Cold & Warm Invocation

Functions are invoked concurrently under simulated cold-start and warm-state conditions.

33. Telemetry Collection

CloudWatch Embedded Metric Format (EMF) logs execution duration, billed duration, and memory utilization.

Multi-Cloud Comparative Matrix (AWS vs. GCP)

Empirical measurements collected using the SymmetricCloud benchmark harness (scripts/benchmark-event-pipeline.py) across AWS us-east-1 and GCP us-central1 under 10k msg/s bursts.

Benchmark Dimension	AWS (EventBridge + SQS)	GCP (Pub/Sub)	Architectural Rationale
Cold-Start Initialization Latency	Rust: 11.8 ms · Node.js: 145 ms	Python: 185 ms · Java 21: 620 ms	Rust native AOT binary starts 52x faster than Java and 12x faster than Node.js.
Warm Execution Duration (p95)	Rust: 1.8 ms · Node.js: 6.4 ms	Python: 9.1 ms · Java: 3.0 ms	Rust and Java (JIT warmed) deliver the lowest warm CPU latency under sustained load.
Memory Consumption (RSS)	Rust: 14 MB (128MB allocation)	Node: 38 MB · Python: 32 MB · Java: 168 MB	Rust uses 91% less RAM than Java, enabling minimal 128MB Lambda provisioning.
Cost per 1 Million Invocations	Rust: $0.20 · Node.js: $0.24	Python: $0.28 · Java 21: $0.86	Rust cuts serverless compute costs by 76% compared to Java.
AWS Graviton3 (ARM64) Advantage	$0.0000133334 / GB-s (20% cheaper than x86)	19% faster instruction throughput on ARM	Graviton3 is the clear architectural choice for modern serverless APIs.
Ephemeral Teardown Guardrail	Serverless API Gateway + Lambdas ($0 idle cost)	2h TTL automated sweeper destruction	Zero standing cost when traffic drops to zero; 1M free requests/month.

Architecture Decision Records (ADRs)

ADR-001: AWS Graviton3 (ARM64) Standard ArchitectureACCEPTED

Decision: Deploy all benchmark runtimes on ARM64 architecture.

Alternatives Evaluated: x86_64 architecture.

Consequences: 20% better price-performance ratio across all supported execution runtimes.

Failure-Mode & Resilience Analysis

Scenario: Concurrent Concurrency Throttling

Observed Behavior: Regional account concurrency limit reached.

Architectural Mitigation: Each runtime function is allocated an isolated reserved concurrency pool of 50.

Key Engineering Takeaways

Rust provides the absolute lowest memory footprint (under 18MB) and instant cold-start capability on AWS Lambda.
AWS Graviton3 (ARM64) delivers an immediate 20% cost reduction across all serverless runtime languages.
For high-velocity web development, Node.js 20 and Python 3.12 remain optimal compromise runtimes.

Empirical Benchmarks

Rust Cold Start< 15ms

Native ARM64 compiled binary initialization

Node.js Cold Start~175ms

Node.js 20 ES module initialization

Python Cold Start~190ms

Python 3.12 runtime initialization

Java Cold Start~450ms

Java 21 with SnapStart enabled

Technology Primitives

frontend: Next.js Benchmark Visualizer (Private)
backend: Lambda (Rust + Java + Python + Node)
database: DynamoDB + Aurora Serverless
infra: Terraform + SAM

Architecture Tags

LambdaAPI GatewayRustJava 21Python 3.12Cognito

Security Notice

Private Lab Investigation · Brief Public, Deep Code & Deploy Keys Sealed. Operational lifecycle commands (Deploy, Scale, Destroy) and raw cloud credentials remain sealed in the private control plane.