What’s new?Documentation Index
Fetch the complete documentation index at: https://docs.flowx.ai/llms.txt
Use this file to discover all available pages before exploring further.
- App builder & reusability
- Integration & data
- Bug fixes & stability
- Info
Build multi-platform applications faster with UI Flows, enhance real-time interactions with UI Events, and integrate custom components across all platforms.📱 UI Flows - Build multi-platform applications with reusable UI components across web, iOS, and Android
⚡ UI Events - Real-time user interaction handling with event-driven UI components
🧩 Custom Component Enhancements - Enhanced integration for custom components with standardized data mapping
📤 File Upload Improvements - Enhanced file upload experience with better loading states and user feedback
♿ Mobile Accessibility - WCAG 2.1 accessibility compliance for iOS and Android platforms
🏢 Cross Workspace Projects - Share projects across multiple workspaces for flexible environment testing
🎯 Collection & Table Actions - Execute actions from collections and tables in UI FlowsMajor Feature
UX Enhancement
Developer Experience
UX Enhancement
Accessibility
Reusability Enhancement
⚡ UI Events - Real-time user interaction handling with event-driven UI components
🧩 Custom Component Enhancements - Enhanced integration for custom components with standardized data mapping
📤 File Upload Improvements - Enhanced file upload experience with better loading states and user feedback
♿ Mobile Accessibility - WCAG 2.1 accessibility compliance for iOS and Android platforms
🏢 Cross Workspace Projects - Share projects across multiple workspaces for flexible environment testing
🎯 Collection & Table Actions - Execute actions from collections and tables in UI Flows
UI flows
UI flows
- Overview
- Problem Solved
- Key Features
- How It Works
- Benefits
- Use Cases
FlowX.AI 5.3 introduces UI Flows, a powerful new capability that enables you to build reusable, multi-platform user interfaces that work across web (Angular/React), iOS, and Android applications. UI Flows separate UI definitions from process logic, enabling better reusability and faster application development without the overhead of full BPMN processes.
UI Flows revolutionize how you build applications by allowing you to create a UI once and deploy it across all platforms, dramatically reducing development time and ensuring consistent user experiences.
Previous Limitations:
Unnecessary process complexity
Some use cases do not need a mapping of the business case in BPMN and the complexity and overhead that a FlowX process entails
Subprocess overhead
Unnecessary subprocess layers inside processes added complexity for simple UI scenarios
Tight UI-process coupling
UI definitions were tightly coupled to process logic, reducing reusability and increasing maintenance
Platform-specific development
Building the same UI for multiple platforms required separate implementations for each platform
UI Flows as project resources
UI Flows are managed as independent project resources, separate from process definitions
Navigation areas management
Manage Navigation Areas inside UI Flows Designer for structured navigation and layout
Start process UI action
Launch FlowX processes directly from UI Flows, bridging UI and process execution
Navigate to UI action
Setup navigation to Nav areas or Container elements through scroll for seamless UX
Task Manager component
Embed Task Manager as a UI Component in UI Flows for task management capabilities
Multi-platform support
Create UI once and deploy to web (Angular/React), iOS, and Android with platform-specific configurations
Import/export
Export UI Flows as portable packages and import them across environments and applications
Platform selection
Configure platform-specific behaviors and overrides for web, iOS, and Android in the UI Flows designer
Home page support
Create UI Flows with dedicated home pages and home navigation icons for better UX
Create UI flow
Create a UI Flow as a project resource in FlowX Designer, separate from process definitions
Design navigation
Manage Navigation Areas inside UI Flows Designer, defining pages and navigation structure
Add components
Add UI components including Task Manager, forms, custom components, and other UI elements
Configure actions
Setup UI Actions like Start Process (to launch processes) and Navigate To (for Nav areas or container scrolling)
Configure platforms
Set platform-specific configurations using the platform selection subheader (Web, iOS, Android)
Reduced complexity
Build UIs without the overhead of BPMN processes for use cases that don’t require business process mapping
Faster development
Build UI once instead of creating separate interfaces for each platform
Flexible architecture
Eliminate unnecessary subprocess layers - use UI Flows for simple scenarios and processes for complex business logic
Consistent UX
Ensure identical user experiences across web, iOS, and Android applications
Reusability
Share UI Flows across multiple applications and projects
Process integration
Launch processes from UI Flows when needed, maintaining clean separation of concerns
Maintainability
Update UI in one place and propagate changes across all platforms
Enhanced navigation
Rich navigation capabilities with Nav areas, container scrolling, and Task Manager integration
When to Use UI Flows vs Processes:Use UI Flows for:
- Information Display: Dashboards, reports, and static content that doesn’t require process orchestration
- Task Management: Task lists and task management interfaces with embedded Task Manager component
- Navigation Shells: Application navigation structures and home pages
- Form Collections: Data entry forms that start processes but don’t need their own process context
- Multi-Platform Apps: Applications that need consistent UI across web and mobile platforms
- Business Logic: Complex workflows with business rules, approvals, and integrations
- State Management: Applications requiring process state tracking and persistence
- Orchestration: Multi-step operations with decision points and parallel execution
UI Flows Documentation
Complete guide to creating and configuring UI Flows, including navigation management, UI actions, and platform considerations.
UI events
UI events
- Overview
- Key Features
- Use Cases
- Benefits
FlowX.AI 5.3 introduces UI Events, enabling real-time interaction handling directly within Reusable UI Templates. UI Events allow you to capture user interactions like button clicks, form changes, or custom events and respond immediately without process execution, providing responsive and dynamic user experiences.
Event configuration
Configure UI Events in UI Designer with custom event types and handling logic
Cross-platform support
UI Events work consistently across Angular, React, iOS, and Android renderers
Runtime mapping
UI Event results are mapped automatically in Reusable UI Template instances at runtime
Design-time testing
Test UI Events directly in UI Designer before deploying to runtime
Form validation
Validate form inputs in real-time as users type, providing immediate feedback
Dynamic UI updates
Show/hide fields, update options, or change UI state based on user interactions
Client-side logic
Execute lightweight client-side logic without triggering backend processes
Responsive interactions
Create highly responsive UI behaviors like autocomplete, live search, or conditional displays
Custom component enhancements
Custom component enhancements
- Overview
- Key Features
- Benefits
FlowX.AI 5.3 standardizes custom component integration across all platforms (Angular, React, iOS, Android) with unified data mapping for input keys, data binding, save operations, and action handling. This provides a consistent developer experience when building custom components.
Unified data mapping
Standard data, saveData, and action body mapping across all platforms
Input key mapping
Consistent input key handling for passing configuration and data to custom components
Platform parity
Identical custom component APIs across Angular, React, iOS, and Android
Action integration
Integration with FlowX actions for triggering backend operations
File upload improvements
File upload improvements
- Overview
- Key Features
- Configuration
FlowX.AI 5.3 enhances the file upload experience across all platforms with improved loading states, better user feedback, and more flexible configuration options. These improvements provide clearer status communication during file upload operations.
Enhanced loading behavior
Configure loading behavior with optional overlay loader and custom loading messages
Toast notifications
Success and error messages displayed as toasts with customizable messages
Dynamic messages
Display dynamic key values in toast and loading messages for context-aware feedback
Generic loader design
Updated loader designs across Angular, React, iOS, and Android for consistent theming
Loading Behavior Options:
- NONE: No loading overlay displayed during upload
- OVERLAY: Full-screen overlay with spinner and optional loading message
- Success Toast: Toggle to show success message when upload completes (auto-dismiss after 3-5 seconds)
- Error Toast: Toggle to show error message when upload fails (auto-dismiss after 3-5 seconds)
- Custom Messages: Configure success and error messages with dynamic substitutions
- Apply custom themes to loaders and toast messages
- Configure colors, sizes, and styling to match your brand
- Consistent visual language across platforms
Mobile accessibility
Mobile accessibility
- Overview
- Key Features
- Benefits
FlowX.AI 5.3 extends WCAG 2.1 accessibility compliance to iOS and Android platforms, allowing you to configure accessibility properties directly from UI Designer and ensuring your mobile applications are accessible to all users.
iOS accessibility
Configure labels, hints, traits, and accessibility properties for iOS components
Android accessibility
Set content descriptions and accessibility properties for Android components
Designer integration
Configure all accessibility properties from UI Designer without code changes
Platform-specific options
Set platform-specific accessibility configurations for optimal native experience
Inclusive mobile apps
Make your mobile applications accessible to users with disabilities
Regulatory compliance
Meet mobile accessibility requirements for government, healthcare, and financial sectors
Better UX
Accessibility improvements benefit all users, not just those using assistive technologies
Unified configuration
Configure accessibility for all platforms from a single Designer interface
Cross workspace projects
Cross workspace projects
- Overview
- Problem Solved
- Solution
- How It Works
- Benefits
- Use Cases
FlowX.AI 5.3 removes the restriction that prevented importing the same project into multiple workspaces within the same environment. This enables organizations to use workspaces to represent different upper environments (UAT, Staging) for testing and development.
A single project (identified by its UUID) can now exist independently across workspaces, each with its own lifecycle: separate active policies, configurations, and access controls.
Previous Limitations:
Environment testing restrictions
Organizations could not use workspaces on the same FlowX deployment to represent different upper environments for testing (e.g. UAT, Staging)
Operational costs
This feature is intended to allow organizations to use workspace functionality to emulate different environments and reduce operational costs.
What Changed:
Restriction removed
The system now allows importing the same project (identified by UUID) into multiple workspaces within the same environment
Independent lifecycles
Each project instance in different workspaces maintains its own independent lifecycle with separate active policies, configurations, and access controls
Import Behavior:
| Aspect | Behavior |
|---|---|
| Import | Import a project build (and optionally a version) into a different workspace on the same environment |
| Active Policy | The imported build is automatically set as the active policy, regardless of what was active in the original workspace |
| User Access | Workspace users must be granted appropriate project rights (e.g., project viewer) to interact with the imported project |
| Process Instances | Workspace-specific; imported projects start with no instances until processes run in the new workspace |
| Database | Projects across workspaces on the same environment share the same database |
| No Impact on Original | Import does not affect the original project’s settings, policies, information, or process instances |
Only the build itself is transferred during cross-workspace import. Configuration and access controls are defined separately in each workspace.
Flexible testing environments
Use workspaces to represent UAT, Staging, and other test environments on the same deployment
Reduced costs
Eliminate the need for additional deployments and DevOps resources for environment management
Better organization
Organize projects and environments more efficiently with workspace-based separation
Independent control
Maintain separate policies and configurations for each workspace while using the same project
Simplified operations
Streamline deployment and environment management workflows
Faster environment setup
Quickly create new test environments by importing existing projects into new workspaces
Example Scenarios:
- Multi-Environment Testing: Import the same project into UAT and Staging workspaces, each with different test data and configurations
- Development Lifecycle: Maintain development, integration, and pre-production environments as separate workspaces with the same project
- Parallel Testing: Run multiple test scenarios simultaneously by creating separate workspaces for each testing team
- Isolated Training Environments: Create dedicated workspaces for training and demos while keeping production separate
Workspaces Documentation
Complete guide to cross-workspace project import, including import behavior and best practices.
Collection and table actions
Collection and table actions
FlowX.AI 5.3 enables executing actions directly from collection and table rows within UI Flows across Angular and React platforms, providing contextual user interactions within data-driven UI Flow components.UI Flows
Row-level actions
Configure and trigger actions with row context for edit, delete, or start process operations in UI Flows
Cross-platform support
Works in both Angular and React web renderers for UI Flows
Enhanced workflow integration, data model management, and backend performance improvements.🔄 Data mappers for workflow integration - Data mappers for workflow integration
🗄️ Workflow data model - New CRUD endpoints and runtime data model access
🤖 MCP Integration - Connect AI agents with external tools and services through Model Context Protocol servers
🤖 Custom Agent Nodes - Custom Agent nodes for AI agents to use external tools and services 📚 Knowledge Base - Create and manage Knowledge Bases for AI agents with document ingestion and semantic search
🔧 Update process variables - Operations teams can modify process variables on active instances to resolve production issues
🔍 Token view improvements - Enhanced token hierarchy visibility with horizontal scrolling, frozen columns, and context-aware columns
🛡️ Access management enhancements - New operations editor role and granular workspace permissions
⚡ Performance & stability - Backend optimizations, caching improvements, and infrastructure updates
🔀 Exclusive Gateways - Expression testing and validation improvementsIntegration Designer
API Enhancement
AI Integration
AI Integration
AI Integration
Iteration 2 - Enhanced Review:Operations Enhancement
UX Enhancement
Access Management
🗄️ Workflow data model - New CRUD endpoints and runtime data model access
🤖 MCP Integration - Connect AI agents with external tools and services through Model Context Protocol servers
🤖 Custom Agent Nodes - Custom Agent nodes for AI agents to use external tools and services 📚 Knowledge Base - Create and manage Knowledge Bases for AI agents with document ingestion and semantic search
🔧 Update process variables - Operations teams can modify process variables on active instances to resolve production issues
🔍 Token view improvements - Enhanced token hierarchy visibility with horizontal scrolling, frozen columns, and context-aware columns
🛡️ Access management enhancements - New operations editor role and granular workspace permissions
⚡ Performance & stability - Backend optimizations, caching improvements, and infrastructure updates
🔀 Exclusive Gateways - Expression testing and validation improvements
Data mappers for workflow integration
Data mappers for workflow integration
- Overview
- Key Features
- How It Works
- Data Model Management
- Limitations & Compatibility
- Benefits
FlowX.AI 5.3 introduces data mappers that enable integration between processes and Integration Designer workflows. Similar to Process Definitions, you can now define structured data models at the workflow level with input and output parameters, ensuring consistent data lineage across your integration architecture.
Workflow Data Models provide the same structured data management capabilities as Process Data Models, enabling declarative data mapping between workflows and processes with full type safety and validation.
Workflow data model
Define data models at the workflow level with input and output parameters, similar to Process Definitions
Input parameter management
Input parameters automatically pre-fill Start Nodes with structured data from the workflow data model
Data parameters
Use data parameters to define input and output data subsets for workflow operations
Process ↔ workflow mapping
Create data mappers on nodes to receive outputs from workflows and map data bidirectionally
Generic CRUD endpoints
Manage data models, entities, attributes, and data parameters programmatically via REST APIs
Unique node validation
Automatic node name uniqueness validation within workflow definitions to ensure clear data lineage
Define workflow data model
Create a data model for your workflow with entities and attributes, similar to Process Data Models. Define which parameters are inputs and outputs
Configure input parameters
Input parameters automatically pre-fill the Start Node when you open the workflow diagram or test at runtime. No manual JSON editing required
Map process to workflow
When invoking a workflow from a process, create data mappers to map process data to workflow input parameters
New API Capabilities:
- Data Model CRUD: Create, read, update, and delete workflow data models
- Entity Management: Add, modify, and remove entities within data models
- Attribute Management: Define and manage attributes with types and validation rules
- Data Parameters Operations: Create input and output data parameters for workflows
- Usage Tracking: Query references and usages for attributes and entities
- Import/Export: Export and import complete data models across environments
- Centralized data model library for common classes and interfaces
- Generic endpoints for data model and data parameters manipulation
- Integration Designer communicates with Admin service for data model operations
- Automatic input body computation based on data model input parameters
- Runtime workflow start data endpoint for testing and execution
Current Limitations:
- Start Subworkflow Node: Works as-is without data model integration in this release
- Endpoint Schemas: Imported Swagger schemas are not yet integrated with workflow data models (planned for future release)
- Database Schemas: Database operation schemas are not mapped to workflow variables yet (planned for future release)
- Existing workflows continue to work without changes
- End nodes from existing workflows can be renamed manually to align with output parameters
- No breaking changes to current workflow execution
- Node names must be unique within a workflow definition
- System automatically validates uniqueness when renaming nodes
- If duplicate names exist, an index is incremented (e.g., “Transform”, “Transform_2”)
Consistent data lineage
Ensure data consistency across processes and workflows with structured data models
Simplified configuration
Input parameters automatically pre-fill Start Nodes - no manual JSON editing
Type safety
Define data types and validation rules at the workflow level for runtime safety
Reusability
Create reusable workflows with clear input/output contracts that can be invoked from multiple processes
Better testing
Test workflows with structured input data based on the data model
Clear interfaces
Workflow data models document the expected inputs and outputs for each workflow
Workflow Data Models Documentation
Complete guide to creating workflow data models, input/output parameters, process integration, and API reference.
Workflow data model
Workflow data model
- Overview
- Key Features
- Use Cases
FlowX.AI 5.3 adds comprehensive workflow data model management capabilities with new CRUD endpoints and runtime access to data model paths. This enables dynamic data model operations and better runtime introspection.
CRUD endpoints
Create, read, update, and delete workflow data models programmatically via REST APIs
Data model paths
Runtime endpoint for retrieving workflow data model paths and structure information
RUT instance mappings
Enhanced /status and /details endpoints with mappings per workflow instance
Runtime caching
Improved caching for reusable templates to reduce latency and improve performance
Dynamic forms
Build dynamic forms based on data model structure at runtime
Data migration
Automate data model synchronization across environments
Documentation
Generate data model documentation automatically from API responses
Validation
Implement runtime validation based on data model definitions
MCP integration
MCP integration
- Overview
- Key Features
- How It Works
- Authentication
- Use Cases
- Benefits
FlowX.AI 5.3 introduces Model Context Protocol (MCP) integration, enabling AI agents to connect with external MCP servers and use their tools within Custom Agent nodes. MCP provides a standardized protocol for AI agents to access external tools, databases, APIs, and services.
MCP integration extends AI agent capabilities by providing access to external tools through a standardized protocol. Configure MCP servers as data sources in Integration Designer and use their tools in workflows.
MCP data sources
Add MCP servers as data sources in Integration Designer with base URL and authentication configuration
Tool management
View, enable, and turn off specific tools exposed by MCP servers directly from Integration Designer
Custom agent integration
Select MCP servers in Custom Agent nodes to make their tools available to AI agents during workflow execution
Authentication support
Support for no authentication and OAuth 2.0 service account authentication methods
Tool discovery
Automatic tool discovery from MCP servers with schema information for inputs and outputs
Execution monitoring
Track tool usage and execution details in console logs for debugging and monitoring
Add MCP server
Configure an MCP server as a data source in Integration Designer with base URL and authentication details
Authenticate connection
Set up authentication using no authentication (for development) or OAuth 2.0 service account (for production)
Configure custom agent
Add a Custom Agent node to your workflow and select which MCP servers the agent can access
Execute workflow
AI agents can now use MCP tools during workflow execution to interact with external systems
Supported Authentication Methods:None
- No authentication required
- Use for public MCP servers or development environments
- Quick setup for testing and prototyping
- OAuth 2.0 service account authentication
- Required configuration:
- Client ID: OAuth client identifier
- Client Secret: OAuth client secret
- Identity Provider URL: Authorization server endpoint
- Use for production environments
- Secure access to MCP servers
External API integration
Connect AI agents to external APIs and services for data retrieval and action execution
Database operations
Query databases and perform data operations through MCP tools within AI workflows
Custom business logic
Expose custom business logic as MCP tools for AI agents to execute
Multi-system orchestration
Use multiple MCP servers in a single Custom Agent node to orchestrate operations across systems
Standardized integration
Use a standardized protocol for AI agent tool integration across different systems
Extended capabilities
Extend AI agent capabilities with external tools without custom code
Flexible tool management
Enable or turn off specific tools per MCP server based on workflow needs
Secure connections
Support for OAuth 2.0 authentication ensures secure access to external services
Tool reusability
Configure MCP servers once and use their tools across multiple workflows and Custom Agent nodes
Monitoring & debugging
Console logs provide visibility into tool execution for troubleshooting and optimization
MCP Integration Documentation
Complete guide to MCP integration including data source configuration, tool management, and Custom Agent node usage.
Custom Agent nodes
Custom Agent nodes
- Overview
FlowX.AI 5.3 introduces Custom Agent nodes, enabling you to create AI agents with custom capabilities powered by Model Context Protocol (MCP) tools. Custom Agent nodes can interact with external systems, databases, and services through MCP servers, allowing them to perform complex, multi-step operations autonomously within your integration workflows.
Custom Agent Node Documentation
Complete guide to Custom Agent nodes, including configuration, usage, and best practices.
Knowledge base
Knowledge base
- Overview
- Key Features
- How It Works
- Workflow Operations
- Use Cases
- Benefits
- Limitations
FlowX.AI 5.3 introduces Knowledge Base integration, enabling you to create and manage centralized repositories of information that AI agents can query when preparing responses. Upload static documents or ingest dynamic data from workflows into Knowledge Bases that use vector embeddings and semantic search for intelligent information retrieval.
Knowledge Bases enable AI agents to provide contextual, accurate responses based on your organization’s documentation, policies, and dynamic data.
Document upload
Upload PDF documents directly into Knowledge Bases for AI agent access
Workflow ingestion
Ingest data dynamically from workflows using Knowledge Base operations (Append, Replace, Delete)
Semantic search
AI agents find relevant information using natural language queries with vector embeddings
Content sources
Organize content across multiple sources within a Knowledge Base for better management
Relevance scoring
Configure minimum relevance thresholds (0-100%) to control response quality
Testing capabilities
Test queries and operations in isolation before adding them to production workflows
Custom agent integration
Enable Knowledge Base queries in Custom Agent nodes with configurable parameters
Content versioning
Append, replace, or delete content sources with full traceability and state management
Query execution
AI agents query the Knowledge Base using semantic search and receive relevant chunks
Knowledge Base operations available in workflows:
Configuration Options:
| Operation | Description |
|---|---|
| Append | Add new content to an existing content source without removing existing data |
| Replace | Delete all existing content and replace with new content |
| Delete | Remove all content from a content source |
- Knowledge Base: Select from local project libraries or dependencies
- Content Source: Use existing sources, create new ones, or use workflow variables
- Content: Static text, workflow variables, or configuration parameters
Product documentation assistant
Create Knowledge Bases with product documentation for AI agents to answer customer questions
Policy compliance
Upload company policies so AI agents can reference them when processing requests
Dynamic knowledge updates
Ingest data from external systems through workflows to keep AI knowledge current
Multi-source synthesis
Organize information across sources and let AI agents synthesize comprehensive answers
Contextual AI responses
AI agents provide accurate responses based on your organization’s actual documentation
Dynamic updates
Keep AI knowledge current by ingesting data from workflows automatically
Quality control
Relevance scoring ensures only high-quality, relevant information is used
Centralized management
Manage all AI knowledge sources from a single location in Integration Designer
No code integration
Configure Knowledge Base queries directly in Custom Agent nodes without code
Testable
Test queries and see relevance scores before deploying to production
Current Limitations:
- Only PDF documents are supported for manual upload (images, PPT, DOC, XLS support coming in future releases)
- Custom metadata cannot be defined (only system metadata is available)
- AI agents can only use one Knowledge Base per Custom Agent node
- Documents received from integrations cannot be directly ingested (Document Plugin links are treated as strings)
Knowledge Base Documentation
Complete guide to creating Knowledge Bases, ingesting content, and using them in Custom Agent workflows.
Update process variables
Update process variables
- Overview
- Problem Solved
- Key Features
- How It Works
- Permissions & Security
- Data Synchronization
- Important Considerations
- Benefits
- Use Cases
FlowX.AI 5.3 introduces the ability for operations teams to modify process variables on active (Started or On Hold) process instances, providing critical tools to resolve production issues without process restarts. Edit, add, or delete attributes and objects directly using an editor with JSON validation.
Updated values automatically sync to Task Manager and Elasticsearch, ensuring consistency across all systems. Previous values are saved in a snapshot table, and all modifications are tracked in the audit log for complete traceability.
Previous Limitations:
Limited correction tools
Operations teams had minimal tools to correct production issues at the process-instance level
Blocked instances
No way to unblock stuck process instances without backend intervention or process restarts
Data correction challenges
Incorrect process data required complex workarounds or manual database modifications
Operational delays
Production issues required developer intervention, increasing resolution time
Editor
Edit process variables in a JSON editor with syntax validation and formatting
Multiple entry points
Access from Process Instances page contextual menu or Process Instance page secondary navigation
Dual view modes
Switch between Tree View (existing) and JSON View for variable visualization and editing
Full CRUD operations
Edit existing attribute values, add new attributes/objects, or delete existing attributes/objects
JSON validation
Automatic JSON format validation before saving to ensure data integrity
Snapshot history
Previous process variables are saved in a new snapshot table before changes are applied
Auto-sync to Task Manager
Updated variables automatically sync to Task Manager using existing mechanism
Elasticsearch integration
Process variables configured for data search are automatically updated in Elasticsearch
Permission-based access
Role-based access control with process_variables_edit permission ensures only authorized users can modify variables
Export functionality
Export button available near the view dropdown for downloading process variables
Compare feature
Ability to review updated process variables through a compare feature, showing before/after values for better visibility and validation
Accessing the Feature:You can access the edit functionality from two entry points:
- Process Instances Page: Use contextual menu on a process instance row → navigates to Process Instance page and opens Variables tab in edit mode
- Process Instance Page: Use contextual menu in secondary navigation → opens Variables tab in edit mode
Select active instance
Choose an active process instance (Started or On Hold status) that requires variable modification
Switch to JSON view
In the Variables tab, switch from Tree View to JSON View using the view dropdown
Modify in editor
Edit process variables in the JSON editor - you can edit existing values, add new attributes/objects, or delete existing ones
Validate JSON
Ensure your JSON format is valid before saving - the editor will highlight syntax errors
Auto-sync
System automatically syncs updated variables to Task Manager and Elasticsearch (for variables configured for data search)
Permission Requirements:
- New Permission:
process_variables_editavailable at workspace level - Default Roles: Added to
org_admin,workspace_admin,workspace_user,workspace_runtime_editor, andworkspace_operations_editorroles - New Role:
workspace_operations_editor- A dedicated workspace role for operations management including process variable editing and operations (migration & move token)
- Edit option in UI is only visible to users with
process_variables_editpermission - Save functionality is restricted to users with the required permission
- Unauthorized users can view process variables but cannot modify them
- Workspace ID
- Feature: Process variables
- Section: Process Instance
- Application UUID and name
- Subject: Process variables
- Event: Edit
- Subject Identifier: Process instance UUID
- Body: JSON with new version of process parameters
What Gets Updated:What Does NOT Get Updated:
Task Manager
Variables are automatically updated in Task Manager using existing mechanisms - ensures task keywords and data remain consistent
Elasticsearch
Variables configured for data search are automatically updated in Elasticsearch - maintains search accuracy
Process instance params
Primary process instance parameters are updated immediately in the database
Snapshot table
Previous values are saved in a new snapshot table before changes are applied
Process snapshots
Process instance snapshots (used for back navigation/reset) are not updated - maintains historical integrity
Debug table
Process instance debug records remain unchanged - preserves execution history
Existing audit logs
Previously recorded audit logs (manual actions, integrations) are not modified - maintains compliance trail
Subprocess variables
Child subprocess variables are not automatically updated - parent changes don’t cascade to children
Limitations & Best Practices:Best Practices:
Subprocess Impact: When modifying parent process variables after subprocesses have started, child processes retain their original values. Variables are not propagated to existing subprocesses.
Back Navigation: Process snapshots used for “Allow back to this action” with “Reset process data” are not updated. Users navigating back will see original values, not modified ones.
Integration Messages: If a token is waiting for an integration message, the integration was called with original values. Modifying variables after integration calls does not re-trigger integrations.
- Verify JSON Format: Always ensure valid JSON before saving to prevent data corruption
- Document Changes: Use audit logs to track all modifications and maintain operational documentation
- Test in Lower Environments: When possible, test variable modifications in staging before production
- Understand Dependencies: Review process flow and subprocess relationships before modifying variables
- Consider Timing: Best used for stuck processes or data corrections, not for regular operational changes
- Check Search Data: If variables are used in data search, verify Elasticsearch sync completed successfully
Faster issue resolution
Operations teams can resolve production issues immediately without developer intervention
Reduced downtime
Unblock stuck instances quickly, minimizing impact on end users and business processes
Operational independence
Empower ops teams with self-service tools for process-instance management
Data consistency
Automatic sync ensures Task Manager and Elasticsearch reflect updated values
Full traceability
Snapshots and audit logs provide complete history of all modifications for compliance
Reduced risk
Permission-based access and comprehensive audit trail reduce risk of unauthorized changes
Flexible editing
The JSON editor provides powerful JSON editing capabilities with validation
Historical preservation
Original values preserved in snapshot table for rollback scenarios
Common Scenarios:1. Correct User Input Errors
- Customer submitted incorrect data in a loan application (wrong income, invalid address)
- Operations team edits the variables to correct the information
- Process continues without requiring customer to restart the application
- Process is waiting for external data that will never arrive (integration timeout, external system down)
- Ops team updates the variable to provide expected data or skip the condition
- Instance is unblocked and continues execution
- External system returned incorrect or incomplete data
- Operations team corrects process variables to match expected values
- Process continues with accurate data without re-calling the integration
- Critical business information changed after process started (regulatory update, pricing change)
- Ops team modifies variables to reflect current information
- Process continues with updated data without restart
- Process needs additional data that wasn’t collected at start
- Operations team adds new attributes or objects to process variables
- Process can now access the required information
- Process contains incorrect or test data that shouldn’t be there
- Ops team deletes the problematic attributes or objects
- Process continues with clean, valid data only
- Task search keywords need updating based on corrected data
- Variables are modified and automatically synced to Task Manager
- Tasks become searchable with correct keywords
- Process data indexed for search contains errors
- Operations team corrects variables configured for data search
- Elasticsearch automatically updates, ensuring accurate search results
This capability, combined with the upcoming Move Token feature, provides comprehensive process-instance management tools for operations teams.
Update Process Variables Documentation
Complete guide including step-by-step instructions, permissions, data synchronization, best practices, and troubleshooting.
Token view improvements
Token view improvements
- Overview
- Key Features
- Table Columns
- Nesting Behavior
- Benefits
- Use Cases
FlowX.AI 5.3 enhances the Tokens tab in the Process Instance View with improved visibility and comprehension of token hierarchy and context. The enhanced token view introduces horizontal scrolling, frozen columns, hierarchical nesting, and new context-related columns to provide better insights into process execution.
These improvements make it easier to understand complex process flows with parallel gateways, embedded subprocesses, and boundary events by clearly displaying token relationships and execution context.
Horizontal scrolling
The table supports horizontal scrolling to accommodate all columns, ensuring all token information remains accessible
Frozen columns
Token UUID and Actions columns remain fixed during horizontal scroll for constant visibility of key identifiers and actions
Hierarchical nesting
Tokens display in a tree structure with nested child tokens under parent tokens, showing clear parent-child relationships
Auto-expanded rows
All token rows are expanded by default, providing immediate visibility into the complete token hierarchy
Dynamic indentation
Indentation dynamically adjusts based on nesting depth, visually representing token relationships
Context column
New Context column displays subprocess names for tokens running within embedded subprocesses, or main process name for main process tokens
Initiator node column
New Initiator Node column shows the node name that generated the token (e.g., Parallel Gateway, Non-interrupting boundary event)
First executed node column
New First Executed Node column displays the first node executed after token generation
UUID copy functionality
Token UUID displays first 6 characters with a copy icon; clicking copies the full UUID to clipboard with success notification
Color-coded status tags
Token Status column uses color-coded tags for quick visual identification of token lifecycle states
Tooltip support
Long node names are truncated with tooltips showing full text on hover for better readability
Timezone-aware timestamps
Last Updated column displays full datetime in browser timezone for accurate local time representation
The enhanced token view includes the following columns:
| Column | Description | Special Behavior |
|---|---|---|
| Token UUID | Unique identifier of the token | Only first 6 characters displayed. Copy icon appears beside UUID. Clicking copies full UUID to clipboard with success toast: “Full Token UUID copied to clipboard.” Frozen column (stays visible during horizontal scroll) |
| Context | Displays contextual data for token | Shows main process name for tokens in main process. Shows embedded subprocess name for tokens in embedded subprocesses (any nesting level) |
| Initiator Node | Shows the node name that generated the token | Applies to child tokens only. For parent tokens, displays ”-”. Examples: Parallel Gateway name, Non-interrupting boundary event name |
| First Executed Node | Displays the first node executed after token generation | For parallel gateway tokens: first executed node on that parallel branch. For boundary event tokens: first executed node on branch started from boundary node. If first node is embedded subprocess, displays embedded subprocess name |
| Current Node | Displays the last node executed within the token branch | For parallel gateway tokens: last node on branch. For boundary event tokens: last node executed on branch triggered by boundary. For tokens in embedded subprocess: displays current node from subprocess |
| Current Node Status | Shows the current execution status | Examples: WAITING_TIMER_EVENT, ARRIVED, EXECUTING, EXECUTED_COMPLETE, EXECUTED_PARTIAL. Sortable column |
| Token Status | Indicates lifecycle state | Values: ACTIVE, INACTIVE, ABORTED, ON HOLD, DISMISSED, EXPIRED, TERMINATED. Color-coded tags for visual identification |
| Last Updated | Timestamp of latest token state change | Displays full datetime in browser timezone |
| Actions | Available actions for the token | Includes Retry token and View (eye icon) actions. Frozen column (stays visible during horizontal scroll). Retry button only visible for ACTIVE tokens |
Token Hierarchy Display:Initiator Node Logic:
Parent-child relationships
Tokens created by parallel gateways or embedded subprocesses are displayed as nested child tokens under their parent tokens
Default expansion
All token rows are expanded by default, showing the complete token hierarchy immediately
Dynamic indentation
Indentation adjusts automatically based on nesting depth, with columns expanding accordingly to maintain alignment
- Parent tokens: Display ”-” in Initiator Node column
- Child tokens from parallel gateway: Display the parallel gateway node name
- Child tokens from boundary event: Display the boundary event node name
- Child tokens from back in steps: Display appropriate initiator information
Better visibility
Horizontal scrolling and frozen columns ensure all token information remains accessible regardless of table width
Clear hierarchy
Hierarchical nesting with dynamic indentation makes parent-child token relationships immediately clear
Context awareness
Context column provides immediate visibility into which subprocess a token is executing within
Execution tracking
Initiator Node and First Executed Node columns help track token origin and execution path
Quick actions
Frozen Actions column ensures retry and view actions are always accessible without scrolling
Easy UUID access
Quick copy functionality for full UUIDs without needing to view token details
Visual status identification
Color-coded status tags enable quick identification of token states at a glance
Improved readability
Tooltips for truncated names and timezone-aware timestamps improve overall readability
Common Scenarios:1. Parallel Gateway Debugging
- View all parallel branches simultaneously with clear parent-child relationships
- Identify which branch each token belongs to through hierarchical nesting
- Track execution progress across multiple parallel paths
- Context column immediately shows which subprocess tokens are executing within
- Understand nested subprocess relationships through indentation
- Track token flow across multiple subprocess levels
- Initiator Node column shows which boundary event triggered each token
- First Executed Node shows the execution path started by boundary events
- Monitor non-interrupting boundary event token execution
- Frozen UUID column ensures token identification is always visible
- Copy UUID functionality enables quick token reference in support tickets
- Color-coded status tags help identify problematic tokens quickly
- Hierarchical view supports complex processes with multiple nesting levels
- Dynamic indentation adapts to any nesting depth
- All tokens visible by default without manual expansion
Token Documentation
Complete guide to tokens, including token status values, current node status, and detailed token status view.
Access management enhancements
Access management enhancements
- Overview
- New Role
- New Permissions
- Benefits
FlowX.AI 5.3 introduces new workspace-level permissions and a dedicated operations editor role, providing more granular control over process instance management and operations.
These enhancements enable organizations to delegate operational tasks to dedicated teams without granting full runtime or admin access.
workspace_operations_editorA new predefined workspace role designed for operations teams who need to manage process instances without requiring full runtime or admin capabilities.Role Constraints:
Operations management
Full CRUD access for process instance operations including migration and move token functionality
Process variables
Edit permission for process variables on active instances across the workspace
Process instances
Read and edit access to all process instances in the workspace
Workspace user inheritance
Inherits all base permissions from workspace_user role including project creation
- Cannot be edited or deleted (predefined role)
- Extends workspace_user with operations-specific permissions
- Does not include broader runtime capabilities (builds, policies, scheduled processes)
- Support engineers managing process migrations
- Operations teams handling token movements
- Technical support staff editing process variables
Workspace-Level Permissions:
Project-Level Permissions:
| Permission | Description | Roles with Access |
|---|---|---|
| Operations (Read/Edit/Create/Delete) | Manage process instance operations including migration and move token | org_admin, workspace_admin, workspace_runtime_editor, workspace_operations_editor |
| Operations (Read/Create only) | Create operations and view all operations | workspace_user |
| Process Variables (Edit) | Edit process variables on active instances | org_admin, workspace_admin, workspace_user, workspace_runtime_editor, workspace_operations_editor |
| Process Instances (Edit) | Edit process instance data | org_admin, workspace_admin, workspace_user, workspace_runtime_editor, workspace_operations_editor |
| Permission | Description | Roles with Access |
|---|---|---|
| UI Flows (Read/Edit/Create/Delete) | Full access to create and manage UI Flows | project_owner, project_editor |
| UI Flows (Read only) | View UI Flows definitions | project_viewer |
Principle of least privilege
Grant only the permissions needed for specific operational tasks
Dedicated operations teams
Enable operations teams to work independently without full admin access
Clear separation of concerns
Distinguish between runtime management (builds, policies) and operations management (migrations, variables)
Flexible role combinations
Combine with other workspace roles for customized access patterns
Access Management Documentation
Complete permissions matrix and role specifications for all FlowX roles.
Performance and stability
Performance and stability
FlowX.AI 5.3 includes platform improvements focused on performance, reliability, and operational excellence.Platform Updates
Backend optimizations
Optimistic lock improvements
Replace retry pattern with capped exponential backoff and infinite retries for better concurrency handling
Events gateway optimization
Update Redis read mode to XREAD BLOCK for more efficient event streaming
Database performance
Remove unnecessary index on token_instance.current_node_id to improve update performance
Template caching
Enhanced caching for reusable templates at runtime reduces latency and improves throughput
Infrastructure updates
Connector Topic Pattern
Added dedicated KAFKA_CONNECTORS_TOPIC_PATTERN variable for connectors, allowing custom topic patterns without breaking other components like document-plugin, data-search, and cms-core
SpiceDB backup
Documented backup and restore procedures for SpiceDB for disaster recovery
Observability
Publish Prometheus and OpenTelemetry Helm charts and container images to Harbor
Security updates
Fix HIGH vulnerabilities in Designer 5.1.x and main branch
Renderer improvements
Enhanced Angular renderer with action form submit functionality and substitution tag support
Exclusive gateways
Exclusive gateways
FlowX.AI 5.3 enhances Exclusive Gateway configuration with expression testing capabilities and improved validation.Process Logic
Expression testing
Test gateway expressions directly from the configuration panel with real-time validation
Committed version testing
Test business rules and gateway expressions in committed versions
Code editor integration
Enhanced code editor with syntax highlighting for complex expressions
Payload synchronization
Test payloads automatically update when rules are saved
Comprehensive bug fixes and stability improvements across Designer, renderers, backend services, and data management.🎨 Designer Fixes - UI Designer and Integration Designer stability improvements
🖥️ Renderer Fixes - Cross-platform renderer bug fixes for web, iOS, and Android
⚙️ Backend Fixes - Backend stability and performance improvements
🗄️ Data & Integration Fixes - Data mapper and workflow integration fixes
🖥️ Renderer Fixes - Cross-platform renderer bug fixes for web, iOS, and Android
⚙️ Backend Fixes - Backend stability and performance improvements
🗄️ Data & Integration Fixes - Data mapper and workflow integration fixes
Designer fixes
Designer fixes
FlowX.AI 5.3 resolves numerous Designer issues to improve stability and user experience.
Designer Stability
UI designer improvements
Configuration & styling
Configuration & styling
- Fixed styles not applied after undo/redo in Reusable UI Template config panel
- Fixed UI blocking when slider min value exceeds max value
- Fixed warning icon display in config panel
- Fixed expression test modal styles when opened in resized screen
- Fixed UI action section refresh when selecting different UI template
- Fixed UI action section rendering after clicking ‘Add new ui action’
File upload component
File upload component
- Fixed loading spinner toggle not available for Overlay loading behavior
- Fixed incomplete loading behavior dropdown
- Fixed default messages not displayed after undo
- Fixed forms in collections handling for patch actions requests
UI Flows designer
UI Flows designer
- Fixed task management error state when view is selected
- Fixed tab content preview showing content from 2 tabs when adding new tab
Output parameters
Output parameters
- Fixed currency key management - can now add/remove currency key in output params
Exclusive Gateways
Exclusive Gateways
- Fixed gateway decisions can now be modified after initial save
- Fixed test payload updates when rules are saved
- Fixed expression propagation to test modal
Frontend runtime fixes
Process management
Process management
- Fixed context column showing empty value for tokens in embedded subprocesses
- Fixed process params update from running process instance modal
- Fixed long node names overlapping adjacent columns in Tokens table
- Fixed workspace redirect on page refresh
Audit & logging
Audit & logging
- Fixed audit log subject value not displayed for process params updates
- Fixed toast error messages to use text from backend request
- Added documentation link to Modify Variables modal info text
Renderer fixes
Renderer fixes
FlowX.AI 5.3 includes comprehensive renderer fixes across all platforms.
Renderer Stability
Web renderers (Angular & React)
File upload component
File upload component
- Fixed theming not applied to general loader
- Fixed theming not applied to toast messages
- Fixed dynamic key values not displayed in toast/loading messages
- Fixed success toast displayed when flag is false
Card & navigation
Card & navigation
- Fixed card not expandable after finishing subprocess started from it (Angular & React)
- Fixed card collapse when next nav area is modal (Angular & React)
- Fixed subprocess navigation closing parent process navigation with multiple hierarchies
UI events
UI events
- Fixed UI event triggering without user interaction (Angular)
Call activity
Call activity
- Fixed call activity UT rendering when started from embedded process
Collections & forms
Collections & forms
- Fixed button with forms to submit no longer disabled until template edited (Angular & React)
- Fixed multi-select search filtering (React)
- Fixed JSON generation with special characters in CollectionsV2
Mobile renderers
Android
Android
- Fixed SSE Event & UI Event - UI event value displayed instead of SSE value
Backend fixes
Backend fixes
Backend stability and performance improvements across core services.
Backend Stability
Process management
Process & build issues
Process & build issues
- Fixed processes not displayed in container app list for imported builds
- Fixed token state changing from Aborted to Active during back navigation
- Fixed audit logs for override operations after merge
Performance
Performance
- Fixed /details endpoint returning cache error for processes with many components
Process engine
Process engine
- Fixed token stuck in receive node when message received after advancing
- Fixed action params copied correctly for child actions when copying node
- Fixed metadata preservation when importing process
Security & configuration
Authentication
Authentication
- Fixed service account client secret configuration parameter in Authorization service
Data management
Runtime issues
Runtime issues
- Fixed FlowxProps.events mapping at runtime for array of objects
Infrastructure
Database & events
Database & events
- Fixed advancing errors in partition event table
- Fixed Liquibase logging when crashing due to lock
Data and integration fixes
Data and integration fixes
Fixes for data mappers and workflow integration features.
Integration Stability
Data mapper issues
Mapping operations
Mapping operations
- Fixed 400 error when saving mappings
- Fixed error when saving mapping with empty parameters
- Fixed unsaved mapping modal displayed when saving action
- Fixed array mapping - arrays in mapper functions now work correctly
- Fixed slice deletion when updating PDM objects
Data streams & workflows
Data streams & workflows
- Fixed data stream availability for older exports during import
- Fixed workflow data stream data appending issue
- Fixed legacy mapping toggle now triggers correctly for call activity
UI updates
UI updates
- Fixed start node not updated in UI after parameters update until refresh
- Fixed manifest resource not found after switching versions
Data mapper fixes ensure reliable workflow integration and process-to-workflow data synchronization.
Additional information
Deployment information
For detailed deployment guidelines, component versions, and upgrade instructions, see the Deployment Guidelines v5.3.0.
Environment variable updates
For detailed information on environment variable changes, see the Update environment variables section.
Breaking changes
FlowX Engine Configuration: v5.3.0 includes a breaking change to the partitioning and archiving configuration structure. If you have enabled data partitioning, you must update your configuration files.
Migration guide
Complete migration guide with step-by-step instructions, configuration examples, and troubleshooting
Compatibility
Upgrade path
Upgrade from v5.2.0 requires configuration changes for FlowX Engine partitioning/archiving
Component compatibility
Compatible with FlowX.AI SDKs (Angular/React/iOS/Android), Designer, and Database 5.3