Human-in-the-Loop Product Ordering with Kestra

id: product-order-approval-hitl
namespace: company.team
description: |
  Order a product with dynamic, API-driven inputs, check stock availability,
  pause for a human approval with structured onResume inputs, then hand the
  purchase order to a finance approval subflow.

variables:
  AVAILABLE: "In Stock"
  LOW: "Low Stock"

inputs:
  - id: category
    type: SELECT
    expression: "{{ http(uri = 'https://dummyjson.com/products/categories') |
      jq('.[].slug') }}"
    defaults: fragrances
    displayName: Product Category

  - id: product
    type: SELECT
    displayName: Product Name
    defaults: "Calvin Klein CK One"
    allowCustomValue: true
    dependsOn:
      inputs:
        - category
    expression: "{{ http(uri = 'https://dummyjson.com/products/category/' +
      inputs.category) | jq('.products[].title') }}"

tasks:
  - id: getProductId
    type: io.kestra.plugin.core.debug.Return
    description: Resolve the selected product title to its API id.
    format: |
      {{ ((http(uri = 'https://dummyjson.com/products/category/' + inputs.category).products | jq('.[] | select(.title == "' ~ inputs.product ~ '")')) | first).id ?? '-1' }}

  - id: getProductDetails
    type: io.kestra.plugin.core.http.Request
    description: Fetch full product details, tolerating unknown products.
    uri: "{{ 'https://dummyjson.com/products/' ~ (outputs.getProductId.value | trim)
      }}"
    options:
      allowFailed: true

  - id: processOrder
    type: io.kestra.plugin.core.flow.If
    description: Only order products that exist and are in stock.
    condition: "{{ outputs.getProductDetails.code == 200 and
      fromJson(outputs.getProductDetails.body).availabilityStatus isIn
      [vars.AVAILABLE, vars.LOW] }}"
    then:
      - id: checkInventoryAndOrder
        type: io.kestra.plugin.core.flow.Parallel
        runIf: "{{ fromJson(outputs.getProductDetails.body).availabilityStatus isIn
          [vars.AVAILABLE, vars.LOW] }}"
        tasks:
          - id: printInventoryCount
            type: io.kestra.plugin.core.log.Log
            message: "{{ fromJson(outputs.getProductDetails.body).availabilityStatus ==
              vars.LOW ? vars.LOW ~ ' Placing order and sending low stock
              alert.' : vars.AVAILABLE ~ ' Placing order, enough stock' }}"

          - id: orderItem
            type: io.kestra.plugin.core.debug.Return
            format: Product {{ inputs.product }} Ordered Successfully

          - id: sendRestockAlert
            type: io.kestra.plugin.core.debug.Return
            runIf: "{{ fromJson(outputs.getProductDetails.body).availabilityStatus isIn
              [vars.LOW] }}"
            format: "Restock Alert for {{ inputs.product }} sent successfully!"
    else:
      - id: cancelOrder
        type: io.kestra.plugin.core.debug.Return
        format: "Failed to order '{{ inputs.product }}'. HTTP Status: {{
          outputs.getProductDetails.code }}"

  - id: hitlProcess
    type: io.kestra.plugin.core.flow.Sequential
    description: Human approval gate, only runs when the order was not cancelled.
    runIf: "{{ (outputs.cancelOrder.value ?? false) == false }}"
    tasks:
      - id: sendApprovalNotification
        type: io.kestra.plugin.core.log.Log
        message: |
          Review request from {{ printContext().labels.system.username ?? 'TestUser' }}
          Approve: {{ appLink() }}&flowInputs={{ inputs | toJson | base64encode }}&requestor={{ printContext().labels.system.username ?? 'Test User' | base64encode }}

      - id: notifyChannel
        type: io.kestra.plugin.slack.notifications.SlackIncomingWebhook
        url: "{{ secret('SLACK_WEBHOOK') }}"
        messageText: |
          Review order request from {{ printContext().labels.system.username ?? 'TestUser' }}

          Approve/Reject: [Here]({{ appLink() }}&flowInputs={{ inputs | toJson | base64encode }}&requestor={{ printContext().labels.system.username ?? 'Test User' | base64encode }})

      - id: waitForApproval
        type: io.kestra.plugin.core.flow.Pause
        onResume:
          - id: approved
            type: BOOL
            displayName: Approve this request?
          - id: reason
            type: STRING
            displayName: Decision notes
          - id: team
            type: SELECT
            displayName: Cost Center
            values:
              - HR
              - Finance
              - IT

      - id: sendToVendor
        type: io.kestra.plugin.core.debug.Return
        format: |
          Order request for {{ inputs.product }} under Cost Center: {{ outputs.waitForApproval.onResume.team }}, has been {{ outputs.waitForApproval.onResume.approved ? 'approved' : 'rejected' }}.
          Reason: {{ outputs.waitForApproval.onResume.reason }}
          {{ outputs.waitForApproval.onResume.approved ? '' : 'Do not ' }}Proceed with invoicing.

      - id: sendPurchaseOrderForFinanceApproval
        type: io.kestra.plugin.core.flow.Subflow
        flowId: purchase-order-finance-approval
        namespace: company.team
        inputs:
          productId: "{{ outputs.getProductId.value | trim }}"
          requestor: "{{ printContext().labels.system.username ?? 'TestUser' }}"
          department: "{{ flow.namespace }}"

      - id: financeApprovalStatus
        type: io.kestra.plugin.core.debug.Return
        format: |
          Manager Approved: {{ outputs.sendPurchaseOrderForFinanceApproval.outputs.managerApproved ? 'YES' : 'NO' }}
          Comments: {{ outputs.sendPurchaseOrderForFinanceApproval.outputs.managerComments }}

