Choosing a quantum backend is a resource-planning decision, not simply a matter of selecting the device with the most qubits. This checklist helps you compare simulators and QPUs using circuit size, depth, connectivity, native gates, noise, queue time, shot requirements, supported features, and cost assumptions before you submit a job.
Overview
The right backend depends on what you need to learn from the circuit. A statevector simulator may be the most useful option for inspecting an ideal result or debugging a small circuit. A noisy simulator can reveal how an algorithm behaves under modeled imperfections. A real QPU becomes relevant when you need hardware measurements, device-specific behavior, or a comparison between ideal predictions and physical execution.
There is no universally best quantum backend. Instead, select the backend that satisfies the experiment's constraints with the least unnecessary risk. A useful first pass is to ask five questions:
- Does the backend provide enough usable qubits for the circuit?
- Can its connectivity and native gate set support the circuit without excessive transformation?
- Can it run the required shots, measurements, dynamic features, or noise model?
- Is the expected queue time and execution cost acceptable?
- What fallback will you use if the job cannot run or the result is inconclusive?
Separate correctness testing from hardware testing. Begin with an ideal or lightweight simulator to verify the circuit and expected measurement format. Move to a noise-aware simulator or QPU only after you understand what a successful result should look like. This reduces the chance of treating a programming error, compilation change, or measurement mistake as a hardware effect.
For circuit sizing, use the quantum circuit resource estimation guide alongside this checklist. If the circuit is already too deep or contains avoidable operations, review the quantum circuit optimization checklist before comparing backends.
How to estimate
Estimate backend fit in four stages: circuit demand, backend capability, execution burden, and fallback readiness.
1. Record circuit demand
Capture the maximum number of qubits, logical depth, two-qubit gate count, measurement locations, number of parameters, and planned shot count. Also record whether the circuit uses mid-circuit measurement, reset, conditional operations, a particular qubit layout, or a feature supported only by some execution targets.
A simple capacity check is:
usable qubits required ≤ backend qubits available
That inequality is necessary but not sufficient. A circuit may fit by qubit count and still be a poor match because its required interactions create many routing operations or because its depth is large relative to the device's noise characteristics.
2. Inspect backend properties
Before execution, inspect the provider's current documentation and backend metadata rather than relying on an old notebook or remembered specification. Look for qubit count, coupling or connectivity information, supported instructions, instruction durations where available, calibration or error indicators where exposed, shot limits, maximum circuit size, queue status, access requirements, and pricing terms.
For a simulator, inspect the simulation method and memory or workload limits. Statevector simulation generally becomes difficult as the number of qubits grows because the simulated state contains an amplitude for every basis state. Other methods may trade exactness for a more manageable workload, so confirm what approximation or noise assumptions apply.
3. Estimate execution burden
For paid or quota-limited services, treat cost as an estimate rather than a fixed constant. Define the variables that matter:
estimated workload = number of circuits × shots per circuit × repetitions
Then check how the provider counts usage. A service may distinguish between compilation, runtime, simulator time, QPU time, storage, or queue priority. If the pricing model is unclear or may change, record the source date and use a conservative budget ceiling before submitting.
Queue time is also an execution input. A backend that appears technically suitable may be unsuitable for an interactive debugging session if jobs are delayed. Keep a smaller simulator or alternate backend available for rapid iteration.
4. Decide using a constraint-first table
| Criterion | What to check | Why it matters |
|---|---|---|
| Simulator capacity | Qubit limit, method, memory, and noise support | Determines whether the circuit can be tested and what result is being modeled |
| QPU size | Available qubits after reserving or selecting a usable subset | Confirms basic feasibility |
| Connectivity | Whether required interactions are direct or need routing | Routing can increase gate count and depth |
| Native gates | Supported instructions and compiler transformations | Compilation may change the circuit you intended to run |
| Noise indicators | Error information, calibration context, and measurement behavior | Helps interpret differences from ideal results |
| Queue and limits | Waiting time, shot limits, circuit limits, and access rules | Determines whether the experiment is practical |
| Cost | Current usage model and your workload estimate | Prevents an avoidable or under-budgeted submission |
Inputs and assumptions
Create a backend worksheet before selecting a target. At minimum, include:
- Algorithm: the circuit or circuit family being tested.
- Logical requirements: qubits, depth, gate counts, measurements, parameters, and repetitions.
- Hardware requirements: connectivity, native instructions, supported control flow, and any required qubit roles.
- Evidence goal: debugging, ideal validation, noise sensitivity, hardware demonstration, or benchmark comparison.
- Acceptance rule: the result you will consider useful, such as a distribution within a defined tolerance or a successful completion without unsupported operations.
- Operational limits: budget, maximum wait, shot ceiling, and data-retention requirements.
- Fallback: a simulator, alternate QPU, reduced circuit, or smaller shot plan.
Make assumptions explicit. For example, “the circuit fits” might mean only that the qubit count fits, while a stronger assumption includes acceptable routed depth and a measurement plan that the backend supports. Likewise, “the result is comparable” should specify whether you are comparing raw counts, normalized probabilities, expectation values, or a derived application metric.
Keep software compatibility in the same worksheet. SDK versions, transpiler behavior, provider interfaces, and backend identifiers can change independently of hardware. Use the quantum Python environment setup guide when a Qiskit project must be reproduced later.
Worked examples
Example 1: Debugging a small variational circuit
Suppose a parameterized circuit uses a small number of qubits, shallow layers, and ordinary measurements. The goal is to verify parameter binding and measurement logic, not to study physical noise. Start with an ideal simulator, use enough shots to expose obvious distribution errors, and save the circuit, parameters, SDK version, and result. A QPU adds queue and noise variables without answering the immediate debugging question. After the simulator result is stable, run a reduced hardware test only if device behavior is part of the next question.
Example 2: Comparing an algorithm with an ideal prediction
Here, use two stages. First, run the circuit on an ideal simulator to establish a reference distribution. Next, choose a noise-aware simulator or QPU that supports the circuit's measurements and execution features. Compare like with like: use the same logical circuit definition, shot plan where practical, and post-processing. Record compilation output because the executed hardware circuit may contain additional routing or basis-conversion operations.
Example 3: A circuit that fits by qubit count but not by practical depth
Assume a circuit needs fewer qubits than a candidate QPU provides, but its important qubit pairs are poorly connected. The compiler may insert routing operations, increasing depth and two-qubit gates. In this case, choose a layout-aware alternative, simplify the circuit, or select a device with more suitable connectivity. Do not call the backend a fit solely because the qubit count passes. The relevant test is whether the compiled circuit remains within your error and runtime assumptions.
For unexpected results, follow a staged workflow from the Qiskit quantum circuit debugging guide. If hardware noise is the intended subject, use the quantum error mitigation decision guide to separate mitigation choices from backend selection.
When to recalculate
Revisit the selection before every meaningful experiment, not only when a job fails. Recalculate when the circuit gains qubits, depth, measurements, parameters, or shots; when compilation changes the instruction count; when a provider changes backend availability, access rules, limits, queue interfaces, or pricing; or when a benchmark, calibration indicator, or noise assumption moves enough to affect interpretation.
Use this five-minute preflight checklist:
- Export or inspect the current circuit requirements.
- Query the backend's current capabilities and limits.
- Compile or transpile a representative circuit and review its depth, gates, and layout.
- Estimate shots, repetitions, wait time, and cost using current assumptions.
- Confirm the fallback and write down the acceptance rule before submission.
Finally, save a backend record with the execution date, backend identifier, software versions, circuit hash or source revision, compiled resource counts, shot plan, and observed result. This turns backend selection into a repeatable engineering process rather than a one-time guess. Repeating the record whenever inputs change makes later comparisons more defensible and gives you a clear reason to update the experiment when providers, benchmarks, or rates change.