A quantum computer is not a faster computer. It is a machine that solves a short list of specific problems in a fundamentally different way — and for everything outside that list, it is worse than the laptop you are reading this on.
So what is on the list? Four problem classes have credible theoretical support: simulating quantum systems like molecules, factoring large numbers, searching unstructured data, and certain optimisation and machine-learning tasks. They are not equally promising. One of them is the reason quantum computing was invented, one would break most of today's encryption, and two are where most of the marketing money goes despite the thinnest evidence.
The honest summary in 2026: no quantum computer has yet done anything commercially useful faster than a classical computer. That is not a reason to dismiss the field. It is a reason to be specific about which claims rest on proof, which rest on plausible theory, and which rest on hope.
The Four Things Quantum Computers Might Actually Do
Every credible quantum application traces back to one of four algorithmic families. What separates them is not how interesting the problem sounds — it is the size of the speedup the algorithm offers, which turns out to decide almost everything.
| Problem class | Speedup over classical | Flagship algorithm | Evidence strength |
|---|---|---|---|
| Simulating quantum systems | Exponential | Quantum phase estimation | Strongest — the problem is natively quantum |
| Factoring, discrete logarithms | Exponential | Shor's algorithm | Proven in theory; needs enormous machines |
| Unstructured search | Quadratic only | Grover's algorithm | Real but probably too small to pay off |
| Optimisation, machine learning | Unclear, often none | QAOA, VQE, QML | Weakest — several claims have collapsed |
Notice that the two classes with genuine exponential speedups are narrow and technical, while the two that sound most commercially exciting sit at the bottom. That inversion is the single most useful thing to understand about this field.
If you want the underlying mechanics — superposition, entanglement, why qubits scale the way they do — start with our quantum computing explainer and come back.
Simulating Nature: The One Everyone Agrees On
Quantum computing began as an answer to a specific frustration. In 1982, Richard Feynman pointed out in his paper Simulating Physics with Computers that classical machines are badly suited to simulating quantum mechanics, because the amount of classical information needed to describe a quantum system grows exponentially with its size. His suggested fix was direct: build the simulator out of quantum mechanics too.
This remains the strongest case for quantum computing, and the reason is almost tautological. Molecules are quantum systems. Simulating them on a classical computer means approximating a quantum process with classical arithmetic; simulating them on a quantum computer means representing a quantum process with a quantum process. No translation loss.
The consequences are practical. Chemists routinely hit molecules they cannot model accurately — not from lack of computing power, but because the exact calculation scales exponentially and every classical method must approximate somewhere.
This is why chemistry, not cryptography or logistics, is the application most physicists name first when asked what these machines are for.
The Worked Example Everyone Uses: Nitrogenase
The canonical target is FeMoco, the iron-molybdenum cofactor at the heart of the enzyme nitrogenase. Nitrogenase does something remarkable: it pulls nitrogen out of the air and converts it to ammonia at ordinary temperature and pressure.
Industry cannot do this. The Haber-Bosch process, which makes the fertiliser feeding a large share of humanity, needs high heat and high pressure, and consumes roughly 1–2% of the world's total energy. A bacterium manages the same chemistry in soil, at room temperature. Nobody fully understands how, because FeMoco's electronic structure is precisely the kind of strongly-correlated quantum problem classical methods struggle with.
In 2017, Markus Reiher, Nathan Wiebe, Krysta Svore, Dave Wecker and Matthias Troyer published a resource analysis in PNAS showing how a quantum computer could attack exactly this problem, using nitrogenase as their worked example. Their conclusion was that the chemistry is reachable — but only on a fault-tolerant machine, after paying the "substantial overhead of quantum error correction."
The trajectory since then is genuinely encouraging, and worth noting because it is the rare quantum-computing number that keeps improving:
| Year | Estimated resources for FeMoco | What changed |
|---|---|---|
| 2017 | ~111 logical qubits, ~10¹⁴ T-gates, runtime in years | First serious resource analysis |
| 2021 | ~2,142 logical qubits, ~5.3×10⁹ Toffoli gates | Traded qubits for a vastly lower gate count |
Read that table carefully, because it shows both halves of the truth. Algorithmic improvements cut the operation count by roughly four orders of magnitude in four years — a faster improvement rate than hardware has managed. And the requirement is still thousands of logical qubits, each of which needs many physical qubits to build.
The Size of the Speedup Matters More Than the Problem
Here is the insight that reorders the whole field, and it is missing from most coverage.
Error correction is not free. A logical qubit stable enough to run a long computation is assembled from many noisy physical qubits, and every logical operation costs far more time than a raw physical one. That overhead is a large constant multiplier on the quantum side.
Now consider what that does to a speedup. A quadratic speedup means a problem taking N steps classically takes about √N quantum steps. Impressive on paper. But if each quantum step carries a thousand-fold error-correction overhead, the constant factor eats the scaling advantage until the problem gets enormous — and by then the runtime may be years.
In 2021, Ryan Babbush, Jarrod McClean, Michael Newman, Craig Gidney, Sergio Boixo and Hartmut Neven worked this through in PRX Quantum. Their conclusion is blunt: "quadratic speedups will not enable quantum advantage on early generations of such fault-tolerant devices unless there is a significant improvement in how we would realize quantum error-correction." Quartic speedups, they found, "look significantly more practical."
This matters because Grover's algorithm — the one usually described as letting quantum computers "search enormous databases" — is quadratic. So a large family of intuitively appealing applications may simply never pay for itself, not because the physics fails, but because the accounting does.
It also explains why the two exponential cases dominate serious roadmaps. An exponential speedup can absorb an enormous constant factor and still win. A quadratic one cannot.
Optimisation: The Widest Gap Between Pitch and Proof
Optimisation is where quantum computing is sold hardest. Route planning, portfolio construction, scheduling, logistics — the pitch writes itself, and the addressable market is vast.
The evidence is much thinner than the pitch, though not empty, and the honest version is more interesting than either the hype or the dismissal.
The strongest published claim comes from a 2024 Science Advances paper by Ruslan Shaydulin and 30 co-authors from JPMorgan Chase, Quantinuum and Argonne National Laboratory. Studying the low autocorrelation binary sequences problem — a real problem, used in radar pulse design — they reported a scaling advantage for the Quantum Approximate Optimization Algorithm: a time-to-solution scaling of 1.21^N against 1.34^N for Memetic Tabu, the best known classical heuristic.
Look closely at what that says, because the detail is the story:
- 1.21^N is still exponential. The quantum result is a smaller exponent, not a different complexity class. Both approaches blow up; one blows up more slowly.
- The advantage appeared in noiseless simulation, run on a classical supercomputer with up to 40 simulated qubits — not on a quantum computer.
- On real hardware — a Quantinuum trapped-ion processor, up to 18 qubits — results degraded to "approaching random guess because of experimental imperfections."
- The authors are explicit that "the overheads of fault tolerance must be substantially reduced to realize the quantum speedup."
That is a legitimate scientific result, and it is also nothing like "quantum computers solve optimisation." Meanwhile, 2025 work on constraint-satisfaction problems found a classical mean-field method matching or beating QAOA on average. The field is contested, and no one has demonstrated a practical optimisation speedup on hardware against a strong classical solver.
Machine Learning and the Algorithms That Got Dequantised
Quantum machine learning has the shortest track record and the most cautionary history.
In 2018, Ewin Tang — then an undergraduate — was asked to prove that a quantum recommendation algorithm was exponentially faster than any classical alternative. Instead, she built a classical algorithm that matched it to within a polynomial factor. The quantum speedup, one of the strongest candidates in the field, evaporated.
The result created an entire research programme called dequantisation: taking a quantum algorithm's claimed advantage and showing that a cleverer classical algorithm, often borrowing the quantum algorithm's own sampling ideas, gets there too. Several further quantum machine-learning speedups have since been dequantised.
The lesson is not that quantum machine learning is worthless. It is that a quantum algorithm beating today's classical methods is not the same as beating all possible classical methods — and the gap between those two claims has swallowed a number of confident predictions.
What Has Actually Been Demonstrated
Quantum computers have beaten classical ones at something. It is important to be precise about what.
The benchmark is random circuit sampling: run a randomly chosen quantum circuit and sample its outputs. It is a deliberately contrived task, chosen because it is hard to simulate classically. It does not optimise anything, simulate a molecule, or break a code. Its only purpose is to demonstrate that the hardware is doing something classically difficult.
Even there, the ground keeps shifting. Google's 2019 Sycamore experiment claimed a task that would take a classical supercomputer millennia. By 2024, Xian-He Zhao, Han-Sen Zhong, Feng Pan and colleagues had simulated it classically in National Science Review, producing three million samples of matching fidelity in 86.4 seconds against Sycamore's 600 — seven times faster — using 1,432 GPUs.
One detail in that comparison deserves more attention than it gets. The classical run consumed 13.7 kWh; Sycamore used 4.3 kWh. Classical hardware won on time and lost on energy by roughly three to one. If quantum computing has an underrated near-term advantage, energy efficiency may be a better candidate than raw speed.
The dispute is still live. A July 2026 preprint by Sangchul Oh argues that random circuit sampling's hardness was misattributed all along. It has not been peer-reviewed, is single-authored, and makes a sweeping claim — so treat it as evidence that the benchmark remains contested, not as a settled refutation. Google and teams in China have meanwhile pushed experiments beyond the reach of known classical simulations.
Read that pattern honestly and it says something specific: quantum hardware has crossed a real technical threshold on artificial tasks, while the useful applications remain ahead of us.
A Realistic Scorecard
| Application | Status in 2026 | What it is waiting on |
|---|---|---|
| Chemistry and materials simulation | Credible, unproven | Thousands of logical qubits |
| Breaking RSA and elliptic-curve crypto | Theoretically certain, practically distant | Millions of physical qubits |
| Random circuit sampling | Demonstrated, and contested | Nothing — but it is not useful |
| Optimisation | Contested; no hardware advantage | Cheaper fault tolerance |
| Quantum machine learning | Weakest case; several claims dequantised | A speedup that survives classical attack |
| Everyday computing | Not a target and never will be | — |
That last row is not a limitation, it is a category error. A quantum computer will not speed up your spreadsheet or your browser, for the same reason a wind tunnel will not help you write an email. We cover why in quantum vs classical computing.
Common Misconceptions
"Quantum computers try all answers at once." They do not. A quantum computer holds a superposition of states, but reading it collapses that superposition to a single result. Useful algorithms work by arranging interference so wrong answers cancel and right ones reinforce — closer to engineered acoustics than parallel search. Entanglement is what makes this coordination possible.
"Quantum computers will replace classical ones." No serious roadmap proposes this. Quantum processors are expected to work as accelerators for narrow subroutines, in the way GPUs handle graphics and matrix maths while the CPU runs everything else.
"Encryption is about to fall." Shor's algorithm works, but the machine required is far beyond current hardware. The genuine near-term risk is harvest now, decrypt later — intercepting encrypted traffic today to decrypt once such a machine exists. That is why post-quantum standards are being deployed now, and it is covered fully in our guide on whether quantum computers will break encryption.
"Quantum computers are good at big data." This is the Grover misconception with a business-intelligence accent. The speedup is quadratic, and per the PRX Quantum analysis above, quadratic is probably not enough.
The Bottom Line
Quantum computers are good for problems that are natively quantum, and for a small number of mathematical structures — factoring above all — where a quantum algorithm offers an exponential shortcut. Everything else is either an open research question or marketing.
The most reliable filter is not the application but the arithmetic. Ask what the speedup is. Exponential is worth building a machine for. Quartic may be. Quadratic probably is not, once error correction is paid for. And if nobody will name the speedup, that is usually the answer.
Judged that way, the field looks neither like a bubble nor like an imminent revolution. It looks like a serious effort to build an instrument for a specific and valuable class of scientific problems — the same thing the Large Hadron Collider is, with a longer road still to travel. Explore the rest of the cluster in our quantum computing hub.
Frequently Asked Questions
What are quantum computers actually used for today?
In commercial terms, nothing yet. No quantum computer has performed a useful task faster or cheaper than a classical computer. Current machines are used for research: testing algorithms, benchmarking hardware, and running small demonstrations of chemistry and optimisation problems whose answers are already known classically. The genuinely useful applications need error-corrected machines that do not exist yet.
What is the single most promising application?
Simulating quantum systems — molecules and materials. The reasoning is structural rather than speculative: molecules are quantum systems, so a quantum computer represents them without approximation, while every classical method must approximate somewhere. This was Feynman's original 1982 argument for building quantum computers, and it remains the application experts most consistently agree on.
Why can't quantum computers just speed up everything?
Because a quantum speedup depends on exploiting mathematical structure in a problem, and most tasks have no such structure to exploit. Loading ordinary data into a quantum computer, adding numbers, or running a web browser gains nothing — and quantum hardware is far slower and noisier per operation than a classical chip. For the vast majority of computing, a classical processor is simply the better machine.
Is quantum computing overhyped?
The science is real; specific commercial claims frequently are not. The clearest warning sign is a promised application resting on a quadratic speedup, which published analysis suggests will not overcome error-correction overheads on early fault-tolerant machines. A second sign is any optimisation or machine-learning claim that does not distinguish between noiseless simulation and results on real hardware.
Has any quantum computer beaten a classical one?
Yes, on deliberately artificial tasks. Random circuit sampling experiments have produced results beyond known classical simulation methods. But several claims have since been matched classically — Google's 2019 Sycamore result was reproduced seven times faster on 1,432 GPUs in 2024 — and the task itself is useless by design. No quantum computer has beaten a classical one at a problem anybody wanted solved.
How far away are useful quantum computers?
Nobody credible gives a confident date, and you should distrust anyone who does. The requirement is thousands of error-corrected logical qubits, where today's best systems manage a handful. The encouraging trend is that algorithmic improvements have cut resource estimates faster than hardware has improved — the FeMoco gate count fell roughly four orders of magnitude between 2017 and 2021 — so progress may come as much from better algorithms as from bigger chips.
Sources
- Elucidating Reaction Mechanisms on Quantum Computers — Reiher, Wiebe, Svore, Wecker & Troyer, PNAS 114:7555–7560 (2017)
- Focus beyond Quadratic Speedups for Error-Corrected Quantum Advantage — Babbush, McClean, Newman, Gidney, Boixo & Neven, PRX Quantum 2, 010103 (2021)
- Evidence of scaling advantage for the quantum approximate optimization algorithm on a classically intractable problem — Shaydulin et al., Science Advances (2024)
- A quantum-inspired classical algorithm for recommendation systems — Ewin Tang (2018)
- Leapfrogging Sycamore: harnessing 1432 GPUs for 7× faster quantum random circuit sampling — Zhao, Zhong, Pan et al., National Science Review (2024)
- Green ammonia synthesis — Nature Synthesis (2023)
