Every qubit built so far is broken. Not broken in the sense of a manufacturing defect, but broken in a much more fundamental way: it forgets. Stray heat, cosmic rays, imperfect control pulses, and even the physical act of trying to read it all conspire to scramble the fragile quantum state a qubit is supposed to hold. A classical bit can sit in a hard drive for years without flipping. A physical qubit today typically loses its information in microseconds to milliseconds. That gap — not raw qubit count — is the real bottleneck standing between quantum computers and doing anything useful. Quantum error correction (QEC) is the set of techniques built to close it, and the emergence of "logical qubits" is the industry's clearest signal of progress toward that goal.
What quantum error correction actually is
Classical computers correct errors constantly, usually invisibly. A hard drive or a network packet uses redundancy — extra bits that let a receiver detect and fix a flipped bit — to keep data intact. The simplest version is repetition: store each bit three times and take a majority vote if one copy disagrees.
Quantum error correction borrows that spirit but has to solve two problems classical codes never face:
- You can't copy a qubit. The no-cloning theorem forbids making an identical duplicate of an unknown quantum state, so the classical trick of "just store it three times" doesn't translate directly.
- You can't look at it to check. Measuring a qubit directly collapses its superposition, destroying the very information you were trying to protect. A direct read-then-compare approach, the backbone of classical error correction, would erase the calculation.
QEC gets around both constraints by encoding one unit of protected quantum information — a logical qubit — across many physical qubits, using entanglement rather than direct duplication. Instead of measuring the data qubits themselves, the system periodically measures special combinations of neighboring qubits called stabilizers or parity checks. These measurements reveal whether an error occurred and roughly where, without ever revealing (and therefore without destroying) the actual quantum state being protected. The output of these checks is called a syndrome, and a classical decoder algorithm reads the syndrome and works out what correction to apply.
Physical qubits vs. logical qubits
This distinction is the single most important vocabulary shift happening in the field right now, and it's worth being precise about it.
| Term | What it is | Analogy |
|---|---|---|
| Physical qubit | An actual hardware qubit — a superconducting circuit, a trapped ion, a photon, etc. | A single, unreliable messenger |
| Logical qubit | A stable, protected unit of quantum information built from many entangled physical qubits plus a QEC code | A committee of messengers who cross-check each other's story |
| Code distance | How many simultaneous errors a code can detect/correct before the logical information is lost | How large the committee needs to be to outvote a liar |
| Syndrome measurement | A check that reveals where an error happened without revealing the encoded data | Comparing notes without reading the original message |
A "100-qubit quantum computer" and a "100-logical-qubit quantum computer" are wildly different machines. The former might be a research chip with fragile physical qubits and no error correction at all. The latter, if it existed today at that scale, would represent one of the most significant engineering achievements in computing history — because each of those 100 logical qubits could plausibly require hundreds or thousands of physical qubits underneath it, depending on the code and the physical error rate. This is why serious vendors have started reporting logical qubit counts and logical error rates alongside (or instead of) raw physical qubit counts — the physical number alone no longer tells you much about capability.
The error threshold: the number that decides everything
The most important concept in QEC is the threshold theorem. It states, roughly, that if the physical error rate of your qubits and gates is below a certain critical value, then adding more physical qubits to your error-correcting code will make the logical error rate go down, not up. Cross that threshold in the wrong direction — physical errors too frequent — and adding more qubits to the code only adds more places for errors to occur, making things worse.
This creates a clean, almost binary framing for hardware progress:
- Above threshold: more physical qubits per logical qubit means a less reliable logical qubit. Scaling up hurts you.
- At threshold: logical error rate stays roughly flat as you add physical qubits. You're treading water.
- Below threshold: logical error rate falls exponentially as code distance increases. Scaling up genuinely helps you, and helps you faster the bigger you go.
Getting hardware reliably below threshold, and then demonstrating that the logical error rate keeps dropping as the code is scaled up, has been the central goal of the entire field for two decades. It's a different kind of milestone than "most qubits" or "highest gate fidelity" headlines — it's a statement about the trend line, not a single measurement.
Why this matters right now
For most of quantum computing's public history, error correction was treated as a distant, mostly theoretical concern — something to worry about once "enough" physical qubits existed. That framing has shifted. Google's Willow chip demonstrated below-threshold error correction: as the company scaled up the size of the error-correcting code (increasing the distance of the surface code used), the logical error rate went down rather than up or staying flat. That's the exponential-suppression behavior the threshold theorem predicts, shown experimentally rather than just simulated.
The significance isn't a single number — it's the direction of the curve. A chip that shows error rates falling as it scales is evidence that the engineering path to fault-tolerant quantum computing is physically achievable with current qubit technology, not just theoretically possible on paper. That's a different claim than "we built more qubits," and it's the reason the language around quantum hardware announcements has been shifting: vendors increasingly quote logical-qubit counts and logical error rates rather than leading exclusively with physical qubit tallies. A roadmap slide that used to say "1,000 qubits by 2027" increasingly gets footnoted, or replaced outright, with a claim about logical qubits and their error rates — because that's the metric that actually predicts whether a machine can run a useful algorithm.
This also reframes what "progress" looks like for outside observers. Raw qubit counts are easy to compare and easy to hype, but they've become a poor proxy for capability. A below-threshold demonstration, even at a modest logical qubit count, is arguably a bigger deal than a much larger chip that has never shown its error rate improving with scale.
Why businesses and technical leaders should care
It's tempting to file quantum error correction under "interesting physics, not my problem." For most organizations, that's still roughly correct today — but the timeline for when it stops being correct is now visibly shortening, and a few practical implications are worth internalizing early.
The gap between "qubits" and "useful computation" is closing, slowly and unevenly
Useful, fault-tolerant quantum algorithms — the kind that could meaningfully accelerate drug discovery, materials science, optimization, or break certain cryptographic schemes — require logical qubits with very low error rates sustained over long computations, not just a handful of noisy physical qubits performing a narrow demonstration. Below-threshold behavior is a necessary precondition for reaching that regime, but it is not the same as having arrived at it. Translating "the error rate trend is right" into "we can run a commercially relevant algorithm reliably" still requires scaling code distance further, reducing physical error rates further, and building the classical control and decoding infrastructure to keep pace — none of which happens overnight.
Cryptographic planning has a longer runway than the hype cycle suggests, but it isn't infinite
The most concrete business risk tied to quantum computing is cryptographic: a sufficiently large, sufficiently reliable fault-tolerant quantum computer could break widely used public-key encryption (RSA, elliptic-curve cryptography) via Shor's algorithm. That requires logical qubit counts and error rates far beyond anything demonstrated publicly today. But "far beyond today" is not the same as "irrelevant," particularly for organizations with data that needs to stay confidential for a decade or more — the "harvest now, decrypt later" threat model. The practical response isn't panic; it's tracking migration to post-quantum cryptography standards on a sensible timeline, informed by the pace of error-correction progress rather than by marketing claims about qubit counts.
Vendor claims need a translation layer
Anyone evaluating quantum computing vendors, whether for a pilot project, a research partnership, or just competitive intelligence, should get comfortable asking a specific question: is this a physical qubit number or a logical qubit number, and what error rate is being claimed at what code distance? The two are not interchangeable, and the gap between them is exactly where most of the remaining engineering difficulty lives. A few questions worth having in your back pocket when a vendor briefing turns to qubit counts:
- Is the reported number physical or logical qubits?
- What's the physical error rate per gate, and is it below the relevant threshold for their code?
- Has logical error rate been shown to decrease as code distance increases, or only measured at one scale?
- What's the target application, and does it actually need fault tolerance, or can it run on noisy intermediate-scale (NISQ) hardware?
Talent and research investment follows the trend line
Below-threshold results tend to pull funding, talent, and partnership interest toward the hardware platforms and research groups that demonstrated them, because it validates the underlying approach (superconducting circuits, trapped ions, neutral atoms, photonics, and others are all racing toward the same threshold from different physical starting points). Businesses evaluating where to place long-horizon research bets, academic partnerships, or early-access commitments should weight demonstrated error-correction trend lines more heavily than headline qubit counts.
The main error-correcting codes, briefly
Several families of QEC codes exist, each trading off differently between overhead (physical qubits per logical qubit), connectivity requirements, and decoding complexity.
| Code family | Core idea | Typical tradeoff |
|---|---|---|
| Surface code | Qubits arranged on a 2D grid; parity checks on nearest neighbors | Widely used because it only needs local, nearest-neighbor connections — practical for chip layouts — but has relatively high physical-qubit overhead per logical qubit |
| Repetition code | Simplified 1D version protecting against only one error type | Useful for early demonstrations and calibration, not for full fault tolerance |
| Color code | Similar topological principle to the surface code, different lattice geometry | Can support more logical operations natively, but is harder to implement on current hardware |
| LDPC-style / quantum low-density parity-check codes | Longer-range qubit connections, denser parity structure | Potentially much lower physical-qubit overhead per logical qubit, but requires connectivity that's harder to build in hardware today |
The surface code has dominated recent demonstrations largely because its nearest-neighbor structure maps well onto how superconducting qubit chips are physically laid out. The tradeoff is overhead: surface codes can require on the order of hundreds to over a thousand physical qubits per high-quality logical qubit at the error rates needed for genuinely useful algorithms, depending on the target logical error rate and the physical error rate you start with. That overhead number is exactly why headline physical qubit counts in the low thousands don't yet translate into more than a handful of high-quality logical qubits — and why the field is investing heavily in alternative codes, like quantum LDPC codes, that promise lower overhead if the connectivity problem can be solved.
Real limitations and open questions
It's worth being direct about what below-threshold demonstrations do not yet solve, because the gap between "promising experiment" and "practical fault-tolerant computer" is still substantial.
- Overhead remains steep. Even with favorable error rates, current codes need large numbers of physical qubits per logical qubit. Reaching dozens or hundreds of high-quality logical qubits — the range needed for commercially interesting algorithms — implies physical qubit counts in the range of hundreds of thousands to millions with today's codes, absent further breakthroughs in code efficiency.
- Decoding has to happen fast enough to matter. Syndrome measurements need to be interpreted by a classical decoder and corrections applied before errors accumulate past the point of recovery. As code distance grows, decoding gets computationally harder, and it has to run in real time alongside the quantum hardware — a nontrivial classical-computing engineering problem in its own right.
- Below-threshold is necessary, not sufficient. A falling logical error rate as code distance increases is the right trend, but getting from "falling" to "low enough for a useful algorithm running millions of logical gates" is a large additional engineering distance, and there's no guarantee the exponential suppression continues cleanly at every scale without new sources of error appearing.
- Different hardware platforms are at different points on this curve. Superconducting qubits, trapped ions, neutral atoms, and photonic approaches all have distinct error profiles, connectivity options, and scaling challenges. A below-threshold result on one platform doesn't automatically transfer to another.
- "Useful" is doing a lot of work in most claims. Demonstrating error correction on a benchmark circuit is different from running an algorithm that outperforms the best classical alternative on a problem anyone actually cares about. That comparison — quantum advantage on a practically relevant task, achieved with error-corrected logical qubits — hasn't yet been convincingly shown.
What to watch next
The signals that will matter most over the next few years are less about qubit counts and more about trend lines and translation into real workloads:
- Logical error rate scaling curves. Does the exponential suppression seen at small code distances continue as codes get larger, or does it flatten out due to new, previously-hidden error sources?
- Logical qubit counts at useful error rates, not just single-logical-qubit demonstrations. Running multi-logical-qubit circuits with entangling operations between logical qubits is a harder and more relevant milestone than protecting one qubit in isolation.
- Lower-overhead codes moving from theory to hardware, particularly quantum LDPC-style approaches that promise fewer physical qubits per logical qubit if the required connectivity can be engineered.
- Real-time decoder performance at scale — whether classical control systems can keep up as code distance and logical qubit count grow.
- Standardized, vendor-neutral benchmarks for logical qubit quality, so that "logical qubit" claims become as comparable across companies as physical qubit counts (imperfectly) are today.
- Post-quantum cryptography migration timelines at large institutions, which serve as an indirect but telling signal of how seriously risk-conscious organizations are pricing in the pace of QEC progress.
FAQ
What is quantum error correction in simple terms?
It's a set of techniques that protect fragile quantum information from noise by spreading it across many physical qubits and periodically checking for errors without directly measuring (and destroying) the protected data. The result, when done successfully, is a more stable "logical qubit" built from many imperfect physical qubits.
What's the difference between a physical qubit and a logical qubit?
A physical qubit is an actual piece of hardware — a superconducting loop, trapped ion, or similar — that holds quantum information briefly and unreliably. A logical qubit is a protected, composite unit of quantum information built from many physical qubits using an error-correcting code, designed to be far more stable than any single physical qubit alone.
What does "below threshold" mean, and why is it a big deal?
The threshold theorem says that once physical error rates drop below a critical value, adding more physical qubits to an error-correcting code makes the logical error rate go down rather than up. A below-threshold demonstration shows that logical error rates actually fall as the code scales — direct evidence that the engineering path to fault-tolerant quantum computing works in practice, not just in theory.
Does this mean quantum computers can now break encryption?
No. Breaking widely used public-key encryption with Shor's algorithm would require far more high-quality logical qubits, sustained over far longer computations, than anything demonstrated publicly so far. Below-threshold results are an important step on that road, not evidence that it has been traveled.
Why are vendors now reporting logical qubits instead of just physical qubits?
Because physical qubit counts alone no longer indicate much about a system's actual computational capability. A chip with many noisy physical qubits and no working error correction can be far less useful than a smaller chip with a few well-protected logical qubits, so logical qubit counts and logical error rates have become the more meaningful comparison points.
How many physical qubits does it take to make one logical qubit?
It depends on the code and the target error rate, but with the surface code — the most widely used approach today — estimates commonly run from the low hundreds to well over a thousand physical qubits per high-quality logical qubit. Lower-overhead codes are an active area of research precisely because this ratio is currently so steep.
When will fault-tolerant quantum computers be practically useful?
There's no reliable consensus timeline, and estimates from serious researchers still range from several years to well over a decade, depending on the application. The more useful signal to track isn't a date but the trend: whether logical error rates keep falling as codes scale, and whether logical qubit counts at useful error rates keep climbing.
Teams evaluating how quantum computing progress might intersect with their own technology roadmap or cryptographic risk planning can get a clearer, jargon-free assessment by talking to Woyce Technologies.