Cloud Native Patterns learning path: everything to study, topic by topic

Understanding cloud native as software designed for a highly dynamic, redundant, and constantly changing environment where failure is normal — and why apps must adapt rather than depend on stable infrastructure

The twelve factors for building portable, scalable, cloud-native applications: codebase, dependencies, config, backing services, build/release/run, processes, port binding, concurrency, disposability, dev/prod parity, logs, and admin processes

Designing processes that start fast and shut down gracefully so instances can be created or destroyed at any moment — a precondition for elasticity, fast deploys, and resilience

Packaging an application and its dependencies into an immutable container image: single-process containers, minimal base images, build vs runtime separation, and image layering for cloud-native deployment

Building stateless application processes so any instance can serve any request, enabling horizontal scaling, rolling deploys, and instance replacement without sticky sessions or in-memory state

Pushing all durable state out of the application process into backing services — databases, caches, object stores, and message brokers — treated as attached resources bound at runtime

Separating config from code: injecting environment-specific configuration via environment variables and config maps so the same immutable artifact runs unchanged across environments

Managing sensitive configuration — credentials, tokens, keys — separately from regular config: injection at runtime, never baking secrets into images, rotation, and least-privilege access

Synchronous request/response communication between cloud-native services: blocking dependencies, latency coupling, timeouts, and when synchronous calls are appropriate versus harmful

Decoupling services through asynchronous events and messaging: publish/subscribe, event notification versus event-carried state transfer, and how events reduce temporal coupling in cloud-native apps

Designing applications that embrace eventual consistency: accepting temporary divergence, reconciling state asynchronously, and shaping UX and APIs around non-immediate consistency

Locating service instances dynamically in an environment where instances come and go: service registries, DNS-based discovery, and why hardcoded endpoints break in cloud-native systems

Distributing requests across discovered instances from the client side: load-balancing strategies, health-aware instance selection, and the trade-offs versus server-side/proxy load balancing

Recovering from transient failures safely: retry with backoff and jitter, idempotency keys, and ensuring retried operations do not produce duplicate side effects

Preventing cascading failure at the application level: tripping a circuit when a dependency fails repeatedly, fast-failing during the open state, and recovering through a half-open probe

Combining resilience patterns — timeouts, bulkheads, fallbacks, rate limiting, and graceful degradation — so the application stays responsive when dependencies are slow or down

How a cloud-native platform provides the runtime contract — scheduling, restarts, scaling, service discovery, and config injection — and how applications should cooperate with platform-provided capabilities

Shipping changes safely through traffic shaping at the application/platform layer: blue-green deployment, canary releases, and progressive rollout with rollback

Designing applications so the platform can scale them horizontally on demand: fast startup, stateless instances, meaningful scaling signals, and avoiding startup/teardown side effects that block scaling

Composing functionality alongside the application via co-located helper containers: the sidecar pattern, the ambassador proxy for outbound connectivity, and the adapter for normalizing interfaces

Exposing the application's own view of its health: liveness versus readiness, what each probe should check, and how probes drive restarts and traffic routing in the platform

Making a cloud-native app debuggable in production through the three pillars — structured logs to stdout, metrics, and distributed traces with correlation/context propagation

Handling the application lifecycle cleanly: draining in-flight work on SIGTERM, deregistering from discovery, honoring termination grace periods, and signaling readiness only when truly ready

Treating deployed artifacts as immutable and replaceable: no in-place mutation, rebuild-and-redeploy over patching, and how immutability underpins reproducibility and reliable rollback