Scoring quantum use cases: five criteria and a weakest-link rule

The quantum-computing industry does not lack use-case lists. Consortium studies catalogue dozens of candidate applications across finance, chemistry, logistics and energy; consultancy monitors attach projected value in the billions; every vendor keynote adds a few more entries.^[1] What these inventories share is that they enumerate. What almost none of them do is discriminate — say which use case is ahead of which, on what evidence, and what specifically blocks the rest.

There is a reason for that, and it is not laziness. The dimensions on which use cases differ are asymmetrically easy to argue. Business value is always argued at length, because it is the part the audience wants to hear and the part that needs no quantum expertise to write. The other questions — is the advantage real end-to-end, can the data actually be loaded, has anyone run the pipeline, what machine does it need — are asserted in a sentence, when they appear at all. Value is the criterion hype gets right. The other four separate a use case from a pitch.

For our own engagements we therefore use a criteria-based assessment: a pass-or-fail screening gate, five criteria scored one to five against fixed anchors, and three derived verdicts — an overall score, a maturity level, and a production horizon. We call it MERIQ, a Maturity Evaluation Rubric for Industrial Quantum use cases. The name matters less than the discipline: the same questions, the same anchors, the same arithmetic for every candidate — including our own flagship, which, as you will see, the rubric refuses to flatter.

This article publishes the model in detail: the gate, the criteria, the anchors, and the derivation rules. It then scores two use cases from the same industry — the sensitivity analysis of business risk that powers our risk demo and the RISQ platform, and a generic quantum-machine-learning case that sounds nearly identical in an executive pitch and lands forty points lower. A closing section says what stays proprietary, and why.

First, a gate: not every hard problem is a quantum problem

Before anything is scored, a candidate must pass three questions. They are pass-or-fail, not graded:

1. Is the classical route expensive, with no cheap shortcut? Not “impossible” — expensive. What disqualifies a candidate is a cheap classical alternative: a closed-form solution, a low-dimensional reformulation, an effective variance-reduction scheme such as importance sampling. A high-dimensional Monte Carlo with none of those escapes qualifies even if it finishes overnight, because computing the same risk measure faster, or more accurately at the same cost, is a competitive edge in itself, for example the desk that re-prices in minutes reacts to a market its competitor is still simulating.
2. Is it structurally quantum-aligned? The problem should be high-dimensional, strongly correlated or combinatorial in a way that maps naturally onto amplitudes and interference. Some problems are simply hard, and stay classical.
3. Is it industrially relevant, with a buyer? An identified owner whose decisions change if the answer improves. Academic interest is necessary; it is not sufficient.

A candidate that fails any of the three is parked, not scored — scoring it would only launder a non-candidate into a low number that invites re-litigating. The use-case timeline SoftBank and Quantinuum published in July 2026 applies essentially the same filter before its feasibility analysis begins,^[2] with one difference of emphasis: theirs asks for outright classical intractability, ours deliberately for the weaker condition — a reliable speed or accuracy edge over the best classical method is already an economic one.

Five questions, scored one to five

Past the gate, five criteria. Each is a question, each names the evidence that feeds it, and each is scored against five fixed anchors — so that two assessors with the same evidence land in the same place, and so that a score can be argued about productively.

1. Business value. If the computation worked at full accuracy and scale, who would act on the answer, and what is acting worth? Evidence: an identified decision owner, the decision cadence, the cost of estimation error — and marginal-gain leverage: whether a small, statistically verifiable improvement converts into large value on a large addressable base.
2. Expected quantum advantage. What is the best-supported speedup over the best classical method, for the end-to-end task — and does it survive overhead accounting? Evidence: complexity results with explicit input and output models, the strength of the classical baseline, dequantisation results.
3. Data basis. Can the input the algorithm needs be obtained, and loaded into a quantum state, at a cost that does not erase the advantage? This criterion exists because data loading is the classic quantum bottleneck — the fine print, in Aaronson’s phrase, under many a claimed speedup.^[3]
4. Technical feasibility. How far along is the algorithm-to-execution pipeline — concept, paper, simulation, compiled pipeline, hardware? Executable, noise-tested evidence outranks theory here, deliberately: this criterion is kept separate from advantage, which credits proofs.
5. Resource requirements. What machine does this need at useful scale, and where does that sit against vendor roadmaps? Scored inverted — lower requirements score higher. Evidence: logical-qubit counts, T- and Toffoli-gate counts including the magic-state factories that supply them, circuit depth.

