Sending Email Notifications Using PowerShell Scripts

In today's fast-paced digital environment, the ability to automate communication processes has become essential for IT professionals and system administrators. When systems require immediate attention, databases need monitoring, or automated reports must reach stakeholders, email notifications serve as the critical bridge between technical operations and human decision-making. The challenge isn't just about sending emails—it's about creating reliable, maintainable, and secure notification systems that work consistently across different scenarios and organizational requirements.

PowerShell scripting combined with email capabilities represents a powerful solution for automating notification workflows. This approach transforms manual communication tasks into intelligent, event-driven systems that respond to conditions, failures, or scheduled triggers without human intervention. Whether you're monitoring server health, tracking backup completion, or alerting teams about critical system events, PowerShell provides the flexibility and control needed to build robust notification mechanisms.

Throughout this comprehensive guide, you'll discover multiple approaches to implementing email notifications through PowerShell, from basic SMTP configurations to advanced authentication methods including OAuth2. You'll learn how to structure your scripts for maximum reliability, handle credentials securely, troubleshoot common issues, and implement best practices that ensure your notification system remains maintainable and effective over time. This knowledge will empower you to build notification solutions that scale with your organization's needs while maintaining security and operational excellence.

Understanding the Fundamentals of SMTP Communication

The Simple Mail Transfer Protocol forms the backbone of email communication across the internet. When PowerShell sends an email, it acts as an SMTP client, connecting to an SMTP server that handles the actual message delivery. This client-server relationship requires proper configuration of several key parameters: the SMTP server address, port number, authentication credentials, and security settings. Understanding these components helps you diagnose issues and optimize your email notification scripts for different environments.

Traditional SMTP operates on port 25, but modern email services increasingly require encrypted connections using ports 587 (STARTTLS) or 465 (SSL/TLS). The choice of port and encryption method depends on your email provider's requirements and your organization's security policies. Many cloud-based email services have moved away from basic authentication, requiring more sophisticated methods like OAuth2 or application-specific passwords to maintain security while enabling automated access.

Core Components Required for Email Delivery

Before writing your first PowerShell email script, you need to gather specific information about your email infrastructure. The SMTP server hostname or IP address serves as the destination for your email requests. Authentication credentials—typically a username and password or application token—verify your identity to the email server. Additionally, you'll need to determine whether your server requires SSL/TLS encryption and which port to use for connections.

• 📧 SMTP server address (hostname or IP)
• 🔐 Authentication credentials or tokens
• 🚪 Port number (25, 587, or 465)
• 🔒 SSL/TLS encryption requirements
• ✉️ Sender and recipient email addresses

The Send-MailMessage Cmdlet: Traditional Approach

PowerShell's built-in Send-MailMessage cmdlet provides a straightforward method for sending emails. This cmdlet abstracts the complexity of SMTP communication, allowing you to send messages with just a few parameters. While Microsoft has deprecated this cmdlet in favor of more secure alternatives, it remains widely used in existing scripts and continues to function in current PowerShell versions. Understanding its capabilities and limitations helps you decide when it's appropriate for your use case.

"The simplicity of Send-MailMessage made it the go-to solution for years, but its security limitations have pushed the industry toward more robust authentication mechanisms."

The basic syntax requires specifying the sender address, recipient addresses, subject line, message body, and SMTP server details. Optional parameters allow you to add attachments, set priority levels, include CC and BCC recipients, and configure authentication. The cmdlet supports both plain text and HTML-formatted email bodies, giving you flexibility in how you present information to recipients.

