Terraform Apply Time Calculator

Estimate how long terraform apply will take based on resource count and parallelism.

About Terraform Apply Time Calculator

Terraform executes independent resource operations concurrently up to the -parallelism limit (default 10), so apply time is closer to total_work / parallelism than the sum of every operation's duration — bounded by the slowest single operation, since apply can't finish faster than its longest-running resource. Formula: serial_time = creates×create_time + modifies×modify_time + destroys×destroy_time; parallel_time ≈ max(longest_op, serial_time / min(parallelism, total_resources)).

Formulas

Serial time

serial_time = creates × avg_create_time + modifies × avg_modify_time + destroys × avg_destroy_time

creates: Resources to create
avg_create_time: Average creation time (sec)
modifies: Resources to modify
avg_modify_time: Average modify time (sec)
destroys: Resources to destroy
avg_destroy_time: Average destroy time (sec)

Parallel apply time

parallel_time = max(longest_op, serial_time / min(parallelism, total_resources))

longest_op: Duration of the slowest single operation
serial_time: Total serial time
parallelism: Terraform -parallelism value
total_resources: creates + modifies + destroys

Worked example

With the default values below, Terraform Apply Time Calculator returns Estimated Apply Time of 1.67. Change any input above and every figure here is recalculated in your browser.

Inputs used

Resources to Createaccepts 0–1,000,000 resources: 40 resources
Resources to Modifyaccepts 0–1,000,000 resources: 15 resources
Resources to Destroyaccepts 0–1,000,000 resources: 5 resources
Avg Create Timeaccepts 0.1–36,000 sec: 20 sec
Avg Modify Timeaccepts 0.1–36,000 sec: 10 sec
Parallelismaccepts 1–1,000 concurrent ops: 10 concurrent ops

Results

Estimated Apply Time: 1.67 min
Estimated Apply Time: 100 sec
Serial (No Parallelism) Time: 1,000 sec
Speedup from Parallelism: 10.00 ×

Step by step

1Serial time: creates×create_time + modifies×modify_time + destroys×destroy_time= 1000s
2Total resources touched= 60
3Parallel time at configured parallelism= 100s (1.67 min)

Assumptions and limits

The result is derived only from the 6 inputs listed above. Anything not among them is not part of the calculation.
In particular, this calculator does not take inflation, tax, fees or charges or compounding frequency into account.
Figures are rounded for display to 2 decimal places, so totals built from several rounded parts can differ slightly from the unrounded arithmetic.

How these calculators are built and tested is described on the Methodology page. If a figure looks wrong, please report it.

Frequently Asked Questions

Why can't apply finish faster than the longest single resource?

Terraform's dependency graph means some resources must wait on others, and even with unlimited parallelism, the critical path through dependent resources (e.g. a VPC before its subnets) sets a floor on total apply time — a single slow resource (like an RDS instance taking 10+ minutes) often dominates regardless of parallelism.

Does increasing -parallelism always speed up apply?

Only up to the number of independent (non-dependent) resources ready to apply at once, and up to API rate limits from your cloud provider — beyond that point, more parallelism just means more concurrent operations queueing on the same rate limit.

Why do create times vary so much by resource type?

Some resources (IAM roles, S3 buckets) are near-instant API calls, while others (RDS instances, EKS clusters, ACM certificate validation) involve provisioning infrastructure that takes minutes — use per-resource-type historical timing from your own applies for the most accurate average.

Should destroys always be assumed as fast as modifies?

Not necessarily — some resources have slow deletion (e.g. RDS instances with final snapshots, load balancers with dependent ENIs). If your destroys are known to be slower, model them separately rather than reusing the modify-time average.