Essential Knowledge

503 Items

Getting Started Configuring Fluent OMS (webapps)

Essential knowledgeThe Fluent OMS module is pre-configured with certain standard functions that allow the interface to manage orders, product availability, inventory, and order fulfilment and serve as a starting point for your projects.The default UX templates are hosted on the platform, so there is no need to create the manifest settings yourself unless you need to customize the existing baseline configuration.

Fluent Connect SDK Architecture

Essential knowledgeThis article will cover the high-level design and features of the SDK.

Salesforce Connectors Overview

Essential knowledgeFluent Commerce offers a scalable cloud platform with Distributed Order Management functionality. This functionality includes support for Click and Collect, Ship from Store, Omnichannel Returns, and a Single View of Inventory across all locations. The Salesforce connectors enable integration between Salesforce Commerce Cloud (SFCC)storefront, Salesforce Service Cloud (SFSC) customer service application, and Fluent Order Management.

About Reference And Extension Modules

Essential knowledgeModules are the package structure used by Fluent Commerce to ship preconfigured features and functions. They are designed to be self-describing, isolated, but inter-dependent assets that can work together with other modules, or be extended by custom modules, all while remaining upgradeable.Here we'll look at the different designations of Modules and describe the Module's Package Structure and Project Structure.

Accessing the Workflow Builder

Essential knowledgeAccessing the Workflow Builder

Account Settings

Essential knowledgeThis article contains the list of Settings used in the context of ACCOUNT.

Activate Sourcing Profile

Essential knowledgeThe `activateSourcingProfile` mutation activates a specific version of a Sourcing Profile. When called, it performs the following actions:

Sets the specified version status to `ACTIVE`
Updates the previously `ACTIVE` version to `INACTIVE`

Workflow Naming Convention

Essential knowledgeThe Workflow Naming Convention is a set of guidelines recommended for Orchestrated Entity Types in the Fluent Order Management System. This convention will help you:

Apply best practices for naming entities to achieve better implementation standards;
Make names consistent and ensure that names are recognisable and can be supported in the future;
Avoid unexpected system behaviour and decrease the likelihood of error because of incorrect symbol or space usage.

Adding a Workflow to your Retailer via API

Essential knowledgethis page is to show how to add a new workflow to your Retailer via the API Put method.

Additional Terms for EU Data Act (v1.0)

Essential knowledgeThe EU Data Act Addendum only applies to Clients that are from an EU country. The Addendum sets out the rights and obligations of both the Client and Fluent Commerce to reflect, and in compliance with, the switching requirements of the EU Data Act.

Additional Terms for Fluent Connect (v1.0)

Essential knowledgeThe Additional Terms for Fluent Connect apply to and govern use of Fluent Connect and all Hosted Connectors (including Connect Inventory) and are incorporated into the MSA entered into between the Client and Fluent Commerce.

Analytics: Roles & Permissions

Essential knowledgeAccess to Fluent Analytics is controlled through a combination of permissions and role-based access control (RBAC). This document defines the permission model, role requirements, and configuration patterns for access to Fluent Analytics.Access to Fluent Analytics is controlled through a two-layer model: users must be assigned a role that

has the `ANALYTICS_VIEW` permission AND
is listed in the Analytics Query definition.

Analytics Query Settings

Essential knowledgeAnalytics Queries are configured through settings that map query names to analytics resources in the Fluent Analytics backend services. Each setting follows the pattern `fc.analytics.queries.{domain}` and defines available queries, their resource locations, access permissions, and optional default parameters. Use this document to:

Understand query setting structure and naming conventions
Configure new analytics queries
Set default parameters for queries
Control query access through role-based permissions

Analytics Query Structure

Essential knowledgeThis document defines the structure and syntax for querying the Fluent Analytics backend services. Analytics Queries reference pre-configured metrics by name (called "targets"), rather than defining individual fields like standard GraphQL queries. Targets provide controlled access to analytics metrics with built-in role-based permissions. Use this document to:

Understand and construct analytics GraphQL queries
Understand target name format and how it links to query settings
Configure filter parameters to refine query results
Integrate analytics into dashboards and web applications

GraphQL (GQL) Mutations

Essential knowledgeMutations in GraphQL are operations designed to modify server-side data, encompassing the creation, updating, or deletion of records. They play a critical role in dynamic data management within GraphQL applications, allowing for precise and controlled data manipulation.

GraphQL Queries

Essential knowledgeQuery operations are used for retrieving data. Fluent's GraphQL API provides two types of query operations:

`Get`: To retrieve and display unique results
`Search`: To search and display a list of results

APIs Overview

Essential knowledgeFluent provides both REST and GraphQL APIs. However, REST APIs are limited to specific Platform operations, while the GraphQL API provides the core Domain Model.

Article REST API (Deprecated)

Essential knowledgeAn Article can be created when a fulfillment is fulfilled, or when a dispatch occurs. The Article represents the physical parcel that contains the customer order items. The Article is the entity received by the customer.

API Authentication

Essential knowledgeAPIs use authorization to ensure that client requests access data securely. This involves authenticating the sender of a request and verifying that they have permission to access or manipulate the relevant data. The authentication request returns a bearer token that can be used in subsequent API calls to confirm authentication.This guide covers the complete OAuth 2.0 authentication flow, including credential management, token lifecycle, and security best practices for production environments.

SSO Authentication Policies Configuration

Essential knowledgeAuthentication policies dictate how the user's identity will be verified. For Corporate IdP all users are managed by corporate IdP and authentication policy needs to be configured to make sure that all users are authenticated via internal IdP.

Authentication Token Expiry

Essential knowledgeToken authentication is mandatory for all Fluent integrations.

Availability - How it Works

Essential knowledgeAvailability Module provides various availability information for different products, taking into account custom attributes defined in a business workflow. Utilising the Fulfillment Options Workflow, the Availability Module generates Fulfillment Plans for the requested items. This process involves interaction with the Inventory module and applying sourcing logic to select plans from a designated Virtual Catalog for the relevant channel.

Availability Interface

Essential knowledgeThe Availability interface provides visibility into fulfilment options generated by the system when evaluating how an order can be completed. Availability ensures that orders are processed in line with business rules, inventory availability, and delivery or collection methods.The interface contains one submenu: Fulfilment Options. This section provides access to all generated fulfilment options and their related fulfilment plans.

Available-to-Sell (ATS) and Available-to-Promise (ATP)

Essential knowledgeThe Availability Module facilitates the presentation of Available-to-Sell (ATS) and Available-to-Promise (ATP) data on the Product Detail Page (PDP), Product Listing Page (PLP), and Checkout pages within an e-commerce platform, for instance.

Average Fulfillment Time Metric

Essential knowledgeLearn about the Average Fulfillment Time Metric in Fluent Analytics

Average Order Items Metric

Essential knowledgeLearn about the Average Order Items Metric in Fluent Analytics

Average Order Value Metric

Essential knowledgeLearn about the Average Order Value Metric in Fluent Analytics

Average Orders by Hour of Day Metric

Essential knowledgeLearn about the Average Orders by Hour of Day Metric in Fluent Analytics

Average Return Order Items Metric

Essential knowledgeLearn about the Average Return Order Items Metric in Fluent Analytics

Average Return Order Value Metric

Essential knowledgeLearn about the Average Return Order Value Metric in Fluent Analytics

Batch API (Deprecated)

Essential knowledgeA batch contains a series of records that will have the same operation applied to it. All Batches are run asynchronously so to confirm success or failure the client must request a status update for submitted batches via the GET API at a later stage. Most Batches are limited to 5,000 records.To create a Batch, the user must first create a Job. A Job is required to store a series of batches. For more information please refer to the Job API.

Inventory Batch Pre-Processing

Essential knowledgeThis page describes how Inventory Batch Pre-Processing (BPP) works, the opportunities available for configuration, and the implementation improvements enabled by using Inventory Batch Pre-Processing.

Inventory Batch Pre-Processing: Technical Guide with Examples

Essential knowledgeThis page describes how Inventory Batch Pre-Processing (BPP) works and what technical aspects need to be considered as part of an implementation.

billingAccount graphQL query and mutation

Essential knowledgeThe `billingAccount` is an entity used for linking customer entities with `payment`, `creditMemo` and `invoice`.

Product Description - Fluent Commerce OMS [Superseded - Document Version 1.0]

Essential knowledgeFluent Order Management components are Web Apps, Modules, Order Management Experience (OMX), Orchestration Engine, and Cloud Infrastructure. These components operate within the framework to enable the order management experience on the platform.

Cancellation Rate Metric

Essential knowledgeLearn about the Cancellation Rate Metric in Fluent Analytics

Category Batch API

Essential knowledgeThe Category Batch API is used to create a Category using the Fluent Commerce Batch framework.

Webhook Receivers

Essential knowledgeAn overview of how webhooks work in Fluent Commerce, how they are signed, and validated, and what public keys are used.

Comment API

Essential knowledgeA Comment provides an additional piece of information to the entity it is related to. An Order and Return can contain multiple comments associated with it.

Comment GraphQL API Overview

Essential knowledgeThe Comment GraphQL API allows customers to manage Comments across various Entities.Multiple Comments can be added against the same Entity, with each Comment automatically capturing:

The timestamp
The User who created it (`USER_VIEW` Permission is required to access the User data)

This feature allows Users to record specific business actions and events, providing a comprehensive history of interactions and updates.

commercetools CloudFormation Template

Essential knowledgecommercetools CloudFormation Template

commercetools Connector Extend (Customisation) Guidelines

Essential knowledgeThis article explains how to extend and customize the commercetools Connector. Readers will learn about package structure requirements (all custom code must be under `com.fluentcommerce.connect`), how to implement message handlers for processing queue messages, create job handlers for polling external systems, set up configuration handlers that react to settings changes, and receive external messages via HTTP or listeners (SQS/Kafka). The guide also covers error handling strategies, handler priority/override mechanisms, and routing configuration essentials.

commercetools Connector Project Configuration

Essential knowledgecommercetools Connector Project Configuration

commercetools prerequisites

Essential knowledgecommercetools connector enables the syncing between commercetools and the Fluent commerce system. There are specific settings that need to be configured in the commercetools system i.e.: custom fields, channels, etc.

commercetools Product Sync Overview

Essential knowledgeThe product synchronization process involves the handling of events and messages through various queues and handlers. It utilizes the commercetools platform for product updates, employs a message router to direct events, and features extensible message handlers for customization.

UX Configuration - Common Concepts

Essential knowledgeSome common types and conventions are used across many component definitions. These items are not directly configurable in the manifest but will often be referenced in other component definitions that use them.

Component SDK - Getting Started

Essential knowledgeGetting Started Guide for Component SDK

Platform Limit Definitions (v1.4)

Essential knowledgeThis document sets out the definitions for the terminology used in the Platform Limits document some of which is also used in your contractual agreement documents (e.g. Order Form) with Fluent Commerce. For definitions of other essential terminology, visit the Glossary of Key Terms and Product Taxonomy pages.

Connector Deployment Cloudformation

Essential knowledgeAttached to this page is the “connectors.yaml” template which is used to create Cloudformation Stack for the Connectors API. The resulting stack deploys ECS Fargate containers that run the API and produce a public endpoint. This public endpoint is secured with an SSL certificate which is applied to the Application Load Balancer.

Consignment API

Essential knowledgeThe Consignment API is responsible for retrieving and updating the status of fulfilment's managed through the Fluent Retail platform. Users can also add consignment details to articles on fulfilment's booked outside of the platform through the Consignment API.

Control Groups and Controls Management

Essential knowledgeRules or controls that determine what inventory is available in a Virtual CatalogControls can be used to:

Exclude SKUs or product categories from a virtual catalog
Manage buffer or safety stock by SKU, Category and/or Location

Core Google Cloud Platform (GCP) Components Supporting Fluent Commerce

Essential knowledgeFluent integrates key Google Cloud Platform (GCP) services to enhance scalability, performance, and security across its infrastructure. By leveraging Compute & Serverless, Data & Storage, Networking & Delivery, and Security & Compliance solutions, Fluent ensures a reliable and efficient cloud environment.

Core Utilities Overview

Essential knowledgeThe Core Utility (`util-core`) is a standard library of utility functions designed to simplify and accelerate Rule development on the Fluent Commerce platform. It provides a foundational set of helper classes that address common development challenges - such as safely handling event attributes, retrieving and converting settings, logging consistently, and minimizing boilerplate code when forwarding events or querying data.PrerequisitesThese articles assumes you're familiar with:

Java
Maven
JUnit

Create Comment

Essential knowledgeThe `createComment` Mutation allows the creation of a Comment against a known Entity.
PrerequisitesSpecific Permissions are required for creating Comments:

`COMMENT_CREATE`
`COMMENT_VIEW`

Query Create and Update Customer via GraphQL

Essential knowledgeA best practice guide of creating customer entity.

Create multi order payload example

Essential knowledge

Example createOrder mutation payload for MULTI order type

Create or Update Sourcing Profile

Essential knowledgeThe `createSourcingProfile` mutation creates a Sourcing Profile (or its newer version, i.e., updates) for a Retailer:

If the provided `ref` is unique, it creates the first version with `ACTIVE` status
If a `SourcingProfile` with the same `ref` already exists, it creates a new version with `DRAFT` status

createFinancialTransaction GraphQL mutation Example

Essential knowledgecreateFinancialTransaction GraphQL mutation Example

commercetools connector - Credential/Secret Configuration

Essential knowledgeAt this stage the only implementation available is AWS Secrets Manager by the `connect-sdk-core-aws` module.

Customer Journeys for Home Delivery (HD) and Click and Collect (CC)

Essential knowledgeThis article illustrates the order journeys for Home Delivery (HD) and Click and Collect (CC) order types.

Customer Reference Program

Essential knowledgeRewarding way for customers to share their achievements.

Data Privacy Addendum (v1.1)

Essential knowledgeThis Data Privacy Addendum (DPA) details the data protection commitments and obligations of Fluent Commerce in relation to its Fluent Order Management cloud-based platform and services. Readers will find detailed information on the processing, transfer, and security of personal data by Fluent Commerce as data processor, and serves as a guide for clients to understand how their personal data is managed and protected.

Data Privacy Addendum (v1.0) [Superseded]

Deprecation Policy (v2.0)

Essential knowledgeThis document provides a comprehensive overview of our deprecation policy, detailing the lifecycle and end-of-life processes across our Platform components.

Deprecation Policy (v1.0) [Superseded]

