Intermediate to Advanced

System Design Roadmap

Progress from requirements and quality attributes to scalable application architecture, load balancing, caching and database design.

Suggested duration: 3–6 months

RequirementsQuality AttributesArchitectureScalabilityLoad BalancingCachingDatabasesObservability

Roadmap Overview

This roadmap follows the sequence of the supplied seven-day system-design notes. It begins by understanding the task-management domain and writing requirements, then identifies the quality attributes that shape the design. The next stages introduce scalability, stateless application instances, load balancing, cache strategies and relational database decisions. Use the same example system across the stages so each new concept connects to earlier decisions instead of becoming an isolated definition.

Learning progression

Work through each stage

Complete the learning outcomes and practice tasks before moving forward. The sequence is intended to build on earlier knowledge.

  1. Stage 017 topics

    Stage 01 — Architecture and Domain Understanding

    Define the system boundary, identify users and core data, and sketch the initial high-level architecture.

    Topics to study

    System OverviewUsers and RolesFunctional RequirementsNon-Functional RequirementsCore DataHigh-Level ArchitectureApplication Layers

    Learning outcomes

    • ✓Describe the task-management domain and its actors.
    • ✓List core use cases and data entities.
    • ✓Draw a client, load-balancer, application, Redis and PostgreSQL architecture.
    • ✓Explain controller, service, repository and database responsibilities.

    Suggessted practice

    Write a one-page system overview and draw the initial architecture before choosing framework-specific details.

  2. Stage 028 topics

    Stage 02 — Requirements and Workload Assumptions

    Turn the use cases into functional requirements and state measurable targets, constraints and assumptions.

    Topics to study

    Registration and LoginProject ManagementMembershipTask WorkflowsCommentsResource AuthorisationPaginationWorkload Assumptions

    Learning outcomes

    • ✓Describe each capability with actors, preconditions and expected results.
    • ✓Define access rules for projects, tasks and comments.
    • ✓Identify bounded collection endpoints and filters.
    • ✓Separate planning assumptions from approved service targets.

    Suggessted practice

    Create an FR/NFR checklist and acceptance criteria. Resolve the different RPS planning figures in the source notes before load testing.

  3. Stage 039 topics

    Stage 03 — Quality Attributes and Trade-offs

    Convert words such as reliable, fast and available into metrics and design implications.

    Topics to study

    AvailabilityLatency PercentilesThroughputReliabilityDurabilityConsistencySecurityFault ToleranceObservability

    Learning outcomes

    • ✓Calculate the downtime budget for a 99.9% monthly availability target.
    • ✓Explain p50, p95 and p99 latency and why average latency can hide slow requests.
    • ✓Distinguish reliability from durability and consistency.
    • ✓Map logs, metrics and traces to operational questions.

    Suggessted practice

    Create a quality-attribute table with targets, measurement methods and architecture implications for the API.

  4. Stage 049 topics

    Stage 04 — Scalability and Stateless Application Design

    Understand vertical and horizontal scaling and make application instances interchangeable.

    Topics to study

    Vertical ScalingHorizontal ScalingStateless APIsShared StateIndexingConnection PoolingRead ReplicasPartitioningSharding

    Learning outcomes

    • ✓Compare scale-up and scale-out trade-offs.
    • ✓Explain why local in-memory sessions complicate horizontal routing.
    • ✓Identify database bottlenecks and candidate optimisation stages.
    • ✓Explain replication lag and the operational cost of sharding.

    Suggessted practice

    Run multiple API instances with shared Redis and PostgreSQL. Verify that consecutive requests can reach different instances without losing required state.

  5. Stage 0510 topics

    Stage 05 — Load Balancing and Reverse Proxies

    Distribute traffic, route around unhealthy instances and understand Layer 4, Layer 7 and proxy responsibilities.

    Topics to study

    Layer 4Layer 7Round RobinWeighted Round RobinLeast ConnectionsIP HashHealth ChecksTLS TerminationSession AffinityNGINX

    Learning outcomes

    • ✓Compare common traffic-distribution algorithms.
    • ✓Describe active and passive health checks.
    • ✓Explain reverse-proxy responsibilities and TLS termination.
    • ✓Describe how an API should behave when one instance fails.

    Suggessted practice

    Place NGINX in front of multiple API containers, add a health endpoint and simulate one API instance becoming unavailable.

  6. Stage 0610 topics

    Stage 06 — Caching and Redis

    Choose cache candidates, implement cache-aside reads and design invalidation and failure behaviour.

    Topics to study

    Cache HitCache MissCache AsideWrite ThroughWrite BehindTTLInvalidationStampedePenetrationEviction

    Learning outcomes

    • ✓Trace the cache hit and miss request paths.
    • ✓Explain why database writes should trigger cache update or invalidation.
    • ✓Choose appropriate keys and TTLs for selected resources.
    • ✓Plan for stampedes, penetration, eviction and Redis failure.

    Suggessted practice

    Cache selected project or task reads. Measure hit/miss behaviour and test invalidation after a successful update.

  7. Stage 0711 topics

    Stage 07 — Database Design and Data Access

    Model relational data, protect writes with transactions and scale query access without returning unbounded result sets.

    Topics to study

    Relational SchemaPrimary KeysForeign KeysRelationshipsNormalisationIndexesTransactionsN+1 QueriesPaginationReplicationBackups

    Learning outcomes

    • ✓Create a schema for users, projects, memberships, tasks and comments.
    • ✓Use constraints and transactions to preserve integrity.
    • ✓Select indexes from common filters and ordering requirements.
    • ✓Compare offset and keyset pagination and explain replica lag.

    Suggessted practice

    Implement the PostgreSQL schema, inspect query plans, test transaction rollback and document a backup/restore procedure.

How the seven topics connect

Architecture is the organising decision. Requirements describe what the system must do; quality attributes describe how well it must do it. Scalability identifies how capacity grows. Load balancing distributes traffic among application instances. Caching reduces repeated reads and database work. Database design protects persistent state and supports query patterns. These topics are interdependent: for example, adding API instances increases potential database concurrency, while caching changes the freshness and consistency model.

Use the Task Management API as the running case study

The source notes use a task-management domain with users, projects, memberships, tasks and comments. Keep this domain constant while studying each stage. At every step, ask what requirement motivates the design, what component is responsible, what can fail, how the behaviour is measured and what trade-off is introduced.

Expected outcomes

  • ✓Translate product needs into workload-aware architecture decisions.
  • ✓Explain the responsibilities and failure modes of each tier.
  • ✓Design stateless application instances behind a health-aware load balancer.
  • ✓Use Redis without making it the source of truth for critical data.
  • ✓Design PostgreSQL schemas and access patterns for correctness and measured scale.