Operations Patterns for Hybrid Quantum Applications

Martin Beisel

, Johanna Barzen

, Frank Leymann

and Benjamin Weder

Institute of Architecture of Application Systems, University of Stuttgart, Germany

{lastname}@iaas.uni-stuttgart.de

Keywords:

Quantum Computing, Pattern Languages, Hybrid Quantum Applications, Operations.

Abstract:

With the rapidly improving capabilities of today’s quantum devices, the development of high-quality quantum

applications, that can be utilized to solve practically relevant problems, becomes necessary. Quantum

software engineering is an emerging paradigm aiming to improve the quality, reusability, and maintainability

of quantum applications. However, while various concepts have been presented for developing and operating

quantum applications, there is a lack of structured documentation supporting developers and operations

personnel in applying the best practices. To facilitate the development of quantum applications, a pattern lan-

guage for the quantum computing domain has been introduced. It documents proven solutions to commonly

recurring problems during the quantum software development lifecycle in an abstract manner. However, it does

not contain patterns for the operations of hybrid quantum applications. To bridge this gap, in this work, we in-

troduce novel patterns focusing on packaging, testing, executing, and observing hybrid quantum applications.

1 INTRODUCTION

Quantum software engineering is an emerging

paradigm in research and industry (Piattini et al.,

2021; Zhao, 2020). Its goal is to improve the quality

of quantum applications and to promote principles,

such as reusability, maintainability, or separation of

concerns (Weder et al., 2022). Thereby, it comprises

concepts for the (i) development of quantum appli-

cations, as well as their (ii) operation and adaptation

based on changing requirements or user feedback.

In classical software engineering, an established

approach for documenting solutions to recurring

problems in a structured manner is patterns (Alexan-

der et al., 1977). Patterns ease the understanding of

problems and the factors that make them difﬁcult

to solve. To overcome these problems, patterns

abstractly describe proven solutions, enabling users

to transfer them to their use case at hand. Multiple

patterns of the same domain can be combined in

a so-called pattern language (Alexander et al., 1977).

To support quantum software engineers in devel-

oping quantum applications, the quantum comput-

ing pattern language has been introduced by Ley-

mann (Leymann, 2019). It contains various patterns

https://orcid.org/0000-0003-2617-751X

https://orcid.org/0000-0001-8397-7973

https://orcid.org/0000-0002-9123-259X

https://orcid.org/0000-0002-6761-6243

tackling different problem areas, e.g., the encoding

of classical data for quantum devices (Weigold et al.,

2021a). While there are already patterns providing de-

sign concepts for the development of quantum appli-

cations, there are no patterns documenting best prac-

tices for successfully operating and managing them.

To bridge this gap, we extend the quantum com-

puting pattern language by introducing ﬁve novel pat-

terns for the operation and management of quantum

applications. These patterns cover various phases of

the operations lifecycle of quantum applications. This

includes proven solution strategies for: (i) The holis-

tic testing of quantum applications and (ii) their self-

contained packaging including all relevant software

artifacts. Furthermore, (iii) the selection of a suitable

quantum device to successfully execute a given quan-

tum circuit. Another pattern shows (iv) how to ease

the execution of quantum circuits across various het-

erogeneous quantum cloud offerings. Finally, (v) con-

cepts for monitoring and analyzing quantum applica-

tions in heterogeneous environments are documented.

The remainder of the paper is structured as fol-

lows: In Section 2, fundamentals and the pattern for-

mat used for authoring the patterns are presented. Sec-

tion 3 gives an overview of the quantum comput-

ing pattern language and then introduces our opera-

tions patterns in detail. Section 4 discusses the pre-

sented operations patterns. Finally, Section 5 presents

related work, and Section 6 concludes the paper.

Beisel, M., Barzen, J., Leymann, F. and Weder, B.

Operations Patterns for Hybrid Quantum Applications.

DOI: 10.5220/0013246900003950

Paper published under CC license (CC BY-NC-ND 4.0)

In Proceedings of the 15th International Conference on Cloud Computing and Services Science (CLOSER 2025), pages 26-36

ISBN: 978-989-758-747-4; ISSN: 2184-5042

2 FUNDAMENTALS

In this section, the fundamentals of hybrid quantum

applications as well as the utilized pattern format and

the employed pattern authoring process are discussed.

2.1 Hybrid Quantum Applications

While quantum devices promise computational ad-

vantages for various problems, e.g., in machine learn-

ing (DeBenedictis, 2018) or chemistry (Cao et al.,

2018), they are unsuitable for many traditional tasks,

e.g., visualizing data (Preskill, 2018). Thus, quantum

devices are typically used in hybrid quantum applica-

tions to solve speciﬁc problems efﬁciently (Leymann

and Barzen, 2020). These hybrid applications com-

prise classical programs as well as quantum circuits

that are executed on a quantum device. To execute a

quantum circuit, it must be sent to a quantum cloud

offering that provides access to quantum devices via

an API. However, due to the heterogeneity of quan-

tum cloud offerings and quantum devices, e.g., in the

supported circuit format, a quantum circuit can not be

executed on arbitrary quantum devices.

2.2 Pattern Format

Patterns are well-structured documents describing so-

lutions to commonly recurring problems (Alexander

et al., 1977). Each pattern is identiﬁed by its name and

a mnemonic icon. To clarify which problem is tackled

by a pattern, each pattern comprises a brief problem

statement. The problem statement is followed by a de-

scription of the context in which the problem occurs

and the forces that complicate solving it. The solution

section of a pattern presents a strategy for solving the

previously described problem and a corresponding so-

lution sketch. Subsequently, the results paragraph dis-

cusses the consequences of applying the solution. In

the related patterns section, connections to other pat-

terns within the same pattern language are discussed.

Finally, real-world use cases and implementations of

the pattern are showcased in the known uses section.

The patterns presented in this work were system-

atically identiﬁed using the pattern authoring method

introduced by Fehling et al. (2014a). In the pattern

identiﬁcation phase, we analyzed state-of-the-art ap-

proaches in the literature and best practices promoted

by different quantum cloud providers and quantum

SDKs. All relevant information about the operation of

quantum applications is then identiﬁed by interpret-

