Why Quantum Computers Make So Many Errors (and How We Fight Back)

Your laptop performs billions of operations every second, and essentially none of them go wrong. Transistors are so reliable that most software is written as if errors simply don't exist. A quantum computer is the opposite. On today's best machines, roughly one in every thousand two-qubit operations fails, and on many machines it's closer to one in a hundred. Run a few thousand operations and an error is almost guaranteed.

That's not because quantum engineers are careless. It's because of something deep about what a qubit is. This post explains where quantum errors come from (noise, decoherence, gate errors, measurement errors, crosstalk and environmental interference), why they add up so fast, and how quantum error correction turns unreliable physical qubits into reliable logical ones.

The Root Cause: A Qubit Must Be Isolated and Controllable at Once

Every error in this post comes from one built-in conflict.

To keep its quantum state, a qubit has to be perfectly isolated from the outside world. Any interaction with its surroundings acts like an accidental measurement and leaks its information away.

But to compute, a qubit has to be perfectly controllable. You must be able to reach in with pulses, make it interact with its neighbours, and read it out.

Those two goals pull in opposite directions. Every wire that lets you control a qubit is also a path for noise to reach it. Every coupling that lets two qubits interact when you want them to also lets them disturb each other when you don't. Quantum hardware engineering is the art of balancing those two demands, and errors are what leak through the balance.

Why classical computers don't have this problem

There's a second, subtler reason classical computers are so reliable: they're digital. A transistor's output is either clearly "high" or clearly "low", and every logic gate snaps a slightly-off signal back to a clean 0 or 1 before passing it on. Small errors are erased at every step, billions of times per second.

A qubit can't do that. Its state is a continuous point on a sphere, and gates are smooth rotations of that point. There's no way to "snap it back" to the nearest correct value, because checking where it is would be a measurement, and measurement destroys the superposition. Small quantum errors aren't cleaned up between gates; they accumulate.

The Big Picture: Many Sources, One Wrong Answer

Errors fall into three broad families, noise, decoherence and control errors, and they show up in practice as six specific problems. Let's take them one at a time.

1. Noise: Random Kicks From Outside

What it is. Noise is any random, uncontrolled fluctuation that reaches the qubit: tiny jitters in electric charge, magnetic field or electrical current in the materials around it, stray microwave photons travelling down the wires, faint thermal energy.

What it does. Each fluctuation nudges the qubit's state a little, slightly rotating it, or slightly shifting its frequency so that it falls out of step with the control pulses. A single nudge is tiny; millions of them, at random, add up to a blurred state.

An everyday picture. Radio static. The music is still there, but the hiss makes it harder and harder to hear clearly, and the further you are from the transmitter, the worse it gets.

One noise type deserves a name. Many materials produce slow, wandering fluctuations called 1/f noise ("one-over-f"), which is strongest at low frequencies. It makes qubit properties drift over seconds, minutes and hours, which is a big part of why quantum computers need constant recalibration.

2. Decoherence: The State Leaks Away

Decoherence is noise's long-term consequence: the gradual loss of a qubit's quantum behaviour as its environment, interaction by interaction, "learns" about it. Engineers measure it with two clocks.

T1, energy relaxation. A qubit in state 1 holds slightly more energy than one in state 0. Left alone, it eventually gives that energy to its surroundings and drops to 0, like a ball rolling to the bottom of a hill. T1 is the typical time this takes.

T2, dephasing. Even without losing energy, a qubit can lose its phase, the hidden ingredient that decides how its amplitudes interfere. Picture a group of runners who start a lap perfectly together; tiny differences in speed mean that after a while they're spread around the track, and you can no longer say "where the group is". T2 is how long the phase stays in step. It can never be longer than twice T1, and in practice it's often shorter.

Coherence is best thought of as a clock that starts the moment your circuit begins. Every gate, every pause and every measurement has to finish before it runs out. But as the next section shows, on today's machines, gate errors usually end the computation before coherence does.

3. Gate Errors: Each Operation Is Slightly Wrong

What it is. A quantum gate is a carefully shaped pulse that rotates the qubit's state by an exact angle. If the pulse is a fraction too strong, too weak, slightly mistimed or slightly off-frequency, the rotation is a little wrong: an over-rotation or under-rotation.

Why it happens. Calibration drifts. The electronics have tiny imperfections. Pulses get slightly distorted travelling down cables. Two-qubit gates are hardest, because they need two qubits to interact strongly for a precise time, then stop interacting completely.

Leakage. Some qubits, including superconducting transmons, have more than two energy levels. A badly shaped pulse can push the qubit up into a third level, outside the 0/1 space entirely. That's called leakage, and it's especially damaging because many error-correction schemes assume errors stay inside the 0/1 space.

Why small, consistent errors are especially dangerous

