5.2 Workflow Construct Examples
This chapter introduces the fundamental building blocks of the Workflow Engine using small, focused JSON examples. Each example highlights one core feature, explains how it works, and shows how it relates to the underlying DSL concepts defined by the Open Workflow Specification spec.
Simple Call Example
This is the smallest possible workflow: a single task that calls one connectable element — here a datapoint, but with.datapoint accepts the id of a connector or another workflow just as well.
What it demonstrates
- Minimal workflow structure
dosequence with a single taskcall+withsyntax
Example Code Snippet:
Simple Call - Workflow Example
{
"id": "base-wf-call-dp",
"name": "base-wf-call-dp",
"type": "workflow",
"version": "0.0.1",
"displayName": "base-wf-call-dp",
"description": "Simplest workflow example that demonstrates calling a datapoint with a static message parameter. Executes a single POST datapoint call with a hardcoded 'Hello from OLIVE!' message. Ideal for learning the basic structure and syntax of temporal workflows and datapoint integration.",
"tags": [
"example",
"simple-example",
"scenario-example-base",
"scenario-example-base-workflows"
],
"workflow": {
"type": "temporal",
"definition": {
"do": [
{
"echoCall": {
"call": "olive",
"with": {
"datapoint": "postman-dp-http-postman-post-placeholder",
"parameters": {
"message": "Hello from OLIVE!"
}
}
}
}
]
}
}
}
How to trigger the workflow with the data-orchestrator:
Request Input
{
"id": "base-wf-call-dp"
}
Workflow With Input Parameters
Demonstrates how workflow inputs are passed into tasks.
What it demonstrates:
- Interpolating
${input.*}into parameters - Defining dynamic inputs
Example Code Snippet:
Input Parameters - Workflow Example
{
"id": "base-wf-call-dp-with-input",
"name": "base-wf-call-dp-with-input",
"type": "workflow",
"version": "0.0.1",
"displayName": "base-wf-call-dp-with-input",
"description": "Basic workflow that demonstrates calling a datapoint with input parameter mapping. Takes an input message and passes it to a POST datapoint, showing how to extract and transform input data for datapoint calls. Useful for learning parameter passing and input handling in temporal workflows.",
"tags": [
"example",
"simple-example",
"scenario-example-base",
"scenario-example-base-workflows"
],
"workflow": {
"type": "temporal",
"definition": {
"do": [
{
"echoCall": {
"call": "olive",
"with": {
"datapoint": "postman-dp-http-postman-post-placeholder",
"parameters": {
"input": "${input.message}"
}
}
}
}
]
}
}
}
How to trigger the workflow with the data-orchestrator:
Request Input
{
"id": "base-wf-call-dp-with-input",
"input": {
"message": "Hello from OLIVE!"
}
}
Input Parameter Chaining
This example demonstrates how step-input chaining works, where each workflow step receives the output of the previous step as its input, while the original trigger payload remains accessible through root.
What it demonstrates:
- Step-to-step input chaining (
inputis replaced after each step, if modified) - Reusing the previous step's output as the next step's input
- Persistent access to the original trigger payload via
root - Parallel reads of
input(current step context) androot(original context)
Example Code Snippet:
Input Parameter Chaining - Workflow Example
{
"id": "base-wf-input-param-chain-behavior",
"name": "base-wf-input-param-chain-behavior",
"type": "workflow",
"version": "0.0.1",
"displayName": "base-wf-input-param-chain-behavior",
"description": "Example Temporal workflow that demonstrates chaining datapoint calls and propagating workflow input and root context across steps. The workflow invokes the same HTTP-based datapoint twice, showing how input and root values behave throught the workflow.",
"tags": [
"example",
"simple-example",
"scenario-example-base",
"scenario-example-base-workflows"
],
"workflow": {
"type": "temporal",
"definition": {
"do": [
{
"firstEcho": {
"call": "olive",
"with": {
"datapoint": "postman-dp-http-postman-post-placeholder",
"parameters": {
"step": "1",
"inputSeenByStep": "${input}",
"rootSeenByStep": "${root}"
}
}
}
},
{
"secondEcho": {
"call": "olive",
"with": {
"datapoint": "postman-dp-http-postman-post-placeholder",
"parameters": {
"step": "2",
"inputSeenByStep": "${input}",
"rootMessage": "${root.message}",
"rootFull": "${root}"
}
}
}
}
]
}
}
}
How to trigger the workflow with the data-orchestrator:
Request Input
{
"id": "base-wf-input-param-chain-behavior",
"input": {
"message": "Hello from client!",
"id": "1234"
}
}
This payload becomes the root object for the entire workflow execution.
How Input Is Seen by Each Step
Step 1 – firstEcho
At the start of the workflow:
inputis initialized with the trigger payloadrootis also set to the trigger payload
Parameters received by the datapoint:
Request Input
{
"step": "1",
"inputSeenByStep": {
"message": "Hello from client!",
"id": "1234"
},
"rootSeenByStep": {
"message": "Hello from client!",
"id": "1234"
}
}
inputandrootare identical only at the first step- The output of
firstEchobecomes theinputfor the next step
Step 2 – secondEcho
In the second step:
inputnow contains the result produced byfirstEcho, in our case the called datapoint wrapped the input and attached some additional metadatarootstill contains the original trigger payload
Parameters received by the datapoint:
Request Input
...
"data": {
{
"step": "2",
"inputSeenByStep": {
"message": "Hello from client!",
"id": "1234"
},
"rootMessage": "Hello from client!",
"rootFull": {
"message": "Hello from client!",
"id": "1234"
}
},
....
}
...
Explanation:
inputSeenByStepstill contains the original input object, but the first echo modified the data and wrapped it in additional metadataroot.messagedemonstrates accessing a single field from the original payload.rootFullshows that the entire root object remains available at any step.
Loop Example (for / each)
Demonstrates iterating over lists.
What it demonstrates:
for.eachloop pattern- Iteration variables
itemandindex - Running a task per item
Example Code Snippet:
For Each Loop - Workflow Example
{
"id": "base-wf-for-each-loop",
"name": "base-wf-for-each-loop",
"type": "workflow",
"version": "0.0.1",
"displayName": "base-wf-for-each-loop",
"description": "Demonstrates for-each loop functionality in workflows by iterating over an array of entries from the input. For each entry, calls a datapoint with the current index and entry value. Useful for learning how to process collections of data within temporal workflows and understanding loop iteration patterns.",
"tags": [
"example",
"simple-example",
"scenario-example-base",
"scenario-example-base-workflows"
],
"workflow": {
"type": "temporal",
"definition": {
"do": [
{
"processEntries": {
"for": {
"each": "entry",
"in": "${input.entries}",
"at": "index"
},
"do": [
{
"postEachEntry": {
"call": "olive",
"with": {
"datapoint": "postman-dp-http-postman-post-placeholder",
"parameters": {
"index": "${index}",
"entry": "${entry}"
}
}
}
}
]
}
}
]
}
}
}
How to trigger the workflow with the data-orchestrator:
Request Input
{
"id": "base-wf-for-each-loop",
"input": {
"entries": [
{ "id": 1, "name": "Aragorn" },
{ "id": 2, "name": "Gandalf" },
{ "id": 3, "name": "Legolas" }
]
}
}
Loop with Conditional Skip
Demonstrates iterating through a list while selectively processing only the items that meet a condition.
What it demonstrates:
- Using
for.eachto loop over an array - Evaluating conditions inside a loop with a
switch - Skipping items that do not satisfy a condition
- Executing tasks only for matching entries
- Using
continueto move to the next loop iteration
Example Code Snippet:
Loop with Conditional Skip - Workflow Example
{
"id": "base-wf-conditional-loop",
"name": "base-wf-conditional-loop",
"type": "workflow",
"version": "0.0.1",
"displayName": "base-wf-conditional-loop",
"description": "Demonstrates conditional logic within for-each loops by iterating over entries and applying conditional processing. Uses ternary operator to check if each entry is active - processes the entry name if active, otherwise outputs 'skipped'. Useful for learning how to combine loop iteration with conditional logic in temporal workflows.",
"tags": [
"example",
"simple-example",
"scenario-example-base",
"scenario-example-base-workflows"
],
"workflow": {
"type": "temporal",
"definition": {
"do": [
{
"processEntries": {
"for": {
"each": "entry",
"in": "${input.entries}"
},
"do": [
{
"postActiveOrSkipped": {
"call": "olive",
"with": {
"datapoint": "postman-dp-http-postman-post-placeholder",
"parameters": {
"message": "${ entry.active ? entry.name : 'skipped' }"
}
}
}
}
]
}
}
]
}
}
}
How to trigger the workflow with the data-orchestrator:
Request Input
{
"id": "base-wf-conditional-loop",
"input": {
"entries": [
{ "name": "Alice", "active": true },
{ "name": "Bob", "active": false },
{ "name": "Cara", "active": true }
]
}
}
Switch Example (Branching)
Shows conditional routing based on input values.
What it demonstrates:
- Multiple conditional branches
- JSONata expressions in
when - Routing to named tasks (
then) - Falling back to
unknownActionwhen no condition matches
Example Code Snippet:
Switch - Workflow Example
{
"id": "base-wf-switch",
"name": "base-wf-switch",
"type": "workflow",
"version": "0.0.1",
"displayName": "base-wf-switch",
"description": "Demonstrates switch-case conditional branching in workflows by routing execution based on input type. Evaluates input.type and directs flow to different handlers (A, B, or default). Each branch calls a datapoint with specific parameters and terminates. Useful for learning conditional workflow routing and multi-path execution patterns.",
"tags": [
"example",
"simple-example",
"scenario-example-base",
"scenario-example-base-workflows"
],
"workflow": {
"type": "temporal",
"definition": {
"do": [
{
"routeByType": {
"switch": [
{
"caseA": {
"when": "${input.type = 'A'}",
"then": "handleA"
}
},
{
"caseB": {
"when": "${input.type = 'B'}",
"then": "handleB"
}
},
{
"fallback": {
"when": "${true}",
"then": "handleDefault"
}
}
]
}
},
{
"handleA": {
"call": "olive",
"with": {
"datapoint": "postman-dp-http-postman-post-placeholder",
"parameters": {
"branch": "A"
}
},
"then": "end"
}
},
{
"handleB": {
"call": "olive",
"with": {
"datapoint": "postman-dp-http-postman-post-placeholder",
"parameters": {
"branch": "B"
}
},
"then": "end"
}
},
{
"handleDefault": {
"call": "olive",
"with": {
"datapoint": "postman-dp-http-postman-post-placeholder",
"parameters": {
"branch": "default"
}
},
"then": "end"
}
}
]
}
}
}
How to trigger the workflow with the data-orchestrator:
Trigger branch "A"
Request Input
{
"id": "base-wf-switch",
"input": { "type": "A" }
}
Default behavior when input isn't recognized- fallback action
Request Input
{
"id": "base-wf-switch",
"input": { "type": "C" }
}
Multi-Step Workflow
Shows how multiple tasks execute in sequence and how values computed in one step can be reused later.
This example uses a set task to prepare data and then passes those variables into a datapoint call.
What it demonstrates:
- Sequential execution of multiple tasks
- Using
setto define workflow-local variables frominput - Reusing those variables in the next
call - Combining simple and nested data
Example Code Snippet:
Multi-Step - Workflow Example
{
"id": "base-wf-set-task",
"name": "base-wf-set-task",
"type": "workflow",
"version": "0.0.1",
"displayName": "base-wf-set-task",
"description": "Demonstrates variable assignment and data preparation using the 'set' task in workflows. Creates both simple and structured variables from input data, then passes these prepared variables to a datapoint call. Useful for learning how to transform and store intermediate data within workflow execution.",
"tags": [
"example",
"simple-example",
"scenario-example-base",
"scenario-example-base-workflows"
],
"workflow": {
"type": "temporal",
"definition": {
"do": [
{
"prepareData": {
"set": {
"simpleValue": "${input.message}",
"structuredValue": {
"meta": {
"tag": "${input.tag}"
}
}
}
}
},
{
"postPrepared": {
"call": "olive",
"with": {
"datapoint": "postman-dp-http-postman-post-placeholder",
"parameters": {
"simple": "${simpleValue}",
"full": "${structuredValue}"
}
}
}
}
]
}
}
}
How to trigger the workflow with the data-orchestrator:
Request Input
{
"id": "base-wf-set-task",
"input": {
"message": "Hello world!",
"tag": "example"
}
}
How the datapoint receives the resolved values:
echoPrepared → echo-datapoint input
{
"simple": "Hello world!",
"full": {
"meta": {
"tag": "example"
}
}
}
Fork Example (Parallel Execution)
This example demonstrates a fork task that calls two datapoints in parallel.
What it demonstrates:
- Defining multiple branches inside a fork task
- Executing independent datapoint calls in parallel
- Using
compete: truefor concurrent execution
Example Code Snippet:
Fork Task - Workflow Example
{
"id": "base-wf-fork",
"name": "base-wf-fork",
"type": "workflow",
"version": "0.0.1",
"displayName": "base-wf-fork",
"description": "Simple workflow demonstrating the fork task calling two datapoint calls in parallel.",
"tags": [
"example",
"simple-example",
"scenario-example-base",
"scenario-example-base-workflows"
],
"workflow": {
"type": "temporal",
"definition": {
"do": [
{
"raiseAlarm": {
"fork": {
"compete": true,
"branches": [
{
"callDoctor": {
"call": "olive",
"with": {
"datapoint": "postman-dp-http-postman-post-placeholder",
"parameters": {
"message": "Doctor!"
}
}
}
},
{
"callNurse": {
"call": "olive",
"with": {
"datapoint": "postman-dp-http-postman-post-placeholder",
"parameters": {
"message": "Nurse!"
}
}
}
}
]
}
}
}
]
}
}
}
How to trigger the workflow with the data-orchestrator:
Request Input
{
"id": "base-wf-fork"
}
Wait Between Two Calls Example
This example demonstrates a simple workflow that:
- Calls a datapoint
- Waits for 30 seconds
- Calls the datapoint again
This example uses the structured duration format.
What it demonstrates:
- Pausing workflow execution using
wait - Continuing execution after the defined delay
Example Code Snippet:
Wait Task - Workflow Example
{
"id": "base-wf-wait",
"name": "base-wf-wait",
"type": "workflow",
"version": "0.0.1",
"displayName": "base-wf-wait",
"description": "Simple workflow demonstrating the wait task between two datapoint calls.",
"tags": [
"example",
"simple-example",
"scenario-example-base",
"scenario-example-base-workflows"
],
"workflow": {
"type": "temporal",
"definition": {
"do": [
{
"firstCall": {
"call": "olive",
"with": {
"datapoint": "postman-dp-http-postman-post-placeholder",
"parameters": {
"message": "Before waiting"
}
}
}
},
{
"wait30Seconds": {
"wait": {
"seconds": 30
}
}
},
{
"secondCall": {
"call": "olive",
"with": {
"datapoint": "postman-dp-http-postman-post-placeholder",
"parameters": {
"message": "After waiting"
}
}
}
}
]
}
}
}
How to trigger the workflow with the data-orchestrator:
Request Input
{
"id": "base-wf-wait"
}
Raise with Inline Error
This example demonstrates a workflow that immediately raises an error using an inline error definition.
What it demonstrates:
- Using the
raisetask to terminate workflow execution - Defining the error object directly inside the task
- Providing structured error metadata such as
type,status, anddetail - Using workflow context values (e.g.,
${root}) inside the error message
Example Code Snippet:
Raise Inline Error - Workflow Example
{
"id": "base-wf-raise-inline",
"name": "base-wf-raise-inline",
"type": "workflow",
"version": "0.0.1",
"displayName": "base-wf-raise-inline",
"description": "Simple workflow that immediately raises an error using an inline error definition.",
"tags": [
"example",
"simple-example",
"scenario-example-base",
"scenario-example-base-workflows"
],
"workflow": {
"type": "temporal",
"definition": {
"do": [
{
"notImplemented": {
"raise": {
"error": {
"type": "https://open-workflow-specification.org/spec/1.0.0/errors/not-implemented",
"status": 500,
"title": "Not Implemented",
"detail": "This workflow is not implemented yet: ${root}"
}
}
}
}
]
}
}
}
How to trigger the workflow with the data-orchestrator:
Request Input
{
"id": "base-wf-raise-inline"
}
Raise with Reusable Error
This example demonstrates how a workflow can define a reusable error and raise it by reference.
What it demonstrates:
- Declaring reusable error definitions in
use.errors - Referencing predefined errors from a
raisetask - Reusing standardized error structures across multiple tasks or workflows
- Separating error definitions from task logic for better maintainability
Example Code Snippet:
Raise Inline Error - Workflow Example
{
"id": "base-wf-raise-reusable",
"name": "base-wf-raise-reusable",
"type": "workflow",
"version": "0.0.1",
"displayName": "base-wf-raise-reusable",
"description": "Workflow that raises a predefined reusable error.",
"tags": [
"example",
"simple-example",
"scenario-example-base",
"scenario-example-base-workflows"
],
"workflow": {
"type": "temporal",
"definition": {
"use": {
"errors": {
"notImplemented": {
"type": "https://open-workflow-specification.org/spec/1.0.0/errors/not-implemented",
"status": 500,
"title": "Not Implemented",
"detail": "This workflow is a work in progress (but its error is reusable!)"
}
}
},
"do": [
{
"notImplemented": {
"raise": {
"error": "notImplemented"
}
}
}
]
}
}
}
How to trigger the workflow with the data-orchestrator:
Request Input
{
"id": "base-wf-raise-reusable"
}
Try / Catch Specified Error Around a Datapoint Call
This example demonstrates how a workflow can wrap a datapoint call inside a try block and catch specific errors.
What it demonstrates:
- Executing tasks inside a
tryblock - Catching errors based on a filter condition
- Preventing workflow failure by handling the error
Example Code Snippet:
Try / Catch - Workflow Example
{
"id": "base-wf-try-catch",
"name": "base-wf-try-catch",
"type": "workflow",
"version": "0.0.1",
"displayName": "base-wf-try-catch",
"description": "Simple workflow demonstrating try/catch around a datapoint call.",
"tags": [
"example",
"simple-example",
"scenario-example-base",
"scenario-example-base-workflows"
],
"workflow": {
"type": "temporal",
"definition": {
"do": [
{
"tryCall": {
"try": [
{
"callService": {
"call": "olive",
"with": {
"datapoint": "postman-dp-http-postman-post-placeholder",
"parameters": {
"message": "Trying call"
}
}
}
}
],
"catch": {
"errors": {
"with": {
"status": 500
}
}
}
}
}
]
}
}
}
How to trigger the workflow with the data-orchestrator:
Request Input
{
"id": "base-wf-try-catch"
}
Try / Catch With Error Handling
This example demonstrates catching an error and executing recovery tasks.
What it demonstrates:
- Raising an error inside a
tryblock - Handling the error using
catch.do - Omitting an error code in
catch.errors.withmakes the catch block act as a catch-all
Example Code Snippet:
Try / Catch with Raise - Workflow Example
{
"id": "base-wf-try-catch-force-500",
"name": "base-wf-try-catch-force-500",
"type": "workflow",
"version": "0.0.1",
"displayName": "base-wf-try-catch-force-500",
"description": "Simple workflow demonstrating try/catch around a datapoint call that forces a 500 error.",
"tags": [
"example",
"simple-example",
"scenario-example-base",
"scenario-example-base-workflows"
],
"workflow": {
"type": "temporal",
"definition": {
"do": [
{
"tryBlock": {
"try": [
{
"forceError": {
"raise": {
"error": {
"type": "https://open-workflow-specification.org/spec/1.0.0/errors/test",
"status": 500,
"title": "Forced Failure",
"detail": "This is an intentional test error"
}
}
}
}
],
"catch": {
"do": [
{
"caughtMarker": {
"call": "olive",
"with": {
"datapoint": "postman-dp-http-postman-post-placeholder",
"parameters": {
"message": "Caught the forced 500 in catch.do"
}
}
}
}
]
}
}
}
]
}
}
}
How to trigger the workflow with the data-orchestrator:
Request Input
{
"id": "base-wf-try-catch-force-500"
}
Try / Catch With Error Context
This example calls a non existent datapoint to demonstrate storing the caught error in a variable and using it inside subsequent tasks.
What it demonstrates:
- Storing the caught error using
catch.as - Accessing structured error information in subsequent tasks
- Passing error details to datapoint calls
Example Code Snippet:
Try / Catch with Error Context - Workflow Example
{
"id": "base-wf-try-catch-nonexistent",
"name": "base-wf-try-catch-nonexistent",
"type": "workflow",
"version": "0.0.1",
"displayName": "base-wf-try-catch-nonexistent",
"description": "Simple workflow demonstrating try/catch around a non-existent datapoint call.",
"tags": [
"example",
"simple-example",
"scenario-example-base",
"scenario-example-base-workflows"
],
"workflow": {
"type": "temporal",
"definition": {
"do": [
{
"testTry": {
"try": [
{
"nonExistentCall": {
"call": "olive",
"with": {
"datapoint": "nonexistent"
}
}
}
],
"catch": {
"as": "err",
"do": [
{
"caughtMarker": {
"call": "olive",
"with": {
"datapoint": "postman-dp-http-postman-post-placeholder",
"parameters": {
"message": "${ err }"
}
}
}
}
]
}
}
}
]
}
}
}
How to trigger the workflow with the data-orchestrator:
Request Input
{
"id": "base-wf-try-catch-nonexistent"
}
Timeout With Reusable Definition
This example demonstrates how a reusable timeout can be declared once and referenced from a task.
What it demonstrates:
- Declaring reusable timeout definitions under
use.timeouts - Referencing a timeout by name
- Reusing timeout configuration across tasks
Example Code Snippet:
This workflow defines a reusable timeout named quickTimeout with a limit of 5 seconds. The task fastOperation references that timeout but waits for 10 seconds, so the task exceeds its allowed execution time and fails with a timeout.
Timeout with Reusable Definition - Workflow Example
{
"id": "base-wf-timeout-reusable",
"name": "base-wf-timeout-reusable",
"type": "workflow",
"version": "0.0.1",
"displayName": "base-wf-timeout-reusable",
"description": "Simple workflow demonstrating the timeout task at the task level using a reusable timeout.",
"tags": [
"example",
"simple-example",
"scenario-example-base",
"scenario-example-base-workflows"
],
"workflow": {
"type": "temporal",
"definition": {
"use": {
"timeouts": {
"quickTimeout": {
"after": {
"seconds": 5
}
}
}
},
"do": [
{
"fastOperation": {
"wait": {
"seconds": 10
},
"timeout": "quickTimeout"
}
}
]
}
}
}
How to trigger the workflow with the data-orchestrator:
Request Input
{
"id": "base-wf-timeout-reusable"
}
Task-Level Timeout
This example demonstrates how a timeout can be applied directly to a single task.
What it demonstrates:
- Applying an inline timeout to one task
- Limiting task execution without affecting earlier tasks
- Failing a task when its runtime exceeds the configured duration
Example Code Snippet:
The first task completes normally. The second task waits for 30 seconds but is limited by an inline timeout of 5 seconds, so the workflow fails during that task.
Task-Level Timeout - Workflow Example
{
"id": "base-wf-timeout-task-level",
"name": "base-wf-timeout-task-level",
"type": "workflow",
"version": "0.0.1",
"displayName": "base-wf-timeout-task-level",
"description": "Simple workflow demonstrating the timeout task at the task level.",
"tags": [
"example",
"simple-example",
"scenario-example-base",
"scenario-example-base-workflows"
],
"workflow": {
"type": "temporal",
"definition": {
"do": [
{
"firstCall": {
"call": "olive",
"with": {
"datapoint": "postman-dp-http-postman-post-placeholder",
"parameters": {
"message": "Before waiting"
}
}
}
},
{
"wait30Seconds": {
"wait": {
"seconds": 30
},
"timeout": {
"after": {
"seconds": 5
}
}
}
}
]
}
}
}
How to trigger the workflow with the data-orchestrator:
Request Input
{
"id": "base-wf-timeout-task-level"
}
Workflow-Level Timeout Example
This example demonstrates how a timeout can be applied to the entire workflow.
What it demonstrates:
- Defining a timeout at workflow level
- Limiting the total runtime of the workflow
- Stopping execution when the overall workflow exceeds the configured duration
Example Code Snippet:
The workflow is allowed to run for a maximum of 15 seconds. Since the second task waits for 30 seconds, the workflow exceeds the configured limit and fails with a workflow timeout.
Task-Level Timeout - Workflow Example
{
"id": "base-wf-timeout-wf-level",
"name": "base-wf-timeout-wf-level",
"type": "workflow",
"version": "0.0.1",
"displayName": "base-wf-timeout-wf-level",
"description": "Simple workflow demonstrating the timeout task at the workflow level.",
"tags": [
"example",
"simple-example",
"scenario-example-base",
"scenario-example-base-workflows"
],
"workflow": {
"type": "temporal",
"definition": {
"do": [
{
"firstCall": {
"call": "olive",
"with": {
"datapoint": "postman-dp-http-postman-post-placeholder",
"parameters": {
"message": "Before waiting"
}
}
}
},
{
"wait30Seconds": {
"wait": {
"seconds": 30
}
}
}
],
"timeout": {
"after": {
"seconds": 15
}
}
}
}
}
How to trigger the workflow with the data-orchestrator:
Request Input
{
"id": "base-wf-timeout-wf-level"
}