ETA Calculator

Math

Compute estimated time of arrival from rate and remaining work with custom units for sprint planning and long-running batch task progress projections.

15.0% done
Time remaining
2.83 h
150 / 1,000 (15.0%)
rate
5.000 / min
Rate (per hour)
300.0 / hour
remaining
850
ETA (minutes)
170.0

About ETA Calculator

When running a huge data import, training a model, or downloading massive files, the question you most want answered is "how much longer, and when will it finish?" This tool uses the simplest reliable approach: linear extrapolation. From the amount done and the time elapsed it derives the current rate, then divides the remaining amount by that rate to estimate the time left, showing the projected finish time and a progress bar too. Just enter total, done, and elapsed minutes, and the result updates anytime. All estimation runs locally in your browser with no backend, ideal for a quick check between batch runs. For example, total 1000, done 400, elapsed 20 minutes estimates about 30 minutes left, with a projected finish time.

Estimation is extrapolating the remaining time from an average rate, so its accuracy depends entirely on the rate being stable. Early in a task the rate has not settled and the error is large, and only once it stabilises does the estimate become trustworthy. Expect the figure to swing early and prefer to rely on it past the halfway mark, since acting early on noise misleads.

Treating the estimate as a range rather than a point is the most important habit. Real execution brings pauses, retries and preemption that all push completion past a projection from the current rate. Use the estimate as a lower bound and add margin rather than treating it as a commitment; promising at optimistic value times a small factor fits reality better than quoting the estimate.

Unit conversion is error-prone across contexts. Progress may be counted in items, files or percent while the rate is per second, per minute or per batch, and mixing them changes the result by orders of magnitude. Unifying units first is basic, and where the rate is very small or large the eye is unreliable at magnitudes, so convert explicitly and recheck.

Comparing with a peer exposes systematic bias. When the same task estimates several times apart across tools or people, the problem is usually not the algorithm but a different definition of done: all items processed versus the main part processed. Align on the completion standard before using estimates externally, which helps more than retuning parameters.

Finally, know which tasks it suits. For batch work with many items of similar duration, extrapolating from an average rate works well, while for few steps of widely varying duration the average is unrepresentative and estimation adds little. Its reliability comes from many homogeneous samples; fewer samples and more variation leave the number as reference only.

The figure describes only how long the current pace needs and says nothing about what comes next. If the second half runs heavier steps such as aggregation, validation or queueing, a rate drawn from the early phase is clearly optimistic. Before using it to communicate, confirm the remaining work matches the earlier work in nature; when it does not, estimate each segment and add them.

How It Works Internally

Estimation uses plain linear extrapolation: completed count divided by elapsed time gives a rate, and remaining count divided by that rate gives the time left. It assumes a constant rate, whereas real jobs run fast early and slow later or fluctuate, so the answer should be a range rather than a fixed moment; when unit cost varies widely, estimating by workload beats estimating by item count.

Input300 items done in 5 minutes, 700 remaining
OutputAbout 11.7 more minutes (extrapolated from the current average rate; the more the rate varies, the wider the range)

Measured on This Page

Rate and remaining150/30 = 5.000 /min with 850 remaining, matching the page
ETA unit switch170 minutes → 2.83 h (switches to hours past 60, two decimals)
Division guarddone=0 produces no result at all — never Infinity
Over-complete guarddone>total clamps remaining to 0 (Math.max) instead of going negative
Hydration safetyThe completion time depends on Date.now(), so SSR and client text necessarily differ — nowMs is only written after onMounted, keeping the first hydration frame identical (a real production finding from 2026-10-03)

A linear ETA implicitly assumes the remaining pace equals the past pace — real throughput fluctuates, so treat the number as a trend, not a promise. Watch the unit thresholds: 60 minutes to hours and 24 hours to days is where minute/hour tools most often get base-60 wrong (this page is correct). And clamping the remaining count to 0 when done exceeds total matters because a negative remaining would render absurd durations like '-0.5 h' downstream.

How this was measured: Total 1000 / done 150 / elapsed 30 minutes compared with an independent Python calculation for rate (5/min), remaining (850), progress (15%) and ETA (170 min → 2.83 h); done=0 (division guard) and done>total (remaining never negative) were also exercised. · Measured 2026-10-30

How to Use

  1. Open "ETA Calculator"
  2. Enter the total items and how many are done
  3. Set the elapsed time in minutes
  4. See remaining time, progress, and finish clock
  5. Copy the numbers you need for your update

Use Cases

  • Data migration — When importing millions of rows, estimate total finish time from rows migrated so far.
  • Model training — Use completed steps and elapsed time to predict hours left in training.
  • Bulk downloads — Estimate remaining time from files downloaded to plan when to step away.
  • Render jobs — Project a video or image render finish time from frames already rendered.
  • Progress reports — Share the current percentage and projected finish with the team for scheduling.
  • Database restore — Estimate restore completion time from the MB processed so far versus the total backup size.
  • File transfer — Project remaining time for a large rsync or S3 sync from the bytes transferred so far.

FAQ

How does it compute the time left?

Rate equals done divided by elapsed, and time left equals remaining divided by rate. This is linear extrapolation assuming future speed matches the current average.

Why does the real finish come earlier or later?

The linear model ignores rate swings. If the later stage slows (large files last) or speeds up (cache hits), actual time will drift, so re-estimate as progress advances.

Does the time-left unit change?

Yes, it adapts: under a minute shows seconds, tens of minutes show minutes, over an hour shows hours, and over a day shows days, for easier reading.

Must elapsed time be in minutes?

Yes, the field is in minutes and accepts decimals. For 90 seconds enter 1.5, and the tool converts to a suitably scaled time left.

Why is there no result when done is 0?

The rate cannot be computed (division by zero), so some progress is required to extrapolate. Come back after the job has made some headway.

The estimated finish time keeps jumping around. Why?

Linear extrapolation assumes a constant rate, while real jobs usually run fast early and slow later, or fluctuate with large files, network retries and rate limiting downstream. A jumping figure means the recent rate is unstable, so use an average over a window rather than the latest instantaneous value, and present the estimate as a range rather than a commitment.

When is linear extrapolation the wrong tool?

It fails when unit costs vary widely or a serial bottleneck exists: estimating by file count when sizes span orders of magnitude, or by item count when some items need human review, both skew the result badly. Estimate by workload rather than count, or sample the duration distribution first and reason from the distribution rather than the mean, which is what makes the resulting range credible.

The ETA differs a lot from reality?

The estimate is only as good as your rate assumption: if the pace is not constant, the prediction drifts — a fast-start task gives an optimistic mid-point ETA. Updating the rate in segments (or using a moving average) narrows the gap but never removes it.