Skip to main content

Overview

FlowX.AI uses multiple specialized data stores, each chosen for specific workload characteristics. They fall into two categories:
  • Embedded data components — shipped with the platform, managed by FlowX.AI
  • Platform data services — third-party dependencies deployed by your team

Embedded data components

Embedded data components are delivered as part of the FlowX.AI platform (Docker images + Helm charts). They run on Kubernetes only, and their versioning is managed by FlowX.AI. These components are included in the standard deployment and cannot be replaced by alternative implementations.

Dgraph

Type: Distributed graph databaseDgraph is used by AI Platform services where relationship-centric data models and graph traversal are required. It stores AI agent state, knowledge graphs, and supports multi-agent collaboration.

Platform data services

The following data services are required by the FlowX.AI platform but are third-party dependencies. You choose the deployment model — managed service or self-hosted, inside or outside the Kubernetes cluster — according to your enterprise standards. FlowX.AI connects to these services via configuration.For supported versions and compatibility details, see the Third-party components compatibility matrix.

Relational storage — PostgreSQL

PostgreSQL is the primary relational database and system-of-record for most core services. It stores:
  • Process definitions and metadata
  • Runtime instance state
  • Platform configuration
  • Administrative data
Most FlowX.AI microservices use PostgreSQL as their authoritative storage layer.

Document storage — MongoDB

MongoDB provides document-oriented storage for unstructured and semi-structured content. It stores:
  • Runtime configuration
  • Runtime workflow state
  • Flexible data structures used by apps and integrations
MongoDB is also the storage layer for FlowX Database — a cross-instance, long-term storage feature that enables apps to persist and query data beyond a single process instance.

Caching — Redis

Redis is an in-memory cache used for performance optimization across the platform. It stores:
  • Cached process definitions
  • Compiled scripts
  • Transient session data
  • Distributed locks across microservices
Redis is used strictly for short-lived, performance-related data and is not a system-of-record. Long-term persistence is handled by PostgreSQL and MongoDB.

Event streaming — Kafka

Kafka is the event streaming backbone that enables asynchronous, event-driven communication between microservices. It handles:
  • Internal event propagation between platform services
  • External integration messaging
  • Decoupled processing workflows
Kafka is used for transient message propagation. Authoritative business data is persisted in PostgreSQL and MongoDB, not in Kafka.

Object storage — S3-compatible

S3-compatible object storage provides persistent file storage. It stores:
  • File attachments
  • Document outputs (generated PDFs, converted files)
  • Large binary assets
FlowX.AI accesses object storage via an S3-compatible interface.
For providers without native S3 support (such as Azure Blob Storage), an S3 proxy is required to expose an S3-compatible interface. If you use a native S3 service (like AWS S3), no proxy is needed.

Search and indexing — Elasticsearch

Elasticsearch is used primarily for audit logging and full-text search across workflow and runtime data. It stores:
  • Searchable representations of audit events
  • Platform activity logs
  • Indexed workflow data for fast retrieval
Elasticsearch is optimized for fast search and traceability rather than primary data storage.

Quick reference

Data StoreRoleWhat it storesPersistence
PostgreSQLSystem of recordProcess definitions, config, metadata, instance statePermanent
MongoDBDocument storeRuntime state, flexible data, FlowX DatabasePermanent
RedisCacheProcess definitions cache, sessions, locksTransient
KafkaEvent streamingInter-service messages, integration eventsTransient
Object StorageFile storeAttachments, documents, binary assetsPermanent
ElasticsearchSearch engineAudit logs, indexed workflow dataPermanent
DgraphGraph database (AI)AI agent state, knowledge graphsPermanent

Service-level database mapping

The tables and diagrams below show which FlowX.AI services connect to which databases and what operations they perform. This is useful for infrastructure sizing, backup planning, and troubleshooting.

PostgreSQL databases

Each core service owns its own PostgreSQL database and manages its schema through Liquibase migrations at startup.
ServiceDatabaseOperations
AdminflowxadminCreates, reads, writes
Advancing ControlleradvancingCreates, reads, writes
Application Managerapp_managerCreates, reads, writes
Authorization Systemauth_systemCreates, reads, writes
Document PlugindocumentCreates, reads, writes
Email Gatewayemail_gatewayCreates, reads, writes
LicenselicenseCreates, reads, writes
Organization Managerorg_managerCreates, reads, writes
Process Engineprocess_engineCreates, reads, writes
Task Managementprocess_engineReads, writes
Task Management shares the process_engine database with Process Engine. Data Sync acts as a centralized migration coordinator for app_manager, auth_system, and process_engine.

MongoDB databases

Each service manages its own MongoDB database. The app-runtime database is a shared read-only dependency for multiple services.
ServiceDatabaseOperations
Admindata-modelCreates, reads, writes
Application Managerapp-runtimeCreates, reads, writes
CMS Corecms-coreCreates, reads, writes
Document PlugindocumentCreates, reads, writes
Document Pluginapp-runtimeReads
Integration Designerintegration-designerCreates, reads, writes
Integration Designerapp-runtimeReads
Notification PluginnotificationCreates, reads, writes
Notification Pluginapp-runtimeReads
SchedulernotificationCreates, reads, writes
Task Managementtask-management-pluginCreates, reads, writes
Task Managementapp-runtimeReads
Process Engineapp-runtimeReads
Email Gatewayapp-runtimeReads
NoSQL DB Runnernosql-db-runnerCreates, reads, writes
The app-runtime database is created by Application Manager and read by 6 other services. It contains runtime configuration, build data, and deployed app state. Availability of this database is critical for runtime operations.

Elasticsearch indexes

ServiceIndexOperations
Audit CoreAudit indexCreates, reads, writes
Process EngineProcess instance indexCreates, reads, writes
Data SearchProcess instance indexReads

Redis

All core services use Redis for caching only via Spring Cache Manager. Events Gateway additionally uses Redis for pub/sub messaging. Services using Redis for caching: Admin, Application Manager, Authorization System, CMS Core, Document Plugin, Email Gateway, Integration Designer, License, Notification Plugin, Organization Manager, Process Engine, Task Management.
ServiceUsage
Events GatewayCache, pub/sub

S3-compatible object storage buckets

Bucket names shown are defaults from the configuration and are configurable via environment variables (e.g., MINIO_BUCKET_PREFIX). Your deployment may use different names. In some deployments, multiple services may share the same bucket. Ensure cross-bucket read access is configured where needed.
ServiceDefault BucketEnv VariablePurpose
Application Managerapplications-bucketApp builds and exported/imported resources
CMS Coremedia-library-bucketPublic media assets
CMS Corecms-private-storage-bucketPrivate theme and font files
Document Pluginflowx-dev-bucketMINIO_BUCKET_PREFIXDocument templates and generated files
Document Plugintemp-bucketMINIO_TEMP_BUCKETTemporary processing files
Integration Designerworkflows-bucketWorkflow definitions and test files
Notification Pluginflowx-devMINIO_BUCKET_PREFIXNotification templates and attachments

Last modified on February 13, 2026