ing the collected data. Finally, the pattern format is

deﬁned to ﬁt the domain, and the patterns are written

and iteratively reﬁned in the pattern authoring phase.

3 OPERATIONS PATTERNS

In the following, we ﬁrst give an overview of the

quantum computing pattern language initiated by

Leymann (2019). Subsequently, we document ﬁve

novel patterns covering different aspects of the opera-

tion and management of hybrid quantum applications.

3.1 Quantum Computing Pattern

Language Overview

Figure 1 provides an overview of the quantum com-

puting pattern language. It comprises the existing pat-

terns for designing and implementing hybrid quantum

applications, as well as the newly introduced patterns

for quantum application operation and management.

The patterns are categorized based on the as-

pects of the quantum application lifecycle they ad-

dress (Weder et al., 2022): The program ﬂow pat-

terns (Weigold et al., 2021b) show how computa-

tions can be split between quantum and classical hard-

ware. To improve the performance of quantum al-

gorithms, the warm-starting category (Truger et al.,

2024) comprises patterns describing different tech-

niques for, e.g., approximating an initial solution

or pre-computing parameters for optimization prob-

lems. The data encodings patterns (Weigold et al.,

2021a) summarize various state preparation routines

to encode classical data into a quantum circuit. The

limited capabilities of today’s quantum devices hin-

der the successful execution of large quantum cir-

cuits (Preskill, 2018). To reduce the size of quan-

tum circuits, circuit cutting can be applied, and dif-

ferent techniques are described in the eponymous cat-

egory (Bechtold et al., 2023). The quantum states pat-

terns (Leymann, 2019) document how to create fun-

damental quantum states, utilized as a basis for vari-

ous quantum algorithms. Another approach to reduce

noise on today’s quantum devices is error handling,

e.g., by mitigating results based on the approximated

error model of the used quantum device (Beisel et al.,

2022). Quantum circuits can be executed in different

ways, e.g., using queues or prioritized access, and the

corresponding concepts are summarized by the pat-

terns in the execution category (Georg et al., 2023).

The unitary transformation patterns document typ-

ical subroutines that are used in different quantum

algorithms. Complementary to the patterns for op-

erating quantum applications introduced in this pa-

per, the development patterns (B

uhler et al., 2023)

describe best practices for developing high-quality

quantum applications. Finally, the measurement pat-

terns (Weigold et al., 2021a) summarize approaches

for extracting classical data from quantum devices.

Operations Patterns for Hybrid Quantum Applications

Biased

Initial

State









New

Error

Correction

Gate Error

Mitigation

Readout

Error

Mitigation

Existing Patterns

Circuit

Cutting

Gate

Cut

Variational

Parameter

Transfer

Pre-Trained

Feature

Extractor

...

Measurement

Post-selective

Measurement

Warm -Starting

Uniform

Superposition

Creating

Entanglement

Amplitude

Amplification

...

Unitary Transformations

QRAM

Encoding



QRAM

Schmidt

Decom-

position

...

Quantum-

Classic Split

QAOA

Quantum

Module

Template

Hybrid

Module

Quantum

Module

Development

Classical-

Quantum

Interface

Orchestrated

Execution

Pre-

deployed

Execution

Prioritized

Execution

...

Execution

Quantum

Circuit

Translator

Error Handling

Circuit Cutting

Wire

Cut

Quantum States

Data Encodings

Program Flow

Operations

Quantum

Application

Archive

Quantum

Hardware

Selection

Quantum

Application

Testing

Unified

Observability

Unified

Execution

Figure 1: Overview of the quantum computing pattern language with some existing (light gray) and new patterns (dark gray).

In this work, we introduce patterns documenting

abstract solutions for operating and managing hybrid

quantum applications. The newly added Operations

category in Figure 1 comprises ﬁve novel patterns:

The QUANTUM APPLICATION ARCHIVE pattern fo-

cuses on the self-contained packaging of hybrid quan-

tum applications including all required artifacts, such

as quantum circuits and classical programs. To cope

with the plethora of heterogeneous quantum devices,

the QUANTUM HARDWARE SELECTION pattern

shows how to select a suitable quantum device for the

execution of a given quantum circuit. Thereby, char-

acteristics of the quantum circuit, as well as the quan-

tum devices and the corresponding quantum cloud of-

ferings are taken into account. The execution across

various heterogeneous quantum cloud offerings is

covered by the UNIFIED EXECUTION pattern, which

automatically translates required input and output for-

mats. Thus, users can utilize their preferred program-

ming language or SDK to implement quantum circuits

and still use any desired quantum cloud offering with-

out additional effort. To verify the correct function-

ality of hybrid quantum applications, the QUANTUM

APPLICATION TESTING pattern describes a holistic

testing strategy including all relevant artifacts. Fi-

nally, the UNIFIED OBSERVABILITY pattern focuses

on the monitoring and analysis of hybrid quantum

applications. It describes concepts for ensuring re-

producibility and understandability while abstracting

from the heterogeneity of quantum cloud offerings.

3.2 Quantum Application Archive

Problem: How to store, version, and

distribute the various heterogeneous ar-

tifacts of a hybrid quantum application?

Context: Hybrid quantum applications comprise a

wide variety of artifacts, e.g., classical programs,

quantum circuits, deployment models, and speciﬁca-

tions of the control and data ﬂow (Weder et al., 2022).

The execution of hybrid quantum applications in a tar-

get environment requires the availability of these ar-

tifacts. For a stable execution in production environ-

ments, the application must be versioned and all de-

pendencies must be ﬁxed (Altmanninger et al., 2009).

Forces: Software in the quantum computing domain

is frequently updated (Vietz et al., 2021; Weder et al.,

2021b). This often leads to incompatibility when up-

grading different parts of the application. Further,

identifying all required artifacts and transferring them

into a target environment is time-consuming, com-

plex, and error-prone. Distributing and selling hybrid

quantum applications, e.g., via a marketplace, typi-

cally requires them to be available as a single entity.

Solution: To enable the storage, versioning, and dis-

tribution of hybrid quantum applications, package all

required artifacts in a self-contained quantum appli-

cation archive as shown in Figure 2. Thereby, ensure

