Common Use Cases and Design Patterns

Note: Compose is only available for Beta testing. See Welcome to UKG Compose > Beta Disclosure for more information.

This page helps builders understand the kinds of business problems UKG Compose can solve and the workflow patterns that are most useful when designing a solution. The goal is to inspire users with practical examples without limiting them to a fixed catalog of solutions. UKG Compose supports bring-your-own-use-case workflow design using the workflow building blocks available in the product.

Start with patterns, not just examples

Most successful Compose solutions begin with a workflow pattern.

Common patterns include:

• Scheduled checks and recurring evaluations
• Event-driven workflows
• Request and response flows
• Approvals and exception handling
• Service orchestration across systems
• Notifications, escalations, and follow-up actions

Once the right pattern is clear, the builder can decide which trigger, logic, and action steps are needed.

Quick reference: common use case categories

Notifications & Alerts:

• Termination checklist to IT, Payroll, and Security
• Legal name change confirmation and downstream alerting
• Status change to PT or Temp with benefits and scheduling alerts
• Certification or license expiry reminders
• PTO balance threshold nudges

Decisions, Compliance, and Signals:

• Employee Wage Step Progression using decision tables
• Equity Signals in Company Reviews with AI
• Salary band compliance checks with variance flags
• Out-of-policy detection on hours, overtime, or job changes
• Timesheet anomaly detection and outreach tasks

Approvals, Cases, and Programs:

• HR Programs for Reimbursements with receipt capture and policy rules
• Tuition or certification reimbursement with auto calculation
• Remote work exception requests with eligibility checks
• Shift swap requests and manager approval
• Associate Relations case intake and triage routing

Collaboration and Service Integrations:

• Slack or Teams notifications with approve or deny actions
• ServiceNow request or incident ticket creation and updates
• Jira task creation for onboarding or offboarding subtasks
• DocuSign or Adobe Sign signature collection
• Weekly email digests to HRBPs on notable changes

Pattern 1: Scheduled checks and recurring evaluations

Use this pattern when work should happen on a known cadence, such as every day, every week, or at a scheduled point in the business cycle.

This pattern is useful for:

• Policy checks
• Exception reporting
• Periodic reminders
• Compliance follow-up
• Threshold monitoring

Typical design:

1. Start with a Schedule Trigger.
2. Retrieve or evaluate the required data.
3. Use IF or Switch to determine whether action is needed.
4. Send a notification, create a task, or route to a downstream system.

Example use cases:

• Wage or step progression review
• Overtime or job change policy flags
• Recurring compliance checks
• Scheduled reminders for unresolved work

Pattern 2: Event-driven workflows

Use this pattern when a workflow should begin because something happened in UKG Pro (see Webhook Triggers).

This pattern is useful for:

• Reacting to supported HCM events
• Triggering follow-up actions when business data changes
• Notifying downstream teams or systems after a defined event
• Launching workflow logic only when there is a meaningful change to process

Typical design:

1. Start with an HCM Webhooks Trigger.
2. Review the incoming event payload.
3. Apply logic to determine what the event means.
4. Send a notification, create a case, call another service, or branch to another path.

Example use cases:

• Notify a team after a supported employee change event
• Create a follow-up action when a policy-related update occurs
• Route downstream integration work after a business event is received

Note: Event-driven workflows using the HCM Webhooks Trigger require the UKG Webhooks prerequisite to be configured first (see Access and Setup).

Pattern 3: Request and response workflows

Use this pattern when a workflow begins because a person or system submits a request and expects a response.

This pattern is useful for:

• Synchronous request/response workflows: Accept an inbound webhook call, process logic, and return a response directly to the caller
• Form-based workflows: Collect structured input from a user, evaluate conditions, and guide the user through next steps
• API-style integrations where the calling system expects an immediate result
• Request acknowledgment patterns where the workflow confirms receipt and returns structured data

Synchronous request/response design

Typical design for synchronous workflows (see Webhook Triggers):

1. Start with UkgWebhookTrigger or Webhook.
2. Capture and validate the request data.
3. Apply business logic or call downstream services.
4. Use Respond to Webhook to return a structured response to the caller.

This pattern is especially useful when:

• The calling system expects an HTTP response with specific data
• The workflow acts as an API endpoint
• Response time must be fast enough for synchronous interaction
• The workflow result must be returned directly rather than processed asynchronously

Form-based workflow design

Typical design for form-based workflows:

1. Start with Form Trigger to collect initial input from the user.
2. Validate and evaluate the submitted data.
3. Use Next Form to collect additional information if needed.
4. Apply routing logic with IF or Switch.
5. Use Ending Form to close the interaction and confirm the outcome.

This pattern is especially useful when:

• Employees need self-service request workflows.
• The process requires guided data collection across multiple steps.
• Validation and approval steps must occur between form submissions.
• The workflow must provide immediate feedback to the user.