Essential knowledgeThis document provides a comprehensive overview of our deprecation policy, detailing the lifecycle and end-of-life processes across our Platform components.

Dynamic Mutations

Essential knowledge`DynamicUpdateMutation` automatically derives the correct update Mutation for the primary Entity based on the `RulesetContext` and then performs the update on one or more fields.

Dynamic Pagination

Essential knowledge`DynamicConnectionQuery` automatically derives the Connection fields (arrays) for the primary Entity based on the `RulesetContext` and can dynamically load all connection items, with pagination handled internally.

Dynamic Queries and Utils

Essential knowledge`DynamicEntityQuery`, with the help of the `DynamicUtils` class, automatically derives the correct GraphQL query operation for the primary Entity from the `RulesetContext`. It dynamically retrieves fields related to that Entity, removing the need for pre-compiled queries while preserving type safety and performance.

Dynamic Utilities Overview

Essential knowledgeThe `util-dynamic` library is a collection of utility functions that allow you to generate GraphQL queries and mutations at runtime. This enables the creation of highly configurable and reusable rules that can adapt to different needs without requiring code changes.PrerequisitesThese articles assumes you're familiar with:

Java
Maven
JUnit

GraphQL API Error Codes Overview

Essential knowledgeThis document explains the GraphQL Error Codes used by Fluent Commerce.

Escaping / unescaping of values in UX Framework

Essential knowledgeCharacter escaping and unescaping are crucial for data integrity and security in UX frameworks. This document focuses on the Mustache.js templating engine, which escapes HTML by default to prevent XSS attacks. When special characters like ampersands need to be displayed, the framework offers unescaping methods to ensure correct and secure rendering.This overview highlights the significance of proper value escaping and the techniques for accurately rendering special characters within the UX framework.

EU Data Act – Information and Disclosures (v1.0)

Essential knowledgeOn this page you will find information about how Fluent Commerce addresses the mandatory contractual, technical and disclosure requirements relating to switching and interoperability under the EU Data Act.

EU Data Act – Switch Process (v1.0)

Essential knowledgeThis document is for EU customers only and describes the Switch process and Exportable Client Data as required by the EU Data Act.

Event Utilities

Essential knowledgeThe `EventUtils` class in the `util-core` bundle provides a set of essential helper methods to simplify event creation, modification, and forwarding. Using these utilities helps to eliminate boilerplate code and prevent common errors, such as forgetting to copy event attributes or improperly handling event schedules.

Using the Event API

Essential knowledgeUsing the Event API

Exception Management in writing Rules

Essential knowledgeThe Workflow Framework Engine ensures that all Exceptions thrown out of Rules are recorded within the Orchestration Audit Events, accessible via the Event API. This is important for providing detailed information about what went wrong.

Ready for Launch Activities

Essential knowledgeThe Ready for Launch (RFL) process includes a number of tasks and activities involved in reviewing a client's configuration, inventory management, workflows, custom plugins and integration designs during the project lifecycle.

Extend Knowledge Content – Terms and Conditions (v1.0)

Essential knowledgeThe Extend Knowledge Content does not form part of the Fluent Order Management Platform or its Documentation, and its use is subject to the terms and conditions below. Extend Knowledge Content is designed to demonstrate how to extend the capabilities of the Fluent Order Management Platform through use of its many extensibility features and tools. Extend Knowledge Content is provided for illustrative purposes only, is not supported or maintained, and may become outdated. Please read the full document thoroughly before using any of the Extend Knowledge Content.

UX Framework - Extending Existing Components

Essential knowledgeThis article provides an overview of methods for configuring components within the UX framework. Customization is possible through configuring the various types of components, such as sub-components, wrapper components, and context components. Read on to find out how to use the above approaches.

External Penetration Testing (PenTest) Policy

Essential knowledgeExternal Penetration Testing (PenTest) is a critical security measure aimed at identifying vulnerabilities in Fluent Commerce’s environments. This policy outlines the guidelines and procedures clients must follow to conduct PenTests responsibly while safeguarding shared infrastructure and ensuring service continuity. It emphasizes the importance of proper authorization, notification, and adherence to security protocols to maintain the integrity and confidentiality of systems and data.

Feeds Interface

Essential knowledgeThe Feeds interface provides visibility into inventory feeds for an account, enabling monitoring and analysis of feed activity over selected time periods.It includes:

Feeds Dashboard—This dashboard displays general information about inventory feeds within the selected time frame (default: last 30 minutes, 1 hour, 8 hours, 24 hours). Learn how to configure custom periods in this guide. The dashboard consists of:
- Overview: Summarizes overall feed status and key metrics.
- Feeds: Lists individual feed details for deeper insight.

Fill Rate Metric

Essential knowledgeLearn about the Fill Rate Metric in Fluent Analytics

financialTransaction graphQL query and mutation

Essential knowledgeThe `financialTransaction` is an entity used for capturing financial transactional made by the customer.

Fluent Big Inventory - Features Overview

Essential knowledgeFluent Big Inventory is an enterprise inventory hub provided by Fluent Commerce. Fluent Big Inventory is designed to work within your omnichannel ecosystem, managing inventory availability across all your channels to ensure you have a single, unified view of inventory across all of your different go-to-market channels.

Fluent Big Inventory Web App Overview

Essential knowledgeThe Fluent Big Inventory Web App is a powerful tool for managing products, inventory, feeds, and sources. Key features include:

Feeds: View inventory feed details.
Sources: Track inventory update integrations.
Products: Manage catalogs and product data.
Unifies View of Inventory: Gain real-time inventory insights across locations and channels for optimal stock management.
Inventory: Monitor allocation, Stock On-Hand (SOH), real-time updates, and buffers.
Stores: Oversee individual and network locations.
Insights: Track system events.
Admin: Configure user access and settings.

Fluent CLI Command Cheat Sheet

Essential knowledgeGet a visual overview on all available commands and sub-commands for the CLI.

Fluent Commerce – Trust, Assurance and Compliance Overview

Essential knowledgeFluent Commerce ensures trust and assurance through robust security measures, compliance with global regulations like GDPR, and certifications such as SOC 2 Type 2. The platform guarantees high availability, privacy controls, and scalability via its cloud-native infrastructure.

Fluent Commerce Sub-processors (v2.0)

Essential knowledgeList of Fluent Commerce sub-processors.

Project Team Setup

Essential knowledgeProject representatives from Fluent Commerce, the Client, and/or the Partner are separated into distinct areas of project responsibility. This article will cover the typical team setups involved in Fluent OMS projects.

Service Levels - Enterprise (v3.0)

Essential knowledgePlease refer to this document to confirm contact points, SLAs and escalation paths.

Service Levels - Enterprise (v1.0) [Superseded]

Essential knowledgePlease refer to this agreement to confirm contact points, SLAs and escalation paths.

Service Levels - Enterprise (v2.0) [Superseded]

Essential knowledgePlease refer to this document to confirm contact points, SLAs and escalation paths.

Service Levels - Professional (v2.0)

Essential knowledgePlease refer to this agreement to confirm contact points, SLAs and escalation paths.

Fluent Commerce Sub-processors (v1.0) [Superseded]

Essential knowledgeList of Fluent Commerce sub-processors.

Fluent Connector Configuration

Essential knowledgeThe Connect SDK expects a minimum of 4 configuration files:

application-connector.yml - Project and Connector specific configuration.
application.yml - Core Connect SDK configuration. These are mostly default configurations and core settings.
bootstrap.yml - Server/Container configuration. This file includes settings for all different environments and - follows the spring profile standards.
logback-spring.xml - Log configuration also supports different configurations based on spring profiles.

It is possible to have dedicated configuration files for each environment, often used to override a common setting for a particular environment. To create such a file, follow Spring Boot's format having the additional desired spring profile name at the end of the application.yml file, for example, application-dev.yml.

Customization Guidelines for Connect SDK

Essential knowledgeThe SDK's handling mechanism involves loading and prioritizing handlers during server startup. It provides transparency with special spring actuators for listing active routes and handlers. Message handlers follow error-handling protocols, while job handlers process data polled from external systems. Configuration handlers react to changes, and the SDK supports various ways of receiving messages from external systems.

Fluent Metrics Library Overview

Essential knowledgeThe Fluent Metrics Library is a collection of metrics and dashboards available to Fluent customers. Delivered through the Fluent Analytics feature, it gives retailers real-time visibility into order, fulfillment, returns, and inventory operations to enable faster, smarter decisions.
Designed for retail operations managers, inventory analysts, business intelligence, and many other teams who need visibility across retail operations.

Fluent Order Management App for Salesforce Service Cloud (SFSC)

Essential knowledgeThe following guide will take you through how to use/navigate through the Fluent Order management app for Salesforce Service Cloud.

Fluent Platform Integrations and Connections

Essential knowledgeFluent platform functionalities are designed to be flexible by integrating with other APIs and Connectors and provides a real time view of the Inventory to the sales channels, enables integration with Warehouse Management Systems (WMS), carrier services, ERPs, etc.

Platform Limits (v1.0)

Essential knowledgeThis page sets out the:

Platform usage limits;
Platform data limits; and
Acceptable Use Policy and other enforcement rights

relating to the Fluent Order Management Cloud Platform (Platform)

commercetools connector - Fluent Settings

Essential knowledgeThe connector requires the settings below to process data being transmitted from Fluent to commercetools and vice versa. It contains a mix of settings and data mapping tables.

Store Labs

Essential knowledgeThe labs in this article will walk you through the following scenarios: Fulfill CC, HD Order with Store-to-Store Transfer and Short Pick, Reassignment, and Multi-shipment.

Fluent Store Web App Overview

Essential knowledgeFluent Store is an in-store responsive web application that provides store staff with end-to-end order management capabilities.

Utility Bundles Overview

Essential knowledgeThe Fluent Commerce Utility Bundles are a set of libraries designed to accelerate Rule development, reduce boilerplate code, and improve the overall quality and maintainability of implementations. They are the cornerstone of writing maintainable, reusable, and easily upgradeable Rules for the Fluent Commerce platform.

Authentication and Single sign-on (SSO)

Essential knowledgeAuthentication in Fluent Web Apps is managed through PingOne, which serves as the central identity hub. It hosts the Fluent Identity Provider (Fluent IdP) and integrates with Corporate Identity Providers (Corporate IdPs) such as Azure AD, Okta, and Google Workspace. PingOne authenticates users, issues tokens, and enforces access and security policies across all environments.

Fulfilment API

Essential knowledgeA fulfilment represents one or more items in an order that need to be picked & packed for the customer. A fulfilment is assigned to a location based on the retailer's fulfilment rules and available inventory. A fulfilment will have an origin (from) and destination (to) associated with it.

Fulfillments by Location Metric

Essential knowledgeLearn about the Fulfillments by Location Metric in Fluent Analytics

Fulfilment Inventory Management

Essential knowledgeAn overview different types of fulfilment that is used in OOTB workflow

Fulfilment Options improvements enablement

Essential knowledgeIn the September 2023 release, we improved our Fulfilment Options response times by up to 50%. These improvements are disabled by default for accounts created before the release. This section will detail how to turn on this setting.

Fulfilment Options Module

Essential knowledgeThis page covers the various Fluent CLI commands which can be used to configure / install Fulfilment Options module

Certification Study Guide - Functional Practitioner

Essential knowledgeThis Study Guide helps prepare for the Functional Practitioner Certification Exam. It provides some summaries of various areas that will be relevant for the exam and other details to help you pass the exam.

Get Comment by Id

Essential knowledgeThe `commentById` Query retrieves a Comment based on a provided Id.
Prerequisites

`COMMENT_VIEW` Permission is required for retrieving a Comment

Get Sourcing Profile

Essential knowledgeThe `sourcingProfile` query retrieves a Sourcing Profile by its Reference:

If a version is provided, the query returns that specific version
If no version is provided, the query returns the latest available version

Getting Started Configuring Fluent Big Inventory Web App

Essential knowledgeThe Fluent Big Inventory Web App is pre-configured with standard functions that provide the interface for managing products, inventory, feeds, and sources and serve as a starting point for your projects.The default UX templates are hosted on the platform, so you don't have to create the manifest settings unless you need to customize the existing baseline configuration.

Getting Started with Fluent Big Inventory

Essential knowledgeThis document will explain how to use Big Inventory for existing Customers and Partners. Additionally, we will cover any pre-requisites for each new feature and any existing configuration needed.

Getting Started with Metrics API

Essential knowledgeThis guide is intended to provide implementers with information about the Metrics API within the Fluent Big Inventory product, describing its functionalities and utilization principles within the Fluent Platform.Pre-requisites:

You should have knowledge of How Metrics works.
You should have knowledge of Metrics usage for Platform Observability.
You should have knowledge of GraphQL.
You should configure your User role with `METRICS_VIEW` permission for Metrics data access.

Inventory Batch API

Essential knowledgeThe Inventory Batch is designed to send large volumes of inventory data, primarily to update the Last On Hand inventory quantities for inventory positions. While its primary purpose is to handle large-scale inventory updates and ensure the OMS reflects the latest inventory levels after a few days of operations, it is flexible enough to support other inventory types as needed, providing adaptability for diverse inventory management scenarios.

GQL @skip @include Directives sample

Essential knowledgeSample GQL payload to use @skip and @include directives

GraphQL All-In-One Inventory Queries

Essential knowledgeRetrieve inventory position, variant product, virtual base position and virtual aggregate position records based on input parameters.

GraphQL Date Utilities

Essential knowledgeThe `GqlDateUtils` class in the `util-core` bundle provides a simple and effective set of functions for handling the specific date format required by the Fluent Commerce GraphQL API. The platform uses the ISO 8601 format (`yyyy-MM-dd'T'HH:mm:ss.SSS'Z'`), and this utility ensures you can easily parse and format dates to be compatible.

GraphQL Inventory Queries

Essential knowledgeSample Inventory Queries that can be used on a daily basis.

GraphQL Operations

Essential knowledgeGraphQL is a query language for APIs and a runtime for fulfilling those queries with your existing data. It provides a complete and easy-to-understand description of the data in your API. Its ability to return select fields enables it to be used with powerful developer tools and ensures that APIs are easily scalable.Fluent's GraphQL API has two operations:

Queries
Mutations

Queries include predefined Queries and Custom Queries, both of which will be covered below.

GraphQL order by ID with flags in parameter

Essential knowledgeRetrieve an order by `id` with flags to drive the retrieval of sub-entities.

GraphQL API

