The labs on this site need JavaScript to run. The same content is written out below.

Learn

Architecture and operations

Topics for when traffic grows, when a system is split into services, and when you deploy and monitor it.

High traffic

• Load balancers and scale out — How far does adding servers get you?
• Caching and TTL — How much does a cache reduce database queries, and when do requests pile up again?
• Redis single-threaded execution — If one command is slow, everyone waits
• Rate limiting — Three meanings of "accept only 5 requests per second"

Messaging and asynchronous processing

• Message queue basics — Leave a note instead of calling directly
• Kafka partitions and consumers — I added consumers, so why is the throughput the same?

Splitting into services

• Circuit breaker — If you keep calling a dead service, you go down too
• Saga and outbox — When every service has its own database, how do you get "all succeed or all cancel"?
• Gateway and gradual migration — Breaking up a huge server piece by piece without stopping it

Deployment and operations

• CI/CD pipelines — You push code, and a machine checks and deploys it for you
• Deployment strategies — How to switch to a new version without interrupting the service
• Containers and virtual machines — Why are containers lightweight and quick to start?
• Kubernetes self-healing — When a container dies, what starts it again?

Observability

• Averages and percentiles — The average response time looks fine, so why do users complain that it is slow?
• Distributed tracing — One request is slow, but which service is to blame?

Collaboration

• Merge and rebase — Three ways to combine two branches