Cloud Native Application Design
Cloud native application design structures software to exploit cloud platform capabilities: containers for packaging, orchestration for scheduling, microservices for independent deployment, and managed services for infrastructure concerns, producing systems that scale, heal, and deploy continuously.
itCloud native tools and technologies | OpenSkills.info
Course pathWalk it in order
Look it upDip in anytime
Go furtherLeaves this page
Don't Panic
Don't Panic — Cloud Native Application Design
Cloud native application design is the habit of arranging software so it can change, handle variable demand, and survive partial failure without requiring a ceremonial search for the one server nobody understands. The cloud part does not mean that a container has been placed near a cloud-shaped logo. It means the application gives a platform enough information to deploy, replace, scale, and observe it.
Start with the user flow. A checkout, upload, or report has a correct result, a response-time limit, and some failures it may tolerate. That small list determines where a boundary, duplicate instance, queue, or reduced feature is worth its cost. Microservices are an option here, not a compulsory badge. If one team changes, releases, and scales a modular monolith together, the monolith is not failing an exam by remaining in one piece.
The important trick is to treat every remote call as a minor weather system. It can be late, unavailable, or complete after the caller has stopped waiting. A timeout limits waiting. A bounded retry with varied delay avoids a crowd of callers retrying in formation. Idempotency means a repeated request keeps one intended business effect, which is useful when the network has delivered ambiguity instead of an answer.
Replaceable instances keep durable records and shared sessions outside one process. That lets another instance take traffic after a restart or scale-out event. Health checks are not three names for the same anxiety: startup asks whether initialization finished, readiness asks whether traffic belongs here now, and liveness asks whether a restart can help. Asking liveness to report every unhappy dependency is how an overloaded system gets less capacity as a bonus.
Operations are part of the arrangement. Metrics show rates, logs record events, and traces connect a request across boundaries. Scaling follows a work signal, not the aesthetic size of the diagram; more application instances do not repair a hot database partition. Compatible delivery also matters: expand a data shape, let old and new versions coexist, migrate, then contract. Rollback only works when the data still agrees to come along.
Read the Intro for the full architecture and failure model. Use Slides for the relationships and decision points, and keep the Cheatsheet nearby when reviewing a boundary, probe, retry policy, scaling signal, or rollout. The rest is disciplined adaptability: choose the smallest design that meets the outcome, then make its promises observable.
Where this skill leads
Relevant careers
See how this topic contributes to broader role-level skill maps.
Sources
- https://github.com/cncf/toc/blob/main/DEFINITION.md
Supports
- Canonical cloud native definition and target system qualities
- Typical technologies and the role of automation
- Cloud native practice across public, private, and hybrid environments
- https://12factor.net/
Supports
- Configuration outside application code
- Backing services as attached resources
- Separation of build, release, and run
- Stateless processes, horizontal process concurrency, disposability, and event-stream logs
- Twelve-Factor application methodology in the cloud-native history
- https://12factor.net/processes
Supports
- Stateless and share-nothing application processes
- Durable state stored in a backing service
- https://learn.microsoft.com/en-us/azure/architecture/guide/design-principles/
Supports
- Self-healing, redundancy, minimal coordination, scale-out, and partitioning
- Operational telemetry, automation, design evolution, and business requirements
- Failure-mode analysis and explicit architecture tradeoffs
- https://learn.microsoft.com/en-us/azure/well-architected/reliability/principles
Supports
- Reliability outcomes for critical user flows
- Resilience, recovery, graceful degradation, fault isolation, and blast radius
- Cost, complexity, security, and operational constraints
- https://learn.microsoft.com/en-us/azure/architecture/patterns/retry
Supports
- Bounded retry handling for transient faults
- Idempotency concerns when operations can be repeated
- Delay and randomized backoff between attempts
- https://kubernetes.io/docs/concepts/workloads/pods/probes/
Supports
- Different meanings and effects of startup, liveness, and readiness probes
- Traffic removal for failed readiness and restart for failed liveness
- Cascading-failure risk from incorrect liveness checks
- https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/
Supports
- CPU and memory resource requests used in scheduling
- CPU and memory resource limit enforcement
- https://kubernetes.io/docs/concepts/workloads/autoscaling/
Supports
- Horizontal scaling by replica count and vertical scaling by assigned resources
- Automatic scaling from observed demand
- https://kubernetes.io/docs/concepts/configuration/secret/
Supports
- Separating confidential values from application code
- Need for encryption at rest and least-privilege access
- https://kubernetes.io/docs/concepts/security/
Supports
- Workload identity and access controls
- Encryption in transit and at rest
- Workload isolation, network policy, and admission policy
- https://learn.microsoft.com/en-us/azure/architecture/guide/multitenant/approaches/storage-data
Supports
- Backward compatibility with a previous database schema version
- Sequencing destructive schema changes across multiple versions
- Automated pipelines for database schema changes
- https://sre.google/workbook/canarying-releases/
Supports
- Repeatable artifacts, automated builds, tests, and deployments
- Small releases and progressive exposure through a canary
- Evaluation and rollback during release automation
- https://opentelemetry.io/docs/concepts/observability-primer/
Supports
- Observability through emitted telemetry
- Roles of metrics, logs, traces, and context across distributed requests
- User-centered service level indicators and reliability
- https://aws.amazon.com/about-aws/whats-new/2006/08/24/announcing-amazon-elastic-compute-cloud-amazon-ec2---beta/
Supports
- 2006 EC2 beta announcement and resizable compute capacity
- https://cloud.google.com/blog/products/gcp/reflecting-on-our-ten-year-app-engine-journey
Supports
- 2008 App Engine introduction and managed application-platform history
- https://www.docker.com/blog/docker-0-1-released/
Supports
- 2013 Docker public-release milestone
- https://kubernetes.io/blog/2024/06/06/10-years-of-kubernetes/
Supports
- 2014 Kubernetes first commit and announcement
- 2015 Kubernetes 1.0 release and donation to CNCF
- https://www.cncf.io/announcements/2016/03/10/cloud-native-computing-foundation-accepts-kubernetes-as-first-hosted-project-technical-oversight-committee-elected/
Supports
- 2016 CNCF acceptance of Kubernetes as first hosted project
- https://cloud.google.com/blog/products/gcp/introducing-certified-kubernetes-and-google-kubernetes-engine
Supports
- 2017 Certified Kubernetes conformance program launch
- https://www.cncf.io/announcements/2018/03/06/cloud-native-computing-foundation-announces-kubernetes-first-graduated-project/
Supports
- 2018 Kubernetes graduation from CNCF
- https://sre.google/sre-book/monitoring-distributed-systems/
Supports
- User-facing monitoring and application health signals
