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 401-425 of 982 flagged pages
Automation
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/automation/change-tracking/overview-monitoring-agent.md
...utomation/change-tracking/overview-monitoring-agent.md
High Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Missing Linux Example
Powershell Heavy
Summary
The documentation demonstrates a moderate Windows bias. Windows-specific concepts (like registry keys, Windows services, and file paths) are discussed in greater detail and often appear before Linux equivalents. There are extensive tables and examples for Windows registry tracking, but no comparable Linux configuration file or daemon tracking examples. Query and alerting examples focus on Windows paths and registry keys, with only a single Linux daemon example. The documentation also references Windows tools and patterns (e.g., c:\ paths, registry, Windows services) more frequently and in more depth than Linux equivalents.
Recommendations
- Provide Linux-first or parallel Linux examples for all features, especially for configuration tracking (e.g., show how to track changes in /etc/passwd or /etc/ssh/sshd_config, or Linux service files).
- Include tables or lists of commonly tracked Linux configuration files and directories, similar to the detailed registry key table for Windows.
- Balance query and alerting examples by including Linux-centric scenarios (e.g., tracking changes to /etc/hosts, /etc/systemd/system/*.service, or package installations).
- When describing features, alternate the order of Windows and Linux examples, or present them side-by-side.
- Expand explanations of Linux daemon and package tracking to match the depth given to Windows services and registry.
- Avoid using only Windows-centric terminology (e.g., 'Windows services') without also mentioning Linux equivalents ('Linux daemons') in the same context.
Create Pull Request
Automation
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/automation/change-tracking/overview-monitoring-agent.md
...utomation/change-tracking/overview-monitoring-agent.md
High Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Powershell Heavy
Missing Linux Example
Summary
The documentation, while claiming support for both Windows and Linux, displays several Windows-centric biases. Windows terminology, tools, and examples are often presented first or exclusively, such as detailed registry key monitoring (Windows-only), alerting examples focused on Windows file paths, and references to Windows services. Linux equivalents (like daemons or configuration files) are mentioned but not explored with the same depth or specificity. Some sections, such as registry tracking, are Windows-only without parallel Linux content. Command-line examples use PowerShell syntax and Windows paths, and alerting queries are Windows-heavy. Linux features and limitations are mentioned but not detailed or exemplified to the same extent.
Recommendations
- Provide Linux-specific examples and explanations wherever Windows examples are given (e.g., track /etc/passwd or /etc/ssh/sshd_config changes, monitor systemd services).
- Balance the order of presentation so that Linux and Windows are treated equally (alternate or parallel sections/examples).
- Include Linux-specific alerting queries and scenarios (e.g., tracking changes to /etc/hosts, /etc/systemd/system/*.service, or installed packages).
- Expand on Linux limitations and supported features to match the detail given for Windows (e.g., which Linux configuration files or daemons are tracked by default).
- Avoid using only Windows-centric terminology (like registry, services) without also referencing Linux equivalents (like configuration files, daemons) in the same context.
- Where PowerShell or Windows CLI is used, provide Bash or Linux CLI equivalents.
Automation
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/automation/change-tracking/overview-monitoring-agent.md
...utomation/change-tracking/overview-monitoring-agent.md
High Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Powershell Heavy
Missing Linux Example
Summary
The documentation demonstrates a moderate Windows bias. Windows-specific concepts (such as registry keys, Windows services, and file paths) are described in detail, often with examples or tables, while Linux equivalents (such as daemons or configuration files) are mentioned but not explored with the same depth. In several sections, Windows tools and patterns (e.g., registry, Windows services, c:\ paths) are presented first or exclusively, and Linux-specific examples are sparse or absent. The alerting/query examples and registry monitoring are heavily Windows-centric, and there is little explanation or tabular detail for Linux-specific monitoring (e.g., no table of common Linux daemon paths or config files). Some command-line examples are presented for both platforms, but the overall narrative and examples lean toward Windows.
Recommendations
- Add equivalent Linux-focused sections, such as a table of commonly monitored Linux configuration files or directories (e.g., /etc/passwd, /etc/ssh/sshd_config) and common daemons.
- Provide Linux-specific examples for alerting and queries, such as tracking changes to /etc/hosts, /etc/shadow, or systemd service states.
- Balance the order of presentation: when listing features, alternate or parallelize Windows and Linux examples (e.g., 'Windows registry or Linux configuration files').
- Expand the explanation of Linux daemon monitoring, including what is tracked and how, similar to the Windows registry section.
- Where screenshots or UI references are given, ensure Linux scenarios are depicted as well.
- Clarify any platform-specific limitations or differences in parity, and provide migration or workaround guidance for Linux users.
Automation
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/automation/change-tracking/overview-monitoring-agent.md
...utomation/change-tracking/overview-monitoring-agent.md
High Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Powershell Heavy
Missing Linux Example
Summary
The documentation demonstrates a moderate Windows bias. Windows-specific concepts (such as registry keys and Windows services) are described in detail, with extensive tables and explanations, while Linux equivalents (like daemons) receive less coverage. Example queries and alerting scenarios often use Windows file paths and registry keys before or instead of Linux examples. The documentation also references Windows tools and concepts (e.g., PowerShell, Windows registry, Windows services) more frequently and in greater detail than their Linux counterparts. Some sections (like registry tracking) are Windows-only, and Linux-specific features or limitations are less thoroughly documented.
Recommendations
- Ensure that for every Windows-specific example (e.g., registry keys, file paths, services), a Linux equivalent (e.g., configuration files, systemd units, package managers) is provided and described with equal detail.
- Balance example queries and alerting scenarios by including Linux-centric use cases (e.g., tracking changes to /etc/passwd, /etc/ssh/sshd_config, or monitoring systemd service states).
- Expand the documentation of Linux-specific features, limitations, and best practices, matching the depth provided for Windows.
- Where Windows tools or patterns are mentioned (e.g., PowerShell, registry), include Linux command-line or configuration management equivalents (e.g., Bash, systemctl, /etc directories).
- Reorder sections or examples so that Linux and Windows are presented in parallel, rather than Windows-first.
- Clarify any feature parity gaps between Windows and Linux, and provide guidance or workarounds for Linux users where features are missing.
Automation
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/automation/change-tracking/overview-monitoring-agent.md
...utomation/change-tracking/overview-monitoring-agent.md
High Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Powershell Heavy
Missing Linux Example
Summary
The documentation demonstrates a moderate Windows bias. Windows-specific concepts (such as registry keys, Windows services, and file paths) are often described in greater detail or appear first. Powershell and Windows file paths are used in examples and queries before Linux equivalents. The registry monitoring section is exclusively Windows-focused, and alerting examples prioritize Windows paths and services. Linux is supported and mentioned, but often as a secondary consideration, with fewer detailed examples or explanations.
Recommendations
- Provide Linux-specific examples and explanations alongside Windows ones, especially for alerting queries, file paths, and service/daemon monitoring.
- Balance the order of presentation so Linux and Windows are treated equally (e.g., alternate which OS is mentioned first in tables and examples).
- Expand the registry monitoring section to clarify that Linux does not have a direct equivalent, and offer guidance on monitoring Linux configuration files or similar artifacts.
- Include Linux command-line examples (e.g., bash, systemctl) where Powershell or Windows commands are shown.
- Ensure screenshots and UI walkthroughs show both Windows and Linux scenarios where applicable.
Automation
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/automation/change-tracking/overview-monitoring-agent.md
...utomation/change-tracking/overview-monitoring-agent.md
High Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Powershell Heavy
Missing Linux Example
Summary
The documentation demonstrates a moderate Windows bias. Windows-specific concepts (such as registry keys, Windows services, and file paths) are often described in more detail or appear first. Several examples, especially in the alerting/query section, use Windows file paths and registry keys without equivalent Linux examples. The registry monitoring section is entirely Windows-focused, and alerting scenarios prioritize Windows paths and services. While Linux is mentioned and supported, Linux-specific examples and explanations are less detailed or absent, and Windows terminology/tools (like PowerShell and Windows registry) are more prominent.
Recommendations
- Provide Linux-specific examples alongside Windows ones, especially in sections covering queries, alerting, and configuration.
- Expand the registry monitoring section to discuss Linux equivalents, such as monitoring configuration files or system directories.
- Balance the order of presentation so that Linux and Windows are given equal prominence (e.g., alternate which OS is described first in tables and examples).
- Include Linux daemon/service monitoring examples with similar detail as Windows services.
- Offer Linux-specific troubleshooting tips and limitations, not just Windows-focused ones.
- Where PowerShell or Windows command-line tools are referenced, provide equivalent Bash or Linux shell commands.
Automation
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/automation/change-tracking/overview-monitoring-agent.md
...utomation/change-tracking/overview-monitoring-agent.md
High Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Missing Linux Example
Powershell Heavy
Summary
The documentation demonstrates a Windows bias in several ways. Windows-specific concepts (such as registry keys and Windows services) are described in detail, with entire sections and tables dedicated to Windows registry monitoring and example queries referencing Windows file paths and services before Linux equivalents. While Linux is mentioned and some parity is attempted (e.g., Linux daemons, Linux packages), Linux-specific examples are sparse or missing, especially for advanced scenarios (e.g., no Linux equivalent to the detailed registry key monitoring section, and alerting examples are Windows-heavy). Command-line examples use PowerShell-style syntax and focus on Windows first. Windows tools and patterns (like registry, services, .exe files) are discussed more thoroughly than their Linux counterparts.
Recommendations
- Add equivalent Linux-focused sections, such as monitoring important Linux configuration files (e.g., /etc/passwd, /etc/ssh/sshd_config), and provide example queries for these.
- Include a table or section listing important Linux daemons and configuration files that are commonly tracked, similar to the Windows registry key table.
- Balance example queries so that Linux scenarios (e.g., tracking changes to /etc/hosts or systemd services) are presented alongside or before Windows examples.
- Provide more Linux-specific troubleshooting tips, limitations, and best practices, not just Windows-centric notes.
- Ensure that command-line examples are provided in both PowerShell and Bash (or at least clarify that az CLI commands are cross-platform and show Linux shell usage where appropriate).
- Review the order of presentation so that Linux and Windows are treated equally throughout, rather than Windows-first.
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 both structure and content. Windows instructions, tools, and examples (especially PowerShell) are consistently presented before Linux equivalents, and in greater detail. PowerShell is the default scripting language for runbook examples, with no Linux shell or Python examples provided. Windows-specific tools and paths are referenced more frequently and with more depth than their Linux counterparts. Some advanced features, such as Hybrid Worker Credentials, are not supported on Linux, but this is only noted in passing. There is a lack of parity in example scripts and troubleshooting guidance for Linux users.
Recommendations
- Present Windows and Linux instructions in parallel or use tabs to allow users to select their OS, rather than listing Windows first.
- Provide equivalent Linux shell (bash) or Python examples alongside PowerShell examples, especially for common runbook tasks.
- Include Linux-specific troubleshooting steps and example scripts where Windows examples are given.
- Ensure that references to tools, paths, and environment variables are balanced between Windows and Linux, and avoid assuming PowerShell as the default.
- Clearly indicate feature gaps for Linux and, where possible, provide workarounds or alternative guidance.
- Expand documentation for Linux-specific configuration, such as credential management and logging, to match the depth provided for Windows.
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 Windows-first and PowerShell-centric bias. Windows instructions, tools, and examples are consistently presented before Linux equivalents, and in some sections, Linux examples are less detailed or omitted. PowerShell and Windows-specific tools (e.g., Control Panel, Windows environment variable dialogs, Windows certificate stores) are emphasized, while Linux instructions are often more generic or less prominent. PowerShell cmdlets are used exclusively in authentication and runbook examples, with no Bash or Python script equivalents for Linux users. Some advanced features (like Hybrid Worker Credentials) are noted as unsupported on Linux, but without Linux alternatives or workarounds.
Recommendations
- Present Windows and Linux instructions/examples in parallel or in clearly separated, equally detailed sections.
- Provide Linux/Bash/Python script examples alongside PowerShell examples, especially for authentication, runbook management, and automation tasks.
- When referencing tools (e.g., environment variable management, certificate/key management), include Linux-native tools and commands (e.g., export, /etc/environment, openssl, gpg) with step-by-step instructions.
- Avoid assuming PowerShell as the default scripting language; clarify when features are PowerShell-specific and offer alternatives for Bash/Python where possible.
- For features not supported on Linux (e.g., Hybrid Worker Credentials), suggest Linux-native alternatives or explicitly state the limitation and potential workarounds.
- Balance the order of presentation so that Linux and Windows users can quickly find relevant information without perceiving one platform as secondary.
Automation
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/automation/automation-use-azure-ad.md
...ob/main/articles/automation/automation-use-azure-ad.md
High Priority
View Details →
Detected Bias Types
Powershell Heavy
Windows Tools
Missing Linux Example
Windows First
Summary
The documentation is heavily focused on Windows and PowerShell tooling, with all examples and instructions using PowerShell modules and cmdlets. There is no mention of Linux, Bash, or cross-platform scripting alternatives, and the credential management workflow is described solely in terms of Windows PowerShell constructs. The documentation assumes the use of Windows-centric tools and patterns throughout.
Recommendations
- Provide equivalent examples using Azure CLI (az) and Bash scripting for Linux and cross-platform users.
- Mention that Azure Automation supports Python runbooks and provide a Python example for credential management and resource automation.
- Clarify which steps and modules are cross-platform, and which are Windows-only, to help non-Windows users understand applicability.
- Include references to Linux authentication workflows, such as using service principals or managed identities with az CLI.
- Reorder sections or add parallel instructions so that Linux/cross-platform methods are not always secondary to Windows/PowerShell.
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 Windows-first and PowerShell-centric bias. Windows instructions, tools, and examples are consistently presented before their Linux equivalents, and in some sections, only Windows/PowerShell examples are provided. Windows-specific tools (e.g., Control Panel, cert store paths) are detailed, while Linux alternatives are less emphasized or less thoroughly explained. PowerShell is the default scripting language throughout, with limited or no examples for Bash or native Linux scripting. Some advanced features (like Hybrid Worker Credentials) are not supported or documented for Linux, and this is only noted as a limitation rather than providing alternatives.
Recommendations
- Present Linux and Windows instructions/examples in parallel or with equal prominence, rather than always listing Windows first.
- Provide equivalent Bash or Python examples for runbook authentication, starting runbooks, and other automation tasks, not just PowerShell.
- Include Linux-native tools and workflows (e.g., environment variable management, certificate/key management) with the same level of detail as Windows tools.
- Where features are unsupported on Linux (e.g., Hybrid Worker Credentials), suggest alternative approaches or workarounds for Linux users.
- Add more Linux-specific troubleshooting and logging guidance, matching the depth provided for Windows.
- Where possible, use cross-platform language (e.g., 'command line' instead of 'PowerShell prompt') and clarify when instructions are OS-specific.
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, Windows environment variable setup, and certificate management) are presented first and in greater detail. PowerShell-based authentication and runbook examples are provided without equivalent Bash or Python/Linux-native examples. Some features (like Hybrid Worker Credentials) are explicitly unsupported on Linux, but this is not always clearly highlighted up front. Linux instructions are present but often less detailed, and Linux-native scripting or tooling (other than GPG for signing) is underrepresented.
Recommendations
- Provide Linux-native command-line examples (e.g., Bash scripts) alongside PowerShell examples for common tasks such as starting runbooks, authentication, and environment variable management.
- Present Windows and Linux instructions in parallel sections or tabs, rather than listing Windows first and Linux second.
- Include Linux-specific troubleshooting steps and references to Linux tools (e.g., systemd, journalctl, or relevant log file locations) where appropriate.
- Where features are unsupported on Linux (e.g., Hybrid Worker Credentials), clearly state this at the beginning of the relevant section.
- Offer Python or Bash runbook examples in addition to PowerShell, especially in authentication and automation scenarios.
- Reference Linux documentation (e.g., man pages, official Python or Bash docs) as frequently as Windows/PowerShell documentation.
- Ensure parity in detail and clarity between Windows and Linux instructions, including explicit steps for common Linux distributions.
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 presented first and in greater detail. Windows tools and file paths are often mentioned before their Linux equivalents, and some sections (such as credential management and runbook authentication) provide only Windows/PowerShell examples or focus heavily on Windows workflows. Linux instructions are present but sometimes less detailed or appear after Windows content. There are also more PowerShell-based code samples than bash or Python equivalents, and some features (like Hybrid Worker Credentials) are noted as unsupported on Linux without offering Linux alternatives.
Recommendations
- Present Windows and Linux instructions/examples in parallel sections or tabs, ensuring equal prominence.
- Provide Linux (bash or Python) code samples wherever PowerShell examples are given, especially for runbook authentication and management tasks.
- When referencing tools (e.g., certificate management, environment variable setup), mention both Windows and Linux tools with equal detail and order.
- Clarify feature parity and, where Linux support is lacking (e.g., Hybrid Worker Credentials), suggest alternative Linux-compatible approaches or workarounds.
- Include Linux-specific troubleshooting and operational guidance alongside Windows content.
- Balance references to Windows file paths and registry locations with Linux equivalents throughout the documentation.
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
Missing Linux Example
Summary
The documentation generally provides parity between Windows and Linux for most troubleshooting steps, with separate sections and examples for each OS. However, there is a consistent pattern of presenting Windows instructions, tools, and examples before Linux equivalents (windows_first). Windows-specific tools (such as PowerShell scripts and registry edits) are described in detail, while Linux instructions are sometimes less detailed or lack equivalent troubleshooting guidance (powershell_heavy, windows_tools, missing_linux_example). Some scenarios, such as registry and event log troubleshooting, are only described for Windows, with no Linux counterpart.
Recommendations
- Alternate the order of Windows and Linux instructions throughout the document, or group by OS to avoid implicit prioritization.
- Ensure that all troubleshooting scenarios covered for Windows (such as registry, event logs, and credential issues) have Linux equivalents or explicitly state if not applicable.
- Provide Linux-native troubleshooting tools or scripts where PowerShell is used for Windows, and offer equivalent command-line examples (e.g., bash, Python).
- Where Windows event logs are referenced, suggest equivalent Linux log files (e.g., /var/log/syslog, /var/log/messages) and commands (e.g., journalctl).
- For sections that only mention Windows-specific issues (such as UAC or registry permissions), clarify if these are not applicable to Linux, or provide Linux-specific security troubleshooting if relevant.
- Review and expand Linux troubleshooting steps to match the depth and clarity provided for Windows, ensuring Linux users have equally actionable guidance.
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 for automation account management, with no equivalent Azure CLI (cross-platform) or Bash examples. The PowerShell sections are prominent and detailed, while Linux-native or cross-platform command-line usage is not addressed. The documentation also refers to Windows-centric tools and patterns, such as PowerShell, without mentioning or prioritizing Linux or cross-platform alternatives.
Recommendations
- Add Azure CLI (az) command examples alongside PowerShell for all automation account management tasks, including deletion and solution removal.
- Include Bash shell script examples where appropriate to demonstrate cross-platform usage.
- Present Azure CLI examples before or alongside PowerShell to avoid prioritizing Windows tools.
- Explicitly mention that Azure CLI is available on Windows, Linux, and macOS, and provide guidance for users on non-Windows platforms.
- Review all sections to ensure that Linux and macOS users are not excluded from the documented workflows.
Automation
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/automation/overview.md
...s/azure-docs/blob/main/articles/automation/overview.md
High Priority
View Details →
Detected Bias Types
Powershell Heavy
Windows First
Windows Tools
Missing Linux Example
Summary
The documentation page demonstrates a Windows bias by focusing heavily on PowerShell and Windows-centric tools and patterns. PowerShell and DSC (Desired State Configuration, a Windows technology) are mentioned repeatedly, often without equivalent emphasis on Linux-native tools or examples. The 'Modules gallery' and integration with the PowerShell Gallery are highlighted, while Linux-native automation tools or scripting languages (like Bash or Ansible) are not mentioned. Although Linux support is acknowledged, concrete Linux examples, tools, or workflows are missing, and Windows technologies are typically mentioned first or exclusively.
Recommendations
- Provide Linux-specific examples alongside PowerShell, such as Bash or Python scripts for common automation tasks.
- Mention Linux-native configuration management tools (e.g., Ansible, Chef, Puppet) where relevant, or clarify integration options.
- Balance references to PowerShell Gallery with mentions of Python Package Index (PyPI) or other Linux-relevant repositories.
- Include explicit Linux runbook authoring and execution scenarios, not just general statements about 'heterogeneous support'.
- When discussing configuration management, note support for Linux DSC or alternatives, and provide links to Linux documentation.
- Ensure that examples and scenarios (such as Hybrid Runbook Worker) include both Windows and Linux use cases, with clear step-by-step guides for each.
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 (especially PowerShell and Windows environment variable management) are presented first and in greater detail. PowerShell is the default scripting language throughout, and most code samples are PowerShell-based. Windows tools and paths are referenced explicitly, while Linux equivalents are sometimes less detailed or missing (e.g., credential asset usage, runbook authentication examples, and some folder permissions). Linux instructions are present but often appear after Windows content and sometimes lack parity in depth or clarity.
Recommendations
- Provide Linux examples alongside Windows examples, especially for credential asset usage, runbook authentication, and starting runbooks via CLI (e.g., Bash/Azure CLI).
- Balance the order of presentation: alternate or parallelize Windows and Linux sections rather than always presenting Windows first.
- Include Linux-specific tools and commands (e.g., Azure CLI, Bash scripts) where PowerShell is used for Windows.
- Expand Linux instructions to match the detail level of Windows instructions, particularly for environment variable management, permissions, and troubleshooting.
- Where Windows paths or tools are referenced, provide the Linux equivalents in the same context.
- Add more Linux-focused troubleshooting and operational guidance, such as log file locations, service management, and common issues.
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 Windows bias by prioritizing Windows PowerShell and Windows-specific tools and patterns throughout. PowerShell (and its Windows-centric features) is consistently presented first and in greater detail than Python or Linux options. Many examples and known issues reference Windows file paths (e.g., C:\modules), environment variables, and cmdlets, with little or no equivalent Linux guidance. Hybrid Runbook Worker support for Linux is mentioned, but practical Linux examples or troubleshooting are missing. Python runbooks receive less detailed coverage, and Linux-specific considerations are often brief or absent.
Recommendations
- Provide Linux-specific examples and troubleshooting steps, especially for PowerShell runbooks running on Linux Hybrid Runbook Workers.
- Include Linux file path examples (e.g., /usr/local/modules) alongside Windows paths in scripts and known issues.
- Clarify differences in behavior, limitations, and module management between Windows and Linux Hybrid Runbook Workers.
- Add parity in code samples: for every PowerShell example, provide a Python example where possible, and vice versa.
- Explicitly document any features or cmdlets that are Windows-only, and suggest Linux alternatives or workarounds.
- Expand the Python runbook section to include more detailed Linux usage scenarios and troubleshooting.
- Reorganize sections to avoid always listing Windows/PowerShell options first; consider grouping by OS or providing parallel guidance.
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 environments. PowerShell is consistently presented as the primary or default scripting language, with detailed examples and screenshots focused on PowerShell modules and workflows. Windows-specific tools (such as PowerShell Gallery and .zip module packaging) are emphasized, and Linux/Python guidance is minimal, often relegated to brief notes. There are no concrete Linux shell or Python package management examples, and REST API samples are PowerShell-centric. This creates a perception that Windows/PowerShell is the preferred or only fully supported environment.
Recommendations
- Provide equivalent, detailed examples for Python runbooks, including REST API payloads and portal workflows.
- Include Linux-specific guidance, such as using .whl files for Python, and clarify how to upload and manage Python packages (with examples).
- Balance screenshots and walkthroughs to show both PowerShell and Python scenarios.
- Mention Linux/Python options alongside or before Windows/PowerShell options where applicable, rather than as afterthoughts or notes.
- Add troubleshooting and best practices sections for Python/Linux runbooks, similar to those for PowerShell.
- Reference both PowerShell Gallery and Python Package Index (PyPI) for package sources.
- Clarify any differences in supported features or limitations between PowerShell and Python environments.
Automation
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/automation/python-3-packages.md
...ocs/blob/main/articles/automation/python-3-packages.md
High Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Powershell Heavy
Missing Linux Example
Summary
The documentation exhibits several forms of Windows bias. In sections describing how to generate wheel files, Windows is mentioned first and in more detail for Python 3.8, with explicit instructions to use a Windows machine, while the Linux equivalent is only provided for Python 3.10. The PowerShell cmdlets for managing Python packages are presented without any Linux/CLI/az CLI alternatives, reinforcing a Windows-centric approach. There are no examples or guidance for managing packages using Linux-native tools or cross-platform command-line interfaces, and the documentation assumes familiarity with Windows conventions and tooling.
Recommendations
- Provide equivalent Linux-based instructions and examples for all package management tasks, including generating wheel files for Python 3.8.
- Include az CLI or REST API examples alongside PowerShell cmdlets to ensure cross-platform accessibility.
- Explicitly mention when steps are platform-specific and offer alternatives for other platforms.
- Reorder sections or examples so that Linux and Windows are given equal prominence, or present them in parallel tabs.
- Clarify which steps are applicable to both Windows and Linux, and avoid assuming the user is on Windows by default.
Automation
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/automation/python-3-packages.md
...ocs/blob/main/articles/automation/python-3-packages.md
High Priority
View Details →
Detected Bias Types
Windows First
Missing Linux Example
Powershell Heavy
Windows Tools
Summary
The documentation demonstrates several Windows-centric biases. In the section on generating wheel files, the Windows (Python 3.8) workflow is described after the Linux (Python 3.10) workflow, but both are present. However, the PowerShell cmdlets for managing Python packages are only shown for Windows/PowerShell, with no equivalent CLI or bash examples for Linux users. The documentation also references Windows-specific architectures (win_amd64) and tools (PowerShell cmdlets) without providing Linux alternatives or parity. There is a lack of Linux-native management examples for package operations, and the PowerShell section is extensive and unbalanced compared to Linux guidance.
Recommendations
- Provide equivalent Azure CLI or Bash examples for all PowerShell cmdlets shown, especially for common package management tasks (add, list, remove, update).
- Explicitly mention and demonstrate how Linux users can manage Python packages in Azure Automation, including any differences in tooling or workflow.
- Balance the documentation by including Linux-first or cross-platform sections, not just Windows/PowerShell.
- When referencing platform-specific architectures (e.g., win_amd64), always provide the Linux equivalent (e.g., manylinux_x86_64) and clarify when each is needed.
- Consider a summary table or section that compares Windows and Linux workflows for package preparation and management in Azure Automation.
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 Azure CLI (cross-platform) or Bash examples. The PowerShell examples are given as the sole scripting/automation method, and there is no mention of Linux-native tools or shell environments. In sections where command-line automation is discussed, PowerShell is prioritized and presented before any mention of Azure CLI, which is only referenced in the introduction and not in the step-by-step instructions.
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 shell script examples where appropriate, especially for tasks that can be automated outside of PowerShell.
- Explicitly mention that all steps can be performed from Linux, macOS, or Windows, and clarify any platform-specific requirements.
- Reorder sections or provide tabs so that Azure CLI and PowerShell examples are presented equally, rather than prioritizing PowerShell.
- Reference Linux-native tools or environments where relevant, and avoid assuming the user is on Windows or using PowerShell.
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 strong Windows and PowerShell bias. PowerShell (including Windows PowerShell and PowerShell Workflow) is presented first and in the most detail, with extensive examples and troubleshooting focused on Windows paths, tools, and cmdlets. Many examples and limitations reference Windows-specific file paths (e.g., C:\modules), environment variables, and behaviors. There is little to no Linux-specific guidance, examples, or troubleshooting, and Linux is only mentioned in passing (e.g., 'can run on Linux Hybrid Worker'), without concrete examples or parity in troubleshooting. Python runbooks receive less coverage, and Linux-specific details are minimal.
Recommendations
- Provide Linux-specific examples for PowerShell runbooks, especially for Hybrid Runbook Workers running on Linux (e.g., file paths, environment variables, module locations).
- Include troubleshooting steps and known issues relevant to Linux environments, not just Windows (e.g., what to do if a module path is /usr/local/share/powershell/Modules).
- Balance the order and prominence of runbook types: consider presenting Python and PowerShell equally, or at least avoid always listing Windows/PowerShell first.
- Where Windows-specific tools or patterns are mentioned (e.g., C:\modules, .ps1 script execution), provide Linux equivalents (e.g., /opt/automation/modules, ./child-runbook.ps1 with Linux path syntax).
- Expand the Python runbook section to include more parity with PowerShell, such as common troubleshooting, best practices, and examples for both Windows and Linux Hybrid Workers.
- Explicitly call out any differences or additional steps required for Linux Hybrid Runbook Workers throughout the documentation, not just in limitations.
Automation
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/automation/overview.md
...s/azure-docs/blob/main/articles/automation/overview.md
High Priority
View Details →
Detected Bias Types
Powershell Heavy
Windows First
Windows Tools
Missing Linux Example
Summary
The documentation page demonstrates a Windows bias primarily through its heavy emphasis on PowerShell and Windows-centric tools and terminology. PowerShell is repeatedly mentioned as the primary automation language, and features like Desired State Configuration (DSC) are described in the context of PowerShell. The modules gallery and runbook examples focus on PowerShell, with only brief mentions of Python. There is a lack of Linux-specific examples, tools, or workflows, and Windows tools and patterns are referenced before or instead of Linux equivalents. While the page claims heterogeneous support, practical Linux parity is not demonstrated.
Recommendations
- Include Linux-specific examples for runbooks, such as Bash or Python scripts managing Linux resources.
- Highlight Linux-native automation tools or integration patterns (e.g., Ansible, shell scripting) alongside PowerShell.
- Provide equal coverage of Linux configuration management options, not just PowerShell DSC.
- Showcase Linux scenarios in common use cases, such as automating package updates, managing systemd services, or configuring SSH.
- Reference Linux module repositories (e.g., PyPI for Python, or community Bash scripts) in addition to the PowerShell Gallery.
- Ensure that when listing features or capabilities, Linux and Windows are presented with equal prominence and detail.
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 instructions, tools, and examples (especially PowerShell) are presented first and in greater detail, with more explicit step-by-step guidance. PowerShell cmdlets and Windows-specific paths/tools are emphasized throughout, while Linux equivalents are sometimes less detailed or omitted. Some advanced scenarios, such as using credential assets for Hybrid Worker credentials, are only supported or documented for Windows. Example scripts and code samples are almost exclusively PowerShell/Windows-centric, with minimal or no Bash/Linux scripting shown for equivalent tasks.
Recommendations
- Present Linux and Windows instructions/examples in parallel or in separate, equally detailed sections, rather than always listing Windows first.
- Provide Bash or Python script examples for Linux wherever PowerShell examples are given for Windows (e.g., starting a runbook, managing credentials, signing runbooks).
- Where features are Windows-only (such as Hybrid Worker credentials), explicitly state this early and suggest Linux alternatives or workarounds if possible.
- Add more detailed Linux-specific troubleshooting, configuration, and environment setup steps, matching the granularity given for Windows.
- Reference Linux tools and patterns (e.g., systemd, log locations, environment variable management) as prominently as Windows tools.
- Where PowerShell is used cross-platform, clarify how to install and use it on Linux, and provide Linux-specific code samples (e.g., file paths, environment variables).