Send-MailMessage -From "sender@domain.com" `
                 -To "recipient@domain.com" `
                 -Subject "Notification Subject" `
                 -Body "Message content here" `
                 -SmtpServer "smtp.domain.com" `
                 -Port 587 `
                 -UseSsl `
                 -Credential (Get-Credential)

Implementing Basic Email Notifications

Creating your first notification script involves structuring the email parameters in a way that's both functional and maintainable. Start by defining variables for commonly changed values like recipient addresses and SMTP server details. This approach makes your scripts easier to adapt across different environments without modifying the core logic. Consider creating a configuration section at the beginning of your script where all email-related parameters are centralized.

Secure Credential Management Strategies

Hardcoding passwords directly in scripts represents a significant security vulnerability. Anyone with access to the script file can view the credentials, and if the script is stored in version control systems, those credentials become permanently embedded in the repository history. PowerShell offers several methods for handling credentials more securely, each with different tradeoffs between convenience and security.

The Get-Credential cmdlet prompts for credentials interactively, which works well for manually executed scripts but fails in automated scenarios. For scheduled tasks and unattended scripts, you need alternative approaches. PowerShell's SecureString functionality allows you to encrypt credentials on disk, readable only by the user account that created them on the specific machine where they were encrypted. This provides reasonable security for scheduled tasks running under service accounts.

Creating and Using Encrypted Credential Files

Storing credentials in encrypted files provides a balance between automation and security. The process involves converting a password to a SecureString, then exporting it to a file using PowerShell's built-in encryption. When the script runs, it reads and decrypts the credential file, using the recovered password to authenticate to the SMTP server. This method works effectively for scripts running on dedicated servers under consistent user accounts.

# Creating encrypted credential file (run once)
$credential = Get-Credential
$credential.Password | ConvertFrom-SecureString | Set-Content "C:\Scripts\smtp-password.txt"

# Using encrypted credential in script
$username = "notifications@company.com"
$encryptedPassword = Get-Content "C:\Scripts\smtp-password.txt" | ConvertTo-SecureString
$credential = New-Object System.Management.Automation.PSCredential($username, $encryptedPassword)

"Security isn't about making systems impenetrable—it's about making unauthorized access more difficult than the value of the protected resource."

Advanced Authentication with OAuth2

Modern email services, particularly Microsoft 365 and Gmail, have moved toward OAuth2 authentication for improved security. This authentication method uses tokens instead of passwords, providing better control over access permissions and the ability to revoke access without changing account passwords. Implementing OAuth2 in PowerShell scripts requires more initial setup but provides significantly enhanced security for production environments.

OAuth2 authentication involves registering your application with the email service provider, obtaining client credentials, and implementing a token acquisition workflow. For Microsoft 365, this means creating an app registration in Azure Active Directory with appropriate API permissions. For Gmail, you'll configure OAuth2 credentials in the Google Cloud Console. Once configured, your script requests access tokens that authenticate your email requests without exposing account passwords.

Configuring Azure AD App Registration

Setting up OAuth2 for Microsoft 365 requires creating an Azure AD app registration with specific permissions. Navigate to the Azure Portal, create a new app registration, and grant it the Mail.Send API permission. You'll need to generate a client secret that your script will use to authenticate. The tenant ID, client ID, and client secret form the foundation of your OAuth2 authentication workflow.

• 🔑 Register application in Azure Active Directory
• 🎫 Grant Mail.Send API permissions
• 🔐 Generate client secret with appropriate expiration
• 📋 Record tenant ID, client ID, and client secret
• ✅ Grant admin consent for API permissions

Building HTML-Formatted Email Bodies

Plain text emails serve basic notification needs, but HTML formatting transforms your notifications into professional, visually organized communications. HTML emails support styling, tables, images, and structured layouts that make information easier to scan and understand. PowerShell allows you to construct HTML email bodies using string manipulation, here-strings, or by generating HTML from PowerShell objects.

When creating HTML emails, focus on simplicity and compatibility. Not all email clients render HTML identically, and complex CSS or JavaScript may not work reliably. Use inline styles rather than external stylesheets, stick to table-based layouts for maximum compatibility, and test your HTML across different email clients to ensure consistent rendering. The goal is clear communication, not elaborate design.

$htmlBody = @"
<html>
<head>
    <style>
        body { font-family: Arial, sans-serif; }
        table { border-collapse: collapse; width: 100%; }
        th, td { border: 1px solid #ddd; padding: 8px; text-align: left; }
        th { background-color: #4CAF50; color: white; }
        .warning { color: #ff6600; font-weight: bold; }
    </style>
</head>
<body>
    <h2>System Status Report</h2>
    <p>Generated: $(Get-Date -Format 'yyyy-MM-dd HH:mm:ss')</p>
    <table>
        <tr>
            <th>Server</th>
            <th>Status</th>
            <th>CPU Usage</th>
        </tr>
        <tr>
            <td>SERVER-01</td>
            <td>Online</td>
            <td>45%</td>
        </tr>
    </table>
</body>
</html>
"@

Send-MailMessage -From "reports@company.com" `
                 -To "admin@company.com" `
                 -Subject "Daily Status Report" `
                 -Body $htmlBody `
                 -BodyAsHtml `
                 -SmtpServer "smtp.company.com"

Converting PowerShell Objects to HTML Tables

