Latest Articles
Recent releases related to Fluent Connect
Stock Segmentation - Data Model and API Overview
Essential knowledgeCore knowledge to understand Fluent CommerceStock Segmentation extends Fluent’s Inventory and Virtual Catalog data models to represent multiple logical segments for the same product and location using explicit, queryable factors.Stock Segmentation supports scenarios such as channel-specific reservations, manufacturing batch traceability, compliance restrictions (for example by country of origin), and supplier-level inventory management while preserving a single physical inventory model per product and location.This document explains the data model and GraphQL API capabilities introduced for Stock Segmentation.- Physical stock in the Inventory Catalog is stored as Inventory Quantities. You can segment them with these fields:
`condition`, `expiresOn`, `countryOfOrigin`, `channel`, `manufacturer`, `manufacturerBatchNumber`, `supplier`, `storageAreaRef`, `segment1`, `segment2`, and `segment3`. - Inventory Quantities support parent-child hierarchies. Use the parent relationship to model multi-level segmentation trees.
- Inventory Quantities can be linked to operational entities using
`associationType` and `associationRef. `The main use cases are linking reservations and tracing stock. - Use Virtual Segments to expose customer-facing segments in virtual availability.
- Segmentation fields only support exact match. Partial matching isn't supported.
- Exception: the
`inventoryQuantities` query supports wildcard search on `condition` and `storageAreaRef`.
- Filter values ignore case, except
`type` and `status` in `updateInventoryQuantitiesStatus`.
Webhook Retries and Inline Events
Essential knowledgeCore knowledge to understand Fluent CommerceThis page explains how the Orchestration Engine retries a webhook that is reached through inline events, and helps you decide which value of `fc.rubix.webhook.retry.event` to use for your account.It describes how each workflow pattern is affected, what each value does, and what to check before you change the setting.- Prerequisites: Webhooks, Inline Event, Understanding Event Execution
- A webhook action is retried only when its request fails with a network error, such as a timeout. This happens most often when the receiving system is under load, for example during peak trading
- With
`webhook-event`, the retry uses the webhook event, which is the event that triggered the ruleset in which the webhook action was produced:- The retry is posted to the same endpoint with the same event as the original call
- If the receiving system responds, with any HTTP status code, the retry counts as delivered and retries stop
- If all retries fail, the Exception event is raised for the ruleset and entity of the webhook event
- With
`initial-event`, the retry uses the initial event, which is the event that started the event context:- The retry is posted to the same endpoint, but with the initial event, so the event name, the entity, and the attributes can differ from the original call
- If the receiving system responds, with any HTTP status code, the retry counts as delivered and retries stop. The original call isn’t sent again, and the Send Webhook audit event shows
`SUCCESS`, so the failure goes unnoticed - If all retries fail, the Exception event is raised for the ruleset and entity of the initial event, not for the ruleset of the webhook event
- The values differ only when the webhook event is an inline event. When the webhook action is produced in the ruleset triggered by the initial event, both values give the same retry
- Accounts created before the setting was introduced keep
`initial-event` until you change it. Accounts created since then use `webhook-event`. Check your workflows with this page, then switch to `webhook-event` - For custom webhook rules and the reference
`SendWebhook` rule, also add `preserve-event-details` to the workflow, so the retry reruns the rule that produced the webhook action. Without it, the retry is sent by the built-in platform webhook rule. See `fc.rubix.sdk.webhook.retry.method`.
Fluent CLI Reference (v2.x.x)
Essential knowledgeCore knowledge to understand Fluent CommerceThis guide covers Fluent CLI v2.x.x, the primary tool for managing Fluent Commerce accounts and assets. Implementing partners use it to automate environment setups and integrate workflows into CI/CD pipelines. For the business, the CLI ensures faster deployment cycles and high consistency.Note: From version 2.3.0, requires a patched Node.js release: ^22.23.4 || ^24.22.1 || >=26.12.1 (earlier 2.x versions: >=20.0.0 <25.0.0).- Profile Management: Use
`profile create` to securely store account IDs, client secrets, and base URLs. Profiles serve as the foundation for all subsequent commands. - Module Lifecycle: Supports the full lifecycle:
`create` from templates, `config` for environment settings, and `install` for sequential asset deployment. - Asset Processing Order: Assets are processed in a specific dependency-aware order (e.g.,
`rules` and `locations` before `workflows`) to ensure system stability. - Workflow Operations: Features robust
`download` and `list` commands with `--json` support, enabling advanced data manipulation using tools like `jq. - Event Operations: Use
`event list` to inspect event history and `event send` to submit an event, for example to recover an order after an issue or to test a workflow during development. - Environment Context: Most commands require a
`-p` (profile) and `-r` (retailer) flag to define the target environment. - Batch Operations: The
`blueprint` command allows for high-volume setup tasks, essential for large-scale data migrations or initial account provisioning. - Logging & Debugging: Use the
`--debug` flag to resolve connectivity or validation issues by viewing the raw communication between the CLI and Fluent APIs.
Getting Started Configuring Fluent Big Inventory Web App
Essential knowledgeCore knowledge to understand Fluent CommerceThe 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.- The Fluent Big Inventory Web App comes with pre-configured standard functions, offering a user-friendly interface for effective management of products, inventory, feeds, and sources.
- Default UX templates are readily available on the platform, eliminating the need to create manifest settings unless customization of the existing baseline configuration is required, streamlining the setup process for a seamless user experience.
Utility Bundles Overview
Essential knowledgeCore knowledge to understand Fluent CommerceThe Fluent Commerce Utility Bundles are a set of libraries designed to speed up Rule development, reduce boilerplate code, and improve the overall quality and maintainability of implementations. They are essential for writing maintainable, reusable, and easily upgradeable Rules for the Fluent Commerce platform.- Prerequisites: You should have knowledge of the Rules SDK, including Designing Rules, Rule Structure, Writing Rules, Rule Development Guidelines, General Principles, and Rules SDK - Getting Started.
- Focus on Business Logic: The libraries handle common, repetitive tasks (like data fetching and JSON conversion), allowing developers to concentrate on writing the business logic that delivers value.
- Specialized Bundles: The utilities are organized into the following modules:
`util-core` for essential daily tasks`util-dynamic` for building runtime queries`util-test` for simplifying testing`util-controls` for consistently applying controls
- Easy Upgrades: Receive bug fixes and new features from Fluent Commerce by updating the dependency version in your
`pom.xml`, ensuring your implementation stays current. - Built for Extensibility: The utilities are flexible and let you to inject your custom logic into standard processes.
Fluent CLI - Template Token Functions
Essential knowledgeCore knowledge to understand Fluent CommerceGuide to using `lower()`, `upper()`, and `env()` functions inside Fluent CLI template tokens.- Three functions available:
`lower()`, `upper()`, and `env()` wrap a name inside the usual `[[...]]` token delimiters to transform or source a value. - Function parameters are token names, not literals — except for
`env()`, whose parameter is a literal environment variable name, not something looked up in the current token context. - Scope differs by function:
`lower()`/`upper()` resolve anywhere a token resolves (module config, workflow fragments, asset files); `env()` only resolves in module config values and errors if used elsewhere. `env()` is prefix-gated and fails closed: only environment variables matching `--env-prefix` (default `FLUENT_`) are readable, and a missing or disallowed reference aborts the command rather than silently installing the literal placeholder text.- No secret-store behaviour on the Fluent side:
`env()` keeps a secret out of the module config file and version control, but the resolved value still lands in plaintext in the uploaded workflow and the workflow log history, exactly like any other config value. - No nesting or chaining: functions can't be composed directly — resolve one function into a named template value first, then reference that value with a second function elsewhere.
GQL mutation createOrder Example
Essential knowledgeCore knowledge to understand Fluent CommerceGQL createOrder example`createOrder` differs from `createOrderAndCustomer` in one key respect: it expects an existing customer, referenced by numeric ID, rather than a customer object to be created inline. Use `createOrder` when the customer already exists in the retailer's Fluent tenant. Use `createOrderAndCustomer` when the customer needs to be created as part of the same call.- Example GQL of
`createOrder` `customer` is passed as `{ id: <customer-id> }`. This is a required field on `CreateOrderInput`. A customer must exist and be linked before the order can be created.- Each item on
`CreateOrderItemWithOrderInput` accepts `price`, `taxPrice`, `taxType`, `totalPrice`, `totalTaxPrice`, and precise equivalents (`precisePrice`, `preciseTaxPrice`, `preciseTotalPrice`, `preciseTotalTaxPrice`, `precisePaidPrice`), in addition to `paidPrice` and `currency`. `fulfilmentChoiceRef` on each item must match the `ref` of a `fulfilmentChoice` exactly, but fulfilmentChoiceRef is not mandatory- Omit
`latitude` and `longitude` entirely when coordinates are unknown, do not pass `0` `status` is assigned by the platform and cannot be set on create
Solution Integration Partner Program 2026
Essential knowledgeCore knowledge to understand Fluent CommerceOur Solution Integration (SI) Partner Program is designed to recognize and reward the value that our SI partners bring to our joint success. It provides a clear, transparent way to measure engagement, contributions, and impact across different areas of collaboration, from demand generation and deal contribution to delivery excellence and customer impact. - What this program does: As a Fluent Commerce SI partner, you get a dedicated Channel & Alliances rep for strategic guidance, commercials, marketing collaboration, and training, plus a structured way to earn recognition for the work you do together.
- How points are earned: Activities like referring qualified leads (5 pts), closing SI partner-sourced deals (15 pts), running joint marketing campaigns (3 pts), completing Functional Practitioner Certification within 2026 (10 pts), providing a customer reference (15 pts), and joint account planning (5 pts) all count toward your total.
- Certain items need approval or minimum thresholds: Leads must reach "needs identified" stage, customer references require customer approval, and collaboration credit is at the team's discretion, so not every effort automatically qualifies.
- Bottom line for partners: Engaging across referrals, deals, marketing, certification, and advocacy is how you build points and deepen the partnership, your Channel & Alliances representative is the go-to contact for questions on any of this.
Synchronous vs. Asynchronous Integration with Fluent Order Management
Essential knowledgeCore knowledge to understand Fluent CommerceFluent’s platform philosophy and integration guidance applies to payment, fulfillment, invoicing, WMS, ERP, and other external systems. Fluent OMS is intentionally asynchronous and event driven to support scalability, reliability, and stable workflow processing. Synchronous calls should occur in a separate integration or middleware layer, which handles the external response and sends the outcome back to Fluent as an event. This prevents delays, timeouts, duplicate actions, and stuck orders while keeping each system within its intended role.- Fluent OMS is an eventdriven, asynchronous platform designed for scalable, stable and reliable integrations.
- Fluent’s workflow engine does not support blocking synchronous calls to external systems such as payment providers, WMS or ERP platforms.
- Synchronous integrations are still possible, but must be managed through an external integration or middleware layer alongside Fluent.
Fluent Connect
Essential knowledgeCore knowledge to understand Fluent CommerceFluent Connect provides a cloud native integration layer that unifies Fluent Commerce with enterprise systems. Its scalable and API driven architecture ensures real time synchronization of orders, inventory and fulfillment data across your tech ecosystem in days instead of months, the following article provides further information about Fluent ConnectTo learn more about Fluent connect native AI powered integration framework read the following article
- Hosted Connectors - Managed integrations with commerce platforms, payments, marketplaces, carriers, tax engines, ERP platforms
- Connected Inventory Connectors - Specialized category for high-frequency, read-only inventory data flows
- AI-Assisted Implementation - AI-assisted build capabilities accelerate connector implementation, troubleshooting, and optimization
Responsive Sourcing Framework Overview
Essential knowledgeCore knowledge to understand Fluent CommerceThe 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.- Prerequisites: You should have knowledge of Order Management and Order lifecycle, Order Reference Module, and GraphQL API
- The Responsive Sourcing Framework is designed for both technical and business users - logic is transparent and comes with a configurable User Experience (UX)
- Enables faster implementation by reusing modular sourcing logic building blocks such as Sourcing Profiles, Strategies, Conditions, and Criteria
- Sourcing Profile GraphQL API is required to correctly set up your sourcing logic
- Supports custom Sourcing Conditions and Criteria through externally developed extensions for advanced or domain-specific logic
Builders Portal Points System
Essential knowledgeCore knowledge to understand Fluent CommerceLearn how the Builders Portal points system works so you can understand which activities earn points, how many points each activity is worth and what tiers and badges you can progress through. Implementing partners can use this to track their team's engagement with Fluent Commerce learning resources and recognise individual contributors publicly via the leaderboard. Points reward the behaviours that build product expertise such as certifications, learning milestones, and forum participation, which all translates to faster, better-informed implementations. - Points are earned automatically for six different activities: completing a certification (500), completing a learning milestone (50), commenting on a forum post (15), creating a forum post (10), reading a release note article (5), and logging in (1).
- There are six tiers, each with its own badge: Trainee (0), Associate (1,000), Practitioner (2,500), Specialist (5,000), Expert (8,500), and Elite (13,000 points).
- Certifications are the fastest route up the leaderboard: a single certification is worth the equivalent of 10 learning milestones or 500 logins, so learning activity, not portal visits, drives ranking.
- Points have no connection to the SI Partner Program: they do not affect partner status, partner program tiers, or commercial arrangements, the system exists purely to recognise individual learning and community contribution.
- Rankings are public: Your position is visible to all Builders Portal users via the 'Leaderboard' button under 'My Rewards'.
GraphQL Permissions
Essential knowledgeCore knowledge to understand Fluent CommerceThe 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.- Permission Structure: GraphQL queries and mutations are secured by permissions that follow the ENTITY_ACTION naming convention (for example, ORDER_VIEW, ORDER_UPDATE). This ensures precise and predictable access control across all API operations
- Nested and Partial Mutations: Nested mutations require separate permissions. Partial mutations are not allowed — if one permission check fails, the entire operation is rolled back
- Plugin Management Access: Plugin-related operations are governed by specific permissions such as PLUGIN_VIEW, PLUGIN_UPLOAD, and PLUGIN_INSTALL. Only users with these permissions can manage plugin
- Error Handling and Troubleshooting: Operations attempted without proper permissions return the error code C0020E. Users must obtain the required permissions before retrying the operation
- Analytics Permissions: Domain-level permissions (for example, ORDER_REPORT, INVENTORY_REPORT) control access to analytics capabilities across business domains via the GraphQL API.
UX Configuration - Common Concepts
Essential knowledgeCore knowledge to understand Fluent CommerceSome 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.- The Mystique manifest configures icons, cards, and template strings. Icons come from React Icons.
- Cards have common fields, and template strings allow dynamic values. Dynamic attributes (standard, image, component) offer flexibility based on conditions.
- A selection of helper functions are also available to control and transform these values as required, for example, number, logic, i18n, array, date, and string functions.
- Additional options like TextOptions and ImageOptions provide styling choices.
Controls Utilities Overview
Essential knowledgeCore knowledge to understand Fluent CommerceThe Controls Utilities library (`util-controls`) applies controls to a catalog position in a consistent, reusable way. Rather than each rule reimplementing how to find and apply controls, a rule calls `ControlUtils.applyControls(...)`, which loads the required data from GraphQL, evaluates the applicable controls, and returns an updated position together with an audit of every change.- Prerequisites: Java, Maven, and JUnit; Rules SDK (Rules and the rule Context); Understanding of Fluent Inventory concepts and domain model
- Single entry point:
`ControlUtils.applyControls(...)` resolves and applies controls in one call - Standard control types:
`ControlUtils` includes inclusion, exclusion, buffer, limit, and threshold controls by default - Specificity-aware: position/product/variant-level controls take precedence over group-level (bulk) controls
- Auditable: the result includes a before/after snapshot for every control the utility applied
- Extensible: supply custom control functions to support control types specific to your implementation
Blueprint Describe Command
Essential knowledgeCore knowledge to understand Fluent CommerceLearn to use the `blueprint describe` command to preview the contents of a JSON manifest file before deployment. This article enables implementing partners to inspect module versions, source locations, and conflict rules locally without needing authentication.For the business, this provides a critical safety check, ensuring that intended configurations (such as specific order management workflows) are verified before any changes reach the account. Note: This is a read-only operation; it identifies potential issues but does not replace the `blueprint validate` command for structural health checks.- Purpose: Use
`fluent blueprint describe <blueprint>` to preview the details of a JSON manifest file locally. - No Auth Required: This is a read-only local operation; no credentials or active internet connection are needed.
- Metadata: Displays blueprint name, version, authors, and searchable tags.
- Module Inventory: Lists every module to be installed, including its exact version, source (registry vs. custom path), and asset filters (includes/excludes).
- Conflict Rules: Shows a table of incompatible modules/blueprints to prevent breaking existing setups.
- Best Practice: Use this for a pre-installation review or to compare version differences before deploying.
Blueprint List Command
Essential knowledgeCore knowledge to understand Fluent CommerceLearn to use the `blueprint list` command to view and track all blueprints installed in a Fluent Commerce account. This article enables implementing partners to perform quick environment inventories and monitor version history across dev, staging, and production.For the business, this provides a clear audit trail and ensures consistency across the platform, resolving the pain point of "version drift." Note: This command requires active account-level authentication; if no blueprints are found, the CLI will return an "info" status rather than an error.- Purpose: Use
`fluent blueprint list` to display all blueprints currently installed in a specific Fluent Commerce account. - Output: Generates a table showing blueprint name, version, module count, and installation timestamp.
- Requirements: Requires account-level authentication and an active profile. Use
`-p` or `--profile` to check different environments (dev, staging, prod). - Audit Value: Essential for tracking "version drift," verifying deployments, and planning upgrades.
- Empty State: If no blueprints are present, it returns "info: No blueprints installed."
What is a Blueprint?
Essential knowledgeCore knowledge to understand Fluent CommerceThis guide covers the blueprint lifecycle, from design to management, teaching you to deploy pre-configured module collections using the Fluent CLI. Implementing partners gain a consistent, repeatable setup across environments, while businesses benefit from faster deployments and reduced downtime via automated conflict prevention.Key features include Smart Versioning for automatic upgrades and Snapshot Mode for development testing. Note: Production requires exact versions; semver ranges are prohibited to ensure stability.- Accelerator Blueprints: JSON manifest files acting as "recipes" to rapidly deploy pre-configured collections of modules to Fluent Commerce accounts.
- Core Functions: Enables version-controlled installations, rapid environment setup, and automated conflict management.
- Module Types: Supports official "Reference" shorthand (core, order, etc.), "Namespaced" organizational modules, and "Custom" modules via S3/HTTPS/Local paths.
- Snapshot Mode: Specific for development; allows automatic resolution of 4-part build numbers or SNAPSHOT versions for latest-build testing.
- Smart Deployment: Installation logic automatically handles upgrades and resumes interrupted sessions by skipping identical versions unless --force is used.
- Lifecycle: Follows a clear path: Design → Validate → Config → Install → Manage.
- Best Practice Supports official "Reference" shorthand (core, order, etc.), "Name-spaced" organizational modules, and "Custom" modules via S3/HTTPS/Local paths.
Learning: Setup & Configuration - Platform Foundations
Essential knowledgeCore knowledge to understand Fluent CommerceThis 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.- Sandbox environments are used for non-live activities like development, testing, training, and demos, while production environments are strictly for live client operations.
- Accounts represent single tenants with their own data, endpoints, and the ability to manage multiple retailers and install custom apps.
- The platform allows for flexible user roles and permissions with context-specific settings at account, retailer, or location levels.
- JSON Configuration files are used to alter settings in Fluent's web apps
Fluent Embedded Analytics
Essential knowledgeCore knowledge to understand Fluent CommerceFluent Embedded Analytics puts dashboards and individual metric tiles inside your Fluent web apps, on the page where the work happens. A user sees the number that matters without leaving the screen they are already working on.It is built for monitoring in context: four reference dashboards covering Orders, Fulfillments, Inventory, and Returns, plus the ability to place any single metric on any page. Metrics come from the Fluent Metrics Library.- Dashboards and metric tiles are rendered natively inside your Fluent web apps
- Four reference dashboards are available: Orders, Fulfillments, Inventory, and Returns
- Individual metrics can be placed on any page, next to the operational data they describe
- A builder controls the layout, which metrics appear, and which filters a user sees
- Filter selections are held in the page URL, so a filtered view can be shared or bookmarked
- Access is controlled by the
`ANALYTICS_VIEW` permission combined with roles defined per metric - Fluent Analytics must be enabled by Fluent Expert Services before any of it is available
Platform Foundations
Essential knowledgeCore knowledge to understand Fluent CommerceThis 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.- Sandbox environments are used for non-live activities like development, testing, training, and demos, while production environments are strictly for live client operations.
- Accounts represent single tenants with their own data, endpoints, and the ability to manage multiple retailers and install custom apps.
- The platform allows for flexible user roles and permissions with context-specific settings at account, retailer, or location levels.
- JSON Configuration files are used to alter settings in Fluent's web apps
Sources Interface
Essential knowledgeCore knowledge to understand Fluent CommerceThe 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.- Sources Dashboard provides real-time tracking of failed updates, update frequency, total received updates, and estimated processing times.
- BPP Metrics Dashboard enhances visibility into batch data ingestion by tracking record modifications.
Connect SDK Libraries
Essential knowledgeCore knowledge to understand Fluent CommerceThe Connect SDK Libraries comprise a modular software development framework designed for building integrations with Fluent Order Management. The architecture centers around a mandatory core module that handles foundational communication, configuration storage, and routing capabilities. Implementation teams can extend this baseline engine using specialized, pluggable add-on libraries to introduce web frameworks, security filters, specific cloud or infrastructure adapters, and isolated simulation testing suites.- What You Will Learn: You will understand the structural purpose of each component within the Connect SDK framework and learn how to select the appropriate core, web, cloud infrastructure, or testing dependencies for your implementation project.
- Mandatory Core Requirement: The
`connect-sdk-core` library is a mandatory dependency for all SDK-based implementations. It houses the baseline engine components, including the REST and GraphQL API client, authentication management for sensitive credentials, message routing, and the configuration manager. - Asynchronous Processing Boundary: All transactional endpoints and internal processing steps handled by the SDK execute asynchronously in the background. The explicit exception to this design rule is product availability processing, which runs synchronously.
- Pluggable Architecture Strategy: Advanced technical capabilities are intentionally isolated into decoupled modules. Developers append specialized add-ons like
`connect-sdk-core-web-security` for Spring Security filters, `connect-sdk-core-aws` for Amazon Web Services (AWS) deployment services like Amazon Simple Queue Service (SQS) and AWS Secrets Manager, or `connect-sdk-core-kafka` for Apache Kafka support. - Isolated Testing Frameworks: The SDK segregates quality assurance utilities into specific test scopes. Teams deploy
`connect-sdk-test-core` to mock external API calls with Wiremock, or utilize the AWS and Kafka test extensions to run integration tests inside software containers alongside LocalStack or virtual Kafka brokers.
External Webhook Integration Architecture - commercetools Connector
Essential knowledgeCore knowledge to understand Fluent CommerceExplains how the commercetools Connector ingests inbound webhooks and dispatches outbound payloads across the integration ecosystem. Partners will learn to configure and apply this shared framework utility, which manages message routing, handler resolution, and internal queue mechanics. For the business, this asynchronous architecture ensures real-time, secure data transmission and protects platform stability by preventing message loss during high-volume storefront traffic spikes.Note: This architectural component serves as a global framework utility rather than a single functional pipeline.- Core Function & Outcome: You will learn how the framework utility orchestrates bidirectional ingress and egress loops, serving as the master execution blueprint for all entity-specific data synchronization pipelines.
- Asynchronous Queue Infrastructure: The architecture processes incoming webhook payloads through an external
`ct-queue` and an internal Event Queue sequentially, decoupling network reception tasks from backend data processing to maintain platform throughput. - Declarative Route Filtering: Implementing partners can manage message names, configure explicit inclusion filters, and reassign target event pathways directly inside the
`application-connector.yml` configuration file. - Extensible Handler Architecture: The core message routing and processing layers are completely decoupled, allowing developers to cleanly register custom storefront event handlers by extending the base
`MessageHandler` class.
Webhooks Frequently Asked Questions
Essential knowledgeCore knowledge to understand Fluent CommerceThis page contains frequently asked questions about Fluent Webhooks. Due to the nature of being a cloud-hosted application, there are some restrictions in place regarding IP Whitelisting and Authentication that frequently come up.- Static IP Whitelisting: Fluent Commerce's cloud setup doesn't allow for static IP whitelisting due to the potential for IP address changes caused by scaling or architectural adjustments, as well as AWS or GCP's own IP address alterations.
- Authentication Measures: Instead of relying on IP Access Control Lists, Fluent Commerce employs strong authentication measures for webhook requests, including cryptographic signing with a private key and verification using a public key to ensure the request's legitimacy and integrity.
- IP-Based Restrictions: Implementing IP-based restrictions, such as whitelisting or IP ranges, is not recommended due to the dynamic nature of IP addresses in the cloud setup, which can lead to high exposure levels and difficulty in implementation.
- Alternative Approaches for Access Control: Instead of IP-based restrictions, companies can utilize firewall/networking equipment or reverse proxies to restrict access based on incoming HTTP request details, or configure unique, specific static URLs for incoming traffic to filter and accept connections securely.
Store Locator - Adobe Commerce Connector
Essential knowledgeCore knowledge to understand Fluent CommerceExplains how the Adobe Commerce Connector pulls physical fulfillment locations—including retail stores, warehouses, and collection nodes—from Fluent Order Management. Partners will learn to configure manual, full, and delta background cron tasks that map data models. For the business, this feature provides accurate store listing directories to support omnichannel options.Note: This article forms part of the inbound pipeline category, where data flows into the Adobe Commerce environment from an external source.- Core Function & Outcome: You will learn how the integration service layer pulls multi-retailer location metrics from Fluent to update internal storefront database records using a four-step pipeline.
- Three Extraction Profiles: Data sets are sustained via command-line full synchronizations, custom administration interface date filters, or automated background cron runs.
- Infrastructure Dependencies: Because processing relies on native messaging queues and background chronologies, proper system execution configuration is vital to maintain accurate store profiles.
- Developer Customization: If you need to alter the default behavior, the framework provides eight distinct events to customize query payloads, request variables, and data models before they are saved.
Consignment - Adobe Commerce Connector
Essential knowledgeCore knowledge to understand Fluent CommerceExplains how the Adobe Commerce Connector ingests inbound consignment updates from Fluent Order Management to update storefront shipments. Partners will learn to manage asynchronous validation chains, message queues, and tracking details. For the business, this automation creates precise full or partial customer shipments and provides real-time carrier tracking links.Note: This article forms part of the inbound pipeline category, where data flows into the Adobe Commerce environment from an external source.- Core Functionality & Outcome: You will learn how this pipeline intercepts Fluent consignment webhooks to automatically create and update full or partial shipments, including tracking codes, in Adobe Commerce.
- Global Scope & Trigger Constraints: If you skip the text, you must know that this framework can only be activated globally across all websites, and shipment generation relies entirely on a configurable, comma-separated list of specified Fluent statuses.
- Asynchronous Validation Flow: Inbound webhooks undergo a strict multi-step validation chain (verifying accounts, retailer IDs, and entity types) before being offloaded to an asynchronous message queue (
`fluentcommerce.consignment.updater`) for safe, decoupled processing. - Architecture & Customization: Developers can extend or override webhook handlers, validation rules, and processing commands using standard Adobe Commerce Dependency Injection (DI) (
`di.xml`) or tap into two dedicated event hooks (`before`/`after` processing).
Category Sync - commercetools Connector
Essential knowledgeCore knowledge to understand Fluent CommerceExplains how the commercetools Connector synchronizes category trees from a storefront outbound to Fluent Order Management. Partners will learn to manage real-time subscriptions and batch execution paths to mirror catalog hierarchies. For the business, this automation aligns navigation structures across platforms, ensures consistent item grouping for backend orchestration, and eliminates manual data entry.Note: This article forms part of the outbound pipeline category, where data flows out of the commercetools environment to an external destination.- Core Function & Outcome: You will learn how the connector coordinates the export of category trees from commercetools to Fluent Order Management, establishing matching catalog nodes across both environments.
- Dual-Trigger Execution: Supports manual, scheduler-driven complete catalog extraction alongside automatic background delta tracking.
- Subscription Management: Relies on core commercetools subscriptions to stream real-time creation and modification alerts into the integration layers.
- Extensible Routing Architecture: Allows business rules, message paths, and handler logic maps to be safely overridden via central YAML configurations. Technical partners can easily reassign event paths, manage inclusion filters, and override standard handler classes inside the centralized
`application-connector.yml` configuration file.
Consignment Updates - commercetools Connector
Essential knowledgeCore knowledge to understand Fluent CommerceExplains how the commercetools Connector tracks shipping events from Fluent Order Management to update commercetools. Partners will learn to manage the inbound webhook pipeline that automatically generates native delivery records, parcel data, and carrier tracking links. For the business, this sync eliminates manual shipment logging and gives customers instant visibility into order transit via the storefront interface.Note: This article forms part of the inbound pipeline category, where data flows into the commercetools environment from an external source.- Core Function & Outcome: You will learn how the commercetools Connector captures consignment updates from Fluent Order Management to automatically generate delivery records, package manifests, and carrier tracking data inside commercetools.
- Asynchronous Queue Infrastructure: Inbound webhook payloads undergo cryptographic signature and parameter verification in the first stage before entering an internal queue, where a named handler processes the data updates asynchronously in the second stage.
- Structural Entity Mapping: The system maps Fluent consignment entities directly onto fulfillment models, which translate into native, line-item level delivery records to cleanly support orders split across multiple packages or locations.
- Data Enrichment Mechanism: Because incoming webhooks carry minimal payloads to reduce network overhead, the connector automatically dispatches a
`GetConsignmentById` GraphQL query back to Fluent to pull complete carrier details and package dimensions before updating commercetools.
Customer Sync - commercetools Connector
Essential knowledgeCore knowledge to understand Fluent CommerceExplains how the commercetools Connector synchronizes customer profile data from a storefront to Fluent Order Management. Partners will learn to configure, validate, and extend this outbound data pipeline from the storefront trigger to the final GraphQL delivery. For the business, this real-time pipeline removes profile fragmentation, giving customer service agents instant access to accurate records.Note: This article forms part of the outbound pipeline category, where data flows out of the commercetools environment to an external destination.- Core Function & Outcome: You will learn how the commercetools Connector detects and processes customer creations and modifications automatically the moment they occur on the storefront, removing the need for manual batch data transfers.
- Asynchronous Queue Infrastructure: The architecture routes payloads through an external
`ct-queue` and an internal Event Queue sequentially, decoupling storefront event triggers from backend database processing to protect platform stability. - Declarative Route Filtering: Implementing partners can manage message types, configure explicit inclusion filters, and reassign target data pathways directly within the
`application-connector.yml` configuration file without modifying core system code. - Extensible Handler Architecture: The core message routing and transformation layers are completely decoupled, enabling developers to cleanly introduce custom profile fields and data-mapping logic by extending the base
`MessageHandler` class.
Order Sync - commercetools Connector
Essential knowledgeCore knowledge to understand Fluent CommerceExplains how the commercetools Connector manages the two-way pipeline that exports new orders from a storefront to Fluent Order Management and handles asynchronous status updates. Partners will learn to configure event-driven triggers, enable customer profile creations, and apply route filters. For the business, this real-time sync establishes a single source of truth for transactions across Home Delivery and store pickup channels.Note: This article forms part of the outbound pipeline category, where data flows out of the commercetools environment to an external destination.- Core Function & Outcome: You will learn how the commercetools Connector handles order exports from commercetools to Fluent Order Management, automates integrated customer profile creation, and establishes the webhook ecosystem for order status processing.
- Out-of-the-Box Capabilities: Out-of-the-box (OOTB) functionality natively supports Home Delivery (HD) and Click and Collect (CC) order structures, complete with automated type-specific order number generation patterns.
- System & Sync Limitations: Designed strictly for new transactions and does not synchronize historical orders created prior to extension installation. Additionally, the order update and modification handlers must be customized to fit your specific implementation needs.
- Extensible Pipeline Architecture: The message routing and handler framework is completely decoupled. Developers can easily update message names, override standard classes, or extend the baseline order creation logic to attach custom operational attributes.
commercetools connector - Location Sync
Essential knowledgeCore knowledge to understand Fluent CommerceThe Location Sync module manages the one-way import of physical store locations, warehouses, drop-ship vendors, lockers, and third-party collection points from Fluent Order Management into commercetools. The module synchronizes backend fulfillment nodes to active frontend storefront channels. This allows system administrators to select, map, and toggle which physical retail channels are active and visible to customers for local pickup options.- What You Will Learn: You will learn how the batch job extracts location nodes, filters active networks, utilizes GraphQL queries for data extraction, and maps spatial and operational attributes to storefront channels.
- Entity Translation: The connector maps Fluent Order Management location entities directly onto native
`Channel` entities within the commercetools Merchant Center. - Job-Driven Orchestration: A dedicated batch job manages the synchronization process. It relies on explicit timestamp parameters and network reference properties configured within Fluent Order Management.
- Storefront Configuration Control: By syncing location attributes and operational statuses down to storefront channels, system administrators can cleanly manage which physical sources display live options during customer pickup funnels.
What are Fluent OMS Entities? (Entity)
Essential knowledgeCore knowledge to understand Fluent CommerceA detailed explanation of Fluent OMS entities and how they can be used throughout the order journey.- Entities in Fluent OMS are data objects that store and process information throughout the order journey, such as orders, fulfilments, and financial transactions.
- Entities are managed via GraphQL, with mutations and queries used to create, update, and retrieve entity data.
- Entities should not be deleted but controlled using status fields, although some "remove" mutations can disconnect entities.
- Orchestrated Entities trigger a CREATE event upon successful creation, enabling workflow automation.
- Entities in Fluent OMS serve unique purposes to enable an end-end digital commerce journey and their statuses determine at what stage they sit.
- Entities have types and subtypes, types are rigidly defined, subtypes are more flexible.
Users, Roles, and Permissions
Essential knowledgeCore knowledge to understand Fluent CommerceThe 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.- A role can be assigned to multiple users, and a user can be assigned multiple roles.
- Permissions are granular access controls and protect every GraphQL or REST API operations. GraphQL permissions follow specific naming conventions.
- Context plays a pivotal role in access levels, allowing users to have role-based access to data for specific Accounts, Retailers, or Locations.
UX Framework - Configuration Guide
Essential knowledgeCore knowledge to understand Fluent CommerceThe 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.- The OMX Web App Manifest document is essential for configuring Fluent Platform web apps and is stored in a setting following the convention "fc.mystique.manifest.<appname>". For instance, Fluent Commerce UIs have settings like "fc.mystique.manifest.oms" and "fc.mystique.manifest.store."
- The document, configured in the ACCOUNT context, is a specific JSON structure that includes sections like App-Level Configuration, Route-Level Configuration, and Local Development Options. Each web app defined within an account has a unique URL, and the Manifest guides app development, covering aspects like navigation, screen layouts, data sources, and user actions.
- Manifest updates can be done through Console/settings or directly via the API, with the ability to partition the document for manageability.
Fluent Analytics Studio
Essential knowledgeCore knowledge to understand Fluent CommerceAnalytics Studio is a dedicated web application within Fluent that enables users to explore, analyse, and act on business data. Where embedded Fluent Analytics metrics are designed for monitoring in specific contexts, Analytics Studio is designed for investigation, giving users access to dashboards, individual records, and data exports to understand what drives changes in key metrics.- Analytics Studio is a dedicated web application for exploring and analyzing business data
- The application is available at
`https://<ACCOUNT_ID>.<ENVIRONMENT>.apps.fluentcommerce.com/analytics` - It extends dashboards by allowing access to the underlying records behind metrics
- Users can investigate issues, identify trends, and understand what is driving changes in key metrics
- The application supports exporting data, setting alerts, and scheduling reports
- Built-in dashboard actions allow users to refresh data, reset filters, change time zone settings, export dashboards, and schedule reports
Adobe Commerce Connector - Core Authentication & Webhook Infrastructure
Essential knowledgeCore knowledge to understand Fluent CommerceEstablishes the foundational security mechanisms, credential mapping strategies, and inbound validation rules required to securely pass transactional payloads between Adobe Commerce and Fluent Commerce:- Safeguards multi-retailer setups by auto-mapping Adobe website scopes to isolated Fluent credentials.
- Speeds up extensions via a unified API layer and an easily modifiable webhook validation chain (
`di.xml`). - Webhooks require a strict 3-step signature and data check. Because all modules rely on this, any configuration issue breaks the entire integration.
- Core Foundation & Outcome: You will learn how the General module acts as the integration's architectural backbone, housing all shared utilities, services, and core API authentication layers that every other module fundamentally depends on.
- Scoped Multi-Retailer Support: If you skip the text, you must know that credentials are completely isolated per website scope, allowing each distinct Adobe Commerce website to map to and authenticate with its own specific Fluent retailer configuration.
- Global Webhook Validation: All incoming webhooks share a centralized, 3-step validation chain (
`MessageValidatorChain`) configured via `di.xml` that automatically enforces field presence, entity types, and security signature integrity. - System-Wide Dependency Risk: Because this module manages the single point of truth for global communication and data validation, any misconfiguration or failure here will break the entire integration ecosystem.
commercetools Connector Extend Configuration
Essential knowledgeCore knowledge to understand Fluent CommerceThe commercetools Connector features a highly adaptable runtime architecture governed by four baseline configuration files: `application-connector.yml`, `application.yml`, `bootstrap.yml`, and `logback-spring.xml`. Together, these files define core connector settings, server/container properties, and logging rules.To manage multi-environment rollouts efficiently, you can override common baseline settings by creating dedicated files that follow standard Spring Boot profile conventions (e.g., `application-dev.yml`) to isolate your development, staging, and production environments.- What You Will Learn: You will understand how to safely configure, secure, and scale the bidirectional data flow between commercetools and Fluent Commerce across multi-profile cloud environments without modifying core connector code.
- Core File Architecture: The connector requires a strict baseline of four configuration files (
`application-connector.yml`, `application.yml`, `bootstrap.yml`, and `logback-spring.xml`). You can dynamically override any environment setting by appending standard Spring Boot profile suffixes (e.g., `application-dev.yml`). - Critical Operational Guardrails: * Job Serialization: The asynchronous job scheduler enforces strict concurrency control—multiple instances of the same data synchronization job cannot run simultaneously.
- Data Retention: Manual
`customDateRange` overrides are destructive parameters; the connector executes the targeted historical timeframe exactly once and automatically deletes the custom range to prevent looping data.
- Security and Performance Impact: Moving or updating sensitive external platform endpoints requires configuring the connector's dedicated credential storage layer. Additionally, message processing throughout during peak traffic events is directly governed by adjusting the
`pool-size` and queue listener properties.
RFP Essential Knowledge: Fluent AI Capabilities
Essential knowledgeCore knowledge to understand Fluent CommerceFluent Commerce is built as an Agent Orchestration Platform — an intelligent OMS where AI is embedded in workflows, not bolted on from the outside. Intelligence is applied where commerce decisions are actually made: order promising, sourcing, fulfilment, customer service, and integration.
This article maps Fluent's AI capabilities to the evaluation categories commonly assessed in enterprise OMS RFQs and RFIs, distinguishing clearly between what is live in production, what is in pilot, and what is on the committed roadmap.- Product Area: AI & Intelligence
- Audience: Sales, Pre-Sales, Partners
RFP Essential Knowledge: Integrations and APIs
Essential knowledgeCore knowledge to understand Fluent CommerceFluent Commerce is an API-first, event-driven platform. All business capabilities are exposed via APIs, enabling 100% interoperability with backend, third-party, and headless front-end systems. The platform supports GraphQL, REST, webhooks, and event-based integration patterns, with a growing library of pre-built connectors and an extensible Connect SDK for building custom integrations.- Intended Audience: Developer, Solution Architect, Integration Engineer
- Classification: Integrations and APIs
RFP Essential Knowledge: Fulfilment and Delivery
Essential knowledgeCore knowledge to understand Fluent CommerceFluent Order Management provides a comprehensive suite of fulfilment capabilities spanning Click & Collect / BOPIS, Ship from Store, carrier management, delivery scheduling, and in-store pick, pack, and dispatch. All fulfilment flows are orchestrated through configurable workflows, enabling retailers to define, adapt, and optimise their fulfilment network with minimal development effort.- Intended Audience: Business User, Store Operations, Implementation Partner
- Classification: Fulfilment and Delivery
RFP Essential Knowledge: Compliance and Certifications
Essential knowledgeCore knowledge to understand Fluent CommerceFluent Commerce maintains a structured compliance programme covering security certifications, data protection obligations, and change management processes. The platform is SOC 2 Type II certified, GDPR compliant, and built on AWS and GCP infrastructure, who hold more compliance certifications than any other providers. This article covers Fluent's audit and compliance posture, GDPR practices, certification status, and change management approach.- Intended Audience: Security Team, Procurement, Legal, IT Leadership
- Classification: Compliance and Certifications
RFP Essential Knowledge: Customer Support
Essential knowledgeCore knowledge to understand Fluent CommerceFluent Commerce provides a multi-tiered support model encompassing platform support, customer success management, Expert Services, and account management. Support is delivered globally across the US, Canada, UK, France, and Australia (HQ). This article covers support structure, SLAs, implementation governance, and multi-brand deployment support.- Intended Audience: IT Leadership, Project Team, Procurement
- Classification: Customer Support
ICP, Qualification Criteria and Additional Use Cases
Essential knowledgeCore knowledge to understand Fluent CommerceThe article provides a comprehensive guide to identifying the Ideal Customer Profile (ICP) for an Order Management System (OMS), highlighting key criteria and red flags to ensure successful implementation. It also explores Fluent OMS use cases, showcasing its capabilities in order capture, fulfillment, tracking, promising, shipping, and inventory management.- Ideal Customer Profile (ICP) based on specific industries, company maturity, and high order volumes
- Poor fit indicators, such as outdated legacy infrastructure or a lack of executive buy in
- Fast Qualification Framework to rapidly assess a prospect's Budget, Systems, Volume, and Channels.
Blueprint Download Command
Essential knowledgeCore knowledge to understand Fluent CommerceLearn how to use the `blueprint download` command to retrieve all module archives defined in a manifest without installing them. This guide enables implementing partners to archive modules for offline use, inspect contents, or build local repositories for air-gapped environments.For the business, this ensures disaster recovery readiness and simplifies distribution by creating a portable snapshot of a specific solution version. Note: This is a read-only operation and does not require Fluent Commerce authentication, though S3 sources still require local AWS credentials.- Purpose: Downloads blueprint module ZIPs to a local directory (
`-o` or `--output`) without applying any changes to an account. - Smart Downloads: Automatically skips files that already exist in the target folder, allowing you to easily resume interrupted downloads.
- Sources: Supports multiple protocols including HTTPS, S3 (requires AWS credentials), and local file system paths.
- Verification: Ideal for auditing module contents, performing version comparisons, or staging artifacts for CI/CD pipelines.
- Formatting: Automatically sanitizes namespaced modules (e.g.,
`acme/core` becomes `acme-core-v1.zip`) for consistent file naming.
Users, Roles, and Permissions
Essential knowledgeCore knowledge to understand Fluent CommerceThe 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.- A role can be assigned to multiple users, and a user can be assigned multiple roles.
- Permissions are granular access controls and protect every GraphQL or REST API operations. GraphQL permissions follow specific naming conventions.
- Context plays a pivotal role in access levels, allowing users to have role-based access to data for specific Accounts, Retailers, or Locations.
Send Enhanced Inventory Attributes in Your Payloads
Essential knowledgeCore knowledge to understand Fluent CommerceInventory payloads can include additional Inventory Quantity attributes to capture richer stock context.This article explains how to use the `attributes` object to include additional data in inventory payloads. It supports both simple key-value pairs and custom JSON structures to meet diverse business requirements - whether you’re:- managing detailed product information
- optimizing warehouse processes
- or integrating with custom workflows
The Inventory Reference Module supports a set of reference attributes that are persisted automatically, while custom attributes provide additional flexibility.- Prerequisites: To fully leverage the extended attributes functionality within the inventory payload, ensure that you are using the Inventory Reference Module v2.3.0 or later
- Flexible attribute structure: The
`attributes` object supports any combination of key-value pairs, including complex JSON structures and arrays. This flexibility allows you to customize the data sent in your inventory payloads to meet specific business needs - Use reference attributes first: Certain key attributes (such as
`associationType`, `associationRef`, `parentRef`, `expectedOn`, `expiresOn`, `condition`, `storageAreaRef`, `supplier`, `manufacturer`, `manufacturerBatchNumber`, `countryOfOrigin`, and `channel`) will be directly updated in the Inventory Quantity associated with the incoming record, facilitating seamless integration with existing fields - Use segment fields for flexible key-value extensions:
`segment1`, `segment2`, and `segment3` provide flexibility for additional flat classification data without introducing new custom attributes - Custom attribute availability: Any custom attributes that you include in the
`attributes` object will be available in workflows via `inventoryPosition.inventoryQuantity.attributes.<fieldName>`. This enables you to incorporate custom data into rule-based processes or other logic tailored to your business requirements
Fluent Big Inventory Web App Overview
Essential knowledgeCore knowledge to understand Fluent CommerceThe 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.
- The Fluent Big Inventory Web App offers a comprehensive suite of functionality.
- With dedicated interfaces for Sources, Products, Inventory, Stores, Insights, and Admin, the web-based interface provides users with a holistic toolset, allowing them to observe and track integrated sources, manage product catalogues, exercise precise control over inventory, oversee individual and networked store locations, monitor system events comprehensively, and efficiently administer the entire inventory availability system for a seamless and valuable user experience.
Overview of Payments in Fluent
Essential knowledgeCore knowledge to understand Fluent CommerceThe Fluent platform enables payment orchestration across the full lifecycle of an Order. Using the OMX Workflow Framework and core payment entities, businesses can implement custom logic for fulfilment, capture, refunds, and reconciliation. This document outlines the Payments Data Model and GraphQL API capabilities, excluding reference Rules, Workflows, or UX components. Financial operations within the Payments domain rely on precision-safe monetary representations to ensure accuracy and consistency across transactions.- This document covers the Payments data model and GraphQL API
- Payments are usually fulfilment-driven, but capture can occur at different stages depending on workflow configuration
- Core entities: FinancialTransaction (funds source), Payment (capture/refund), PaymentTransaction (status log)
- Monetary values support precision-safe amounts via preciseAmount (BigDecimal/NUMERIC); legacy Float fields remain optional for backward compatibility
BigDecimal Precision & Rounding Principles
Essential knowledgeCore knowledge to understand Fluent CommerceThis document defines the core principles for using `BigDecimal` in monetary and high-precision calculations. After reading, developers can apply the appropriate constructors, division rules, and rounding strategies to ensure consistent numeric representation across services, APIs, and storage. These principles reduce defects caused by floating-point arithmetic, undefined division, rounding errors, and incorrect value comparisons.- Monetary calculations rely on deterministic precision across all services.
- Precision is preserved using
`NUMERIC` (DB), `BigDecimal` (Java), and (`unscaledValue`, `scale`) (API). - Division requires explicit scale and rounding to avoid runtime exceptions.
- Most defects originate from constructing from
`double`, confusing scale vs precision, or misusing `equals()`.
Fluent Metrics Library Overview
Essential knowledgeCore knowledge to understand Fluent CommerceThe 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.- Operational clarity - get a clear view of what's working and what needs attention across your network.
- Proactive issue management - quickly detect spikes in cancellations, rejections, or delays.
- Continuous optimization - track key metrics across locations, channels and fulfillment types to drive improvements.
- Data-driven decisions - support trade planning, performance reviews and customer experiences with real-time data.
"FC Retail Group" Sample Setup
Essential knowledgeCore knowledge to understand Fluent CommerceThis 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.- Training accounts model a retail group with shared and individual workflows for FC Fashion and FC Sports.
- Locations and networks enable fulfillment options like Home Delivery and Click & Collect, tailored to each retailer.
- Catalogs, including virtual ones, determine sellable items and fulfillment types across networks.
- Settings at account, retailer, and location levels control permissions, workflows, and inventory behavior.
Tool Overview: LaunchPad v1
Essential knowledgeCore knowledge to understand Fluent CommerceThis 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.- Fluent LaunchPad is a smart Postman workflow that quickly sets up a Fluent account to be ready for end-to-end order processing (retailers, locations, products, inventory, workflows).
- It is a “guided engine”, using pre-/post-request scripts, variables, and execution control to improve on the more manual SDK Insomnia collection.
- It covers dynamic auth, retailer creation, locations & networks, products, global inventory, and fulfillment/order-management configuration.
Introduction to the Events API
Essential knowledgeCore knowledge to understand Fluent CommerceThe 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.- Events are fundamental to the Fluent Platform, representing actions or occurrences within the system.
- The Events API enables viewing and creating events, supporting workflow logic and system activity tracking.
`ORCHESTRATION` events trigger workflows, while `ORCHESTRATION_AUDIT` events log workflow execution details.- Common Event API operations include retrieving events by ID, filtering events, and creating new events asynchronously.
- Event Contracts are defined by Rulesets in workflows, combining event attributes to handle specific processes.
- Recommended practice: Use asynchronous integration for non-real-time actions to optimize performance.
- Common integrations include inventory updates, product master data transfer, fulfillment updates, and carrier tracking.
Sourcing Profiles Interface
Essential knowledgeCore knowledge to understand Fluent CommerceThe 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.- Part of Admin UI: Sourcing Profiles are managed in the Admin interface for Fluent OMS.
- Profile Versions: Editing a profile in the Admin UI triggers the creation of a new draft version via the
`updateProfile` mutation. - Centralized Management: View all active profiles with key details such as version, status, last updated, default catalog, networks, and max split.
- Sourcing Strategies: Create new strategies (including fallback) and edit existing ones. Strategies within profiles are assigned priorities, ensuring that the most critical business rules are applied first.
- Conditions & Criteria: Define or adjust fulfillment logic using configurable IF conditions and THEN criteria.
- Intuitive Editing Experience: Users can easily add or configure conditions, set maximum splits, and apply catalogs or networks through guided forms.
Why Fluent Commerce Focuses on SOC 2 Type 2 Attestation (Not SOC 1 / ISAE 3402)
Essential knowledgeCore knowledge to understand Fluent CommerceFluent 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.- SOC 1 / ISAE 3402 focuses on financial reporting, which is not relevant to Fluent Commerce's services.
- Fluent Commerce provides tools for order management and fulfillment, not direct financial transaction processing.
- SOC 2 Type 2 attestation is more appropriate for evaluating cloud-based software providers.
- SOC 2 Type 2 assesses controls across five Trust Services Categories: Security, Availability, Processing Integrity, Confidentiality, and Privacy.
- Annual independent audits of SOC 2 Type 2 demonstrate Fluent Commerce's commitment to data protection and system reliability.
Search Sourcing Profiles
Essential knowledgeCore knowledge to understand Fluent CommerceThe `sourcingProfiles` query retrieves existing Sourcing Profiles. It supports multiple filters and pagination.- Prerequisites: User should have
`SOURCINGPROFILE_VIEW` permission - Flexible Filtering: Multiple filters are supported, including
`ref`, `version`, `versionComment`, `name`, `description`, `status`, `defaultMaxSplit`, and date ranges (`createdOn`, `updatedOn`). This lets you target specific Profiles or narrow results down by lifecycle state and time window - Pagination Support: The query supports cursor-based pagination (
`first`, `last`, `before`, `after`), making it efficient to handle large sets of Sourcing Profiles
Product Description - Fluent Hosted Connectors
Essential knowledgeCore knowledge to understand Fluent CommerceFluent 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.- Enables connectivity between Fluent Order Management and external systems (marketplaces, commerce, payments, service platforms, inventory).
- Hosted connectors simplify operations but are not customer-modifiable
- Includes specialized Connected Inventory hosted connectors for near real-time inventory updates to downstream platforms.
Product Description - Fluent Commerce OMS
Essential knowledgeCore knowledge to understand Fluent CommerceFluent 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 main components that comprise the platform architecture are Web Apps, Modules, Order Management Experience (OMX), Orchestration Engine, and Cloud Infrastructure.
- Each Module represents a particular business domain and its associated rules and workflows. Core, Inventory, Order and fulfilment are the four Fluent modules.
- These are the web and in-store interfaces used to access module functionality.
Product Description - Fluent Commerce OMS
Essential knowledgeCore knowledge to understand Fluent CommerceFluent 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 main components that comprise the platform architecture are Web Apps, Modules, Order Management Experience (OMX), Orchestration Engine, and Cloud Infrastructure.
- Each Module represents a particular business domain and its associated rules and workflows. Core, Inventory, Order and fulfilment are the four Fluent modules.
- These are the web and in-store interfaces used to access module functionality.
Orchestration Webhooks
Essential knowledgeCore knowledge to understand Fluent CommerceFluent 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.- Webhooks enable real-time communication between Fluent workflows and external systems, eliminating the need for frequent API polling.
- The
`sendWebhook` rule simplifies outbound communication by passing essential data that external systems can use to fetch additional details. - Typical use cases include order status updates, shipping notifications, payment captures, and stock transfers.
- Webhooks should not be used for Inventory domain operations due to scalability concerns, performance impacts, and stability risks, so use Inventory Feeds instead.
- In rare cases where inventory-related webhooks are required (e.g., conditional stock change notifications), contact our team to discuss alternatives before implementation.
Workflow Framework Overview
Essential knowledgeCore knowledge to understand Fluent CommerceThe 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.- Cloud-native, high availability, scale-on-demand workflow execution.
- Pre-built, customizable workflows delivering capabilities across each of the Fluent App domains.
- Rich Rule Library containing reusable rules across each of the Fluent Apps.
- Software Development Kit (SDK) and Developer Tooling, enabling the implementation of custom rules and integrations.
- Business Tools to manage, configure, and implement workflow and process automation.
Overview of Pick and Pack
Essential knowledgeCore knowledge to understand Fluent CommerceThe 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.- Adaptability: The process is responsive, ensuring a seamless experience on screens of varying sizes. Customization options are available through UI configuration or creating new components.
- Process Stages: The wave process involves creating a wave, picking order items, packing them, and booking carriers.Prioritization logic is applied based on factors such as expiration dates, order types, or delivery types.
- Efficient Picking: Picking orders is initiated by creating a wave, followed by selecting orders and using a user-friendly PICK component.Confirmation of picked items involves a final review, confirmation, and automatic rejection of unpicked items.
- Completion Process: The wave-picking process leads to the completion of fulfilling online orders in-store, providing a streamlined approach to order fulfillment.
Unified View of Inventory Interface
Essential knowledgeCore knowledge to understand Fluent CommerceThe 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.- Centralized Inventory Management: The Unified View of Inventory (UVOI) consolidates data from multiple locations and channels into a single, real-time interface, simplifying inventory management and improving decision-making.
- Advanced Filtering Capabilities: UVOI offers flexible filters for refining search results, including catalog, stock status, on-hand quantities, and product or location-specific criteria.
- Comprehensive and Customizable Views: The Inventory Search page provides a detailed overview of inventory, with drill-down capabilities for stock levels, available-to-sell quantities, and update histories. Users can navigate to location-specific or product-specific views and customize filters and criteria to tailor the experience to their operational needs.
Inventory Interface
Essential knowledgeCore knowledge to understand Fluent CommerceThe 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 Fluent Web app's Inventory interface offers a comprehensive suite of capabilities, including inventory visibility, allocation, total stock quantity (stock on hand), inventory status, available-to-promise levels, and strategically implemented buffers to prevent product overselling.
- The interface is equipped with various configurations, such as Inventory Catalogues, Control Groups, Virtual Catalogues, Cross-Catalogue Views, and Location Inventory Views, providing users with versatile tools to tailor their inventory management approach according to specific business needs and scenarios.
Inventory Ingestion
Essential knowledgeCore knowledge to understand Fluent CommerceInventory 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 Batches handle large-scale updates (thousands to millions of records), while Delta updates are ideal for smaller, incremental changes in real time.
- Batches use asynchronous processing for bulk data, grouped into Jobs for tracking, whereas Deltas are processed individually directly by the workflow engine.
- Batches are suited for periodic updates like ERP integrations and stocktakes, while Inventory Deltas are designed for real-time changes to reflect inventory movements such as store sales, returns, or daily adjustments.
- Batches require management of file sizes and grouping, while Deltas focus only on incremental updates, ensuring simplicity and speed for smaller changes.
Pack for Multi-Parcel Shipments
Essential knowledgeCore knowledge to understand Fluent CommerceThe 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.- Store Associates can choose which fulfillment to pack next, optimizing the packing process based on operational needs.
- Fulfillments are organized into two tabs—Awaiting Pack and Packed Fulfillments—providing a clear overview of the packing stages.
- A badge displays the number of fulfillments awaiting packing, helping Associates manage their tasks efficiently.
- Store Associates can allocate items to specific parcels, add or remove parcels, set dimensions and weight, and reject items.
- The integrated barcode scanner speeds up the packing process by quickly and accurately identifying parcels and items.
Order Management Interface
Essential knowledgeCore knowledge to understand Fluent CommerceThe 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.- The Order Management interface brings together orders, customers, billing accounts, returns, and escalated fulfilments in one place.
- It enables visibility and control over the entire order lifecycle, from creation through fulfilment, return, or escalation.
A collection of links to get started with your Fluent OMS journey.
Essential knowledgeCore knowledge to understand Fluent CommerceFluent Commerce is a flexible, cloud-native distributed order management system (OMS) designed to help retailers manage inventory, orders, fulfillment, and customer experience more efficiently. This guide outlines the key resources and steps to get you started.- Fluent Commerce is a cloud-native OMS designed to optimize inventory, orders, and fulfillment for retailers.
- Key resources include Core Concepts, Fluent CLI, API integration, workflows, and environment setup.
- Training and certification are available to enhance expertise in Fluent Commerce.
Product Description - Fluent Commerce OMS [Superseded - Document Version 1.0]
Essential knowledgeCore knowledge to understand Fluent CommerceFluent 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 main components that comprise the platform architecture are Web Apps, Modules, Order Management Experience (OMX), Orchestration Engine, and Cloud Infrastructure.
- Each Module represents a particular business domain and its associated rules and workflows. Core, Inventory, Order and fulfilment are the four Fluent modules.
- These are the web and in-store interfaces used to access module functionality.
commercetools Connector Extend Customization
Essential knowledgeCore knowledge to understand Fluent CommerceA Fluent Connector project typically has the structure as defined below :
com.fluentcommerce.connect.custom
Any customizations/extensions can either be done under the custom folder or as a separate module (jar) altogether.
Regardless of which way one chooses to extend it, the key message here is that any custom code should be under the `com.fluentcommerce.connect` package. This is due to how the FluentConnectorApplication is wired to work with Spring, and in its current form, Spring will only scan for components under `com.fluentcommerce.connect`.
During the server start-up, the commercetools-connector will load all handlers found in the spring context and bind them to the correct service they belong to. As part of this binding process, the commercetools-connector also determines which handler has precedence over others of the same name. In other words, it is possible to override existing handlers by assigning a higher priority to the custom handler. By default, all handlers will have a priority of zero, and the commercetools-connector understands the highest priority as the higher number. For example, priority = 100 takes precedence over priority = 1.`@HandlerInfo(name = "CustomCategoryUpsert", priority = 100)`[Warning: empty required content area]commercetools Prerequisites & Project Configuration
Essential knowledgeCore knowledge to understand Fluent CommerceThis page covers how to configure the appropriate settings in the commercetools the commercetools system i.e.: custom fields, channels, etc. so that syncing can be enabled between it and the Fluent Commerce system.- Custom fields are required for Orders, Order Line Items, Delivery, Channels, and Parcels, with specific field names provided.
- Project configuration files include application-connector.yml, application.yml, bootstrap.yml, and logback-spring.xml for different settings and environments.
- Route mappings are used to map incoming messages to handlers, with examples provided for configuration.
- Listeners manage different types of queues, including batch jobs, internal messages, notifications, and commercetools events.
- Detailed configuration examples and instructions are available for customizing routes, handlers, and Fluent account mappings.
Extend Knowledge Contribution Terms and Conditions
Essential knowledgeCore knowledge to understand Fluent CommerceThe Third Party Contributor Terms and Conditions, also known as Contribution Terms, outline the guidelines and legal framework for submitting contributions to Fluent Retail Pty Ltd, trading as Fluent Commerce. These terms establish the rights and obligations of both the contributor and the company, including licensing under Creative Commons and Apache licenses, use of contributions, privacy considerations, and limitations of liability. Contributors must ensure they have the necessary rights to submit their work and agree to the terms before submission. - Contributions are governed by Creative Commons and Apache licenses, requiring contributors to have necessary rights and authorization.
- Fluent Commerce may use, share, and publish contributions at their discretion, without any obligation for payment to contributors.
- The agreement can be terminated at any time by either party, but existing licenses remain unaffected.
MockApiClient
Essential knowledgeCore knowledge to understand Fluent CommerceThe `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.
- Test API Interactions: The
`MockApiClient` allows you to test how your rule responds to different API outcomes (e.g., success, failure, empty data) without making live network calls. - Isolate and Speed Up Tests: By mocking the API, your tests run faster and are isolated from network or environment issues.
- Executor Integration: You typically don't use
`MockApiClient` directly. You use the helper methods on `RuleExecutor` and `WorkflowExecutor` (like `.mockQuery()` and `.mockSetting()`) to configure it. - Full Coverage: It supports mocking pre-compiled queries/mutations, dynamic queries/mutations, and settings, giving you complete control over your test environment.
Master Buffer: Strategic Adjustment of Available-to-Sell (ATS) Quantity
Essential knowledgeCore knowledge to understand Fluent CommerceUnderstand 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.
- Concluding ATS modifier: Applies a direct SKU-level override after all quantity buffers, just before ATS is calculated.
- Strategic & Product-Specific: Use it for deliberate, product-level inventory goals (like promotions or managing supply risks), not for general, location-based stock on hand buffering.
- Direct Impact on Sales: A positive buffer value increases ATS; a negative value decreases it. A resultant negative ATS will always be floored to zero.
- Use Deliberately & Review: Due to its significant impact, apply the Master Buffer thoughtfully. Document the rationale and regularly review its necessity.
Availability Overview
Essential knowledgeCore knowledge to understand Fluent CommerceAvailability provides out-of-the-box (or reference) features in each function, as well as the capability to extend (or customise) business requirements via software development kits (SDKs). It helps provide real-time inventory data on Available-to-Sell and Available-to-Promise information, making the online shopping experience more convenient and efficient. This feature integrates with the Inventory Module, ensuring product availability is accurately represented across different channels. Availability is calculated based on product, customer location, and delivery methods.- Ensures real-time display of Available-to-Sell (ATS) and Available-to-Promise (ATP) data, including stock levels and delivery options, on Product Detail Pages (PDP), Product Listing Pages (PLP), and during checkout.
- Provides seamless integration with the Fulfillment Options workflow to present a diverse array of procurement alternatives, including Click-and-Collect (CC) and Home Delivery (HD).
- Customisable to business needs via SDKs.
Extending the UX Framework with the Component SDK
Essential knowledgeCore knowledge to understand Fluent CommerceThis 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.- What is the Component SDK? A development kit for building custom components for the UX Framework Component Library using modern, developer-friendly tools like React and TypeScript.
- What can be extended? Developers can create a wide range of components, including content, layout/page, interaction, form field components, and template helpers, significantly expanding the functionality of the standard library.
- Why use the Component SDK? The SDK simplifies custom component creation by handling complex tasks like manifest configuration, authorization, data access, localization, and workflow interaction, allowing developers to focus on component logic and design. It also leverages the Fluent OMX Design System (based on Material-UI) for consistent and high-quality UX.
Setting up the Manifest Document
Essential knowledgeCore knowledge to understand Fluent CommerceThis 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.- VS Code Setup: Use the provided VS Code workspace for Manifest editing.
- Manifest Definition: The Manifest defines a Fluent Web App's structure, layout, navigation, and data.
- Account Setting: Manifests are stored as account-level settings.
- Web App Access: Web apps are accessed via URLs based on the Manifest's appName.
- Key Elements (Name, Title, Context, Routes): Manifests define these core elements.
- Route Types: Page, Section, and Reference routes define navigation within the app.
Core Google Cloud Platform (GCP) Components Supporting Fluent Commerce
Essential knowledgeCore knowledge to understand Fluent CommerceFluent 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.- Google Cloud Platform components used by Fluent fall into the Compute & Serverless, Data & Storage, Networking & Delivery, and Security & Compliance categories
- Compute & Serverless: Run workloads with virtual machines (GCE), Kubernetes (GKE), and event-driven functions (Cloud Functions).
- Data & Storage: Store and analyze data with Cloud Storage, BigQuery, Cloud SQL, and Cloud Spanner.
- Networking & Delivery: Speed up content with Cloud CDN and balance traffic efficiently with Cloud Load Balancer.
- Security & Compliance: Protect workloads with IAM, Cloud KMS, Secret Manager, and Audit Logs.
Manifest Creation and Customization
Essential knowledgeCore knowledge to understand Fluent CommerceThis 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.- Manifest Fragment Creation: Learn to create and configure a new Manifest fragment for managing storage areas.
- Account Settings Integration: Integrate the new fragment into account settings and reference it in the main Manifest.
- List Component Integration: Use the List Component to display storage area data.
- Data Source Configuration: Use the
`activeLocation` context to configure a page query as a data source for the List Component. - Details Page Creation: Create a details page for individual storage areas with a dedicated page query.
- Dynamic Value Handling: Learn to work with dynamic values using formatters (e.g.,
`dateStringFormatter`), array access, attribute retrieval by name, and image rendering. - i18n Configuration: Configure i18n language translation keys for the web app.
Understanding Manifest Structure
Essential knowledgeCore knowledge to understand Fluent CommerceThis 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.- Manifest Types: There are two types of Manifests: main and fragment.
- Main Manifest Structure: Required fields include manifestVersion, name, title, context, and routes. Optional fields include homePath.
- Context Configuration: Defines whether the app operates at a LOCATION or RETAILER level and allows role-based access control.
- Routes (Section, Page, Reference): Routes define the navigation menu. Section routes group menu items, Page routes link to specific pages, and Reference routes include fragment manifests.
- Fragment Manifests: Fragment manifests contain only manifestVersion and routes, allowing for modular management of large Manifest configurations.
- Plugin Integration: The Manifest can include references to custom component plugins hosted externally.
Introduction to the Component Library
Essential knowledgeCore knowledge to understand Fluent CommerceThis 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.- Fluent Platform Integration: OMX Components seamlessly integrate with the Fluent Platform.
- Component Categories: The library includes Foundation, Content, Layout, Interaction, and Field Components, each with distinct roles.
- Component Hierarchy: Content and Layout components are typically children of Foundation Components.
- Mobile Responsiveness: Components should be designed with mobile responsiveness in mind.
- Interaction Components: These enable user interaction with the application.
- Field Components: Automatically rendered form elements, essential for complex workflow input, are not configured via the manifest.
Unit Testing Custom Components
Essential knowledgeCore knowledge to understand Fluent CommerceThis 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.- Testing Framework: The SDK includes Jest and React's test renderer for unit testing.
- Mock Objects: Mock objects are created for external dependencies like authentication (
`useAuth`), data from the page query, and dynamic attributes from the manifest. - Arrange, Act, Assert: The testing process follows the standard Arrange, Act, Assert pattern.
- Arrange: Mocks are set up and configured.
- Act: The component is rendered with the mock data.
- Assert: The rendered output is compared against a snapshot.
- Snapshot Testing: Jest's snapshot feature is used to compare the component's output to a previously saved snapshot, ensuring consistency.
- Testable Components: Unit tests help ensure the reliability and maintainability of custom components.
Enhance Your Custom Fields: Leveraging Existing Components from the Registry
Essential knowledgeCore knowledge to understand Fluent CommerceThis 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.- Structure and Layout: Learn how to structure and organize the elements within your custom form field for optimal presentation.
- Styling with Material-UI: Use Material-UI's styling capabilities (e.g., makeStyles) to style your custom field and maintain design consistency.
- Form Control Integration: Integrate pre-built form controls, like the QuantitySelector, to efficiently capture specific data types (e.g., integers for quantity).
- Component Registry Retrieval: Learn how to retrieve and use existing components from the component registry (e.g., the QuantitySelector using its alias "number").
- State Management: Manage the state of form inputs using React's state mechanisms.
- Debugging with
`useEffect`: Use the `useEffect` hook to debug and verify the behavior and output of your custom field.
Accessing User and Location Context with the useAuth Hook
Essential knowledgeCore knowledge to understand Fluent CommerceThis 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.`useAuth` Hook Purpose: The useAuth hook provides a convenient way to access details about the authenticated user, including their roles, permissions, and current context.- Contextual Information: The hook provides access to the user's current location or retailer context, which is vital for location-based applications.
- Location Coordinates: For location-context apps, useAuth allows retrieval of the selected store's coordinates (longitude and latitude), enabling map integration and location-based functionality.
- Fluent Store Application: In the context of Fluent Store, this hook will be used to get the coordinates of the currently viewed store, providing the data needed to display the store's location on the map.
Client Scenario: Building a Product Availability Map
Essential knowledgeCore knowledge to understand Fluent CommerceThis 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.- Client Need: The client requires a visual representation of product availability in nearby stores, which would enable staff to locate items quickly for customers.
- Map Functionality: The map should be integrated into the Product Availability details screen. It should display pins for the 10 closest stores with stock and show store details (name, product reference, available stock) when a pin is clicked. The map's appearance and behavior should be configurable via the manifest.
- Product Lookup Configuration: This involves adding a new page to the Fluent Store app, using a List Component to display product variants, configuring list filters, and creating hyperlinks to product details pages.
- Detail Availability Page Configuration: This includes creating a new page, linking it from the Product Lookup page, and adding card components to display product details and images. A List Component will show data from the search VirtualInventory query.
- Hands-on Lab Focus: The lab simulates a real-world scenario where a customer seeks a specific shoe size, requiring a store associate to check nearby store inventory. This exercise will prepare you for creating custom components in the following lessons to realize the client's vision fully.
Building Custom Components with the Component SDK
Essential knowledgeCore knowledge to understand Fluent CommerceThis 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.- Types of Custom Components: The Component SDK enables the creation of custom view components (for page content) and custom field components (for workflow user actions), allowing developers to tailor interfaces to specific needs.
- Hooks for OMX Integration: Fluent-specific React hooks (e.g.,
`useAuth`, `useI18n`, `useQuery`) provide easy access to platform functionalities like authentication, localization, and API interaction, simplifying complex tasks. - Utility Components for Consistency: The SDK offers utility components (e.g., Card, Loading, Drawers) that serve as building blocks for custom components, ensuring a consistent look and feel, theme responsiveness, and mobile compatibility.
- Component Registries: Custom components must be registered with the appropriate registry (Component, Field, or Template) before they can be used in OMX Web Apps, making them discoverable and usable within the framework.
Creating Custom Template Helpers
Essential knowledgeCore knowledge to understand Fluent CommerceThis 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.- Template Helpers: Template helpers are reusable functions that can be called within Manifest documents to perform various operations.
- Use Cases: Template helpers can be used for styling, formatting, calculations, and other data transformations.
`TemplateRegistry`: The `TemplateRegistry` is used to register custom template helpers, making them available for use in Manifests.- HTML Formatting: The lesson demonstrates creating a template helper that bolds entity references using
`TemplateRegistry` utility methods for formatted HTML generation. - Customizability: Custom template helpers extend the functionality of Manifests, allowing for greater flexibility and control over data presentation.
Extending Forms with Custom Field Components
Essential knowledgeCore knowledge to understand Fluent CommerceThis 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`.- Form Field Generation: The UX Framework automatically generates forms based on expected data types.
- Custom Field Components: Developers can create custom field components to handle complex data types or improve UX.
- Extending Scenarios: Custom field components can be used with workflow user actions, GraphQL mutations, and list filters.
- JSON Data Capture: This lesson's focus is on creating a custom field component to capture a JSON object for stock reservation details, containing locationRef and quantity fields.
- Client Scenario: The need for a custom form field arises from the client's requirement to capture stock reservations, which involves a specific JSON structure.
Support & Operations Activities
Essential knowledgeCore knowledge to understand Fluent CommerceThis 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.- Plugin Management: Upload, activate, and manage plugin versions via Plugin API.
- Workflow Versions: Submit, view, and retrieve versions for effective workflow management.
- Event Categories: Includes snapshots, rulesets, rules, actions, and exceptions.
- Event Viewing: Access audit data via Event API, Event Search, or Fluent OMS Activity tab.
Orchestration Engine
Essential knowledgeCore knowledge to understand Fluent CommerceThe 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.- Orchestration Engine
- Powers the execution of workflows, business logic, and business processes.
- 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.
Inventory Ingestion
Essential knowledgeCore knowledge to understand Fluent CommerceInventory 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 Batches handle large-scale updates (thousands to millions of records), while Delta updates are ideal for smaller, incremental changes in real time.
- Batches use asynchronous processing for bulk data, grouped into Jobs for tracking, whereas Deltas are processed individually directly by the workflow engine.
- Batches are suited for periodic updates like ERP integrations and stocktakes, while Inventory Deltas are designed for real-time changes to reflect inventory movements such as store sales, returns, or daily adjustments.
- Batches require management of file sizes and grouping, while Deltas focus only on incremental updates, ensuring simplicity and speed for smaller changes.
UX Framework Overview
Essential knowledgeCore knowledge to understand Fluent CommerceThe 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.
- Dynamic user management experience.
- Configurable left-navigation menu items.
- Dynamic views, labels, and fields based on configuration and GraphQL queries.
- Dynamic and contextual user actions based on workflow configuration.
- Ability to create and edit all entities, including non-workflow entities.
- Customise UIs to meet specific business needs and processes.
- Ability to configure contextual actions based on roles and process states.
- Enables centralised management of orders, products, inventory, fulfillments, and locations.
Configure a Data Source for your Page
Essential knowledgeCore knowledge to understand Fluent CommerceIn order to show data in the Storage Areas List, we need to configure a data source.Components on a page can reference a data source from a query defined on the Page Component.First, we'll configure a page query, to retrieve the currently active Location's associated Storage Areas.The `data` object on the Page Route takes a `query` and a `variables` object for defining a GraphQL Query.`"data": {``"query": "query locationStorageAreas ($locationRef: String!) { location (ref: $locationRef) { id ref storageAreas { edges { node { id name status type } } } } }",``"variables": {``"locationRef": "{{activeLocation.ref}}"``}``}`You'll notice the use of a special variable called `{{activeLocation.ref}}` above. Since this Web App Context is "location", you can access the currently active context using the `activeLocation` object. This provides access to the Location Id, Ref, and Primary Address.Once the Page query is defined, go to the Component configuration, and add a `dataSource` field. The `dataSource` for the list should be set to the `storageAreas` connection on the `location` query path: `location.storageAreas` `"dataSource": "location.storageAreas"`With the data source configured, all that's left is to update the fields to be displayed in the list with dynamic values. We'll display the Name, Type, and Status from the Storage Area.This is done by specifying the field of each node in the Storage Areas connection: `{{node.name}}` `"attributes": [``{``"label": "Name",`
`"value": "{{node.name}}"``},``{``"label": "Type",`
`"value": "{{node.type}}"``},``{``"label": "Status",`
`"value": "{{node.status}}"``}``]`See this in action in the video below...Note: This video does not have audio.[Warning: empty required content area]Partner Center
Essential knowledgeCore knowledge to understand Fluent CommercePartner guides, processes, important documents and links to help you on your journey with Fluent Commerce.- Landing page for partners with important links and documents
- Project Delivery; Discovery Slides, Starter Pack, and Ready for Launch Process
- Sales like; Register a Lead, and Cheat Sheet for Prospecting
- Education links such as; Partner Training Portal, Release Notes, and Roadmap
- Support links such as; Where can I get help?, Support Portal, Support Process, and Status Page
Information Security Policy
Essential knowledgeCore knowledge to understand Fluent CommerceThe Information Security Policy is a cornerstone of Fluent Commerce's commitment to secure data and systems. It defines the safeguarding responsibilities of staff, contractors, and third parties. The policy covers a range of topics, including access control, account management, and incident response, with the goal of ensuring confidentiality, integrity, and availability of information.- Adherence to Security Practices: It is imperative for all staff, contractors, and third parties to rigorously follow the established information security practices to safeguard Fluent Commerce's data and systems.
- Regular Policy Review: The Information Security Policy should be reviewed and updated regularly to respond to new security threats and changes in technology and business operations.
- Access Control: Access to information and systems must be managed strictly on a need-to-know basis, ensuring confidentiality and integrity of data.
- Incident Response: A clear and tested incident response plan is crucial for the timely and effective handling of security breaches or potential threats.
Overview of Technical Requirements for Web Apps
Essential knowledgeCore knowledge to understand Fluent CommerceOur web app leverages the OMX design system to ensure a seamless, responsive user experience across all devices. Built on material design principles, it supports a modern interface that adapts to various screen sizes. Additionally, it offers language support with multiple language packs available for enhanced accessibility.- Cross-Device Compatibility: Ensure seamless performance and visual consistency across desktops, tablets, and mobile devices.
- Language Support: The app supports multiple language packs, including en-AU, en-GB, en-US, and fr-EU, with en-AU as the default.
- OMX Design System: Utilize the OMX design system, which is based on material design, to create a modern and user-friendly interface.
UX Framework Overview
Essential knowledgeCore knowledge to understand Fluent CommerceThe 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.
- Dynamic user management experience.
- Configurable left-navigation menu items.
- Dynamic views, labels, and fields based on configuration and GraphQL queries.
- Dynamic and contextual user actions based on workflow configuration.
- Ability to create and edit all entities, including non-workflow entities.
- Customise UIs to meet specific business needs and processes.
- Ability to configure contextual actions based on roles and process states.
- Enables centralised management of orders, products, inventory, fulfillments, and locations.
Using the anyMatch Template
Essential knowledgeCore knowledge to understand Fluent CommerceThe 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.- The anyMatch template is used for performing conditional checks on structured data streams (i.e lists, arrays), typically JSON. The template requires three inputs parameters:
`STRING_PATH_TO_VARIABLE`, `VALUE` and `OPTIONAL_FUNCTION .` - This template checks if a specific path within your data structure matches a given value.
- The anyMatch template also supports optional functions to perform different kinds of comparisons. The optional functions will compare the specified path to the value and return results if there is a match.
Users Configuration Overview
Essential knowledgeCore knowledge to understand Fluent CommerceOMS 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.`Type`: Understand the different types of users; ADMIN, RETAILER, API, and AGENT- User Status: Be aware of the user status options, ACTIVE and INACTIVE, which reflect the user's current accessibility.
- Filtering Users: Utilize the filter component to efficiently search for users based on various criteria like username, status, creation date, and type.
- Roles and Permissions: Assign roles to users to manage permissions within the system, ensuring each user has the appropriate level of access.
- Paging Control: Utilize the paging controls at the bottom of the Users table to navigate between pages and manage the number of entries displayed per page, with options for 10, 25, or 100 entries.
- Deprecation Notice: Be aware that certain user types such as AGENT, SUPPORT, and others have been deprecated and should not be used for new users.
APIs Overview
Essential knowledgeCore knowledge to understand Fluent CommerceFluent provides both REST and GraphQL APIs. However, REST APIs are limited to specific Platform operations, while the GraphQL API provides the core Domain Model.- Common Authentication Token: Both Platform REST and Domain GraphQL APIs utilize a shared authentication token, ensuring a unified authentication approach.
- Platform REST APIs: Various Platform-level APIs, including Event, Workflow, Job, Plugin, and User Action APIs, are implemented in REST format with version 4.1.
- GraphQL API Advantages: The actively supported GraphQL API offers significant benefits over REST, while deprecated Domain-based REST APIs are in maintenance mode for existing clients, with documentation available for reference.
Escaping / unescaping of values in UX Framework
Essential knowledgeCore knowledge to understand Fluent CommerceCharacter 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.- Mustache.js Templating: The UX framework utilizes mustache.js for templating, which automatically escapes HTML characters. This is important for preventing XSS (Cross-Site Scripting) attacks and ensuring data is displayed as intended.
- Unescaping Variables: To display special characters properly, such as ampersands, you must unescape variables using triple mustaches, e.g.,
`{{{variable}}}`, or the `&` symbol in the variable tag, e.g., `{{&variable}}`. - Correct Display of Values: Escaping or unescaping variables correctly is crucial for the accurate representation of data within the UX. This ensures that special characters are rendered as intended, maintaining the integrity of the information displayed to users.
Multi-factor authentication (MFA)
Essential knowledgeCore knowledge to understand Fluent CommerceMulti-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.- MFA Categories: OTP, delivered through various means, offer time-limited codes effective against online attacks.
- OTP Options: SMS, Voice, Email, and Application/Soft Tokens provide versatile MFA choices.
- Authentication Methods: Mobile Apps, Authentication App (TOTP), Email, and SMS come with specified security settings for password limits, block duration, and passcode refresh.
Domain Model
Essential knowledgeCore knowledge to understand Fluent CommerceFluent'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.- Order Management: Comprehensive system for handling orders, from creation to fulfillment and returns.
- Billing Management: Orchestrates billing operations and manages invoices, credit/debit memos, payments, and ERP integrations.
- Foundation Domain: Sets up Fluent Commerce app ecosystem, including Account, Retailer, Activity, and defines locations and networks.
- Store Fulfillment: Crucial for retailers, utilizes the Wave entity for grouping and monitoring orders.
- Shipping & Product Availability: Records shipping details offer real-time product availability considering custom attributes.
- Security Domain: Governs users, roles, and permissions across the Fluent platform.
Fluent Connect SDK Architecture
Essential knowledgeCore knowledge to understand Fluent CommerceThis article will cover the high-level design and features of the SDK.- The Connect SDK architecture consists of core, cloud, and additional libraries, enabling the building and extension of connectors.
- Key features include configurations, a secret manager for sensitive information, a scheduler for periodic operations, listeners/subscribers, web services/webhooks, an event log, product availability options, and SDK handlers for custom business logic.
- The message lifecycle follows a specific flow, and there are two integration approaches: Pull and Push. The SDK offers patterns for scheduled operations and receiving external requests, and it includes dead letter queues, metrics, and logs for monitoring and observability.
- Build and deployment use SpringBoot, generating a deployable JAR with an embedded Tomcat.