A quantum computer is a machine that processes information in qubits, which hold weighted combinations of 0 and 1, and computes by making those weights interfere so that wrong answers cancel and right ones add up. It is not faster across the board: only for specific problems, such as factoring large numbers and simulating molecules.
This guide explains bits and qubits, superposition, entanglement and interference in plain terms, why "faster" applies to only some problems, why noise is the real engineering problem, the four main kinds of hardware, and where the field stands in September 2026. For the view from an IT department, read how quantum computing could transform IT; for how quantum programs are built from gates, see quantum circuit design explained.
What is a quantum computer?
A quantum computer is a processor whose basic parts, the qubits, follow the rules of quantum mechanics instead of the on-or-off logic of transistors. The idea goes back to the 1980s, when Richard Feynman and Yuri Manin suggested that hardware built on quantum effects might simulate quantum systems more efficiently than conventional computers. In 1994 Peter Shor showed that such a machine could also factor large numbers far faster than any known classical method, and the field took off.
Two things about it are widely misunderstood. First, a quantum computer does not replace your servers. In cloud services such as Amazon Braket, a quantum processing unit (QPU) works as a co-processor for ordinary CPUs, speeding up specific calculations inside a classical program. Second, its power does not come from trying every answer at once. It comes from a narrower trick, interference, which only helps with problems that have the right mathematical structure. The rest of this guide builds up to why.
Bits versus qubits
A classical bit is 0 or 1. A qubit is described by two numbers called amplitudes, one for 0 and one for 1. When you measure it, you get 0 or 1, with probabilities set by the squared size of each amplitude, and the qubit is left in the state you observed. Measurement is the only way to get information out, and it always hands back ordinary bits.
What changes is the bookkeeping in between. Describing n qubits takes 2ⁿ amplitudes, one for every possible pattern of bits. Microsoft's documentation gives a concrete example: a system of particles that can sit in 40 possible locations has 2⁴⁰ configurations, and writing down its quantum state on a classical computer takes 2⁴⁰ numbers, over 130 GB of memory. Each extra location doubles that. A quantum computer needs 40 qubits to hold the same state. This is why quantum computers are a natural fit for simulating quantum systems, and why simulating even a modest quantum computer on classical hardware soon becomes impossible.
The catch is that you cannot read those amplitudes. Measure 40 qubits and you get 40 bits. Everything useful has to happen before measurement, by steering the amplitudes so that the answer you want is the likely outcome.
Superposition, entanglement and interference, in plain words
These three effects are the raw material of every quantum algorithm.
Superposition. A qubit with non-zero amplitudes for both 0 and 1 is in a superposition. It is not secretly one or the other, waiting to be discovered: until it is measured, both amplitudes take part in the calculation. One standard gate, the Hadamard gate, turns a qubit that starts at 0 into an equal superposition of 0 and 1.
Entanglement. Entangled qubits share one joint state that cannot be described qubit by qubit. The textbook example takes two gates: a Hadamard gate followed by a CNOT turns two qubits that start at 00 into a state that, when measured, gives 00 half the time and 11 the other half, and never 01 or 10. Neither qubit has a value of its own, yet their results always agree. Algorithms use entanglement to build the correlations between qubits that a calculation needs.
Interference. This is the part popular explanations skip, and IBM calls it the engine of quantum computing. Amplitudes behave like waves: they can be positive or negative (in general, complex numbers), so when an algorithm combines them, amplitudes that line up add together and amplitudes of opposite sign cancel. A quantum algorithm is a sequence of gates arranged so that, by the time you measure, the amplitudes for wrong answers have cancelled and the amplitude for the right answer has grown. Lov Grover described his 1996 search algorithm in exactly these terms: by adjusting the phases of operations, successful computations reinforce each other.
An analogy that holds up is noise-cancelling headphones. They play a sound wave that is the mirror image of the incoming noise, and the two cancel. A quantum algorithm does the same with amplitudes, deliberately, for the wrong answers, while the waves for the right answer add up. The analogy stops at two points: amplitudes are not physical sound, and you never observe them directly, only the measurement results they make likely.
This explains the most common myth. "A quantum computer tries every answer in parallel" is half true: one gate per qubit puts a register into a superposition of every input. But measuring that register returns one input at random, which is no better than guessing. The speedup exists only when interference can concentrate the amplitude on the answer, and that is possible only for problems with structure an algorithm can exploit.
How a quantum computer runs a program
A run on real hardware takes five steps; the figure at the top of this page splits the gate step into the three effects above.
- Prepare. Every qubit is reset to 0.
- Apply gates. Single-qubit gates create superpositions, two-qubit gates such as CNOT create entanglement, and the whole sequence, called a circuit, is designed so that interference favours the answer.
- Measure. Each qubit returns 0 or 1.
- Repeat. Because the outcome is probabilistic, the same circuit is run many times. Each run is a shot, and the number of shots is chosen for the accuracy you need.
- Post-process. A classical computer turns the counts into a result. In hybrid algorithms, it also adjusts the circuit's parameters and sends it back for another round.
Steps 1 to 3 have to finish before the qubits lose their quantum state. That deadline is where the engineering difficulty begins, and it comes up again below.
Is a quantum computer faster than a normal computer?
For most work, no. A 2023 analysis by Torsten Hoefler, Thomas Häner and Matthias Troyer, published in Communications of the ACM, makes the point plainly: each operation on a quantum computer is slower than the corresponding classical one, so classical computers are always faster on small problems. A quantum computer wins only past a crossover point, where an algorithm's reduction in the number of steps outweighs the slower steps. The useful question is not "is it faster" but "for which problems is the reduction big enough". These are the known answers.
Factoring and discrete logarithms: Shor's algorithm
Shor's algorithm factors integers and computes discrete logarithms in a number of steps that grows polynomially with the number of digits, exponentially faster than the best known classical algorithm. Those two problems underpin RSA and elliptic-curve cryptography, which is why the result matters far beyond physics. It also needs a large, error-corrected machine, which does not exist yet; what that means for encryption, and how organizations are replacing RSA and elliptic-curve keys, is covered in our guide to quantum computing in cybersecurity.
Search: Grover's algorithm and its quadratic limit
Grover's algorithm finds a marked item among N unsorted items in about √N steps, where any classical method needs to check about N/2 items for an even chance of success. For a million entries, that is on the order of a thousand steps instead of half a million. It sounds large, but it is a quadratic speedup, and it cannot be improved much: Bennett, Bernstein, Brassard and Vazirani proved that no quantum algorithm searches an unstructured space in fewer than about √N steps, so Grover's algorithm is essentially optimal. Hoefler and colleagues estimate that, with slower quantum operations, a quadratic speedup on even a single floating-point operation per step would take several months to reach the crossover point. Their conclusion: quadratic speedups are not enough for practical advantage.
Simulating molecules and materials
The strongest practical case is the one Feynman started with. Chemistry and materials are governed by quantum mechanics, and their classical description grows exponentially, as the 130 GB example shows. A 2017 study in PNAS worked through the reaction mechanism of nitrogenase, the enzyme behind biological nitrogen fixation, and estimated that a fault-tolerant quantum computer could complete the calculation in reasonable time, error-correction overhead included. Hoefler and colleagues name chemistry and materials science as the most promising application of all.
Benchmarks that are fast but not useful
Speed records usually come from benchmarks. In December 2024 Google reported that its Willow chip ran a random circuit sampling task in under five minutes that would take one of the fastest supercomputers 10²⁵ years, while noting that the benchmark has no known real-world application. It proves the hardware does something classical machines cannot, not that it is faster at your workload.
Why big data is a poor fit
Getting data in and out is slow. The same analysis estimates that even an optimistic future quantum computer would read classical data about 10,000 times more slowly than a classical chip available today. Any problem limited by data access, such as searching a large database, will be solved faster classically. In the authors' phrase, quantum computers suit "big compute" problems on small data.
What quantum computers are good at, and what they are not
| Task | Quantum fit | Why |
|---|---|---|
| Factoring and discrete logarithms (RSA, ECC) | Strong, once machines are fault-tolerant | Shor's algorithm is exponentially faster than the best known classical method |
| Simulating molecules and materials | Strongest practical candidate | Exponential speedup on small inputs; classical cost explodes with system size |
| Unstructured search | Weak | Grover's √N speedup is the proven ceiling, and too small to pay off in practice |
| Database queries, analytics, anything data-heavy | Poor | Loading classical data into qubits is far slower than on a classical chip |
| Training large AI models | Poor with current algorithms | Proposed speedups are mostly quadratic, and training is data-heavy |
| Monte Carlo, weather and fluid simulation | Not with current algorithms | Proposed speedups are quadratic; the 2023 analysis lists them among likely dead ends |
| Web servers, email, office software, games | None | The work is mostly input and output, and each quantum operation is slower |
Why noise is the hard part
Qubits are fragile. Contact with the environment, such as heat, vibration or stray electromagnetic fields, pushes a qubit out of its quantum state, a process called decoherence. That is why superconducting processors are cooled to about a hundredth of a degree above absolute zero. Gates are imperfect too: current quantum computers have error rates between 1% and 0.1% per operation, so roughly one gate in every 100 to 1,000 goes wrong. Among the best published figures, Quantinuum reports 99.921% two-qubit gate fidelity for its Helios system, launched in November 2025: fewer than one error per thousand two-qubit gates.
Useful algorithms need far better. A 2023 Nature paper from a Harvard-led team puts the requirement for large-scale algorithms at gate error rates below about 10⁻¹⁰, one in ten billion, far below what any physical device is likely to reach on its own. John Preskill named the current stage in 2018: noisy intermediate-scale quantum, or NISQ, machines in which noise limits the size of the circuits that run reliably. As of September 2026, Amazon's documentation still describes the industry as in the NISQ era, with devices too noisy to run Shor's or Grover's algorithm as designed.
How error correction turns many qubits into one logical qubit
Classical computers protect data by copying it. Quantum information cannot be copied (the no-cloning theorem), and measuring a qubit destroys its superposition, so quantum error correction works differently. It spreads one qubit's worth of information across many physical qubits, whose joint state forms a logical qubit. Extra qubits repeatedly check parities between neighbours, which reveals whether and where an error happened without reading the data itself. Errors come in two kinds: bit flips, which swap 0 and 1 like a classical error, and phase flips, which change the sign of an amplitude and have no classical equivalent. A code has to catch both. The surface code, a two-dimensional grid of qubits, is one of the most promising designs.
The catch is the threshold. Every added qubit is another place for errors to happen, so a bigger code only helps if each physical qubit is good enough. Below that threshold, each step up in code size cuts the logical error rate exponentially; above it, a bigger code does not help.
In December 2024, Google Quantum AI published the first clear demonstration below threshold, in Nature. On its 105-qubit Willow processor, the team grew a surface code from distance 3 to 5 to 7 (grids of 3×3, 5×5 and 7×7 data qubits), and each step cut the logical error rate by a factor of 2.14. The distance-7 logical qubit used 101 physical qubits, had an error rate of 0.143% per round of error correction, and kept its information 2.4 times longer than the best physical qubit in it.
Keep the limits in view. This was a quantum memory, one logical qubit being stored, not a computation across many. It took 101 physical qubits to make that one logical qubit, and the team found rare correlated errors, about once an hour, whose origin was not yet understood. Other groups have encoded more logical qubits with lighter codes: a Harvard-led team working with QuEra ran up to 48 logical qubits on 280 neutral atoms in 2023, using codes that detect rather than fully correct errors, and Quantinuum reports 48 error-corrected logical qubits on Helios. How circuits are laid out on the surface code is covered in our guide to quantum circuit design.
The research behind "a new, faster type of quantum computer"
The phrase "a new, faster type of quantum computer" comes from science-news coverage of two papers by Michael Fellner, Anette Messinger, Kilian Ender and Wolfgang Lechner, of the University of Innsbruck and Parity Quantum Computing GmbH: Universal Parity Quantum Computing in Physical Review Letters and a companion paper on its applications in Physical Review A, both published on October 27, 2022. They are a good example of what "faster" means in quantum research.
The problem they tackle is connectivity. On a chip, a qubit usually interacts only with its neighbours, so a gate between two distant qubits needs a chain of SWAP operations to bring their states together, and every extra gate is another chance for an error. In the parity scheme, each physical qubit records the parity of a pair of logical qubits, that is, whether the two agree. A controlled-phase gate between any two logical qubits then becomes a few single-qubit rotations, including one on the qubit that records their parity. The layout needs only nearest-neighbour interactions and no SWAP chains, and its built-in parity checks detect bit-flip errors. The companion paper shows that this reduces circuit depth, the number of sequential steps, for the quantum Fourier transform (the core of Shor's algorithm) and for quantum addition, while keeping the number of multi-qubit gates comparable.
"Faster", then, means fewer steps for particular circuits, not a quicker computer in general, and it has a price. In the full layout, n logical qubits need n(n+1)/2 physical qubits, so 10 logical qubits take 55, although the paper also describes lighter variants. The papers are theoretical proposals, designed for existing hardware (superconducting, neutral-atom and trapped-ion), not reports of a new machine. That is typical: most "faster quantum computer" headlines describe a better way to run a class of circuits on hardware that is still limited by noise.
The main types of quantum computer hardware
Companies build qubits from very different physical systems. None has won, and each trades speed, scale and accuracy differently.
| Type | What the qubit is | Strength | Main hurdle | Example |
|---|---|---|---|---|
| Superconducting | A tiny superconducting circuit on a chip, cooled close to absolute zero | Fast: a gate-and-measure cycle takes about a microsecond | Building architectures with tens of thousands of qubits | Google Willow, 105 qubits (December 2024); IBM Nighthawk, 120 qubits (November 2025) |
| Trapped ion | One charged atom, held by electromagnetic fields above a trap chip and driven by lasers | Very high gate fidelity; any qubit can interact with any other | Scaling up: Quantinuum's roadmap depends on 2D trap chips made with CMOS processes | Quantinuum Helios, 98 qubits (November 2025) |
| Neutral atom | One uncharged atom, held in a focused laser beam (an optical tweezer) | Arrays of about ten thousand atoms, which can be moved to connect any pair | Slow cycles, measured in milliseconds, so deep circuits are hard | QuEra, with a Harvard-led team: 48 logical qubits (December 2023) |
| Photonic | Particles of light in silicon-photonics chips and optical fibre | Most components work at room temperature, and modules network over fibre | Losing photons along the way | Xanadu Aurora, 35 photonic chips networked into one machine (January 2025) |
The trade-offs are real enough that Google Quantum AI added neutral atoms to its superconducting program in March 2026. In its words, superconducting processors are easier to scale in circuit depth, and neutral atoms in qubit count. Which approach reaches large, error-corrected machines first is still open.
Where quantum computing stands in September 2026
Separate results from roadmaps. A peer-reviewed paper or a shipped system shows what exists; a roadmap is a company's own target.
What has been shown. Published results include error correction below threshold (Google, 2024), processors running dozens of logical qubits on neutral atoms (2023) and trapped ions (2025), and IBM's 120-qubit Nighthawk processor, announced in November 2025. On advantage, in July 2026 IBM and research partners at the University of Chicago, Qedma and Algorithmiq reported demonstrations of quantum advantage with built-in ways to validate the results, and logged them on an open Quantum Advantage Tracker where each claim is tested against the best classical methods. These are specific scientific problems, such as sampling and physics simulations, not business workloads.
What the vendors plan. The table lists published targets, not results:
| Company | Hardware | Published roadmap target |
|---|---|---|
| IBM | Superconducting | Verified quantum advantage by the end of 2026; Starling, a fault-tolerant machine with 200 logical qubits running 100 million operations, by 2029 |
| Google Quantum AI | Superconducting, adding neutral atoms | Commercially relevant superconducting quantum computers by the end of this decade (stated March 2026) |
| Quantinuum | Trapped ion | Apollo, a universal, fully fault-tolerant machine with hundreds of logical qubits, by the end of the decade (stated September 2024) |
Note
Read roadmaps in logical qubits and operations, not physical qubit counts. IBM expects Nighthawk to run circuits of up to 7,500 gates by the end of 2026; its 2029 Starling target is 100 million operations. Resource estimates for the most promising algorithms call for millions of gates on hundreds of logical qubits.
Important
Quantum computers do not break encryption today. A May 2025 estimate by Craig Gidney of Google Quantum AI puts factoring a 2048-bit RSA key at less than a million noisy qubits running for less than a week, assuming a 0.1% gate error rate; the error-corrected experiments above use roughly one hundred to a few hundred physical qubits. The risk is in the future, but migration is slow, which is why NIST published its first three post-quantum encryption standards in August 2024 and encourages administrators to start integrating them immediately.
What this means if you run IT
For most organizations, quantum computing changes one thing now: cryptography. Planning the move to post-quantum algorithms, and a realistic timeline for everything else, is the subject of how quantum computing could transform IT.
You do not need to buy hardware to learn. Quantum processors are reached as cloud services: Amazon Braket, for example, offers gate-based hardware from AQT, IonQ, IQM and Rigetti and an analog device from QuEra, along with simulators, with no upfront commitment. Treat that as a research budget for a small team, not an infrastructure decision.
In that model a quantum processor is a co-processor that classical applications call through a cloud service, next to the rest of your infrastructure. If your own applications still sit on ageing servers, that is the nearer project: our cloud transformation service moves applications to containers and cloud platforms one rehearsed wave at a time, with a rollback at every stage.
