This paper presents pyBeamline Designer, a web-based no-code platform developed for the construction, validation, and execution of streaming process mining pipelines. Built as a front-end application atop the pyBeamline library, it enables users to visually define streaming process mining workflows through an intuitive drag-and-drop interface. The platform automatically generates valid Python code for these pipelines and supports built-in live execution and export functionalities. Our contribution enhances the usability, accessibility, and prototyping of streaming process mining applications, especially for non-expert users, and represents a novel integration of low-code development principles within the process mining domain. The tool is open-source, thoroughly evaluated in a user study, and freely available online.
Value
Streaming process mining [
To address this gap, we developed pyBeamline Designer, an interactive, no-code [
The motivation for this work stems from the need to lower the technical barriers associated with streaming process mining. While pyBeamline simplifies prototyping relative to Beamline, it still demands a strong grasp of asynchronous programming and stream composition. This complexity can hinder rapid experimentation and reduce adoption among non-technical stakeholders. Our contribution is the design and implementation of a web-based no-code platform that complements pyBeamline. By enabling users to create pipelines visually, inspect their logical flow, and receive immediate feedback on potential errors, pyBeamline Designer improves both the eficiency and the approachability of pipeline development. Furthermore, the ability to export pipelines as fully functioning Python scripts allows for integration with existing workflows, making the platform suitable for both teaching and applied research. 3. Tool Description pyBeamline Designer is implemented as a fully client-side web application using modern front-end technologies, including Vue.js (https://vuejs.org) for the underlying framework, TypeScript for static typing and maintainability, and PrimeVue (https://primevue.org) and VueFlow (https: //vueflow.dev) for user interface and diagramming capabilities. The platform enables users to design streaming process mining pipelines using a visual flow-based model, where blocks representing operators are connected via edges to form a directed acyclic graph.
Each block in the designer corresponds to a concrete pyBeamline operator [
Under the hood, each block is backed by a JSON schema that describes its structural characteristics, including its expected input and output types, required parameters, valid values, and pyBeamline function mapping. The tool leverages the AJV (https://ajv.js.org) validation library to dynamically check that user-constructed pipelines conform to these constraints1. Type mismatches, missing parameters, and invalid block configurations are detected in real time and highlighted directly into the pipeline, guiding users toward a valid and executable pipeline. 1The complete JSON schema is availble at https://github.com/beamline/pybeamline-designer/tree/master/ src/model/schemas.
When a block is selected, a parameter configuration panel is shown in a sidebar (cf. Fig. 1). This panel includes helpful documentation, input forms for each required argument, and type hints to ensure proper usage. For instance, a excludes_activity_filter block might require a list of activities to exclude. Parameters are specified using a combination of text boxes, dropdowns, and – where appropriate – code editors.
The tool also supports advanced usage scenarios through its implementation of “wildcard blocks.” These customizable blocks allow users to embed arbitrary Python code directly within the platform. A code editor embedded in the sidebar allows the user to define new operator functions or sink behaviors, which are automatically injected into the script during the code generation phase. This enables users to prototype and test experimental operators or specialized logic without modifying the core application.
Once the pipeline is completely drawn, it is possible to generate the corresponding code. The code generation module traverses the user-defined diagram using a depth-first search strategy. The traversal respects the logical execution order of the pipeline and constructs a complete Python script that includes import statements, source and operator instantiations, and subscription logic. The generated script is presented to the user in a code viewer and can be downloaded as a standalone file.
To ensure reproducibility and continuity of work, users can save and load their pipelines as JSON files. These files capture the full state of the diagram, including node positions, parameters, and connections, making it easy to archive, share, or resume work at a later time. An action bar at the top of the interface (cf. Fig. 1) provides access to all core functions, including saving, loading, resetting, and generating the code.
The tool includes support for the execution of pipelines within the browser by connecting to a local Jupyter Kernel Gateway (https://jupyter-kernel-gateway.readthedocs.io). Fig. 2 shows the interface with the result of the execution of the generated pyBeamline code directly inside pyBeamline Designer. More complex pipelines can be exported and executed externally in a full Python environment where pyBeamline is installed. The ability to run code directly from within the tools fosters more rapid prototyping and faster development/test lifecycles. Visually, the tool emphasizes clarity and feedback. Each port type of the pipeline operators is color-coded and shaped according to its type and connection constraints (cf. Fig. 1). For example, a port that accepts multiple incoming connections (e.g., union operators) is visually distinct from a port that allows only a single input. Animations along the edges indicate the direction of the events flowing, and the interface dynamically updates to reflect the connection status of each node. In summary, pyBeamline Designer ofers a comprehensive and user-friendly environment for constructing and experimenting with streaming process mining
Listing 1: Generated pyBeamline code from the visual pipeline in Fig. 1. pipelines. Its architecture emphasizes modularity, real-time validation, and extensibility, making it suitable for both novice users exploring process mining for the first time and advanced users seeking a rapid prototyping platform for complex pipeline configurations.
To illustrate the core functionality of pyBeamline Designer, we present a minimal yet representative example of a streaming process mining pipeline constructed in the tool (cf. Fig. 1) and the Python code it generates (cf. List. 1). In the designer interface, a log_source and a string_test_source blocks are added to emit event data. The events are combined together using the merge operator. From here, all events are printed using a print_sink and they are also sent to an exclude_activity_filter, which removes events corresponding to activity “F”. The output of the filter is then forwarded to a simple_dfg_miner block, which derives a directly-follows graph (DFG) from the filtered stream and, finally, the resulting DFG is passed to a sink block that prints the result. Fig. 1 shows the pipeline. The user specifies the activity to filter (e.g., “F”) through the block’s parameter sidebar. Once the diagram is complete and validated, the tool generates the corresponding Python script shown in Listing 1. The generated code is syntactically correct and executable in any Python environment where the pyBeamline is installed.2 The script reflects the sequence of operations defined visually in the tool, with function parameters and chaining logic correctly preserved.
This example demonstrates the platform’s core objective: enabling users to define complex streaming logic visually and obtain robust, ready-to-run Python implementations. Larger pipelines involving joins, unions, or custom user-defined functions are handled similarly, with the tool automatically managing function declarations, type validations, and connection logic.
The tool has reached a mature state, having satisfied a set of functional and non-functional requirements [5, Ch. 6]. These include support for saving/loading pipelines, live code execution, error detection, diagram-to-code translation, and extensibility. All functionalities are provided through a self-contained front-end interface, in line with modern web deployment practices.
To evaluate the platform’s usability and efectiveness, we conducted a user study involving 20
participants from both technical and non-technical backgrounds. Participants were tasked with validating
pipelines and completing a series of guided exercises. Quantitative and qualitative feedback indicated
that the platform significantly reduced the complexity of building streaming pipelines (compared to
just using pyBeamline) and was perceived as intuitive and eficient. Fig. 3 shows an excerpt of the
results where time and correctness were compared between pyBeamline Designer and plain pyBeamline.
Participants consistently achieved similar or higher correctness with pyBeamline Designer, while also
completing the tasks significantly faster. All results are available at [
From a development standpoint, the tool adheres to modular design principles Correctness vs Time (seconds) and maintains compatibility with evolv- 1.0 ing versions of pyBeamline. The use of 0.8 schema-based operator definitions also ensures that new operators can be added tssen0.6 without modifying core logic, contribut- rrcoe0.4 ing to long-term maintainability. C
code, browser-based platform for visu- Figure 3: Results of an evaluation that compared ally creating, validating, and executing pyBeamline Designer and plain code. streaming process mining pipelines. By combining an intuitive interface with automatic code generation and real-time feedback, the tool reduces complexity, accelerates development, and broadens access to pyBeamline.
During the preparation of this work, the authors used Grammarly in order to: Grammar and spelling check. After using this service, the authors reviewed the content and take full responsibility for the publication’s content. 0.2 0.0 100 200