Scalable Cloud Service Platform (Base)

A simple, extensible base project demonstrating the core building blocks of a scalable cloud service platform:

• Stateless REST API (Node.js + Express) — safe to run many copies of.
• Vertical scaling: Node's cluster module forks one worker per CPU core.
• Horizontal scaling: Docker Compose runs multiple app replicas.
• Load balancing: Nginx distributes traffic across replicas (least-connections).
• Caching layer: in-memory cache (swap for Redis in production) to cut repeated work.
• Health checks: /health and /ready endpoints for container orchestrators and load balancers.
• Centralized error handling & logging (Morgan + Express error middleware).

Project structure

scalable-cloud-platform/
├── app/
│   ├── server.js         # Express API + clustering + caching
│   ├── package.json
│   ├── .env.example
│   └── Dockerfile
├── nginx/
│   └── nginx.conf        # Load balancer config
├── docker-compose.yml     # Orchestrates 3 app replicas + nginx
└── README.md

Run locally (single process, with in-process clustering)

cd app
cp .env.example .env
npm install
npm start

Then visit:

• http://localhost:3000/health
• http://localhost:3000/api/v1/items/1

Run at scale with Docker Compose (horizontal scaling + load balancing)

docker compose up --build --scale app=3

Then hit the load balancer (not the app directly):

• http://localhost:8080/health
• http://localhost:8080/api/v1/items/1

Refresh a few times — you'll see the pid in the JSON response change as Nginx routes you to different app containers, proving requests are being load-balanced across replicas.

Extending this base

• Database: replace fetchItem / createItem in server.js with real calls to Postgres, MongoDB, DynamoDB, etc.
• Shared cache: swap node-cache for Redis so cache is shared across all instances instead of per-process.
• Auth: add JWT/OAuth middleware before your route handlers.
• Message queue: introduce RabbitMQ/Kafka/SQS for async work and to decouple services.
• Kubernetes: this Docker setup maps directly onto a Deployment + Service + Horizontal Pod Autoscaler if you want to move beyond Compose.
• Observability: add Prometheus metrics and structured JSON logging for production monitoring.

Why this counts as "scalable"