Essential knowledgeThe Fluent GraphQL API provides powerful access to data, integration, and orchestration-driven business logic. It provides an opportunity to streamline and optimize requests to the Fluent Order Management platform in a way that is more flexible than the REST-based API.

GraphQL Permissions

Essential knowledgeThe GraphQL Permissions define the access rights that control every operation in the Fluent platform’s GraphQL API. Each permission represents a single, specific action a user can perform on an entity, ensuring secure access management across all services.By assigning permissions to roles, organizations can control user capabilities at a granular level. This ensures that users only access and modify data relevant to their role and business context.

GraphQL Product Queries

Essential knowledgeSample Product Queries that can be used on a daily basis

GraphQL Reference

Essential knowledgeThese docs were generated by graphql-docs. Just starting out with GraphQL? Check out GraphQL's official documentation!

How Inventory Batch Pre-Processing works

Essential knowledgeThis document outlines the functionality of Inventory Batch Pre-Processing, offering insights into how unchanged records are filtered during the inventory ingestion process using Inventory Batches.

How do Inventory Feeds work

Essential knowledgeThis document will describe how Inventory Feeds work and guide users through understanding any prerequisites to integrate with Inventory Feeds.

How Metrics works

Essential knowledgeThis document is intended to describe to implementers Metrics technical details within the Fluent Big Inventory product.Pre-requisites:

You should have knowledge of Metrics
You should have knowledge of OMX Workflow Framework.
You should have knowledge of Events.
You should have knowledge of GraphQL.

How to enable Returns in Fluent OMS and Fluent Store

Essential knowledgeThe Returns feature is available for any OMX web apps. The following guide will step through the areas of configuration to enable the Returns reference solution.

How to Handle Amount, Scale, and Unscaled Values

Essential knowledgeThis guide teaches you how to manage large monetary values accurately in Fluent OMS using `scale` and `unscaledValue` rather than relying solely on floating-point `amount`. By following these practices, you’ll learn to configure financial values for invoices and other transactions with precision. Implementing partners benefit from consistent, reliable data, and customers gain accurate, trustworthy financial information—especially when handling large currency amounts.

How to Interpret the Batch Pre-Processing (BPP) Dashboard

Essential knowledge
This document explains how to interpret the Batch Pre-Processing (BPP) dashboard, focusing on the Change Rate Efficiency metric. It provides methods for analyzing inventory batch trends and optimizing data submissions. Implementation partners can use these insights to enhance batch performance and deduplication, while customers gain better visibility into changed vs. unchanged records. The dashboard supports a date range of up to 31 days, with historical data limited to the last five months.

How to transform v1.0 manifest into the manifest v2.0

Essential knowledgeThis article explains how to transform manifests v1.0 into the new manifests v2.0. From this guide, you will learn how to configure manifest with necessary menu items, add filters and configure them, and add custom components. The examples below demonstrate the following Fluent OMS menu items:

Orders
Roles & Permissions
Settings

Learn more about App-Level and Route-Level configuration here.Differences between Admin Console and Fluent OMS manifests are summarised in the following tables

Using the anyMatch Template

Essential knowledgeThe Mystique manifest configures icons, cards, and templates. Templates can be structured in various ways; for further details, please consult the UX Configuration Common Concepts article. This article, however, will specifically concentrate on the any Match template. This template functions as a filter for a stream (such as a list of items), capable of matching none, some, or all records where a specific condition is met by a field path. This feature is particularly valuable for filtering purposes.

Extend the Connector Contract

Essential knowledgeDescribes Fluent’s approach to name messages used by the module’s workflows. The message is a mode of communication between two different systems. The naming convention helps to keep all messages uniform and consistent across all Fluent modules allowing partners to understand and adopt the format and follow it during their customisation.A message can be of 2 types:

Command: A Command is a message directed at a receiver to get something done (aka action). The producer of command has an intent and may expect a response from the receiver. Example: create an order
Event: Events communicate the performed action from one system to another system. It’s a fact that cannot be changed as that has already happened in the past. Example: Order update notification: When the order is created or modified, a notification is sent from Fluent to external systems.

Webhooks Frequently Asked Questions

Essential knowledgeFluent Commerce doesn't support static IP whitelisting due to AWS Cloud's dynamic nature. Instead, robust authentication measures are in place for webhook security, including cryptographic signing and signature verification. While static IPs aren't recommended, securing webhook endpoints is achievable by configuring unique URLs and firewall rules. Additionally, setting up custom authorizers or message queue validation enhances security. Each webhook establishes a single connection, with inbound and outbound calls dependent on workflow events. For detailed guidance, refer to Fluent's 'Webhook overview' documentation.

Webhooks

Essential knowledgeFluent Commerce can post standard webhooks to a configured endpoint so that the third-party system can be notified or react to the provided event. For example, common webhook scenarios include order status updates and shipping notifications.

Designing Rules

Essential knowledgeThis page provides all the information needed to design best practice Rules for your workflows. There are some important things to be aware of, so we highly recommend you thoroughly read through this page, and refer back to it regularly during development.

Understanding Event Execution

Essential knowledgeThis page describes how Event Execution works.

Connector Contract

Essential knowledgeConnector Contracts are suggested design patterns provided by Fluent Commerce for common integration requirements.Each contract documents a series of “flows” - request-response webhooks, events, and occasionally mutations - that represent the overall back and forth between Fluent and a third-party API.

Label Naming Conventions

Essential knowledgeThis page provides naming recommendations to follow for labels across the Fluent platform.

nameSpace.domain.[subdomain].module.[submodules...].label
submodules = page.tab.component(card/table)
All levels use the singular. For example, order instead of orders and component instead of components.
Use Camel Case to separate words. For example,: fc.om.order.ui.list.title).

Wave Dashboard Template

Essential knowledgeThe Wave Dashboard Template is a preconfigured UX Template used within the Fluent Store Web App.

Accounts

Essential knowledgeThis section describes the different Account types, prerequisites, and processes for requesting an Account.A Fluent account is the representation of a single-tenant of the Fluent platform. An account is isolated and secure and provides access to the Fluent Order Management Platform on either a sandbox or production environment. For information about the Fluent environments, see environments. Access to an account is via the account-specific URL, in the format `https://<ACCOUNTID>.sandbox.apps.fluentcommerce.com`. This is a unique Console URL in a sandbox environment.

Fluent Store Dispatch Template

Essential knowledgeThe Dispatch Template is a preconfigured UX Template used within the Fluent Store Web App.

Overview of the Fulfilment Choice entity

Essential knowledgeThe Fulfilment Choice Entity is used to store the shipment specific information:

Delivery method
Delivery or pickup address
Delivery dates

Pick by Expiry Template

Essential knowledgeThe Pick by Expiry Template is a preconfigured UX Template used within the Fluent Store Web App.

Domain Model

Essential knowledgeFluent's Order Management domain oversees the entire order process, including entities like Order, Fulfillment, and Return Order. Billing Management handles financial operations, while Global Inventory aggregates product inventory. The Foundation domain configures setups, and Store Fulfillment manages order fulfillment through the Wave entity. Security governs users and permissions, Shipping records shipping details, and the Product Availability domain ensures real-time product availability. Fulfillment Option and Fulfillment Plan provide flexibility in order fulfillment strategies.

Languages and Localisation

Essential knowledgeAs a part of Internationalisation, the Fluent platform supports multiple languages. This support allows users of web apps such as OMS Webapp and Fluent Store to configure and view the modules and interfaces of the Fluent platform in their preferred language.As of the Fluent v4.45 release, the Fluent platform provides pre-configured support for the following languages.Fluent Order Management uses a default language of Australian English `en-AU`.

Australian English `en-AU` - Default
American English - `en-US`
French - `fr-FR`
Mexican Spanish - `es-MX`
Italian - `it-IT`

Order Workflow Templates Overview

Essential knowledgeWe provide three reference workflows Home Delivery (HD), Click and Collect (CC) and Mixed Baskets. Suppose our reference workflows do not accommodate your business case. In that case, you can create a new Order Workflow to support additional Order Types that require different processing and timing, with such as marketplace orders and back ordersLearn more about supported reference workflows here.

Pack Template

Essential knowledgeThe Pack Template is a preconfigured UX Template used within the Fluent Store Web App

React Hooks in the Component SDK

Essential knowledgeComponent SDK provides a collection of React hooks to allow custom components to access the core UX framework functionality.The SDK includes Typescript declaration files that tell your IDE and compiler what these look like and that they are available on the global scope.

Component SDK - Overview

Essential knowledgeGeneral Principles and the Features of the SDK

Rules SDK - Event Attributes

Essential knowledgeThe `@EventAttribute` Annotation declares the Event Attributes the Rule requires from the Event.

Rules SDK - API Collections

Essential knowledgeThe Rules SDK comes with 2 API Collections:

Postman Collection
Insomnia Collection

Cloud Technology - Architecture

Essential knowledgeThe Fluent platform leverages advanced cloud technologies to provide a seamless, scalable, cost-effective solution. Designed natively for the cloud, it offers users:

Automatic scaling to efficiently manage fluctuating demand without manual intervention.
Cost savings through optimized resource utilization and infrastructure sharing.
Continuous operations with updates and upgrades that do not disrupt retailer activities.

Warehouses

Essential knowledgeWarehouses configuration contains:

Warehouses page
Warehouse Details page

Cloud Technology Environments

Essential knowledgeCloud Technology Environments on the Fluent platform include Sandbox and Production settings. The Sandbox is for testing and training, mirroring the live Production environment. Retailers ensure secure operations using HTTPS and tailored firewall or proxy configurations. These environments are fundamental for smooth retail activities on the Fluent Commerce Cloud platform.

Location - Stores

Essential knowledgeStores configuration contains:

Stores page
Store Details page
Location Ref
Created On
Updated On

Add colours to statuses to highlight important information

Essential knowledgeThis document provides an overview of enhancing visual representation within a system by displaying coloured dots. These dots serve as a quick reference to different statuses of orders or items, making it easier to recognize and prioritize tasks at a glance. You will learn how to customize the appearance of these dots by changing their colour through hex codes and understand the default settings. The guide also includes recommendations for a colour palette to optimize the utility of status indicators.

Federated Identity Provider (IdP)

Essential knowledgeFederated identity management means establishing of a trusted relationship between separate organizations and third parties, allowing users to authenticate to one domain and access resources in another without a separate login, enhancing security and user satisfaction. Fluent's Federated SSO utilizes protocols like SAML and OIDC for secure data exchange, providing a seamless single sign-on experience across Fluent OMX applications. These open standards enable the secure transmission of authentication and access information across domains

Connect SDK Overview

Essential knowledgeConnect SDK is the launchpad to connect any external system with Fluent Commerce in a predictable way. It reduces implementation timelines and costs so customers can see faster ROI. Technically, Connect SDK is a Java Maven Archetype and Java Library Utils that form a toolkit for building Spring Boot micro-service applications that communicate with the Fluent Order Management System and any external system.

Understanding Dispatch Process

Essential knowledgeThis topic explains the dispatch process for Home Delivery (HD) and Click and Collect (CC) fulfilments using the ServicePoint console.

Exploring Roles & Permissions via the UI

Essential knowledgeRoles & Permissions configuration contains:

Roles & permissions page
Role Details page

Customers

Essential knowledgeCustomer configuration contains:

Customer List page
Customer Details page

Fluent Identity Provider (IdP)

Essential knowledgeAn identity provider (IdP) is a service that stores and manages digital identities. Companies use these services to allow their employees or users to connect with the resources they need. They provide a way to control access, adding or removing privileges, while security remains tight.For companies who don’t have corporate IdP, Fluent provides a solution that allows them to receive all SSO benefits without needing to support their own SSO solution.

Waves

Essential knowledgeWaves configuration contains:

Waves List page
Wave Details page

Networks

Essential knowledgeNetworks configuration contains:

Networks List page
Network Details page

Fulfilment Options Page

Essential knowledge

Fulfilment Options page
Further Reading

Billing Account Overview

Essential knowledgeThe Billing account entity represents financial operations. Billing accounts are responsible for orchestrating all invoices and invoice adjustments (Credit & Debit memos). Additionally, Billing Accounts also manages all associated downstream outcomes including payments, invoice notifications, and ERP integrations.Billing Account configuration contains:

Billing Account List page
Billing Account details page

Collections

Essential knowledgeCollections configuration contains:

Collections List page
Article Details page

Order lifecycle

Essential knowledgeThis article will explore the different stages involved in an order's lifecycle. Through the various tabs and sections in the Fluent OMS interface, you can easily track the status and progress of orders including customer delivery preferences and details. This promotes transparency and efficiency in the order fulfillment process.

Returns in Fluent OMS Web App

Essential knowledgeReturns OMS configuration contains:

Creating a Return
Returns List page
Return Details page
Return Fulfillment Details page

Location details page overview and configuration

Essential knowledgeA Location represents a physical place, whether a retail store, a warehouse, or even third-party vendor facilities. A Location page displays the list of existing locations, while a Location Details page displays detailed information about the particular location.

Admin Console Overview

Essential knowledgeThe Fluent Admin Console is a web browser-based portal, for retail business users, that provides the interface to manage orders, product availability, inventory and order fulfillment. The Admin Console is used by businesses and administrators to access a large range of functionality provided by the following Fluent Commerce apps:

Distributed Order Management
Global Inventory
Product Availability

Each app provides out-of-the-box capabilities that are accessed by the Fluent Admin Console.By default, the Admin Console displays content in English. However, v4.44 release onwards, the Fluent platform provides support for multiple languages. For more information on languages and localization and configuring other languages, click here. The console should be used on tablets and computers that have an active internet connection and a supported web browser.

Single sign-on (SSO) Overview

Essential knowledgeSingle sign-on (SSO) is a session and user authentication module that gives users the ability to sign on once and with a single set of credentials to access multiple services and resources. It means is that the user will be authenticated against any Fluent platform application via corporate identity management provider (IdP) or Fluent IdP.

Dashboard Interface

Essential knowledgeThe Fluent OMS Web App's dashboard interface serves as a central hub for monitoring and managing order activity and alerts.
It provides real-time visibility into key operational metrics — such as orders received, escalations, returns, cancellations, and pending actions — enabling quick responses to exceptions.The dashboard is fully configurable to match business requirements. The numbers displayed represent the total records returned by these queries.

Escalated Fulfillments

Essential knowledgeA fulfillment represents one or more items in an order that need to be picked and packed for the customer. It is assigned to a location based on the retailer's fulfillment rules and available inventory. A fulfillment will have an origin (from) and destination (to) associated with it. A fulfillment containing unfulfillable items can be moved to the Escalated state. The Escalated Fulfilments page displays fulfillments in the Escalated state.