that all artifacts have a ﬁxed version to prevent incom-

patibilities through future updates. The quantum ap-

CLOSER 2025 - 15th International Conference on Cloud Computing and Services Science

V1.2.0

Classical

Programs

Quantum

Circuits

Control- and Dataflow

Specifications

Deployment

Models

Version

Definition

: V1.1.1

: V0.3.2

: V2.6.3

…

Figure 2: Solution sketch for the QUANTUM APPLICATION

ARCHIVE pattern, comprising all relevant artifacts.

plication archive must comprise all artifacts required

to set up the execution environment of the application

and to subsequently execute it in this environment.

Result: By packaging quantum applications utilizing

a quantum application archive, all classical and quan-

tum artifacts required for execution can be shared as

a single entity. Since the archive does not only con-

tain the executable programs but also comprises all

the necessary data for setting up the execution envi-

ronment, it can be executed independently of the ex-

ecution environment installed by the user. Due to the

holistic versioning of the artifacts of the quantum ap-

plication archive, incompatibilities are prevented.

Related Patterns: Hybrid quantum algorithms within

a quantum application archive are commonly real-

ized by the HYBRID MODULE pattern (B

uhler et al.,

2023). To deploy and execute the packaged quantum

application, the PRE-DEPLOYED EXECUTION pat-

tern (Georg et al., 2023) can be utilized. The QUAN-

TUM APPLICATION TESTING pattern should be ap-

plied when packaging a hybrid quantum application

to verify the correct behavior of all contained artifacts.

Known Uses: Weder et al. (2021b) introduce a con-

cept for the self-contained packaging of hybrid quan-

tum applications. Different development lifecycles for

hybrid quantum applications have been presented that

include the packaging of the application as an essen-

tial phase (Gheorghe-Pop et al., 2020; Weder et al.,

2022). Leymann et al. (2019) describe a platform

for distributing quantum applications, which enables

users to package and sell their quantum applications.

3.3 Uniﬁed Execution

Problem: How to execute a quantum

circuit independently of the heteroge-

neous quantum cloud offerings and their

supported quantum circuit formats?

Context: Quantum circuits should be executed using

a suitable quantum cloud offering. The circuits might

be implemented utilizing different SDKs, such as

Unification Middleware

A B

Translator

Figure 3: Solution sketch for the UNIFIED EXECUTION pat-

tern, automatically translating quantum circuits.

Qiskit and Braket, quantum programming languages,

such as Q#, or quantum assembler, such as Open-

QASM (Leymann et al., 2020; Vietz et al., 2021).

Forces: When an SDK is used to implement quantum

circuits, they can only be executed utilizing a quantum

cloud offering supported by the respective SDK. If, on

the other hand, a quantum programming language or

a quantum assembler is used, the quantum cloud of-

fering for the execution must support this technology.

This often leads to a vendor lock-in, which prevents

users from ﬂexibly switching to a different quantum

cloud offering that provides, e.g., cheaper access.

Solution: Unify the execution of quantum circuits by

utilizing a middleware providing a single, uniﬁed in-

terface for accessing different quantum cloud offer-

ings. Figure 3 gives an overview of the conceptual

structure of the uniﬁcation middleware. This middle-

ware uses a set of translators that automatically trans-

late the given quantum circuit for the target quan-

tum device if the format of the circuit is not natively

supported. Since accessing quantum devices requires

users to authenticate themselves, an access token is

required for each quantum cloud offering. They can

either (i) be provided with each execution request or

(ii) the middleware can store the tokens of each user.

Alternatively, (iii) the middleware provides access to

all quantum devices via a separate pricing model, fa-

cilitating the execution for users as they do not require

an access token for each quantum cloud offering.

Result: The quantum circuit can be executed via a

single interface independently of the circuit format

and quantum cloud offering. Thus, vendor lock-ins

can be avoided and circuits can be executed using dif-

ferent quantum cloud offerings without any additional

effort. However, the uniﬁcation middleware does not

automatically select a suitable quantum device but

only supports the execution on the target device.

Related Patterns: The QUANTUM CIRCUIT TRANS-

LATOR pattern (B

uhler et al., 2023) is utilized by

the uniﬁcation middleware to translate quantum cir-

cuits that use data formats incompatible with the tar-

get quantum device. To select a suitable quantum de-

Operations Patterns for Hybrid Quantum Applications

Quantum Device

Data Retrieval

Circuit

Analysis

Width:

Depth:

#Gates:

…

Available

Quantum Devices

Quantum Device

Characteristics

Quantum Circuit

Characteristics

Suitability

Ranking

Cloud Offering

Data Retrieval

Final Device

Selection

Quantum Cloud

Offerings

Quantum Cloud

Offerings Characteristics

Quantum Device

Suitability Ranking

Figure 4: Solution sketch for the QUANTUM HARDWARE SELECTION pattern, showing the phases to select a quantum device.

vice for the quantum circuit at hand, the QUANTUM

HARDWARE SELECTION pattern can be used in com-

bination with the UNIFIED EXECUTION pattern. The

UNIFIED OBSERVABILITY pattern enables monitor-

ing and analyzing the execution of quantum circuits

when using heterogeneous quantum cloud offerings.

Known Uses: Giortamis et al. (2024) introduce Qon-

ductor, a tool for executing quantum applications via

a hardware-agnostic API. Salm et al. (2020) present a

concept as well as a corresponding tool for automati-

cally translating circuits between different circuit for-

mats and executing them via different quantum cloud

offerings. Weder et al. (2024) introduce a uniﬁcation

middleware for quantum cloud offerings, which also

enables additional features, such as circuit cutting.

3.4 Quantum Hardware Selection

Problem: How to automatically select

a suitable quantum device to execute a

given quantum circuit?

Context: Quantum circuits can either be executed

on a quantum device or a classical computer sim-

ulating the computation. However, it is impossible

to simulate larger quantum circuits using classical

hardware (Zhou et al., 2020). Therefore, a suitable

quantum device for the execution must be selected.

Forces: Quantum devices are provided by different

vendors, e.g., IBM, IonQ, and Rigetti (Leymann et al.,

2020). These quantum devices are very heteroge-

