Web Driver Auto-update

Feature

Synthetic monitoring environments often rely on browser-based automation frameworks such as Selenium and Microsoft Edge WebDriver. One common operational challenge in these environments is browser auto-updates causing version mismatches between the installed browser and the WebDriver binaries. When this occurs, synthetic monitoring scenarios may suddenly fail, even though the monitored application itself remains healthy.

To address this challenge, we implemented an automated Edge Driver synchronization mechanism using GermainUX automation capabilities.

While the original requirement focused on maintaining synthetic monitoring stability, this implementation also demonstrates a broader concept: GermainUX automation can be leveraged for virtually any infrastructure or operational automation task.

Traditionally, operations teams manually:

Identify the updated browser version
Download the matching driver
Replace the existing WebDriver binary
Restart monitoring services

This manual process introduces:

Monitoring downtime
Operational overhead
Overnight alert noise
Unnecessary incident escalations

Auto-Resolve Driver Mismatch

Using GermainUX automation workflows, we designed a self-healing process that automatically detects and resolves driver mismatches.

The automation workflow performs the following steps:

Detect the installed Microsoft Edge browser version
Detect the installed Edge WebDriver version
Compare browser and driver major versions
Automatically download the matching WebDriver when a mismatch is detected
Replace the existing driver binary
Validate successful synchronization
Continue synthetic execution without manual intervention

Configuration

The automation logic was implemented using a PowerShell script executed through GermainUX automation scheduling capabilities.

In this example, we focus specifically on the Microsoft Edge WebDriver auto-update use case within a Windows Server environment, where synthetic monitoring workloads depend on maintaining strict compatibility between the Edge browser and its corresponding WebDriver version.

1. Navigate to Local Automation Configuration

In the GermainUX console, navigate to: Settings → Automation → Local Programs

From this section, create a new automation configuration. This defines a locally executable automation job associated with the Germain Engine instance running on the target server.

2. Define Automation Metadata

Click Add New Configuration and provide:

A meaningful automation name (e.g., Edge Driver Update)
Enable the option: Execute via Engine

This ensures the script is executed by the locally installed Germain Engine.

3. Attach Automation Script

Click Add New Script and paste the PowerShell automation script responsible for:

Detecting the Edge browser version
Validating the installed WebDriver version
Downloading and replacing mismatched drivers
Performing post-update validation

This script becomes the core remediation logic executed by GermainUX.

Script:

CODE

# ==========================================
# Edge Driver Auto Update Script
# Updates ONLY when major versions mismatch
# ==========================================

# ---------- CONFIG ----------

$driverFolder = "C:\Work\scripts\edgeDriver"
$driverExe = "$driverFolder\msedgedriver.exe"
$tempZip = "$env:TEMP\edgedriver.zip"

# Edge possible install locations
$edgePaths = @(
    "C:\Program Files (x86)\Microsoft\Edge\Application\msedge.exe",
    "C:\Program Files\Microsoft\Edge\Application\msedge.exe"
)

# ---------- FIND EDGE ----------

$edgeExe = $null

foreach ($path in $edgePaths) {

    if (Test-Path $path) {

        $edgeExe = $path
        break
    }
}

if (-not $edgeExe) {

    Write-Host "ERROR: Microsoft Edge browser not found."
    exit 1
}

# ---------- GET BROWSER VERSION ----------

$browserVersion = ((Get-Item $edgeExe).VersionInfo.ProductVersion).Trim()

Write-Host ""
Write-Host "Installed Edge Browser Version: $browserVersion"

# Compare only major version
$browserMajor = $browserVersion.Split(".")[0]

# ---------- GET DRIVER VERSION ----------

$driverVersion = ""
$driverMajor = ""

