Docs

Release notes

SDKs

Setup guides

Requests

Academy

Support

Community

FlowX.AI is an AI multi-experience development platform that sits on top of legacy systems and creates unified, scalable digital experiences.

Introduction

Let's explore how you can build amazing things with FlowX.

Building with FlowX.AI

Based on what you need to accomplish and understand, find below-suggested tracks you can follow. Choose the track that suits you best.

Learn more

FlowX.AI architecture

The FlowX Process Designer workspace is designed for creating and editing business processes, the menu contains all elements required to create a process.

Process Designer

The core of the platform is the process definition, which is the blueprint of the business process made up of [nodes](../node/node) that are linked by sequences.

Process definition

A process instance is a specific execution of a business process that is defined on the FlowX.AI platform. Once a process definition is added to the platform, it can be executed, monitored, and optimized by creating an instance of the definition.

Process instance

Learn how to configure, start, and execute subprocesses efficiently within your process flow.

Subprocess management

With versioning, you can easily track your process definition's evolution.

Versioning

Navigation areas play a pivotal role in user interface design. They enhance the user experience by providing a structured, organized, and efficient way for users to interact with and explore various features and solutions.

Navigation areas

A BPMN node is a visual representation of a point in your **process**. Nodes are added at specific process points to denote the entrance or transition of a record within the process.

BPMN nodes

Let's go through all the options for configuring start and end nodes for a process definition.

Start/end nodes

Send message task and Receive message task nodes are used to handle the interaction between a running process and external systems. This is done using [**Kafka**](../../platform-overview/frameworks-and-standards/event-driven-architecture-frameworks/intro-to-kafka-concepts).

Send message/receive message tasks

A task **node** refers to a task that utilizes various services, such as Web services, automated applications, or other similar services, to accomplish a particular task.

Task node

This node represents an interaction with the user. It is used to display a piece of UI (defined in the [UI Designer](../ui-designer/ui-designer)) or a [custom Angular component](../ui-designer/ui-component-types/root-components/custom). You can also define **actions** available for the users to interact with the process.

User task node

In the world of process flows, decisions play a crucial role, and that's where the Exclusive Gateway comes into play. This powerful tool enables you to create conditional pathways with ease.

Exclusive gateway

When you have multiple operations that can be executed concurrently, the Parallel Gateway becomes a valuable tool. This type of node creates a parallel section within the **process**, particularly useful for tasks that can run independently without waiting for each other. It's essential to close each parallel section with another Parallel Gateway node.

Parallel gateway

Error Events expand the capabilities of process modeling and error handling within BPMN processing. These Error Event nodes enhance the BPMN standard and offer improved control over error management.

Error events

The activity that a node has to handle is defined using an <Tooltip tip = "Actions in the FLOWX.AI platform are used to define the activity that a node has to handle. They can have various types and are used to specify the communication details for plugins or integrations."> **action** </Tooltip>. These can have various types, they can be used to specify the communication details for plugins or integrations.

Overview

Send data to user interface **action** is based on Server-Sent Events (SSE), a web technology that enables servers to push real-time updates or events to clients over a single, long-lived HTTP connection. It provides a unidirectional communication channel from the server to the client, allowing the server to send updates to the client without the need for the client to continuously make requests.

Send data to user interface

An **Upload File action** is an **action** type that allows you to upload a file to a service available on <Tooltip tip ="In FLOWX.AI, Kafka handles all communication between the FLOWX Engine and external plugins and integrations. It is also used for notifying running process instances when certain events occur.">**Kafka**</Tooltip>.

Upload file action

A **Start subprocess action** is an **action** that allows you to start a **subprocess** from another (parent) **process**.

Start subprocess action

It is a type of **action** that allows you to send data from a [subprocess](../process/subprocess) to a parent [process](../process/process).

Append params to parent process

The FlowX Designer offers various options to configure the Kafka Send Action through the **Actions** tab at the node level.

Kafka send action

