Async Utility Apps are lightweight, webhook-triggered workflows that run autonomously in the background to perform tasks such as real-time data lookups, API calls, and on-the-fly data transformations. Their most common use case is powering dynamic dropdown menus inside forms — allowing fields to be populated with live data from external systems without any manual intervention.

Unlike standard workflow applications that manage multi-step user journeys, Async Utility Apps are designed to be invisible to the end-user. They execute silently behind the scenes and return structured responses back to the calling component.

When to Use an Async Utility App

Async Utility Apps are ideal when you need to:

Populate a searchable dropdown in a form with real-time data from an external API (e.g., fetching a list of departments from your HRMS).
Perform real-time data validation as users interact with a form field.
Retrieve context-aware information dynamically based on a user's input or profile.
Execute a reusable data lookup that multiple applications need to share.

Example: An employee fills out an expense report form. When they click the "Cost Center" dropdown, an Async Utility App fires a webhook, calls the finance ERP's API, and returns a list of active cost centers — all in under a second.

How It Works

Overview of the Execution Flow

The lifecycle of an Async Utility App follows a straightforward, automated path:

Trigger — A client-side component (such as a form dropdown) fires an async hook configured with the Async Utility App's ID.
Route — The system's hook routing logic detects the asyncUtilityAppId in the hook configuration and routes the request to the dedicated Async Utility execution service rather than treating it as a standard external webhook.
Execute — The execution service validates the app, creates a tracking session, and runs the app's internal workflow synchronously. Input data (such as search queries or pagination parameters) is passed into the workflow as form data.
Transform & Respond — Upon completion, the system uses a response template defined on the trigger node to map workflow output data into a structured JSON response. This response is returned to the calling component.
Track — The execution session is finalized with a status of COMPLETED or FAILED, enabling full analytics and monitoring.

Workflow Structure

Every Async Utility App is bootstrapped from the Dynamic Dropdown Template, which provisions a fixed three-node workflow:

Node	Type	Purpose
Dynamic Dropdown Trigger	`AUTONOMOUS_SYNC`	Entry point that accepts input parameters (search query, pagination) and holds the response template for output mapping.
Mapper	`MAPPER`	The core data processing node — calls external APIs, transforms the response, and prepares the data for output.
End	`END`	Concludes the workflow execution.

Pre-configured Forms

The template automatically creates two forms:

Form	Fields	Purpose
Filter Params	(Empty by default)	A customizable form where you define any additional filters your dropdown needs.
Pagination & Search	`q` (search query), `pageSize`, `hasNext`, `page`, `skipToken`	System-managed fields that handle search input and both page-based and skip-token pagination out of the box.

Response Template

The trigger node includes a responseTemplate — a JSON template that maps values from the workflow's data center into the final API response. The template parser replaces placeholder tokens (e.g., {{mapper_output.options}}) with actual data collected during execution.

This means the response structure is fully configurable. You can shape the output to match whatever format the consuming component expects.

Creating an Async Utility App

Step 1: Create a New Application

Navigate to Workflows Studio > App Listing and click Create App. In the creation dialog:

Set the Utility Type to Async Utility.
Provide a descriptive Name (e.g., "Fetch Active Cost Centers").
The system automatically sets the Trigger Type to Webhook — this cannot be changed.

Step 2: Configure the Mapper Node

Open the workflow builder. The three-node workflow is already provisioned. Click on the Mapper node to configure it:

Data Source: Define the integration action that fetches data from your external system (e.g., a REST API call to your HRMS).
Mapping Rules: Map each field from the API response to the output structure. For example, map response.departments[].id → option.value and response.departments[].name → option.label.

Step 3: Define the Response Template

On the Trigger node, configure the responseTemplate to structure how the final JSON response will look. Common output fields include:

options — The array of dropdown items.
hasNext — Boolean flag indicating more pages of data exist.
page — Current page number for pagination.

Step 4: Publish the App

Once configured and tested, Publish the app to make it available for use. The app will receive a unique appIdentifier that other applications reference when configuring their async hooks.

Step 5: Link to a Form Dropdown

In any other workflow application's form, configure a dropdown field to use an Async Hook. Set the asyncUtilityAppId to point to your published Async Utility App. When users interact with that dropdown, the utility app executes automatically.

Allowed Node Types

While the template starts with a fixed three-node structure, you can extend the workflow by adding nodes from the following allowed types inside the sync execution block:

Decision Node
Merge Node
Branch Node
Action Node
Function Node
Mapper Node
For Each Loop
While Loop

Note: Input, Approval, and other human-interaction nodes are not supported inside Async Utility Apps since these workflows execute autonomously without user involvement.

Session Tracking and Analytics

Every execution of an Async Utility App is recorded as a Workflow Session tagged with the ASYNC_UTILITY utility type. This integration with the platform's session tracking system provides:

Usage Metrics — How often each utility app is called.
Success/Failure Rates — Visibility into execution reliability.
Performance Monitoring — Track execution times to identify bottlenecks.

These sessions appear in the standard Reports section and can be filtered specifically by utility type.

Key Considerations

Visibility: Async Utility Apps are excluded from the end-user application catalog by default. They are designed to be consumed by other applications, not initiated directly by users.
Pagination Support: The pre-configured form fields support both traditional page-based pagination and skip-token pagination, making it easy to handle large datasets.
Reusability: A single Async Utility App can be referenced by multiple forms across different applications, reducing duplication and ensuring a single source of truth for dynamic data.
OAuth Handling: The system automatically detects which integrations within the utility app require end-user OAuth and manages the authentication flow seamlessly.
Migration: When migrating applications between environments, the system detects Async Utility App dependencies and flags them for proper mapping to ensure nothing breaks in the target environment.
Auto-Documentation: The platform supports AI-assisted documentation generation specifically tailored for utility apps, covering sections like Summary, Integrations, Forms, Workflow Steps, Success Output, and Edge Cases.