Invocation

Invocation steps call other Logic Composer constructs and Dataverse processes, enabling modular design and reuse.

Run Logic Block

Executes a Logic Block and returns its outputs.

Parameter	Description
Logic Block	The block to execute
Block Inputs Binding	Mapping of values to block inputs

Returns: The block's output values

Example - Formula:

RUN LOGIC BLOCK
  Logic Block: CalculateOrderTotal
  Block Inputs Binding:
    Quantity: OrderLine.Quantity
    UnitPrice: OrderLine.UnitPrice
    DiscountPercent: Customer.DiscountRate
    TaxRate: TaxConfiguration.Rate
  → Store outputs:
    Total → LineTotal

Example - Decision Table:

RUN LOGIC BLOCK
  Logic Block: DetermineShippingMethod
  Block Inputs Binding:
    OrderWeight: Order.TotalWeight
    DestinationCountry: Order.ShipToCountry
    CustomerTier: Customer.Tier
    IsExpedited: Order.ExpressShipping
  → Store outputs:
    ShippingMethod → SelectedMethod
    ShippingCost → CalculatedCost
    EstimatedDays → DeliveryDays

Example - Validation Set:

RUN LOGIC BLOCK
  Logic Block: ValidateOrderForSubmission
  Block Inputs Binding:
    Order: Order
    Customer: Customer
    CreditLimit: Customer.CreditLimit
  → Store outputs:
    IsValid → OrderIsValid
    ValidationMessages → ErrorMessages

CONDITION: Order Valid?
  Condition: OrderIsValid == true
  
  TRUE BRANCH:
    → Continue with order processing
  
  FALSE BRANCH:
    → Display ErrorMessages to user
    → HALT

Run Logic Flow

Executes another Logic Flow as a sub-flow.

Parameter	Description
Logic Flow	The flow to execute
Flow Inputs Binding	Mapping of values to flow inputs

Returns: The sub-flow's output values

Sub-flows enable you to break complex processes into manageable, reusable pieces.

Example:

RUN LOGIC FLOW
  Logic Flow: ProcessPayment
  Flow Inputs Binding:
    OrderId: Order.Id
    Amount: Order.TotalAmount
    PaymentMethod: SelectedPaymentMethod
  → Store outputs:
    Success → PaymentSuccess
    TransactionId → PaymentTransactionId
    ErrorMessage → PaymentError

Nested Flow Example:

# Main Flow: ProcessOrder

1. RUN LOGIC FLOW: ValidateOrderFlow
   → ValidationResult

2. CONDITION: Is Valid?
   TRUE:
     3. RUN LOGIC FLOW: CalculatePricingFlow
        → PricingResult
     
     4. RUN LOGIC FLOW: ProcessPaymentFlow
        → PaymentResult
     
     5. CONDITION: Payment Success?
        TRUE:
          6. RUN LOGIC FLOW: CreateShipmentFlow
             → ShipmentResult
          
          7. RUN LOGIC FLOW: SendConfirmationFlow

Run Business Process

Starts a Process Orchestrator business process against a target record. Use this to hand a record off to a multi-stage, orchestrated process from within a flow.

Parameter	Description
Business Process	The business process to run
Entity Logical Name	The entity type the process runs against
Entity ID	The record to start the process on
Input Arguments	Mapping of values to the business process's input parameters

Returns: The identifier of the created business process instance.

Example:

RUN BUSINESS PROCESS
  Business Process: Order Fulfillment
  Entity Logical Name: salesorder
  Entity ID: Order.Id
  Input Arguments:
    Priority: "High"
  → Store outputs:
    BusinessProcessInstanceId → FulfillmentInstanceId

A business process is invokable from a flow when it is published as an action (Is Action). Under the covers this runs the business-process action against the target record. See Process Triggers.

Run Process Action

Executes a Dataverse process action (Custom API or Action).

Parameter	Description
Process	The process action to execute (identified by its process id)
Entity Logical Name	The entity type the action is bound to (for entity-bound actions)
Entity ID	The record the action runs against (for entity-bound actions)
Input Arguments	Mapping of values to the action's input parameters
Output Arguments Map	Optional mapping that renames action outputs onto flow variables

Returns: The action's output parameters

Example:

RUN PROCESS ACTION
  Process: new_CalculateCommission
  Entity Logical Name: salesorder
  Entity ID: SalesOrder.Id
  Input Arguments:
    SalespersonId: Order.OwnerId
    Period: "Q4-2024"
  → Store outputs:
    CommissionAmount → CalculatedCommission
    CommissionRate → AppliedRate

Run Process Workflow

Executes a Dataverse workflow (process) against a record by issuing an ExecuteWorkflowRequest.

Parameter	Description
Workflow	The workflow to execute (identified by its process id)
Entity Logical Name	The entity type the workflow runs against
Entity ID	The record to run the workflow on

If the target workflow is configured as a background (asynchronous) workflow, Dataverse queues it as a system job; the step returns once the request has been submitted.

Example:

RUN PROCESS WORKFLOW
  Workflow: Account Approval Workflow
  Entity Logical Name: account
  Entity ID: NewAccount.Id

Best Practices

Design for Reusability: Create Logic Blocks and sub-flows that can be reused across multiple parent flows.

Keep Interfaces Clean: Define clear, minimal inputs and outputs for called constructs. Don't pass more data than needed.

Handle Sub-Flow Failures: Always check the outputs of called flows and blocks, especially success/failure indicators.

Avoid Deep Nesting: Too many levels of sub-flows become hard to debug. Keep the call hierarchy reasonably flat.

Document Dependencies: Make it clear which flows call which other flows/blocks to understand the full execution chain.

Use Blocks for Calculations: If you need to perform a calculation, use a Logic Block rather than embedding the formula in the flow. This makes it reusable and testable.

Consider Transaction Boundaries: Sub-flows typically run in the same transaction as the parent. Be aware of this for error handling and rollback scenarios.