FlowX.AI is a comprehensive, event-driven platform designed to accelerate digital transformation by enabling rapid development of web and mobile applications without extensive coding. The architecture consists of several interconnected components that work together to provide a seamless experience for both developers and end users.
The FlowX.AI platform is built on a microservices architecture, with each component serving a specific purpose in the overall ecosystem:
The FlowX.AI Designer is a collaborative, no-code/full-code web-based application development environment that serves as the central workspace for creating and managing processes, UIs, integrations, and other application components.
Key capabilities:
The FlowX Designer is a web application that runs in the browser, residing outside a FlowX deployment, serving as the administrative interface for the entire platform.
The no-code/full-code capabilities allow both business users (analysts, product managers) and experienced developers to collaboratively build applications, reducing the typical development cycle from months to days.
FlowX.AI is built on a suite of specialized microservices that provide the foundation for the platform’s capabilities. These microservices communicate through an event-driven architecture, primarily using Kafka for messaging, enabling scalability, resilience, and extensibility:
The FlowX.AI Engine is the core orchestration component of the platform, serving as the central nervous system that executes process definitions, manages process instances, and coordinates communications between all platform components.
Key responsibilities:
The Engine is built on Kafka, providing high-throughput, low-latency event processing. This architecture enables FlowX.AI to maintain a responsive user experience (0.2s response time) even when integrating with slow legacy systems by buffering load and managing asynchronous communication.
Technical infrastructure:
The Engine works closely with the Advancing Controller to ensure efficient process instance progression, particularly in scaled environments.
The Application Manager is responsible for managing the application lifecycle, including:
This microservice maintains a comprehensive data model for applications, including all their components, versions, and dependencies, ensuring consistency across environments.
The Runtime Manager works in conjunction with the Application Manager to:
The Integration Designer provides a visual interface for creating and managing integrations with external systems:
This microservice simplifies the complex task of connecting to various enterprise systems, allowing for secure, scalable, and maintainable integrations without extensive coding.
The Content Management microservice handles all taxonomies and structured content within the platform:
This Java-based service uses MongoDB for flexible storage of unstructured content, making it the go-to place for all shared taxonomies and content definitions.
The Scheduler microservice handles time-based operations within processes:
It communicates with the FlowX Engine through Kafka, creating time-based events that can be processed when needed, similar to a reminder application for business processes.
The Admin microservice is responsible for:
This service connects to the same database as the FlowX Engine, ensuring consistency in process definitions and configurations.
The Data Search microservice enables search capabilities across the platform, allowing users to find data within process instances:
This service leverages Elasticsearch to execute efficient searches. It works by indexing process data automatically when process status changes or at specific trigger points, making the information searchable without impacting performance. The service communicates with the FlowX Engine through Kafka topics, receiving search requests and returning results that can be displayed in applications.
The Events Gateway microservice centralizes and manages the real-time communication between backend services and frontend clients through Server-Sent Events (SSE):
This component is crucial for maintaining the real-time, responsive nature of FlowX applications. It ensures that all UI updates, notifications, and system changes are immediately reflected across the platform without requiring page refreshes or manual polling. The Events Gateway reads messages from Kafka topics and distributes them appropriately, enabling features like instant form rendering when reaching user tasks or displaying real-time configuration errors.
The platform provides SDKs for different client platforms:
These SDKs communicate with the FlowX Engine to render dynamic UIs and orchestrate user interactions based on process definitions.
The platform’s functionality can be extended through plugins:
Plugins provide modular extensions to the core platform, allowing for customization without modifying the base architecture.
The Advancing Controller is a critical supporting service for the FlowX.AI Engine that enhances process execution efficiency, particularly in scaled deployments:
The Advancing Controller works in close coordination with the Engine to ensure uninterrupted process advancement. It must run concurrently with the Engine for optimal performance, particularly in production environments where reliability is crucial.
FlowX.AI recommends Keycloak or Azure AD (Entra) for identity and access management:
Every communication from client applications passes through a public entry point (API Gateway), which validates authentication tokens before allowing access to the platform. The system supports OAuth2 authentication with multiple configuration options for securing microservice communication.
FlowX.AI can connect to external systems through custom integrations called connectors
These integrations can be developed using any technology stack, with the only requirement being a connection to Kafka. This flexibility allows for seamless integration with:
The FlowX.AI platform uses an event-driven architecture based on Kafka for asynchronous communication between components:
This event-driven approach enables the platform to handle complex, long-running processes while maintaining responsiveness and scalability. Each microservice communicates through predefined Kafka topics following a consistent naming convention (e.g., ai.flowx.dev.core.trigger.advance.process.v1
), allowing for loosely coupled but highly cohesive system architecture.
FlowX.AI supports multiple scripting languages for business rules, validations, and data transformations:
This flexibility allows developers to use the most appropriate language for different use cases while maintaining performance and security.
FlowX.AI is designed for containerized deployment, typically using Kubernetes:
The platform includes comprehensive monitoring and health check capabilities:
These features ensure that the platform remains reliable and observable in production environments, with the ability to detect and resolve issues proactively.
FlowX.AI offers a comprehensive, event-driven platform for rapidly developing and deploying digital applications without extensive coding. Its microservices architecture, combined with industry-standard technologies and a user-friendly design environment, enables organizations to accelerate their digital transformation initiatives while maintaining flexibility, scalability, and integration with existing systems.