Skip to main content

​
Overview

Qovery helps you optimize infrastructure costs through intelligent resource management, auto-scaling, and efficient build processes.

​
Cluster Auto-Scaling with Karpenter

Qovery uses Karpenter to automatically provision and scale cluster nodes based on your workload demands.

​
How Karpenter Works

Karpenter monitors pending pods and automatically provisions the right-sized nodes to run them efficiently:
  • Just-in-time provisioning: Nodes are created only when needed
  • Bin-packing optimization: Workloads are efficiently packed onto nodes
  • Fast scaling: New nodes ready in ~2 minutes
  • Cost-optimized instance selection: Automatically selects the most cost-effective instance types

​
Benefits

Automatic Scaling

Scales cluster up and down based on demand

Cost Optimization

Selects optimal instance types for your workloads

Fast Provisioning

New nodes available in minutes

Efficient Packing

Maximizes resource utilization
Karpenter runs automatically on Qovery-managed clusters with no configuration required.

​
Pod Auto-Scaling

Automatically scale your application instances based on CPU utilization or custom metrics.

​
Horizontal Pod Autoscaling (HPA)

Configure auto-scaling for your applications:
1

Navigate to Settings

Go to your Application → Settings → Resources
2

Configure Auto-Scaling

Set the auto-scaling parameters:
  • Min Instances: Minimum number of running instances (e.g., 2)
  • Max Instances: Maximum number of instances (e.g., 10)
  • Target CPU Utilization: Scale when CPU exceeds threshold (e.g., 60%)
3

Save and Deploy

Click Save and redeploy your application

​
How It Works

When CPU utilization exceeds the target threshold, Kubernetes automatically adds more pod instances. When usage decreases, it scales back down to the minimum.
Auto-scaling helps maintain performance during traffic spikes while reducing costs during low-traffic periods.

​
Event-Driven Autoscaling with KEDA

For advanced use cases, Qovery supports event-driven autoscaling powered by KEDA. What is KEDA? KEDA scales your applications based on external event sources like:
  • Message queues (AWS SQS, RabbitMQ, Kafka)
  • Data streams (AWS Kinesis)
  • Databases (PostgreSQL, MySQL)
  • Custom metrics (Prometheus, Datadog)
  • Scheduled events (cron-based)
When to Use KEDA:
  • Your application processes messages from a queue
  • Scaling should respond to queue depth, not CPU usage
  • You need to scale based on external metrics
  • You want scale-to-zero capability
Beta Feature - KEDA autoscaling is currently in beta and available to select customers only. Contact your Qovery account manager if you’re interested in early access.
AWS and GCP clusters only - KEDA event-driven autoscaling is currently available for applications deployed on AWS and GCP clusters.

KEDA Configuration Guide

Learn how to configure event-driven autoscaling with detailed examples and authentication patterns

​
Spot Instances

Reduce compute costs by up to 70% using Spot Instances for non-critical workloads.

​
What Are Spot Instances?

Spot instances use spare cloud capacity at significantly discounted prices compared to on-demand instances.

​
When to Use Spot Instances

Development Environments

Ideal for testing and development

Staging Environments

Perfect for pre-production testing

Batch Processing

Good for fault-tolerant workloads

CI/CD Jobs

Suitable for short-lived tasks

​
Configuration

Qovery automatically configures Spot instances with intelligent fallback:
  • Spot instances: Used when available (up to 70% cost savings)
  • Automatic fallback: Switches to on-demand if spot capacity unavailable
  • Graceful handling: Manages spot instance interruptions
Don’t use Spot instances for production workloads requiring high availability.

​
Environment Start-Stop

Automatically stop non-production environments outside business hours to reduce costs.

​
Scheduling Environments

1

Access Environment Settings

Navigate to Environment → Settings
2

Enable Scheduling

Turn on Environment Scheduling
3

Configure Schedule

Set when the environment should be running:
  • Start time: e.g., 8:00 AM
  • Stop time: e.g., 8:00 PM
  • Days: Monday-Friday
  • Timezone: Your local timezone
4

Save

Click Save to apply the schedule

​
Cost Savings

Stopping environments when not in use can reduce costs by 60-70% for development and staging: 
Example Savings:
Development Environment (runs 24/7): $500/month
Development Environment (scheduled 8am-8pm, Mon-Fri): $150/month
Savings: $350/month (70%)
Schedule development and staging environments to run only during working hours.

​
Build Optimization

Qovery optimizes your application builds to save time and resources.

​
Smart Build Detection

Qovery avoids unnecessary rebuilds by:
  • Detecting code changes: Only rebuilds when application code changes
  • Skipping unchanged services: If no changes detected, uses previous build
  • Monitoring Git commits: Tracks which services are affected by commits
This reduces build times and CI/CD costs by avoiding redundant builds.

​
Docker Cache

Qovery leverages Docker layer caching to speed up builds:
  • Layer caching: Reuses unchanged Docker layers from previous builds
  • Dependency caching: Cached npm install, pip install, etc. if dependencies unchanged
  • Multi-stage build support: Efficiently caches intermediate build stages

​
Build Cache Benefits

Faster Builds

Reduces build time by 50-80% for unchanged layers

Lower Costs

Fewer compute resources needed for builds

Faster Deployments

Get changes to production quicker

Automatic

Works automatically, no configuration needed

​
Next Steps

Secure

Implement security best practices

Kubecost Integration

Track and analyze Kubernetes costs