Terraform Cloud Per-Resource (RUM) vs Scalr Per-Run: The 2.11 Breakeven Ratio

Terraform Cloud (now HCP Terraform) bills per resource under management (RUM) and Scalr bills per run, so which one costs less comes down to a single ratio: how many managed resources you hold for every billable run you execute in a month. Against HCP Terraform Standard, the two break even at 2.11 resources per monthly run. For three customer segments priced at list, Scalr Business costs 75% to 87% less than the Terraform Cloud tier each segment needs. This page derives that ratio from the public rate cards, prices an example estate for each of three customer segments with the arithmetic shown, states where HCP Terraform comes out cheaper, and ends with a script you can run against your own organization. Every figure uses undiscounted list prices as of October 2026.

For the plan-by-plan feature comparison, see Scalr vs Terraform Cloud pricing. This page is the math.

1. How much less does Scalr cost than Terraform Cloud (HCP Terraform) at list price?

HCP Terraform charges for every managed resource in state for every hour it exists, whether or not anyone changes it. Scalr charges for each billable run, a plan or an apply, and nothing for the resources a run manages. Infrastructure that sits stable in state (VPCs, IAM roles, databases, security groups) costs money every hour on the first meter and nothing between changes on the second. HashiCorp's own cost guidance follows from its meter: the first lever in the "Optimize costs" section of its cost-estimation docs is to "Review managed resources regularly and remove unused or unnecessary resources to reduce your managed resource count." On a per-run meter, the resource count isn't part of the bill.

Scalr is a drop-in replacement for Terraform Cloud: it runs the same cloud and remote backend, CLI workflow and API, so moving to the per-run meter is a data move of state, variables and workspaces, not a re-platforming.

For the three customer segments priced in section 4, Scalr Business costs 75% to 87% less than the HCP Terraform tier each segment requires, at published list prices on both sides. Across paying Scalr customers, the median holds 16.1 managed resources per monthly billable run, more than seven times the 2.11 breakeven against HCP Terraform Standard. Scalr publishes its volume pricing as prepaid monthly bundles, so the Scalr figures use them. HashiCorp's contract and Flex discounts aren't published, so the HCP Terraform figures stay at the per-resource rates; a negotiated HashiCorp contract narrows the gap.

Rate cards used (as of October 2026)

Sources: HashiCorp's pricing page and cost estimation docs; Scalr's pricing page and pricing FAQ. HashiCorp lists each paid rate as "Starting at" and publishes no volume tiers. A month here is the per-month figure HashiCorp publishes; its own worked example multiplies the hourly rate by 720 hours.

Neither free allowance carries into a paid plan. HashiCorp's worked example prices an Essentials organization with 1,000 managed resources at $97.85 a month, billing all 1,000. Scalr's pricing calculator prices 100 runs a month at $99, billing all 100. The formulas below therefore subtract nothing on either side.

How Scalr's volume pricing works

Scalr's per-run price falls automatically with volume. It starts at $0.99 a run, falls to $0.89 at 15,000 runs a month on the published monthly bundles in the pricing calculator, and goes as low as $0.60 a run on large annual commitments. Runs beyond a prepaid bundle bill at $0.99 each, and the cheapest choice is whichever of "bundle plus extra runs" or "next bundle up" costs less. The examples in section 4 use the published monthly bundles, not annual pricing.

2. What is the breakeven resource-to-run ratio?

Let R be managed resources and N be billable runs per month. HCP Terraform Standard costs 0.47 × R and Scalr Business costs 0.99 × N. They're equal when:

Breakeven ratio = Scalr price per run / HCP Terraform price per resource per month
 
Scalr Business vs HCP Terraform Standard:   0.99 / 0.47 = 2.11 resources per monthly run
Scalr Business vs HCP Terraform Essentials: 0.99 / 0.10 = 9.90 resources per monthly run
Scalr Business vs HCP Terraform Premium:    0.99 / 0.99 = 1.00 resources per monthly run

These use the $0.99 per-run ceiling. Prepaid bundles lower Scalr's effective rate as volume grows, to $0.89 a run at 15,000 runs a month ($13,355 / 15,000), which lowers the breakeven against Standard to 0.89 / 0.47 = 1.89.

Above the breakeven ratio, Scalr costs less. Below it, HCP Terraform costs less.

