Server Survival is an interactive 3D simulation game where you play as a Cloud Architect. Your mission is to build and scale a resilient cloud infrastructure to handle increasing traffic loads while fighting off DDoS attacks, managing your budget, and keeping your services healthy.

Learn cloud by playing:

• Survival — the core experience: survive as long as possible against escalating traffic, DDoS spikes, random events, and service degradation.
• Campaign — 20 hand-crafted levels across 4 chapters (Basics → Optimization → Defense & Mastery → Production Readiness). Each level teaches one architecture concept with pre-built diagrams, objectives, and a debrief.
• Sandbox — a free-play lab: any budget, any traffic mix, no game over. Experiment with all 23 services.

Every mechanic is a real cloud concept in miniature:

• Observability — place a Monitoring node to unlock a live metrics dashboard (RPS, error rate, latency sparklines) and alerts. Level 15 makes you fly blind without it first.
• Auto-scaling & cold start — Compute fleets scale out at 70% utilization and back in at 30%, but new instances need warmup time (Containers even more so).
• Queue-depth scaling — a queue-fed fleet scales on queue pressure, not just CPU, so backlogs trigger scale-out.
• Circuit breaking & retries — overloaded downstreams trip a breaker (50% error rate over a rolling window), traffic is retried with backoff, and SPOFs get flagged.
• Multi-region failover — GeoDNS splits traffic across regional stacks; region-outage events show why one region is never enough.
• OLTP vs OLAP — the Data Warehouse takes analytics writes cheaply but refuses realtime reads; the Relational DB does the opposite trade.
• Failure-reason badges — every dropped request pops a badge on the node that dropped it, saying why (no route, capacity, read-only replica, search-only index...).

Survive as long as possible! Manage your Budget ($), Reputation (%), and Service Health.

• Earn Money by successfully processing legitimate traffic requests.
• Lose Reputation if requests fail or if malicious traffic slips through.
• Maintain Health - Services degrade under load and need repairs.
• Game Over if Reputation hits 0% or you go bankrupt ($-1000).

Build your architecture using the toolbar. All 23 services are organized into five category tabs — the same taxonomy as the table below. Each service has a cost, capacity, and per-minute upkeep:

• Base Upkeep: Each service has per-minute upkeep costs
• Upkeep Scaling: Costs increase 1x to 2x over 10 minutes
• Repair Costs: 15% of service cost to manually repair
• Auto-Repair: +10% upkeep overhead when enabled

The core experience - survive as long as possible against escalating traffic with constant intervention required:

• RPS Acceleration - Traffic multiplies at time milestones (×1.3 at 1min → ×4.0 at 10min)
• Random Events - Cost spikes, capacity drops, traffic bursts, service outages every 15-45 seconds
• Traffic Shifts - Traffic patterns change every 40 seconds
• DDoS Spikes - 50% malicious traffic waves every 45 seconds
• Service Degradation - Services lose health under load, require repairs
• Health bars, event indicator, finances panel, auto-repair toggle, game-over analysis

20 levels across 4 chapters, each one a scenario built around a single lesson:

1. Basics (levels 1-3) — your first server, storage, and edge caching with a CDN.
2. Optimization (levels 4-10) — caching, queues, read scaling, search, NoSQL, rate limiting, serverless vs compute.
3. Defense & Mastery (levels 11-14) — defense in depth, high availability, cost crunches, and Black Friday.
4. Production Readiness (levels 15-20) — observability, auto-scaling, node failures, dead-letter queues, fan-out, and two-region failover.

Levels come with pre-built starting architectures, primary and bonus objectives, speedrun stars, and a debrief tip. Later chapters throw forced outages — including a whole region going dark — at your build.

A fully customizable testing environment for experimenting with any architecture:

No game over in Sandbox - experiment freely!

Built something you're proud of? The share panel exports your architecture two ways:

