Binomial Probability Distributions: Mean, Variance & Standard Deviation

Our free-throw shooter is back. She makes 70% of her shots, and she's about to take 10. We already know the expected number of makes is 7.

But "expected" doesn't mean "guaranteed". Some days she makes 5. Some days she makes 9. The number 7 is just the center of a whole spread of possible outcomes.

So here's the real question: how wide is that spread, and can we predict it without simulating a million games?

Turns out yes. And the way we get there is more interesting than the formula itself.

Forget the 10 shots. Start with just one.

Before we can talk about spread across 10 shots, we need to understand the spread in a single shot. One free throw. It lands on 0 (miss) or 1 (make). That's it.

This single yes/no event is called a Bernoulli trial, and even though it only has two possible outcomes, it still has a well-defined average and a well-defined wobble around that average.

The average is easy. If she makes a shot with probability $p$, then over many, many single shots, the average outcome is just $p$ itself. We write this as

The wobble is less obvious, but here's the intuition: the wobble is biggest when the outcome is most uncertain, meaning $p$ close to 0.5, and it shrinks to zero when the outcome is nearly certain, meaning $p$ close to 0 or 1. That balance is captured by

Drag $p$ toward 0.5 and watch the std dev band widen. Drag it toward the edges and watch it shrink toward nothing. A near-certain outcome has almost no wobble. A coin flip has the most.

Ten shots is just ten of these, stacked

Here's the trick that makes everything else fall into place. Ten free throws aren't one big complicated event, they're ten separate copies of the same simple Bernoulli trial, added together.

And here's the payoff: averages always add. It doesn't matter if the shots are related or independent, weird or well-behaved. If shot 1 has an average of $p$, and shot 2 has an average of $p$, and so on, then the total number of makes over $n$ shots has an average of

That's it. That's the whole proof for why the binomial mean is $np$. No combinatorics required.

Variance is a different story. Variances only add when the trials don't influence each other, when they're independent. Free throws qualify: one shot going in doesn't change the odds of the next one. So we get to add those too:

And standard deviation, being the square root of variance, is

Notice what just happened. Variance scales directly with $n$. But standard deviation scales with $\sqrt{n}$, because of that square root. That gap between "grows with $n$" and "grows with $\sqrt{n}$" is the whole story of why big samples feel more predictable than small ones.

Watch the pink mean line climb in a straight ramp as $n$ grows. Now watch the amber std dev curve. It climbs too, but it bends, falling further and further behind the straight line. By $n = 60$, the mean has grown 60 times over, but the standard deviation has only grown about 7.7 times over, because $\sqrt{60} \approx 7.75$.

That's why 1,000 free throws feels so much more "predictable" than 10. The average scales with the number of trials. The wobble around it scales with the square root.

What does "one standard deviation" actually cover?

Numbers like $np(1-p)$ are easy to compute but hard to feel. So let's make it concrete: how much of the actual probability sits inside one standard deviation of the mean?

Set $n = 30$, $p = 0.5$, and look at the ±1σ band. Most of the bars, the tall ones near the center, fall completely inside that shaded region. Read the stat box: it's landing close to 68%, matching the familiar rule for bell-shaped distributions. Push to ±2σ and watch it jump to roughly 95%.

This isn't a coincidence. As $n$ grows, the jagged binomial bars smooth out into something that looks almost exactly like a bell curve, so the same 68-95-99.7 rule that governs the normal distribution starts to apply here too.

Now try something else. Drag $p$ down toward 0.05 while keeping $n$ small. The bars pile up on the left, lopsided, and the ±1σ band no longer captures anywhere near 68%. The bell-curve approximation needs both a reasonably large $n$ and a $p$ that isn't too extreme. Standard deviation still means "typical spread", but "typical" only looks like the familiar bell shape under the right conditions.

Does this match what actually happens when you simulate it?

Everything above is a prediction. Let's test it against reality.

Hit play. Every tick runs a fresh batch of 10 simulated free throws at $p = 0.7$, and adds that outcome to a running tally. From that tally we compute the sample standard deviation, the actual spread we're observing, and compare it to the theoretical value $\sqrt{10 \times 0.7 \times 0.3} \approx 1.449$.

Early on, with only a few dozen runs, the green line jumps around. That makes sense, a small sample doesn't have enough data to reveal the true spread yet. Keep it running. Watch the "distance from theory" number in the stat box. It doesn't stay put, it shrinks, and the green line settles onto the dashed amber theoretical line.

This is the same law of large numbers at work again, just applied to the spread instead of the average. Run the experiment enough times, and the observed wobble converges to the predicted one.

The short version

A binomial distribution's mean and standard deviation don't require summing the whole probability formula across every outcome. They fall out of a much simpler idea: treat $n$ trials as $n$ separate Bernoulli trials, and let the math do the rest.

Averages add no matter what. Variances add only when trials are independent. And because standard deviation is a square root of something that scales with $n$, it always lags behind the mean, growing like $\sqrt{n}$ instead of $n$.

That single gap between the two growth rates explains why big samples settle down and feel predictable, while small samples stay noisy and jumpy. Same $p$, same coin, same shooter, the only thing that changes the reliability is how many times you let it run.

All simulations run live in the browser. The convergence simulator draws fresh Bernoulli trials with Math.random() on every animation tick, driven by requestAnimationFrame, no libraries beyond React.