Two design rules run through all five. First, end-to-end or it does not count: a speedup for a kernel, measured from the moment the data is already in amplitudes to the moment before anyone reads the answer out, is a level-3 claim at best. Second, every use case must name its scaling axis — the one tunable number that tracks difficulty, against which resources are estimated. For a molecule that might be spin orbitals; for a risk model, the number of risk items; for a classifier, the size and dimensionality of the training set. A use case that cannot name its scaling axis is not yet specified enough to score.

The anchors

The anchors below are the published calibration of the model. They are worded so that placing a use case is mostly a matter of evidence, not taste.

Business value

Expected quantum advantage

The top of this ladder deliberately distinguishes quadratic from super-quadratic. A proven end-to-end quadratic speedup is a real mathematical fact and a weak economic one: once the constant-factor overheads of error correction are priced in, quadratic advantages are unlikely to pay off at realistic clock rates and problem sizes — the case made carefully by Babbush and colleagues, and one we accept.^[4] The tortoise-and-hare model behind MIT’s quantum-economic-advantage calculator reaches the same verdict from the economics side: a quantum computer takes algorithmically fewer steps but takes each step more slowly, so an advantage exists only past the crossover problem size at which fewer steps outweigh the slower clock — and for quadratic speedups that crossover typically sits beyond economically relevant sizes, while super-quadratic speedups pull it well inside.^[5]

Data basis

Technical feasibility

Resource requirements (inverted)

One caution before the table: a logical qubit is not a platform-neutral currency. Superconducting processors run error-correction cycles in about a microsecond but bring lower physical fidelities, so they pay for a logical qubit with more physical qubits — a multiplier that qLDPC codes are currently compressing. Trapped-ion machines have it the other way round: fidelities high enough for leaner encodings, at gate speeds two to three orders of magnitude slower — a price that compounds on deep circuits, where wall-clock time is set by the clock, not the qubit count. We have written about the fast clock and its price separately. For scoring, the consequence is that the evidence behind a resource score must name its platform class: the same logical footprint can mean two very different machines, on two very different timelines.

From five scores to three verdicts

The five scores are combined three ways, and the three outputs answer three different questions.

The overall score is the equal-weighted sum, normalised to 0–100 — a profile of straight fours lands at 80, straight threes at 60. Equal weights are the published illustration; in engagement work we apply calibrated weights, which belong to the proprietary layer described at the end of this article. The score answers: how strong is the case, all dimensions considered?

The maturity level starts from the score band in the table below, and is then subjected to the rule that gives this article its title: the final level cannot exceed the lowest single criterion score. A use case with a blocked data basis is immature no matter what its average says; averaging is exactly how weak dimensions hide. The cap has a pleasant mechanical consequence: Level 4, “pilot-ready”, requires a resource score of at least 4 — which is to say, pilot-ready requires a machine that exists. That is what pilot-ready ought to mean, and the rubric enforces it by arithmetic rather than by discipline.

One blocked dimension makes a use case immature, no matter what the average says.

The production horizon is the forward-looking verdict, and in 2026 it is the discriminating one. It is a fact of the field that no use case with a proven advantage reaches Level 4 today: the algorithms with proofs need fault-tolerant machines that do not yet exist, and the algorithms that run today lack proofs. Read as a snapshot, the maturity ladder would therefore be monotonous. Read forward, it is not — because use cases differ enormously in what blocks them. The horizon names the binding criterion and the event that lifts it, stated in vendor-neutral machine classes (available now; first logical generation, tens of logical qubits; early fault-tolerant, hundreds to a thousand; large fault-tolerant, thousands and up). The classes are deliberately platform-agnostic; dating them is not, because clock speeds and fidelities differ between platforms by orders of magnitude — a point the worked example returns to. A blocker that is a milestone on published hardware roadmaps is datable — an envelope, never a forecast, and the uncertainty grows with the horizon. A blocker that is an open research problem — no proven advantage, no loading route — is undatable. That distinction, not today’s level, is what should steer investment.

Worked example: the use case behind our risk demo

Our flagship use case, and the one this blog has already walked through from the inside: a network of business risks — intrinsic probabilities, financial impacts, conditional triggers — encoded in a state-preparation circuit; quantum amplitude estimation reading off the tail probability P(loss ≥ threshold); and Grover maximum-finding stacked on top to rank which parameter drives the tail. You can run the reduced version in your browser, and the productised version in RISQ. It passes the gate without discussion: exact evaluation enumerates 2ⁿ scenarios, Monte Carlo converges as 1/√N, and a general dependency network offers neither a closed form nor an obvious importance-sampling shortcut; the model is a network of correlated binary events, which is about as quantum-aligned as business data gets; and the buyer is any institution whose solvency arithmetic is regulated. The scaling axis is the number of risk items n: the scenario space is 2ⁿ, and the state register needs roughly one qubit per risk item.