neous and differ in characteristics, such as the number

of qubits, their decoherence times, or the supported

gate set (Weder et al., 2021a). Some of the character-

istics change over time, e.g., the decoherence times

when recalibrating the quantum device (Tannu and

Qureshi, 2019). However, the successful execution of

a given quantum circuit depends on these character-

istics (Salm et al., 2020). Thus, selecting an unsuit-

able quantum device can lead to error-prone results.

Quantum cloud offerings also differ regarding their

payment models and access methods, e.g., queue-

based systems or reservations of exclusive time slots.

Solution: Figure 4 gives an overview of the phases to

select suitable quantum devices. First, the character-

istics of the quantum devices available to the user are

retrieved. This can either be done by periodically ac-

cessing an API providing data about these character-

istics, e.g., a provider API or a dedicated provenance

system, or by executing benchmarks that approxi-

mate device characteristics (IBM, 2024a; Tomesh

et al., 2022; Weder et al., 2021a). Then, analyze the

given quantum circuit so that in the next phase the

suitability of the devices can be ranked based on

the characteristics of the circuits and devices (Salm

et al., 2020). Finally, ensure that a quantum device is

selected that is available via a suitable cloud offering,

e.g., a cloud offering supporting a pay-per-use model.

Result: The quantum circuit can be executed on the

selected quantum device. Through proper hardware

selection, the impact of errors can be reduced and

other factors, such as the waiting time, can be opti-

mized. If the format of the circuit is incompatible with

the selected quantum device, it must be translated.

Related Patterns: The UNIFIED EXECUTION pat-

tern can be used to execute the quantum circuit if

the circuit format is not supported by the selected

CLOSER 2025 - 15th International Conference on Cloud Computing and Services Science

quantum device. The PRIORITIZED EXECUTION pat-

tern (Georg et al., 2023) enables selecting a suitable

quantum device even if the respective queue is long

by providing prioritized access to the quantum device.

Since errors still occur when utilizing a suitable quan-

tum device, their impact can be reduced by apply-

ing the READOUT ERROR MITIGATION and GATE

ERROR MITIGATION patterns (Beisel et al., 2022).

Known Uses: Salm et al. (Salm et al., 2020) and

Quetschlich et al. (Quetschlich et al., 2023) intro-

duce tools to automatically select suitable quan-

tum devices based on given quantum circuits.

Suchara et al. (Suchara et al., 2013) present the QuRE

Toolbox, a framework to estimate the required re-

sources for executing quantum circuits. This informa-

tion can then be used to select a suitable quantum de-

vice. Qiskit provides functionalities to ﬁlter available

quantum devices based on different characteristics,

e.g., the minimum number of qubits or the supported

gate set (IBM, 2024b). Further, the quantum device

for the execution can be selected from the remaining

quantum devices based on their current queue size.

3.5 Quantum Application Testing

Problem: How to ensure the correctness

of all functionalities of a hybrid quan-

tum application?

Context: Hybrid quantum applications are realized

using a plethora of different artifacts, such as quan-

tum circuits, classical programs, deployment models,

and control and data ﬂow speciﬁcations (Weder et al.,

2021b). The correctness of the functionality of all ar-

tifacts as well as their interactions must be ensured.

Forces: Quantum applications comprise heteroge-

neous programs, e.g., using different programming

languages and data formats. The execution of quan-

tum circuits is probabilistic and arbitrary unknown

quantum states can not be copied, hence, obtaining

information about a qubit without disturbing the cor-

responding quantum system state is impossible (Ali

et al., 2021; Bu

zek and Hillery, 1996). Further,

simulating the execution of larger quantum circuits is

impossible due to the exponential resources required

for simulating additional qubits (Zhou et al., 2020).

The changing characteristics of quantum devices may

lead to different results when executing the same

quantum circuit at different times, even when using

the same quantum devices (Tannu and Qureshi, 2019).

Solution: Utilize a holistic testing strategy compris-

ing the following steps as depicted in Figure 5:

(i) Unit tests for the classical programs. (ii) Speciﬁc

tests for the quantum circuits. This includes math-

Unit

Tests

Quantum

Circuit Tests

Deployment

Test

Integration

Test

3 4

Figure 5: Solution sketch for the QUANTUM APPLICATION

TESTING, documenting four testing phases.

ematical veriﬁcation of quantum circuits (Chareton

et al., 2021; Wang et al., 2008), adding and evalu-

ating assertions to ensure certain states (Huang and

Martonosi, 2019; Liu et al., 2020), as well as white

and black box tests for quantum circuits (Miranskyy

et al., 2020). (iii) Deployment tests verifying that

the application was provisioned as intended (Wurster

et al., 2018). (iv) Integration tests validating the inter-

play of the various software artifacts (Wu et al., 2003).

Result: By testing all artifacts of a quantum appli-

cation, as well as their interplay and execution en-

vironment, the reliability of the quantum application

is signiﬁcantly increased. Well-tested artifacts of hy-

brid applications promote their reuse for other appli-

cations (Weder et al., 2022; Zhao, 2020). To automate

the testing procedure it may be integrated, e.g., into

the application’s continuous integration and develop-

ment (CI/CD) pipeline (Romero-

Alvarez et al., 2024).

Related Patterns: The correct functionality of hy-

brid quantum applications also depends on hardware

characteristics and the current calibration of quan-

tum devices. To select a suitable quantum device

for testing the quantum application, the QUANTUM

HARDWARE SELECTION pattern can be utilized. The

QUANTUM APPLICATION ARCHIVE pattern can in-

clude test speciﬁcations enabling integration and de-

ployment tests in the target environment. Due to

the increased complexity when integrating quantum

and classical programs, each CLASSICAL-QUANTUM

INTERFACE (B

uhler et al., 2023) should be tested.

Known Uses: Different lifecycles for hybrid quan-

tum applications include a dedicated testing phase fo-

cussing on the quantum-speciﬁc as well as integra-

tion aspects (Gheorghe-Pop et al., 2020; Weder et al.,

2022; Zhao, 2020). Becker et al. (2023) introduce a

testing pipeline for hybrid quantum applications that

includes tests for classical programs as well as quan-

tum circuits. Romero-

