Live interactive workshop React / TypeScript / Systems Design

ScaleShop: learn to scale from evidence

Scalability Distributed Systems Open Source
Launch the Lab View Repository
ScaleShop Scalability Lab showing an abstract distributed-system topology
Illustrative render — the workshop itself is live at lab.ghassan-alhamoud.com and open source.
ProblemScaling advice is often technology-first instead of evidence-first.
FormatTwelve progressive, counterfactual incidents with modeled outcomes.
StatusPublic, live, and open source under the MIT License.
incident:  read path degrades as traffic grows
telemetry: p95 read latency climbing; cache hit rate falling;
           replica lag still zero
decision:  tune the queries · add a cache · add a read replica ·
           change nothing yet
outcome:   scored against a reference path; trade-offs explained,
           including the cost of each rejected option
Modeled — one of twelve playable incident scenarios in the live workshop. Outcomes come from the lab's deterministic scoring model, not from production measurements.

ScaleShop is an interactive workshop for practicing scalability decisions. Each level drops you into a system that is struggling: an architecture, a set of operating limits, and a dashboard full of telemetry. Your job is to figure out what is actually going wrong, point to the evidence that convinced you, pick the smallest change that fixes it, and then see how your call plays out against a reference path.

This is not about memorizing the climb from monolith to microservices. It is about learning to tell when a system genuinely needs a new cache, queue, replica, service boundary, concurrency control, or resilience mechanism, and just as important, when it does not.

Why I built it

Most architecture discussions I've sat in take a symptom and jump straight to a fashionable technology. The hard part gets skipped: naming the real constraint, protecting the invariants that matter, and only taking on the operational complexity the evidence actually justifies. ScaleShop makes that reasoning visible and repeatable, so teams can practice it before the pressure is on.

What the workshop covers

The twelve levels move from the everyday to the genuinely painful:

  • Reading observability and understanding your capacity envelope.
  • Database query behavior, caching, and when read replicas earn their keep.
  • Asynchronous side effects and horizontal scaling done for the right reasons.
  • Service isolation, concurrency control, and the stuff that quietly breaks around data lifecycle.
  • Compound dependency, zone, and deployment failures, the incidents that really ruin your week.

What to inspect

Everything you need to audit the project is in the repository: the authored level model, the deterministic scoring and outcome calculations, accessibility contracts, regression tests, product specifications, and architecture docs. The workshop itself keeps any optional progress in your browser and provisions no infrastructure, so you can poke at it freely without worrying about cost or cleanup.

Why it belongs here

ScaleShop captures how I actually approach systems work: start from evidence, make the constraints explicit, reach for the smallest maintainable intervention, and test the consequences rather than just the happy path. It is my own practice made into something other engineers can try out.