Master 100k+ RPS Systems Before You Hit Production.
Most developers never get hands-on access to production systems handling massive traffic bursts. RepoHamster ScaleLab is an upcoming interactive load simulation arena where candidate code is bombarded with synthetic traffic spikes. You must diagnose bottlenecks and implement both code-level and service-level architectural changes to survive the surge.
ScaleLab Engineer
Status: Construction Active
Level 1: Code-Level Surgery
Micro-benchmarking inside the application runtime
When millions of requests arrive, algorithmic sloppiness causes catastrophic failure. Candidates must resolve:
- •Thread contention on synchronized blocks & global locks
- •Allocation-heavy hot loops triggering Stop-the-World GC pauses
- •Unbounded in-memory collections causing Out-Of-Memory (OOM) crashes
- •Database connection leaks starving the worker thread pool
Level 2: Service-Level Architecture
Macro-resilience across distributed boundaries
Resilience requires distributed mechanisms to prevent downstream outages from collapsing your whole stack:
- •Token bucket rate limiters shedding load at the gateway edge
- •Circuit breakers isolating degraded downstream microservices
- •Message queue backpressure preventing consumer buffer overflow
- •Cache stampede mitigation with coalescing singleflight locks
Planned TODO Tasks: Code-Level Optimization Challenges
Hands-on coding challenges deployed directly inside GitHub Codespaces.
Deadlock & Mutex Lock Contention Elimination
Diagnose and replace coarse-grained synchronized mutex locks on high-throughput shared state (e.g. inventory decrements) with optimistic concurrency, atomic CAS primitives, or striped locking.
Hot-Path Object Allocation & Garbage Collection Pause Reduction
Refactor memory-intensive request parsers to use reusable byte buffers, object pools, and zero-copy string slicing, preventing stop-the-world GC latency spikes during 50k RPS load bursts.
Database Connection Pool Exhaustion & Leak Remediation
Fix unreleased database connection leaks, configure pool sizing and connection timeouts (HikariCP / pgBouncer / Go sql.DB), and optimize queries holding exclusive row locks.
Cache Stampede & Thundering Herd Defense
Implement coalescing singleflight patterns, probabilistic early expiration (XFetch), and tiered L1 in-memory + L2 distributed Redis caches to prevent cache invalidation database crashes.
Planned TODO Tasks: Service-Level Distributed Challenges
Multi-container architectural resilience and backpressure exercises.
Distributed Token Bucket Rate Limiting & Load Shedding
Build sliding-window rate limiters with Redis scripts and load-shedding reverse proxies that gracefully reject non-critical requests when CPU utilization exceeds 85%, ensuring system survival.
Circuit Breaker Pattern with Graceful Fallback Responses
Implement resilient circuit breakers (Closed / Open / Half-Open state machines) guarding slow 3rd-party payment APIs, returning cached fallbacks rather than queuing cascading timeouts.
Message Queue Backpressure & Buffer Drain Balancing
Configure consumer concurrency, batch acknowledgement, and dead-letter queues in Kafka / RabbitMQ pipelines to prevent unbounded memory growth and out-of-memory worker crashes.
Read-Replica Routing & Replication Lag Tolerance
Architect dynamic connection splitters directing read traffic to read-replicas while keeping write-after-read consistency guarantees for critical user paths.
Platform Infrastructure & Stress Harness Roadmap
The underlying burst test runner, real-time metrics telemetry, and automated grading harness.
Distributed Synthetic Load Burst Generator (k6 & Autocannon)
Deploy headless load worker nodes capable of simulating customizable traffic profiles: gradual warm-up, flash sale spike bursts (10k -> 100k RPS), and soak testing.
Real-Time Streaming Telemetry (p50, p95, p99 & Resource Heatmap)
Stream real-time latency distributions, 4xx/5xx HTTP error rates, CPU/RAM saturation, and thread pool exhaustion into an interactive live dashboard in the candidate Codespace.
Survival Score & Performance Degradation Evaluator
Score candidate code submissions on 3 criteria: (1) p99 latency SLA compliance under peak load, (2) zero data loss / corruption, and (3) graceful recovery after load diminishes.
Post-Run Flamegraph & Bottleneck Trace Explorer
Generate interactive flamegraphs showing candidate engineers the exact lines of code, lock waits, or SQL queries that caused bottleneck throttling.
Want to Test High-Traffic Scenarios Early?
We are actively developing the first batch of k6 load generation templates and Redis backpressure sandboxes. In the meantime, you can sharpen your debugging skills on our live real-world challenges!