In engineering terms: for HCP Terraform Standard to cost less than Scalr Business, an organization has to execute more than one billable plan or apply every month for every 2.11 resources in its state files. An estate of 10,000 managed resources would need more than 4,747 billable runs a month, about 158 a day, every day. That pattern exists (see section 5), but most estates don't look like that. A network module that defines 40 subnets, route tables and security group rules gets planned when someone changes it, which might be twice a month, and is billed 40 times every hour by a per-resource meter in between.

The savings at a given ratio r follow from the same two prices: Scalr Business saves 1 − 0.99 / (0.47 × r) against Standard. At r = 10 that's 78.9%; at r = 20 it's 89.5%.

3. Which meters and feature gates change the total?

What each meter bills, and what it leaves out

Two billed items cut against Scalr and belong in any estimate. Speculative plans are free on HCP Terraform and billable on Scalr, so a workflow with heavy pull-request traffic and few applies pushes the ratio down. Plan-phase failures are billable on Scalr. The script in section 6 counts both.

Which features sit behind which tier

4. What do real workloads and customer segments show?

Measured ratio across paying Scalr customers

Across customers paying Scalr on October 28, 2026 that manage at least 100 resources and executed at least one billable run in September 2026, the resource-to-run ratio (managed resources per monthly billable run) is:

• 25th percentile (high-churn, active development): 7.4:1
• 50th percentile (median production): 16.1:1
• 75th percentile (stable core and foundational infrastructure): 37.1:1

The 25th percentile is 3.5 times the 2.11 breakeven against HCP Terraform Standard, the median 7.6 times and the 75th percentile 17.6 times. About 4% of these customers sit below it. About 35% sit below the 9.9 breakeven against Essentials, so for roughly a third of them, Essentials would cost less if they didn't need the features Essentials leaves out.