The arithmetic: 4 + 5 + 4 + 4 + 3 = 20 of 25, an overall score of 80/100 — the 75–89 band, provisionally Level 4. Then the cap: the lowest criterion is resources at 3, so the final verdict is Level 3, Demonstrated. Our own flagship, scored with our own rubric, stops one level short of pilot-ready — because the machine it needs does not exist yet, and no amount of enthusiasm for our own algorithm changes that. We could have softened the cap to avoid this outcome. We kept it strict precisely because it binds on our best case: a rule that never bites the assessor’s own portfolio is not a rule.

The horizon is where the picture turns favourable, and it is the verdict we would actually take to a steering committee. The blocker is a hardware milestone, not an open research question: an early-fault-tolerant machine on the order of 200 logical qubits, with enough magic-state throughput to feed the rotation synthesis. On the superconducting side, that footprint now appears on vendor roadmaps almost verbatim: IBM’s Starling system, announced for 2029, targets exactly 200 logical qubits and 100 million gates on qLDPC codes, with the 2,000-logical-qubit Blue Jay to follow around 2033;^[9] IQM’s roadmap targets fault tolerance by 2030 with hundreds of logical qubits, and its 2026 tile-code results point towards encodings near 30 physical qubits per logical;^[10] Google frames a useful error-corrected machine around 2029, on the way to the million-physical-qubit endpoint of its roadmap.^[11] On the trapped-ion side, Quantinuum’s Apollo generation targets fault tolerance in 2029.^[2] The platforms will not reach the footprint on the same terms: for a construction as deep as Grover-over-QAE, the fast superconducting clock is worth paying overhead for, while the slower ion-trap clock buys fidelities that need less encoding — which machine runs the model best is itself a platform-dependent question, and part of our hardware-requirement-estimation work. Either way the blocker is datable — a milestone with a year attached, with all the usual caveats that roadmaps are envelopes and slip. Among finance use cases with a proven end-to-end advantage, this one carries one of the smallest hardware gaps we know of; the same construction extends to credit and liquidity risk with more data points and no new algorithm. Level 3 today, and near the front of the queue for Level 4.

A use case is a question, not a technology

The scorecard above contains a subtlety worth making explicit, because it changed how we define the unit of assessment. The demo answers two questions with the same circuit family. Estimate the tail probability: that is plain amplitude estimation, a proven end-to-end speedup that is quadratic — anchor 4, and per the overhead-accounting argument above, unlikely to beat a well-run classical Monte Carlo desk once error correction is priced in.^[4] Rank the drivers of the tail: that is amplitude estimation composed inside Grover maximum-finding, effectively quartic — anchor 5. Same circuits, same data, one level apart. MERIQ therefore scores the triple (question, algorithm, data model) — never a business domain, and never a technology. “Quantum for risk” is not a use case; it is a category containing use cases whose scores differ.

The data-basis row carries the second subtlety. Every probability in the model enters the circuit as a rotation angle, and a fault-tolerant machine has no arbitrary-angle gate: each rotation must be synthesised from the Clifford+T gate set, at a T-count that grows with the precision demanded — roughly 3·log₂(1/ε) T gates per rotation^[12] — and every T gate consumes a distilled magic state, the single most expensive commodity on a fault-tolerant machine. Demanding arbitrary resolution in the input probabilities would push that overhead to prohibitive levels. The practical consequence: the model’s probabilities must follow coarse, representable patterns, and the <200-qubit estimate assumes they do. That constraint is real, it is why the data basis scores 4 rather than 5, and expert-elicited risk parameters — which arrive at one or two significant figures anyway — happen to tolerate it unusually well.

The contrast: quantum machine learning for fraud detection

To show the rubric discriminates, we score a case from the same industry with a near-identical executive pitch: use a quantum computer to classify transactions and catch fraud. It reaches the scoring stage with a caveat the gate already flags — gradient-boosted ensembles are cheap and very good at this task, which is exactly the kind of classical shortcut the first question screens for. We score it anyway, because it is instructive to see where the points fall.

