Automation
123
Total Pages
24
Linux-Friendly Pages
99
Pages with Bias
80.5%
Bias Rate
Bias Trend Over Time
Pages with Bias Issues
982 issues found
Showing 451-475 of 982 flagged pages
Automation
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/automation/automation-runbook-types.md
...b/main/articles/automation/automation-runbook-types.md
High Priority
View Details →
Detected Bias Types
Windows First
Powershell Heavy
Windows Tools
Missing Linux Example
Summary
The documentation demonstrates a Windows and PowerShell-centric bias. PowerShell (a traditionally Windows-first technology) is presented as the primary and recommended runbook type, with extensive detail and examples focused on Windows paths, tools, and cmdlets. Many examples and known issues reference Windows-specific file paths (e.g., C:\modules), environment variables, and behaviors. Linux-specific guidance is minimal or absent, and there are no Linux shell (bash) examples. Even in sections mentioning Linux support (e.g., Hybrid Runbook Workers), practical Linux usage patterns, troubleshooting, or examples are missing.
Recommendations
- Provide Linux-specific examples for runbook authoring and troubleshooting, such as using Linux file paths and shell commands where appropriate.
- Clarify and expand on Linux Hybrid Runbook Worker support, including any limitations, best practices, and differences from Windows workers.
- Include parity in examples: for every PowerShell/Windows example, provide an equivalent for Linux environments (e.g., bash or Python scripts interacting with Azure).
- Avoid referencing only Windows paths (like C:\modules); include Linux equivalents (e.g., /opt/automation/modules) where relevant.
- Document any Linux-specific issues, workarounds, or environment variables for Python and PowerShell runbooks on Linux Hybrid Workers.
- Reorder sections or tables to avoid always listing Windows/PowerShell first, or explicitly state that ordering does not imply preference.
- Highlight cross-platform capabilities and provide guidance for users working in non-Windows environments.
Create Pull Request
Automation
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/automation/manage-runtime-environment.md
...main/articles/automation/manage-runtime-environment.md
High Priority
View Details →
Detected Bias Types
Powershell Heavy
Windows Tools
Windows First
Missing Linux Example
Summary
The documentation page demonstrates a strong bias toward Windows and PowerShell environments. PowerShell is consistently presented as the primary or default scripting language, with detailed instructions and examples focused on PowerShell modules, cmdlets, and package management. References to Windows-specific patterns (e.g., .zip for PowerShell modules, PowerShell Gallery) are prevalent, while Linux/Python guidance is minimal, often limited to brief notes or parenthetical mentions. There are no concrete Linux shell or Python package management examples, and REST API samples are PowerShell-centric. This results in insufficient guidance for users working in Linux or Python environments.
Recommendations
- Provide equal, step-by-step examples for both PowerShell and Python runbooks, including screenshots and REST API payloads for each.
- Include Linux-specific instructions and examples, such as using .whl files for Python, and demonstrate how to upload and manage Python packages in detail.
- Reference Linux tools and package sources (e.g., PyPI) alongside PowerShell Gallery, and clarify differences in package formats and management workflows.
- When mentioning PowerShell modules or cmdlets, offer equivalent Python code snippets or commands where possible.
- Avoid presenting PowerShell/Windows options first by interleaving or parallelizing instructions for both environments.
- Add troubleshooting and best practices sections for Python/Linux runbooks, not just PowerShell.
- Explicitly state OS/runtime compatibility and limitations for both PowerShell and Python environments.
Automation
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/automation/troubleshoot/extension-based-hybrid-runbook-worker.md
.../troubleshoot/extension-based-hybrid-runbook-worker.md
High Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Powershell Heavy
Windows Registry Focus
Summary
The documentation generally provides parity between Windows and Linux for most troubleshooting steps, but there is a noticeable Windows-first bias in the ordering and depth of examples. Windows tools, paths, and PowerShell scripts are often mentioned first or in greater detail, and several scenarios (such as registry key manipulation and event log checks) are Windows-specific or lack Linux equivalents. Some troubleshooting steps and error investigations are described only for Windows, especially those involving PowerShell, registry, and event logs.
Recommendations
- Alternate the order of Windows and Linux instructions throughout the document, or group them together under clear subheadings to avoid a Windows-first impression.
- Where PowerShell or Windows registry steps are provided, ensure equivalent Linux commands or configuration file edits are described, or explicitly state if not applicable.
- For event log troubleshooting, provide Linux equivalents (such as journalctl, syslog, or custom log file locations) where possible.
- Add more Linux-specific troubleshooting scenarios, especially for authentication, permissions, and service management, to match the depth of Windows coverage.
- Where Windows-specific tools or logs are referenced (e.g., Microsoft-SMA event logs), clarify what Linux users should check instead.
- Ensure that all code snippets and examples are balanced in number and detail for both platforms.
Automation
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/automation/automation-hrw-run-runbooks.md
...ain/articles/automation/automation-hrw-run-runbooks.md
High Priority
View Details →
Detected Bias Types
Windows First
Powershell Heavy
Windows Tools
Missing Linux Example
Summary
The documentation demonstrates a Windows-first bias in several ways: Windows instructions, examples, and tools (such as PowerShell and Windows environment variable configuration) are consistently presented before their Linux equivalents. PowerShell-based examples dominate, and Windows-specific tools and paths are referenced in detail, while Linux instructions are often less detailed or presented after Windows. Some sections (e.g., credential asset permissions, runbook authentication examples) lack Linux-specific examples or omit equivalent Linux details.
Recommendations
- Alternate the order of Windows and Linux sections/examples, or present them in parallel tabs to give equal prominence.
- Provide Linux-specific code examples wherever PowerShell/Windows examples are given (e.g., use Bash or Python for Linux runbooks).
- Include detailed Linux instructions for tasks like environment variable setup, credential asset permissions, and runbook authentication, matching the depth of Windows guidance.
- Where Windows tools or paths are referenced (e.g., C:\ paths, Control Panel), provide the Linux equivalents (e.g., /etc/environment, relevant Linux commands).
- Add Linux troubleshooting tips and references alongside Windows event log and path information.
- Where PowerShell is the only example, consider including a Python or Bash example for Linux users.
Automation
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/automation/automation-runbook-types.md
...b/main/articles/automation/automation-runbook-types.md
High Priority
View Details →
Detected Bias Types
Windows First
Powershell Heavy
Windows Tools
Missing Linux Example
Summary
The documentation exhibits a strong Windows and PowerShell bias. PowerShell (a Windows-centric technology) is presented first and in greatest detail, with multiple sections and examples, while Linux-specific considerations are minimal or absent. Many examples and known issues reference Windows file paths (e.g., C:\modules), Windows environment variables, and Windows-specific behaviors. There is little to no guidance or examples for Linux users, especially regarding file paths, environment variables, or troubleshooting on Linux Hybrid Runbook Workers. The documentation also refers to Windows tools and patterns (such as PowerShell Workflow and graphical runbooks) that are not available or supported on Linux, often without clearly highlighting equivalent Linux workflows or limitations up front.
Recommendations
- Add Linux-specific examples and troubleshooting steps, especially for Hybrid Runbook Workers running on Linux.
- When referencing file paths, provide both Windows and Linux equivalents (e.g., C:\modules and /usr/src/PSModules).
- Clearly indicate in tables and introductory sections which runbook types and features are supported on Linux, and highlight Linux limitations or alternatives.
- Provide parity in code samples: for every PowerShell example, include a Python example that demonstrates similar automation tasks, especially for cross-platform scenarios.
- Avoid assuming Windows as the default environment; explicitly mention when instructions or limitations apply only to Windows.
- Include a dedicated section summarizing Linux support, best practices, and known issues for Linux Hybrid Runbook Workers.
- Where graphical or workflow features are Windows-only, suggest alternative approaches for Linux users.
Automation
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/automation/delete-account.md
...e-docs/blob/main/articles/automation/delete-account.md
High Priority
View Details →
Detected Bias Types
Powershell Heavy
Missing Linux Example
Windows Tools
Windows First
Summary
The documentation page demonstrates a Windows bias by providing only Azure PowerShell command-line examples, with no equivalent examples for Azure CLI (which is cross-platform and more commonly used on Linux/macOS). The only scripting examples are in PowerShell, and there are no bash or shell script examples. Portal instructions are platform-agnostic, but the command-line automation focus is exclusively on Windows-centric tools. Azure CLI is mentioned in the introduction but not actually used in any example. This may hinder Linux users or those preferring cross-platform tooling.
Recommendations
- Add equivalent Azure CLI (az) command examples for all PowerShell commands, especially for deleting Automation accounts and removing Log Analytics solutions.
- Where scripting is shown (e.g., for automation or batch operations), provide both PowerShell and bash/shell script examples.
- When listing command-line options, present Azure CLI examples before or alongside PowerShell to emphasize cross-platform support.
- Explicitly mention that all actions can be performed from Linux/macOS using Azure CLI, and provide links to relevant CLI documentation.
- Review all sections for references to Windows-only tools or patterns, and ensure Linux parity in instructions and screenshots where applicable.
Automation
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/automation/manage-runtime-environment.md
...main/articles/automation/manage-runtime-environment.md
High Priority
View Details →
Detected Bias Types
Powershell Heavy
Windows Tools
Windows First
Missing Linux Example
Summary
The documentation demonstrates a strong bias toward Windows and PowerShell. Most examples, screenshots, and REST API payloads focus on PowerShell runbooks and the Az PowerShell module. Windows/PowerShell tools and patterns (e.g., PowerShell Gallery, .zip modules, Get-Module cmdlet) are mentioned and illustrated in detail, while Linux/Python equivalents are either briefly mentioned or omitted. There is little to no parity in examples or guidance for Python (Linux) runbooks, and Linux-specific package management is only referenced in passing.
Recommendations
- Provide equal, step-by-step examples for Python (Linux) runbooks, including screenshots and REST API payloads.
- Include explicit instructions and examples for uploading and managing Python packages (e.g., .whl files), similar to the PowerShell/Az module guidance.
- Mention and illustrate Linux/Python tools and patterns (e.g., pip, PyPI) where relevant, not just PowerShell Gallery.
- Add sample code and output for viewing installed Python packages in a runbook, analogous to the Get-Module example for PowerShell.
- Ensure that all notes and guidance referencing PowerShell (e.g., .zip files, Az module) have clear Linux/Python equivalents or caveats.
- Balance screenshots and UI walkthroughs to show both PowerShell and Python runbook creation and management.
Automation
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/automation/troubleshoot/extension-based-hybrid-runbook-worker.md
.../troubleshoot/extension-based-hybrid-runbook-worker.md
High Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Powershell Heavy
Windows Centric Scenarios
Summary
The documentation generally provides parity between Windows and Linux for most troubleshooting steps, with separate sections and commands for each OS. However, there is a noticeable Windows-first bias: Windows examples and paths are consistently listed before Linux equivalents, and some troubleshooting scenarios (especially those involving registry, event logs, and PowerShell scripts) are Windows-specific or more detailed for Windows. Several scenarios and resolutions focus exclusively on Windows tools (e.g., PowerShell scripts, registry edits, event logs), while Linux equivalents are either less detailed or absent. Some advanced troubleshooting and error scenarios are only described for Windows environments.
Recommendations
- Alternate the order of Windows and Linux instructions or group them together to avoid always listing Windows first.
- Ensure that all troubleshooting scenarios and resolutions provided for Windows have Linux equivalents, or explicitly state when a scenario is Windows-only.
- Expand Linux troubleshooting sections to match the level of detail given for Windows, including log locations, commands, and common issues.
- Where PowerShell scripts or Windows event logs are referenced, provide equivalent Bash scripts or Linux log file locations and commands.
- Add more Linux-centric troubleshooting scenarios, especially for issues that may be unique to Linux environments.
- Clearly indicate in each scenario which OSes are affected, and avoid assuming Windows as the default context.
Automation
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/automation/troubleshoot/extension-based-hybrid-runbook-worker.md
.../troubleshoot/extension-based-hybrid-runbook-worker.md
High Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Powershell Heavy
Windows Registry Focus
Summary
The documentation provides both Windows and Linux troubleshooting steps for Azure Automation Hybrid Runbook Workers, but there is a noticeable Windows bias. Windows examples, tools, and troubleshooting steps are often listed first, and some scenarios (e.g., registry and event log troubleshooting, PowerShell scripts) are Windows-specific or more detailed for Windows. There is heavy reliance on Windows tools (PowerShell, registry edits, event logs), and some troubleshooting guidance is more comprehensive for Windows than for Linux.
Recommendations
- Alternate the order of Windows and Linux instructions to avoid always listing Windows first.
- Ensure Linux troubleshooting steps are as detailed and comprehensive as Windows steps, including equivalent commands and log locations.
- Where PowerShell or Windows registry steps are given, provide equivalent Linux shell commands or configuration file edits.
- For event log troubleshooting, suggest Linux equivalents (e.g., journalctl, syslog) and provide example commands.
- Add more Linux-specific troubleshooting scenarios, especially for authentication, permissions, and service management.
- Where possible, use cross-platform scripting or tooling, or clearly indicate when a step is platform-specific.
- Review all scenarios to ensure Linux users have parity in actionable guidance and examples.
Automation
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/automation/automation-hrw-run-runbooks.md
...ain/articles/automation/automation-hrw-run-runbooks.md
High Priority
View Details →
Detected Bias Types
Windows First
Powershell Heavy
Windows Tools
Missing Linux Example
Summary
The documentation demonstrates a moderate Windows bias. Windows-specific instructions, tools, and examples (such as PowerShell cmdlets, environment variable setup, and certificate management) are often presented first or in greater detail. PowerShell is the primary scripting language shown, with Linux/Python alternatives included but less emphasized. Some sections (e.g., credential asset usage, runbook authentication, and starting runbooks via PowerShell) lack Linux-specific examples or focus on Windows paths and tools. Windows UI patterns (like Control Panel navigation) are described in detail, while Linux equivalents are more terse. There are also more detailed code samples and troubleshooting steps for Windows than for Linux.
Recommendations
- Ensure Linux instructions are presented with equal prominence and detail as Windows instructions, including step-by-step guides and code samples.
- Provide Linux-specific examples for credential asset usage, runbook authentication, and starting runbooks (e.g., using Bash or Python instead of only PowerShell).
- Include Linux-native tools and patterns (such as systemd, cron, or Linux file paths) where appropriate, not just Windows tools like Control Panel or Windows event logs.
- When showing PowerShell cmdlets, also provide equivalent Bash or Python scripts for Linux users where possible.
- Avoid always listing Windows instructions first; alternate the order or present both platforms side by side.
- Expand troubleshooting and logging sections to include more detailed Linux guidance, not just Windows event logs and paths.
- Clarify any features that are Windows-only or Linux-only up front, and provide parity where possible.
Automation
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/automation/automation-runbook-types.md
...b/main/articles/automation/automation-runbook-types.md
High Priority
View Details →
Detected Bias Types
Windows First
Powershell Heavy
Windows Tools
Missing Linux Example
Summary
The documentation exhibits a Windows bias by prioritizing PowerShell (a Windows-centric technology) in both structure and detail, providing only PowerShell-based code examples, referencing Windows file paths and environment variables, and focusing on Windows-specific tools and workflows. Linux-specific guidance, examples, or parity in explanations are largely absent, especially for PowerShell and graphical runbooks. Python runbook Linux details are minimal and lack practical examples.
Recommendations
- Provide Linux-specific examples and guidance for PowerShell runbooks, especially for scenarios where Linux Hybrid Runbook Workers are supported.
- Include Linux file path examples and environment variable usage alongside Windows equivalents.
- Clarify which features and limitations apply to Linux Hybrid Runbook Workers versus Windows, and highlight any differences.
- Add practical Python runbook examples that demonstrate both Windows and Linux Hybrid Worker usage.
- For graphical runbooks, explicitly state Linux limitations and, where possible, suggest alternatives or workarounds for Linux environments.
- Balance the order of presentation so that Linux and cross-platform scenarios are not always secondary to Windows.
- Where Windows tools or cmdlets are referenced (e.g., C:\modules, .ps1 scripts), provide Linux equivalents or note their absence.
Automation
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/automation/delete-account.md
...e-docs/blob/main/articles/automation/delete-account.md
High Priority
View Details →
Detected Bias Types
Powershell Heavy
Missing Linux Example
Windows Tools
Windows First
Summary
The documentation page demonstrates a Windows bias by providing command-line examples exclusively in Azure PowerShell, with no equivalent Azure CLI (cross-platform) or Bash examples. The PowerShell examples are presented as the only scripting/automation option, and there is no mention of Linux-native tooling or shell environments. Additionally, the structure presents PowerShell before any mention of CLI, and in some cases, CLI is omitted entirely. This may disadvantage users on Linux or macOS who prefer or require cross-platform tools.
Recommendations
- Add Azure CLI examples alongside all PowerShell examples, using Bash syntax where appropriate.
- Explicitly mention that both PowerShell and Azure CLI are supported, and provide parity in instructions.
- Where automation scripts are shown, offer both PowerShell and Bash/CLI script versions.
- Consider including a table or tabbed interface for each command-line example, allowing users to select PowerShell, Azure CLI, or REST API.
- Review the order of presentation so that cross-platform tools (Azure CLI) are not always secondary to Windows-centric tools (PowerShell).
Automation
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/automation/manage-runtime-environment.md
...main/articles/automation/manage-runtime-environment.md
High Priority
View Details →
Detected Bias Types
Powershell Heavy
Windows Tools
Windows First
Missing Linux Example
Summary
The documentation demonstrates a strong bias towards Windows and PowerShell. PowerShell is consistently presented as the primary or default scripting language, with detailed examples and references to Windows-specific tools (e.g., PowerShell Gallery, Az PowerShell module, .zip packaging for modules). Linux/Python support is mentioned but lacks equivalent depth, examples, or tooling guidance. REST API examples overwhelmingly use PowerShell as the runbook type, and there are no concrete Linux shell or Python-centric examples. Windows packaging conventions are referenced before Linux ones, and the documentation assumes familiarity with Windows/PowerShell patterns.
Recommendations
- Provide parallel, detailed examples for Python runbooks, including REST API payloads and portal workflows.
- Include Linux-oriented packaging guidance (e.g., .whl, .tar.gz) and reference Python package repositories (e.g., PyPI) alongside PowerShell Gallery.
- When mentioning PowerShell or Windows-specific tools, immediately follow with Linux/Python equivalents (e.g., show how to list installed Python packages in a runbook).
- Add explicit Linux/Python runbook creation, update, and test examples, both in the portal and via REST API.
- Balance screenshots and walkthroughs to include both PowerShell and Python scenarios.
- Avoid assuming PowerShell as the default; clarify that both PowerShell and Python are first-class options, and structure documentation to treat them equally.
Automation
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/automation/manage-runtime-environment.md
...main/articles/automation/manage-runtime-environment.md
High Priority
View Details →
Detected Bias Types
Powershell Heavy
Windows Tools
Windows First
Missing Linux Example
Summary
The documentation page demonstrates a strong bias toward Windows and PowerShell environments. PowerShell is consistently presented as the primary or default scripting language, with detailed examples and references to PowerShell modules, cmdlets, and packaging formats. Windows-centric tools and patterns (such as PowerShell Gallery, .zip modules, and Get-Module cmdlet) are emphasized, while Linux/Python equivalents are only briefly mentioned or lack practical examples. REST API examples and screenshots also focus on PowerShell scenarios, and there is little to no guidance for Linux-native workflows or tools.
Recommendations
- Provide parallel, detailed examples for Python runbooks, including REST API payloads, portal workflows, and package management steps.
- Include Linux-native packaging and module management guidance (e.g., using .whl, pip, or requirements.txt for Python) with concrete examples.
- Highlight the use of Azure CLI and bash scripting in automation scenarios, not just as a note but with step-by-step instructions.
- Balance screenshots and walkthroughs to show both PowerShell and Python/Linux scenarios.
- Reference Linux documentation and best practices where relevant, such as running Python runbooks on Linux-based runtime environments.
- Avoid presenting PowerShell/Windows tools and patterns first or exclusively; ensure equal prominence for Linux/Python approaches.
Automation
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/automation/troubleshoot/extension-based-hybrid-runbook-worker.md
.../troubleshoot/extension-based-hybrid-runbook-worker.md
High Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Powershell Heavy
Windows Registry Focus
Missing Linux Example
Summary
The documentation generally provides parity between Windows and Linux for most troubleshooting steps, but there are several signs of Windows bias. Windows examples, tools, and troubleshooting steps are often presented first, and some scenarios (such as registry key removal, event log checks, and PowerShell-based troubleshooting) are described only for Windows, with no Linux equivalents or alternatives. There is a heavier focus on Windows-specific tools (PowerShell scripts, registry edits, event logs), and Linux troubleshooting is sometimes less detailed or omitted.
Recommendations
- Alternate the order of Windows and Linux instructions or present them in parallel to avoid always listing Windows first.
- Where Windows-specific tools (e.g., PowerShell scripts, registry edits, event log checks) are mentioned, provide equivalent Linux commands or log locations (e.g., journalctl for service logs, Linux equivalents for registry or configuration changes).
- For scenarios that only provide Windows steps (such as registry key removal or event log troubleshooting), add Linux-specific troubleshooting steps or clarify if not applicable.
- Ensure Linux troubleshooting steps are as detailed as Windows steps, including command-line examples for common issues (e.g., checking service status, log collection, authentication issues).
- Where PowerShell scripts are referenced for Windows, provide bash or Python script equivalents for Linux where possible.
- Explicitly mention if a scenario or step is Windows-only, and provide rationale or alternatives for Linux users.
Automation
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/automation/automation-hrw-run-runbooks.md
...ain/articles/automation/automation-hrw-run-runbooks.md
High Priority
View Details →
Detected Bias Types
Windows First
Powershell Heavy
Windows Tools
Missing Linux Example
Summary
The documentation exhibits a moderate Windows bias. Windows-specific instructions, tools, and examples (especially PowerShell) are often presented first or exclusively, with Linux equivalents sometimes appearing later or in less detail. Many code samples, especially for authentication and runbook management, use PowerShell and Windows-centric paths or commands. Some advanced features, such as Hybrid Worker Credentials and certain credential management, are only described for Windows, with Linux support explicitly marked as unavailable or not covered. In several sections, Linux instructions are present but less detailed or lack parity with Windows examples.
Recommendations
- Provide Linux examples alongside Windows examples in all sections, especially for authentication, credential management, and starting runbooks.
- When presenting instructions or code samples, alternate the order (sometimes Linux first) or present both platforms in parallel tabs or sections.
- Expand Linux-specific guidance for features currently described only for Windows (e.g., Hybrid Worker Credentials), or clearly state if/why a feature is not available on Linux.
- Include Bash or Python script examples for Linux where only PowerShell is shown for Windows.
- Ensure that all references to tools, environment variables, and file paths include both Windows and Linux equivalents.
- Where a feature is not supported on Linux, provide context and possible workarounds or alternatives.
Automation
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/automation/automation-runbook-types.md
...b/main/articles/automation/automation-runbook-types.md
High Priority
View Details →
Detected Bias Types
Windows First
Powershell Heavy
Windows Tools
Missing Linux Example
Summary
The documentation exhibits a Windows bias by prioritizing PowerShell (a Windows-centric tool) in both structure and content, providing only PowerShell code samples, and referencing Windows file paths and environment variables. Linux-specific considerations are mentioned only in passing, and there are no Linux shell (e.g., Bash) examples or detailed Linux workflow guidance. Several features and limitations are described only in the context of Windows or PowerShell, with Linux support or differences often omitted or minimized.
Recommendations
- Provide equivalent Linux/Bash examples for common automation scenarios, especially where PowerShell is used.
- Explicitly document differences in behavior, limitations, and setup for Linux Hybrid Runbook Workers, including file paths, environment variables, and module/package management.
- Avoid using Windows file paths (e.g., C:\modules) in examples without also providing Linux equivalents (e.g., /opt/modules or /home/automation/modules).
- Clarify which features are supported or unsupported on Linux Hybrid Runbook Workers, and provide workarounds or alternatives where possible.
- Balance the order of presentation so that Python and Linux scenarios are not always secondary to PowerShell/Windows.
- Include troubleshooting and known issues sections specific to Linux environments.
- Where PowerShell is recommended, clarify that PowerShell Core (7.x) is cross-platform, and provide Linux-specific notes or examples for PowerShell usage on Linux.
Automation
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/automation/delete-account.md
...e-docs/blob/main/articles/automation/delete-account.md
High Priority
View Details →
Detected Bias Types
Powershell Heavy
Missing Linux Example
Windows Tools
Windows First
Summary
The documentation page demonstrates a Windows bias by providing command-line examples exclusively in Azure PowerShell, with no equivalent Azure CLI (cross-platform) or Bash examples. The only non-portal automation method shown is PowerShell, which is primarily associated with Windows environments. There is no mention of Linux-native tools or scripting approaches, and the ordering of examples always places PowerShell before any mention of CLI (which is only referenced in the intro, not in examples).
Recommendations
- Provide Azure CLI (az) command examples alongside PowerShell for all automation and deletion tasks, as Azure CLI is cross-platform and widely used on Linux and macOS.
- Include Bash script examples where appropriate, especially for tasks that could be automated outside of Windows environments.
- When listing automation options, present Azure CLI and PowerShell together, or alternate their order, to avoid implying PowerShell is the primary or preferred method.
- Explicitly mention that all operations can be performed from Linux, macOS, or Windows, and provide links to relevant cross-platform tooling documentation.
- Consider including REST API curl examples for advanced users who may prefer direct API calls from any platform.
Automation
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/automation/troubleshoot/extension-based-hybrid-runbook-worker.md
.../troubleshoot/extension-based-hybrid-runbook-worker.md
High Priority
View Details →
Detected Bias Types
Windows First
Powershell Heavy
Windows Tools
Summary
The documentation generally provides parity between Windows and Linux for most troubleshooting steps, including file paths, log locations, and extension management. However, there is a noticeable Windows-first bias: Windows examples, tools, and troubleshooting steps are often presented before their Linux equivalents, and some scenarios (such as registry and event log troubleshooting) are Windows-specific or more detailed for Windows. PowerShell is heavily used for Windows instructions, while Linux instructions are less detailed or use generic bash commands. Some troubleshooting scenarios are only described for Windows, with no Linux equivalent or guidance.
Recommendations
- Alternate the order of Windows and Linux instructions or present them in parallel to avoid always listing Windows first.
- Ensure all troubleshooting scenarios that are Windows-specific have equivalent Linux guidance or explicitly state if not applicable.
- Provide Linux-specific troubleshooting steps for authentication, permissions, and log/event analysis (e.g., using journalctl, syslog, or Linux equivalents of Windows Event Viewer).
- Where PowerShell scripts are provided for Windows, consider providing bash or Python scripts for Linux where possible.
- Expand Linux troubleshooting sections to match the level of detail provided for Windows, especially for advanced issues (e.g., stuck jobs, authentication failures, certificate management).
- Where registry or Windows event log steps are given, offer analogous Linux file or configuration locations, or clarify if not relevant.
Automation
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/automation/delete-account.md
...e-docs/blob/main/articles/automation/delete-account.md
High Priority
View Details →
Detected Bias Types
Powershell Heavy
Missing Linux Example
Windows Tools
Windows First
Summary
The documentation page demonstrates a Windows bias by providing only Azure PowerShell command-line examples and omitting equivalent Azure CLI (cross-platform) or Bash examples. The PowerShell approach is presented as the sole scripting/command-line method, and no Linux-native or cross-platform shell instructions are given. The structure and order of examples also prioritize Windows-centric tools and workflows.
Recommendations
- Add Azure CLI examples (az automation account delete, etc.) alongside PowerShell for all command-line operations.
- Include Bash shell snippets where appropriate to demonstrate cross-platform usage.
- Present Azure CLI examples before or alongside PowerShell to avoid a 'Windows-first' impression.
- Explicitly mention that PowerShell examples are platform-agnostic only if they are tested on Linux/macOS, or clarify any platform-specific limitations.
- Where possible, provide REST API examples using curl or similar cross-platform tools.
- Review screenshots and UI instructions to ensure they are not overly Windows-specific if accessed via browser.
Automation
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/automation/automation-runbook-types.md
...b/main/articles/automation/automation-runbook-types.md
High Priority
View Details →
Detected Bias Types
Windows First
Powershell Heavy
Windows Tools
Missing Linux Example
Summary
The documentation exhibits a strong Windows and PowerShell bias. PowerShell (and specifically Windows PowerShell) is presented as the primary and recommended runbook type, with extensive detail and examples provided only for PowerShell. Windows-specific paths (e.g., C:\modules), environment variables, and tools are referenced throughout, while Linux equivalents are rarely mentioned or are only briefly addressed. There are no Linux-specific code examples, and Linux support is often described in terms of limitations or as an afterthought. Python runbooks receive less coverage and lack parity in example depth compared to PowerShell. Hybrid Runbook Worker support for Linux is mentioned but not illustrated with practical examples.
Recommendations
- Provide Linux-specific examples for both PowerShell (PowerShell Core) and Python runbooks, including file paths, environment variables, and troubleshooting steps relevant to Linux environments.
- Avoid referencing Windows paths (e.g., C:\modules, C:\usr\src\PSModules) exclusively; include Linux path examples (e.g., /usr/src/PSModules) wherever file system access is discussed.
- Balance the depth of examples and troubleshooting between PowerShell and Python runbooks, ensuring Python users (especially on Linux) have equivalent guidance.
- When discussing environment variables or configuration (such as PYTHON_2_PATH), include Linux shell equivalents and usage patterns.
- Explicitly call out Linux support and limitations in each runbook type section, and provide clear guidance for Linux Hybrid Runbook Worker scenarios.
- Where Windows-only features or limitations exist, clearly label them as such and, where possible, suggest Linux alternatives or workarounds.
Automation
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/automation/manage-runtime-environment.md
...main/articles/automation/manage-runtime-environment.md
High Priority
View Details →
Detected Bias Types
Powershell Heavy
Windows Tools
Windows First
Missing Linux Example
Summary
The documentation demonstrates a Windows/PowerShell bias by focusing primarily on PowerShell examples, tools, and workflows. PowerShell is consistently mentioned first, with detailed steps and REST API payloads centering on PowerShell runbooks and modules (e.g., Az PowerShell, Get-Module). Linux/Python support is referenced but lacks equivalent depth, examples, or tooling guidance. There are references to Linux (e.g., Python .whl files for cp310 Linux OS), but no Linux shell or CLI examples, and the documentation assumes familiarity with Windows/PowerShell-centric patterns.
Recommendations
- Provide equivalent Linux/Python examples for all workflows, including REST API payloads and portal steps.
- Include examples using Azure CLI and bash for managing runtime environments and runbooks, not just PowerShell.
- When listing scripting languages or runtime options, alternate the order or explicitly state parity between PowerShell and Python.
- Offer guidance on using Linux-native packaging (e.g., .tar.gz, pip) and troubleshooting for Python/Linux environments.
- Add screenshots and walkthroughs for Python runbooks and Linux-based runtime environments, not just PowerShell.
- Reference Linux tools and patterns (e.g., bash, shell scripts) alongside Windows/PowerShell tools.
- Clarify which features or modules are exclusive to PowerShell/Windows and which are available for Python/Linux, to set clear expectations.
Automation
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/automation/manage-runtime-environment.md
...main/articles/automation/manage-runtime-environment.md
High Priority
View Details →
Detected Bias Types
Powershell Heavy
Windows Tools
Windows First
Missing Linux Example
Summary
The documentation exhibits a clear bias toward Windows and PowerShell environments. Most examples, especially for creating and managing runtime environments and runbooks, focus on PowerShell, with detailed steps and REST API payloads for PowerShell scenarios. References to Windows-specific tools (e.g., PowerShell Gallery, Get-Module cmdlet, .zip files for modules) are prevalent, while Linux/Python equivalents are either briefly mentioned or omitted. The documentation often presents PowerShell/Windows approaches first and in more detail, with Linux/Python support appearing as side notes or afterthoughts.
Recommendations
- Provide parallel, detailed examples for Python runbooks and Linux-based runtime environments, including REST API payloads and portal steps.
- Include Linux/Python-specific tooling and patterns (e.g., using pip, requirements.txt, .tar.gz/.whl files) alongside PowerShell/Windows instructions.
- Balance the order of presentation so that Linux/Python approaches are given equal prominence and detail as PowerShell/Windows.
- Reference both PowerShell Gallery and Python Package Index (PyPI) for package management, and provide guidance for both ecosystems.
- Add explicit Linux/Python code snippets and screenshots where only PowerShell/Windows examples are currently shown.
- Clarify when instructions or features are Windows/PowerShell-specific versus cross-platform.
Automation
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/automation/troubleshoot/extension-based-hybrid-runbook-worker.md
.../troubleshoot/extension-based-hybrid-runbook-worker.md
High Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Powershell Heavy
Windows Registry Focus
Windows Event Log Focus
Summary
The documentation generally provides parity between Windows and Linux for most troubleshooting steps, with separate sections and commands for each OS. However, there is a consistent pattern of presenting Windows examples, tools, and troubleshooting steps before their Linux equivalents. Several scenarios and troubleshooting steps are Windows-specific, focusing on PowerShell commands, Windows registry, event logs, and folder permissions, with less emphasis or equivalent detail for Linux. Some troubleshooting advice and monitoring steps reference Windows-only tools or logs (e.g., Microsoft-SMA event logs, registry keys), and Windows-specific issues are described in more detail than Linux-specific ones.
Recommendations
- Alternate the order of Windows and Linux instructions or present them in parallel to avoid always listing Windows first.
- Where possible, provide equivalent Linux commands or log locations for steps that currently reference only Windows tools (e.g., event logs, registry).
- Expand Linux troubleshooting scenarios to match the depth and specificity of Windows-focused sections (e.g., permissions, user management, service status).
- Include Linux-native troubleshooting tools and patterns (e.g., journalctl, systemd logs, Linux file permissions) alongside Windows event logs and registry references.
- Ensure that all PowerShell-heavy instructions have Bash or Python equivalents for Linux environments.
- Add more Linux-specific troubleshooting scenarios, especially for common issues like permissions, service failures, or log analysis.
Automation
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/automation/automation-runbook-types.md
...b/main/articles/automation/automation-runbook-types.md
High Priority
View Details →
Detected Bias Types
Windows First
Powershell Heavy
Windows Tools
Missing Linux Example
Summary
The documentation page demonstrates a significant Windows and PowerShell bias. PowerShell (and specifically Windows PowerShell) is presented as the default and recommended runbook type, with extensive detail and examples provided only for PowerShell. Many examples and troubleshooting steps reference Windows-specific paths (e.g., C:\modules), environment variables, and tools. Linux support is mentioned but not illustrated with examples, and Linux-specific considerations are minimal or absent. Python runbooks receive less coverage, and Linux Hybrid Worker scenarios are only briefly referenced, often in the context of limitations.
Recommendations
- Provide Linux-specific examples and troubleshooting steps, especially for Hybrid Runbook Worker scenarios.
- Include sample scripts and code snippets for Linux environments (e.g., referencing /var/tmp or /opt/modules instead of only C:\ paths).
- Balance the order of presentation so that Python and Linux options are not always listed after Windows/PowerShell.
- Explicitly document any differences in behavior, limitations, or setup steps for Linux Hybrid Runbook Workers.
- Where Windows tools or environment variables are referenced, provide Linux equivalents (e.g., $HOME, /tmp, etc.).
- Add parity in known issues and workarounds for Linux users, not just Windows/PowerShell scenarios.
- Clarify in tables and overviews which features are cross-platform and which are Windows-only.