Overview
FlowX.AI is an event-driven platform built on specialized microservices that communicate primarily through Apache Kafka. The architecture is organized into distinct layers, each responsible for a specific concern — from process execution and application lifecycle management to authorization, content delivery, and AI-powered automation. All backend services are containerized and deployed on Kubernetes. Client applications connect through an API Gateway that handles OAuth2 token validation and request routing.For detailed database-to-service mapping, storage types, and sizing guidance, see the Data architecture page.
Architecture overview
The diagram above shows the main architectural layers and how they interact. Almost all inter-service communication flows through Kafka, while the Events Gateway pushes real-time updates to clients via Server-Sent Events (SSE).FlowX Designer
The FlowX Designer is a collaborative, no-code/full-code web application for building and managing processes, UIs, integrations, and other application components. It is built on Angular and React within an Nx monorepo and includes 39 feature modules:- BPMN editor — visual process designer built on Fabric.js canvas
- UI designer — drag-and-drop interface builder for web and mobile
- Data model builder — schema design and management
- Integration designer UI — visual workflow builder for external system connections
- Script builder — Monaco-based code editor for business rules (JavaScript, Python, MVEL)
- AI features — embedded config-time agents, conversation system, command center
- CMS, theme editor, access management — content, branding, and permissions configuration
FlowX Designer
Core Engine layer
The Core Engine layer handles workflow execution, process orchestration, and real-time event delivery.Process Engine
The Process Engine is the central orchestration service that executes BPMN 2.0 process definitions and manages process instance lifecycles.- Executes business processes and coordinates real-time interactions between users, systems, and data
- Manages process instances from creation through completion
- Supports multiple script engines: JavaScript (GraalJS), Python 3 (GraalPy), and MVEL
- Dynamically generates and delivers UI components based on process state
process_engine), MongoDB (app-runtime read), Redis (cache), Elasticsearch (indexing)
Process Engine
Advancing Controller
The Advancing Controller ensures efficient process instance progression, particularly in scaled deployments.- Distributes workload evenly across Process Engine instances
- Facilitates redistribution during scale-up and scale-down
- Prevents process instances from getting stuck if a worker pod fails
- Performs cleanup tasks and monitors worker pod status
advancing), Redis
Advancing Controller
Events Gateway
The Events Gateway centralizes real-time communication between backend services and frontend clients through Server-Sent Events (SSE).- Routes and distributes messages from Kafka topics to appropriate frontend clients
- Enables real-time UI updates without page refreshes or polling
- Uses Redis pub/sub to ensure messages reach the correct instance holding the SSE connection
Events Gateway
Scheduler Core
The Scheduler Core handles time-based operations within processes.- Sets process expiration dates and reminders
- Triggers time-based events and activities
- Manages recurring tasks and delayed actions
notification shared with Notification Plugin)
Scheduler Core
Application Lifecycle layer
The Application Lifecycle layer manages the full journey from design through build to deployment.Application Manager
The Application Manager handles project lifecycle management.- Creates, updates, and deletes projects and their resources
- Manages versions, manifests, and configurations
- Serves as a proxy for frontend resource requests
- Handles project builds and deployments
app_manager), MongoDB (app-runtime), S3 (applications-bucket)
Projects
Runtime Manager
The Runtime Manager works alongside the Application Manager to deploy and manage applications in runtime environments.- Deploys application builds to runtime environments
- Manages runtime configurations and environment-specific settings
- Monitors and manages active application instances
Admin
The Admin service manages process definitions and platform-wide settings.- Stores and edits process definitions and data models
- Manages user roles and permissions
- Configures system-wide settings
flowxadmin), MongoDB (data-model)
Data Sync
The Data Sync job coordinates database migrations and data synchronization across multiple services.- Manages Liquibase migrations for
app_manager,auth_system, andprocess_enginedatabases - Synchronizes resource definitions across MongoDB instances (CMS, Scheduler, Task Management, Document Plugin, Notification Plugin, Integration Designer)
Content & Data layer
The Content & Data layer handles taxonomies, search, data persistence, and external system integrations.CMS Core
The CMS Core (Content Management System) manages all taxonomies and structured content within the platform.- Manages enumerations, dropdown options, and categories
- Stores and serves localization content and translations
- Organizes media assets and reference data
cms-core), S3 (media-library-bucket, cms-private-storage-bucket)
Content Management
Data Search
The Data Search service enables search capabilities across process instances using Elasticsearch.- Indexes process data automatically on status changes or at configured trigger points
- Supports filtering by process status, date ranges, and indexed keys
- Enables cross-application data discovery
Data Search
NoSQL DB Runner
The NoSQL DB Runner powers the FlowX Database feature — a persistence layer for storing structured data independently of process instances.- Executes MongoDB operations (find, insert, update, delete)
- Supports both native MongoDB and Azure Cosmos DB (MongoDB API)
- Enables data sharing between different process instances
nosql-db-runner)
FlowX Database
Integration Designer
The Integration Designer provides a visual interface for creating and managing integrations with external systems.- Defines REST API endpoints and authentication methods
- Creates and configures integration workflows with parallel branches
- Maps data between FlowX.AI processes and external systems
- Supports AI nodes for text, document, image, and data processing
integration-designer), S3 (workflows-bucket)
Integration Designer
Authorization & Security layer
The Authorization & Security layer provides multi-tenant access control, workspace isolation, and identity management.Authorization System
The Authorization System is the centralized authorization service for the platform.- Manages workspaces, users, groups, roles, and permissions
- Enforces access control lists (ACLs) for fine-grained resource permissions
- Provides RBAC (role-based access control) at organization, workspace, and project levels
auth_system), SpiceDB (ACL operations)
SpiceDB
SpiceDB is an embedded relationship-based access control (ReBAC) engine inspired by Google’s Zanzibar paper.- Stores and evaluates authorization policies
- Provides consistent, fine-grained permission decisions across all platform services
- Supports reverse lookups (finding all resources a user can access)
SpiceDB is an embedded component shipped with the platform. It runs alongside other services and is not deployed separately.
Organization Manager
The Organization Manager handles organization and tenant lifecycle management.- Manages organization creation and provisioning
- Handles user registration and onboarding
- Monitors platform component health
- Publishes organization lifecycle events to Kafka
org_manager)
Available starting with FlowX.AI 5.5.0
Multi-tenancy and workspaces
FlowX.AI uses workspaces to provide logical data isolation across the platform. Each workspace operates independently with its own resources (projects, libraries, themes) and access controls. The Authorization System, SpiceDB, and Organization Manager work together to enforce tenant boundaries while allowing users to belong to multiple workspaces.Workspaces
Identity providers
FlowX.AI delegates authentication to external identity providers. Every request passes through the API Gateway, which validates OAuth2 tokens before allowing access.Plugins
Plugins are modular extensions that add domain-specific capabilities to the core platform.Document Plugin
The Document Plugin handles document generation and management.- Generates documents from HTML templates
- Supports file upload, conversion, splitting, combining, and encryption/decryption
- Manages document storage and retrieval
document), MongoDB (document, app-runtime read), S3 (flowx-dev-bucket, temp-bucket)
Notification Plugin
The Notification Plugin manages notifications across multiple channels.- Sends email, SMS, and push notifications
- Handles OTP (one-time password) generation and validation
- Supports notification templates with dynamic content substitution
notification, app-runtime read), S3 (flowx-dev)
Task Management Plugin
The Task Management Plugin handles human task assignment and lifecycle.- Manages task creation, assignment, and completion
- Supports allocation rules and out-of-office delegation
- Provides multi-language localization with substitution tags
process_engine shared), MongoDB (task-management-plugin, app-runtime read)
Task Management
OCR Plugin
The OCR Plugin provides optical character recognition for document processing and data extraction.Plugins
Supporting Services
Supporting services provide cross-cutting capabilities like auditing, email communication, and licensing.Audit Core
The Audit Core service provides a centralized audit trail for all platform activities.- Logs user actions and system events with timestamps, subjects, and status
- Stores audit data in Elasticsearch for efficient querying
- Ingests events from Kafka topic
ai.flowx.core.trigger.save.audit.v1
Audit
Email Gateway
The Email Gateway handles email communication workflows.- Sends and receives emails through IMAP protocol
- Supports master election for distributed instances
- Publishes email events to Kafka for process triggering
email_gateway), MongoDB (app-runtime read)
License
The License service manages platform licensing. Data stores: PostgreSQL (license)
Document Parser
The Document Parser is a Python-based service for AI-powered document and image extraction.- Parses multiple formats: PDF, DOCX, XLSX, PPTX, and images
- Supports OCR engines: Tesseract, RapidOCR, EasyOCR
- Provides semantic chunking for RAG workflows
- Detects signatures and extracts table structures
Available starting with FlowX.AI 5.5.0
AI Platform
The AI Platform extends FlowX.AI with intelligent agents that operate at two levels:- Config-time agents — embedded in the FlowX Designer to help developers and analysts build apps faster (AI Analyst, AI Designer, AI Developer, AI Assistant)
- Business agents — power end-user experiences at runtime, built with the Agent Builder or installed from the Agentic Apps Marketplace
- Java services (gRPC): Connected Graph, Agents, Binaries, Conversations, Models, Tenants, Knowledge Graph (KAG)
- Python services (REST): Planner, AI Developer, AI Analyst, AI Designer
Observatory for AI observability, governance, and compliance tracking (EU AI Act, NIST AI RMF) is available starting with FlowX.AI 5.5.0.
The AI Platform uses Dgraph as an embedded graph database for AI agent state and knowledge graphs.
AI Platform
Client SDKs
The FlowX.AI SDKs provide process renderers that display dynamic UIs and orchestrate user interactions on each platform. The SDK architecture uses a framework-agnostic core (@flowx/core-sdk) with platform-specific wrappers.
Angular SDK
@flowx/angular-sdk for Angular applicationsReact SDK
@flowx/react-sdk for React applicationsiOS SDK
Native iOS renderer
Android SDK
Native Android renderer
The SDKs include companion packages for theming (
@flowx/ui-theme) and UI components (@flowx/ui-toolkit).Service communication
The following diagram shows the typical request flow through the platform:- Client applications initiate processes through the API Gateway using REST calls with an OAuth2 token
- The Process Engine executes the process definition and publishes events to Kafka
- Plugins and integrations consume events, perform their work, and publish results back to Kafka
- The Events Gateway picks up UI update events and pushes them to connected clients via SSE
Service quick reference
| Service | Layer | Port | Primary DB | Key Dependencies |
|---|---|---|---|---|
| Process Engine | Core Engine | 8085 | PostgreSQL, MongoDB | Kafka, Redis, Elasticsearch |
| Advancing Controller | Core Engine | 8097 | PostgreSQL | Redis, Process Engine |
| Events Gateway | Core Engine | 8090 | — | Redis, Kafka |
| Scheduler Core | Core Engine | 8091 | MongoDB | Kafka |
| Application Manager | App Lifecycle | 8099 | PostgreSQL, MongoDB | S3 |
| Runtime Manager | App Lifecycle | — | — | Application Manager |
| Admin | App Lifecycle | 8086 | PostgreSQL, MongoDB | — |
| Data Sync | App Lifecycle | — | — | PostgreSQL (3 DBs), MongoDB (8 DBs) |
| CMS Core | Content & Data | 8087 | MongoDB | S3 |
| Data Search | Content & Data | 8096 | Elasticsearch | Kafka |
| NoSQL DB Runner | Content & Data | 8121 | MongoDB | — |
| Integration Designer | Content & Data | 8098 | MongoDB | S3 |
| Authorization System | Auth & Security | 8100 | PostgreSQL | SpiceDB |
| SpiceDB | Auth & Security | 50051 | (embedded) | PostgreSQL |
| Organization Manager | Auth & Security | 8102 | PostgreSQL | SpiceDB |
| Document Plugin | Plugins | 8088 | PostgreSQL, MongoDB | S3 |
| Notification Plugin | Plugins | 8089 | MongoDB | S3 |
| Task Management | Plugins | 8093 | PostgreSQL, MongoDB | — |
| OCR Plugin | Plugins | — | — | — |
| Audit Core | Supporting | 8095 | Elasticsearch | Kafka |
| Email Gateway | Supporting | — | PostgreSQL, MongoDB | Kafka |
| License | Supporting | 8105 | PostgreSQL | — |
| Document Parser | Supporting | — | — | Kafka, AI providers |
Infrastructure
FlowX.AI requires the following infrastructure components:- PostgreSQL — system of record for process definitions, instance state, and platform configuration
- MongoDB — document storage for runtime configuration, workflow state, and flexible data structures
- Redis — in-memory cache for process definitions, compiled scripts, and distributed locks
- Apache Kafka — event streaming backbone for all inter-service communication
- Elasticsearch — search indexes for process data and audit logs
- S3-compatible storage — files, documents, and binary assets
- Dgraph — graph database for AI Platform agent state and knowledge graphs (embedded)
Data architecture
Database-to-service mapping and storage details
Third-party components
Supported versions and compatibility matrix