Why Your Voltage Divider Drops Under Load (With Real Numbers)

Two resistors, one formula, and it is the first circuit almost everyone builds:

Vout = Vin x R2 / (R1 + R2)

Then you connect something to the output and the voltage is not what the formula said. This is the single most common surprise in beginner electronics, and it is not a mistake in your arithmetic. The formula is correct — it is just answering a different question from the one you asked.

What the formula actually assumes

The divider equation assumes no current leaves the midpoint. All the current that flows through R1 continues through R2, which is what makes the two voltages split in proportion to the two resistances.

The moment you attach anything to that midpoint, some of the current goes into your load instead of into R2. The split changes, and so does the voltage.

The collapse, measured

Every number below came from running the circuit in ngspice, not from the formula.

Start with a 12 V supply and two 10 kΩ resistors. Unloaded, the midpoint sits exactly where you expect:

V1 in 0 12
R1 in mid 10k
R2 mid 0 10k

Result: 6.0000 V.

Now attach a 10 kΩ load from the midpoint to ground — anything that draws a little current:

A third of the output is gone, and nothing about the divider changed.

Why the drop is exactly that size

Your load is in parallel with R2, and parallel resistance is always smaller than either resistor alone. A 10 kΩ load across a 10 kΩ R2 gives 5 kΩ. Put that back in the formula:

Vout = 12 x 5k / (10k + 5k) = 4 V

So the divider is still obeying the equation. It is just that R2 is no longer 10 kΩ from the circuit's point of view. Once you see the load as part of the lower leg, the number stops being surprising.

The version that fails badly

The measurement above is mild because the load was large. The failure people actually hit is trying to use a divider as a power supply — dropping 12 V to 5 V to run a small module.

Size the divider for 5 V unloaded, then connect a module drawing about 20 mA, which is a 250 Ω load:

Five volts became four tenths of a volt. Nothing is broken and nothing burned out. A divider made of 7 kΩ and 5 kΩ resistors simply cannot deliver 20 mA at 5 V — the current it can supply is set by its own resistors, and that is far less than the load wants.

This is the rule worth remembering: a voltage divider is a reference, not a supply. If the thing you are connecting draws real current, you want a regulator, not two resistors.

How to size one that holds

If the load is light and you just want the error to be small, make the divider stiff — use smaller resistors, so the load is large compared with them.

Same load, same ratio, same 6 V target — only the resistor values changed, and the error fell from a third to under five percent.

The usual guideline is to make the divider resistance roughly ten times smaller than the load impedance, which lands you near that 5% figure. That is where the 10x rule of thumb comes from; it is not magic, it is just this calculation run backwards.

Smaller resistors are not free, though. The stiffer the divider, the more current it burns continuously, and that current is dissipated as heat in the resistors themselves — which is a second thing worth checking before you build.

When a divider is the right answer

Dividers are excellent when the thing reading the midpoint draws almost nothing:

• Scaling a voltage down to measure it. An Arduino analog input is effectively megaohms, so a 10k/10k divider reading a 12 V battery loads it by almost nothing.
• Setting a reference for a comparator or an op-amp input.
• A potentiometer, which is just a divider you can turn.

And when the load does draw current, the standard fix is to put a unity-gain op-amp buffer between the divider and the load. The buffer draws almost nothing from the divider and supplies the load itself.

Check yours before you build it

The fastest way to know whether loading will bite you is to add the load to the schematic and run it. In CircuPilot you can describe the circuit in plain English — "a 12 V source with a 10k and 10k divider and a 10k load on the midpoint" — and it builds the schematic and runs real ngspice on it. Add the load, run it, and read the midpoint. Every number in this article was produced that way.

The useful habit is to simulate the divider with the load attached, not on its own. On its own it will always agree with the formula, which is exactly why the surprise waits until the breadboard.

Try it in the browser →