From Kong-on-K8s to AWS Serverless in 24 Hours: Building a Production‑Grade API Platform

Druhin Dhavala — Thu, 12 Feb 2026 11:25:21 +0000

I’ve spent years in the API platform world — Apigee, Kong, hybrid gateways, multi‑DC deployments, modernization programs, and platform rescues. But this week, I decided to do something different:

Rebuild an entire API platform on AWS — from scratch — in under 24 hours.

Not a demo.
Not a tutorial.
A production‑grade platform with:

API Gateway v2
Lambda
Terraform IaC
CloudWatch Golden Signals
k6 performance testing
real JSON business logic
alarms, dashboards, and cost controls

The result:

2.9k req/min sustained throughput
120ms p95 latency
$0.01/day serverless economics
Zero‑drift Terraform
Fully observable, fully automated, fully validated

This wasn’t a “hello world” experiment.
It was a full platform build.

Why I moved from Kong-on-K8s to AWS Serverless (for this POC)
I’ve built and operated large-scale API platforms on:

Kong (K8s, hybrid, multi‑cluster)
Apigee OPDK
Apigee Hybrid
Apigee X
Gravitee
Custom gateways

They’re powerful — but they come with:

cluster management
upgrades
patching
scaling policies
ingress complexity
cost overhead
operational drag

For this POC, I wanted to see:

What happens when you remove all of that?
What happens when the gateway is the platform?

AWS API Gateway + Lambda answered that question fast.

Architecture Overview
The platform includes:

API Gateway v2 (HTTP APIs)
Lambda (Node.js backend)
Terraform (IaC, modules, zero drift)
CloudWatch (metrics, dashboards, alarms)
k6 (load testing)
IAM (least privilege)

Endpoints:

Code
/api/orders
Returns JSON business logic with consistent performance under load.

Performance Results
Using k6 (50 VUs):

2.9k requests/min
120ms p95 latency
0 errors
Stable concurrency
No cold start issues

This is production‑grade performance with almost no operational overhead.

Cost Profile
This is the part that surprised me most.

$0.01/day.
Not a typo.
API Gateway + Lambda + CloudWatch + logs + alarms — all in pennies.

This is the kind of economics that changes how you think about platform design.

Lessons Learned

Serverless removes 80% of platform overhead No clusters. No ingress. No autoscaling configs. No patching. No node pools.

Just APIs.

Terraform + API Gateway is a clean combination
The IaC story is far simpler than K8s CRDs, Helm charts, or hybrid gateway configs.
Observability is built-in
CloudWatch Golden Signals gave me everything I needed:

latency
errors
duration
concurrency
throttles

Load testing serverless is fun
k6 + API Gateway is a great combo.
You see the platform scale instantly.
Cost is a superpower
When your platform costs pennies, you design differently.

What’s Next
This is just the beginning.

Next steps include extending this blueprint into:

Azure API Management
GCP Apigee X

The goal:
A multi‑cloud API platform reference architecture with:

one API spec
three cloud deployments
cost comparison
latency comparison
governance model
migration strategy

Full Code, IaC, Load Tests, and Screenshots
Everything is open-source here:

👉 GitHub:

https://github.com/ddruhin/cloud-native-api-platform

If you’re working on API modernization, serverless platforms, or multi‑cloud strategy, feel free to reach out or fork the repo.

DEV Community: Druhin Dhavala

From Kong-on-K8s to AWS Serverless in 24 Hours: Building a Production‑Grade API Platform