System Design Learning Lab

A structured learning lab for system design, scalability, reliability, and interview preparation.

This repository is a personal learning space for studying system design in a way that is reusable, presentable, and grounded in engineering thinking. It is not just a place to store notes. It is a long-term knowledge base, a portfolio of system thinking, and a practice ground for interview-ready design communication.

Goals

• Build a strong foundation in system design and distributed systems
• Practice common system design interview problems
• Translate real projects and research into industry system design language
• Develop reusable frameworks for requirement clarification, estimation, trade-off analysis, and reliability thinking
• Turn learning notes into a structured engineering knowledge product

Why This Repository?

This repository is designed to support three purposes at the same time:

• A cumulative learning system
• A showcaseable engineering project
• A knowledge base that can later be turned into interview material

The focus is not only on collecting concepts, but on learning how to explain systems clearly, analyze trade-offs, and organize ideas in a repeatable way.

Repository Structure

system-design-learning-lab/
|
|-- README.md
|-- LICENSE
|-- .gitignore
|
|-- docs/
|   |-- fundamentals/
|   |   |-- load-balancing.md
|   |   |-- caching.md
|   |   |-- databases.md
|   |   |-- consistency.md
|   |   |-- queues.md
|   |   |-- sharding.md
|   |   `-- replication.md
|   |
|   |-- patterns/
|   |   |-- rate-limiter.md
|   |   |-- url-shortener.md
|   |   |-- chat-system.md
|   |   |-- notification-system.md
|   |   `-- news-feed.md
|   |
|   |-- interview-frameworks/
|   |   |-- requirement-clarification.md
|   |   |-- capacity-estimation.md
|   |   |-- trade-off-thinking.md
|   |   |-- reliability-checklist.md
|   |   `-- security-checklist.md
|   |
|   `-- translations/
|       |-- aosa-as-system-design.md
|       `-- asr-llm-pipeline-as-system-design.md
|
|-- templates/
|   |-- system-design-note-template.md
|   |-- mock-interview-template.md
|   `-- postmortem-template.md
|
|-- diagrams/
|   |-- url-shortener/
|   |-- chat-system/
|   `-- aosa/
|
|-- exercises/
|   |-- week-01/
|   |-- week-02/
|   `-- mock-interviews/
|
`-- journal/
    |-- week-01-reflection.md
    |-- week-02-reflection.md
    `-- mistakes-and-lessons.md

What Each Section Is For

docs/fundamentals/

Core concepts written in my own words, such as caching, replication, sharding, databases, message queues, and consistency models. This section acts as a reusable component library for system design thinking.

docs/patterns/

Classic system design cases and common interview topics such as URL shorteners, rate limiters, chat systems, notification systems, and news feeds. This section is the hands-on problem set.

docs/interview-frameworks/

Reusable answering frameworks for interviews, including requirement clarification, QPS and storage estimation, bottleneck analysis, trade-off thinking, security considerations, and reliability checklists. This section is the response skeleton.

docs/translations/

A section for translating research and personal project experience into system design language. This is where architecture thinking becomes more distinctive and portfolio-oriented.

templates/

Reusable note templates to keep structure consistent across all topics and make the repository easier to maintain.

diagrams/

Architecture diagrams, flow charts, and sequence diagrams. Mermaid is a lightweight default, but other tools such as draw.io, Excalidraw, or exported slides also work.

journal/

Weekly reflections, mistakes, and lessons learned. This helps with retention, tracks growth over time, and creates material for reflective interview answers.

Topics Covered

• Load balancing
• Caching
• SQL vs NoSQL
• Replication and sharding
• Message queues
• Consistency models
• Reliability and observability
• Security and governance in system design
• Capacity estimation and trade-off analysis
• Translating real-world systems into system design language

Note Template

To keep each note consistent and useful, the default structure for a system design topic is:

# Topic: Rate Limiter

## 1. What problem does it solve?
Brief explanation of the real-world problem.

## 2. Core idea
What is the main mechanism behind this design?

## 3. Key components
- Client
- API Gateway
- Rate limiting service
- Redis / in-memory store

## 4. Common approaches
- Token bucket
- Leaky bucket
- Fixed window
- Sliding window

## 5. Trade-offs
Pros and cons of each approach.

## 6. Failure cases
What can go wrong?

## 7. Interview version
How I would explain this in an interview.

## 8. Personal reflection
What was confusing at first, and what I understand now.

## 9. Related topics
- API Gateway
- Redis
- Distributed counters

Initial Roadmap

The first six notes that give this repository a strong foundation are:

1. docs/fundamentals/load-balancing.md
2. docs/fundamentals/caching.md
3. docs/fundamentals/databases.md
4. docs/fundamentals/consistency.md
5. docs/patterns/url-shortener.md
6. docs/patterns/rate-limiter.md

Suggested Workflow

The simplest learning workflow for this repository is:

1. Create a branch for a single topic
2. Write or revise one note
3. Commit with a descriptive message
4. Merge back into main

Example:

git checkout -b note/rate-limiter
git add .
git commit -m "add system design note for rate limiter"
git push origin note/rate-limiter

Good commit messages:

• add note on load balancing basics
• add system design note for url shortener
• add trade-off analysis for caching strategies
• add interview framework for requirement clarification

Future Ideas

• Track learning progress with GitHub Projects
• Open GitHub Issues for individual study topics
• Publish the notes as a documentation site with MkDocs, Docusaurus, or Astro

Author

Jason Chia-Sheng Lin