A 30-minute live demo of how AWS infrastructure carries a single HTTP packet from a client all the way through CloudFront → ALB → ECS Fargate → RDS MySQL — with realistic regional latency, full Terraform IaC, and a Jupyter notebook narrating the whole journey.
Built to teach fullstack developers what cloud actually does, beneath the marketing — by deploying a real (small) stack and watching a request light up each layer in turn.
A working multi-tier AWS deployment that demonstrates:
- Packet journey tracking end-to-end: client → CloudFront CDN → Application Load Balancer → ECS Fargate → RDS MySQL.
- Regional latency simulation from a single client perspective — measured against AWS regions in Bahrain, Frankfurt, Virginia, and Oregon.
- Interactive HTML visualisation of each hop with timing data.
- Full IaC — every piece is in Terraform; no manual console clicks.
- Test coverage: 24/24 integration tests passing — the journey is repeatable.
┌──────────────┐
Client ──HTTPS──► │ CloudFront │ ──► ALB ──► ECS ──► RDS
└──────────────┘ (Fargate) (MySQL)
| Slot | What happens |
|---|---|
| 0–9 min | Concept walkthrough (slides + notebook intro) — what each AWS service does and why it matters |
| 9–30 min | Live deployment + traffic — terraform apply, hit the /api/journey endpoint, watch the visualisation light up each AWS hop with real timings |
Cost: ~$2–5 for a few hours of usage. terraform destroy cleans everything up.
| Layer | Stack |
|---|---|
| Frontend (demo UI) | Interactive HTML + JS, embedded in the Express app |
| Application | Node.js + Express, Docker-packaged |
| Data | Amazon RDS (MySQL 8) |
| Compute | ECS on Fargate |
| Edge / CDN | CloudFront |
| Load balancing | Application Load Balancer (ALB) |
| IaC | Terraform |
| Notebook | Jupyter (Python 3.8+, AWS CLI v2) |
| Tests | Jest (24 integration tests, Docker-compose'd) |
cloud-demo-stack/
├── dynamic_app/ # The Express + Docker application
│ ├── server.js # Main packet-journey endpoints (~600 LOC)
│ ├── server-local.js # Local-only variant with simulated regional latency
│ ├── __tests__/ # Jest integration tests
│ └── docker-compose.yml # Local stack + test stack
├── terraform/ # Full IaC — CloudFront, ALB, ECS, RDS, networking
│ ├── main.tf
│ ├── variables.tf
│ └── outputs.tf
├── notebooks/ # Jupyter narrative for the 30-min demo
│ ├── cloud_demo_presentation.ipynb
│ └── requirements.txt
├── architecture_diagram.mmd # Mermaid diagram of the full stack
├── storyboard.md # Detailed demo storyboard
├── proof_commands.md # The "prove it's real" AWS CLI commands
├── pre_read_cheatsheet.md # 10-min primer for the audience
└── setup-database.sql # RDS schema + seed data
GET /health— Health check.GET /api/hello— Simple greeting with server info (which container? which region?).GET /api/journey— The full packet journey, with timings per hop.GET /api/trace— Detailed request trace with infrastructure metadata.GET /— The interactive HTML visualisation.
cd dynamic_app
docker-compose up # spins up the app + a local MySQL
curl http://localhost:3000/api/journey # see the journey output
open http://localhost:3000 # the interactive visualisation# 1. Configure AWS CLI (one-time)
aws configure
# 2. Deploy infrastructure
cd terraform
terraform init
terraform apply # ~6–8 minutes; outputs CloudFront URL + RDS endpoint
# 3. Hit the deployed stack
curl https://<cloudfront-domain>/api/journey
# 4. Tear it down (don't forget!)
terraform destroySee terraform/README-CREDENTIAL-MANAGEMENT.md for how DB credentials are passed to the ECS task definition.
The Jupyter notebook notebooks/cloud_demo_presentation.ipynb is the live-demo narrative. It interleaves:
- Slides (markdown cells) explaining each AWS service in plain language.
- Code cells running
terraform apply,aws ecs describe-tasks,aws rds describe-db-instances, etc. - Live URLs that hit the deployed stack and show real latency.
Designed for fullstack developers with no prior cloud experience. The audience leaves understanding why CloudFront + ALB + ECS + RDS is a sensible architecture rather than how to memorise it.
See storyboard.md for the minute-by-minute demo plan, including the "RDS proof" segment where a single aws rds describe-db-instances query reveals the hostname that the running ECS task is using as its DB_HOST.
Roughly $2–5 for a few hours of demo usage (mostly RDS and data transfer). The cleanup step in the storyboard is non-negotiable — run terraform destroy before walking away.
MIT.
Built as a teaching artifact. The constraint that drove the design: a developer who has never opened the AWS console should leave the 30-minute session knowing what each layer does and why it's there.