Create your own workflow

When templates don't fit your needs, Create Your Own lets you build custom workflows. Use the drag-and-drop interface to chain actions from the actions catalog into automation that matches your process.

How to use this guide

This guide shows you how to build workflows using concepts and a complete example. Choose your learning path:

• Learn core concepts first → Read Core concepts and Workflow patterns to understand the fundamentals, then apply them

• Follow the example → Jump to Example walkthrough to build an EC2 auto-resize workflow step-by-step

• Reference patterns → Use the Workflow patterns section as a quick reference when building your own workflows

  Dica

  New to workflows? Start with core concepts, then follow the example. The EC2 workflow demonstrates all key patterns in a real-world scenario.

Why build custom workflows?

Build your own workflow to:

• Implement unique business logic that templates don't support
• Integrate multiple systems beyond standard templates
• Handle complex decisions with conditional branching
• Match your team's process for approvals and notifications

Core concepts

Understand these fundamentals before you build:

For detailed error handling patterns, see Best practices.

Quick start

Build your first workflow in five steps:

1. Navigate to one.newrelic.com > All Capabilities > Workflow Automation and select Create Your Own
2. Define parameters for credentials (from secrets manager: ${{ :secrets:keyName }}), configuration (regions, instance types), and runtime data (account IDs, alert IDs)
3. Drag actions from the catalog, connect them with ${{ .steps.stepName.outputs.field }} syntax to pass data
4. Insert switches for conditional branching, loops for processing lists or polling, approval gates for human decisions
5. Run after each section to catch errors early, then start or schedule your workflow

Key workflow patterns

Four essential patterns handle most automation scenarios. Each pattern is demonstrated in the Example walkthrough below.

Conditional branching with switches

Use switches when: Outcomes vary based on data (threshold checks, API responses, user decisions)

Key syntax:

- name: hasCompleted
  type: switch
  switch:
    - condition: "${{ .steps.waitForCompletion.outputs.automationExecutionStatus == 'Failed' }}"
      next: displayError
    - condition: "${{ .steps.waitForCompletion.outputs.automationExecutionStatus == 'Success' }}"
      next: displaySuccess
  next: displayUnexpected  # Default path when no condition matches

See it in action: Handle team response and Verify and clean up sections show switches routing based on Slack reactions and AWS SSM status.

Loops for processing lists

Use loops when: Processing multiple items or repeating actions

Key syntax:

# Send progress updates using range loop
- name: progressLoop
  type: loop
  for:
    in: "${{ [range(1; 5)] }}"  # Loop 5 times
    steps:
      - name: wait
        type: wait
        seconds: 10
      - name: progressMessage
        type: action
        action: slack.chat.postMessage
        version: 1
        inputs:
          channel: "${{ .workflowInputs.channel }}"
          text: "Resizing in progress..."

See it in action: Execute the resize section uses progressLoop for status updates.

Approval gates and waiting

Use approval gates when: Human judgment needed before destructive operations or compliance sign-off required

Key syntax:

- name: requestApproval
  type: action
  action: slack.chat.postMessage
  version: 1
  inputs:
    channel: "#approvals"
    text: "Approve? React with :thumbsup: or :thumbsdown:"

- name: getReactions
  type: action
  action: slack.chat.getReactions
  version: 1
  inputs:
    token: "${{ .workflowInputs.slackToken }}"
    channelID: "${{ .steps.requestApproval.outputs.channelID }}"
    threadTs: "${{ .steps.requestApproval.outputs.threadTs }}"
    timeout: 300  # Wait 5 minutes for reaction

- name: checkApproval
  type: switch
  switch:
    - condition: '${{ .steps.getReactions.outputs.reactions | any(.name == "+1") }}'
      next: handleApproval
    - condition: '${{ .steps.getReactions.outputs.reactions | any(.name == "-1") }}'
      next: handleRejection

For simple delays:

- name: waitBeforeRetry
  type: wait
  seconds: 60  # Wait 60 seconds before continuing

See it in action: Request team approval section implements full Slack approval workflow.

Passing data between steps

Use data passing when: One step's output becomes another's input (the foundation of all workflows)

Key syntax:

# Reference previous step outputs
awsRegion: "${{ .inputs.region }}"
instanceId: "${{ .steps.getAlert.outputs.data.entity.instanceId }}"

See it in action: All sections demonstrate data passing—each step builds on previous results.

Example walkthrough: Auto-resize EC2 with approval

This complete example demonstrates how to build a workflow that automatically resizes EC2 instances when CPU spikes—after getting team approval via Slack. It shows data gathering, conditional logic, external integrations, and error handling in a real-world scenario.

Prerequisites

Before building this workflow, ensure you have:

• AWS: Credentials with EC2 and Systems Manager permissions
• Slack: Bot token and channel for notifications
• New Relic: Alert condition monitoring EC2 CPU
• Secrets manager: Configured (see secrets management)

Workflow overview

High-level flow:

1. Gather data: Fetch alert and instance details from New Relic
2. Request approval: Send Slack message, wait for team response
3. Execute resize: Use AWS Systems Manager to resize EC2 instance
4. Verify and clean up: Check results, notify team, remove temporary resources

This example demonstrates key patterns you'll use in custom workflows: querying APIs, conditional branching, external integrations, polling loops, and error handling.

Workflow inputs

This workflow requires credentials, configuration, and runtime context as inputs. Sensitive values come from secrets manager using ${{ :secrets:keyName }} syntax.

Input categories:

• Authentication: AWS and Slack credentials from secrets manager
• Alert context: Account ID and issue ID from New Relic
• Configuration: Region, instance type, timezone, Slack channel

Build the workflow step-by-step

Now let's build each part of the workflow. Each step includes the specific actions to add and the workflow patterns they demonstrate.

Next steps

Run and manage

• Start and schedule workflows: Trigger manually or schedule automatically.
• Managing workflows: Edit, version, clone, or deactivate workflows.

Improve

• Best practices: Error handling, secrets management, performance, testing.
• Actions catalog: AWS, Azure, GCP, HTTP, data transformations.
• Workflow examples: More real-world automation scenarios.

Scale

• Workflow Automation APIs: Deploy via API for infrastructure-as-code.
• Workflow limits: Timeouts, action limits, payload constraints.