Quantum Resource Estimation Worksheet: Calculate Qubits, Circuit Depth, Shots, and Execution Cost
resource estimationqubitscircuit depthshotsruntimecloud execution

Quantum Resource Estimation Worksheet: Calculate Qubits, Circuit Depth, Shots, and Execution Cost

SSmart Qubit Editorial Team
2026-11-14
7 min read

A practical worksheet for estimating quantum circuit qubits, depth, shots, simulator memory, runtime, and cloud execution cost.

Before selecting a simulator, reserving hardware time, or approving a quantum cloud budget, estimate what the circuit will require. This worksheet shows how to record qubits, gates, depth, shots, batching, memory, runtime, and execution cost, then validate the estimate with a small pilot job.

Overview

Quantum resource estimation is a planning exercise, not a promise of exact performance. A circuit’s requirements can change after transpilation, when a provider maps it to a particular device, or when queueing, calibration, and execution policies introduce additional overhead. The goal is therefore to produce a transparent estimate with known assumptions and a practical margin.

Use the worksheet to answer five questions:

  • How many logical qubits does the algorithm require?
  • How many physical qubits or simulator resources may be needed?
  • What gate count and circuit depth will be executed after compilation?
  • How many shots, batches, and repeated jobs are required?
  • What runtime, memory, and cloud cost should be budgeted?

Keep three versions of the circuit separate: the algorithmic circuit written by the developer, the transpiled circuit adapted to a target backend, and the executed workload that includes shots, repetitions, parameter sweeps, mitigation, and retries. Estimating only the first version commonly understates the real workload.

This approach applies to variational algorithms, quantum machine learning experiments, sampling workloads, benchmarking, and smaller enterprise pilots. It also works across SDKs and providers because the inputs are expressed as circuit and job characteristics rather than provider-specific promises.

How to estimate

1. Define the workload boundary

Write down exactly what the estimate covers. A single circuit execution is different from a training experiment with hundreds of parameter updates. State whether the estimate includes compilation, queue time, warm-up runs, calibration, error mitigation, retries, post-processing, and classical optimization.

For a hybrid workflow, calculate the complete loop:

Total circuit executions = circuits per iteration × iterations × parameter settings × repetitions

Add any validation, test, and baseline runs separately. This prevents a small production circuit from being mistaken for a small experiment.

2. Record logical qubits and measurements

Start with the highest number of qubits used simultaneously by the logical circuit. Record the number of classical bits and measurement groups as well. If the workflow uses ancillas, include them even when they are not part of the final output.

For a fault-tolerant design, distinguish logical qubits from physical qubits. A simple planning model is:

Estimated physical qubits = logical data qubits × physical-qubit overhead per logical qubit + ancillary overhead

The overhead is highly dependent on the error-correction design, target error rate, hardware assumptions, and compiler. Treat it as a scenario input rather than a universal conversion factor.

3. Compile for the target backend

Measure the circuit before and after transpilation. Record total gates, two-qubit gates, maximum depth, depth by gate type, and any inserted swaps or basis-change operations. For hardware planning, post-transpilation figures are usually more useful because connectivity constraints can increase both gate count and depth.

Compare at least two compilation settings when optimization choices are important. A more aggressive optimization may reduce depth but require additional compile time or produce a circuit that is harder to compare with an earlier experiment. Save the SDK version, compiler settings, target backend, and circuit identifier with each estimate.

4. Convert shots into executions

Shots are repeated measurements of a circuit. If one circuit is submitted with S shots and the experiment contains N distinct circuits, the basic measurement workload is:

Total shots = S × N

For parameterized workloads, N includes every parameter binding that must be evaluated. If error mitigation evaluates several noise-scaled versions, multiply by the number of scaled circuits. If a provider groups compatible circuits into a batch, batching may reduce submission overhead, but it does not necessarily reduce the number of circuit executions.

5. Estimate runtime and cost separately

Use a simple decomposition rather than one optimistic number:

Elapsed time ≈ submission overhead + queue time + compilation time + execution time + result processing

When the provider bills by a measurable unit, model cost from that unit. A generic estimate is:

Estimated cost = billable execution units × unit price + fixed service or storage charges

Do not assume that circuit depth alone determines the billable unit. Depending on the platform, relevant inputs may include shots, task count, processor time, simulator size, execution duration, or a combination of these. Enter the current pricing value manually in the worksheet and label its source date.

Inputs and assumptions

Use the following table as the minimum worksheet. Add columns for low, expected, and high cases when the result will influence a budget or delivery commitment.