The arithmetic: 4 + 2 + 1 + 3 + 2 = 12 of 25 — 48/100, the 35–54 band, provisionally Level 2. The cap then does its work: data basis sits at 1, so the verdict is Level 1, Exploratory, and the horizon is undatable — what blocks this use case is not a machine on anyone’s roadmap but two open research problems, a rigorous advantage on natural data and a loading route that does not consume the speedup. Note what the rubric did not do: it did not punish the idea everywhere. The use case scores a full 4 on value — the same as our flagship — which is exactly the point. The forty-point gap and the two-level gap come entirely from advantage, data and resources: the three dimensions a pitch deck rarely mentions.

One reconciliation is owed here, because careful readers of the same literature will notice it. The SoftBank–Quantinuum timeline ranks fraud detection — international revenue-share fraud in telecoms — as its near-term use case.^[2] There is no contradiction: their route is topological data analysis, estimating Laplacian moments of structured k-partite graphs in a hybrid pipeline, with no amplitude-encoded training set anywhere in sight. Different question, different algorithm, different data model — a different triple, and it would earn a different scorecard, with the data-basis row transformed. The same business domain can contain a 48 and something considerably stronger. That is not the rubric contradicting itself; that is the rubric having resolution.

The question is not which use case is mature today — none are. The question is which blocker has a date.

Convergent logic

We were encouraged to find, in the SoftBank–Quantinuum white paper of July 2026, a differently shaped instrument built on the same load-bearing ideas.^[2] Their method publishes no scalar score; instead it estimates circuit-level resources for two domains — quantum chemistry and topological data analysis — and matches them against a four-generation hardware roadmap to answer when each workload becomes executable. But the components correspond almost one-to-one: their qualification filter is our gate; their per-domain problem-size metrics — spin orbitals, k-partite graph size — are our scaling axis; their implementation-driven stance, crediting only what can be compiled and run under realistic noise, is our feasibility criterion; their generation mapping is our production horizon, and they frame it exactly as we do — an assumption-driven envelope whose uncertainty grows with the horizon, not a forecast.

What MERIQ adds is the part their format deliberately avoids: fixed anchors and a scalar score that make use cases comparable across domains, and a cap that says in one number what binds. What their format adds is depth per domain — a full resource curve along the scaling axis rather than a single score. We read the convergence as evidence the axes are right, and the difference as a division of labour.

MIT’s FutureTech group has meanwhile turned the tortoise-and-hare framework into a public quantum-economic-advantage calculator: feed it the classical and quantum complexities of a problem, an error-correction overhead and a hardware roadmap, and it returns the crossover size and an estimated year at which the quantum route wins economically.^[5] That is, in effect, a computable instrument for two of MERIQ’s five dimensions — advantage and resources, evaluated along the scaling axis — and we apply the same logic qualitatively whenever we date a production horizon. What it deliberately does not ask is who owns the decision, whether the data can be loaded, or whether anyone has built the pipeline; that is what the other three criteria are for. Three instruments, built independently, keep landing on the same axes. We take the hint.

What we publish, and what we don’t

The model described in this article — the gate, the five criteria, the anchors, the bands, the weakest-link cap and the horizon logic — is published deliberately, so that our scores can be argued with rather than taken on authority. The instrument that makes the model repeatable is not published: the catalogue of sub-questions behind each criterion, the calibration weights we apply per engagement, and the benchmark library of past assessments that anchors new scores against old ones are proprietary to JoS QUANTUM GmbH, in internal use since the framework’s conception on 1 May 2026, and constitute a protected company asset.

That layer is also, in practice, our advisory work: MERIQ is the method behind the strategy advisory that decides which use cases to prioritise, and it is what our use-case development, hardware requirement estimation and technical due diligence engagements produce evidence for. The published layer lets you check our arithmetic; the proprietary layer is how the arithmetic gets its inputs.

Honest caveats

1. A rubric compresses judgment into integers. The scoring disciplines the analysis; it does not replace it. Two assessors with the same evidence should land within a point of each other — that is what the anchors are for — but the evidence still has to be gathered and argued.
2. The resource anchors are dated. They are calibrated to 2026 hardware and roadmaps, and a use case’s resource score has a time derivative. Horizons are envelopes, not forecasts: the executable frontier widens gradually, and there will be no single “advantage day”.
3. Equal weights are the published illustration. Engagement work uses calibrated weights, which move overall scores but never the cap — the weakest link binds under any weighting.
4. Two worked cases illustrate; they do not validate. A validation study needs a portfolio scored ex ante and checked ex post. That is whitepaper material.
5. We scored our own flagship with our own rubric. The anchors are published precisely so you can re-score it against us. If you land more than a point away on any criterion, we would genuinely like to hear the argument.