• PNG export — a clean image of your diagram to post anywhere.
• Shareable URL — your whole build encoded in a ?arch= link; anyone who opens it gets your architecture loaded and ready to run.

• Left Click: Select tools, place services, and connect nodes.
• Right Click + Drag: Pan the camera.
• Scroll: Zoom in and out.
• WASD / Arrows: Move camera (pan) when zoomed in.
• ESC: Open main menu and pause game. Press again or click Resume to close menu (stays paused).
• Camera Reset: Press R to reset the camera position.
• Birds-Eye View: Press T to switch between isometric and top-down view.
• Hide HUD: Press H to toggle UI panels.
• Category Tabs: The toolbar groups services into five tabs — Front Door, Compute, Data, Async, Ops. Keys 1-5 switch between them.
• Connect Tool: Click two nodes to create a connection (flow direction matters!).
  • Valid Flows: Internet -> (GeoDNS/Firewall/CDN/API Gateway) -> Load Balancer -> Queue -> Compute -> Cache -> (Search Engine/Read Replica/SQL DB/NoSQL DB/Storage)
• Delete Tool: Remove services to recover 50% of the cost.
• Time Controls: Pause, Play (1x), and Fast Forward (3x).

1. Block Attacks First: Always place a Firewall immediately connected to the Internet. Malicious leaks destroy reputation fast (-5 per leak) and cost $50 per breach.
2. Use CDN for Static Content: Connect Internet -> CDN -> Storage. The CDN handles 95% of static traffic cheaply!
3. Watch Service Health: Damaged services have reduced capacity. Click to repair or enable Auto-Repair.
4. Scale for Traffic Surges: RPS multiplies at milestones - prepare before ×2.0 at 3 minutes!
5. Balance Income vs Upkeep: Start lean, scale as income grows. Over-provisioning leads to bankruptcy.
6. Use Cache Wisely: Reduces database load significantly for READ requests.
7. Buffer with Queue: Queue helps survive traffic burst events without dropping requests — and a queue-fed Compute fleet auto-scales on queue depth.
8. React to Events: Watch the event bar - cost spikes mean hold off on purchases, traffic bursts mean ensure capacity.
9. API Gateway for Graceful Degradation: Throttled requests only lose -0.2 reputation (vs -1.0 for failures). Great for surviving traffic spikes!
10. Split DB Traffic with NoSQL: Route READ/WRITE to NoSQL (faster, cheaper) and keep the Relational DB for SEARCH queries only.
11. Search Engine for SEARCH Storms: SEARCH is the heaviest traffic type (2.5x weight). A dedicated Search Engine processes it 3x faster than SQL DB.
12. Read Replica for READ offloading: Under "API Heavy" or "Read Heavy" shifts, a Read Replica prevents your main DB from drowning in READ requests.
13. Serverless Function = pay-per-use: Great for spiky traffic, but monitor finances — per-request cost ($0.03) adds up fast at high RPS.
14. Place Monitoring early: The metrics dashboard shows error rates and latency before the failure badges start raining.
15. Read the failure badges: Every dropped request tells you why it died — the badge is the lesson.

• Core: Vanilla JavaScript (native ES modules — an explicit module graph under src/, no bundler)
• Rendering: Three.js for 3D visualization.
• Styling: Tailwind CSS for the glassmorphism UI.
• Build: No build step required! The game is served raw from this repo by GitHub Pages.

1. Clone the repository.
2. Open index.html in your modern web browser.
3. Start building your cloud empire!

There is still zero build step — the dev tooling is optional and for contributors only:

• npm install once, then npm run check runs ESLint + the full Vitest suite (593 tests).
• CI runs the same check on every PR.
• The code is native ESM: game.js plus focused modules under src/ (sim/, core/, ui/, campaign/, persistence/, input/).

See CONTRIBUTING.md for the workflow.

Join our Discord server to discuss strategies and share your high scores: Join Discord

Built with code and chaos.