Back to path
LargePortfolio centerpiece ~28h· 6 milestones

Design a high-scale system and load-test the bottleneck

Design alone is theory. You design a high-scale system (ride-sharing, streaming, or payments-style) and then prove your central assumption by building and load-testing the critical path.

Large-scale architectureCapacity planningLoad testingBottleneck analysisCaching & queuesObservabilityCost modelingChaos & failover testingBlameless postmortems
Build this freeBrowse all projectsNo credit card. Already a member?

What you'll build

A complete architecture with capacity planning and failure analysis, plus a working prototype of the critical path that you load-test to validate (or correct) the design.

See how we teach, before you sign up

You don't just get code dumped on you. Every starter file and every solution is explained line-by-line, in plain English. Here's one real file from this project:

prototype/docker-compose.ymlyaml
services:
  postgres:
    image: postgres:16
    environment:
      POSTGRES_PASSWORD: dev
      POSTGRES_DB: matcher
    ports: ["5432:5432"]
    command: ["postgres", "-c", "max_connections=200"]
  redis:
    image: redis:7
    ports: ["6379:6379"]
    command: ["redis-server", "--maxmemory", "512mb", "--maxmemory-policy", "allkeys-lru"]

Reading this file

  • image: postgres:16Using a real Postgres container, not an in-memory fake, so behavior under load matches production.
  • max_connections=200The connection limit is a common bottleneck, set it explicitly so the load test reveals when you hit it.
  • --maxmemory-policy ... allkeys-lruEvicting least-recently-used keys when memory fills mirrors how a real cache behaves under pressure.

Real backing stores so behavior under load is representative, never in-memory fakes.

That's 1 of 10 explained code blocks in this single project.

The build, milestone by milestone

  1. 1

    Design the full system

    6 guided steps

    The full design is the map you’ll test against. Without quantified capacity targets, the later load test has nothing to confirm or refute.

  2. 2

    Identify the bottleneck

    5 guided steps

    Every system has one component that fails first under load. Finding it on paper, and the assumption you’re betting on, tells you exactly what to prototype and test.

  3. 3

    Build the critical path

    5 guided steps

    A prototype that doesn’t mirror the real bottleneck’s constraints produces numbers you can’t trust. Realistic enough to measure is the bar, not feature-complete.

  4. 4

    Load-test & revise

    5 guided steps

    Pushing the system until it fails is the only way to know your real ceiling. The design revision afterward is the evidence you can reason from measurement, not hope.

  5. 5

    Break it on purpose: chaos & failover

    5 guided steps

    Your failure-mode table is a hypothesis until you’ve watched the system fail. Chaos under load is the only way to know your mitigations work and to measure real recovery time, not the one you wrote down.

  6. 6

    Write the blameless postmortem

    5 guided steps

    The senior skill isn’t avoiding failure, it’s learning from it in writing without blaming people. A blameless postmortem of your own load/chaos run is the artifact that proves you reason from evidence and ship fixes.

What's inside when you start

4 starter files, ready to clone
6 guided milestones
6 full reference solutions
10 code blocks explained line-by-line
6 "is it working?" checks
4 interview questions it prepares you for

You'll walk away with

A full design doc with capacity planning, a cost model, and failure analysis
A load-test report on the critical path with the breaking point and limiting resource
A chaos/failover experiment report with measured MTTR and any invariant violations
A blameless postmortem with a timeline, root cause, and prioritized action items
A revision note (and ADR) documenting what the tests changed about the design

This is portfolio-grade. Build it free.

Sign up to unlock every milestone step-by-step, the code skeletons, full reference solutions, and checkable tasks, with your progress saved as you build.

Start building