Arrivals

Essential knowledgeArrivals configuration contains:

Arrivals List page
Article Details page

Insights

Essential knowledgeThe Insights interface is a comprehensive repository of system Events, representing occurrences or triggers within the Fluent Platform. These Events, like changes in inventory position or entity states, act as notifications, prompting specific workflows and providing a dynamic overview accessible through a user-friendly configuration featuring the Events Search Form, the Events Search Results, and the Event Details Drawer for efficient information retrieval.

Interface Mapping

Essential knowledgeThe Interface mapping document should clearly define what data will be exchanged between OMS and the external systems (e.g. middleware or eCom).

Introduction to the Component Library

Essential knowledgeThe OMX Component Library is a suite of UI Components, ready to be configured and used in Fluent Web Apps.Unlike a standard UI Component, Fluent Components are built to natively interact with the Fluent Platform.The Library contains a number of different types of Components, including:

Foundation Components, such as Page Components which form the base of a screen
Content Components for displaying data and media
Layout Components for structuring pages
Interaction Components for capturing user input

Inventory Batch API

Essential knowledgeA batch contains a series of records that will have the same operation applied to it. All batches are run asynchronously as such the client will be required to request a status update for entered batches. A batch can include a maximum of 5000 records.To create a Batch, the user must first create a Job. A job is required to store a series of batches. For more information please refer to the Job API.

Inventory Batch Events

Essential knowledgeInventory Batch Events offer insights into the processing status of Inventory Batches, helping to determine whether the corresponding records within a batch were successfully submitted for processing.

Inventory Batch

Essential knowledgeInventory Batch enables bulk uploading of inventory updates to the Fluent Commerce platform, handling high data volumes from thousands to million updates per operation. Leveraging Fluent Big Inventory's Batch API and Inventory Batch Pre-Processing, it ensures faster processing and accurate inventory availability in the Fluent Order Management System. This scalable solution keeps inventory data synchronized across channels, empowering businesses to manage stock efficiently and meet customer expectations with accurate, up-to-date stock information.

Inventory Coverage Days Metric

Essential knowledgeLearn about the Inventory Coverage Days Metric in Fluent Analytics

Inventory Feeds

Essential knowledgeThis document is intended to introduce the Inventory Feeds feature to Customers and Partners. This page will describe the Inventory Feeds feature and how they fit within the Fluent Big Inventory Product and will direct the reader to resources describing how to use Inventory Feeds.

Inventory Ingestion

Essential knowledgeInventory Ingestion in Fluent Commerce ensures that stock levels across all sales channels remain accurate and up-to-date, enabling effective inventory management. It allows businesses to send inventory updates to the platform using two distinct methods: Inventory Batch and Inventory Delta. Each method is tailored to different scenarios, depending on data volume, frequency, and operational needs.

Inventory Module Getting Started Guide

Essential knowledgeThe Inventory Reference Module is the foundation for inventory-related implementations. It provides reference Workflows for inventory ingestion and processing. Extensible by design, use this Module as a base to build a solution to your customers' needs.

Inventory Quantity Type Breakdown Metric

Essential knowledgeLearn about the Inventory Quantity Type Breakdown Metric in Fluent Analytics

Location Utils

Essential knowledgeThe `LocationUtils` class in the `util-sourcing` is a utility class that provides utilities for location-based sourcing decisions. It handles location-specific sourcing logic including distance calculations, location availability checks, and provide location-based caching optimization.

Item Rejection Rate Metric

Essential knowledgeLearn about the Item Rejection Rate Metric in Fluent Analytics

JSON Utilities

Essential knowledgeThe `JsonUtils` class in the `util-core` bundle provides a foundational set of helper methods for working with JSON data. Built on top of the Jackson library, these utilities simplify the conversion of raw JSON into usable Plain Old Java Objects (POJOs) and vice-versa.JSON is a common data format found in event attributes, entity attributes, and setting values, and these utilities are essential for effective rule development.

Platform Foundations

Essential knowledgeThis section covers the basics of the Fluent Platform, such as sandbox and production environments, account structure, retailer management, location networks, user roles and permissions, and platform configuration.

About the Platform and Setting Up

Essential knowledgeThis section covers the basics of Fluent Account setup and walkthrough of the LaunchPadV1

"FC Retail Group" Sample Setup

Essential knowledgeThis section goes through the different sections of an account and the different parts that make a Fluent Account work. It introduces the account structure, including training accounts, locations, networks, catalogs, data files, user roles, and settings at various levels.

Accessing Page Query Data

Essential knowledgeThis lesson focuses on retrieving data for our map visualization. We'll explore how to access data from the page query defined in the manifest document, rather than making GraphQL queries directly within the component. This approach promotes reusability and configurability. We'll specifically target retrieving a list of locations that stock a given product, a crucial step in displaying product availability on the map.

Adding Nested (Child) Components

Essential knowledgeThis lesson combines adding map pins with the concept of nested components. Building on the Google Map integration, we'll show how to dynamically add pins (child components) to the map (parent component). This is crucial for visualizing location data and illustrates building complex, modular UIs using nested components. You'll learn how to place markers representing locations and how this parent-child relationship contributes to organized, reusable UI elements.

API, Integration, and Connectors

Essential knowledgeAPI, Integration, and ConnectorsThis lesson covers the various integrations and connections with the Fluent platform.

Availability Labs

Essential knowledgeThis article will allow you to apply the practical knowledge you've acquired related to availability in this knowledge track course.

Availability Module Features

Essential knowledgeIn this article, you will understand how fulfillment options provide the Available to Sell quantities.

Availability Module Overview and Key Concepts

Essential knowledgeThis course introduces the fundamentals of the availability module, helping you familiarize yourself with key terms and providing an overview of its high-level implementation in Fluent OMS.

Availability Module Scenario

Essential knowledgeIn this article, you will explore a real-life business scenario and learn how the Product Availability call helps address it.

Creating Custom Template Helpers

Essential knowledgeThis lesson explores the creation and registration of custom template helpers within the Component SDK. Template helpers are powerful utilities that can be used within Manifest documents for tasks like styling, formatting, and calculations. We'll demonstrate how to create a custom template helper, in this case, one that bolds entity references, showcasing how to leverage the `TemplateRegistry` and its utility methods for generating formatted HTML.

Creating and Registering a Custom Component

Essential knowledgeThis lesson demonstrates the process of creating and registering a custom component using the Component SDK. We'll walk through the steps of building a simple React Function Component, leveraging a utility component (Card) provided by the SDK. We'll then register this custom component with the Component Registry, making it available for use within our web application. Finally, we'll show how to integrate the registered component into a page by updating the application's manifest.

Implementing a Custom Form Field

Essential knowledgeThis lesson walks through the implementation of a custom form field component for a Stock Reservation user action. We'll build a field that captures `locationRef` and `quantity` and outputs a JSON object structured as required by the Ruleset. The lesson covers configuring the user action button, creating the custom field component using React Function Components and the `FormFieldProps` interface, registering the field, and updating the workflow definition to use the new custom field type.

Carrier Collections

Essential knowledgeThis article covers how articles are marked as Collected in the Fluent Store app.

Case Scenario - Implement Fraud Check

Essential knowledgeIn this scenario we will implement a Fraud Check step in the Order Workflow

Client Scenario: Building a Product Availability Map

Essential knowledgeThis lesson introduces a practical client scenario: visualizing product availability on a map. Building upon the foundation laid in the UX Framework course, we'll enhance the Fluent Store app's Product Availability screen by adding a map that displays nearby store locations and stock information for a selected product variant. This hands-on lab will guide you through configuring the product lookup and detail availability pages, setting the stage for creating custom components in subsequent lessons.

Building Custom Components with the Component SDK

Essential knowledgeThis lesson dives into the practical application of the Component SDK, focusing on how to build custom components for OMX Web Apps. We'll explore the different types of custom components you can create, the powerful hooks available for interacting with the Fluent platform, and the utility components that streamline development and ensure consistency. We'll also touch on the crucial concept of component registries.

Composing Workflows

Essential knowledgeIn this section you will learn all about rules, including:

Typical functions of a rule
How to use them in workflow
Rule design best practices and recommendations

Configuring Components with Settings

Essential knowledgeThis lesson addresses the best practice of avoiding hardcoded values, specifically API keys, within components. We'll explore how to use the `useSettings` hook provided by the Component SDK to retrieve configuration values from platform settings. This approach makes components more configurable and reusable across different clients and environments, simplifying maintenance and updates.

Connectors

Essential knowledgeIn this lesson, we'll talk about Connector Contracts, and the out-of-the-box connectors that are provided with the Fluent OMS.

Control Groups & Controls

Essential knowledgeIn this course you will learn how Controls and Control Groups are used to define the ATS quantity.

Manifest Creation and Customization

Essential knowledgeThis series of lessons guides you through building a feature to manage storage areas within the Fluent Store web app. We'll cover creating a new Manifest fragment, adding it to account settings, and referencing it in the main Manifest. We'll then add a List component to display storage areas, configure a data source for the list using a page query, and create a details page for individual storage areas. Finally, we'll explore working with dynamic values, including date formatting, array access, image rendering, and configuring i18n language translation.

Customer Click and Collect Journey

Essential knowledgeFluent supports various fulfillment options like Click and Collect, Ship-from-Store, and Ship-from-Warehouse. The process involves checking inventory, reserving stock, and notifying relevant parties at each stage. Orders are managed through the Fluent platform, allowing customers to collect from stores or receive deliveries at home, with real-time updates on order status.

Configuring Custom Components via the Manifest

Essential knowledgeThis lesson focuses on configuring custom components using the Manifest file. We'll demonstrate how to define an interface for your component's properties, allowing it to receive data from the Manifest. Specifically, we'll show how to declare a `MapCardProps` interface with properties like `title` and `width`, and then configure these properties within the Manifest to dynamically control the component's appearance and behavior.

Deploy your Rule

Essential knowledgeIn this lesson, you will learn how to deploy and run a custom rule.

Deploying a Custom Component Plugin

Essential knowledgeThis lesson covers the deployment process for custom component plugins. Unlike server-side plugins, component plugins are frontend JavaScript bundles that can be hosted on any web server. We'll explore the key steps involved in preparing your plugin for production, including versioning, bundling, and deployment, and how to reference the deployed plugin in the manifest document.

Domain Model & Entities

Essential knowledgeIn this section the reader will learn about the Fluent domain model and the various entities that make it up.

Setting Up Your Component SDK Project

Essential knowledgeThis lesson provides a step-by-step guide to downloading, installing, and setting up a new Component SDK project. You'll learn how to prepare your development environment, install necessary dependencies, and run the project locally. We'll also cover the crucial step of referencing your local plugin within your Fluent Web Apps manifest, enabling you to integrate your custom components into your applications.

Exception Management, Debugging and Logging Events

Essential knowledgeThis section covers the Exception handling, Debugging and Logging in a Custom Rule

Order Management - Fluent Web Apps & User Interfaces

Essential knowledgeThis section outlines how the webapps interact with the modules

Foundational Domains & Entities

Essential knowledgeThe Foundation Domain contains the core foundational entities to support the Order Management capabilities.

How the Domain Model Works

Essential knowledgeThis article focuses on understanding the Order Domain within Fluent, highlighting orchestrated and non-orchestrated domains. The Order is the central entity that has relationships to sub-entities like Fulfillment, Article, Consignment, and Return Order. These relationships determine the order processing flow, including picking, packing, delivery, and optional returns.

Implementing Delta Inventory Updates

Essential knowledgeIn this lesson, you will learn how delta inventory updates can be sent to Fluent OMS.

Install & Run Rules SDK Prerequisites

Essential knowledgeThe software required to install and run Rules SDK, also known as the Fluent SDK.

Extending Forms with Custom Field Components

Essential knowledgeThis lesson introduces the concept of custom form fields within the UX Framework. While standard form fields are automatically generated based on data types, developers can create custom field components to handle more complex data structures or enhance the user experience for specific scenarios, such as workflow user actions, GraphQL mutations, and list filters. In our client scenario, we'll focus on building a custom form field to capture stock reservation details, which requires a JSON object containing `locationRef` and `quantity`.

Introduction to Fluent Rules

Essential knowledgeWorkflow Framework Rules are written using Java and contain a specific structure and metadata for describing and validating the Rule. In this lesson, you will learn how to write Rules by adding customised business logic.

Introduction to GraphQL

Essential knowledgeIn this lesson, we'll look at the benefits of using GraphQL, as well as explore the differences between GraphQL and REST based APIs. We will also look at some examples of a GraphQL query and a GraphQL mutation.

Introduction to Integrations and Connections

Essential knowledgeWelcome! This course talks about the various Integrations and Connections of the Fluent Platform.

Introduction to Setup and Configuration

Essential knowledgeThis section covers the scope of the Setup and Configuration course and the required prerequisites

Introduction to Store Fulfillment

Essential knowledgeThis course covers the basics of the Store module, helping you get acquainted with essential terminology and offering an overview of its high-level implementation in Fluent OMS.

Introduction to Support & Operations

Essential knowledgeThis training introduces the tools and activities used in Fluent Commerce Support and Operations processes. You’ll learn how to use Fluent OMS and Postman for troubleshooting, identify common issues like stuck orders, and learn to resolve them effectively.

Introduction to the Component Library

Essential knowledgeThis lesson introduces the OMX Component Library, a collection of pre-built, configurable UI components designed for use in Fluent Web Apps. Unlike standard UI components, these components are specifically built to interact natively with the Fluent Platform. We'll explore the various categories of components within the library, including Foundation, Content, Layout, Interaction, and Field Components, and understand their distinct roles in building user interfaces.

Introduction to the Events API

Essential knowledgeThe Events API is a core component of the Fluent Platform, enabling the creation and management of events that drive workflow logic and system activity tracking. It supports asynchronous operations for optimized performance and integrates with systems for inventory updates, product data transfer, fulfillment, and carrier tracking.

Introduction to the Fluent OMX: Configure - UX Framework

Essential knowledgeThis module provides an introduction to the Fluent OMX UX Framework (Mystique) and its role in building user interfaces for the Fluent Platform. We'll explore the core concepts behind the framework, how it functions, and the basic structure of a Fluent Web App. This foundational knowledge will prepare you for more advanced topics in later modules.

Extending the UX Framework with the Component SDK