Alvarez et al. (2024) present a

concept to integrate hybrid quantum applications into

CI/CD pipelines. They enable the automated testing

and deployment of hybrid quantum applications in-

cluding the classical programs and quantum circuits.

Operations Patterns for Hybrid Quantum Applications

3.6 Uniﬁed Observability

Problem: How to ensure reproducibil-

ity, understandability, and quality when

executing hybrid quantum applications?

Context: Quantum applications comprise a multitude

of classical programs and quantum circuits which are

typically executed in a heterogeneous execution envi-

ronment, e.g., utilizing classical and quantum cloud

offerings (Beisel et al., 2024b; Leymann et al., 2020).

Forces: When executing hybrid quantum applications

in heterogeneous execution environments, collecting

all necessary data is difﬁcult: The data must be gath-

ered using the different APIs or SDKs of the utilized

quantum and classical cloud offerings, which often

change, e.g., when new features are released. Further-

more, the offerings might not provide all the required

data (Weder et al., 2021a). Finally, some of the data

also changes over time, e.g., the qubit decoherence

times or the error rates (Tannu and Qureshi, 2019).

Analyzing the data is complicated by different

data formats and abstraction levels of the provided

data (Beisel et al., 2024b). Moreover, hybrid quan-

tum applications are typically developed and operated

by interdisciplinary teams with various backgrounds,

e.g., physics, mathematics, and software engineering,

requiring different information (Weder et al., 2022).

Solution: Figure 6 shows the phases required to

achieve uniﬁed observability. Data about the execu-

tion of the quantum application and the used quan-

tum and classical resources must be collected continu-

ously. Persistently store these data using a provenance

system that automatically uniﬁes data using transfor-

mation methods. For example, quantum cloud offer-

ings use both the ﬁdelity and error rate metrics to

describe the quality of their gate operations, where

Error Rate = 1 −Fidelity. Use benchmarks to retrieve

data that is not provided by the cloud offerings but re-

quired by the user (Tomesh et al., 2022). To enable

user-group-speciﬁc monitoring and analysis provide

suitable abstractions, e.g., by aggregating data or hid-

ing unnecessary information (Beisel et al., 2024b).

Result: The provenance system stores all relevant

Data

Collection

Data

Abstraction

Data

Analysis

Data

Unification

Figure 6: Solution sketch for the UNIFIED OBSERVABILITY

pattern, documenting the four observability phases.

data produced by the quantum applications, enabling

their monitoring and analysis, e.g., to identify errors

and optimize the application. Data abstractions facil-

itate understanding the application and its execution

environment, particularly by visualizing crucial data.

Related Patterns: The UNIFIED EXECUTION pattern

can be combined with the UNIFIED OBSERVABIL-

ITY pattern to monitor and analyze the execution of

quantum applications using heterogeneous hardware.

The stored data about quantum devices can be used

as a basis for the QUANTUM HARDWARE SELEC-

TION, GATE ERROR MITIGATION, and READOUT

ERROR MITIGATION patterns (Beisel et al., 2022).

Known Uses: Beisel et al. (2024b) introduce a con-

cept to unify the observability of hybrid quantum ap-

plications realized using workﬂows within heteroge-

neous multi-cloud environments. Weder et al. (2021a)

present a provenance system for quantum com-

puting automatically gathering required provenance

data, which can be used for monitoring and analysis.

4 DISCUSSION

The validity of patterns in the software engineering

domain can be conﬁrmed by identifying several real-

world occurences (Gamma et al., 1995; Schmidt et al.,

1996). For each documented operations pattern for

hybrid quantum applications, a set of known real-

world uses is summarized in the known uses section.

Quantum software engineering is currently still

a new discipline (Piattini et al., 2021; Zhao, 2020):

Quantum applications are often developed research-

driven and in an ad-hoc manner to realize experiments

or evaluate the suitability of quantum applications to

solve a certain problem (Ali et al., 2022). However,

with the increasing capabilities of quantum devices,

the development of high-quality hybrid quantum ap-

plications is of vital importance (Weder et al., 2022).

With the usage of hybrid quantum applications in pro-

duction environments, we expect a focus shift to the

operational aspects of quantum software engineering

and the corresponding tools provided by different re-

search institutions and companies. Hence, additional

known uses for the presented patterns can be added.

The application of the UNIFIED EXECUTION and

UNIFIED OBSERVABILITY pattern becomes increas-

ingly more difﬁcult the more heterogeneous the data

and interfaces are. A well-established method for re-

ducing heterogeneity is the introduction of standards.

These standards are typically developed by the ma-

jor stakeholders from industry as well as experts from

academia. As quantum software engineering is still

in its infancy, there currently is a lack of standard-

CLOSER 2025 - 15th International Conference on Cloud Computing and Services Science

ization. The ﬁrst steps for developing dedicated stan-

dards for quantum software engineering are being

taken, e.g., the introduction of OpenQASM 3.0 (Cross

et al., 2022), a language for specifying quantum cir-

cuits. However, additional standards are required to

improve the portability and interoperability of quan-

tum applications and to streamline their development

and operation. For example, standards for deﬁning

the capabilities of a quantum device and for storing

the measurement results of a quantum computation.

When operating quantum applications, often existing

standards from classical software engineering can be

used with no or only minor adaptations (Beisel et al.,

2024a): (i) BPMN (OMG, 2011) for orchestrating

the control- and dataﬂow of the different functional-

ities using workﬂow technologies, (ii) TOSCA (OA-

SIS, 2013) for automating the deployment of the re-

quired programs, (iii) PROV (W3C, 2013) for stor-

ing provenance data about quantum applications, and

(iv) OpenAPI (OpenAPI Initiative, 2024) for describ-

ing the interfaces of quantum and classical services.

5 RELATED WORK

The patterns for operating hybrid quantum applica-

tions introduced in this paper extend the existing

quantum computing pattern language (Beisel et al.,

2022; Georg et al., 2023; Leymann, 2019; Truger

et al., 2024). In addition to the quantum computing

pattern language, there are other works presenting and

utilizing patterns within the quantum domain that do

not follow the pattern structure introduced by Alexan-

der et al. (1977). Khan et al. (2023) conduct a sys-