Not all gate errors are equal. A random error (sometimes a little too far, sometimes a little short) tends to partly cancel out over many gates. A consistent error, the same small over-rotation every time, piles up in one direction.

Here's how big the difference is. Suppose a gate over-rotates by just 1 degree, and you apply it 100 times in a row:

The same tiny imperfection becomes a near coin-flip, simply because it's consistent. That's why compilers deliberately randomise circuits (a technique called twirling, described in the stage 02 flagship) to turn consistent errors into random ones, and why calibration has to be so precise.

4. Measurement Errors: Reading the Wrong Answer

What it is. Even when the computation is perfect, the final readout can return the wrong bit.

Why it happens.

• Overlapping signals. Measurement turns a faint signal into a 0 or 1 by comparing it with a threshold. Noise spreads the "0" and "1" signals out, and where they overlap, some shots land on the wrong side.
• Decay during the measurement. A measurement takes around a microsecond on superconducting hardware. A qubit in 1 can relax to 0 part-way through, and be read as 0. That's why "1 read as 0" is usually more common than the reverse.
• Disturbing the neighbours. The readout signal itself can slightly disturb nearby qubits, which matters when measuring some qubits in the middle of a circuit while others keep computing.

How big. Around 0.5% to 3% per qubit on many current machines; better on the best ones.

Why it adds up. Every qubit has to be read correctly for the whole output to be right:

Chance every qubit is read correctly, at 98% each:
 
   10 qubits:  0.98^10  ≈ 82%
   50 qubits:  0.98^50  ≈ 36%
  100 qubits:  0.98^100 ≈ 13%

Measurement errors are also among the easiest to correct after the fact. By measuring how often known 0s and 1s are misread, the classical computer can statistically undo much of the bias, a technique called readout error mitigation.

5. Crosstalk: Qubits Disturbing Each Other

What it is. An operation intended for one qubit also affects its neighbours, or two qubits influence each other when they're supposed to be idle.

Why it happens.

• Shared signals. A control pulse meant for one qubit leaks slightly onto a neighbour's line, or a laser beam aimed at one ion spills onto the next.
• Always-on coupling. Qubits that are built to interact for two-qubit gates often keep a tiny residual interaction all the time. Each qubit's behaviour then depends slightly on what its neighbours are doing.
• Frequency crowding. Superconducting qubits are addressed by their frequency. On a large chip, some neighbours inevitably sit close in frequency, and a pulse for one partly drives the other.

An everyday picture. Trying to hold a quiet conversation at a crowded party. The more people in the room, and the closer they stand, the more each conversation bleeds into the next.

Why it matters for scaling. Crosstalk often doesn't show up when qubits are tested one or two at a time. It appears when many gates run in parallel, which is exactly what real algorithms do. A gate that's 99.9% accurate on its own may be noticeably worse with its neighbours busy. And because crosstalk errors can hit several qubits at once, they're particularly awkward for error correction.

6. Environmental Interference: The World Outside the Fridge

Even inside a heavily shielded, near-absolute-zero refrigerator, the outside world still finds ways in:

• Stray magnetic fields from nearby equipment, or even the Earth's field changing slightly, shift qubit frequencies. Trapped-ion and spin qubits are especially sensitive.
• Vibrations from the refrigerator's own pumps, or from the building, can jiggle components and modulate signals.
• Temperature fluctuations and stray infrared light leaking down from warmer stages create unwanted excitations.
• Material defects called two-level systems, tiny flaws in the chip's materials, behave like microscopic rogue qubits. They absorb energy from real qubits, and they wander in frequency, so a qubit that was excellent yesterday can be poor today.
• Laser and atom problems in atom-based machines: small fluctuations in laser power or frequency cause gate errors, and an atom can occasionally escape its trap entirely.
• Cosmic rays and natural radioactivity. This is the most surprising one. High-energy particles from space, and from traces of radioactive material in ordinary surroundings, occasionally hit the chip. In one well-known study, researchers at Google observed such events roughly every ten seconds on their chip, each one briefly causing errors across a large group of qubits at once. Defences include better shielding, chip designs that soak up the energy, and research systems placed deep underground.

That last point matters for error correction too: most correction schemes assume errors are rare and independent. A burst that hits many qubits at the same time breaks that assumption, so the hardware has to be designed to contain it.

How Errors Add Up: A Realistic Error Budget

Each individual error rate looks small. The problem is that a useful circuit has to survive all of them, every time. The probability of a completely error-free run is roughly the product of every operation succeeding:

A modest circuit: 50 qubits, 500 two-qubit gates, then measure all 50
 
  Two-qubit gates:  0.995^500  ≈ 8%
  Measurement:      0.98^50    ≈ 36%
  Together:         8% × 36%   ≈ 3% chance of a run with no errors at all