Essential knowledgeThis lesson introduces the Component SDK, a powerful toolkit for extending the UX Framework Component Library. We'll explore the core concepts behind the SDK, covering its purpose, capabilities, and benefits. By the end of this lesson, you'll understand how the Component SDK empowers developers to create custom, OMX-ready components for Fluent Web Apps, streamlining development and ensuring consistent user experiences.

Introduction to Webhooks

Essential knowledgeIn this lesson, we'll look at what Webhooks are, their structure, features and some recommended practices around using Webhooks.

Inventory Batches

Essential knowledgeIn this lesson, we'll talk about Batches, and the data that can be loaded using Batches.

About Inventory Catalogs

Essential knowledgeIn this course you will learn how inventory is uploaded into Fluent OMS and how the Inventory Catalog enables the maintenance of stock-on-hand records across all locations.

Inventory Module Labs

Essential knowledgeThis article will allow you to apply the practical knowledge you've acquired related to inventory in this knowledge track course.

Inventory Module Overview

Essential knowledgeThis course covers the basics of the inventory module. You will become acquainted with key terms and concepts and understand the core data objects and flows.

Inventory Module Product Catalog

Essential knowledgeThis course covers how product master data is handled in Fluent.

Inventory Quantity Types

Essential knowledgeThis course covers how the Inventory Position On Hand quantity is calculated from the different Inventory Quantity types.

Support and Operations Labs

Essential knowledgeThese labs focus on debugging and troubleshooting Fluent Order Management workflows using GraphQL and Postman. They cover retrieving detailed data for orders and waves, analyzing audit events, identifying stuck orders, and re-triggering workflows. The goal is to simulate real-world scenarios, understand workflow paths, and resolve issues efficiently.

Integrate and Connect Labs

Essential knowledgeThe labs in this article will walk you through the following scenarios: GraphQL Introspection and Sending a Webhook

Order Orchestration Labs

Essential knowledgeThe lab covers creating and managing different order types in Fluent OMS, simulating warehouse and store interactions, and enabling user actions for order cancellation. It focuses on Home Delivery (HD), Click and Collect (CC), split fulfilment, and enhancing workflows with user-configured actions. This lab guide users through hands-on exercises using Postman and the Fluent OMS interface.

Logical Gates in Workflows

Essential knowledgeAn introduction to the concept of Logical Gates and examples of how to use these in a workflow.

Make Your Component Interactive

Essential knowledgeThis lesson focuses on adding interactivity to the map pins. Building on the previous styling enhancements, we'll use React's `useState` hook to manage the state of pin interactions, specifically clicks. This will enable us to trigger actions when a pin is clicked, making the map more dynamic and responsive.

Managing Workflow States

Essential knowledgeLearn about managing state in a workflow and the recommended best practices to follow.

Order Management Modules

Essential knowledgeFollowing the completion of this section readers should gain an understanding of the different modules and the segregation between them. They should understand some of the key features of the modules and how they could be used to benefit both the customer and the company providing products and services.

Order Management Overview

Essential knowledgeWhat is Fluent Order Management?'Fluent Order Management', also referred to as the 'Fluent Platform', is the core product of 'Fluent Commerce'.

Order management - Orchestration Engine and Cloud Infrastructure

Essential knowledgeThis topic describes the cloud native nature of the Fluent platform

Orchestration Webhooks

Essential knowledgeFluent workflows use webhooks for real-time communication with external systems, triggered at specific workflow points. Webhooks provide timely updates for order status, shipping, payments, and inventory movements. The standard SendWebhook rule simplifies outbound communication by sending basic data, allowing external systems to retrieve additional information as needed.

Order Cancellations and Returns Handling

Essential knowledgeOrder management in Fluent includes handling cancellations, revisions, and returns. Cancellations can be for entire or partial orders. Order revisions allow modifications to in-progress orders before dispatch, and returns handle customer issues with delivered items. Depending on the business' needs, these processes can be managed manually by customer service or automated within workflows.

Order Management Experience (OMX)

Essential knowledgeIn this lesson, we'll discuss Fluent OMX, which stands for Order Management Experience. We'll be introducing concepts such as Fluent workflow and UI configuration and customization.

Order Orchestration Module Overview

Essential knowledgeThe 'Order Orchestration' module is integral to Fluent Order Management. It handles the end-to-end management of orders from creation to fulfillment. It optimizes the fulfillment process, allowing flexibility and control over sourcing and fulfillment strategies.

Overview of Workflow Framework

Essential knowledgeYou'll acquire new knowledge of the Workflow Framework, its fundamental concepts and terminologies, and also learn about best practice workflow design concepts. After covering the theory, you will get ‘hands-on’ by completing a Lab where you'll have a go at composing business logic (code free) via the Workflow Builder.

Pick, Pack, & Dispatch

Essential knowledgeOne of the main capabilities provided by Fluent Store is the capability to manage Wave creation, Pick, Pack and Dispatch operations. This article covers these notions, and provides multiple use cases in which they are used.

Tool Overview: LaunchPad v1

Essential knowledgeThis page provides an overview of Fluent LaunchPad v1. It is a tool designed to streamline the setup of Fluent accounts for efficient order processing by leveraging Postman's advanced features to automate workflows, reducing manual effort and minimizing errors. LaunchPad ensures comprehensive account configuration, including dynamic authentication, retailer creation, inventory management, and fulfillment setup.

Plugin Structure & JS GraphQL

Essential knowledgeIn this module, you will learn about a Plugin Project structure and JS GraphQL within the Plugin Project. You will also learn how to modify and run a JS GraphQL query.

Completing the Custom Form Field: Outputting the Result

Essential knowledgeThis lesson completes the custom form field component by implementing the crucial step of outputting the captured data to the form's submitted payload. We'll learn how to use the `onChange` event provided by the `FormFieldProps` to pass the structured data (containing `locationRef` and `quantity`) back to the form. This ensures that the user's input is included in the data posted when the form is submitted. We'll also demonstrate how to verify the output using browser developer tools.

Recap of Workflow Framework

Essential knowledgeThis article will provide an introduction to the fundamental concepts of the Workflow Framework, including:

Explanation of Events, Rules, Rulesets, and Triggers
Description of Statuses representing the condition and state of entities in a workflow
Details about Actions as outcomes of Rules
Explanation of User Actions, which are UI interactions integrated with workflows

Fetching Data with the useQuery Hook

Essential knowledgeThis lesson focuses on fetching data within a custom form field using the `useQuery` hook. We'll move away from relying on page query data and instead directly query the Fluent GraphQL API to retrieve a list of nearby locations with product stock. This involves defining data structures for query results, storing the query in a constant, and using the `useQuery` hook to execute the query with dynamic parameters derived from the form's context and the user's context (via `useAuth`). We will then render the results in a selectable list using radio buttons.

Rules SDK Setup & Plugin Creation

Essential knowledgeIn this lesson, you will learn about Rules SDK, the Software Development Kit for Fluent Order Management, and the key features of the SDK.

Security Domain and Entities

Essential knowledgeThe Security Domain represents the Users, Roles, and Permissions across the Fluent platform.

Setting up the Manifest Document

Essential knowledgeThis lesson introduces the Manifest document, a crucial component in defining the structure and layout of Fluent Web Apps. We'll cover how to set up your development environment with a pre-configured VS Code workspace, understand the key elements of a Manifest document, and learn how to create a new web app by defining an account-level setting. We'll also explore the different types of routes used in Manifests and walk through creating a simple page route. This setup and introduction will prepare you for more advanced Manifest configurations in later lessons.

Setup and Configuration Labs

Essential knowledgeThe Setup and Configuration lab covers the step by step guide to setup a Retailer from scratch

Order management - Ship from Store Customer Journey

Essential knowledgeThis topic describes an example "Ship from Store" Customer Journey

Splits, Rejections, Revisions and Escalation

Essential knowledgeSplit fulfilment allows retailers to complete an Order from multiple locations if a single location can't fulfill the whole Order. Rejection occurs when orders can't be fully met due to various constraints, leading to escalated statuses where customer notification and resolution actions are taken. In-flight revisions enable modifications to order items, allowing flexibility in managing customer orders.

Store Arrivals

Essential knowledgeThis article covers how Store arrivals are handled in Fluent OMS.

Store Sourcing Methodologies

Essential knowledgeSourcing determines the best fulfillment location for an order based on various business rules and priorities. It aims to optimize delivery speed, cost, and inventory management while enhancing customer experience. Retailers can quickly adapt sourcing strategies to market changes and manage fulfillment efficiently, ensuring maximum flexibility and revenue.

Style and Theme Your Component

Essential knowledgeThis lesson focuses on enhancing the visual representation of our map pins through styling. We'll explore how to add color to the map pins, improving their visual appeal and potentially conveying additional information. This styling process will demonstrate how to customize the look and feel of custom components.

Support & Operations Activities

Essential knowledgeThis lesson covers key operational activities in Fluent Commerce, including Plugin Management, Workflow Versioning, and Audit Events. You’ll learn how to manage Fluent plugins, version workflows, and utilize audit events to debug and analyze processes within the Fluent platform.

Support & Operations Tools

Essential knowledgeFluent OMS and Postman are key tools for managing and troubleshooting the Fluent Commerce platform. Fluent OMS provides a web-based interface for managing orders, inventory, and workflows, while Postman facilitates advanced debugging and custom queries using GraphQL. Together, they help identify and resolve issues like stuck orders or workflow interruptions.

Test your Rule

Essential knowledgeIn this module, you will learn about Unit Testing and creating a Mocked Unit test for a custom Rule. You will also learn how to perform testing on the TestExecutor and finally deploy your plugin into your sandbox environment

Unit Testing Custom Components

Essential knowledgeThis lesson covers the process of unit testing custom components using the tools provided within the Component SDK: Jest and React's test renderer. We'll walk through the steps of creating mock objects for dependencies (authentication, data, attributes), arranging the test environment, acting by rendering the component with the mocks, and asserting the output using snapshot testing. This process ensures the reliability and correctness of your custom components.

Understanding Manifest Structure

Essential knowledgeThis lesson details the structure of Manifest documents, covering both main web application manifests and fragment manifests. We'll explore the required fields and optional configurations for the main manifest, including context, routes (section, page, and reference), and plugin integration. We'll also examine the simpler structure of fragment manifests and how they contribute to managing complex UI configurations.

Integrating a Third-Party Map Component

Essential knowledgeThis lesson demonstrates how to integrate a third-party component, specifically a Google Maps React component, into your custom map card. We'll cover the installation process using Yarn and discuss best practices for selecting third-party components for use in Fluent Web Apps. We'll also explore the option of using the map in development mode without an API key.

Configuring Components with Dynamic Attributes

Essential knowledgeThis lesson explores the use of Dynamic Attributes within components, a powerful mechanism for making component content configurable. We'll demonstrate how to create a component, in this case an `InfoBox` that appears when a map pin is clicked, and how to fully configure the information displayed within it directly from the Manifest using Dynamic Attributes. This approach allows for flexible and data-driven component content.

Enhance Your Custom Fields: Leveraging Existing Components from the Registry

Essential knowledgeThis lesson details how to enhance custom form fields by adding structure, styling, and interactive controls. We'll focus on improving the user experience and data capture capabilities of our custom field component. This involves using Material-UI for styling, organizing the field's layout, and integrating pre-built form controls from the component library, such as the `QuantitySelector`. We'll also cover best practices like using the `useEffect` hook for debugging.

Accessing User and Location Context with the useAuth Hook

Essential knowledgeThis lesson explores the `useAuth` hook provided by the Component SDK, which grants access to crucial information about the currently logged-in user. We'll learn how to retrieve user details, including roles/permissions and the current location/retailer context. Specifically for location-context web apps like Fluent Store, we'll focus on using this hook to access the currently selected store's information, such as longitude and latitude coordinates, which will be essential for our map implementation.

About Virtual Catalogs

Essential knowledgeIn this course, you will understand how the Virtual Catalog enables the calculation of the ATS quantity.

Workflow Event Execution

Essential knowledgeIn this module you'll learn about how events are executed on the Fluent platform.

Workflow Framework Overview and Key Concepts

Essential knowledge.

Workflow Process Flows

Essential knowledgeAn overview of workflow process flows, explaining how processes are executed by the workflow framework and offering best practices for workflow design.

Workflow Scenario (Recommended Practice)

Essential knowledgeWalkthrough of an example scenario that demonstrates the advantages of following recommended practices in workflow design.

Working with Rulesets

Essential knowledgeIn this section you will learn all about Rulesets and how they can be configured using the Workflow Builder.

Working with Workflows

Essential knowledgeYou will learn about key Workflow concepts and the Workflow Builder

Workflow Framework Labs

Essential knowledgeThis module will guide you through a hands-on lab where you can put all of the theory to practice and implement a simple Fraud Check solution. This will cover adding new business logic to your workflow, including configuring some user actions to enable business users to approve or cancel orders that have been flagged as potentially fraudulent.

Learning Pathways

Essential knowledgeLearning Pathways offer structured learning consisting of Knowledge Tracks, Labs, and Assessments to up-skill for specific roles. You can choose from various pathways tailored to your role and complete assessments to earn certificates. Completing all pathways is recommended before you pursue a full certification.

Extend Knowledge Content - site policies v1.0

Essential knowledgeThe Extend Knowledge Content serves as a showcase for the versatile extensibility features of the Fluent Order Management Platform, enabling use cases beyond its standard capabilities. This content operates under distinct licensing terms from the main platform and documentation. It includes open source licenses with disclaimers, emphasizing user responsibility. Contributions are welcome from both Fluent Commerce and external parties, provided they adhere to the established open source licenses. For legal inquiries, contact legalnotices@fluentcommerce.com.

Location API

Essential knowledgeA Location is any place where an order can be fulfilled and/or collected by the customer. Locations can include a store, warehouse, drop-ship vendor, lockers, or a third-party logistics or collection point.

Log Utilities

Essential knowledgeThe `LogUtils` class in the `util-core` bundle provides structured logging helpers that remove boilerplate code when using logging actions within your rules. These utilities make it easy to record key actions, errors, and checkpoints to the event log for debugging and auditing purposes.

Master Buffer: Strategic Adjustment of Available-to-Sell (ATS) Quantity

Essential knowledgeUnderstand the Master Buffer: a tool for final Available-to-Sell (ATS) quantity adjustments. This guide covers its function, configuration, and strategic applications. Using it offers precise, SKU-level ATS control, helping optimize stock, support promotions, prevent over/underselling, and align inventory with business goals.