tematic literature review aiming to identify architec-

ture design patterns in quantum applications. Baczyk

et al. (2024) present a variety of architectural software

patterns in the quantum software engineering domain.

However, their patterns only focus on the develop-

ment and not the operations of quantum applications.

Gilliam et al. (2019) and Perdrix (2007) present vari-

ous patterns for building and improving quantum cir-

cuits. Huang and Martonosi (2019) introduce a strat-

egy for using quantum programming patterns to pre-

vent bugs in quantum circuits. Perez-Castillo et al.

(2024) analyze how different patterns from the quan-

tum computing pattern language can be utilized to

build quantum circuits using Qiskit and OpenQASM.

Some patterns presented in this work are com-

posite patterns employing patterns that were intro-

duced in other domains as part of their solutions:

The UNIFIED EXECUTION pattern utilizes the API

GATEWAY pattern (Richardson, 2018) to provide a

single interface unifying the underlying quantum de-

vices. To reduce the upper limit of required trans-

lators per language from n

to 2n, a CANONICAL

DATA MODEL (Hohpe and Woolf, 2004) can be

used as an intermediate format for translating quan-

tum circuits. Furthermore, the LOG DEPLOYMENTS

AND CHANGES and the LOG AGGREGATION pat-

terns (Richardson, 2018) are utilized by the UNI-

FIED OBSERVABILITY pattern to keep track of the

execution environments of hybrid quantum applica-

tions. The HYBRID DEVELOPMENT ENVIRONMENT

pattern (Fehling et al., 2014b) can be employed to

use different execution environments for the develop-

ment, testing, and operations of quantum applications.

To facilitate the applications of patterns, Falken-

thal et al. (2017) propose the concept of solution lan-

guages. Solution languages associate so-called con-

crete solutions with the patterns of a pattern language.

Concrete solutions are implementations of a pattern,

e.g., a Java program or a quantum circuit. Thus, so-

lution languages enable a systematic, pattern-centric

collection of real-world implementations. Since con-

crete solutions are interconnected with the respec-

tive patterns, developers can reuse an existing im-

plementation for their use case when utilizing a pat-

tern. Thereby, the manual effort of implementing the

abstract solution described in the pattern is reduced.

6 CONCLUSION & OUTLOOK

In this work, we motivated the need for concepts to

successfully operate hybrid quantum applications and

the suitability of using patterns to formalize these

concepts concisely and easily digestibly. We cap-

tured existing concepts from the literature to operate

and manage quantum applications and documented

them as ﬁve novel patterns that extend the quantum

computing patterns language. The introduced pat-

terns are made publicly available via the Pattern At-

las (Leymann and Barzen, 2021), a graphical tool

for authoring, managing, and visualizing patterns.

The operation and management of hybrid quan-

tum applications is a highly active area that is gaining

attention from research and industry. Thus, we plan to

continue analyzing the literature and emerging tools

to identify and document novel patterns in this area.

ACKNOWLEDGEMENTS

This work was partially funded by the BMWK

projects EniQmA (01MQ22007B) and SeQuenC

(01MQ22009B).

Operations Patterns for Hybrid Quantum Applications

REFERENCES

Alexander, C., Ishikawa, S., and Silverstein, M. (1977).

A Pattern Language: Towns, Buildings, Construction.

Oxford University Press.

Ali, S., Arcaini, P., Wang, X., and Yue, T. (2021). Assessing

the Effectiveness of Input and Output Coverage Crite-

ria for Testing Quantum Programs. In 2021 14

IEEE

Conference on Software Testing, Veriﬁcation and Val-

idation (ICST), pages 13–23.

Ali, S., Yue, T., and Abreu, R. (2022). When Software En-

gineering Meets Quantum Computing. Communica-

tions of the ACM, 65(4):84–88.

Altmanninger, K., Seidl, M., and Wimmer, M. (2009). A

survey on model versioning approaches. International

Journal of Web Information Systems, 5(3):271–304.

Baczyk, B., P

erez-Castillo, R., and Piattini, M. (2024).

Towards a Framework of Architectural Patterns for

Quantum Software Engineering. In Proceedings of the

International Workshop on Quantum Software En-

gineering and Technology (Q-SET), pages 41–48.

Bechtold, M., Barzen, J., Beisel, M., Leymann, F., and

Weder, B. (2023). Patterns for Quantum Circuit Cut-

ting. In Proceedings of the 30

Conference on Pattern

Languages of Programs (PLoP), pages 1–11. HILL-

SIDE.

Becker, C. K.-U., Gheorghe-Pop, I.-D., and Tcholtchev, N.

(2023). A testing pipeline for quantum computing

applications. In Proceedings of the 2023 IEEE In-

ternational Conference on Quantum Software (QSW),

pages 54–59. IEEE.

Beisel, M., Alvarado-Valiente, J., Barzen, J., Leymann,

F., Romero-

Alvarez, J., Stiliadou, L., and Weder, B.

(2024a). Utilizing a Standards-Based Toolchain to

Model and Execute Quantum Workﬂows. In Web En-

gineering – ICWE 2024, pages 401–405. Springer.

Beisel, M., Barzen, J., Leymann, F., Stiliadou, L., and

Weder, B. (2024b). Observability for Quantum Work-

ﬂows in Heterogeneous Multi-cloud Environments. In

Advanced Information Systems Engineering – CAiSE

2024, pages 612–627. Springer.

Beisel, M., Barzen, J., Leymann, F., Truger, F., Weder, B.,

and Yussupov, V. (2022). Patterns for Quantum Error

Handling. In Proceedings of the 14

International

Conference on Pervasive Patterns and Applications

(PATTERNS), pages 22–30. Xpert Publishing Services

(XPS).

uhler, F., Barzen, J., Beisel, M., Georg, D., Leymann, F.,

and Wild, K. (2023). Patterns for Quantum Software

Development. In Proceedings of the 15

Interna-

tional Conference on Pervasive Patterns and Appli-

cations (PATTERNS), pages 30–39. Xpert Publishing

Services (XPS).

zek, V. and Hillery, M. (1996). Quantum copying: Be-

yond the no-cloning theorem. Physical Review A,

