hosting

AWS Lets PromQL Alarms Drive Auto Scaling Actions

Amazon CloudWatch now lets PromQL alarms trigger EC2 Auto Scaling and Application Auto Scaling step and simple scaling policies, connecting OpenTelemetry metrics to capacity changes.

Featured image for AWS Lets PromQL Alarms Drive Auto Scaling Actions

Many cloud teams already use Prometheus Query Language to explore application behavior, build dashboards, and create alerts. Scaling capacity, however, has often remained a separate path: a team observes a PromQL signal, translates it into another alarm type, and then attaches an auto-scaling action. Amazon CloudWatch is narrowing that gap.

In its official November 10 announcement, AWS said CloudWatch alarms that use PromQL can now trigger Amazon EC2 Auto Scaling and Application Auto Scaling step and simple scaling policies. The same kind of PromQL query used for dashboards and alerting can now participate in a capacity decision, provided the query returns a single series and compares it with a threshold.

The change is small in the console and meaningful in operations. It gives teams using OpenTelemetry metrics a more direct route from “the workload is under pressure” to “add or remove capacity,” without maintaining a second expression language for the scaling signal.

What AWS changed

CloudWatch PromQL alarms can now attach actions for EC2 Auto Scaling and Application Auto Scaling. AWS describes the supported policies as simple and step scaling. In a step policy, how far the PromQL result is beyond the threshold determines which scaling step applies. That enables a graduated response: a modest breach can add a small amount of capacity, while a larger breach can add more.

The feature is available in the AWS Regions where CloudWatch PromQL alarms are available. AWS says standard CloudWatch alarm pricing applies. Target tracking is not currently supported for PromQL alarms, so this is an extension of alarm-driven scaling rather than a replacement for every auto-scaling strategy.

Why the PromQL connection matters

Traditional infrastructure metrics are useful for capacity decisions, but they can be indirect. CPU may be high because a process is busy, while user-facing latency remains acceptable. Memory may look stable while a queue grows. A service can have spare compute and still be falling behind because its work is blocked elsewhere.

PromQL lets a team express a signal closer to the workload. That could be queue depth, request rate, error ratio, processing lag, or a metric derived from several labels. When the same expression appears in a dashboard, an alert, and a scaling alarm, operators have fewer translations to compare during an incident or a capacity review.

The practical benefit is consistency. A developer can inspect the query that is visible in the monitoring view and understand the condition that can initiate the scaling action. That does not make the condition automatically correct, but it reduces the chance that the alert and the scaling rule describe different versions of reality.

A concrete before-and-after example

Imagine a document-processing service that receives bursts during business hours. The team exports an OpenTelemetry metric for work waiting in the queue and uses PromQL to graph the backlog. Previously, the team might alert on that query, then create a separate CloudWatch metric alarm or custom translation for scaling.

With the new capability, the team can use a single-series PromQL query as the alarm condition. If the backlog crosses the first threshold, a simple policy can add one worker. If it crosses a higher step, the policy can add several workers. When the backlog falls below a recovery condition, a separate action can reduce capacity, subject to the cooldown and stabilization behavior chosen by the team.

This is not an instruction to scale directly on every noisy metric. It is an example of where the feature can help: a clear workload signal, a known relationship between the signal and capacity, and step boundaries that have been tested against real traffic patterns.

What teams should validate before connecting the action

  1. Query shape. AWS says the query must return a single series and compare it with a threshold. A query that produces multiple series because of labels is not the same as a single fleet-level signal.
  2. Metric meaning. Confirm that the metric represents work or pressure that more capacity can actually relieve. A growing queue caused by a downstream dependency may not improve when more workers are added.
  3. Step boundaries. Write down what each breach means operationally. A small step should not trigger an oversized fleet, and a large step should not exceed account, subnet, database, or downstream limits.
  4. Recovery behavior. Scale-in needs its own reasoning. A signal that falls briefly may not mean the workload has stabilized, especially when instances are still warming or queued work is being drained.
  5. Evidence. Test the exact PromQL query, alarm, policy, and resource type together. A dashboard showing the expected line is not proof that the alarm will produce the intended scaling action.

The limitations are part of the design

The most visible limitation is the absence of target tracking support for PromQL alarms. Target tracking is useful when a team wants a resource to follow a target value, while step scaling is better suited to explicit thresholds and discrete responses. Teams with a target-tracking design will still need a supported metric path for that policy type.

The single-series requirement also matters. PromQL is expressive, and it is easy to write a query that returns one line per service, region, status, or tenant. Scaling usually needs a carefully chosen aggregation boundary. A query should make that boundary visible rather than hiding a large set of independent signals behind an action that can only scale one resource group.

Finally, a scaling action is not the same as instant capacity. New instances need time to launch, pass health checks, warm caches, and connect to dependencies. The useful design question is therefore not only “what threshold should trigger?” but also “how early must the signal move for the added capacity to arrive before users feel the impact?”

What changes for OpenTelemetry teams

Teams that have invested in OpenTelemetry metrics can now treat CloudWatch as a more complete control surface for those signals. The path can be conceptually simpler: instrument the service, send the metric, use PromQL for analysis and alerting, and attach a supported scaling action where the workload and policy fit.

The trade-off is that the convenience moves responsibility into the query and the policy. A shared expression language does not remove the need for aggregation, thresholds, cooldowns, capacity limits, and failure testing. It makes those decisions more visible, which is useful when operators review why a fleet grew, shrank, or failed to respond.

A monitoring feature becomes operationally valuable when it connects observation to a controlled response. AWS’s PromQL alarm update does that for a defined set of scaling policies. For teams already speaking PromQL, the main opportunity is not to automate every signal; it is to choose a few workload metrics that describe capacity clearly, then let the same language carry them from dashboard to action.

This article is a general information summary based on the cited public sources. It is not legal, cybersecurity, or compliance advice.

Written By

PragnaTeja Bandiboyina

Web Designer

PragnaTeja Bandiboyina shares practical publishing insights, comparisons, and WordPress-focused growth guidance for modern web teams.

207 articles published Member since 2026