Example use cases:

• Form-based: employee reimbursement intake with receipt capture and multi-step review
• Form-based: facility access requests with validation and approval routing
• Form-based: exception handling intake with guided questions and policy checks
• Synchronous API: external system calls a workflow endpoint and expects structured JSON response
• Synchronous API: webhook receiver that validates input and returns success or error immediately

Pattern 4: Approvals and exception handling

Use this pattern when a process requires human review, escalation, or a decision based on business logic (see Approval and Workflow Nodes).

This pattern is useful for:

• Routing requests that need manager or admin attention
• Handling exceptions to standard policy
• Escalating work that crosses a threshold
• Separating straight-through processing from exception paths

Typical design:

1. Start with a schedule, form, webhook, or event trigger.
2. Evaluate the input against a condition.
3. Route standard cases one way and exceptions another.
4. Notify the right user or system and track the outcome (see Notification Nodes).

Example use cases:

• Overtime policy flags
• Job change exception routing
• Reimbursements that exceed policy thresholds
• Escalations for unresolved compliance actions

Pattern 5: Service orchestration and downstream integrations

Use this pattern when Compose needs to connect multiple services into one business process.

This pattern is useful for:

• Coordinating multiple actions after a single trigger
• Sending data to collaboration or ticketing tools
• Calling external APIs
• Standardizing follow-up steps across systems

Typical design:

1. Start with a trigger.
2. Transform or enrich the data if needed.
3. Call one or more downstream services.
4. record success, notify the next stakeholder, or escalate failures.

Example use cases:

• Create or update a ServiceNow ticket
• Send a notification after a business event
• Route information into collaboration tools
• Connect a UKG process to one or more external services

Representative use cases for UKG Compose

The following examples reflect priority solution areas for this doc set.

Wage or step progression

This use case fits well when a business needs recurring checks, notifications, or workflow routing tied to progression logic.

Common pattern:

• Scheduled review
• Conditional evaluation
• Notification or downstream action

OSHA or safety compliance management

This use case fits when compliance-related work needs recurring evaluation, follow-up actions, or exception routing.

Common pattern:

• Scheduled or request-driven workflow
• Policy evaluation
• Escalation, reminder, or tracking action

Employee facility management

This use case fits when a process begins with a request and needs routing, validation, and follow-up.

Common pattern:

• Form or webhook intake
• Branching logic
• Notification, tasking, or service action

Overtime or job change policy flags

This use case fits when a workflow needs to identify threshold conditions and route work differently depending on what was found.

Common pattern:

• Scheduled or event-driven trigger
• IF or Switch-based evaluation
• Escalation or exception handling

Employee reimbursements with receipt capture and policy checks

This use case demonstrates form-based workflow design combined with approval and policy logic.

Common pattern:

1. Form Trigger collects reimbursement details and receipt upload
2. Workflow validates required fields and policy thresholds
3. IF or Switch routes based on amount, category, or policy rules
4. Standard requests proceed to approval using Notification (see Notification Nodes)
5. Exception cases route to manual review or escalation
6. Ending Form confirms outcome to the employee after approval decision

This pattern fits when:

• Employees need self-service submission workflows
• The process requires validation before approval
• Policy rules determine routing paths
• Users expect guided interaction and immediate feedback

ServiceNow ticket create or update

This use case fits when Compose is orchestrating work between UKG and an external service system.

Common pattern:

• Event, schedule, or request trigger
• Data preparation
• ServiceNow create or update action
• (Optional) Follow-up notification

Use examples as starting points, not limits

These examples are meant to help users understand where Compose can be effective. They are not intended to define the full boundary of what Compose can support.

When evaluating a new use case, ask:

• What starts the process?
• What decision or routing logic is required?
• What outcome should the workflow produce?
• Does the workflow need to involve another user or system?
• Does the process run on a schedule, from an event, or from a request?

If those questions can be answered with available triggers, logic, and actions, the use case is likely a good fit for Compose.

How to choose the right pattern

Use this simplified guide:

• Choose a scheduled workflow when the business wants recurring evaluation or periodic action
• Choose an event-driven workflow when work should begin after a supported business event (see Webhook Triggers)
• Choose a request-driven workflow when a user or system must submit information to start the process (see Webhook Triggers)
• Choose an approval or exception pattern when not every case follows the same path (see Approval and Workflow Nodes)
• Choose an integration pattern when multiple systems need to work together (see Connectors and Connections)

Many real solutions combine more than one of these patterns (see Build Workflows in UKG Compose).

Related pages

Getting started:

• Get Started with UKG Compose in UKG Pro
• Build Workflows in UKG Compose

Implementation:

• Access and Setup in UKG Pro
• Security and Governance
• Packaging and Scale Guidance

Nodes and connectors:

• Connectors and Connections