Estimation in Maths: Rounding, Fermi Problems and Checks

Estimation means finding an answer that is roughly right, quickly, usually in your head. It is one of the most useful skills in maths, and one of the most underrated. It lets you check a calculator answer in two seconds, spot a misplaced decimal point, make sensible decisions when exact numbers are not available, and tackle questions that look impossible at first.

This guide covers the core technique, rounding to one significant figure, measures how accurate it really is across 10,000 calculations, shows how to estimate things nobody knows the exact answer to (Fermi problems), and explains the most practical use of all: catching mistakes.

The core technique: round to 1 significant figure

Round each number to its first non-zero digit, then do the easy calculation. 38 becomes 40, 21 becomes 20, 612 becomes 600, 4.87 becomes 5. The significant figures of a number are its digits starting from the first non-zero one, so 0.0347 rounded to 1 significant figure is 0.03.

Division works the same way: 612 ÷ 29 is about 600 ÷ 30 = 20 (the exact answer is 21.1). Here are the multiplications in code, followed by a test of how good this method is in general:

import math, random, statistics

def one_sig_fig(x):
    """Round to 1 significant figure: 38 -> 40, 612 -> 600, 4.87 -> 5."""
    power = 10 ** math.floor(math.log10(abs(x)))
    return round(x / power) * power

for a, b in [(38, 21), (4.87, 19.6), (612, 29)]:
    print(f"{a} x {b} = {a * b:g}   estimate {one_sig_fig(a):g} x {one_sig_fig(b):g} = {one_sig_fig(a) * one_sig_fig(b):g}")

# How good is this in general? Try 10,000 random multiplications of 2- and 3-digit numbers
rng = random.Random(7)
errors = []
for _ in range(10_000):
    a, b = rng.randint(10, 999), rng.randint(10, 999)
    est = one_sig_fig(a) * one_sig_fig(b)
    errors.append(abs(est - a * b) / (a * b) * 100)
errors.sort()
print(f"median error {statistics.median(errors):.1f}%")
print(f"9 in 10 estimates within {errors[int(0.9 * len(errors))]:.0f}%")
print(f"worst error {errors[-1]:.0f}%")

38 x 21 = 798   estimate 40 x 20 = 800
4.87 x 19.6 = 95.452   estimate 5 x 20 = 100
612 x 29 = 17748   estimate 600 x 30 = 18000
median error 7.1%
9 in 10 estimates within 22%
worst error 57%

How accurate is it?

Across 10,000 random multiplications of 2- and 3-digit numbers, the median error was 7.1%, and nine in ten estimates were within 22%. That is more than good enough to tell whether an answer is sensible. But the worst was 57% out.

The big errors come from numbers like 149 × 149, where both numbers are rounded down a long way (to 100 × 100 = 10,000, when the answer is 22,201). Two simple fixes: round one number up and the other down when both are near the middle, or keep two significant figures for numbers like 149 (150 × 150 = 22,500). Knowing when an estimate might be rough is part of the skill.

Using estimates to catch mistakes

The most practical use of estimation is checking. A calculator does exactly what you type, including your mistakes. A misplaced decimal point gives an answer ten times too big or too small, and it looks perfectly believable unless you know roughly what to expect:

def check(answer, estimate):
    ratio = answer / estimate
    if 0.5 <= ratio <= 2:
        return "looks right"
    return f"suspicious: {ratio:.0f} times the estimate" if ratio > 2 else f"suspicious: 1/{1 / ratio:.0f} of the estimate"

# 3.8 x 42.5 should be about 4 x 40 = 160
print("typed 3.8 x 42.5 ->", 3.8 * 42.5, check(3.8 * 42.5, 160))
print("typed 38 x 42.5  ->", 38 * 42.5, check(38 * 42.5, 160))
print("typed 3.8 x 4.25 ->", 3.8 * 4.25, check(3.8 * 4.25, 160))

typed 3.8 x 42.5 -> 161.5 looks right
typed 38 x 42.5  -> 1615.0 suspicious: 10 times the estimate
typed 3.8 x 4.25 -> 16.15 suspicious: 1/10 of the estimate

Fermi problems: estimating the unknown

Some questions have no exact answer anywhere, like "how many times does a heart beat in a lifetime?" The physicist Enrico Fermi was famous for estimating such things by breaking them into pieces he could guess, then multiplying. Questions like this are now called Fermi problems, and some interviews and olympiads use them to see how people think.

A resting adult heart beats roughly 60 to 100 times a minute, so take about 70. There are 60 × 24 × 365 minutes in a year, and a long life is about 80 years. Multiply, and also try the extremes:

# How many times does a heart beat in a lifetime? Estimate each piece, then multiply.
minutes_per_year = 60 * 24 * 365

low = 60 * minutes_per_year * 70     # slow heart, shorter life
mid = 70 * minutes_per_year * 80
high = 90 * minutes_per_year * 90    # fast heart, longer life
for name, n in [("low", low), ("middle", mid), ("high", high)]:
    print(f"{name:<6} {n:>15,}  about {n / 1e9:.1f} billion")

low      2,207,520,000  about 2.2 billion
middle   2,943,360,000  about 2.9 billion
high     4,257,360,000  about 4.3 billion

The middle estimate is about 2.9 billion, and even the most extreme guesses stay between 2.2 and 4.3 billion. That is the magic of Fermi problems: errors in the separate guesses partly cancel out, and the answer lands on the right order of magnitude, billions rather than millions or trillions. Knowing the order of magnitude is often all a decision needs.

• Break it down into pieces you can reasonably guess.
• Round generously to numbers that are easy to multiply.
• Try a low and a high version to see how much the answer could move.
• Ask if it is sensible: compare with something you already know.

Estimation in everyday life and in coding

• Shopping: round every item and keep a running total in your head.
• Time: 7 tasks of about 25 minutes is roughly 3 hours, not 1.
• Percentages: 18% of 490 is about 20% of 500 = 100. Our guide to calculating percentages has more shortcuts like this.
• Programming: before running a slow program, estimate: a loop of a million steps inside another of a million steps is a trillion steps, far too many. That estimate is the whole idea behind Big O notation.

An estimate is a promise about roughly what the answer will look like. When the real answer breaks that promise, look again.

How we teach it

Estimation matches two principles on our how we teach page. Students explain their thinking, and saying an estimate out loud before calculating is exactly that. And mistakes are data, not failures: an answer that does not match the estimate is a clue, not a disaster. Our live maths classes run one to one or in small groups of 5 to 10.

Frequently asked questions