Power Automate CSV to Teams: Automate P1/P2 ServiceNow Incident Alerts

What We Are Building

In IT operations, the traditional process of managing email incident exports is simple but repetitive:

1. Receive the incident email.
2. Open the CSV attachment.
3. Find high-priority incidents.
4. Read the incident details.
5. Copy the relevant information.
6. Open Microsoft Teams.
7. Send the incident information to the operations team.

This is exactly the type of repetitive process that Microsoft Power Automate can automate. In this tutorial, we will build a Power Automate workflow that reads a CSV attachment from an email, converts it into text, parses the incident information, identifies High and Critical incidents, and automatically sends the relevant details to Microsoft Teams.

The final automation follows this architecture:

Outlook Email
     │
     ▼
CSV Attachment
     │
     ▼
Power Automate
     │
     ├── Convert Base64 → Text
     │
     ├── Clean CSV Content
     │
     ├── Split CSV into Rows
     │
     ├── Skip Header
     │
     ├── Split Rows into Columns
     │
     ├── Check Incident Priority
     │
     └── Filter High/Critical Incidents
                 │
                 ▼
        Microsoft Teams Alert

Full Flow Visualization

Below is a visual representation of the entire automation flow:

The result is an automated incident notification system. Instead of manually monitoring a CSV report, the operations team receives the important incidents directly in Teams.

Why Automate CSV Incident Processing?

Incident management often involves repetitive data-processing tasks. For example, an operations team may receive a CSV containing hundreds of incidents, while only a small number require immediate attention.

A human operator might have to search for:

Priority = High
Priority = Critical

Power Automate can perform this filtering automatically.

Manual vs. Automated Process

Prerequisites

To build a similar workflow, you will need:

• Microsoft Power Automate
• Microsoft Outlook / Microsoft 365
• Microsoft Teams
• A CSV file containing incident information
• A consistent CSV structure
• Access to create Power Automate flows

For this example, assume that the CSV contains incident fields such as:

Incident,Priority,Short Description,Assignment Group,Assigned To,Caller,Created,Category,Sub Category,Location,Description

Step 1: Trigger the Power Automate Flow

Start with the Outlook trigger: When a new email arrives (V3). Configure the trigger so that only relevant emails are processed.

• Email folder (e.g. Inbox / Incidents)
• Subject filter (e.g. SNOW | NEW P1/P2 INCIDENT)
• Include Attachments: Yes

Step 2: Process Email Attachments

An email can contain multiple attachments. Therefore, the flow uses an Apply to each action to process each attachment individually and verify if it has a .csv extension.

Expression to check for CSV files:

endsWith(items('Apply_to_each')?['name'], '.csv')

Recommended branch behavior: if the attachment is not a CSV, leave the No branch with no processing action. Avoid using Terminate here, because terminating the flow can stop processing other attachments in the same email.

Step 3: Convert the CSV Attachment from Base64 to Text

This is one of the most important steps when working with email attachments in Power Automate. Attachment content is initially provided as Base64-encoded binary data.

Use a Compose action with the following expression:

base64ToString(item()?['contentBytes'])

Step 4: Clean the CSV Content

CSV files exported from enterprise systems can contain Windows-style line endings. Normalize \r\n to \n and remove any remaining carriage returns before splitting the file into rows.

replace(replace(outputs('CSV_Text'), decodeUriComponent('%0D%0A'), decodeUriComponent('%0A')), decodeUriComponent('%0D'), '')

decodeUriComponent('%0A') represents a line-feed character and decodeUriComponent('%0D') represents a carriage return.

Step 5: Handle Windows Line Breaks

Windows systems use \r\n (Carriage Return + Line Feed). Strip out \r using:

replace(outputs('Clean_CSV_Text'), decodeUriComponent('%0D'), '')

Step 6: Split the CSV into Rows

Split the normalized string at every newline character to generate an array of rows:

split(outputs('Remove_CR'), decodeUriComponent('%0A'))

Optional: Count the CSV Rows for Testing

During testing, you can verify the total number of parsed lines by calling:

length(outputs('CSV_Lines'))

Step 8: Skip the CSV Header

The first item in the row array represents column headers (e.g. Incident,Priority...). Skip the first item using:

skip(outputs('CSV_Lines'), 1)

Optional: Inspect the First Data Row

During development, you can inspect the first actual incident row without looping by combining first() and skip():