How the numbers were measured: managed resources were counted as resource instances (each count and for_each copy counts once, as HashiCorp's RUM does) on October 2, 2026, excluding null_resource and terraform_data, the same exclusions HashiCorp's RUM count makes. Billable runs are those executed in September 2026, using Scalr's own billing rules (scheduled drift detection runs and the non-billable failures listed in section 3 excluded). Where a customer has several Scalr accounts, their resources and runs are summed before the ratio is taken. All figures are medians with the interquartile range (25th to 75th percentile) of each customer's own ratio, interpolated linearly between ranks; apart from the inclusion rules above, no customers were trimmed as outliers. One bias runs in Scalr's favor: these are teams that chose a per-run meter, and teams with very high run rates have a reason not to.

Three customer segments and the plans they map to

The pricing below uses three customer segments. Each segment's typical requirements decide which HCP Terraform tier it needs, and an example estate for each segment prices that tier against Scalr. The requirements are the ones this benchmark assigns to each segment, not a survey of customers.

Drift detection is what moves the first two segments off Essentials: HashiCorp includes health assessments only in Standard and Premium. A self-hosted VCS is what puts the regulated segment on Premium: HashiCorp documents private VCS connections as Premium only. Scalr Business covers all three requirements at no extra cost.

The measured ratio for each segment, from the same September 2026 measurement:

Among Scalr's paying customers, growth SaaS companies run the most plans and applies per managed resource. About 10% of them sit below the 2.11 breakeven against HCP Terraform Standard, and about half sit below the 9.9 breakeven against Essentials, so for those without a need for drift detection, Essentials would cost less. No mid-market or regulated customer measured sits below 2.11. Segments come from a reviewed classification of customers by industry; the few whose industry couldn't be established are left out of this table but stay in the overall figures above.

Priced example for each segment

Formulas, so each cell can be checked with a calculator:

1. HCP Terraform = R × tier rate. Growth SaaS: 3,000 × $0.47 = $1,410.00. Mid-market: 10,000 × $0.47 = $4,700.00. Regulated enterprise: 25,000 × $0.99 = $24,750.00. No 500-resource deduction applies on paid plans.
2. Scalr = the largest prepaid monthly bundle at or below N, plus $0.99 for each run above it (the pricing calculator's bundles; buying the next bundle up costs more in all three cases). Growth SaaS: $295 for 300 runs + 50 × $0.99 = $344.50. Mid-market: $1,140 for 1,200 runs + 50 × $0.99 = $1,189.50. Regulated enterprise: $2,783 for 3,000 runs + 550 × $0.99 = $3,327.50. No 50-run deduction applies on a paid month.
3. Saving = 1 − Scalr ÷ HCP Terraform. Growth SaaS: 1 − 344.50 / 1,410 = 75.6%. Mid-market: 1 − 1,189.50 / 4,700 = 74.7%. Regulated enterprise: 1 − 3,327.50 / 24,750 = 86.6%.

At the $0.99 per-run rate with no bundle, Scalr would cost $346.50, $1,237.50 and $3,514.50, and the savings would be 75.4%, 73.7% and 85.8%.

All three segment examples sit near the measured 25th percentile (7.4) and well below the median (16.1), so they model busier-than-typical estates and understate the median gap. Their resource counts are close to each segment's median estate, while their run counts are well above each segment's median, so the savings shown are a floor rather than a typical result. B and C also sit below their own segment's 25th percentile (9.5 for mid-market, 16.1 for regulated enterprise); A sits between the growth SaaS 25th percentile and median. Four notes on tier choice:

• Both plans priced for the regulated enterprise example meet all three of its requirements. On HCP Terraform, the private VCS connection requires Premium, and 15 concurrent agent runs exceed Standard's 10, which would otherwise mean buying add-on concurrency at a price HashiCorp doesn't publish. Scalr Business includes VCS agents for a private VCS, and each self-hosted agent adds five concurrent runs at no charge, so three agents cover 15. Most Scalr customers with estates of that size are on Business.
• The mid-market SSO requirement doesn't change its tier: SSO is on every plan of both products. Drift detection is what puts the mid-market example on Standard.
• If the regulated enterprise example also needed audit logs or customer-managed keys, HCP Terraform Premium already includes them (audit trails start at Standard; hold your own key is Premium). On Scalr both come with Enterprise or as add-ons, priced by quote, so Scalr's figure would rise and the saving would narrow. Scalr Enterprise is priced by quote, and at that price it also costs less than HCP Terraform Premium for the large majority of the customers measured above. Without the private VCS, it would fit HCP Terraform Standard plus add-on concurrency: 25,000 × $0.47 = $11,750.00 before the add-on, against which Scalr saves 1 − 3,327.50 / 11,750 = 71.7%.
• The growth SaaS and mid-market examples fall below the 9.9 Essentials breakeven. Without the need for drift detection, the growth SaaS example would cost $300.00 a month on Essentials (3,000 × $0.10) against Scalr's $344.50, and HCP Terraform would be the cheaper option.

5. When is HCP Terraform less expensive than Scalr?

HCP Terraform costs less whenever the resource-to-run ratio falls below the breakeven for the plans being compared and the cheaper HCP Terraform tier covers the requirements. The boundaries, at list price:

A worked case: an ephemeral test harness with 600 managed resources that applies automatically 25 times a day, needs no drift detection, no audit logging and no extra concurrency. Over a 30-day month that's 750 runs, a ratio of 600 / 750 = 0.8.

• HCP Terraform Essentials: 600 × $0.10 = $60.00 a month.
• Scalr Business: $674 for a 700-run bundle + 50 × $0.99 = $723.50 a month.

HCP Terraform is $663.50 a month cheaper here, and would still be cheaper on Standard (600 × $0.47 = $282.00). A per-run meter charges for churn. If an estate is small and changes constantly, the per-resource meter fits it better, and that's the case to keep it.

Discounts move every boundary. HashiCorp sells contract and Flex plans at lower rates it doesn't publish, and Scalr discounts prepaid runs by volume (1,000 runs a month lists at $954, $0.954 a run). For the growth SaaS example, HCP Terraform Standard ties with Scalr's list price at a discount of 75.6% off list.

6. How can you verify your own ratio?

The script below reads your HCP Terraform organization with a read-only token and prints your resource-to-run ratio and the list-price monthly bill on each plan of both products. It uses only the Python 3 standard library (urllib.request and json), runs on your machine, and sends requests to your HCP Terraform host only. Nothing goes to Scalr.

What it does:

• Sums managed resources from the Explorer API's current-rum-count, HashiCorp's RUM figure. Explorer needs an organization token or a team with read access to all workspaces; without it, or when no workspace has a RUM count yet, the script falls back to each workspace's resource-count, which may include resources RUM excludes.
• Counts runs from the last 30 days on the organization runs endpoint, all operations including plan-only runs (retrying without action_only on hosts that predate it), and leaves out canceled runs. HashiCorp limits that endpoint to 30 requests a minute, so the script pauses about two seconds between pages; a busy organization takes a few minutes.
• Counts errored runs as billable. Scalr doesn't bill most of them (init failures, pre-plan policy stops), so the Scalr figure it prints is an upper bound.

export TFC_TOKEN={read-only-token}
export TFC_ORG={organization-name}
export TFC_HOST=app.terraform.io   # optional: app.eu.terraform.io or a Terraform Enterprise hostname
export DAYS=30                     # optional: run window to sample
python3 tfc_cost_audit.py

#!/usr/bin/env python3
"""Compare an HCP Terraform organization's list-price bill with Scalr's per-run list price.
 
Reads the HCP Terraform API with a read-only token and runs entirely on your machine.
It makes GET requests to your HCP Terraform host and nothing else: no data goes to Scalr.
 
Usage:
  export TFC_TOKEN=...            # read-only user, team or organization token
  export TFC_ORG=my-org
  export TFC_HOST=app.terraform.io  # optional; app.eu.terraform.io or a TFE hostname
  export DAYS=30                  # optional; run window to sample (default 30)
  python3 tfc_cost_audit.py
"""
import json
import os
import sys
import time
import urllib.error
import urllib.parse
import urllib.request
from datetime import datetime, timedelta, timezone
 
# Public list prices, as of October 2026. Edit these if the rate cards change.
HCP_FREE_RESOURCES = 500  # the Free tier covers up to 500 managed resources; paid tiers bill every one
HCP_PER_RESOURCE_MONTH = {"Essentials": 0.10, "Standard": 0.47, "Premium": 0.99}
SCALR_FREE_RUNS = 50      # Scalr is free up to 50 runs a month; a paid month bills every run
SCALR_FLEX_RATE = 0.99   # per run beyond a prepaid bundle; Enterprise is priced by quote
# Scalr Business prepaid monthly bundles from scalr.com/pricing: (runs, price)
SCALR_BUNDLES = [(100, 99), (200, 198), (300, 295), (400, 390), (500, 485), (700, 674),
                 (1000, 954), (1200, 1140), (1500, 1417), (2000, 1875), (2500, 2330),
                 (3000, 2783), (4000, 3684), (5000, 4579), (6000, 5469), (7500, 6797),
                 (10000, 8997), (12500, 11182), (15000, 13355)]
 
RUN_OPERATIONS = "plan_only,plan_and_apply,save_plan,refresh_only,destroy,empty_apply,action_only"
NOT_BILLED_STATUSES = {"canceled", "force_canceled"}
 
TOKEN = os.environ.get("TFC_TOKEN")
ORG = os.environ.get("TFC_ORG")
HOST = os.environ.get("TFC_HOST", "app.terraform.io")
DAYS = int(os.environ.get("DAYS", "30"))
BASE = f"https://{HOST}/api/v2"
 
 
def get(path, params=None, pause=0.05):
    """GET one JSON:API page, retrying on 429 with backoff."""
    url = path if path.startswith("http") else BASE + path
    if params:
        url += ("&" if "?" in url else "?") + urllib.parse.urlencode(params)
    req = urllib.request.Request(url, headers={
        "Authorization": f"Bearer {TOKEN}",
        "Content-Type": "application/vnd.api+json",
    })
    for attempt in range(6):
        try:
            with urllib.request.urlopen(req, timeout=60) as resp:
                time.sleep(pause)
                return json.load(resp)
        except urllib.error.HTTPError as err:
            if err.code == 429:
                time.sleep(float(err.headers.get("Retry-After") or 2 ** attempt))
                continue
            raise
    sys.exit(f"Gave up after repeated rate limiting on {url}")
 
 
def pages(path, params, pause=0.05):
    """Yield every item across pages, following meta.pagination.next-page."""
    page = 1
    while page:
        body = get(path, {**params, "page[size]": 100, "page[number]": page}, pause)
        yield body.get("data", [])
        page = body.get("meta", {}).get("pagination", {}).get("next-page")
 
 
def managed_resources():
    """Sum resources under management. Prefers the Explorer API's RUM count; falls back to resource-count."""
    try:
        total, known, unknown = 0, 0, 0
        for rows in pages(f"/organizations/{ORG}/explorer", {"type": "workspaces"}):
            for row in rows:
                count = row.get("attributes", {}).get("current-rum-count")
                if count is None:
                    unknown += 1
                else:
                    known += 1
                    total += count
        if known:
            note = "Explorer API, current-rum-count"
            if unknown:
                note += f" ({unknown} workspaces still calculating; counted as 0)"
            return total, note
        # No workspace has a RUM count yet (or the host doesn't report one): fall back.
    except urllib.error.HTTPError as err:
        if err.code not in (400, 403, 404):
            raise
    total = 0
    for rows in pages(f"/organizations/{ORG}/workspaces", {}):
        total += sum(w["attributes"].get("resource-count") or 0 for w in rows)
    return total, "workspace resource-count (may include null_resource and terraform_data)"
 
 
def runs_in_window(cutoff):
    """Count runs of every operation, plan-only included, which the endpoint leaves out by default.
 
    Hosts that predate the action_only operation reject it with a 400, so retry without it.
    """
    try:
        return count_runs(cutoff, RUN_OPERATIONS)
    except urllib.error.HTTPError as err:
        if err.code != 400:
            raise
        return count_runs(cutoff, RUN_OPERATIONS.replace(",action_only", ""))
 
 
def count_runs(cutoff, operations):
    """Count runs created since cutoff. The org runs endpoint allows 30 requests a minute."""
    counted, statuses = 0, {}
    for rows in pages(f"/organizations/{ORG}/runs",
                      {"filter[operation]": operations, "filter[timeframe]": "year"},
                      pause=2.1):
        in_window = 0
        for run in rows:
            created = datetime.fromisoformat(run["attributes"]["created-at"].replace("Z", "+00:00"))
            if created >= cutoff:
                in_window += 1
                status = run["attributes"].get("status", "unknown")
                statuses[status] = statuses.get(status, 0) + 1
        counted += in_window
        if rows and in_window == 0 and os.environ.get("FULL_SCAN") != "1":
            break  # runs come back newest first; a page with none in the window ends the scan
    return counted, statuses
 
 
def hcp_bill(resources, rate):
    return 0.0 if resources <= HCP_FREE_RESOURCES else resources * rate
 
 
def scalr_bill(runs):
    """Cheapest list price: no bundle, or a bundle plus $0.99 for each run beyond it."""
    if runs <= SCALR_FREE_RUNS:
        return 0.0
    options = [runs * SCALR_FLEX_RATE]
    options += [price + max(0, runs - size) * SCALR_FLEX_RATE for size, price in SCALR_BUNDLES]
    return min(options)
 
 
def main():
    if not TOKEN or not ORG:
        sys.exit("Set TFC_TOKEN and TFC_ORG.")
    cutoff = datetime.now(timezone.utc) - timedelta(days=DAYS)
    resources, source = managed_resources()
    runs, statuses = runs_in_window(cutoff)
    excluded = sum(n for s, n in statuses.items() if s in NOT_BILLED_STATUSES)
    monthly_runs = round((runs - excluded) * (365 / 12) / DAYS)
 
    print(f"\nHCP Terraform organization: {ORG} ({HOST})")
    print(f"Managed resources:          {resources:,}   [{source}]")
    print(f"Runs in last {DAYS} days:       {runs:,}   (canceled, not counted: {excluded:,})")
    print(f"Runs per month (estimate):  {monthly_runs:,}")
    for status, n in sorted(statuses.items(), key=lambda kv: -kv[1]):
        print(f"    {status:<22}{n:>8,}")
    if monthly_runs:
        print(f"\nResource-to-run ratio:      {resources / monthly_runs:,.2f} resources per monthly run")
    scalr = scalr_bill(monthly_runs)
    run_rate = scalr / monthly_runs if scalr else SCALR_FLEX_RATE
    print("\nMonthly list price (Scalr with its published bundles; HCP Terraform without contract discounts)")
    print(f"  Scalr Business              ${scalr:>12,.2f}   = {monthly_runs:,} runs, ${run_rate:.4f} a run")
    for tier, rate in HCP_PER_RESOURCE_MONTH.items():
        print(f"  HCP Terraform {tier:<11}   ${hcp_bill(resources, rate):>12,.2f}"
              f"   = {resources:,} resources x ${rate:.2f}")
    print("\nScalr against each HCP Terraform tier (negative: Scalr costs more)")
    for tier, rate in HCP_PER_RESOURCE_MONTH.items():
        hcp = hcp_bill(resources, rate)
        saving = f"{(1 - scalr / hcp) * 100:+6.1f}%" if hcp else "   n/a"
        print(f"  Scalr Business vs {tier:<11} {saving}"
              f"   breakeven {run_rate / rate:5.2f} resources per monthly run")
    print("\nErrored runs are counted, so the Scalr figure is an upper bound: Scalr does not bill runs"
          " that fail in init, pre-plan policy checks or cost estimation, or scheduled drift detection.")
 
 
if __name__ == "__main__":
    main()

Edit the price constants at the top if your quote differs from list. For a Scalr quote at volume pricing, the pricing calculator gives the per-run rate for a given monthly or annual run count, and migrating from Terraform Cloud covers what the move itself involves.