Running a quantum circuit on real hardware is less about writing a new algorithm than about preparing, compiling, submitting, and validating an experiment under practical constraints. This guide presents a repeatable workflow for moving a circuit from a local simulator to IBM Quantum, Azure Quantum, or Amazon Braket, while estimating shots, execution cost, queue time, and result quality without relying on platform-specific promises that may change.
Overview
A simulator is the right place to check syntax, test circuit logic, and build a baseline. Real quantum hardware adds effects that a basic ideal simulator does not reproduce: limited connectivity, gate noise, readout error, calibration drift, compilation overhead, queue delays, and provider-specific execution rules. The first hardware run should therefore be treated as a controlled experiment, not simply a faster version of local development.
The broad workflow is similar across the three platforms:
- Create an account and confirm the access, billing, workspace, or project requirements for the selected platform.
- Install the required SDK or connector and authenticate locally through the provider’s current method.
- Run the circuit on an ideal simulator, then on a noise-aware or provider-compatible simulator when available.
- Select a real device or provider backend that supports the circuit’s gates, qubit count, and connectivity needs.
- Transpile or compile the circuit for that target, inspect the resulting depth and two-qubit gate count, and submit a small test job.
- Collect results, compare them with the simulator baseline, and record the backend, compilation settings, shots, and submission date.
IBM Quantum is commonly approached through Qiskit and IBM-managed backends. Azure Quantum provides a workspace and provider-oriented model, so the available targets and SDK path depend on the selected provider. Amazon Braket uses AWS account and region concepts and supports provider-specific devices through its own programming interface. Names, access rules, pricing, and authentication flows can change; use each platform’s current documentation before treating this article as an operational checklist.
For a broader discussion of access, queues, costs, and results, see How to Run Quantum Circuits on Real Hardware: Access, Costs, Queues, and Results. If you are still deciding which programming layer to use, compare Qiskit, PennyLane, and Cirq before committing your project to one workflow.
How to estimate
Estimate a hardware experiment in four separate quantities: circuit workload, shot workload, paid execution, and elapsed time. Keeping them separate prevents a common mistake—assuming that a small circuit is automatically a cheap or quick experiment.
1. Count the submitted circuits
Start with the number of distinct circuits that will be executed. A single logical circuit may become several circuits after measurement-group expansion, parameter binding, error-mitigation steps, or comparison experiments.
Total circuit submissions = logical circuits × parameter settings × measurement variants × control variants
For example, a variational experiment with 12 parameter settings and two measurement variants represents 24 submitted circuit instances before repeats are added.
2. Choose shots deliberately
Shots are repeated measurements of the same circuit. More shots reduce ordinary sampling uncertainty, but they do not automatically remove hardware noise or systematic readout bias. Begin with a small pilot run, inspect whether the outcome distribution is stable enough for your question, and increase the shot count only when the decision depends on finer differences.
Total shots = submitted circuit instances × shots per circuit
When comparing two circuits, give them comparable shot budgets. Otherwise, an apparent performance difference may reflect measurement precision rather than the circuits themselves.
3. Separate provider charges from your own compute
Do not assume that every platform uses the same billing unit. Depending on the provider and target, relevant inputs may include shots, tasks or jobs, execution time, device type, simulator usage, storage, workspace resources, and classical orchestration. Represent the estimate symbolically until you verify current prices:
Estimated total = hardware execution charge + simulator charge + classical cloud charge + storage or network charge
If a platform offers a no-charge access path, confirm its limits and eligibility rather than assuming that all devices, queues, or workloads are included. A free development path may still require an account, a workspace, a payment method, or a separate provider relationship.
4. Estimate elapsed time separately
Elapsed time includes local preparation, compilation, queue waiting, device execution, result retrieval, and analysis. A rough planning model is:
Elapsed time = setup + compilation + queue wait + execution + retrieval and analysis
Queue time is the least predictable component. Treat published queue indicators as operational guidance rather than a guarantee, and avoid scheduling a deadline-sensitive experiment around one submission.
Inputs and assumptions
Before submitting, record the inputs that make the result reproducible. A useful experiment sheet should include:
- Algorithm: the circuit purpose, qubit count, measured observables, and expected output.
- Software: SDK name and version, Python version, transpiler or compiler settings, and source-code revision.
- Target: provider, backend or device, region or workspace where relevant, and whether the target is a simulator or real hardware.
- Compilation: optimization level, initial layout, routing method, final circuit depth, and one- and two-qubit gate counts.
- Sampling: shots per circuit, random seeds where supported, parameter settings, and the number of repeated jobs.
- Operations: submission time, queue observations, job identifiers, cancellation policy, and any cost ceiling.
- Validation: ideal-simulator output, noise-aware baseline if available, calibration context, and the metric used for comparison.
A small circuit can still become expensive or difficult to interpret if it is submitted hundreds of times. Conversely, a larger circuit may be useful as a one-time diagnostic if the objective is to study compilation or noise. Define the question first: are you validating functionality, measuring sampling behavior, comparing devices, or testing an algorithmic signal?
Use a simulator as a gate-level and output baseline, not as proof that hardware should produce the same distribution. For simulator guidance, see Quantum Simulator Comparison: Qiskit Aer vs Cirq vs PennyLane and Quantum Circuit Simulators vs Real Hardware.
Worked examples
Example 1: A Bell-state sanity check
Suppose a two-qubit Bell circuit is measured in one basis with 1,000 shots. The workload is one circuit instance and 1,000 total shots. Run it first on an ideal simulator, then submit the same compiled circuit to a selected device. The useful comparison is not whether every shot matches the ideal output; it is whether the dominant outcomes, unexpected outcomes, and approximate proportions are consistent with the experiment’s purpose.
If you repeat the test on three devices, the workload becomes three circuit instances and 3,000 total shots. Add a second measurement basis and the workload becomes six circuit instances and 6,000 total shots. This simple accounting prevents underestimating a comparison study.
Example 2: A parameter sweep
Assume a four-qubit circuit is evaluated at 20 parameter settings, with 2,000 shots per setting. The initial plan contains 20 circuit instances and 40,000 shots. If each setting is also evaluated with a control circuit, the count becomes 40 instances and 80,000 shots. If the provider charges per task rather than only per shot, the number of grouped jobs and submission behavior also becomes an important input.
A practical approach is to submit five settings first. Check compilation output, result formatting, queue behavior, and whether the measured signal is distinguishable from the simulator baseline. Only then expand to all 20 settings. This staged approach limits wasted execution while preserving a clear path to the full experiment.
Example 3: Choosing among platforms
For a Qiskit-based project, IBM Quantum may be the most direct path when the required target and access method fit your project. Azure Quantum may be useful when your organization already manages cloud workspaces or wants to evaluate multiple connected providers through one environment. Amazon Braket may fit a workflow built around AWS identities, regions, and provider-specific devices. These are workflow considerations, not permanent rankings. Compare the current SDK support, target availability, authentication requirements, pricing unit, data-handling rules, and queue behavior for your exact experiment.
When to recalculate
Recalculate the plan whenever an input changes—not only when a provider changes its pricing. Revisit it when you alter the device, qubit layout, compiler settings, optimization level, shot count, number of parameter settings, measurement bases, mitigation method, or job grouping. A circuit that was inexpensive in a simulator may require substantially more hardware submissions after measurement expansion or parameter binding.
Check the provider’s current documentation before each new project cycle for account requirements, available targets, supported SDK versions, billing units, and access terms. Also recalculate after an SDK upgrade: compiler defaults and result formats can change enough to affect depth, runtime, or downstream analysis.
Before pressing submit, use this short action list:
- Run the circuit locally and save the baseline output.
- Count circuit instances, shots, repeats, and measurement variants.
- Compile for the intended target and record depth and two-qubit gate count.
- Confirm authentication, budget limits, region or workspace settings, and cancellation options.
- Submit a small pilot before launching the full workload.
- Save job identifiers, raw results, metadata, and the exact software environment.
- Compare hardware results with both the ideal baseline and the experiment’s stated success metric.
Real quantum hardware access becomes manageable when every run has a defined question, a bounded workload, and a recorded baseline. That discipline matters more than choosing a platform by reputation, and it makes your results easier to reproduce when prices, queues, devices, and SDKs change.