Skip to main content
Welcome. This lesson covers Kubernetes autoscaling — how to automatically adjust application and cluster capacity so your workloads remain resilient and responsive as traffic changes. You’ll learn when to scale, which autoscaler to use, and practical patterns to avoid common pitfalls. Imagine you run an online store and traffic spikes during a flash sale. If capacity doesn’t increase quickly enough, pages slow or become unavailable and users abandon their carts. Autoscaling prevents that by increasing resources when demand rises and decreasing them when demand falls, keeping costs under control while preserving performance.
A presentation slide titled "Identifying the Need for Scaling" showing an illustrated online store on a large monitor with customers shopping. On the right it lists problems to scale for: "Website slows down" and "Customers can't access."
Autoscaling behaves like a thermostat for your infrastructure: it observes load (metrics or events) and adjusts capacity so applications meet their service levels. In Kubernetes this can mean scaling application replica counts, resizing container resource requests/limits, or adding and removing nodes. At a high level:
  • Your applications run inside Pods on worker nodes.
  • The control plane schedules Pods onto nodes.
  • When load increases, you may need more Pod replicas and/or more nodes to host them.
  • Different autoscalers handle these responsibilities: some scale Pods, others right-size resources, and others manage the underlying node pool.
A diagram titled "K8s Autoscaling" showing a Kubernetes cluster with multiple worker-node pods (some highlighted) arranged inside the cluster. Arrows from a green "Traffic" circle point to the cluster, illustrating incoming traffic and autoscaling.
What we’ll cover in this course
  • Definitions and scaling goals: when to scale horizontally vs vertically, and how to measure success.
  • Horizontal Pod Autoscaler (HPA): scale replicas using CPU, memory, custom, or external metrics.
  • Vertical Pod Autoscaler (VPA): recommend or apply container resource requests/limits to right-size Pods.
  • Cluster Proportional Autoscaler (CPA): scale cluster-level or add-on replicas proportionally to node count.
  • Cluster Autoscaler (and alternatives like Karpenter): add/remove nodes based on pending Pods and scheduling constraints.
  • KEDA (Kubernetes Event-Driven Autoscaler): scale based on event sources (message queues, streams) and enable scale-to-zero patterns.
  • Hands-on examples and recommended patterns to avoid conflicts and instability.
A slide titled "Course Content" showing a colorful roadmap of Kubernetes autoscaling topics with connected circular icons and arrows. The items listed are Introduction to Scaling, Horizontal Pod Autoscaler, Vertical Pod Autoscaler, Cluster Proportional Autoscaler, and Kubernetes Event-Driven Autoscaling (KEDA) Scaling.
Autoscaler summary A few clarifying points
  • HPA adjusts the number of Pod replicas for Deployments, ReplicaSets, and StatefulSets and supports built-in (CPU/memory), custom, and external metrics.
  • VPA adjusts container resource requests and/or limits to right-size Pods. VPA does not increase replica counts — use HPA for replica-based scale-out.
  • CPA targets cluster-level services and scales their replicas relative to node count (helpful for DNS, logging, and monitoring add-ons).
  • Cluster Autoscaler (and alternatives like Karpenter on AWS) changes node count based on unschedulable Pods and cloud-provider scaling policies.
  • KEDA connects to external event sources (Kafka, SQS, Azure Queue, Prometheus, etc.) and exposes metrics or triggers that drive scaling, including scale-to-zero.
Avoid uncontrolled interaction between HPA and VPA: if both modify the same resource targets (for example, container CPU requests), they can create oscillations. Use recommended patterns—like VPA in “recommend” mode with HPA controlling replica count—or split responsibilities by workload type.
We’ll include hands-on examples for manual and automated scaling, plus practical tips to avoid common issues (metric selection, cooldowns, target utilization, and resource fragmentation). Follow along to learn when to use HPA, VPA, CPA, Cluster Autoscaler, and KEDA so your applications remain available during spikes and efficient during low load.
By the end of this course you’ll understand how these autoscalers interact, which to use for different problems, and implementation best practices so applications stay available under changing load.
Links and references Ready to get started with the first hands-on lesson?

Watch Video