Running a quantum circuit on real hardware requires more than selecting a backend and pressing submit. This quantum hardware experiment checklist helps you verify device suitability, connectivity, native gates, calibration context, noise expectations, shots, queue constraints, measurement design, and classical comparisons before execution, so each hardware job produces results you can interpret and reproduce.
Overview
A circuit that behaves well in a simulator may perform very differently on a real quantum computer. Physical qubits are noisy, connectivity is limited, gate sets vary by device, calibration data changes over time, and cloud access may introduce queue or job-size constraints. A useful pre-run process therefore treats hardware execution as an experiment rather than a simple software deployment.
The goal is not to eliminate every source of uncertainty. It is to identify the variables that could affect the result, record them before submission, and decide whether the selected backend is suitable for the question you are asking. This is especially important when comparing hardware runs with an ideal simulator, a noisy simulator, or a classical algorithm.
Before starting, define the claim you want to test. For example, you may be checking whether a circuit produces the expected distribution, comparing two transpilation strategies, measuring the effect of circuit depth, or evaluating whether a small algorithm remains useful under noise. The claim determines what must be measured and which baseline is appropriate.
For related preparation, see Quantum Circuit Resource Estimation: How to Calculate Qubits, Depth, Gates, and Shots and How to Optimise Quantum Circuits: Gate Simplification, Transpilation, and Benchmarking.
What to track
1. Backend suitability and access
Confirm that the backend supports the features your experiment needs. Check the available number of qubits, supported measurement operations, mid-circuit measurement or reset requirements if applicable, and any restrictions imposed by the provider or software framework. Do not assume that every listed device accepts the same circuit model.
Record the provider, backend name or identifier, software framework and version, account or access configuration, and submission date. Interfaces and backend naming conventions can change, so preserving this information makes a later comparison more meaningful.
2. Qubit mapping and connectivity
Inspect how logical qubits map to physical qubits. A circuit with many two-qubit operations may require additional routing operations if the selected physical qubits are not directly connected. Those extra operations increase depth and can change the experiment more than the algorithm itself.
Record the selected physical qubits, coupling or connectivity information, the logical-to-physical mapping, and the number of routing operations introduced during transpilation. If the software chooses the mapping automatically, save the transpiled circuit or its summary rather than relying on the original source circuit alone.
3. Native gates and transpilation
Real hardware executes a native gate set, not necessarily the gates used in your high-level circuit. Transpilation converts the circuit into operations supported by the backend and may alter gate count, depth, measurement placement, and qubit assignment.
Compare the original and transpiled circuits. Track total depth, single-qubit gates, two-qubit gates, routing operations, barriers if relevant, and the final measurement layout. A short circuit at the source level is not automatically a short circuit on hardware. Keep the transpiler settings, optimisation level, and any seed or deterministic configuration used for the run.
If you need to investigate unexpected output, the transpiled circuit is usually the version that deserves attention. The guide to How to Debug Quantum Circuits: A Step-by-Step Workflow for Measurement and Simulation Errors provides a useful companion workflow.
4. Calibration and device condition
Calibration data provides context for a hardware result. Depending on the platform, the available information may include estimated readout error, gate error, relaxation or coherence-related values, and calibration timestamps. Terminology and visibility vary, so record the labels supplied by the platform rather than translating them into a supposedly universal score.
Check whether the calibration snapshot was taken before submission, during a relevant period, or at another time. A result collected under one device condition should not be compared casually with a result collected under a substantially different condition. Calibration values are indicators, not a guarantee of circuit-level performance.
5. Noise expectations
Decide in advance which noise effects could matter. Common considerations include errors from two-qubit operations, readout mistakes, accumulated error in deep circuits, and changes in performance across the selected qubits. Avoid describing a hardware result as a failure solely because it differs from an ideal distribution; the experiment may be demonstrating the effect of noise.
Run an ideal simulation where practical, and consider a noise-aware simulation if the available model is appropriate for your purpose. These references do not replace hardware data, but they help distinguish an implementation error from an expected degradation pattern.
6. Shots, measurements, and controls
Choose the number of shots according to the result you need. More shots reduce sampling uncertainty in estimated probabilities, but they do not remove systematic hardware errors. Record the shot count, measurement basis, measured qubits, classical bit order, post-processing rules, and whether any results were filtered or corrected.
Use controls that expose simple problems. A small basis-state circuit can check measurement ordering and readout behaviour. A circuit with a known ideal outcome can provide a sanity check. If the experiment compares two circuits, run them under comparable shot settings and execution conditions where possible.
For interpretation of counts, probabilities, and uncertainty, see How to Interpret Quantum Measurement Results: Counts, Probabilities, Shot Noise, and Error Bars.
7. Queue and execution constraints
Before submitting, check practical limits such as maximum circuit size, permitted shot counts, batching rules, job expiry, authentication requirements, and queue behaviour. These details are provider- and interface-dependent, so verify them in the current documentation or console rather than relying on an old workflow.
Save the job identifier, submission time, completion time when available, and any execution or transpilation warnings. If a job is delayed, cancelled, retried, or split into multiple submissions, record that fact because it may affect comparisons.
8. A classical baseline
A quantum result needs a reference point. Select the baseline before running the hardware experiment. Depending on the task, this could be an exact classical calculation for a small instance, a brute-force enumeration, a heuristic, an ideal quantum simulation, or a noisy simulation.
State what the baseline measures and what it does not measure. For example, an ideal simulator can test circuit logic but does not establish an advantage over a classical method. A classical approximation may be more relevant for a practical problem but may not reproduce the same probability distribution. Keep input data, tolerances, and evaluation metrics consistent.
Cadence and checkpoints
Use the following checkpoints for every hardware experiment:
- Before coding: define the question, success metric, circuit family, expected output, and classical or simulation baseline.
- Before transpilation: confirm required qubits, gates, measurements, resets, and circuit limits.
- After transpilation: inspect the physical mapping, native operations, depth, two-qubit gate count, and routing overhead.
- Before submission: review calibration context, device availability, shot count, measurement order, queue constraints, and access settings.
- After completion: save raw counts, metadata, warnings, job identifiers, circuit representations, and post-processing code.
- After analysis: compare with the chosen baseline, quantify uncertainty where possible, and note whether the conclusion depends on a particular device condition.
For recurring projects, review the checklist monthly or quarterly. A monthly review is useful when a team runs hardware jobs frequently or depends on an actively changing software interface. A quarterly review is usually a reasonable minimum for educational repositories, internal documentation, and experiments that run less often. Recheck sooner when a provider changes backend specifications, calibration terminology, access requirements, transpiler behaviour, or circuit submission rules.
Keep a small experiment log rather than updating only the final report. A table with one row per run can include date, backend, physical qubits, circuit depth, two-qubit gate count, shots, calibration snapshot, queue notes, baseline, and headline result.
How to interpret changes
When two hardware runs differ, change one category at a time where possible. First compare the circuit actually executed, not only the source code. Then compare physical-qubit selection, calibration context, shot count, measurement processing, and queue timing.
A worse result after a backend change does not necessarily mean the algorithm has regressed. The new mapping may contain more routing operations, the selected qubits may have different error characteristics, or the measurement convention may have changed. Conversely, a visually improved result with more shots may reflect lower sampling noise rather than better hardware performance.
Separate three types of variation:
- Sampling variation: changes caused by drawing a finite number of shots.
- Implementation variation: changes caused by transpilation, mapping, gate decomposition, or measurement handling.
- Hardware variation: changes associated with device condition, calibration, and physical noise.
Do not report a single hardware score without the conditions behind it. A concise result should state the backend, circuit version, mapping, shots, relevant calibration context, baseline, and interpretation limits. This makes the work easier to reproduce and more useful to someone choosing a backend for a later experiment.
When to revisit
Revisit this quantum hardware experiment checklist immediately before each new hardware job, even if the circuit has run successfully before. At minimum, update the record when the backend, physical qubits, framework, transpiler settings, circuit depth, shot count, or measurement design changes.
Use a scheduled monthly or quarterly review to confirm that your project documentation still matches the current provider interface and backend information. Mark older results with their execution date and avoid treating them as timeless measurements of a device. If a result is important, rerun a small control circuit and the main experiment under the new conditions before drawing a direct comparison.
A practical experiment brief can use this template:
- Question: What specific claim is being tested?
- Circuit: What is the input, expected ideal output, and measurement basis?
- Backend: Which provider and backend are being used, and why?
- Mapping: Which physical qubits are selected, and how many routing operations are added?
- Execution: What are the native gates, depth, shot count, queue notes, and job identifier?
- Calibration: Which device metrics and timestamps were available?
- Baseline: What classical, ideal, or noisy reference will be used?
- Result: Which raw files, counts, plots, warnings, and conclusions were saved?
- Next review: When will the backend details and workflow be checked again?
For a broader learning plan, visit A Practical Quantum Computing Learning Path for Beginners. The checklist becomes most valuable when it is attached to every job submission and used to build a consistent record of what changed, what stayed constant, and what the hardware result can genuinely support.