54(3):1844.

Cao, Y., Romero, J., and Aspuru-Guzik, A. (2018). Poten-

tial of quantum computing for drug discovery. IBM

Journal of Research and Development, 62(6):6:1–

6:20.

Chareton, C., Bardin, S., Bobot, F., Perrelle, V., and Val-

iron, B. (2021). An Automated Deductive Veriﬁcation

Framework for Circuit-building Quantum Programs.

In European Symposium on Programming (ESOP),

pages 148–177. Springer.

Cross, A., Javadi-Abhari, A., Alexander, T., Beaudrap,

N. D., Bishop, L. S., Heidel, S., et al. (2022). Open-

QASM 3: A broader and deeper quantum assembly

language. ACM Transactions on Quantum Comput-

ing, 3(3):1–50.

DeBenedictis, E. P. (2018). A Future with Quantum Ma-

chine Learning. Computer, 51(2):68–71.

Falkenthal, M., Barzen, J., Breitenb

ucher, U., and Leymann,

F. (2017). Solution Languages: Easing Pattern Com-

position in Different Domains. International Journal

on Advances in Software, 10(3):263–274.

Fehling, C., Barzen, J., Breitenb

ucher, U., and Leymann,

F. (2014a). A Process for Pattern Identiﬁcation, Au-

thoring, and Application. In Proceedings of the 19

European Conference on Pattern Languages of Pro-

grams (EuroPLoP). ACM.

Fehling, C., Leymann, F., Retter, R., Schupeck, W., and Ar-

bitter, P. (2014b). Cloud Computing Patterns: Funda-

mentals to Design, Build, and Manage Cloud Appli-

cations. Springer.

Gamma, E., Helm, R., Johnson, R., Vlissides, J., and Pat-

terns, D. (1995). Elements of reusable object-oriented

software, volume 99. Addison-Wesley Reading.

Georg, D., Barzen, J., Beisel, M., Leymann, F., Obst, J., Vi-

etz, D., Weder, B., and Yussupov, V. (2023). Execution

Patterns for Quantum Applications. In Proceedings of

the 18

International Conference on Software Tech-

nologies (ICSOFT), pages 258–268. SciTePress.

Gheorghe-Pop, I.-D., Tcholtchev, N., Ritter, T., and

Hauswirth, M. (2020). Quantum DevOps: Towards

Reliable and Applicable NISQ Quantum Computing.

In IEEE Globecom Workshops, pages 1–6. IEEE.

Gilliam, A., Venci, C., Muralidharan, S., Dorum, V., May,

E., Narasimhan, R., and Gonciulea, C. (2019). Foun-

dational Patterns for Efﬁcient Quantum Computing.

arXiv:1907.11513.

Giortamis, E., Rom

ao, F., Tornow, N., Lugovoy, D., and

Bhatotia, P. (2024). Orchestrating Quantum Cloud En-

vironments with Qonductor.

Hohpe, G. and Woolf, B. (2004). Enterprise Integration

Patterns: Designing, Building, and Deploying Mes-

saging Solutions. Addison-Wesley.

Huang, Y. and Martonosi, M. (2019). Statistical Assertions

for Validating Patterns and Finding Bugs in Quantum

Programs. In Proceedings of the 46

International

Symposium on Computer Architecture (ISCA), pages

541–553. ACM.

IBM (2024a). IBMQ Dashboard. https://quantum.ibm.com.

IBM (2024b). Qiskit Backend Filtering. https://docs.

quantum.ibm.com/guides/get-qpu-information#

ﬁlter-backends.

Khan, A. A., Ahmad, A., Waseem, M., Liang, P., Fahmideh,

M., Mikkonen, T., and Abrahamsson, P. (2023). Soft-

ware architecture for quantum computing systems —

CLOSER 2025 - 15th International Conference on Cloud Computing and Services Science

A systematic review. Journal of Systems and Software,

201:111682.

Leymann, F. (2019). Towards a Pattern Language for Quan-

tum Algorithms. In Proceedings of the First Interna-

tional Workshop on Quantum Technology and Opti-

mization Problems (QTOP). Springer.

Leymann, F. and Barzen, J. (2020). The bitter truth

about gate-based quantum algorithms in the NISQ era.

Quantum Science and Technology, pages 1–28.

Leymann, F. and Barzen, J. (2021). Pattern Atlas, pages

67–76. Springer.

Leymann, F., Barzen, J., and Falkenthal, M. (2019). To-

wards a Platform for Sharing Quantum Software. In

Proceedings of the 13

Advanced Summer School on

Service Oriented Computing (2019), IBM Technical

Report (RC25685), pages 70–74. IBM Research Divi-

sion.

Leymann, F., Barzen, J., Falkenthal, M., Vietz, D., Weder,

B., and Wild, K. (2020). Quantum in the Cloud: Ap-

plication Potentials and Research Opportunities. In

Proceedings of the 10

International Conference on

Cloud Computing and Services Science (CLOSER),

pages 9–24. SciTePress.

Liu, J., Byrd, G. T., and Zhou, H. (2020). Quantum Cir-

cuits for Dynamic Runtime Assertions in Quantum

Computation. In Proceedings of the 25

Interna-

tional Conference on Architectural Support for Pro-

gramming Languages and Operating Systems (ASP-

LOS), pages 1017–1030. ACM.

Miranskyy, A., Zhang, L., and Doliskani, J. (2020). Is

Your Quantum Program Bug-Free? In Proceedings

of the ACM/IEEE 42

International Conference on

Software Engineering: New Ideas and Emerging Re-

sults (ICSE-NIER), page 29–32. ACM.

OASIS (2013). Topology and Orchestration Speciﬁcation

for Cloud Applications (TOSCA) Version 1.0. Organi-

zation for the Advancement of Structured Information

Standards (OASIS).

OMG (2011). Business Process Model and Notation

(BPMN) Version 2.0. Object Management Group

(OMG).

OpenAPI Initiative (2024). OpenAPI Speciﬁcation.

https://spec.openapis.org/oas/v3.1.1.html.

Perdrix, S. (2007). Quantum Patterns and Types for Entan-

glement and Separability. Electronic Notes in Theo-

