The Road to Fault-Tolerant Quantum Computing

Quantum computing has a marketing problem that is really an engineering problem. The headline qubit counts you see — 100, 156, soon hundreds — are physical qubits, and a physical qubit is a fragile, noisy thing that decoheres in microseconds and flips its state for no reason you can see. The machine that runs a useful algorithm end to end does not run on those. It runs on logical qubits: error-corrected abstractions built from many physical qubits working together to behave like one near-perfect qubit. The entire road to fault tolerance is the road from one to the other, and the distance between them is where every honest conversation about timelines has to start.

Logical versus physical, and the overhead nobody likes#

A logical qubit is an encoding. You take a block of physical qubits, entangle them in a structured code, and continuously measure the system in a way that reveals errors without collapsing the data you care about. When a physical qubit faults, the code tells you and you correct it. The result is a qubit whose error rate is far below that of its parts — provided your physical qubits are already good enough to be below the code’s threshold.

The cost is the overhead, and it is steep. Depending on the code and the target error rate, a single logical qubit can demand somewhere from dozens to over a thousand physical qubits. That ratio is the central fact of the field. It is why a 156-qubit chip is not a 156-qubit computer in any application sense, and why “we have N qubits” tells you almost nothing without the error rate and the code attached. When you see a roadmap promise hundreds of logical qubits, mentally multiply by the overhead and you understand why these machines are the size of rooms and why the timelines run to the end of the decade.

Fault tolerance, properly defined, requires three things working at once: physical error rates below threshold, a code that suppresses errors as you scale it up, and a classical decoder fast enough to keep up with the error stream in real time. Miss any one and the system does not become a computer. Most public demonstrations have nailed one or two. The roadmaps are bets on nailing all three at scale.

There is a fourth requirement that gets less airtime and matters just as much: a universal set of fault-tolerant operations. Correcting a stored qubit is necessary but not sufficient — you also have to compute on the encoded data without breaking the encoding. Some logical gates are cheap to do this way; the ones that give a quantum computer its power, the non-Clifford gates, are not, and they are typically supplied through a resource-hungry process called magic-state distillation. That distillation overhead is folded into every credible physical-qubit estimate, and it is a large part of why the totals run so high. When a roadmap quotes a logical-qubit count, the honest version of that number already pays for the gates, not just the memory.

IBM: a dated plan, on qLDPC codes#

IBM has published the most concrete near-term schedule, and notably it pivoted its error-correction strategy. Rather than the surface code, IBM’s fault-tolerant plan centers on quantum low-density parity-check (qLDPC) codes — specifically bivariate bicycle codes, which the company estimates deliver roughly a tenfold improvement in qubit efficiency over an equivalent surface-code design. That efficiency is the whole reason for the pivot: less overhead per logical qubit means a useful machine arrives with fewer physical qubits.

The hardware cadence is specific. IBM’s Heron is a 156-qubit processor that anchors the current generation, and the company has detailed a 120-qubit Nighthawk processor aimed at running progressively deeper circuits over the next few years. The error-correction milestones matter more than the raw counts: Loon is the experimental chip built to prove out the connectivity qLDPC codes require, and Kookaburra is slated to be the first module that stores information in a qLDPC memory. The destination is Starling, which IBM targets for 2029 as a system with around 200 logical qubits capable of running on the order of 100 million operations. If that ships on time, it is the first machine you could fairly call fault-tolerant at a useful scale.

Google: milestones, not qubit counts#

Google Quantum AI frames its plan as a six-milestone roadmap rather than a qubit-count race, which is the more honest framing. Milestone one was the 2019 beyond-classical demonstration. Milestone two was a logical-qubit prototype that suppresses errors as it scales. The recent Willow result — below-threshold error correction — is the evidence that the approach works and the bridge toward milestone three, a long-lived logical qubit. After that come a logical gate, scale-up, and finally a large error-corrected machine that Google describes as connecting and controlling a million physical qubits.

What I respect about Google’s framing is that it refuses to let physical qubit count stand in for progress. Each milestone is a capability — suppress, sustain, operate, scale — and you cannot skip one with a bigger chip. The company says it believes the endpoint is achievable within the decade. That is a belief, stated as one, and the surface-code physics underneath it is real.

Quantinuum: trapped ions and the cleanest qubits#

Quantinuum comes at the problem from a different modality. Its trapped-ion machines have the lowest physical error rates in the business, which changes the overhead math: cleaner physical qubits mean fewer of them per logical qubit. The company announced an accelerated roadmap toward universal, fully fault-tolerant quantum computing by 2030, with its Helios system as the current step and a larger machine, Apollo, as the fault-tolerant target. Reported figures put Helios at roughly 98 physical qubits delivering on the order of 48 logical qubits — a logical-to-physical ratio that superconducting platforms cannot touch today, precisely because the physical qubits are so clean.

The trade-off is speed. Trapped-ion gates are slower than superconducting ones, and shuttling ions around a trap takes time. Whether low error rates or fast gates win the race to a useful machine is genuinely unsettled, and it is reasonable to expect the answer differs by application. A workload dominated by a few deep, high-fidelity circuits may favor the clean-qubit camp; one that needs to run many shots quickly may favor the fast-gate camp. The modality wars will not produce a single winner so much as a map of which physics fits which problem.

PsiQuantum: skip the small machine entirely#

PsiQuantum’s bet is the most contrarian. Instead of scaling up from small noisy processors, it is building a photonic architecture aimed directly at a million-plus physical qubits manufactured on standard semiconductor lines. The thesis: error correction needs enormous physical-qubit counts no matter the modality, so the only thing that matters is whether you can mass-produce qubits in a fab. Photons are room-temperature and chip-fab-friendly, which is the appeal. The risk is equally clear — there is no intermediate noisy-but-useful product to validate the path along the way. It is fault tolerance or nothing.

Neutral-atom platforms add a fourth credible approach. The Harvard–MIT–QuEra collaboration executed algorithms on 48 logical qubits encoded from 280 physical neutral atoms, using atom shuttling to reconfigure connectivity on the fly. Four distinct modalities, four distinct bets on which physics scales first.

Reading the roadmaps without getting played#

A few disciplines keep you honest when a vendor deck lands on your desk.

Always convert to logical qubits. A physical-qubit count is a press number. Ask for the code, the code distance, the physical error rate, and the resulting logical error rate. Those four together tell you whether a chip can run an algorithm or just a benchmark.

Watch the decoder, not just the chip. Fault tolerance is a real-time classical-computing problem as much as a quantum one. A demonstration that decodes errors offline, after the fact, has not shown the hard part. The decoder has to close its loop fast enough to keep the error stream from backing up.

Treat end-of-decade dates as direction, not delivery. 2029 and 2030 targets are credible statements of intent from serious teams. They are not procurement dates. Plan around capability milestones — below-threshold operation, a sustained logical qubit, a logical gate — because those are checkable, and slips in them are the real signal.

For enterprises, the practical posture is patience with preparation. Fault-tolerant machines will not arrive as a surprise; the milestones telegraph it years out. The work worth doing now is identifying which of your problems are genuinely quantum-shaped, building the classical Data Platforms and AI implementation muscle that any quantum workload will sit beside, and staying close enough to the roadmaps to know a real milestone from a marketing one. The same discipline that separates a working Hospital Management System from a slide of one separates a fault-tolerant computer from a qubit count.

---

Building a quantum-readiness posture without buying the hype? We help engineering teams separate roadmap signal from marketing noise and prepare the classical infrastructure quantum workloads will need. Talk to our engineering team.