And that ignores single-qubit gates, idle decoherence and crosstalk. Meanwhile, the algorithms that would genuinely matter, such as breaking today's encryption or simulating complex molecules, need millions to billions of operations.

That gap, between "one error per thousand" and "billions of operations", is the central engineering problem of quantum computing.

Three Ways to Fight Back

There are three complementary responses, and the field is pursuing all of them at once.

1. Better hardware. Cleaner materials, better chip design, better shielding, better pulses, better calibration. This has improved error rates by roughly a factor of ten every several years. It's essential, but on its own it will never reach one-in-a-billion, because the isolation-versus-control conflict never fully goes away.

2. Error mitigation. Run the circuit in deliberately varied ways and use classical statistics to estimate what a noise-free result would have been. It works on today's hardware and is covered in detail in the stage 02 flagship. But it costs many extra shots, and the cost grows quickly with circuit size, so it can't take us to large algorithms.

3. Quantum error correction. Detect and fix errors while the computation is running, so that a computation can survive far longer than any single qubit could. This is the only known route to large, reliable quantum computers.

An Introduction to Quantum Error Correction

The classical idea, and why it seems impossible for qubits

Classical computers have corrected errors for decades using a simple idea: redundancy. Store a bit three times, as 000 or 111. If noise flips one copy (say 010), a majority vote recovers the original.

Copy that idea to qubits and you hit two walls at once:

1. You can't copy a qubit. The no-cloning theorem forbids making copies of an unknown quantum state.
2. You can't look to see what went wrong. Checking a qubit's value is a measurement, which destroys the very superposition you're trying to protect.

For years, these two facts made many physicists suspect that quantum error correction was impossible. It isn't, thanks to a clever trick.

The trick: check relationships, not values

Instead of copying a qubit, you spread its information across several physical qubits using entanglement. Then, instead of measuring the qubits themselves, you use extra helper qubits to measure relationships between them, such as "are these two the same, or different?" These checks are called parity checks, and their results are the syndrome.

The beauty is that a parity check reveals whether and where an error happened, but reveals nothing about the protected information itself. So the superposition survives the check.

The simplest version, the three-qubit repetition code, protects against bit flips. Two parity checks compare qubit 1 with qubit 2 (check A) and qubit 2 with qubit 3 (check B):

At no point did anyone learn whether the protected qubit was 0, 1 or a superposition, only which qubit disagreed with its neighbours. Real codes, such as the widely used surface code, extend this idea in two dimensions so they catch phase flips as well as bit flips, and the whole cycle repeats continuously:

The threshold: why bigger codes get better

Spreading one qubit over many physical qubits sounds like it would make things worse; more qubits means more places for errors. Whether it helps depends on one number.

The threshold theorem says that if every physical operation's error rate is below a certain threshold (around 1% for the surface code), then making the code bigger makes the logical qubit exponentially more reliable. Above the threshold, bigger codes just collect more errors. Below it, each step up in code size divides the logical error rate by a constant factor.

That's why Google's Willow result in late 2024 mattered so much. Growing its surface code from a 3×3 to a 5×5 to a 7×7 grid of data qubits cut the logical error rate roughly in half at each step, the first convincing demonstration that real hardware is below threshold and that the approach scales.

The catch: overhead

Error correction is expensive. A surface-code logical qubit at a useful reliability can need from around a hundred to a thousand or more physical qubits, plus a classical decoder fast enough to keep up with checks every microsecond. Useful algorithms need hundreds to thousands of logical qubits, which is where the "millions of physical qubits" estimates come from.

Reducing that overhead is one of the hottest areas in the field:

• Better codes. Newer code families can pack several logical qubits into far fewer physical qubits. IBM, for example, has built its roadmap around a code that stores 12 logical qubits in 288 physical qubits, though such codes need longer-range connections between qubits.
• Better qubits. Lower physical error rates mean smaller codes for the same logical reliability.
• Qubits with built-in protection. Cat qubits, which naturally suppress one kind of error, and topological qubits, which aim to suppress errors through their physics, are both bets on needing less correction.

Quick Recap

• Errors come from one conflict: a qubit must be isolated yet controllable.
• Quantum errors accumulate, because qubits are continuous and can't be checked without being disturbed.
• Small error rates multiply into likely failure over thousands of operations.
• Quantum error correction spreads information across many qubits, checks parities instead of values, and, below threshold, gets exponentially better as codes grow.

What's Next on the Learning Path

The next major article, Quantum Error Correction: How Do We Protect a Qubit?, goes deep into quantum error correction: how the surface code actually works, how much it costs, how decoding works, what "fault tolerance" really requires, and how the leading companies plan to get from today's handful of logical qubits to the thousands that useful algorithms need. After that, stage 04, Quantum Programming, gets hands-on. The full 11-stage path is listed at the end of the beginner's guide.