# Architecture

> Designing systems that survive contact with real load and real teams.

9 guides.

- [What "Architecture" Even Means](https://themissingmanual.dev/guides/what-architecture-means) _(beginner)_ - Software architecture is the high-level shape of a system - the major parts and how they talk - and the small set of decisions that are expensive to change later; this guide gives you the mental model from scratch.
- [Monolith vs Microservices, Straight](https://themissingmanual.dev/guides/monolith-vs-microservices) _(intermediate)_ - What a monolith and microservices each actually are, the real strengths and real costs of both, and a clear way to choose instead of cargo-culting the architecture everyone's blogging about.
- [Caching, Explained](https://themissingmanual.dev/guides/caching-explained) _(intermediate)_ - A cache is a copy of an expensive-to-produce answer kept somewhere fast so you don't redo the work. This guide covers what a cache really is, where caches live, and why keeping them accurate is the genuinely hard part.
- [Designing for Scale (Load Balancing & Statelessness)](https://themissingmanual.dev/guides/designing-for-scale) _(advanced)_ - How to take on more load without falling over: scale out instead of just up, make your servers stateless so any box can handle any request, put a load balancer in front, and push the parts that can't be cloned - sessions, the database, the cache - out to the edges.
- [Designing for Failure (Retries, Timeouts & Circuit Breakers)](https://themissingmanual.dev/guides/designing-for-failure) _(advanced)_ - How to build distributed systems that bend instead of break: assume failure everywhere, add timeouts and backoff retries and circuit breakers, then fail soft with degradation, fallbacks, and bulkheads so one sick dependency can't sink the whole ship.
- [Event-Driven Architecture](https://themissingmanual.dev/guides/event-driven-architecture) _(intermediate)_ - Systems that talk by emitting events instead of calling each other directly: queues, pub/sub, and choreography versus orchestration.
- [The Twelve-Factor App](https://themissingmanual.dev/guides/the-twelve-factor-app) _(intermediate)_ - The canonical checklist for an app that is actually shippable and scalable: config in the environment, stateless processes, logs as streams, and more.
- [API Gateway, Explained](https://themissingmanual.dev/guides/api-gateway-explained) _(intermediate)_ - A single front door in front of many backend services - what an API gateway actually does, and when it earns its keep versus when it's overkill.
- [The CAP Theorem](https://themissingmanual.dev/guides/the-cap-theorem) _(advanced)_ - In a distributed system, a network partition forces a choice between consistency and availability - what CAP actually claims, why the choice is unavoidable, and what it looks like in real databases.