The NISQ Era

Suppose someone hands you a brand-new quantum computer with 1000 qubits. It sounds like a machine that should factor enormous numbers and break the internet by lunchtime. It cannot — and understanding why is the single most important piece of context for where quantum computing actually stands today. The chip is real, the qubits are real, but every one of them is noisy: each gate you apply has a small chance of quietly corrupting the state, and there is no error correction running underneath to clean the mistakes up. Run a circuit that's too long and the noise swamps the signal before the answer emerges.

In 2018 John Preskill gave this awkward, in-between stage of hardware a name that stuck: NISQ — Noisy Intermediate-Scale Quantum. It is a deliberately honest label for the machines we can build right now, and it sits directly on top of the physical demands we met in the DiVincenzo criteria: we can make qubits and gates, but not yet make them good enough to run forever.

Unpacking the acronym

Each word in "Noisy Intermediate-Scale Quantum" carries real technical weight — read it as a three-part status report on today's hardware.

Noisy. There is no full error correction. Every gate has an error rate of roughly 0.1\% to 1\% (p \approx 10^{-3} to 10^{-2}), and those errors simply accumulate as the circuit runs. This is the binding constraint — it limits how deep (how many gates long) a circuit can be before it turns to mush.
Intermediate-Scale. Roughly 50 to 1000 qubits — far more than the handful you can simulate by hand or on a laptop, but far fewer than the millions that a fault-tolerant machine will need. Big enough to be interesting, too small to be safe.
Quantum. They really are quantum devices — genuine superposition and entanglement — not classical emulators. That is exactly what makes even a noisy one potentially hard to simulate on a classical computer.

The core limit: noise caps the circuit depth

Here is the whole story in one estimate. If each gate fails independently with probability p, then a circuit of D gates suffers, on average, about

\langle \text{errors} \rangle \ \approx\ D \times p

errors. Once that expected count reaches \sim 1, at least one error is likely to have struck somewhere and the result is no longer trustworthy. Setting D \times p \approx 1 gives the rough ceiling on usable depth:

D_{\max}\ \approx\ \frac{1}{p}.

So the usable circuit depth is roughly the reciprocal of the gate error rate. Halve the error rate and you double the depth you can afford. This single relationship — not the qubit count — is what defines what a NISQ machine can and cannot attempt.

Worked example 1: how deep can a NISQ circuit go?

Take a good-but-noisy device with a gate error rate of p = 0.1\% = 10^{-3}. How long a circuit can it run before we expect about one error?

D_{\max} \approx \frac{1}{p} = \frac{1}{10^{-3}} = 1000 \ \text{gates}.

Around a thousand gates — and that is the whole budget, shared across every qubit and every layer. Now suppose engineering improves the hardware tenfold, to p = 0.01\% = 10^{-4}. The ceiling rises to D_{\max} \approx 1/10^{-4} = 10{,}000 gates. A tenfold drop in error rate buys a tenfold increase in usable depth — which is exactly why the error rate, not the qubit count, is the headline number that matters.

Worked example 2: why Shor's algorithm is out of reach

Now push the other way. Running Shor's algorithm on a cryptographically interesting number needs on the order of millions to billions of high-fidelity gates — the modular-exponentiation circuits alone are enormous. Ask how small the error rate would have to be to run, say, D = 10^{9} gates with the naive D \cdot p \lesssim 1 rule:

p \ \lesssim\ \frac{1}{D} = \frac{1}{10^{9}} = 10^{-9}.

A one-in-a-billion gate error rate — roughly a million times better than today's best physical gates (\sim 10^{-3}). No amount of clever engineering closes a gap that large by improving raw gates alone. The only known way out is to stop relying on perfect gates and instead correct errors as you go: encode each logical qubit across many physical ones so mistakes can be detected and undone faster than they pile up. That is the fault-tolerant era — and it is a different world from NISQ.

See it: depth collapses as the error rate grows