if (Test-Path $driverExe) {

    try {

        $driverOutput = & $driverExe --version

        # Extract version using regex
        $driverVersion = [regex]::Match(
            $driverOutput,
            '\d+\.\d+\.\d+\.\d+'
        ).Value

        $driverMajor = $driverVersion.Split(".")[0]

        Write-Host "Installed Edge Driver Version : $driverVersion"
    }
    catch {

        Write-Host "Unable to determine current driver version."
    }
}
else {

    Write-Host "Edge Driver not found."
}

Write-Host ""

# ---------- COMPARE ----------

if ($browserMajor -eq $driverMajor) {

    Write-Host "SUCCESS: Major versions already match."
    Write-Host "No update required."

    exit 0
}

Write-Host "Version mismatch detected."
Write-Host "Updating Edge Driver..."
Write-Host ""

# ---------- PREPARE ----------

New-Item -ItemType Directory -Force -Path $driverFolder | Out-Null

# Stop running Edge driver processes
Get-Process msedgedriver -ErrorAction SilentlyContinue | Stop-Process -Force

# Remove old zip if exists
if (Test-Path $tempZip) {

    Remove-Item $tempZip -Force
}

# ---------- DOWNLOAD DRIVER ----------

$downloadUrl = "https://msedgedriver.microsoft.com/$browserVersion/edgedriver_win64.zip"

Write-Host "Downloading:"
Write-Host $downloadUrl
Write-Host ""

try {

    Invoke-WebRequest -Uri $downloadUrl -OutFile $tempZip

}
catch {

    Write-Host "ERROR: Failed to download Edge Driver."
    Write-Host $_.Exception.Message

    exit 1
}

# ---------- EXTRACT ----------

try {

    Expand-Archive -Path $tempZip -DestinationPath $driverFolder -Force

}
catch {

    Write-Host "ERROR: Failed to extract Edge Driver."
    Write-Host $_.Exception.Message

    exit 1
}

# ---------- CLEANUP ----------

if (Test-Path $tempZip) {

    Remove-Item $tempZip -Force
}

# ---------- VERIFY ----------

Write-Host ""
Write-Host "Verifying installation..."
Write-Host ""

if (Test-Path $driverExe) {

    $newDriverOutput = & $driverExe --version

    # Extract version using regex
    $newDriverVersion = [regex]::Match(
        $newDriverOutput,
        '\d+\.\d+\.\d+\.\d+'
    ).Value

    Write-Host "New Driver Version: $newDriverVersion"

    $newDriverMajor = $newDriverVersion.Split(".")[0]

    if ($newDriverMajor -eq $browserMajor) {

        Write-Host ""
        Write-Host "SUCCESS: Edge Driver updated successfully."

        exit 0
    }
    else {

        Write-Host ""
        Write-Host "WARNING: Driver version still does not match browser."

        exit 1
    }
}
else {

    Write-Host "ERROR: msedgedriver.exe not found after extraction."

    exit 1
}

4. Configure Execution Schedule

Define the scheduling strategy based on operational requirements:

Run interval (e.g., every 6 hours or daily)
Execution window aligned with synthetic monitoring cycles

This ensures the environment remains continuously self-healing and synchronized, even after browser updates.

5. Configure SLA Trigger (Optional)

To further enhance proactive remediation, the automation can be linked to SLA conditions.

Configure:

SLA threshold definitions (e.g., synthetic transaction failure rate, execution failures, or driver mismatch detection alerts)
Trigger automation execution upon SLA violations

This enables event-driven remediation, where the automation is invoked only when monitoring degradation is detected.

Result

Once configured, the Germain Engine automatically executes the Edge Driver synchronization workflow either on a schedule or in response to SLA conditions.

This eliminates manual intervention and ensures continuous alignment between browser and driver versions, helping maintain the stability and reliability of synthetic monitoring scenarios.

This configuration pattern is not limited to browser driver management. The same approach can be extended to virtually any operational automation use case supported by GermainUX, including:

Infrastructure maintenance
Service recovery
Environment consistency enforcement
Automated remediation workflows

Component: Engine

Feature Availability: 2026.1 or later