Key Points:
- Final SKU-level ± adjustment applied after all quantity buffers to the aggregated SOH.
- Directly modifies ATS; negative calculated ATS becomes zero.
- Intended for strategic, deliberate application.

Metrics usage for Platform Observability

Essential knowledgeThis document is intended to describe to implementers which Metrics are available within the Fluent Big Inventory product and what kind of data they provide to achieve Platform Observability.Pre-requisites:

You should have knowledge of How Metrics works.
You should have knowledge of Events.
You should have knowledge of Fluent APIs.

Migrating from a multi-tenant to single-tenant environment

Essential knowledgeFluent Commerce cloud-native Multi-Tenant Software as a Service (SaaS) is a solution engineered to optimize order management processes. It uses multi-availability zone microservices and a pooled resources multi-tenancy model for performance and scalability. The Purpose of this document is to explain the high level process for migration of a Client from a multi-tenant environment to a single tenant environment.

MockApiClient

Essential knowledgeThe `MockApiClient` is a critical component of the `util-test` library. It provides a mock implementation of the `ApiClient`, which is the interface Rules use to communicate with the Fluent Commerce GraphQL API.By using the `MockApiClient`, you can test how your Rule behaves with different API responses without making any actual network calls. This isolates your tests, makes them faster, and allows you to simulate any scenario, including errors or empty data results.

Module Dependencies

Essential knowledgeLearn how module dependencies work, how they are described and when they are enforced.

Mystique Config Guide V1

Essential knowledgeThis config guide refers to version 1 of the UX Framework which is now deprecated

Order API

Essential knowledgeAn order is a customers request to purchase one or more items from a retailer. An order is created when a customer completes the checkout process against a Retailer Products.

Network API

Essential knowledgeA network is a collection of physical fulfillment or collection locations such as stores, warehouses, distribution centres, or even lockers. Fluent Retail allows users to manage their network from a centralized position with control of network-specific order logic via custom rules. The Network API defines the creation and addition of networks as well as retrieval of details pertaining to a network and updating the parameters of a network.There are three default networks,Collection Point Network,C&C Network, and Home Delivery Network. These can be extended and configured with subnetworks.

Metrics Overview

Essential knowledgeThis document is intended to introduce the Metrics and describe their place within the Fluent Big Inventory product.Pre-requisites:

You should have knowledge of the Inventory.
You should have knowledge of OMX Workflow Framework.
You should have knowledge of Events.
You should have knowledge of GraphQL.

OMX Design System Foundations

Essential knowledgeThe Order Management Experience (OMX) Design System provides guidelines for delivering a user experience tailored to the Omnichannel Order Management space. This article will describe the foundations of the Design System, including color palette and typography which make up the overarching design theme of the Fluent Commerce platform.

UX Framework - Component Library

Essential knowledgeThe OMX UX Component Library contains a suite of UI Components, ready to be configured and used in Fluent Web Apps. The Library contains Foundation, Content, Layout, Interaction and Field Components.

Open Source Licenses

Essential knowledgeOpen Source Licenses

What are Fluent OMS Entities? (Entity)

Essential knowledgeA detailed explanation of Fluent OMS entities and how they can be used throughout the order journey.

Orchestration & Audit Events

Essential knowledgeThis article describes the details of the different events in the Fluent platform and provides the required base knowledge for troubleshooting. This article expects that you have a good understanding of the Fluent Event Execution process and how Events are matched before the corresponding business logic is executed.

Orchestration Engine

Essential knowledgeThe Orchestration Engine powers the execution of workflows, business logic, and business processes. It enables real-time sync for orchestrated availability calls, high-volume batch processing for inventory loads and updates, event tracking which logs all activities, responds to events triggering execution, and triggers activity in external systems.

Order Management Experience (OMX) Framework

Essential knowledgeFluent's Order Management Experience (OMX) framework comprises the UX Framework, Workflow Framework, and Connect Framework, which can be configured and extended (or customised) using software development kits (SDKs).

Order Management Experience (OMX) Overview

Essential knowledgeOrder Management Experience is all about delivering the best possible experiences for our clients, that allow them to tailor their businesses to the fast-changing retail landscape, keeping costs down, and customer satisfaction high.

Order Management Interface

Essential knowledgeThe Order Management interface is the central workspace for managing the order lifecycle. It brings together orders, customers, billing accounts, returns, and escalated fulfilments in one view. Orders provide access to details and fulfilments. Customers show records including accounts and order history. Billing Accounts manage financial operations such as invoices, memos, and payments. Returns track customer or system-initiated cases with refund details. Escalated Fulfilments highlight exceptions requiring action.

Order Orchestration - Reference solution on how OMS selects the next best location for fulfilment

Essential knowledgeThis article provides an example of how OMS selects the next best location for fulfilment

Activity log

Essential knowledgeThe Activity Log is an audit trail of events that happen in the Fluent Commerce OMS app.

Order Utils

Essential knowledgeThe `OrderUtils` class in the `util-sourcing` is a utility class that provides order-specific utilities for sourcing operations. It handles order-related sourcing operations including fulfillment creation, fulfillment type determination, and order item management.

orderBillingAddress graphQL query and mutation

Essential knowledgeThe `orderBillingAddress` (aka `billingAddress`) is a sub-entity of the Order entity. A customer can optionally add a billing address while ordering items from a store, so an Order can store one `billingAddress` as an attribute.

Orders by Order Type Metric

Essential knowledgeLearn about the Orders by Order Type Metric in Fluent Analytics

Overriding Connector Features

Essential knowledgeBelow are the key features from `fc-commercetools-module`.

Overview of Payments in Fluent

Essential knowledge

Fluent Order Management enables the management of payments throughout the lifecycle of an Order.
Build custom payment logic into the Order workflow using the OMX Workflow Framework and provided entities.
This document provides an overview of the Payment Data Model and GraphQL API capabilities and does not include any reference Rules, Workflows, or UX Components.

Overview of Pick and Pack

Essential knowledgeThe Pick and Pack feature suiteof the Store Fulfilment app allows stores to pick and pack online orders that are allocated to the store based on store inventory at the time of order creation. The Fluent Store’s interface is used to access the capabilities of the Pick and Pack feature suite.

REST API

Essential knowledgeThe Fluent Platform provides and number of REST APIs for interacting with the platform.These differ from the primary GraphQL APIs which primarily cover domain entities. This section provides access to the REST based Platform APIs reference documentation.

Overview of the General module for Adobe Commerce Connector

Essential knowledgeThe General module manages credentials, API authentication, webhook validation, and a unified approach for making API requests, among other features. All other modules have a dependency on the General module.

Pack for Multi-Parcel Shipments

Essential knowledgeThe Pack feature of the Fluent Store empowers Store Associates to efficiently manage the packing process for multi-parcel shipments. It allows them to allocate items to specific parcels, add new parcels as needed, set parcel dimensions and weight, remove parcels, and reject items that don't meet requirements. This feature ensures that each parcel is properly organized and labeled, giving Store Associates complete control over the packing process.

Packing List Generation Logic

Essential knowledgeThe values on the packing list.

payment graphQL query and mutation

Essential knowledgeThe `payment` is an entity that is required as part of the payment process.

Payment Settings

Essential knowledgeThe below settings control the allowed values in the order transaction create method in the REST API (POST /api/v4.1/order/{orderId}/transaction). The createFinancialTransaction GraphQL mutation can use custom-defined paymentProvider, paymentMethod and currency fields. We recommend that the below settings be used as the way to look up current configured values dynamically without hardcoding values for these fields. These settings can be modified and retrieved via the settings API.

paymentServiceProvider graphQL query and mutation

Essential knowledgeThe `paymentServiceProvider` is an entity that is required as part of the payment process.

paymentTransaction graphQL query and mutation

Essential knowledgeThe `paymentTransaction` is an entity that is required as part of the payment process.

Peak Period Readiness & Black Friday

Essential knowledgeThe peak season, including events like Black Friday and Cyber Monday, is a critical time for retailers to maximize sales and meet customer expectations. Fluent Commerce has implemented measures such as extended support teams, scaled infrastructure, and a release freeze to ensure smooth operations during this period. Tailored guidance is available for businesses with unique promotional schedules or extraordinary sales volumes.

SSO Cutover Planning and Execution

Essential knowledgeThe SSO Cutover Planning and Execution details the essential steps for migrating and transitioning to SSO in Fluent. The specifics may differ based on the client's implementation of Fluent. It is advisable to have discussions with your partner and the Expert Services contact to gain further clarification.

Platform Limit Definitions (v1.0)

Platform Limit Definitions (v1.2)

Platform Limit Definitions (v1.1) [Superseded]

Platform Limit Definitions (v1.3) [superseded]

Platform Limits (v1.7)

Essential knowledgeThis page sets out the:

Platform usage limits;
Platform data limits; and
Acceptable Use Policy and other enforcement rights

relating to the Fluent Order Management Cloud Platform (Platform)

Platform Limits (v1.0-lingo)

Essential knowledgeThis page sets out the:

Platform usage limits;
Platform acceptable use policy; and
Data restrictions which apply to the use by clients and partners and their users of the Fluent Commerce Platform (Platform), also referred to as the Fluent Order Management or the Cloud Services.

Platform Limits (v1.1)

Essential knowledgeThis page sets out the:

Platform usage limits;
Platform data limits; and
Acceptable Use Policy and other enforcement rights

relating to the Fluent Order Management Cloud Platform (Platform)

Platform Limits (v1.2)

Essential knowledgeThis page sets out the:

Platform usage limits;
Platform data limits; and
Acceptable Use Policy and other enforcement rights

relating to the Fluent Order Management Cloud Platform (Platform)

Platform Limits (v1.3)

Essential knowledgeThis page sets out the:

Platform usage limits;
Platform data limits; and
Acceptable Use Policy and other enforcement rights

relating to the Fluent Order Management Cloud Platform (Platform)

Platform Limits (v1.4) [Superseded]

Essential knowledgeThis page sets out the:

Platform usage limits;
Platform data limits; and
Acceptable Use Policy and other enforcement rights

relating to the Fluent Order Management Cloud Platform (Platform)

Platform Limits (v1.5)

Essential knowledgeThis page sets out the:

Platform usage limits;
Platform data limits; and
Acceptable Use Policy and other enforcement rights

relating to the Fluent Order Management Cloud Platform (Platform)

Platform Limits (v1.6) [superseded]

Essential knowledgeThis page sets out the:

Platform usage limits;
Platform data limits; and
Acceptable Use Policy and other enforcement rights

relating to the Fluent Order Management Cloud Platform (Platform)

Product API

Essential knowledgeA Product is a conceptual entity with a product description and multiple sets of attributes. A unique combination of the Product attributes defines a SKU which is an item for sale.

Product Description - Fluent Commerce Big Inventory

Essential knowledgeThis is the Product Description for the Fluent Big Inventory Product. Fluent Big Inventory enables fast, intelligent processing of inventory data at scale. It serves as a unified solution for receiving, managing, and ensuring the accessibility of your inventory data for your business systems.This Product is available to purchase and use standalone or combined with other Fluent Order Management products.

Product Description - Fluent Hosted Connectors

Essential knowledgeFluent Connect provides Hosted Connectors for integration between Fluent Order Management and external systems such as marketplaces, commerce platforms, payment providers, service platforms, and inventory distribution services. This approach simplifies integrations, reduces delivery timelines, and enables reliable connectivity across platforms.

Product Description - Fluent Commerce OMS

Product GraphQL API Overview

Essential knowledgeThis article is intended to provide technical users with information about the Product GraphQL API, describing its functionalities within the Fluent Platform.
PrerequisitesYou should have knowledge of:

Products, Product Catalogs, and Product Management
Inventory Reference Module, including the Product Catalog Workflow Interface Contracts
GraphQL API

Product Management

Essential knowledgeProduct Master in Fluent OMS is defined in this hierarchy:

Categories
Standard Product
Variant Product

The UPSERT_PRODUCT event will help the user to manage the product-related entities in the OMS.

Products Interface

Essential knowledgeThe Products interface is a collection of products and any attributes and details associated with each product in the category.The Products interface of the Fluent Web App provides comprehensive capabilities:

Product Catalog management
Standard and Variant Product management
Category management

The module contains the following configurations:

Categories
Product Catalogues

Working with Fluent Commerce

Essential knowledgeThis article provides some key guidelines for working with Fluent Commerce on implementation projects, including platform and application support responsibilities.

Fluent Commerce Accounts

Essential knowledge This article will cover the typical Fluent Commerce account structure, the provisioning of accounts, and some key points covering performance testing.

Project Estimation

Essential knowledgeThis article covers the typical methods used to estimate projects. Take a look at our project sizing template, the MOSCOW framework, and an example of estimating by priority.

Python tool to compare entities attributes

Essential knowledgeThis is a tool for comparing 2 entities' attributes with the OMS. For example, customer support would like to compare order attributes between Production and UAT.

Query Comments

Essential knowledgeThe `comments` Query retrieves Comments based on various filter criteria.
Prerequisites

`COMMENT_VIEW` Permission is required for retrieving Comments

GraphQL Query Limits

Essential knowledgeThe following guidelines and specifications apply to the entire schema, with any exceptions documented in the schema of the relevant entity.

Query Utilities

Essential knowledgeThe `QueryUtils` class in the `util-core` bundle offers a set of functions to simplify GraphQL queries from within your Rules. These helpers make it easier to work with query results and handle common data structures like paginated connections.

Ready for Launch Process

Essential knowledgeThe Ready for Launch process (RFL) is an engagement with the Fluent Commerce Expert Services team throughout the lifecycle of a Fluent project. The process is initiated at the beginning of a Fluent Commerce project and completed with the go-live of the project in production.The final review ("RFL Launch Gate") should be planned for 3-4 weeks before the desired Go-Live event to receive the approval to move into production.

Project Roles and Responsibilities

Essential knowledgeThis article will cover the typical team setups involved in Fluent OMS projects, and the various roles and associated tasks in delivering a successful project.

Reference behaviour: Inventory Batch, Inventory Position and Inventory Quantity (Quantities)with RESERVED & SALE

Essential knowledgeReference behaviour: Inventory Batch, Inventory Position and Inventory Quantity (Quantities)with RESERVED & SALE

Reference behaviour: Inventory Batch, Inventory Position and Inventory Quantity (Quantities)with CORRECTION

Essential knowledgeReference behaviour: Inventory Batch, Inventory Position and Inventory Quantity (Quantities) with CORRECTION