first(skip(outputs('CSV_Lines'), 1))

Step 10: Ignore Empty Rows

Check that trailing blank lines or spaces are ignored inside the loop condition. If the condition is false, use an empty/no-op branch so the current iteration simply moves on:

greater(length(trim(item())), 0)

Step 11: Split Each Incident into Columns

Inside the row processing loop, the example flow removes simple quote/backslash artifacts and then splits the row by commas:

split(replace(replace(item(), '"', ''), '\\', ''), ',')

Step 12: Access Individual CSV Columns

The example CSV has 11 fields, so the zero-based indexes run from 0 through 10. Keep this mapping aligned with the actual export schema:

Step 13: Filter High and Critical Incidents

Filter only High and Critical incidents using an or() and contains() condition on column index 1. If the condition is false, use a no-op branch rather than terminating the flow:

or(
    contains(outputs('Cols')[1], 'High'),
    contains(outputs('Cols')[1], 'Critical')
)

In this example, High and Critical are treated as the organization's P2/P1-style alert levels. ServiceNow priority labels vary by implementation, so change the condition to match the exact values used in your export.

Step 14: Send the Incident to Microsoft Teams

Use the Teams connector action: Post message in a chat or channel. Format the body using extracted column fields.

Example Microsoft Teams Alert

When triggered, the operations channel receives a formatted notification:

Complete Power Automate Workflow

Here is the complete control flow summary for the entire solution:

┌──────────────────────────────┐
│      New Email Arrives       │
│      Outlook Trigger         │
└──────────────┬───────────────┘
               │
               ▼
┌──────────────────────────────┐
│      Get Attachments         │
└──────────────┬───────────────┘
               │
               ▼
┌──────────────────────────────┐
│   Loop Through Attachments   │
└──────────────┬───────────────┘
               │
               ▼
          Is it CSV?
          /         \
        No           Yes
        │             │
        ▼             ▼
      Ignore     Base64 → Text
                      │
                      ▼
                Clean CSV Text
                      │
                      ▼
                Split into Rows
                      │
                      ▼
                 Skip Header
                      │
                      ▼
              Process Each Row
                      │
                      ▼
                 Empty Row?
                  /      \
                Yes       No
                │          │
                ▼          ▼
              Ignore   Split Columns
                            │
                            ▼
                      Check Priority
                       /          \
                     Low       High/Critical
                      │             │
                      ▼             ▼
                   Ignore     Teams Message

Key Power Automate Expressions

Common Problems & Troubleshooting

CSV attachment isn't readable

Check that the Outlook trigger includes attachments and that the correct attachment content bytes are passed to base64ToString().

CSV rows aren't splitting correctly

Check the line endings. Windows uses \r\n rather than just \n. Strip %0D using replace() before splitting.

Header is being processed as an incident

Ensure the array passed to your loop uses skip(outputs('CSV_Lines'), 1).

Blank Teams messages are being generated

Add a condition checking greater(length(trim(item())), 0) to filter out trailing empty lines.

Incorrect fields appear in Teams

Verify positional column index mapping if the upstream CSV schema was altered.

Important Limitations

1. CSV Is Not the Same as Excel

A CSV file is unformatted plain text with delimiters, whereas .xlsx files are zip-compressed XML workbooks. This tutorial parses plain text. For Excel files, use the native Power Automate Excel Online connector.

2. Commas Inside Fields

If a field value contains commas (e.g. "Server down, impact high"), a plain split(item(), ',') will split inside the field. The approach in this tutorial is therefore best for simple, predictable CSV exports. It is not a full RFC-compliant CSV parser and can also require additional handling for embedded line breaks or complex escaped quotes.

How This Automation Helps IT Operations

• Incident Alerting: Instantly push P1/P2 critical alerts to operational channels.
• Monitoring Reports: Parse scheduled system status emails.
• ServiceNow Automation: Automatically relay high-priority ticket exports.
• SLA Tracking: Alert teams before ticket breach thresholds occur.

Best Practices

1. Keep CSV schema consistent: Avoid changing export column positions.
2. Validate incoming attachments: Always test file extension and size.
3. Handle empty records: Filter empty lines prior to column splitting.
4. Test special characters: Verify handling of quotes and line breaks.
5. Add error handling: Wrap core steps inside Power Automate Scope blocks.
6. Avoid exposing sensitive data: Only post necessary fields to public Teams channels.