Choosing a quantum cloud platform in the UK is less about finding a permanent winner and more about matching hardware access, SDK compatibility, data location, cost controls and experiment goals. This guide provides a repeatable comparison method, a compatibility checklist, a hybrid-workload cost template and a migration workflow for moving from a simulator to cloud hardware without losing reproducibility.
Overview
A quantum cloud platform usually combines a software development environment with access to simulators and, directly or through a marketplace, quantum processing units (QPUs). The practical choice may involve IBM Quantum, Azure Quantum, Amazon Braket or a combination of services. The right option depends on the circuit you need to run, the SDK your team already uses, the location and sensitivity of your data, and the level of operational control required.
For a UK-based development or enterprise proof of concept, separate the decision into three questions:
- Can the platform run the workload? Check supported gates, connectivity, qubit count, measurement options, shot limits and any hardware-specific constraints.
- Can the team operate it reliably? Check authentication, access controls, job monitoring, quotas, audit requirements, regional routing and integration with existing tooling.
- Can the experiment be evaluated fairly? Compare simulator results, hardware results and a classical baseline using the same objective function, inputs and success criteria.
Do not treat a provider's largest advertised device as the most useful device for your project. A smaller processor with suitable connectivity, lower error for the relevant operations or a manageable queue may be more valuable than a larger but poorly matched option. Hardware specifications, prices, supported devices and queue conditions change, so the comparison below is deliberately structured around fields that should be checked before each project.
Provider comparison framework
| Platform | Typical role in a project | Hardware and access questions | SDK and workflow considerations | UK decision checks |
|---|---|---|---|---|
| IBM Quantum | Direct access to IBM's quantum services, simulators and associated development tooling. | Which processor families are available to your account? Record the current native qubit count, connectivity, calibration data, supported operations, noise indicators and queue conditions for the selected device. | Qiskit is the natural first check. Confirm the installed Qiskit and provider package versions, transpilation behaviour and whether your circuit uses backend-specific features. | Confirm account eligibility, data-handling terms, access region, job quotas, support route and whether results can be exported into your existing UK governance process. |
| Azure Quantum | A cloud entry point that can expose multiple quantum providers and integrate with Azure services. | Evaluate the specific target provider and device rather than Azure Quantum as one uniform hardware class. Record the selected backend's qubit count, connectivity, error information, queue expectations and availability. | Check the workflow used by your team, such as Qiskit, Cirq, PennyLane or provider-specific integrations. Verify version compatibility and how circuits are translated between abstractions. | Review the Azure region, identity model, billing scope, resource policies, logging, networking and any restrictions on sending data or job metadata outside an approved location. |
| Amazon Braket | A managed interface for simulators and access to selected quantum hardware providers through AWS services. | Assess each device separately. Capture the hardware type, native qubit count, connectivity, available operations, noise or calibration information, queue behaviour and device availability. | Braket SDK may be the orchestration layer, while PennyLane, Cirq or other tools may be used through adapters or circuit conversion. Test the exact SDK and plugin versions in a clean environment. | Check AWS region selection, IAM permissions, CloudTrail or equivalent audit needs, network controls, data retention, service quotas and the billing account responsible for simulator and QPU usage. |
The table is a decision worksheet, not a static ranking. For current native qubit counts, noise specifications, regional availability, queue times and pricing tiers, use the provider's current documentation and console immediately before procurement or experimentation. A useful record includes the date and time of every observation because queue and availability measurements can change during the day.
For background on the main platforms, see Quantum Cloud Platforms Compared: IBM Quantum, Azure Quantum and Amazon Braket. If the project involves supplier selection, pair this technical review with the quantum technology vendor due diligence checklist.
How to estimate
A useful estimate covers more than the price of a QPU submission. Hybrid quantum-classical workloads may include local development, simulator execution, compilation, cloud orchestration, QPU execution, repeated shots, result storage and engineering time. Build the estimate from measurable units rather than a single headline figure.
- Define the experiment. Record the number of circuits, circuit depth, qubit count, shots per circuit, optimisation iterations, parameter sweeps and expected reruns.
- Split local and cloud work. Identify which steps run on a developer machine, a cloud simulator, a managed classical service and a QPU. This prevents simulator usage and QPU usage being mixed into one unexplained total.
- Apply the provider's current billing units. Depending on the service, billing may be associated with tasks, shots, execution time, simulator resources, storage or other service-specific units. Use the provider's published pricing and account calculator rather than assuming that all platforms measure usage in the same way.
- Add operational overhead. Include failed submissions, calibration checks, test circuits, queue delays, result storage, monitoring and a controlled contingency. Keep the contingency visible instead of hiding it in a rounded total.
- Estimate value separately. Cost is not evidence of algorithmic benefit. Track accuracy, constraint satisfaction, runtime, repeatability and comparison with a classical baseline. The article on benchmarking quantum algorithms against classical methods provides a useful evaluation direction.
Quantum cloud cost-estimate template
Copy the following fields into a spreadsheet and fill them with the provider's current rates and your measured workload:
| Input | Value to record | Why it matters |
|---|---|---|
| Number of unique circuits | Count before and after parameter binding | Parameterized experiments can produce many submitted circuits even when the source code is short. |
| Shots per circuit | Planned shots and any validation reruns | Shot count affects statistical confidence and may affect usage charges. |
| Iterations or optimisation steps | Expected, minimum and maximum | VQE, QAOA and quantum machine learning workflows may submit circuits repeatedly. |
| Simulator usage | Runtime, machine size or task count, as applicable | Development can generate more simulator usage than final hardware runs. |
| QPU usage | Provider billing unit and current rate | Record the exact device and pricing tier rather than using a platform-wide average. |
| Storage and data transfer | Expected result volume and retention period | Large parameter sweeps and repeated measurement results create operational costs. |
| Engineering time | Setup, debugging, analysis and reporting hours | A low execution bill can still represent a costly experiment if the workflow is difficult to maintain. |
| Contingency | Separate percentage or fixed allowance | Allows for reruns caused by failed jobs, changed calibration or inconclusive results. |
A simple model is: total project estimate = simulator cost + QPU cost + orchestration and storage cost + engineering cost + contingency. Use a low, expected and high case. The high case should reflect additional optimisation iterations or reruns, not an arbitrary multiplier.
Inputs and assumptions
SDK compatibility checklist
Before choosing a platform, run the same small circuit through the tools your team expects to use. Record the result in a repository alongside a locked environment file.
- Qiskit: confirm the Qiskit version, provider integration, transpiler pass behaviour, backend naming and the handling of shots, measurements and runtime parameters.
- Cirq: confirm gate-set conversion, device topology representation, measurement ordering and the adapter used to reach the selected provider.
- PennyLane: confirm the device plugin, differentiation method, supported operations, gradient behaviour and whether the target hardware supports the circuit as written.
- Amazon Braket SDK: confirm task construction, device selection, result format, simulator choice and any conversion between Braket circuits and another SDK.
- Environment: pin Python and package versions, record operating-system assumptions, test authentication from a non-interactive environment and document required credentials without committing secrets.
- Reproducibility: save the source circuit, transpiled circuit, backend identifier, SDK versions, shot count, random seeds where supported and timestamp of submission.
Use a simulator as a correctness gate, not as proof that hardware will produce the same distribution. Noise, connectivity constraints, compilation choices and queue-time device conditions can change the result. Start with a circuit small enough to inspect manually, then compare ideal simulation, noisy simulation where available and hardware output.
UK and enterprise assumptions
For an enterprise proof of concept, ask where job metadata and results are processed, which identity provider controls access, how usage is logged and how data is deleted. Avoid sending commercially sensitive inputs until the provider's contractual and security review is complete. If the algorithm can operate on synthetic or reduced data, use that version for the first hardware experiment.
Also distinguish quantum workload data from post-quantum security planning. A cloud quantum experiment does not by itself address an organisation's exposure to future cryptographic risks. For that separate workstream, see the post-quantum readiness checklist for UK businesses.
Worked examples
Example 1: a small algorithm tutorial
Suppose a developer is validating a short circuit and needs a baseline, a noisy simulation and one hardware run. The estimate should list the number of unique circuits, shots for each circuit, simulator tasks, QPU tasks, storage and engineering time. The first run should use a fixed set of inputs and a modest shot count chosen for debugging. A second run can increase shots only if the initial output is stable enough to justify more measurement.
The decision is not simply “which platform is cheapest?” It is whether the chosen platform supports the SDK workflow, exposes enough information to diagnose errors and produces results that can be exported and reproduced. A short Qiskit tutorial or comparable SDK example should be converted into this test before a larger experiment.
Example 2: a hybrid optimisation proof of concept
For a QAOA or VQE-style workflow, estimate the number of optimiser iterations and circuits per iteration. If each iteration evaluates several parameterised circuits and includes validation measurements, the total submission count can grow quickly. Create low, expected and high cases for iteration count, then measure the classical optimiser separately from QPU execution.
Compare each platform using the same problem instances and stopping rule. Record objective value, constraint violations, number of submitted circuits, elapsed wall-clock time and total spend. A platform with a shorter queue may be preferable for iteration even if its individual execution unit has a different price. The conclusion should be based on the full workflow, not a single hardware specification.
Migration workflow: simulator to cloud hardware
- Freeze the problem definition, objective function and classical baseline.
- Validate the circuit on a local simulator with unit tests for measurements and qubit ordering.
- Run a noisy or constrained simulation where possible and identify sensitivity to depth, shots and connectivity.
- Select a target device using current documentation, not an old benchmark or cached device list.
- Transpile or compile the circuit and save both the original and transformed versions.
- Submit a small smoke test, check the result format and confirm that billing and logging behave as expected.
- Run the controlled experiment with a recorded shot count, backend identifier, SDK environment and submission timestamp.
- Repeat only when the reason is documented, such as statistical uncertainty, a failed job or a changed hardware condition.
- Compare hardware output with the simulator and classical baseline, then archive the cost and performance record.
When to recalculate
Revisit the comparison and cost estimate before every new proof of concept, not only when the provider changes its website. Recalculate immediately when pricing inputs, billing units, supported devices, SDK versions, adapters, noise information, queue behaviour or regional routing changes. Also recalculate after changing circuit depth, shot count, optimiser, parameter sweep size, data volume or success criteria.
For an evergreen operating process, schedule a quarterly review and an event-driven review after a major hardware or SDK release. During each review:
- refresh the provider comparison table and record the date of each observation;
- rerun the SDK compatibility smoke test in a clean environment;
- replace estimates with measured simulator and hardware usage where available;
- check account quotas, region, identity controls and data-handling assumptions;
- update the low, expected and high cost cases;
- reconfirm the classical baseline and the criteria for stopping the experiment.
Finally, keep a small decision log explaining why a platform was selected and what would cause that decision to change. This makes the next experiment faster, prevents outdated prices or device assumptions from being reused and gives procurement, security and engineering teams a common record. For SDK selection context, compare Qiskit, PennyLane and Cirq, then use the resulting compatibility checklist before committing to a cloud hardware run.