PowerShell's ConvertTo-Html cmdlet automatically generates HTML tables from objects, making it easy to include structured data in your email notifications. This approach works particularly well for status reports, log summaries, or any scenario where you're presenting tabular information. The cmdlet accepts customization through CSS fragments and pre/post content parameters, allowing you to integrate the generated tables into larger HTML documents.

"The best notification is one that provides exactly the information needed to make a decision, presented in a format that requires minimal interpretation."

Implementing Error Handling and Logging

Production email notification scripts require robust error handling to ensure reliability. Network issues, authentication failures, or SMTP server problems can prevent email delivery, and your script needs to handle these situations gracefully. PowerShell's try-catch-finally blocks provide structured error handling, allowing you to catch exceptions, log errors, and implement fallback mechanisms when email delivery fails.

Comprehensive logging serves multiple purposes: it helps diagnose issues when emails don't arrive, provides an audit trail of notification activities, and helps you identify patterns in failures or performance issues. Consider logging both successful deliveries and failures, including timestamps, recipient addresses, and any error messages. Store logs in a consistent location with appropriate rotation policies to prevent unbounded growth.

$logPath = "C:\Scripts\Logs\email-notifications.log"

function Write-Log {
    param([string]$Message, [string]$Level = "INFO")
    $timestamp = Get-Date -Format "yyyy-MM-dd HH:mm:ss"
    $logEntry = "$timestamp [$Level] $Message"
    Add-Content -Path $logPath -Value $logEntry
}

