What Quantum Is (and Isn't) Good At

An honest speedup scorecard

Let's start with the single most important honest claim in this whole field: a quantum computer is not a magic box that checks every answer at once. A superposition does let many possibilities exist as amplitudes at the same time, but you never get to read them all. When you measure, you get exactly one outcome, with a probability set by the Born rule. The entire art of quantum algorithms is arranging interference so the amplitudes for wrong answers cancel and the amplitude for the right answer grows — *then* you measure.

Because of that, the speedup you get depends entirely on the structure of your problem, not on raw qubit count. There is no single 'quantum is X times faster' number. Instead there are roughly three buckets: a few problems get an exponential speedup, a broader class gets a quadratic (square-root) speedup, and the vast majority get no useful speedup at all. Knowing which bucket a problem falls into is most of what 'understanding quantum computing' really means.

PROBLEM TYPE              SPEEDUP            EXAMPLE
-------------------------------------------------------------
structured (periodicity)  exponential        factoring (Shor)
simulating quantum systems exponential*       chemistry, materials
unstructured search        quadratic (sqrt N) database-style search
linear algebra (special)   sometimes large    certain solvers (caveats)
general-purpose computing  none worth it      email, spreadsheets, web
-------------------------------------------------------------
* exponential in the right regime; a classical computer cannot
  efficiently simulate large quantum systems at all.

Great fits: factoring, simulation, some search

The crown jewel is Shor's algorithm. It factors large numbers exponentially faster than any known classical method by reframing factoring as period-finding and using the quantum Fourier transform to extract that period through interference. This is the result that threatens RSA and ECC — but only once a large, error-corrected machine exists, which does not yet.

The fit that may matter even more is simulating quantum systems themselves: molecules, catalysts, materials, exotic phases of matter. Nature is quantum, so a classical computer pays an exponential cost to track the quantum state of even a modest molecule. A quantum computer represents that state natively. This is the original reason Feynman proposed quantum computers, and it underlies near-term approaches like the VQE and the optimization-flavored QAOA.

Then there is search. Grover's algorithm finds a marked item in an unstructured list of N items in about sqrt(N) steps instead of N, using amplitude amplification to pump probability toward the answer. That is a genuine, provable quadratic speedup — valuable, broadly applicable, and routinely overstated. It does not let you search instantly, and for many real tasks the overhead of running a quantum computer eats the square-root advantage.

Grover, roughly:

  start:   every item equally likely  (flat amplitudes)
           |x0> |x1> |x2> ... |x*> ...   <- x* is the answer

  repeat ~sqrt(N) times:
     [oracle]  flip the sign of the answer's amplitude
     [diffuse] reflect all amplitudes about their average
               -> answer's amplitude grows, others shrink

  measure -> answer with high probability

  cost: ~sqrt(N) iterations, NOT 1, NOT log(N)

Poor fits: most everyday computing

Now the honest bad news: most of what computers do every day gets no useful quantum speedup. Sending email, rendering a web page, running a spreadsheet, streaming video, serving a database of customer records, training many machine-learning models — these are either already efficient classically or lack the special structure (like hidden periodicity) that quantum algorithms exploit. For these, a quantum computer would be slower, more expensive, and far more fragile than the laptop you already own.

There is also a steep input/output tax. Many proposed quantum speedups assume your data is already loaded into a quantum state, and loading large classical datasets into qubits can itself cost as much as the speedup saves. A measurement at the end gives you just one sample from a probability distribution, not a full readout of everything inside. So even when the core math is faster, getting data in and answers out can erase the win.

Quantum is not a faster CPU

Here is the mental model to delete: *'a quantum computer is like my CPU but with way more cores.'* It isn't. A classical core does many fast, reliable, freely-copyable operations. Qubits are different animals: their states cannot be copied (the no-cloning theorem), every gate must be reversible and unitary, and reading a qubit destroys its superposition. You don't program a quantum computer by spreading ordinary instructions across more cores — you sculpt amplitudes so interference reveals an answer.

And today's hardware is genuinely fragile. We are in the NISQ era — Noisy Intermediate-Scale Quantum — where qubits lose their state in microseconds to milliseconds (decoherence, characterized by T1 and T2) and every gate carries error. There is no large-scale fault-tolerant quantum computer yet. Error correction like the surface code can fix this in principle, but only above a roughly 1% error threshold and at a brutal overhead: thousands of physical qubits per single reliable logical qubit. That overhead is exactly why Shor-scale factoring is still years away, not a product you can buy.

WRONG picture:                CLOSER picture:

  CPU with 1000 cores           1000 fragile qubits
  -> 1000x more work            -> one carefully tuned
     done in parallel              interference pattern
  -> copy/inspect freely        -> can't copy (no-cloning)
  -> read anytime               -> measure once, state
                                   collapses, get 1 sample

Reading hype critically

You now have enough to read quantum headlines like a skeptic instead of a fan. The same handful of moves show up again and again, and once you can name them, the hype mostly disarms itself. The goal isn't cynicism — quantum computing is real and genuinely exciting for its narrow wins. The goal is to tell the narrow real wins apart from the broad imaginary ones.

1. 'Tries all answers at once.' No. Superposition holds many amplitudes, but measurement returns one outcome; the work is in making interference favor the right one. Treat this phrase as a red flag for the rest of the article.
2. 'Exponentially faster at everything.' No. Only Shor-type structured problems and quantum simulation get exponential speedups. Grover-style search is quadratic. Most tasks get nothing.
3. 'We have N qubits, so it's powerful.' Ask about quality, not just count: gate error, coherence time, connectivity, and whether they're noisy physical qubits or error-corrected logical qubits. A few good qubits can beat many bad ones.
4. 'Quantum breaks all encryption today.' No. Breaking RSA needs a large fault-tolerant machine that doesn't exist yet, and post-quantum cryptography (classical algorithms resistant to quantum attack) is already being deployed. Note too that QKD is a separate, physics-based idea — not the same as post-quantum crypto.
5. 'Quantum supremacy means it's useful.' Not necessarily. A quantum advantage demo can beat classical machines on a contrived benchmark with no practical payoff. Always ask: useful for *what*, and compared to the *best* classical method?