Your first real-device experiment is easier to manage when you treat it as a readiness and estimation exercise rather than simply submitting a circuit. This checklist helps you confirm access, choose a suitable backend, estimate execution resources, anticipate queue behavior, and prepare for noisy results before you run on quantum hardware.
Overview
A simulator can validate much of your code, but a real quantum computer adds constraints that are easy to overlook. Your circuit must fit the device's available qubits, connectivity, supported gates, execution rules, and current service limits. The hardware also introduces measurement noise, gate errors, readout errors, and variation between runs.
Use this article as a preflight checklist for a first hardware experiment. It is deliberately provider-neutral because access workflows, backend names, pricing models, job limits, and calibration data can change. Confirm the current details in the documentation for the quantum cloud provider or hardware provider you plan to use.
A useful first experiment has a narrow objective. Examples include measuring a prepared one- or two-qubit state, comparing simulator and hardware distributions, testing a small variational circuit, or observing how a circuit's output changes as depth increases. A small, interpretable experiment is usually more useful than a large circuit whose errors you cannot diagnose.
For background on software choices, compare the available quantum SDKs and frameworks before committing to a provider-specific workflow. You can also review quantum cloud providers and hardware architectures when selecting an execution target.
How to estimate
Estimate a hardware run in four stages: eligibility, circuit resources, sampling resources, and operational overhead.
- Confirm eligibility. Create an account or use your organization's existing account, accept any required terms, and verify that your project or workspace can access a real-device backend. Check whether credentials use an API key, token, cloud role, or another mechanism. Store credentials securely rather than placing them directly in notebooks or source repositories.
- Measure the circuit. Record the number of logical qubits, circuit depth, two-qubit gate count, measurement operations, and any mid-circuit operations. Do this after compiling or transpiling if possible, because the hardware sees the compiled circuit rather than the abstract circuit you originally wrote.
- Estimate sampling demand. A shot is one circuit execution used to build an outcome distribution. If you submit one circuit with S shots, your basic sampling workload is S. If you submit C circuit variants, the workload is approximately C × S. Include repetitions created by parameter sweeps, calibration experiments, control circuits, or error-mitigation methods.
- Add operational overhead. Account for compilation, validation, retries, polling, queue time, and result storage. These may not be billed in the same way as hardware shots, but they affect the time and resources required to complete the experiment.
Before submitting, run the exact circuit through the provider's compiler or transpiler. Check the resulting qubit mapping, inserted routing operations, gate basis, depth, and measurements. A circuit that is short in an SDK can become substantially longer when its interactions must be routed across limited qubit connectivity.
For debugging, use a local simulator and inspect the compiled circuit first. The quantum circuit testing and debugging tools directory can help you identify validators, visualizers, and profilers suitable for this stage.
Inputs and assumptions
Write down the following inputs before choosing a backend. Keeping them in a small experiment log makes the decision repeatable.
- Account and permissions: Confirm the project, workspace, region, service access, authentication method, and allowed API operations.
- Backend status: Check whether the device is available, accepting jobs, under maintenance, or restricted to particular users or plans.
- Qubit count: Record the logical qubits required and leave room for ancillas only if the algorithm needs them.
- Connectivity: Compare the circuit's interaction graph with the device's coupling map. Poor alignment can add swap operations and increase depth.
- Gate support: Identify the hardware's native or accepted gate set. Unsupported gates will be decomposed during compilation.
- Calibration information: Review the provider's available indicators for qubit quality, readout behavior, gate performance, and calibration recency. Treat these as selection inputs, not guarantees of a particular result.
- Shots and repetitions: Define the minimum number of shots needed to distinguish the outcomes you care about. Separate exploratory runs from final measurement runs.
- Pricing inputs: If the provider charges for execution, record the current unit used for billing, such as shots, circuit executions, runtime, or a plan allowance. Do not assume that one provider's unit maps directly to another's.
- Result format: Confirm whether results return as counts, probabilities, bit strings, expectation values, samples, or provider-specific objects. Plan how you will save metadata alongside the result.
- Error strategy: Decide in advance whether you will use raw results only, repeated runs, measurement-error correction, zero-noise extrapolation, or another supported method. Error mitigation can require extra circuits and therefore extra execution resources.
A simple workload estimate is:
Total circuit executions = number of circuit variants × shots per variant × mitigation or repeat factor.
This is an estimate, not a universal billing formula. Use the provider's current documentation to translate the workload into cost or quota usage. When uncertain, start with a small shot count and a single backend test job.
Worked examples
Example 1: One circuit, raw measurements. Suppose a Bell-state experiment contains one circuit and you plan to collect S shots. The estimated workload is S circuit executions. Before submission, verify that the two selected physical qubits are connected or that the compiler can route the interaction without creating an unexpectedly deep circuit. Compare the hardware counts with the ideal simulator distribution, but do not expect identical results.
Example 2: Parameter sweep. Suppose a circuit is evaluated at P parameter values, with S shots for each value. The basic workload is P × S. If compilation produces multiple circuit variants for each parameter value, use the actual submitted circuit count instead of assuming that a parameterized job is treated as one execution. Save the parameter value with every result so that queue retries or partial completion do not make the data ambiguous.
Example 3: A comparison with mitigation. Suppose you submit one target circuit, one control circuit, and an additional set of circuits for an error-mitigation procedure. If there are M total circuit variants and each receives S shots, the baseline estimate is M × S. Add any provider-required repetitions or retry policy to the estimate. This is why mitigation should be introduced only after the raw experiment is understood.
For each example, retain the abstract circuit, compiled circuit, backend identifier, qubit mapping, shot count, submission timestamp, software version, and result object. These details make a noisy outcome diagnosable and allow you to repeat the experiment after a calibration or software change.
When to recalculate
Recalculate your estimate before every hardware run if any input has changed. In particular, revisit it when the provider changes pricing or quota units, backend names or availability, job-size limits, authentication flow, compiler defaults, supported gates, connectivity information, calibration reporting, or error-mitigation options. Also recalculate after changing qubit count, circuit depth, parameter count, shot count, or result-processing methods.
A practical refresh routine is:
- Re-run the circuit locally and record the ideal expectation or distribution.
- Compile for the currently selected backend.
- Inspect mapping, depth, gate counts, and measurements.
- Check backend status and the latest available calibration information.
- Recompute total circuit executions and the provider-specific cost or quota estimate.
- Submit a small validation job before the full run.
- Compare raw hardware output with the simulator and document deviations.
Keep a dated run log rather than relying on memory. Hardware access conditions are moving inputs, so an experiment that was affordable, accepted, or interpretable previously may require a different backend or smaller workload later. For broader platform decisions, consult the quantum computer evaluation guide and the quantum computing learning path. The goal of this checklist is not to eliminate noise or uncertainty; it is to make both visible before you spend execution time on a real device.