try {
    Send-MailMessage -From $from -To $to -Subject $subject `
                     -Body $body -SmtpServer $smtpServer `
                     -Port $port -UseSsl -Credential $credential `
                     -ErrorAction Stop
    
    Write-Log "Email sent successfully to $to"
    
} catch {
    Write-Log "Failed to send email: $($_.Exception.Message)" -Level "ERROR"
    
    # Implement fallback notification method
    Write-EventLog -LogName Application -Source "EmailNotification" `
                   -EntryType Error -EventId 1000 `
                   -Message "Email notification failed: $($_.Exception.Message)"
}

Working with Email Attachments

Many notification scenarios require including files as attachments—log files, reports, screenshots, or configuration exports. PowerShell's email capabilities support attachments through the -Attachments parameter, which accepts one or more file paths. When working with attachments, consider file size limitations imposed by email servers, typically ranging from 10MB to 25MB for most providers.

Dynamic attachment handling requires validating file existence and accessibility before attempting to send the email. Your script should check that attachment files exist, verify their sizes are within acceptable limits, and handle scenarios where expected attachments are missing. Consider implementing compression for large files or multiple attachments, reducing email size and improving delivery reliability.

Best Practices for Attachment Management

When implementing attachment functionality, structure your code to handle edge cases gracefully. Test for file existence before referencing paths in the -Attachments parameter. Implement size checks to prevent attempting to send oversized attachments that will be rejected by mail servers. For multiple attachments, consider using array syntax to specify all files in a single parameter value.

Leveraging .NET Classes for Advanced Scenarios

While PowerShell cmdlets provide convenient email functionality, direct access to .NET Framework classes offers greater control and flexibility for complex scenarios. The System.Net.Mail namespace contains classes like MailMessage and SmtpClient that provide low-level email functionality. This approach becomes valuable when you need features not exposed through PowerShell cmdlets or when you're building custom email solutions with specific requirements.

Using .NET classes requires more verbose code but provides access to advanced features like custom headers, alternative views for multipart messages, and fine-grained control over SMTP connection behavior. This approach also remains stable across PowerShell versions, as .NET Framework classes maintain backward compatibility more consistently than PowerShell cmdlets that may be deprecated or modified.

# Creating email using .NET classes
$mailMessage = New-Object System.Net.Mail.MailMessage
$mailMessage.From = "sender@company.com"
$mailMessage.To.Add("recipient@company.com")
$mailMessage.Subject = "Advanced Notification"
$mailMessage.Body = "Message content with full .NET control"
$mailMessage.IsBodyHtml = $true
$mailMessage.Priority = [System.Net.Mail.MailPriority]::High

# Configure SMTP client
$smtpClient = New-Object System.Net.Mail.SmtpClient("smtp.company.com", 587)
$smtpClient.EnableSsl = $true
$smtpClient.Credentials = New-Object System.Net.NetworkCredential($username, $password)

try {
    $smtpClient.Send($mailMessage)
    Write-Host "Email sent successfully"
} finally {
    $mailMessage.Dispose()
    $smtpClient.Dispose()
}

Implementing Multipart Email Messages

Multipart messages contain both plain text and HTML versions of the same content, allowing email clients to display the most appropriate version based on their capabilities. This approach ensures maximum compatibility while providing enhanced formatting for clients that support HTML. The .NET MailMessage class supports multipart messages through the AlternateViews collection, where you can add both text and HTML representations of your message.

"Direct access to .NET classes transforms PowerShell from a scripting language into a full-featured programming environment capable of sophisticated application development."

Configuring Email for Different Providers

Each email service provider has specific requirements for SMTP connectivity, authentication, and security settings. Understanding these provider-specific configurations ensures your notification scripts work reliably across different environments. Microsoft 365, Gmail, SendGrid, and on-premises Exchange servers each have unique requirements that must be addressed in your PowerShell scripts.

Microsoft 365 Configuration

Microsoft 365 requires authenticated SMTP connections over TLS on port 587. You'll need to use the smtp.office365.com server address and authenticate with a valid Microsoft 365 account. If your organization has enabled security defaults or conditional access policies, you may need to use app passwords instead of regular account passwords. For production scenarios, implementing OAuth2 authentication provides better security and avoids password-related authentication issues.

• 🌐 SMTP Server: smtp.office365.com
• 🚪 Port: 587
• 🔒 Encryption: STARTTLS (UseSsl)
• 🔑 Authentication: Required
• ⚠️ Consider OAuth2 for production

Gmail Configuration

Gmail's SMTP server requires SSL/TLS encryption and authentication. Standard Gmail accounts need "Less secure app access" enabled or, preferably, app-specific passwords when two-factor authentication is active. For Google Workspace accounts, administrators can configure SMTP relay services that allow authenticated sending without requiring individual account credentials. Gmail imposes sending limits—typically 500 recipients per day for standard accounts—that your scripts must respect.

Scheduling Automated Email Notifications

The true power of PowerShell email notifications emerges when combined with Windows Task Scheduler or other automation platforms. Scheduled email scripts can send daily reports, monitor systems continuously, or respond to specific events without manual intervention. Proper scheduling configuration ensures your scripts run reliably, with appropriate credentials, and handle failures gracefully.

When creating scheduled tasks for email notifications, configure the task to run under a service account with appropriate permissions. Store credentials securely using the encrypted file method discussed earlier, ensuring the service account can decrypt them. Set appropriate triggers based on your notification requirements—time-based for reports, event-based for alerts, or on-demand for manual execution. Configure the task to log results and send alerts if the task itself fails to run.

# Creating scheduled task for daily report
$action = New-ScheduledTaskAction -Execute "PowerShell.exe" `
    -Argument "-NoProfile -ExecutionPolicy Bypass -File C:\Scripts\DailyReport.ps1"

$trigger = New-ScheduledTaskTrigger -Daily -At 8:00AM

$principal = New-ScheduledTaskPrincipal -UserId "DOMAIN\ServiceAccount" `
    -LogonType Password -RunLevel Highest

$settings = New-ScheduledTaskSettingsSet -AllowStartIfOnBatteries `
    -DontStopIfGoingOnBatteries -StartWhenAvailable

Register-ScheduledTask -TaskName "Daily Email Report" `
    -Action $action -Trigger $trigger -Principal $principal `
    -Settings $settings -Description "Sends daily system status report"

Troubleshooting Common Email Delivery Issues

Email notification scripts can fail for numerous reasons, from network connectivity issues to authentication problems to SMTP server configuration errors. Systematic troubleshooting requires understanding the failure point and having tools to diagnose the issue. PowerShell provides several techniques for debugging email problems, including verbose output, error variable capture, and network connectivity testing.

"Most email delivery failures stem from authentication issues or network connectivity problems, not from errors in the PowerShell code itself."

Diagnostic Techniques and Tools

Start troubleshooting by verifying basic connectivity to your SMTP server using Test-NetConnection. This cmdlet checks whether the server is reachable and whether the specified port is open. Authentication failures often indicate incorrect credentials, expired passwords, or security policies blocking the connection. Enable verbose output in your scripts during testing to see detailed information about the SMTP conversation and identify where failures occur.

# Testing SMTP connectivity
Test-NetConnection -ComputerName smtp.office365.com -Port 587

# Capturing detailed error information
try {
    Send-MailMessage -From $from -To $to -Subject $subject `
                     -Body $body -SmtpServer $smtpServer `
                     -Port $port -UseSsl -Credential $credential `
                     -ErrorAction Stop -ErrorVariable emailError
} catch {
    Write-Host "Error Details: $($_.Exception.Message)"
    Write-Host "SMTP Response: $($_.Exception.InnerException.Response)"
    Write-Host "Full Error: $($_ | Format-List * -Force | Out-String)"
}

Optimizing Performance for Bulk Notifications

Sending notifications to multiple recipients or generating numerous individual emails requires performance optimization to avoid overwhelming SMTP servers or triggering rate limits. Strategies include batching recipients into single emails where appropriate, implementing delays between messages, and using connection pooling for multiple sends. Understanding your email provider's rate limits and implementing appropriate throttling prevents service interruptions.

For truly large-scale email operations, consider using dedicated email service APIs rather than SMTP. Services like SendGrid, Amazon SES, or Mailgun provide REST APIs designed for high-volume sending with better performance, detailed delivery tracking, and sophisticated rate limiting. These services also handle bounce processing, complaint management, and delivery optimization automatically.

Security Considerations and Best Practices

Email notification systems represent potential security vulnerabilities if not properly secured. Credentials stored in scripts, unencrypted SMTP connections, and email content containing sensitive information all pose risks. Implementing security best practices protects both your notification system and the information it transmits. Always use encrypted connections (SSL/TLS), never store passwords in plain text, and consider encrypting sensitive information in email bodies.

Regular security reviews of your email notification scripts should verify that credentials remain valid, encryption settings are current, and access permissions follow the principle of least privilege. Monitor for unauthorized use of notification accounts, implement logging to detect suspicious activity, and establish procedures for rotating credentials periodically. Consider whether email is the appropriate channel for particularly sensitive notifications, or whether alternative secure communication methods should be used.

Essential Security Practices

• 🔐 Use OAuth2 or app passwords instead of account passwords
• 🔒 Always enable SSL/TLS encryption for SMTP connections
• 📝 Implement comprehensive logging for audit trails
• 🔑 Rotate credentials regularly and after personnel changes
• ⚠️ Validate and sanitize any user input included in emails

"Security isn't a feature you add at the end—it's a fundamental design principle that must be incorporated from the beginning."

Integrating with Monitoring and Alerting Systems

Email notifications become most valuable when integrated into comprehensive monitoring and alerting workflows. PowerShell scripts can query system status, evaluate conditions, and send notifications only when specific thresholds are exceeded or events occur. This approach prevents alert fatigue by ensuring recipients receive only relevant, actionable notifications rather than constant status updates.

Effective monitoring integration requires defining clear conditions that trigger notifications, implementing appropriate thresholds to avoid false alarms, and providing sufficient context in notification messages for recipients to take action. Consider implementing escalation logic that sends different notifications based on severity levels, time of day, or persistence of conditions. Your notification system should complement, not replace, dedicated monitoring platforms like Nagios, Zabbix, or Azure Monitor.

# Example monitoring script with conditional notification
$cpuThreshold = 80
$memoryThreshold = 90

$cpu = (Get-Counter '\Processor(_Total)\% Processor Time').CounterSamples.CookedValue
$memory = (Get-Counter '\Memory\% Committed Bytes In Use').CounterSamples.CookedValue

$alerts = @()

if ($cpu -gt $cpuThreshold) {
    $alerts += "CPU usage is $([math]::Round($cpu, 2))% (threshold: $cpuThreshold%)"
}

if ($memory -gt $memoryThreshold) {
    $alerts += "Memory usage is $([math]::Round($memory, 2))% (threshold: $memoryThreshold%)"
}

if ($alerts.Count -gt 0) {
    $subject = "⚠️ Server Alert: Resource Threshold Exceeded"
    $body = "The following conditions require attention:`n`n" + ($alerts -join "`n")
    
    Send-MailMessage -From "monitoring@company.com" `
                     -To "admins@company.com" `
                     -Subject $subject -Body $body `
                     -SmtpServer $smtpServer -UseSsl -Credential $credential
}

Creating Reusable Email Functions and Modules

As your notification requirements grow, encapsulating email functionality in reusable functions or PowerShell modules improves maintainability and consistency. A well-designed email function accepts parameters for all variable elements while handling common tasks like credential management, error handling, and logging internally. This approach allows you to update email logic in one place rather than modifying numerous individual scripts.

PowerShell modules take reusability further by packaging related functions with proper namespacing, documentation, and version management. Creating an email notification module for your organization standardizes how notifications are sent, ensures consistent security practices, and simplifies script development. Module-based approaches also facilitate testing, as you can validate the email functionality independently of the scripts that use it.

function Send-NotificationEmail {
    [CmdletBinding()]
    param(
        [Parameter(Mandatory=$true)]
        [string]$To,
        
        [Parameter(Mandatory=$true)]
        [string]$Subject,
        
        [Parameter(Mandatory=$true)]
        [string]$Body,
        
        [Parameter(Mandatory=$false)]
        [string[]]$Attachments,
        
        [Parameter(Mandatory=$false)]
        [ValidateSet('Normal','High','Low')]
        [string]$Priority = 'Normal',
        
        [Parameter(Mandatory=$false)]
        [switch]$BodyAsHtml
    )
    
    try {
        $params = @{
            From = $script:DefaultFrom
            To = $To
            Subject = $Subject
            Body = $Body
            SmtpServer = $script:SmtpServer
            Port = $script:SmtpPort
            UseSsl = $true
            Credential = $script:SmtpCredential
            ErrorAction = 'Stop'
        }
        
        if ($Attachments) { $params.Attachments = $Attachments }
        if ($BodyAsHtml) { $params.BodyAsHtml = $true }
        if ($Priority -ne 'Normal') { $params.Priority = $Priority }
        
        Send-MailMessage @params
        Write-Verbose "Email sent successfully to $To"
        
    } catch {
        Write-Error "Failed to send email: $($_.Exception.Message)"
        throw
    }
}

Testing Email Functionality

Thorough testing ensures your email notification scripts work reliably before deploying them to production. Testing should cover successful delivery scenarios, error conditions, edge cases like missing attachments or invalid recipient addresses, and performance under load. Implement a testing strategy that includes unit tests for individual functions, integration tests for complete notification workflows, and end-to-end tests that verify actual email delivery.

During development, consider using test email addresses or dedicated testing mailboxes to avoid accidentally sending notifications to production recipients. Implement a testing mode in your scripts that modifies recipient addresses or adds prefixes to subject lines to clearly identify test messages. Document test cases and expected outcomes, and maintain a testing checklist that covers all critical scenarios before promoting scripts to production use.

Frequently Asked Questions

Why does my PowerShell email script work manually but fail when run as a scheduled task?

This typically occurs due to credential issues or execution policy restrictions. Scheduled tasks run under different user contexts than interactive sessions, so credentials stored using SecureString may not be accessible. Ensure your scheduled task runs under the same user account that created the encrypted credential file, or use alternative credential storage methods like Windows Credential Manager. Additionally, verify that the execution policy allows script execution in the scheduled task context by using the -ExecutionPolicy Bypass parameter in your scheduled task configuration.

How can I send emails through Gmail using PowerShell when I have two-factor authentication enabled?

Gmail with two-factor authentication requires using app-specific passwords rather than your regular account password. Navigate to your Google Account security settings, find the "App passwords" section, and generate a new password specifically for your PowerShell script. Use this 16-character app password in your credential object instead of your regular Gmail password. This allows authenticated access while maintaining the security benefits of two-factor authentication on your primary account.

What's the best way to handle email notifications when the SMTP server is temporarily unavailable?

Implement a retry mechanism with exponential backoff in your error handling code. When an email send fails, catch the exception and attempt to resend after a delay, increasing the delay with each retry attempt. After a maximum number of retries, log the failure and consider implementing a fallback notification method such as writing to Windows Event Log or sending a message through an alternative channel. Store failed notification details in a queue file that can be processed later when connectivity is restored.

How do I include dynamic data like server status or log file contents in my email notifications?

Gather the dynamic data using appropriate PowerShell cmdlets before constructing your email body. Use string interpolation or the -f format operator to insert variables into your message text. For structured data like server status tables, use ConvertTo-Html to generate HTML tables from PowerShell objects, then incorporate the resulting HTML into your email body. For log file contents, use Get-Content with appropriate filters to extract relevant information, and consider formatting or truncating the data to keep email size reasonable.

Can I send emails from PowerShell without storing credentials in any form?

Yes, several approaches eliminate stored credentials. For Microsoft 365, implement OAuth2 authentication using certificate-based authentication where the certificate serves as the credential. For internal networks, configure your SMTP server to allow anonymous relay from specific IP addresses or servers, eliminating authentication requirements entirely. Some email services support API keys or tokens that can be stored in environment variables or retrieved from secure vaults like Azure Key Vault at runtime. Windows Integrated Authentication (when supported by your SMTP server) uses the running script's security context without requiring explicit credentials.