Reference behaviour: Inventory Batch, Inventory Position and Inventory Quantity (Quantities) with DELTA

Essential knowledgeReference behaviour: Batch Inventory, Inventory Position and Inventory Quantity (Quantities) with CORRECTION

Reference Solutions - Overview

Essential knowledgeThe Connect SDK provides fundamental capabilities for integrating Fluent Commerce with external platforms, and it also offers additional features to facilitate multiple integrations between systems. To help clients comprehend these features, Fluent Commerce has created reference solutions, which are small projects that demonstrate how to leverage Connect SDK's capabilities to solve specific integration challenges. Essentially, reference solutions are examples that illustrate how to achieve various types of system integrations. This should be taken as a sample ONLY and accordingly modified specifically to production needs. Watch out for this page as we add more reference solutions over the coming months!

Removal Process of Client Personal Data from Fluent OMS/Ticketing System

Essential knowledgeThis document describes Fluent Commerce's methodology to remove Personal Data submitted by or on behalf of a Client to the Fluent OMS and Fluent Commerce’s Ticketing System (Personal Data) from those systems.

Reports page

Essential knowledgeDiscover how the Reports page in the Big Inventory Web App enables understanding an account Inventory Position Update and Inventory Position Change usage for selected periods.

Sourcing Profiles Interface

Essential knowledgeThe Sourcing Profiles functionality in the Fluent OMS Admin interface enables retailers to configure, manage, and optimize sourcing rules. Profiles group strategies with defined priorities, catalogs, and networks, while strategies use flexible conditions (IF) and criteria (THEN) to refine fulfillment logic. New profiles are created via API, while profile versions can be generated either through the Admin UI or API. The UI provides capabilities to view, edit, reorder, activate, and track versions.

Responsive Sourcing Framework Overview

Essential knowledgeThe Responsive Sourcing Framework is a configurable, scalable alternative to custom Workflows and Rules for managing sourcing strategies. You’ll learn how to define and optimize sourcing logic using Sourcing Profiles, Strategies, Conditions, and Criteria. The Framework empowers both technical and business users with faster implementation, greater control, and transparency into how sourcing decisions are made and why.

Retailer Batch

Essential knowledgeA Retailer Batch is used to create new Retailers within a Fluent Account. This can be used when a new retail operation is being onboarded to an existing Fluent Account or during the initial setup of the Fluent Account to create the required Retailers.

Retailer Settings

Essential knowledgeThis section explains the settings used in Retailer context.

Retailer Setup in SSO-Enabled Accounts

Essential knowledgeCreating new retailers within an SSO-enabled account involves specific considerations to ensure seamless integration and secure user management. This section provides guidelines on how to set up new retailers effectively post-SSO enablement.

Return API

Essential knowledgeA return is a customer's request to send back one or more items against an Order from the Retailer. A return can exist with or without the original order reference. If the original order reference exists, the return can contain the details of the returned items, the reasons, and the amount to be refunded. A return also could represent items within an original order that could not be fulfilled or has been canceled by the customer and requires a subsequent refund. Through the type of return, we can identify the context of the return, i.e., if it is a customer return, cannot fulfill or cancel.

Return Rate Metric

Essential knowledgeLearn about the Return Rate Metric in Fluent Analytics

Return Reason Ratio Metric

Essential knowledgeLearn about the Return Reason Ratio Metric in Fluent Analytics

Rule Actions

Essential knowledgeRule Actions are the single output of a Rule.Rules do not perform actions directly. Rather, they inform the Workflow Engine what it should do as a result of the rule execution. The Workflow Engine interprets the specific Action produced by the Rule and handles it appropriately.Most Actions are queued internally within the Workflow Engine and executed at the end of the current process.

Connect SDK - Frequently Asked Questions

Essential knowledgeFrequently Asked Questions on Connect SDK

Rule Context Generator

Essential knowledgeThe `RuleContextGenerator` is the underlying class that the `RuleExecutor` and `WorkflowExecutor` use to construct a mock `Context` for your tests. While you will most often interact with it through the executors, you can also use it directly to manually create a `Context` object.This is particularly useful when you are unit testing a helper or utility class that requires a `Context` object as a parameter, but you don't need to execute a full rule.

Rule Development Guidelines & Recommended Practices

Essential knowledgeThis document provides comprehensive guidelines and best practices for custom rule development on the Fluent Commerce platform. Following these guidelines ensures your Rules are maintainable, testable, and follow platform conventions.It is highly recommended that you first read Designing Rules and Writing Custom Rules if you have not done so already.

Rule Executor

Essential knowledgeThe `RuleExecutor` is the primary tool in the `util-test` library for unit testing a single rule in isolation. It provides a builder-style interface for setting up a mock `Context`, executing your rule's `run` method, and asserting the results.

Rule Utilities

Essential knowledgeThe `RuleUtils` class in the `util-core` bundle provides helper methods to streamline the process of retrieving and validating Rule properties. Using these utilities helps ensure that your Rules are configured correctly and reduces the risk of runtime errors caused by missing or invalid parameters.

Sales Channel Availability Management

Essential knowledgeHow to manage inventory visibility to each sales channel

Sample Rules

Essential knowledgeThe Rules SDK Maven archetype will generate 2 sample Rules into the Plugin Project.

DemoSendArbitraryEvent
DemoAddAttributeToOrder

SCIM Connector Architecture

Essential knowledgeThe integration between Azure Active Directory (or any other Identity Manager supporting SCIM 2.0 Specification) and the Fluent Commerce platform is done via a new component referenced further as Fluent Commerce SCIM Connector.

SCIM Connector Features

Essential knowledgeThere are a number of features provided as part of the SCIM Connector.

SCIM Connector Project Configuration

Essential knowledgeSCIM Connector Project Configuration

Search Sourcing Profiles

Essential knowledgeThe `sourcingProfiles` query retrieves existing Sourcing Profiles. It supports multiple filters and pagination.

Security Policy (v2.0)

Essential knowledgeDescription of the technical and organisational measures implemented by the Fluent Commerce (including any relevant certifications) to ensure an appropriate level of security, taking into account the nature, scope, context and purpose of the processing, and the risks for the rights and freedoms of natural persons.

Security Policy (v1.0) [Superseded]

Self-Service IPU/IPC visibility Overview

Essential knowledgeThis document will detail how customers can view their Inventory Position Update(IPU) and Inventory Position Change(IPC) usage from within the Inventory Web App. Using this, customers can easily compare their usage to contracted rates.Pre-requisites

To view the reports, a user must have:
- Access to the Fluent Big Inventory Web application
- Access to the Admin module of the Fluent Big Inventory Web application
- Assigned `ACCOUNTUSAGE_VIEW` permission
The UI is configured to display admin reports

Sell Through Rate Metric

Essential knowledgeLearn about the Sell Through Rate Metric in Fluent Analytics

Platform Services and Frameworks (version 1.0)

Essential knowledgeThe Fluent Order Management Cloud Platform is underpinned by a comprehensive infrastructure designed to support order management and inventory availability processes, comprising of technical capabilities organized into Services and Frameworks, each facilitating specific functionalities critical to platform operations.

Setting Schema

Essential knowledgeThe Setting Schema is a JSON schema used by the Settings Component to provide metadata for a setting, helping to define its structure. This schema primarily describes the fields that the component will render, allowing for a no-code configuration experience within the Fluent platform.

Settings Overview

Essential knowledgeThis page provides a high-level understanding of what settings represent within the Fluent platform.

Setting Utilities

Essential knowledgeThe `SettingUtils` class in the `util-core` bundle provides a robust set of tools for retrieving configuration settings from the Fluent Commerce API. A key feature of this utility is that it automatically respects the platform's setting hierarchy, ensuring that the most specific setting value is always returned.

Shared Responsibility Matrix model between Fluent Commerce OMS vs Customer

Essential knowledgeThis document outlines the shared responsibilities between Fluent Commerce and the Client, emphasizing data security, compliance, and user access management.

Shippit Connector

Essential knowledgeTo accelerate carrier integration between the Shippit and Fluent Order Management platforms, Shippit and Fluent Commerce provide a connector that enables seamless pick, pack and dispatch processes inside the Fluent Store App.

Shippit Connector Features Mapping

Essential knowledgeThe following mappings capture the features supported by the Shippit Connector.

SKU Velocity (List View) Metric

Essential knowledgeLearn about the SKU Velocity (List View) Metric in Fluent Analytics

SKU Velocity Metric

Essential knowledgeLearn about the SKU Velocity Metric in Fluent Analytics

Sold Inventory Metric

Essential knowledgeLearn about the Sold Inventory Metric in Fluent Analytics

Sources Interface

Essential knowledgeThe Sources interface provides inventory and batch-processing metrics visibility, enabling data ingestion and processing efficiency tracking. It includes:

Sources Dashboard – Monitors inventory updates, failure rates, and processing times.
BPP Metrics Dashboard – Tracks batch-processing efficiency, showing processed, changed, and unchanged records with a date range filter of up to 31 days.

Both dashboards use structured data, support trend analysis within configurable time frames, and require METRICS_VIEW permission for access.

Sourcing Conditions Overview

Essential knowledgeSourcing Conditions let you control how Sourcing Strategies are applied within the Responsive Sourcing Framework. After reading, you will understand how to configure and extend them to adapt sourcing logic for specific Sourcing Requests.

Sourcing Context Utils

Essential knowledge`SourcingContextUtils` in the `util-sourcing` is a utility class for managing sourcing context and data loading operations. It provides methods to create and populate sourcing contexts with order details, unfulfilled items, and supporting data required for sourcing decisions.

Sourcing Criteria Overview

Essential knowledgeSourcing Criteria determine which eligible Locations are best once a Strategy applies. You’ll learn how to configure, sequence, and extend Criteria so your prioritization is predictable and explainable across business scenarios.

Sourcing Profile GraphQL API Overview

Essential knowledgeThis article provides technical users with information about the Sourcing Profile GraphQL API, which enables configuration and querying of Sourcing Profiles within the Fluent Platform.

Sourcing Utilities Overview

Essential knowledgeThe `util-sourcing` library is a comprehensive collection of utility functions designed to minimize the overhead and complexity of writing sourcing logic in your Fluent Commerce rules.PrerequisitesThese articles assumes you're familiar with:

Java
Maven
JUnit

Sourcing Utils

Essential knowledgeThe `SourcingUtils` class in the `util-sourcing` bundle is the main utility class that orchestrates the entire sourcing process within a Rule. It provides core helper methods such as loading a Sourcing Profile, initialise the Sourcing Context, and trigger the execution of the sourcing logic configured in the profile. Each stage supports multiple customisation points throughout the process.

Corporate Identity Provider (IdP) Integration

Essential knowledgeIf a company has an internal IdP then this IdP can be integrated with our SSO Vendor and used for future user authentication.API user is always managed in the SSO vendor environment and doesn't have an MFA authentication option.

SSO

Essential knowledgeThis guide helps to select correct IDP configuration and plan SSO implementation.

Start your journey here

Essential knowledgeTo guide you through your journey of understanding and learning the Fluent Commerce OMS platform, the documentation is modeled according to the internal building blocks of the system, like 🔀Workflow or ⚙️Settings, with other top-level content types, such as 💡Essential Knowledge and 🧭How-to Guides layered on top of it. Dive right into it by starting here.

Store Interface

Essential knowledgeThe Store interface empowers retailers to enhance their operational efficiency by transforming stores into fulfillment centers and optimizing inventory management. This ultimately delivers a superior customer experience through streamlined order fulfillment and improved inventory control. The app contains the following configurations:

All Locations
Stores
Warehouses
Networks

Support Policy - Fluent OMS (v1.0) [Superseded]

Essential knowledgeThis Support Policy describes the support services provided by Fluent Commerce in connection with the “Fluent Order Management” Cloud Platform.

Support Policy - Fluent Order Management Cloud Platform (v1.1)

Essential knowledgeThis Support Policy describes the support services provided by Fluent Commerce in connection with the “Fluent Order Management” Cloud Platform.

Platform Support Process

Essential knowledgePlatform Support Process

Expert Service Packages

Essential knowledgeFluent Expert Services (ES) are our subject-matter experts who are responsible for ensuring that project implementations leverage the full extent of the software features and capabilities of Fluent OMS, and that best practices are followed. This article will cover the different service packages that are on offer to help facilitate the project, keep it moving forward and involve all parties (Expert Services, Partner, and/or the Client) working collaboratively to validate choices, monitor progress, and review developments.

Test Utilities Overview

Essential knowledgeThe `util-test` library is a comprehensive collection of utility functions, mock objects, and executors designed to minimize the overhead and complexity of testing your Fluent Commerce rules.PrerequisitesThese articles assumes you're familiar with:

Java
Maven
JUnit

Rules SDK Testing Rules

Essential knowledgeThis page describes the best practice testing approaches for rules and plugins.

Inventory Interface

Essential knowledgeThe Inventory interface of the Fluent Web app provides comprehensive inventory management capabilities:

Inventory visibility
Inventory allocation
The total quantity of stock for a specific item (stock on hand(SOH)) and the status of that inventory
Available to promise inventory levels
Inventory buffers to reduce overselling of products

The run Method

Essential knowledgeThe `run` method is called by the Workflow Engine when executing each Rule in a Ruleset triggered by an Orchestration Event.

Top 10 Purchased Products Metric

Essential knowledgeLearn about the Top 10 Purchased Products Metric in Fluent Analytics

Top 10 Products Fulfilled Metric

Essential knowledgeLearn about the Top 10 Products Fulfilled Metric in Fluent Analytics

Top 10 Reserved Products Metric

Essential knowledgeLearn about the Top 10 Reserved Products Metric in Fluent Analytics

Top 10 Short Picked Products Metric

Essential knowledgeLearn about the Top 10 Short Picked Products Metric in Fluent Analytics

Top 10 Returned Products Metric

Essential knowledgeLearn about the Top 10 Returned Products Metric in Fluent Analytics

Total Available Metric

Essential knowledgeLearn about the Total Available Metric in Fluent Analytics

Total Completed Fulfillments Metric

Essential knowledgeLearn about the Total Completed Fulfillments Metric in Fluent Analytics

Total Correction Metric

Essential knowledgeLearn about the Total Correction Metric in Fluent Analytics

Total Escalated Fulfillments Metric

Essential knowledgeLearn about the Total Escalated Fulfillments Metric in Fluent Analytics

Total Expired Fulfillments Metric

Essential knowledgeLearn about the Total Expired Fulfillments Metric in Fluent Analytics

