From Noisy Qubits to Fault-Tolerant Quantum Computers

Every quantum computing headline seems to announce a bigger number: 100 qubits, 1,000 qubits, 6,000 qubits. It's an easy number to report and an easy number to compare. It is also the wrong number to watch.

The single most important idea in the future of quantum computing is this: what matters isn't how many qubits a machine has, but how many reliable operations it can run. A machine with a million noisy qubits that can't keep a calculation alive for more than a few thousand steps is less useful than one with a thousand qubits that can run a billion operations without error.

That shift, from counting qubits to counting reliable operations, is how the whole industry now describes its future. The roadmaps all describe the same climb, in three levels:

Microsoft's roadmap uses almost exactly this framing: Level 1, Foundational (today's noisy machines), Level 2, Resilient (reliable logical qubits) and Level 3, Scale (quantum supercomputers that can solve problems classical computers can't). IBM, Google, Quantinuum and others use different words, but describe the same journey. This post is the big-picture architecture of that journey: what each level is, what it can do, what has to be engineered to get from one to the next, and where the field actually is today.

The Three Levels at a Glance

Level 1: Noisy Physical Qubits

What it is

This is where quantum computing has lived since its beginning, and where most machines still are. In 2018, physicist John Preskill named it the NISQ era, for Noisy Intermediate-Scale Quantum: machines with tens to hundreds (now thousands) of qubits, too noisy to correct their errors.

Every physical operation has a small chance of going wrong, and the chances multiply. The arithmetic is unforgiving:

Today's best machines sit around the middle row for their two-qubit gates. So a Level 1 machine can run circuits of hundreds to a few thousand operations before noise wins, however many qubits it has. The useful algorithms in the algorithms post, such as Shor's algorithm and large chemistry simulations, need millions to billions.

What Level 1 has achieved

Level 1 is not a failure; it's where the field learned to engineer qubits at all. Its milestones include:

• "Beyond classical" demonstrations, such as Google's 2019 random circuit sampling experiment and its successors, which showed that quantum hardware can do something classical computers struggle to simulate.
• Utility-scale experiments, such as IBM's 2023 simulation of a 127-qubit magnetic model with error mitigation, which pushed noisy hardware to the edge of classical simulation (and, tellingly, was soon matched by improved classical methods).
• Error mitigation, a toolbox of statistical tricks that get more accurate averages out of noisy machines (covered in the errors post). Mitigation is useful, but its cost grows exponentially with circuit size, so it can't take you to large algorithms.
• Engineering maturity: better fabrication, control electronics, calibration and cloud access, all of which the next levels depend on.

The limit

Level 1's limit isn't the number of qubits. Adding more noisy qubits without lowering the error rate just gives you a bigger machine that fails just as quickly. The only way past Level 1 is error correction.

Level 2: Error-Corrected Logical Qubits

What it is

A logical qubit is one reliable qubit encoded across many physical qubits, with constant checks that detect and correct errors without disturbing the stored information. The error correction post explains how this works with the surface code. The essential fact for the big picture is the threshold theorem: if physical qubits are good enough (below an error threshold, about 1% for the surface code), then making the code bigger makes the logical qubit exponentially more reliable.

Level 2 begins when that promise becomes real on hardware: logical qubits that are better than the physical qubits they're made from, and get better as they grow.

The milestones that mark Level 2

• Below threshold. In December 2024, Google's Willow chip showed that growing a surface-code logical qubit from distance 3 to 5 to 7 roughly halved the logical error rate each time, and that the largest logical qubit outlived the best physical qubit on the chip ("beyond breakeven").
• Many logical qubits at once. In 2023, Harvard, MIT and QuEra ran algorithms on up to 48 logical qubits on a neutral-atom machine. In 2024, Microsoft and Quantinuum demonstrated logical qubits with error rates far below the physical ones on trapped ions, and Microsoft and Atom Computing entangled dozens of logical qubits on neutral atoms. Quantinuum's Helios system, launched in late 2025, continued that trajectory.
• Logical operations, not just storage. Keeping a logical qubit alive is the first step; performing reliable gates between logical qubits is the second, and it's where much current research is focused.

Many of these early demonstrations use small codes or error detection rather than full correction, so read each announcement carefully (more on that below). But together they mark the field crossing from Level 1 into Level 2.

What a Level 2 machine can do

With logical error rates around one in a million, a machine can run circuits of hundreds of thousands to millions of operations before an error is likely, hundreds of times longer than Level 1. That's enough to:

• Prove error correction scales, the essential engineering result.
• Run the first small algorithms entirely on logical qubits.
• Possibly do scientifically useful simulations of physics that noisy machines can't, the first useful applications described in Where Can Quantum Computers Actually Be Useful?.

It's not yet enough for large chemistry problems or for breaking encryption. Those need Level 3.

The overhead: how many physical qubits per logical qubit?

Using the same rule of thumb as the error correction post (logical error ≈ 0.1 × (p / 1%)^(d+1)/2 for a surface code of distance d, which uses about 2d² physical qubits), you can see why physical error rates matter so much:

Two lessons jump out. First, each extra factor of a thousand in reliability costs only a modest increase in qubits, which is what makes fault tolerance possible at all. Second, a tenfold better physical qubit cuts the overhead by three to four times, which is why fidelity improvements matter more than raw qubit counts. Newer codes, such as the qLDPC codes IBM is building around, aim to cut the overhead further still.

Level 3: The Fault-Tolerant Quantum Computer

What "fault-tolerant" really means

Level 2 protects stored information. Level 3 protects everything: memory, gates, measurements, and the error correction itself. In a fault-tolerant computer, any single failure, anywhere, including in the circuits that check for errors, can be caught and corrected before it spreads. That's what lets a calculation run for billions of operations.

Three things have to work together:

• A full set of logical gates. Some logical operations (the "Clifford" gates, such as CNOT and H) are naturally easy in codes like the surface code. Others, notably the T gate, are not, and they're essential for any useful algorithm.
• Magic state factories. The usual answer is to prepare special "magic states" in dedicated regions of the chip, purify them (distillation, or newer, cheaper methods such as magic state cultivation), and consume them to perform T gates. In many designs, these factories take a large share of the machine.
• Lattice surgery and logical routing. Logical qubits interact by merging and splitting the patches of physical qubits that encode them, a technique called lattice surgery. The compiler has to schedule all of this like a chip layout.

How big is a Level 3 machine?

Take 1,000 logical qubits at a logical error rate of one in a trillion, with physical qubits at 0.1% error. From the table above, that's about 880 physical qubits per logical qubit, or roughly 880,000 physical qubits, before adding magic state factories and routing space. So a useful fault-tolerant machine is likely to need around a million physical qubits on today's error rates, which matches the 2025 estimate that breaking RSA-2048 would need under a million noisy qubits (see Why Quantum Computers Threaten Today's Encryption). Better qubits or better codes shrink that number.

How fast is a Level 3 machine?

Error correction also sets the clock speed. In a superconducting surface code, one round of checks takes about a microsecond, and a logical operation takes roughly d rounds. At distance 21, that's about 20 microseconds per logical operation, or tens of thousands of logical operations per second per logical qubit, thousands of times slower than a single classical processor core.

Different technologies trade speed for quality. Trapped ions and neutral atoms have better fidelities and more flexible connectivity (so they may need fewer physical qubits per logical qubit), but their operations take much longer, so their logical clocks are slower. That's why Microsoft proposed measuring Level 3 machines in reliable quantum operations per second (rQOPS), combining how many logical qubits a machine has with how fast and how reliably it runs them; Microsoft has suggested that a useful quantum supercomputer needs around a million rQOPS at an error rate of about one in a trillion. IBM states its targets as total reliable gates: its Starling system is aimed at about 200 logical qubits running 100 million gates.

Inside a Fault-Tolerant Quantum Computer

What does the whole machine look like? Less like a single chip, and more like a data centre system with a quantum core:

Walking up the stack:

1. Environment. Dilution refrigerators for superconducting and spin qubits, ultra-high vacuum and lasers for ions and atoms, and an enormous amount of wiring (see Why Quantum Computers Need Extremely Cold Temperatures). At Level 3 scale, a single fridge probably can't hold the machine, so designs are becoming modular: many units linked together.
2. Physical qubits and control. Hundreds of thousands to millions of qubits, each driven and read out by classical control electronics, increasingly built into custom chips close to the qubits.
3. Error correction. The code (surface code, qLDPC codes, or others) and the circuits that measure its checks, repeated continuously.
4. The real-time decoder. Classical hardware (FPGAs, custom chips, or GPUs) that receives every check result, works out which errors most likely happened, and feeds corrections back, all within about a microsecond on superconducting machines, or the backlog grows without limit. AI-based decoders, discussed in Quantum Computing + AI, are one route to making this both fast and accurate.
5. The logical layer. Logical qubits, lattice surgery and magic state factories, managed like a processor's instruction pipeline.
6. Compiler and resource estimation. Software that turns an algorithm into logical operations, counts the expensive T gates, lays out the logical qubits and estimates runtime. Tools such as Microsoft's Azure Quantum Resource Estimator and Google's Qualtran let researchers estimate today what an algorithm will need on tomorrow's hardware.
7. Applications. Chemistry, materials, physics and cryptanalysis, usually as part of larger hybrid workflows with classical high-performance computing.

The key architectural insight is the same one from How Does a Quantum Computer Actually Work?: a quantum computer is mostly a classical computer. At Level 3, that's even more true. The decoder alone may need a substantial classical computing system running in hard real time.

What Level 3 Unlocks

The pattern from the applications post holds: the strongest Level 3 workloads are simulations of quantum systems, and the most consequential one for IT is cryptanalysis, which is why post-quantum cryptography is being deployed years before Level 3 machines exist.

How the Industry Roadmaps Map to the Three Levels

Roadmaps change and are statements of intent, not guarantees, but they share a striking convergence: most major players aim to reach early Level 3 around the end of this decade.

Microsoft's position is worth noting because it explains why the three-level language spread so quickly. Its own topological qubit work (Majorana 1, announced in 2025) is still debated scientifically, as covered in How Are Qubits Actually Built?, so in parallel it has worked with Quantinuum and Atom Computing to demonstrate Level 2 logical qubits on other hardware. The levels give everyone a hardware-neutral way to describe progress.

The Hard Problems Between the Levels

Getting from Level 2 to Level 3 isn't one breakthrough; it's a long list of engineering problems that all have to be solved together.

• Scale. Going from a few hundred physical qubits to around a million needs new fabrication, packaging and yield control, the same kind of work the semiconductor industry did over decades.
• Wiring and cryogenics. You can't run a million control wires into a fridge. Control electronics must move closer to the qubits, and machines must become modular.
• Linking modules. Modular machines need high-quality connections between chips or traps, often using photons. That's the bridge to stage 10, quantum networking.
• Real-time decoding. Decoders must keep up with a million or more checks per second per logical qubit, with low latency, at scale.
• Magic states. Producing enough high-quality magic states, fast enough, is a major part of the cost of any useful algorithm.
• Correlated errors and leakage. Error correction assumes errors are mostly independent. Events that hit many qubits at once (such as cosmic-ray bursts in superconducting chips) or qubits leaking out of their computational states must be suppressed or handled.
• Calibration and operations. Keeping a million qubits tuned is impossible by hand; it needs automated, increasingly AI-driven calibration.
• Software. Compilers, logical instruction sets, debuggers and resource estimators for a machine that runs billions of operations.

The Metrics Are Changing Too

As the field climbs the levels, the number that matters changes:

How to read the next roadmap announcement

What This Means for IT and Security Teams

• Plan security around Level 3, not around today's machines. A cryptographically relevant quantum computer is a Level 3 machine. Roadmaps targeting early fault tolerance around 2029 to 2033 are why post-quantum migration deadlines cluster around 2030 to 2035 (see Quantum-Safe PKI).
• Expect quantum as a service inside HPC. Level 3 machines will be large, expensive facilities accessed through the cloud and national computing centres, not devices you install.
• Build skills now, at Level 1. The programming model changes as machines become fault-tolerant, but the concepts (circuits, measurement, hybrid workflows) carry over. The first quantum program lab is a good start.
• Read announcements with the checklist above. It filters most of the hype.

Quick Recap

• The future of quantum computing is measured in reliable operations, not qubit counts.
• Level 1 (noisy physical qubits): today's machines; errors of about 0.1% limit circuits to hundreds or thousands of operations.
• Level 2 (error-corrected logical qubits): logical qubits that beat physical ones and improve as codes grow; demonstrated since 2023 to 2025, with Willow's below-threshold result as the landmark.
• Level 3 (fault-tolerant computers): every operation protected, including T gates via magic state factories; thousands of logical qubits; roughly a million physical qubits at today's error rates.
• Overhead depends on quality: at 0.1% physical error, a one-in-a-trillion logical qubit needs about 880 physical qubits; at 0.01%, about 240.
• The machine is mostly classical: real-time decoders, compilers and control systems wrap a quantum core.
• Roadmaps converge on early Level 3 around 2029 to 2033, which is why post-quantum cryptography deadlines fall around 2030 to 2035.
• Between the levels lie engineering problems: scale, wiring, modularity, decoding, magic states and correlated errors.

What's Next on the Learning Path

Next in stage 11, The Future of Computing: CPU + GPU + NPU + QPU shows how quantum processors will fit alongside CPUs, GPUs and NPUs in hybrid systems. The remaining posts look at the next ten years in more detail: the technologies racing towards fault tolerance, the industries preparing for it, and the skills worth building now. Stage 10, Quantum Networking, covers the links that will connect modular quantum computers to each other. The full 11-stage path is listed at the end of the beginner's guide.