The FlowX platform offers a variety of ready-to-use [UI components](./ui-designer#ui-component-types) that can be used to create rich web interfaces. These include common form elements like [input fields](./ui-component-types/form-elements/input-form-field), [dynamic dropdown menus](./ui-component-types/form-elements/select-form-field#example---dynamic-dropdowns), [checkboxes](./ui-component-types/form-elements/checkbox-form-field), [radio](./ui-component-types/form-elements/radio-form-field), and [switch buttons](./ui-component-types/form-elements/switch-form-field), as well as other UI elements like image, text, anchor links, etc. The properties of each component can be customized further using the details tab, and [design flexibility](./#styling) is achieved by adding styles or CSS classes to the pre-defined components. The UI templates are built in a hierarchical structure, with a root component at the top.

There are two types of buttons available, each with a different purpose.

Buttons

The File Preview UI element is a user interface component that enables users to preview the contents of files quickly and easily without fully opening them. It can save time and enhance productivity, providing a glimpse of what's inside a file without having to launch it entirely.

File preview

Image UI elements are graphical components of a user interface that display a static or dynamic visual representation of an object, concept, or content.

Image

The indicators (Message UI elements) allow you to display different types of messages.

Indicators

Typography is an important aspect of design that greatly influences how users perceive and interact with your content. In this section, we'll explore how to effectively utilize two essential UI elements, "Text" and "Link."

Typography

Multiple UI elements can be linked to an [action](../actions/actions) via a UI Action. If the action is just a method to interact with the process, the UI Action adds information about how that UI should react. For example, should a loader appear after executing the action, should a modal be dismissed, or if some default data should be sent back to the process.

UI actions

Validators are an essential part of building robust and reliable applications. They ensure that the data entered by the user is accurate, complete, and consistent. In Angular applications, validators provide a set of pre-defined validation rules that can be used to validate various form inputs such as text fields, number fields, email fields, date fields, and more.

Validators

In modern application development, the ability to create dynamic and interactive user interfaces is essential for delivering personalized and responsive experiences to users. Dynamic values and computed values are powerful features that enable developers to achieve this level of flexibility and interactivity.

Dynamic & computed values

Layout settings will be available for all components that can group other types of elements (for example, [Container](./ui-component-types/root-components/container) or [Card](./ui-component-types/root-components/card)).

Layout configuration

Token is the concept that describes the current position in the process flow. When you start the process you have a graph of [nodes](./node/node) and based on the configuration you will go from one to another based on the defined sequence (connection between nodes).

Token

Scripts are used to define and run [actions](./actions/actions) but also properties inside [nodes](./node/node). For now, the following script languages are supported.

Supported scripts

The FLOWX.AI Designer is a collaborative, no-code, web-based application development environment, designed to facilitate the creation of web and mobile applications without the need for coding expertise.

FlowX.AI Designer

The first step of defining your business process in the **FlowX Designer** is adding a new [process definition](../../building-blocks/process/process-definition) for it.

Creating a new process definition

Once you create a new **process definition**, you can start configuring it by adding new **nodes**.

Adding a new node

We use actions to add business decisions to the **flow** or link the process to custom integrations and **plugins**.

Adding an action to a node

To add business decisions in the flow and use them to pick between a flow branch or another, we can use [exclusive gateways](../../building-blocks/node/exclusive-gateway-node).

Handling decisions in the flow

Adding more flow branches

Creating a user interface

Back in process is a functionality that allows you to go back in a business process redo a series of previous **actions** in the process.

Moving a token backwards in a process

To copy **process definitions** and move them between different environments, you can use the export/import feature.

Exporting / importing a process definition

Entering the realm of FlowxX unlocks a spectrum of possibilities for elevating processes and workflows. From automation to data-driven decision-making, several straightforward approaches pave the way for leveraging this platform efficiently. Let's delve into the ways to kickstart a process.

Initiating processes

The engine is the core of the platform, it is the service that runs instances of the process definitions, generates UI, communicates with the frontend and also with custom integrations and plugins. It keeps track of all currently running process instances and makes sure the process flows run correctly.

FlowX Engine

The Advancing Controller is a support service for the [Process Engine](./flowx-engine) that enhances the efficiency of advancing operations. It facilitates equal distribution and redistribution of the workload during scale-up and scale-down scenarios.

Advancing controller

Events Gateway a service that centralizes the communication with SSE (Server-sent Events) messages from Backend to Frontend.

Events gateway

Generic parameters are variables or settings that are used to control the behavior of a software application or system. These parameters are designed to be flexible and adaptable, allowing users to customize the software to their specific needs.

Generic parameters

The Audit log service provides a centralized location for all audit events. The following details are available for each event.

Audit

The Scheduler is part of the core extensions of the **FlowX.AI platform**. It can be easily added to your custom FlowX deployment to **enhance the core platform capabilities with functionality specific to scheduling messages.**

Scheduler

The Search data service is a microservice that enables data searches within other processes. It facilitates the creation of processes capable of conducting searches and retrieving data by utilizing [Kafka send/ Kafka receive](../../building-blocks/node/message-send-received-task-node) actions in tandem with Elastic Search mechanisms.

Search data

Adding new capabilities to the core platform can be easily done by using plugins. FlowX plugins represent already-built functionality that can be added to a FlowX.AI platform deployment.

FlowX custom plugins

The OCR (Optical Character Recognition) plugin is a powerful tool that enables you to read barcodes and extract handwritten signatures from .pdf documents with ease.

OCR plugin

Get ready to revolutionize your journey with our upcoming AI-powered agents.

FlowX AI Agents

FlowX Designer's WYSIWYG (**"What You See Is What You Get"**) editor enables you to create and modify [notification](./custom-plugins/notifications-plugin/notifications-plugin-overview) and [document](./custom-plugins/documents-plugin/documents-plugin-overview) templates without the need for complicated coding from the developers. WYSIWYG editors make the creation/editing of any type of document or notification easier for the end-user.

WYSIWYG editor

Integrations play a crucial role in **connecting legacy systems** or **third-party applications** to the **FlowX Engine**. They enable seamless communication by leveraging custom code and the **Kafka** messaging system.

Connectors are the vital gateway to enhancing FLOWX.AI's capabilities. They seamlessly integrate external systems, introducing new functionalities by operating as independently deployable, self-contained microservices.

This guide focuses on creating a **Kafka** consumer using Spring Boot.

Creating a Kafka consumer

This guide focuses on creating a **Kafka** producer using Spring Boot.

Creating a Kafka producer

If you need to test the business process flow but haven't completed all integrations, you can still do so by utilizing the mock integrations server included in the platform.

Mock integrations

The scope of this document is to present some basic information on how to include Jaeger tracing into a Java based project.

Jaeger setup for microservices

FLOWX.AI uses a number of third-party software components

Third-party components

Swimlanes provide a way of grouping process nodes by process participants.

Swimlanes

An optional attribute, from the authorization token, that can be set in order to restrict access to process instances based on a business specific value (ex. bank branch name).

Business filters

Clear cache strategy 4.0

Process status

Start process

Start process and inherit values

Execute action

The Documents Plugin provides the following REST API endpoints for interacting with the stored files.

List buckets

List objects in a bucket

Download a file

Add new Kafka exchange mock

View Kafka exchanges

FLOWX.AI provides web and native mobile SDKs. These SDKs enable developers to create applications that can be displayed in a browser, embedded in an internet banking interface, or in a mobile banking app. The SDKs automatically generate the user interface (UI) based on the business process and data points created by a business analyst, reducing the need for UX/UI expertise.

SDKs overview

FlowxProcessRenderer is a low code library designed to render UI configured via the Flowx Process Editor.

Web SDK (Angular renderer)

iOS SDK

Android SDK

Deploying microservices typically involves breaking down the application into smaller, modular components. Each microservice should be independently deployable, with all the necessary dependencies and configurations included.

This guide will provide instructions on how to set up and configure the FlowX Engine to meet your specific requirements.

FlowX Engine setup

Configuring access roles for processes

This guide provides step-by-step instructions to help you configure and deploy the Advancing Controller effectively.

To set up FlowX Designer in your environment, follow this guide.

FlowX Designer

The admin part manages process-related entities and provides the REST API used by the **FlowX Designer**. The processes defined here will be handled by the [**FlowX Engine**](/4.0/docs/platform-deep-dive/core-components/flowx-engine).

Admin

The CMS service is a microservice that allows managing taxonomies and contents. It is available as a Docker image and is designed to make it easy to edit and analyze content. This guide will walk you through the process of setting up the service and configuring it to meet your needs.

FlowX CMS

This guide will walk you through the process of setting up the Scheduler service.

This guide will walk you through the process of setting up the events-gateway service.

This guide will walk you through the process of setting up the Audit service and configuring it to meet your needs.

This guide will walk you through the process of setting up the Search Data service using a Docker image.

The License Engine is a service that can be set up using a Docker image. This guide will walk you through the process of setting up the License service and configuring it to meet your needs.

License Engine

To set up a plugin in your environment, you must go through the next steps.

The Documents plugin provides functionality for generating, persisting, combining, and manipulating documents within the **FlowX.AI** system.

Documents plugin

The Notifications plugin is available as a docker image, and it has the following dependencies.

Notifications plugin

The plugin is available as a docker image.

Task management

The OCR plugin is a docker image that can be deployed using the following infrastructure prerequisites.

The Reporting setup guide assists in configuring the reporting plugin, relying on specific dependencies and configurations.

Reporting

The Customer management plugin is available as a docker image so we need to configure.

Customer management

Identity and access management (IAM) is **a framework of business processes, policies and technologies that facilitates the management of electronic or digital identities**. With an IAM framework in place, you can control user access to critical information/components within an organization.

IAM solution

Configuring an IAM solution

Below you can find the list of all the default roles that you can add or import into the Identity and Access Management solution to properly manage the access to all the FlowX.AI microservices.

Default roles

Granular access rights can be configured for restricting access to the Admin component.

Admin access rights

Granular access rights can be configured for restricting access to the Engine component.

FlowX Engine access rights

Granular access rights can be configured for restricting access to the CMS component.

FlowX CMS access rights

Granular access rights can be configured for restricting access to the License component.

License Engine access rights

Granular access rights can be configured for restricting access to the Documents plugin component.

Documents plugin access rights

Granular access rights can be configured for restricting access to the Notification plugin component.

Notifications plugin access rights

Granular access rights can be configured for restricting access to the Task management plugin component.

Task management plugin access rights

Sub-processes are smaller process flows that can be triggered by actions in the main process. They can also inherit some process parameter values from the parent process and send their results back to the parent process when they are completed. The subprocesses will communicate with the front-end apps using the same connection details as their parent process.

Release Notes

V3.4.4 november 2023

Bug Fixes 🔧

FLOWX.AI Engine 🚂

Web SDK

Other Bits

Gremlins to Watch Out For 🙁

Additional information

Release Notes

​Bug Fixes 🔧

​FLOWX.AI Engine 🚂

​Web SDK

​Other Bits

​Gremlins to Watch Out For 🙁