outputs:
  - id: orderStatus
    type: STRING
    value: "{{ outputs.processOrder.evaluationResult == false ?
      outputs.cancelOrder.value : (outputs.orderItem.value ~ ' ' ~
      (outputs.sendRestockAlert.value ?? '')) }}"

  - id: invoiceStatus
    type: STRING
    value: "{{ outputs.sendToVendor.value ?? 'Invoicing not done' }}"

  - id: purchaseOrderStatus
    type: STRING
    value: "{{ outputs.financeApprovalStatus.value ?? 'Purchase Order not sent' }}"

Model a real procurement chain in a single declarative flow. This Kestra blueprint demonstrates three advanced patterns together: dynamic, dependent inputs populated live from an API; an inventory-aware ordering decision; and a two-stage human-in-the-loop approval where the first reviewer answers structured questions and a second finance approval runs as a subflow. It uses the public dummyjson product API as a stand-in for your catalog, so it runs out of the box, and it links approvers to a companion Kestra App form through appLink() (an Enterprise Edition and Kestra Cloud feature).

How it works

The category input (SELECT) is populated at execution time by an expression calling the products API with the http() Pebble function; the product input depends on it via dependsOn and reloads its options when the category changes.
The getProductId task (io.kestra.plugin.core.debug.Return) resolves the chosen title to an id with an inline jq filter, defaulting to -1 when not found.
The getProductDetails task (io.kestra.plugin.core.http.Request) fetches the product with allowFailed: true so an unknown product does not crash the flow.
The processOrder task (io.kestra.plugin.core.flow.If) checks the HTTP code and availabilityStatus against the AVAILABLE and LOW variables. In-stock products run a io.kestra.plugin.core.flow.Parallel block that logs inventory, places the order, and fires a restock alert only for low stock. Anything else lands in cancelOrder.
The hitlProcess block (io.kestra.plugin.core.flow.Sequential) runs only when the order was not cancelled. It logs and posts an approval link to Slack (io.kestra.plugin.slack.notifications.SlackIncomingWebhook), embedding the flow inputs and requestor in the appLink() URL, then pauses with io.kestra.plugin.core.flow.Pause. The onResume schema collects a boolean decision, free-text notes, and a cost center from the approver.
After resume, sendToVendor summarizes the decision, sendPurchaseOrderForFinanceApproval (io.kestra.plugin.core.flow.Subflow) launches the purchase-order-finance-approval flow, and financeApprovalStatus reports the manager's verdict. Flow-level outputs expose order, invoice, and purchase order status to callers.

What you get

Dependent dropdown inputs whose options come from a live API at execution time.
A Pause gate that captures structured, typed decisions instead of a bare resume click.
Two chained approval stages with full lineage between parent and subflow.
Typed flow outputs consumable by any calling flow or API client.

Who it's for

Teams modeling procurement, ordering, or request workflows with multiple sign-offs.
Platform engineers learning dynamic inputs, runIf, and onResume patterns.
Solutions engineers demonstrating human-in-the-loop orchestration end to end.

Why orchestrate this with Kestra

Approval chains usually end up split across a form tool, a ticketing system, and scripts, with no single record of what was requested, decided, and executed. Kestra keeps the entire chain in one execution graph: inputs are validated and versioned, the pause holds state durably for as long as the approver needs, the structured onResume answers become outputs downstream tasks can branch on, and the finance stage is a reusable subflow other processes can call too. The companion App gives approvers a clean form without granting them access to the Kestra UI.

Prerequisites

Outbound HTTP access from the Kestra host to dummyjson.com (or swap in your catalog API).
The companion purchase-order-finance-approval flow deployed in the same namespace.
A Kestra App bound to this flow so appLink() resolves (EE or Kestra Cloud); without one, replace the link with an execution URL.
A Slack incoming webhook for approval notifications.

Secrets

SLACK_WEBHOOK: Slack incoming webhook URL used by notifyChannel.

Quick start

Add the SLACK_WEBHOOK secret to your Kestra namespace.
Deploy purchase-order-finance-approval, then this flow.
Execute it, picking a category and product from the dynamically loaded dropdowns.
Open the paused execution (or the App link from Slack), answer the approval questions, and resume.
Resume the finance subflow's pause and check the three flow outputs.

How to extend

Point the input expressions at your real product or service catalog API.
Replace the Return stubs with real vendor API calls or ERP tasks.
Add timeout behavior to the Pause tasks to auto-escalate stale approvals.
Route the cost center answer to different finance subflows with a Switch task.
Add unit tests for the ordering logic with Kestra's flow testing support.

Product Order with Human Approval and Finance Sign-Off

How it works

What you get

Who it's for

Why orchestrate this with Kestra

Prerequisites

Secrets

Quick start

How to extend

Links

Tasks

Orchestrate with Kestra

Share this Blueprint

Create a Blueprint

New to Kestra?

Product Order with Human Approval and Finance Sign-Off

How it works

What you get

Who it's for

Why orchestrate this with Kestra

Prerequisites

Secrets

Quick start

How to extend

Links

Tasks

Orchestrate with Kestra

Share this Blueprint

Create a Blueprint

More Business Blueprints

Convert Natural Language Prompts to Structured Todoist Tasks with Deepseek AI

Sync Postgres records to Algolia index

AI-Powered Inventory Demand Forecasting, Auto-Generate Purchase Orders with OpenAI

Query and filter customer data from HubSpot

Automate Incident Response, Create Jira Tickets, Alert Slack, and Log to Database

AI Slack Chatbot with Per-User Conversation Memory Using OpenAI and KV Store

New to Kestra?