retical Computer Science, 170:125–138.

Perez-Castillo, R., Fern

andez-Osuna, M., Cruz-Lemus,

J. A., and Piattini, M. (2024). A preliminary study

of the usage of design patterns in quantum software.

In Proceedings of the 5th ACM/IEEE International

Workshop on Quantum Software Engineering, pages

41–48.

Piattini, M., Serrano, M., Perez-Castillo, R., Petersen, G.,

and Hevia, J. L. (2021). Toward a Quantum Software

Engineering. IT Professional, 23(1):62–66.

Preskill, J. (2018). Quantum Computing in the NISQ era

and beyond. Quantum, 2:79.

Quetschlich, N., Burgholzer, L., and Wille, R. (2023). MQT

Predictor: Automatic Device Selection with Device-

Speciﬁc Circuit Compilation for Quantum Comput-

ing. ACM Transactions on Quantum Computing.

Richardson, C. (2018). Microservices patterns. Simon and

Schuster.

Romero-

Alvarez, J., Alvarado-Valiente, J., Moguel, E.,

Garcia-Alonso, J., and Murillo, J. M. (2024). En-

abling continuous deployment techniques for quan-

tum services. Software: Practice and Experience,

54(8):1491–1515.

Salm, M., Barzen, J., Breitenb

ucher, U., Leymann, F.,

Weder, B., and Wild, K. (2020). The NISQ Analyzer:

Automating the Selection of Quantum Computers for

Quantum Algorithms. In Proceedings of the 14

Symposium and Summer School on Service-Oriented

Computing (SummerSOC), pages 66–85. Springer.

Schmidt, D. C., Fayad, M., and Johnson, R. E. (1996).

Software patterns. Communications of the ACM,

39(10):37–39.

Suchara, M., Kubiatowicz, J., Faruque, A., Chong, F. T.,

Lai, C.-Y., and Paz, G. (2013). QuRE: The Quantum

Resource Estimator Toolbox. In IEEE 31st Interna-

tional Conference on Computer Design (ICCD), pages

419–426. IEEE.

Tannu, S. S. and Qureshi, M. K. (2019). Not All Qubits Are

Created Equal: A Case for Variability-Aware Policies

for NISQ-Era Quantum Computers. In Proceedings

of the 24

International Conference on Architectural

Support for Programming Languages and Operating

Systems (ASPLOS), page 987–999. ACM.

Tomesh, T., Gokhale, P., Omole, V., Ravi, G. S., Smith,

K. N., Viszlai, J., et al. (2022). SupermarQ: A Scal-

able Quantum Benchmark Suite. In 2022 IEEE Inter-

national Symposium on High-Performance Computer

Architecture (HPCA), pages 587–603. IEEE.

Truger, F., Barzen, J., Beisel, M., Leymann, F., and Yus-

supov, V. (2024). Warm-Starting Patterns for Quan-

tum Algorithms. In Proceedings of the 16

Interna-

tional Conference on Pervasive Patterns and Appli-

cations (PATTERNS), pages 25–31. Xpert Publishing

Services (XPS).

Vietz, D., Barzen, J., Leymann, F., and Wild, K. (2021).

On Decision Support for Quantum Application Devel-

opers: Categorization, Comparison, and Analysis of

Existing Technologies. In Computational Science –

ICCS 2021, pages 127–141. Springer.

W3C (2013). PROV Model Primer. World Wide Web Con-

sortium (W3C).

Wang, S.-A., Lu, C.-Y., Tsai, I.-M., and Kuo, S.-Y. (2008).

An XQDD-Based Veriﬁcation Method for Quan-

tum Circuits. IEICE Transactions on Fundamentals

of Electronics, Communications and Computer Sci-

ences, 91(2):584–594.

Weder, B., Barzen, J., Beisel, M., B

uhler, F., Georg, D.,

Leymann, F., and Stiliadou, L. (2024). Qunicorn: A

middleware for the uniﬁed execution across heteroge-

neous quantum cloud offerings. In Proceedings of the

International Workshop on Quantum Software En-

gineering (Q-SE). IEEE.

Weder, B., Barzen, J., Leymann, F., Salm, M., and Wild, K.

(2021a). QProv: A provenance system for quantum

Operations Patterns for Hybrid Quantum Applications

computing. IET QuantumCommunication, 2(4):171–

181.

Weder, B., Barzen, J., Leymann, F., and Vietz, D. (2022).

Quantum Software Development Lifecycle. In Quan-

tum Software Engineering, pages 61–83. Springer.

Weder, B., Barzen, J., Leymann, F., and Zimmermann, M.

(2021b). Hybrid Quantum Applications Need Two Or-

chestrations in Superposition: A Software Architec-

ture Perspective. In Proceedings of the 18

IEEE

International Conference on Web Services (ICWS),

pages 1–13. IEEE.

Weigold, M., Barzen, J., Leymann, F., and Salm, M.

(2021a). Encoding patterns for quantum algorithms.

IET QuantumCommunication, 2(4):141–152.

Weigold, M., Barzen, J., Leymann, F., and Vietz, D.

(2021b). Patterns for Hybrid Quantum Algorithms.

In Proceedings of the 15

Symposium and Sum-

mer School on Service-Oriented Computing (Summer-

SOC), pages 34–51. Springer.

Wu, Y., Chen, M.-H., and Offutt, J. (2003). UML-Based

Integration Testing for Component-Based Software.

In Proceedings of the 2

International Conference

on COTS-Based Software Systems, pages 251–260.

Springer.

Wurster, M., Breitenb

ucher, U., Kopp, O., and Leymann, F.

(2018). Modeling and Automated Execution of Ap-

plication Deployment Tests. In Proceedings of the

IEEE 22

International Enterprise Distributed Ob-

ject Computing Conference (EDOC), pages 171–180.

IEEE.

Zhao, J. (2020). Quantum Software Engineering: Land-

scapes and Horizons. arXiv:2007.07047.

Zhou, Y., Stoudenmire, E. M., and Waintal, X. (2020). What

Limits the Simulation of Quantum Computers? Phys-

ical Review X, 10(4):041038.

CLOSER 2025 - 15th International Conference on Cloud Computing and Services Science