The complete guide to Kubernetes autoscaling

Kubernetes autoscaling automatically adjusts compute resources to match application demand. This guide covers everything from basic concepts to advanced patterns, with practical examples for implementing autoscaling in production environments.

Kubernetes autoscaling dynamically adjusts resources based on real-time demand. Unlike traditional static provisioning where you guess capacity needs, autoscaling responds to actual usage patterns, scaling up during peaks and down during quiet periods.

🛍️ E-commerce flash sales: An online retailer experiences 20x normal traffic during Black Friday. Without autoscaling, they'd need to provision for peak capacity year-round. With Northflank's autoscaling, their platform automatically scales from 5 to 100 instances during the sale, then back down afterward.

📹 Social media viral content: A social platform's video service typically handles 1,000 requests/second. When content goes viral, traffic spikes to 50,000 requests/second within minutes. Autoscaling prevents service degradation by rapidly adding capacity.

🏦 Financial services batch processing: A bank processes transactions in nightly batches. Data volume varies from 1GB on weekends to 100GB at month-end. Autoscaling provisions resources only when needed, reducing costs by 80% compared to static provisioning.

HPA scales the number of pod replicas based on metrics. It's ideal for stateless applications where adding instances directly increases capacity.

Basic HPA configuration:

apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: webapp-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: webapp
  minReplicas: 2
  maxReplicas: 50
  metrics:
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: 70

Northflank's simplified approach: Instead of YAML, Northflank provides toggle controls where you:

• Enable horizontal autoscaling with one click
• Set min/max instances with sliders
• Configure CPU, memory, and RPS thresholds
• View real-time scaling events in the dashboard

VPA adjusts resource requests and limits for pods, right-sizing containers based on actual usage.

VPA configuration example:

apiVersion: autoscaling.k8s.io/v1
kind: VerticalPodAutoscaler
metadata:
  name: webapp-vpa
spec:
  targetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: webapp
  updatePolicy:
    updateMode: "Auto"
  resourcePolicy:
    containerPolicies:
    - containerName: webapp
      minAllowed:
        cpu: 100m
        memory: 128Mi
      maxAllowed:
        cpu: 2
        memory: 2Gi

Manages the cluster itself by adding or removing nodes based on pod scheduling needs.

Key behaviors:

• Adds nodes when pods can't be scheduled
• Removes underutilized nodes after grace period
• Respects pod disruption budgets
• Considers node pools and instance types

Northflank's custom metrics support enables scaling based on application-specific indicators:

# Expose custom metrics in your app
from prometheus_client import Gauge, generate_latest

queue_depth = Gauge('message_queue_depth', 'Pending messages')

@app.route('/metrics')
def metrics():
    queue_depth.set(get_queue_size())
    return Response(generate_latest(), mimetype='text/plain')

Then in Northflank:

1. Specify your Prometheus endpoint and port
2. Select metric type (Gauge or Counter)
3. Set threshold values
4. Northflank handles the rest, no adapter configuration needed

Northflank transforms complex Kubernetes autoscaling into a straightforward process. Instead of wrestling with YAML configurations and manual metric setup, Northflank provides an intuitive interface that makes autoscaling accessible to teams of all sizes. The platform handles the underlying complexity while giving you powerful features like custom metrics, multi-threshold scaling, and real-time monitoring, all without the operational overhead of managing Kubernetes directly.

Every 15 seconds, the autoscaling control loop:

1. Collects metrics from all pods in the deployment

2. Calculates average utilization across instances

3. Determines required replicas using the formula:

   required = ceil[current * (actualMetric / targetMetric)]

4. Applies scaling decision based on policies

Scale-up characteristics:

• Immediate response to threshold breach
• Can scale multiple instances at once
• No cooldown period by default

Scale-down characteristics:

• 5-minute stabilization window
• Gradual reduction to prevent flapping
• Selects highest replica count from window

When using multiple metrics (CPU, memory, RPS), the autoscaler:

• Calculates required replicas for each metric independently
• Selects the highest requirement
• Ensures no metric is under-provisioned

Northflank makes this seamless, enable any combination of metrics and the platform coordinates scaling decisions automatically.

Static provisioning wastes resources during low-demand periods. Autoscaling delivers significant savings:

• Development environments: 70-80% reduction (scale to zero when unused)
• Production services: 50-60% reduction (right-sized for actual load)
• Batch processing: 80-90% reduction (resources only when processing)

Autoscaling maintains performance KPIs during demand variations:

• Response times stay consistent during traffic spikes
• Queue processing times remain predictable
• User experience doesn't degrade under load

Teams save significant time by eliminating manual scaling tasks:

• No midnight interventions for traffic spikes
• Automatic response to seasonal patterns
• Focus on features, not infrastructure

Northflank amplifies these benefits with visual monitoring and one-click configuration changes that would typically require complex YAML editing and kubectl commands.

Combine reactive autoscaling with scheduled scaling for predictable patterns:

# Morning scale-up for business hours
apiVersion: batch/v1
kind: CronJob
metadata:
  name: morning-scaleup
spec:
  schedule: "0 7 * * MON-FRI"
  jobTemplate:
    spec:
      template:
        spec:
          containers:
          - name: scaler
            image: bitnami/kubectl
            command: ["kubectl", "patch", "hpa", "webapp-hpa",
                     "--patch", '{"spec":{"minReplicas":10}}']

Northflank's deployment strategies work seamlessly with autoscaling:

1. Deploy new version with same autoscaling config
2. Gradually shift traffic while both scale independently
3. Complete cutover with zero downtime

For global applications, implement region-aware autoscaling:

• Scale regions independently based on local demand
• Use Northflank's multi-region support
• Configure different thresholds per region

Traditional Kubernetes autoscaling requires:

• Installing metrics servers
• Configuring RBAC permissions
• Writing YAML manifests
• Setting up Prometheus adapters
• Managing metric aggregation

Northflank provides:

• Visual configuration: Sliders and toggles instead of YAML
• Automatic metric collection: No manual setup required
• Integrated monitoring: See metrics and scaling events together
• Custom metrics support: Prometheus endpoints work immediately
• Multi-metric coordination: CPU, memory, and RPS in one interface

Here's how a Northflank user configures autoscaling:

1. Navigate to your service's Resources page
2. Expand "Advanced resource options"
3. Toggle "Enable horizontal autoscaling"
4. Set your parameters:
   • Minimum instances: 2
   • Maximum instances: 20
   • CPU threshold: 70%
   • Memory threshold: 80%
   • RPS threshold: 1000

That's it. No YAML, no kubectl, no manual metric server configuration.

Northflank provides integrated monitoring that shows:

• Current instance count with scaling history
• Real-time metrics for all configured thresholds
• Scaling event logs with reasons
• Cost tracking as instances scale

Kubernetes changes transforms how we manage application resources, moving from static provisioning to dynamic, demand-based allocation. While the underlying technology is powerful, complexity has traditionally limited adoption.

Northflank changes this by making enterprise-grade autoscaling accessible to teams of all sizes. Through intuitive interfaces, automatic metric collection, and integrated monitoring, Northflank removes the operational burden while delivering the full benefits of Kubernetes autoscaling.

Whether you're scaling web applications during traffic spikes, optimizing batch processing costs, or managing complex microservices architectures, autoscaling ensures optimal resource utilization. Start with basic CPU-based scaling, monitor real-world behavior through Northflank's dashboards, and gradually introduce custom metrics as your needs evolve.

The future of infrastructure is adaptive, not static.

With Northflank's approach to Kubernetes autoscaling, that future is accessible today, no infrastructure expertise required.

Try Northflank for free, today.