The plot below draws the ceiling D \approx \text{(errors tolerated)}/p against the gate error rate p. Notice the shape: as p shrinks toward the left the usable depth shoots up, and as p grows the depth crashes. Drag the slider to allow yourself a few more expected errors and watch the whole curve lift — but the punchline never changes: on NISQ hardware, with p around 10^{-3}, you get hundreds to a few thousand gates, nowhere near the millions Shor demands.

What NISQ machines can actually attempt

A thousand-gate budget rules out the famous deep algorithms, but it does not mean the machines are useless. The whole NISQ research programme is about finding shallow, noise-tolerant things to do. Three families dominate.

Variational algorithms — VQE and QAOA. A short quantum circuit with tunable parameters is run, measured, and a classical optimiser nudges the parameters to improve the result — repeat. The quantum part stays shallow (NISQ-friendly), and the loop tolerates some noise because it's only searching for a good setting, not computing an exact answer.
Quantum simulation — modelling small quantum systems (a molecule, a lattice of spins) directly on quantum hardware, which is the original motivation Feynman gave for building quantum computers at all.
Sampling tasks — random-circuit sampling and boson sampling, used in "quantum advantage" demonstrations, where a quantum device produces a distribution that is believed to be hard for any classical computer to reproduce.

Picture: the NISQ era and what lies beyond

It helps to see quantum computing as a landscape with two regions separated by a wall. On the left is where we live now — the NISQ era. On the right is the fault-tolerant era that the deep algorithms require. Between them stands the error-correction threshold: to cross it you must spend many noisy physical qubits to build one reliable logical qubit. Step through the figure to build up the map.

The question that hangs over this whole era is deceptively simple: can a noisy machine do something useful before fault tolerance arrives? It's crucial to separate two very different milestones. Quantum advantage (sometimes "quantum supremacy") means a quantum device outruns the best classical simulation on some task — and that has been demonstrated, on contrived random-sampling problems chosen precisely because they are hard to simulate. But those tasks compute nothing anyone wanted the answer to; they are stopwatches, not solutions. Practical quantum advantage — a genuinely useful problem solved better, faster, or cheaper than any classical method — has not been convincingly shown on NISQ hardware. Whether it can be, before error correction matures, is the defining open question of the NISQ era, and the reason the field feels equal parts thrilling and uncertain.

Two traps to sidestep. First, a "quantum advantage" sampling demonstration is not a useful computation. It proves a device is hard to simulate on a contrived task; it does not solve a problem you had. Treating a headline like "quantum computer beats a supercomputer" as though a practical breakthrough occurred is a genuine misreading. Second — and more insidious — the qubit count is nearly meaningless on its own. A press release trumpeting "1000 qubits!" tells you almost nothing, because 1000 noisy qubits are not 1000 usable qubits. Without high gate fidelity (a low error rate) and enough connectivity between qubits, those thousand qubits can only run circuits a few hundred gates deep — and after error correction, thousands of them might encode just a handful of reliable logical qubits. The number to watch is the gate error rate, not the qubit count.

Summary

NISQ names exactly where quantum computing sits today: powerful enough to be genuinely quantum and hard to simulate, but too noisy to run the algorithms that made the field famous. The road forward runs through error correction — encoding fragile logical qubits across many physical ones — toward the fault-tolerant machines that Shor and Grover at useful scale require.

NISQ = Noisy Intermediate-Scale Quantum (Preskill, 2018): roughly 50–1000 qubits with no full error correction;
gate errors (\sim 0.1\%–1\%) accumulate, so usable depth is capped at about D_{\max} \approx 1/p — shallow circuits only;
NISQ-friendly work is shallow and noise-tolerant: variational algorithms (VQE / QAOA), quantum simulation, and sampling demonstrations;
deep algorithms like Shor need millions–billions of high-fidelity gates — out of reach without error correction (the fault-tolerant era, many physical qubits per logical qubit);
a "quantum advantage" demo ≠ a useful computation, and raw qubit count is meaningless without fidelity — watch the error rate.