Quantum hardware results are only meaningful when you understand the noise behind them. This practical checklist explains how to measure and interpret T1, T2, readout error, single-qubit error, two-qubit error, and drift before trusting a hardware experiment, with guidance for recording calibration conditions and uncertainty across changing quantum platforms.
Overview
Quantum noise characterization is the process of measuring how a device departs from ideal quantum behavior. It is not a single number and it is not a one-time task. Relaxation, dephasing, imperfect measurement, control errors, crosstalk, thermal conditions, and calibration changes can all affect a circuit in different ways.
The most useful characterization workflow connects each measurement to a decision. T1 and T2 help determine whether a circuit fits within the device's coherence window. Readout error indicates how much confidence to place in measured bitstrings. Single- and two-qubit error estimates help identify whether a circuit's gate count and connectivity are realistic. Drift tells you whether a result collected today can be compared fairly with one collected later.
Provider dashboards and SDK APIs may expose some of these values as backend properties or calibration fields, while other measurements require you to submit circuits. Field names, units, fitting conventions, and benchmark implementations can change, so treat provider metadata as useful context rather than a substitute for recording your own experimental conditions. For broader device comparisons, see our quantum hardware benchmarking checklist.
Core measurements at a glance
| Measurement | What it describes | Typical method | Why it matters |
|---|---|---|---|
| T1 | Energy-relaxation time from the excited state toward the ground state | Prepare |1⟩, wait for different delays, then measure | Sets a time scale for idle periods and circuit duration |
| T2 | Loss of phase coherence | Ramsey or echo sequence followed by a fit | Indicates sensitivity to dephasing and timing |
| Readout error | Probability of reporting the wrong classical state | Prepare known basis states and compare measured counts | Affects every final bitstring and mitigation model |
| Single-qubit error | Imperfect implementation of one-qubit operations | Gate-specific calibration or randomized benchmarking | Shows whether repeated local operations remain reliable |
| Two-qubit error | Imperfect entangling operations, including interaction effects | Pair-specific benchmarking or provider characterization | Often constrains circuit layout, depth, and algorithm choice |
| Drift | Change in measured behavior over time or operating conditions | Repeat sentinel circuits and compare timestamps | Determines whether results remain comparable |
These quantities are related but not interchangeable. A qubit with a long T1 may still have poor readout, and a strong average gate metric may conceal a problem with one particular gate, pair, frequency range, or circuit schedule.
Checklist by scenario
Before a first hardware run
- Define the question. Decide whether you need a quick suitability check, a publication-quality characterization, a comparison between platforms, or a regression test after a software or calibration change.
- Record the target backend and qubits. Save the provider, backend identifier, qubit indices, coupling pair, SDK version, transpiler settings, basis gates, and circuit compilation date.
- Capture available metadata. Export the calibration snapshot or backend properties, including T1, T2, readout-related fields, gate error estimates, gate durations, and timestamps when available. Do not assume a field's name or definition is identical across providers.
- Check circuit timing. Estimate idle time, gate duration, measurement duration, depth, and the number of two-qubit operations. A circuit that looks small by gate count can still be long in wall-clock execution time.
- Prepare controls. Include an ideal simulator result, a simple basis-state circuit, and at least one circuit that exercises the intended gate family or qubit pair.
Transpilation can change the operations you actually run. Review the final circuit rather than characterizing only the source program; layout, routing, scheduling, and inserted operations can materially alter exposure to noise. The quantum circuit transpilation guide provides a useful review framework.
When measuring T1 and T2
- Choose a delay range. Use delays that cover the expected decay rather than clustering all points near zero. Include enough points to distinguish a fast decay from a flat response.
- Use repeated shots at each delay. The result at one delay is an estimate with sampling uncertainty, not an exact probability.
- Fit the data explicitly. A basic T1 experiment measures excited-state population versus delay and commonly uses an exponential-decay model. A Ramsey-style T2 experiment measures oscillating contrast with a decaying envelope. State the model, fit window, and any weighting used.
- Repeat selected points. Repeating short, middle, and long delays helps identify unstable runs or a changing baseline.
- Compare T2 with T1 carefully. T2 is affected by both energy relaxation and dephasing, so it should not be interpreted as a second measurement of T1. Echo-based coherence measurements also answer a different question from a free-induction or Ramsey sequence.
When measuring readout error
- Prepare each measured qubit in a known computational-basis state, such as |0⟩ and |1⟩.
- Collect enough shots to estimate the conditional probabilities of reporting 0 or 1 for each prepared state.
- Build a confusion matrix for one qubit, or a joint assignment model when correlated readout is relevant.
- Repeat the basis-state circuits at the same time as the main experiment if the result is especially sensitive to measurement error.
- Separate assignment error from state-preparation error where the experimental design permits it. A preparation circuit can introduce gate errors before measurement.
Readout mitigation can improve estimates, but it does not make the underlying measurement noiseless. For practical mitigation choices, compare this characterization step with the guide to readout mitigation and other error-mitigation techniques.
When measuring gate error
- Start with the relevant operations. Characterize the single-qubit gates and entangling gates that appear after transpilation, not just the gates in the original algorithm.
- Use a suitable benchmark. Provider-reported error estimates, cycle benchmarking, randomized benchmarking, interleaved benchmarking, and direct process checks answer different questions. Label the method rather than presenting all values as equivalent fidelities.
- Test the actual pair. Two-qubit error is generally pair-specific. Record direction, coupling relationship, gate variant, pulse or scheduling options when exposed, and the surrounding circuit context.
- Include identity or idle controls. These help distinguish gate-induced error from decoherence accumulated during a sequence.
- Report uncertainty and fit quality. A point estimate without shots, repetitions, fit residuals, confidence intervals, or a stated uncertainty method is difficult to compare.
When checking drift
Run a small sentinel suite at the beginning and end of a session. Useful sentinels include basis-state readout circuits, a short coherence experiment, a shallow single-qubit circuit, and a representative two-qubit circuit. Keep their qubit mapping, shot count, compilation settings, and scheduling fixed. Compare distributions and fitted values, not only a single success percentage. If the sentinel changes, annotate the main result and avoid treating it as a clean software regression.
What to double-check
- Units: Confirm whether delays and gate durations are expressed in seconds, nanoseconds, or backend-specific time units.
- Definitions: Determine whether an error field is a measured estimate, a model output, an average over gates, or a provider calibration value.
- Timestamp: Record when metadata was retrieved and when circuits were queued and executed. Queue time can separate calibration inspection from measurement.
- Compilation: Save the transpiled circuit, physical qubit mapping, optimization level, and any routing decisions.
- Shots and seeds: Record shot counts and relevant simulator, sampler, transpiler, or randomized benchmark seeds.
- Uncertainty: Include binomial or bootstrap intervals for proportions where appropriate, and report fit uncertainty for T1 and T2.
- Correlation: Check whether errors may be correlated across qubits, repetitions, measurement channels, or neighboring gates.
- Reproducibility: Store raw counts, processed data, notebook or script version, environment details, and analysis parameters. See the reproducible quantum experiments checklist.
When comparing providers or SDKs, normalize the question before normalizing the number. A reported two-qubit error from one benchmark should not automatically be compared with a calibration field produced by another method. If you port a circuit between frameworks, rerun characterization because compilation and native gate decomposition can change the hardware workload.
Common mistakes
- Using a dashboard value as a permanent property. Calibration values describe a device under a particular operating condition and time window.
- Measuring only T1 and T2. Coherence does not capture readout assignment errors, control imperfections, crosstalk, or entangling-gate behavior.
- Calling every benchmark a fidelity measurement. Fidelity depends on the definition, state or process being tested, averaging procedure, and error model.
- Ignoring the final compiled circuit. Hidden swaps, basis changes, decompositions, and idle periods can dominate the noise budget.
- Fitting too few points. A visually plausible curve can produce an unstable time constant if the delay range or shot count is inadequate.
- Overcorrecting noisy data. Mitigation can reduce bias while increasing variance or producing physically implausible estimates. Always retain raw counts.
- Comparing results from different sessions without drift checks. A changed calibration state may explain a difference that has nothing to do with the algorithm.
When to revisit
Revisit your characterization before each important hardware experiment, after a backend or calibration change, when the SDK or transpiler changes, and whenever the circuit's qubit mapping, native gate set, depth, or scheduling changes. It is also worth repeating the suite when a result differs unexpectedly from an earlier run.
For routine work, maintain a compact baseline: the latest metadata snapshot, T1 and T2 estimates for selected qubits, readout confusion data, relevant single- and two-qubit benchmark results, sentinel-circuit counts, and an uncertainty record. Compare new measurements with that baseline using the same analysis code and a clearly labeled timestamp.
Before you submit the next run: export current backend metadata; inspect the final transpiled circuit; verify units and qubit mapping; run basis-state, coherence, and gate sentinels; record shots, seeds, timestamps, and queue conditions; save raw counts; and note whether any result is provider-reported or independently measured. This small routine turns quantum noise characterization from a one-off diagnostic into a dependable part of quantum programming and hardware evaluation.