Total Failed Fulfillments Metric

Essential knowledgeLearn about the Total Failed Fulfillments Metric in Fluent Analytics

Total On Hand Metric

Essential knowledgeLearn about the Total On Hand Metric in Fluent Analytics

Total Orders Metric

Essential knowledgeLearn about the Total Orders Metric in Fluent Analytics

Total Partially Fulfilled Fulfillments Metric

Essential knowledgeLearn about the Total Partially Fulfilled Fulfillments Metric in Fluent Analytics

Total Return Amount Metric

Essential knowledgeLearn about the Total Return Amount Metric in Fluent Analytics

Total Return Orders Metric

Essential knowledgeLearn about the Total Return Orders Metric in Fluent Analytics

Total Revenue Metric

Essential knowledgeLearn about the Total Revenue Metric in Fluent Analytics

Total Fulfilled Fulfillments Metric

Essential knowledgeLearn about the Total Fulfilled Fulfillments Metric in Fluent Analytics

TRAINING TERMS AND CONDITIONS

Essential knowledgeTRAINING TERMS AND CONDITIONS

Uncollected Articles

Essential knowledgeThe UNCOLLECTED Articles feature of the Fluent Store module provides a capability for the retailers to set a collection SLA for the customers.

Understanding IDs and Refs in GraphQL Entities

Essential knowledgeThe Fluent platform generates unique IDs internally, which serve as the primary key for each new record. They are unique and enforced to avoid ambiguity. Users cannot set these via API. Whereas refs are typically from third-party integrations, they represent external system IDs and occasionally are generated internally with guaranteed uniqueness. It is the integrator's responsibility to ensure refs are unique in Fluent Commerce.

Unified View of Inventory Interface

Essential knowledgeThe Unified View of Inventory (UVOI) interface consolidates data from multiple locations and channels into a single, real-time interface. It provides centralized inventory search, advanced filtering, and customizable views. It enables you to monitor, analyze, and act on inventory data.

General Principles for Rules

Essential knowledgeUnderstand what are some general Rule principles.

Multi-factor authentication (MFA)

Essential knowledgeMulti-factor authentication (MFA) is used to ensure that digital users provide at least two pieces of evidence to prove their identity. Each piece of evidence must come from a different category, something they know, have, or something they are.Traditionally, authentication mechanisms or factors have been categorized as belonging to one of three groups:

Something you know (for example, a password or a PIN).
Something you have (for example, a mobile phone or a token).
Something you are (for example, a fingerprint or other biometric data).

In best practice, though, MFA goes beyond 2FA by requiring a user to authenticate via two or more authentication factors from different categories (e.g., a “something you know” combined with a “something you have”). The goal of having two or more authentication factors from different categories is to reduce the likelihood of an impostor gaining access.

UX Framework - Configuration Guide

Essential knowledgeThe OMX UX Framework delivers configuration-based solution implementation for UIs (Web Apps). Configuration is managed in a JSON document called the OMX Web App Manifest.

SSO Audit

Essential knowledgeThis page describes where to find user activity logs in SSO Environment. Ping Identity (SSO Vendor) logs all actions performed in the SSO admin console and keeps logs for two years by default. Review logs if you need to investigate an activity of a certain users or check a number of failed logins.

Rulesets

Essential knowledgeRulesets are fundamental components in implementing business flows. They are reusable collections of rules that contain orchestration logic. These functions can be applied across various workflows and use cases, providing flexibility and efficiency. The Order, Inventory, and Fulfilment reference modules contain a set of pre-defined rulesets, each with its corresponding rules.

Password Policies

Essential knowledgeA password policy dictates the strength and complexity requirements for a password or passphrase.Fluent IdP supports the following types of password policies:

Basic: The basic policy is a more relaxed standard that allows maximum customer flexibility. The basic policy can be less secure because users are not required to change their passwords.
Passphrase: The passphrase policy encourages users to use a passphrase instead of a password for stronger authentication. A passphrase can be easier to remember and more secure because of its length.
Standard: The standard password policy incorporates industry best practices for a typical password policy. By default, a basic password policy with all requirements and rules cleared is set for each Client Account on the Fluent IdP side.

Fluent OMS Project Phases

Essential knowledgeLearn about the typical phases for delivering Fluent OMS projects from Discovery to 'Go Live'.

Mixed Baskets User Interface

Essential knowledgeThe Fluent OMS module is pre-configured with certain standard functions. Mixed Baskets functionality is not a part of the default pre-configuration. The reference manifest fragment represents the new UI for Mixed Baskets functionality. Detailed information on configuring UI for Mixed Baskets is available in the guide.

Product Description - Fluent Commerce OMS

Workflow Configuration - Getting Started

Essential knowledgeClients and Partners will need to have their Fluent Account set up prior to being able to work with Orchestration.You should have received an "Account Ready" email with your Fluent Account Details, including user login credentials.If you do not have access to a Sandbox account, please contact your Fluent Account Manager.

API Retries and Exponential Back-offs

Essential knowledgeExponential backoff is a standard error handling policy for network communications such as the Fluent APIs. Exponential backoff involves a client periodically retrying a failed request over an increasing amount of time.

Designing Workflows

Essential knowledgeYou will learn how to design workflows, what they consist off and what are the best practices.

Fluent Commerce Fundamentals

Essential knowledgeThis is a guidepost for Developers highlighting important guides and articles to speed up Fluent Commerce's learning process.

Where can I get help?

Essential knowledgeThere are several ways to get in touch with the team. Continue reading for assistance.

Admin Interface

Essential knowledgeThe Admin interface in the Fluent Web Apps provides comprehensive administrative capabilities to manage the entire system efficiently.

createOrderAndCustomer sample

Essential knowledgeGQL createOrderAndCustomer example

Getting Started Configuring Fluent Store

Essential knowledgeThe Fluent Store web app is a preconfigured baseline web app which can be used as a starting point for your projects.The default UX templates are hosted on the platform, so there is no need to create the manifest settings yourself, unless you need to customize the existing baseline configuration.

REST API Error Codes Overview

Essential knowledgeFluent REST API returns specific HTTP Error Codes which may vary depending on the API endpoint and are explained in this document.

Getting Help with Support & Operations

Essential knowledgeThe support process at Fluent Commerce relies on integration partners to handle initial investigations for issues related to custom implementations. If platform-related problems are identified, partners must escalate them via a JIRA support ticket. Additionally, Fluent Commerce offers Expert Services for guidance during the design, implementation, and support phases.

Authentication policies

Essential knowledgeAuthentication policies dictate how to verify a user's identity.

Fluent OMS UI / Admin Console Date Time Format - (include UTC conversion)

Essential knowledgeHandy reference guide on how to display date time value on the UIFor Date format and conversion in UI, two functions can be used:

`formateDate`
`dateStringFormatter` (if true, then it will leave it as UTC timezone, else, it will convert to the user's browser timezone)

Topics for Project Discovery

Essential knowledgeDiscovery is the critical first phase of any project where all parties develop a shared understanding and mutually devise strategies to solve the various problems from an OMS perspective. It gives the opportunity to align the client, project team, business, IT stakeholders, and other vendors but also ensures the project is steered in the right direction with a strong foundation. Discovery topics refer to the main areas we suggest should be covered during a discovery session.

Users Configuration Overview

Essential knowledgeOMS Webapp's Users List page allows users to efficiently search and view existing users using a versatile filter component. The Users table provides essential user details, with a clickable Username link leading to a detailed User Details page displaying user information. The paging control at the bottom ensures easy entry management with customizable rows per page and intuitive navigation.

How to Use Enhanced Inventory Attributes in Your Payloads

Essential knowledgeThis guide explains how to leverage the `attributes` object to include custom data in your inventory payloads. By supporting both simple key-value pairs and complex JSON structures, the `attributes` object offers the flexibility to meet diverse business requirements—whether you’re managing detailed product information, optimizing warehouse processes, or integrating with custom workflows. You’ll also learn about recommended attribute fields like `expectedOn`, `storageAreaRef`, and `condition`, which are automatically integrated into Inventory workflows for streamlined updates and better data consistency.

Update Comment

Essential knowledgeThe `updateComment` Mutation allows for the updating of an existing Comment object.
PrerequisitesSpecific Permissions are required for updating Comments:

`COMMENT_UPDATE`
`COMMENT_VIEW`

Upsert Location Module

Essential knowledgeThe Upsert Location Module contains the workflow and supporting rules to update or create (aka upsert) locations. This page covers the steps to configure and install the Upsert Location Module.

User Lockouts: What to Expect After Too Many Failed Login Attempts

Essential knowledgeThis article explains what happens when an account is temporarily locked due to multiple failed login attempts, whether caused by a user entering the wrong password or an integration using outdated credentials.After reading this article, you will understand:

What triggers a username lockout in Fluent
How the lockout works
What actions users and integration owners should take

Key Points to Know:

Lockouts are temporary (15 minutes).
Applies to both web console users and API clients.
A lockout is enforced even if the correct password is entered after the threshold is reached.

SSO User Management

Essential knowledgeUser management is a client’s internal process. Your nominated IT team or a partner is responsible for user management.

SSO User onboarding and offboarding

Essential knowledgeThe document describes the best practice for onboarding and offboarding users.

Users, Roles, and Permissions

Essential knowledgeThe Fluent platform provides a comprehensive user role management system, allowing for the assignment of diverse permissions via roles to regulate platform access and functionalities. Custom roles can be created and fine-tuned, ensuring users only have access to appropriate functionality and data. The system provides flexibility to specify the scope for a role at different context levels, such as Accounts, Retailers, and Locations.

UX Configuration - Deprecated (v1) - Overview

Essential knowledgeMystique customizes the Fluent Admin Console UI, offering businesses development-free control over data presentation and business rules. This empowers them to configure user-centric functions for optimal value. A best-practice template is included. Mystique optimizes existing modules and enables new module creation based on entity perspectives. Please take a look at how it works below for configuration details.

UX Framework - Overview

Essential knowledgeThe OMX UX Framework, or Mystique, delivers configuration-based solution implementation for UIs (Web Apps) that understand the Fluent Platform. It enables UIs to react to changes within workflows and provides best-in-class user experience and design. Web apps can be built using code-free configuration, utilising a rich library of ready-to-use UI Components. Customising UIs to meet specific business requirements using Component SDKs is also possible. Configuration is managed in a JSON document called the OMX Web App Manifest.

UX Framework Overview

Category API

Essential knowledgeBelow are the properties available in the Category object, which can be updated and retrieved through the APIs in this document.

REST Event API

Essential knowledgeEvents are a fundamental part of the Fluent Platform. Not only are they used to trigger workflow logic, but they also capture everything that happens within the system. Events are categorized by type.

Fulfillment Options API

Essential knowledgeThe Fulfillment Options API retrieves the proposed Fulfillment Options for the customer order.

Job API

Essential knowledgeA Job represents a container that can hold multiple batches. A job stays open until midnight (UTC), where the status will change to CLOSED. All jobs are processed concurrently.

Order Item API

Essential knowledgeAn Order Item is the SKU purchased by the customer on the Retailer's online store. There can be one or many Order Items within an Order. Each order item has an associated quantity and paid price.

Plugin API

Essential knowledgeThe Plugin API provides methods for uploading, installing, and viewing Plugins.A Plugin Bundle represents a collection of rules for a retailer that is uploaded and installed into Rubix for use in workflows. They can be developed and installed through the use of the Fluent SDK.

Settings API

Essential knowledgeSettings API is used to set configurations used by the platform, accounts and retailers. See Commerce Apps documentation for specific settings keys and their function.Configurations have a hierarchy of contexts in which they can be applied. GLOBAL, ACCOUNT and RETAILER are the levels in decreasing order of context, where GLOBAL is reserved by platform use and ACCOUNT and RETAILER are available to developers to override the GLOBAL defaults.

SKU API

Essential knowledgeSKU is the specific item that can be purchased by the customer. SKU has a unique set of attributes such as colour and size. Product is the parent of SKU and must be created before the SKU API can be used.

Transaction Order API

Essential knowledgeAn API Order transaction defines the payment or refund details associated with an Order.

Transaction Return API

Essential knowledgeAn Order transaction defines the payment or refund details associated with an Order.

User Action API

Essential knowledgeThe User Action API provides the framework to interact with orchestration via the ServicePoint and Admin Console platform portals, as well as the capability to interact with various other external applications. This interaction provides the capability to translate unique requirements into a user interface.

Workflow API

Essential knowledgeA workflow defines the orchestrated business logic to be applied to an entity on a given event. A workflow consists of Workflow States and Workflow Rule Sets for an Entity. The Workflow States specify the states that the entity could be in at any given point in time. The Workflow Rule Sets specify the business rules behind the progression of these states.

Virtual Position Queries

Essential knowledgeSample Virtual Position Queries that can be used on a daily basis

Settings

Essential knowledgeSettings configuration contain:

Settings List page
Setting Details page

What if I need to modify a Rule from a Module?

Essential knowledgeThis resource page offers detailed instructions on how to find assistance when looking to alter the Rules that are part of a Module.

What is a Module

Essential knowledgeThis article introduces the concept of a Fluent Commerce Module, describing it's basic structure and content.

What is a Reference Module?

Essential knowledgeA Reference Module is a Module provided by Fluent Commerce that is designed to provide reference artifacts that you can use to create your own solutions. While an Extension contains an entire solution within itself, Reference Modules provide Domain Artifacts that can be used to speed up building your solutions. Structurally, Reference Modules are identical to Modules, as are Extensions.

What is an Extension?

Essential knowledgeExtension definition in Fluent OMS

Why Fluent Commerce Focuses on SOC 2 Type 2 Attestation (Not SOC 1 / ISAE 3402)

Essential knowledgeFluent Commerce prioritizes SOC 2 Type 2 attestation over SOC 1 / ISAE 3402 due to its focus on order management, fulfillment, and inventory processes. SOC 2 Type 2 evaluates controls across Security, Availability, Processing Integrity, Confidentiality, and Privacy, addressing customer concerns about data protection and system reliability. Annual audits reinforce Fluent Commerce's commitment to these areas.

Configuring Wildcard Search with a Two-Layer Model

Essential knowledgeThis article describes the two-layer configuration model for controlling wildcard behavior in string-based search filters.The new model introduces:

An account-level wildcard configuration (the `fc.mystique.filters.string` setting) that defines the default wildcard behavior for all string filters
A field-level override (`wildcardFilter`) inside the `fc.filter.string` component, which allows customizing wildcard behavior for specific fields.