Essential Knowledge

The 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.

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

Fluent 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.

Modules 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

The 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.

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

Mutations 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.

Query 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

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

An 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.

APIs use authorization to ensure that client requests access data securely. This can involve authenticating the sender of a request and verifying that they have permission to access or manipulate the relevant data. The below request will return a bearer token. This token can then be used in the header of subsequent API calls to confirm authentication.

Authentication 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.

Token authentication is mandatory for all Fluent integrations.

Availability 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.

The 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.

A 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.

This 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.

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

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

Fluent 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.

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

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

A 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.

The 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

commercetools Connector Project Configuration

commercetools 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.

The 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.

Some 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.

Getting Started Guide for Component SDK

The 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.

Rules or controls that determine what inventory is available in a Virtual Catalog

Controls can be used to:

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

Fluent 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.

A best practice guide of creating customer entity.

• Example createOrder mutation payload for MULTI order type

createFinancialTransaction GraphQL mutation Example

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

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

Rewarding way for customers to share their achievements.

This 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.

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

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

This guide provides solutions to common issues encountered in eLearning environments, including troubleshooting steps for login errors, exam resets, and password recovery.

This document explains the GraphQL Error Codes used by Fluent Commerce.

Character 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.

Using the Event API

The 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.  

The 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.

This 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.

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

Fluent 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.

The 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.

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

List of Fluent Commerce sub-processors.

Project 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.

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

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

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

The 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.

The 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.

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

Fluent 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.

This 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)

The 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.

The 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 is an in-store responsive web application that provides store staff with end-to-end order management capabilities.

This guide helps to select the correct IDP configuration and plan SSO implementation.

A 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.

An overview different types of fulfilment that is used in OOTB workflow

In 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.

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

This 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.

The 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.

This 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.

The 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.

Sample GQL payload to use @skip and @include directives

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

Sample Inventory Queries that can be used on a daily basis.

GraphQL 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.

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

Every GraphQL operation is currently protected by Permissions. 

Sample Product Queries that can be used on a daily basis

This 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.

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

The 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.

This 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.

Describes 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.

Fluent 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.

This 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.

This page describes how Event Execution works.

This 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).

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

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

• Delivery method
• Delivery or pickup address
• Delivery dates

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

Fluent'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.

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

Component 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.

General Principles and the Features of the SDK

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

The Rules SDK comes with 2 API Collections:

• Postman Collection
• Insomnia Collection

The 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 configuration contains:

• Warehouses page
• Warehouse Details page

Cloud 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.

Stores configuration contains:

• Stores page
• Store Details page
• Location Ref
• Created On
• Updated On

This 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 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 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.

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

Roles & Permissions configuration contains:

• Roles & permissions page
• Role Details page

Customer configuration contains:

• Customer List page
• Customer Details page

An 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 configuration contains:

• Waves List page
• Wave Details page

Networks configuration contains:

• Networks List page
• Network Details page

• Fulfilment Options page
• Further Reading

The 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 configuration contains:

• Collections List page
• Article Details page

This 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 OMS configuration contains:

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

A 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.

Single 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.

A 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 configuration contains:

• Arrivals List page
• Article Details page

The Insights module 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.

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

A 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 offer insights into the processing status of Inventory Batches, helping to determine whether the corresponding records within a batch were successfully submitted for processing.

This 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.

This section covers the basics of Fluent Account setup and walkthrough of the LaunchPadV1

This 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.

This 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

This lesson covers the various integrations and connections with the Fluent platform.

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

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

This 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.

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

This 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.

This 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.

This 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.

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

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

This 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.

In 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

This 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.

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

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

This 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.

Fluent 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.

This 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.

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

This 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.

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

This 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.

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

This section outlines how the webapps interact with the modules

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

This 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.

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

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

This 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`.

Workflow 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. 

In 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. 

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

This section covers the scope of the Setup and Configuration course and the required prerequisites 

This 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.

This 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.

This 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.

In this lesson, we'll look at Event APIs, learn more about Event Contracts and the role of Events in the Workflow Framework, as well as look at some common integrations that use the Events API.

This 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.

This 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.

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

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

In 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.

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

This 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.

This course covers how product master data is handled in Fluent.

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

These 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.

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

The 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.

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

This 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.

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

Following 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.

What is Fluent Order Management?

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

This topic describes the cloud native nature of the Fluent platform

Fluent 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 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.

In 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.

The '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.

You'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.

One 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.

In 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.

This 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.

This 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

This 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.

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

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

This 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.

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

This topic describes an example "Ship from Store" Customer Journey

Split 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.

This article covers how Store arrivals are handled in Fluent OMS.

Sourcing 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.

This 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.

This 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.

Fluent 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.

In 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

This 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.

This 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.

This 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.

This 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.

This 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.

This 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.

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

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

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

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

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

You will learn about key Workflow concepts and the Workflow Builder 

This 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 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.

A 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.

Understand 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.

Fluent 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.

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

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

An 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.

A 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.

The 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. 

The 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

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

The  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.

Fluent'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 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.

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

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

The `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.