InputWhat to recordWhy it matters
Logical qubitsPeak qubits used, including ancillasDefines algorithm size and memory requirements
Physical-qubit assumptionDevice capacity or logical-to-physical scenarioSeparates near-term execution from fault-tolerant planning
Gate countTotal gates, especially two-qubit gatesHelps assess compilation work and noise exposure
Circuit depthTotal depth and critical two-qubit depthProvides a rough execution and fidelity planning signal
ShotsShots per circuit and confidence targetDrives measurement workload and often cost
Number of circuitsParameter bindings, observables, and repetitionsDetermines the size of the complete job
BatchingCircuits per submission and submission countSeparates task overhead from circuit executions
Simulator memoryState representation, qubit count, and precisionMemory can grow rapidly with qubit count for state-vector simulation
Runtime inputsCompile, queue, execution, and post-processing estimatesCreates a realistic elapsed-time range
Pricing inputsCurrent billable unit, rate, and fixed chargesTurns resource estimates into a budget

For state-vector simulation, a rough memory model is proportional to 2^n complex amplitudes for n qubits. The exact requirement depends on numeric precision, simulator implementation, saved intermediate data, parallelization, and operating-system overhead. Use the simulator’s documented limits or a controlled benchmark before committing a large run.

For noisy simulation, density-matrix or trajectory methods may have different scaling behavior. Do not use a state-vector estimate as a universal simulator comparison. Record the simulation method, precision, noise model, and whether intermediate states or probabilities are saved.

For hardware, include assumptions about connectivity, native gates, measurement duration, reset behavior, calibration state, and queue conditions. These variables can change the practical runtime even when the source circuit is unchanged.

Worked examples

Example 1: A single hardware pilot

Assume a circuit uses 12 logical qubits, has 180 gates before compilation, and is evaluated with 2,000 shots. After transpilation, it uses 260 gates, including 96 two-qubit gates, and reaches a depth of 74. The pilot contains four distinct circuits for four parameter settings.

The basic measurement workload is:

2,000 shots × 4 circuits = 8,000 circuit shots

The worksheet should budget for four compiled circuits, not one source circuit. It should also preserve the post-transpilation count of 260 gates and depth of 74 as the hardware planning values. If the team repeats the pilot three times to compare calibration windows or compiler settings, the workload becomes 24,000 shots before adding retries or mitigation.

Example 2: A variational training loop

Assume an optimizer runs 50 iterations. Each iteration evaluates 30 parameter points, and each point requires six observable circuits at 1,000 shots. The total number of circuit executions is:

50 × 30 × 6 = 9,000 circuit executions

The shot count is:

9,000 × 1,000 = 9,000,000 shots

This estimate changes if the implementation groups observables, reuses measurements, uses a gradient method with extra evaluations, or adds error mitigation. The correct next step is not to debate the final number in the abstract; it is to run a small representative slice, such as several iterations with the same transpilation settings and measurement structure.

Example 3: Comparing an optimization

Suppose an earlier circuit has a post-transpilation depth of 110 and 140 two-qubit gates. An optimized version has depth 82 and 100 two-qubit gates but requires an additional measurement grouping step. Compare both versions using the same shots, parameter settings, backend, and result-quality checks.

Record whether the optimization changes the number of distinct circuits or only the gates within each circuit. A lower depth is useful only if it does not introduce a larger shot requirement, additional repetitions, or a quality loss that forces more sampling. Resource estimation should therefore include an outcome metric, such as estimator variance, classification performance, or agreement with a trusted classical baseline.

When to recalculate

Recalculate the worksheet whenever any input that affects execution changes. In practice, revisit it in these situations:

  • The circuit changes: New qubits, ansatz layers, observables, encoding methods, or measurements alter the workload.
  • Transpilation changes: A new SDK version, compiler setting, basis gate set, coupling map, or optimization level can change gate count and depth.
  • The backend changes: Capacity, native operations, queue behavior, calibration conditions, and execution limits may differ across targets.
  • Shots or precision targets change: More confidence, mitigation, or repeated trials can multiply executions.
  • The workflow expands: Training, hyperparameter searches, cross-validation, sweeps, and retries often dominate the original circuit cost.
  • Pricing or billing inputs change: Refresh the rate, billable unit, minimum charge, storage treatment, and any fixed service assumptions before approving spend.
  • Benchmarks disagree with the model: Replace guessed compile, execution, or memory values with measurements from a representative pilot.

For a practical review cycle, export the circuit, transpile it for each candidate target, and save a machine-readable record containing qubits, gates, depth, shots, circuit count, compiler settings, SDK version, backend identifier, and pricing-input date. Run a small pilot that mirrors the production workload, compare observed execution and memory behavior with the worksheet, then update the low, expected, and high cases.

Finally, link the estimate to the experiment or deployment decision. A resource worksheet is most useful when it answers a concrete question: which backend can run this workload within the available memory, time, quality target, and budget? Recalculate after every meaningful change, and treat the resulting range as a decision aid rather than a guaranteed quote.

Related Topics

#resource estimation#qubits#circuit depth#shots#runtime#cloud execution
S

Smart Qubit Editorial Team

Quantum Computing Editors

Senior editor and content strategist. Writing about technology, design, and the future of digital media. Follow along for deep dives into the industry's moving parts.