We study how to evaluate hybrid quantum programs as end-to-end workflows rather than as isolated devices or algorithms. Building on the Hybrid Quantum Program Evaluation Framework (HQPEF), we formalize a workflow-aware Quantum Readiness Level (QRL) score; define a normalized speedup under quality constraints for the Utility of Quantumness (UQ); and provide a timing-and-drift audit for hybrid pipelines. We complement these definitions with concise Python reference implementations that illustrate how to instantiate the metrics and audit procedures with state-of-the-art classical and quantum solvers (e.g., via Qiskit or PennyLane), while preserving matched-budget discipline and reproducibility.
We study how to evaluate hybrid quantum programs as end-to-end workflows rather than as isolated devices or algorithms. Building on the Hybrid Quantum Program Evaluation Framework (HQPEF), we formalize a workflow-aware Quantum Readiness Level (QRL) score; define a normalized speedup under quality constraints for the Utility of Quantumness (UQ); and provide a timing-and-drift audit for hybrid pipelines. We complement these definitions with concise Python reference implementations that illustrate how to instantiate the metrics and audit procedures with state-of-the-art classical and quantum solvers (e.g., via Qiskit or PennyLane), while preserving matched-budget discipline and reproducibility.
Quantum computing is quickly becoming a potentially disruptive technology that can tackle the problems inaccessible to classical computers, but the use of quantum computing in real software systems has yet to be fully explored. Present day quantum studies are largely focused on the development of algorithms and hardware, whereas engineering workflows to be used to enable smooth hybrid quantum-classical operations attract limited attention. The paper suggests a concept of quantum-ready software engineering- a systematic approach to applying established principles of software engineering to hybrid systems. In order to meet maintainability, scalability, and reliability objectives in hybrid applications, propose the adoption of a multilayered design, such as abstraction, integration, orchestration, and verification. An example concrete programming template, written in Python in Qiskit, demonstrates how quantum functions being used as modular services can be simulated with classical software. Evaluation measures (maintainability index, latency, and modularity) demonstrate the feasibility of the framework. Results indicate that the hybrid pipelines can be designed in a systematic way using quantum-classical-adapted design patterns. The study introduces a repeatable methodology, program templates, and design pattern engineering principles, which open the door to additional development of quantum DevOps and design pattern formalization. This project, by bridging the gap between classical software engineering and quantum integration, gives a platform upon which to build extraordinarily reliable, scalable systems in the Noisy Intermediate-Scale Quantum and beyond.
Quantum optimisation is emerging as a promising approach alongside classical heuristics and specialised hardware, yet its performance is often difficult to assess fairly. Traditional benchmarking methods, rooted in digital complexity theory, do not directly capture the continuous dynamics, probabilistic outcomes, and workflow overheads of quantum and hybrid systems. This paper proposes principles and protocols for fair benchmarking of quantum optimisation, emphasising end-to-end workflows, transparency in tuning and reporting, problem diversity, and avoidance of speculative claims. By extending lessons from classical benchmarking and incorporating application-driven and energy-aware metrics, we outline a framework that enables practitioners to evaluate quantum methods responsibly, ensuring reproducibility, comparability, and trust in reported results.
Evaluating the performance of quantum devices is an important step towards scaling quantum devices and eventually using them in practice. The great number of available quantum metrics and the different hardware technologies used to develop quantum computers complicate this evaluation. In addition, different computational paradigms implement quantum operations in different ways. A prominent quantum metric is given by the Q-score metric of Atos. This metric was originally introduced as a standalone way to benchmark devices using the Max-Cut problem. In this work, we show that the Q-score defines a framework of quantum metrics, which allows benchmarking using different problems, user settings and solvers. To showcase the applicability of the framework, we showcase a second Q-score in this framework, called the Q-score Max-Clique. This yields, to our knowledge, the first application-level metric capable of natively comparing three different paradigms of quantum computing. This metric is evaluated on these computational quantum paradigms – quantum annealing, gate-based quantum computing, and photonic quantum computing – and the results are compared to those obtained by classical solvers.
Commercially available Noisy Intermediate-Scale Quantum (NISQ) devices now make small hybrid quantum-classical experiments practical, but many tools hide configuration or demand ad-hoc scripting.
We introduce the Quantum Experiment Framework (QEF): A lightweight framework designed to support the systematic, hypothesis-driven study of quantum algorithms. Unlike many existing approaches, QEF emphasises iterative, exploratory analysis of evolving experimental strategies rather than exhaustive empirical evaluation of fixed algorithms using predefined quality metrics. The framework's design is informed by a comprehensive review of the literature, identifying principal parameters and measurement practices currently reported in the field.
QEF captures all key aspects of quantum software and algorithm experiments through a concise specification that expands into a Cartesian product of variants for controlled large-scale parameter sweeps. This design enables rigorous and systematic evaluation, as well as precise reproducibility. Large sweeps are automatically partitioned into asynchronous jobs across simulators or cloud hardware, and ascertain full hyper-parameter traceability. QEF supports parameter reuse to improve overall experiment runtimes, and collects all metrics and metadata into a form that can be conveniently explored with standard statistical and visualisation software.
By combining reproducibility and scalability while avoiding the complexities of full workflow engines, QEF seeks to lower the practical barriers to empirical research on quantum algorithms, whether these are designed for current NISQ devices or future error-corrected quantum systems.
As quantum computing (QC) matures towards practical applications, effective methods to evaluate quantum algorithms, circuits, and execution quality in quantum software are gaining more relevance. To apply such methods, a set of meaningful metrics must be defined, understood, calculated, and applied. In an effort to solve that problem, this paper categorizes quantum related metrics into pre-runtime (derived from the static analysis of circuits before execution) and post-runtime (derived from the analysis of execution results). It is worthwhile to mention that while popular quantum SDKs such as Qiskit, PennyLane, and Q\# offer some circuit characteristics, there is often a gap between these native capabilities and the broader set of insightful pre- and post-runtime metrics in the literature. This paper introducesqWard, a Python library developed to bridge this gap by offering an initial implementation for the Qiskit SDK. qWard provides a toolkit designed to compute and visualize key pre-runtime and post-runtime metrics, facilitating the analysis of quantum algorithms. To illustrate its application, an experiment using a bell state circuit is conducted, which includes different backend configurations within the simulator as well as its execution on the IBM “torino” quantum processor. It is important to note that the initial version of qWard is limited to the Qiskit SDK and the Qiskit AER simulator.
Variational Quantum Algorithms and dynamic circuits are hybrid programs that interleave quantum operations with classical control flow, mid-circuit measurement, typed classical data, and parameter binding. Building such programs by hand is demanding, requiring expertise in quantum mechanics, circuit design, and a quantum SDK, so low-code platforms have been proposed to capture them as graphical models that a pipeline transforms into code. The pipeline this thesis builds on emits OpenQASM 3, but that representation becomes useful only once a mainstream SDK can execute it. The obstacle is layered. An SDK’s circuit representation holds a subset of OpenQASM 3, and its documented importer parses a smaller subset still. For these hybrid programs the importer cannot ingest the typed classical declarations and expressions they carry, even where the SDK’s own representation can hold them. This thesis closes that gap with a structure-preserving export step that lowers the pipeline’s OpenQASM 3 into executable SDK code, building the target’s representation directly rather than routing through its importer. A complementary backend extension carries structured loops into that representation rather than unrolling them, which matters for loops driven by measurement. The exporter is provider-based and aims to be SDK-independent. Qiskit is the realized target, chosen because its representation can hold the hybrid structure these programs need, and a second, proof-of-concept provider reaches Amazon Braket. Per-construct, end-to-end, and scenario tests confirm that supported models compile to executable Qiskit programs, with structured classical control flow, typed classical data, and symbolic parameters preserved at circuit level.