Why quantum computers keep breaking: noise, decoherence, and the error correction problem

You now know the theory: qubits use interference to solve certain problems faster than classical computers. So why don’t we just build a big quantum computer and start?

Because qubits are the most fragile things humans have ever tried to compute with.

How fragile? This fragile.

A classical bit stored in silicon can sit unchanged for years. A qubit typically survives for microseconds to milliseconds before losing its quantum properties. Some hardware does better — trapped ions can hold for seconds — but that’s still absurdly short by computing standards.

To put this in perspective: IBM’s best superconducting qubits have coherence times of about 300 microseconds. A modern CPU performs roughly 5 billion operations per second. So while your laptop does 1.5 million operations in the time a qubit survives, a quantum computer might manage a few hundred quantum operations — and each one introduces errors.

What causes the fragility?

Quantum states are destroyed by interaction with the environment. This is called decoherence, and it’s relentless:

Thermal noise. Most quantum computers operate near absolute zero (-273°C) because room-temperature vibrations contain enough energy to flip a qubit. Even at near-zero temperatures, tiny thermal fluctuations cause errors.

Electromagnetic interference. A stray photon from the lab lights, a signal from someone’s phone, electromagnetic noise from nearby electronics — all of these can disturb a qubit.

Cosmic rays. Yes, really. In 2021, Google published a paper showing that cosmic ray impacts on their quantum chip created error bursts affecting multiple qubits simultaneously.

Crosstalk. Qubits on the same chip can interfere with each other. When you perform an operation on one qubit, it can accidentally disturb its neighbours.

Control imprecision. Quantum operations are performed by precisely timed microwave pulses (for superconducting qubits) or laser beams (for trapped ions). Any imprecision in timing, frequency, or amplitude introduces errors.

The result: even the best quantum hardware today has error rates of about 0.1-1% per operation. That sounds small, but if your algorithm needs 1,000 operations, the probability of getting through without an error is roughly zero.

The error correction solution

Classical computers solved their error problem decades ago. Your laptop’s memory uses error-correcting codes — extra bits that detect and fix errors automatically. You never think about it.

Quantum error correction is the same idea, but vastly harder:

You can’t copy a qubit. Classical error correction works by making copies. The “no-cloning theorem” says you can’t copy an arbitrary quantum state. This breaks the most basic error correction approach.

Measurement destroys the state. In classical error correction, you can check a bit’s value without changing it. In quantum error correction, measuring a qubit collapses it. You have to detect errors without looking at the actual information.

There are more types of errors. A classical bit can only flip (0→1 or 1→0). A qubit can have bit-flip errors, phase errors (the amplitude changes sign), or any combination. You need to correct all of them.

The solution: encode one logical qubit (the one you compute with) across many physical qubits (the ones on the chip). The extra qubits act as “error syndrome” detectors — they reveal what kind of error happened without revealing the actual data.

The overhead is staggering

Here’s where it gets real. The leading error correction approach, the surface code, requires roughly:

• 1,000 physical qubits to encode 1 useful logical qubit (at current error rates)
• Error rates need to be below a threshold (~1%) for correction to work at all
• Useful algorithms like Shor’s factoring need thousands of logical qubits

Do the math: to break current encryption (RSA-2048), you’d need roughly 4,000 logical qubits × 1,000 physical qubits each = 4 million physical qubits. The largest quantum computer today has about 1,100 physical qubits.

That’s the gap. It’s not a mystery — it’s engineering.

Where we actually are

The field is currently in the NISQ era — “Noisy Intermediate-Scale Quantum.” These machines have enough qubits to be interesting (50-1,100) but too many errors for full error correction.

The state of play in 2026:

• Error rates: Best two-qubit gate fidelities around 99.9% (IBM), approaching the threshold needed for error correction
• Qubit counts: Up to 1,100 (IBM), 1,225 (Atom Computing), 5,000 (D-Wave, but a different type)
• Error correction demonstrations: Small proof-of-concept codes running on real hardware, but nowhere near the scale needed for useful computation
• Hybrid approaches: Using classical computers for most of the work and quantum hardware only for the specific steps where it provides advantage

When will this be solved?

Nobody knows for certain. But the trajectory is visible:

Error rates are improving roughly 10× every few years. If that continues, we’ll cross the threshold for practical error correction in the late 2020s. Qubit counts are scaling faster than many expected.

The most honest assessment: the physics works. The engineering is extraordinarily hard. But it’s engineering, not fundamental physics — which means it will eventually be solved. The question is whether “eventually” is 5 years or 25.

The honest summary

• Qubits are destroyed by almost everything: heat, light, vibrations, even cosmic rays
• Error rates of ~0.1-1% per operation mean long computations are currently impossible
• Error correction exists but requires ~1,000 physical qubits per logical qubit
• We need millions of physical qubits for useful algorithms; we have ~1,000 today
• The NISQ era (now) is about finding useful applications despite the noise
• This is an engineering challenge, not a physics mystery — it will be solved

What’s next?

Now you understand the core concepts: qubits, interference, entanglement, and error correction. The natural question is: what can we actually do with today’s imperfect machines? That’s where the hardware platforms and their different approaches come in.