Below are the key features from `fc-commercetools-module`.

• 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.

The 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.

The 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.

The 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.

The values on the packing list.

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

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

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

All the details you need to get ready for peak season and black Friday.

The 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.

This 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)

This 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.

This 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)

This 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)

This 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)

A 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.

This 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 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.

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

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

This 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.

This 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.

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

The 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.

This 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

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

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

The 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!

This 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.

Discover 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.

A 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.

This section explains the settings used in Retailer context.

Creating 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.

A 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.

Rule 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.

Frequently Asked Questions on Connect SDK

How to manage inventory visibility to each sales channel

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

• DemoSendArbitraryEvent
• DemoAddAttributeToOrder

The 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.

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

SCIM Connector Project Configuration

Description 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.

The 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.

The 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.

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

To 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.  

The following mappings capture the features supported by the Shippit Connector.

The Sources section provides visibility for inventory and batch-processing metrics, 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.

If 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.

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

To 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.

The Fluent Store Web App empowers retailers to enhance their operational efficiency by transforming stores into fulfillment centers and optimizing inventory management, ultimately delivering a superior customer experience through streamlined order fulfillment and improved inventory control. 

The app contains the following configurations:

• All Locations
• Stores
• Warehouses
• Networks

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

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

Platform Support Process

Fluent 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.

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

The Inventory module 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 is called by the Workflow Engine when executing each Rule in a Ruleset triggered by an Orchestration Event.

TRAINING TERMS AND CONDITIONS

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

The 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.

The Unified View of Inventory (UVOI) 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.

Understand what are some general Rule principles.

Multi-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.

The 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.

This 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.

A 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.

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

Fluent 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.

Exponential 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.

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

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

We are here to help and there are several ways how to get in touch with our team. Read on if you'd like some help!

The Admin user interface in the Fluent OMS Web App provides comprehensive administrative capabilities to manage the entire system efficiently.

GQL createOrderAndCustomer example

The 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.

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

The 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 dictate how to verify a user's identity.

Handy reference guide on how to display date time value on the UI

For 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)

Discovery 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.

OMS 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.

This 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.

The 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.

This 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.

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

The document describes the best practice for onboarding and offboarding users.

The 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.

Mystique 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.

The 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.  

The 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.  

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

Events 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.

The Fulfillment Options API retrieves the proposed Fulfillment Options for the customer order.

A 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.

An 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.

The 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 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 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.

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

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

The 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.

A 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.

Sample Virtual Position Queries that can be used on a daily basis

Settings configuration contain:

• Settings List page
• Setting Details page

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

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

Extension definition in Fluent OMS

The Connect Framework provides low-code tools that allow non-technical users to configure their ecosystem integrations easily. In situations where the standard configuration options are not enough, developers can build their own custom solutions using the Software Development Kits (SDKs) provided, which include tools and design patterns for building specific integrations and processes via Connector SDK, which is used to build custom Integrations.

Anti-Patterns are patterns found which are not recommended practice, or violate best practice guidelines, and can be harmful to performance and reliability.

Frequently asked questions around composing a workflow from workflow fragments.

This section covers the fundamentals of the Workflow Engine, provides an overview of the architecture, identifies key concepts, and prepares clients to build and use their workflows.

The Workflow Engine (aka Rubix) is the engine that drives the Fluent platform. The Workflow Engine enables business process orchestration, workflow automation, and underpins the specific feature sets and functionality for each of the Fluent apps. Additionally, the Workflow Engine is built to be highly scalable, and provide high-performance workflow execution across any domain.

Best Practices for Workflow Design: Keep in Mind These Principles.

This article describes settings that can be added to a Workflow. 

Workflows are the backbone of the Fluent platform as they describe the lifecycle of an entity. Defining subsections or sub-processes within a workflow allows to manage and evolve them independently. Thus fostering loosely coupled and self-contained fragments with no duplication of shared or unchanged behavior of a baseline workflow.

On this page we will look at the different ways of structuring workflows into fragments and then how to optimally merge them into a final workflow that is used to orchestrate entities. Finally how to package both workflows and fragments into a module.

In this document we will describe how to work with workflows and workflow fragments using the Fluent CLI. Then delve into how the tool is tracking the installed workflows, fragments in the workflow log.