239
Pages Scanned
39
Pages Flagged
239
Changed Pages
16.3%
% Pages Flagged
Scan Information
Started At: 2026-02-10 00:00:10
Finished At: 2026-02-10 18:00:39
Status: completed
Target Repo: Azure
Current Phase: discovery
Files Queued: 239
Files Completed: 239
Problematic Pages
40 issues found
Application Gateway
Tutorial: Improve web application access - Azure Application Gateway
.../articles/application-gateway/tutorial-autoscale-ps.md
High Priority
View Details →
Detected Bias Types
powershell_heavy
windows_tools
missing_linux_example
windows_first
Summary
The tutorial exclusively uses Azure PowerShell and Windows PowerShell cmdlets for all steps, including certificate creation (New-SelfSignedCertificate, Export-PfxCertificate), and does not provide any Bash, Azure CLI, or Linux/macOS-compatible alternatives. Windows-specific file paths (e.g., c:\appgwcert.pfx) are used throughout. There is no mention of how to perform these tasks on Linux or macOS, nor are cross-platform tools or instructions provided.
Recommendations
- Add Azure CLI examples for each step alongside PowerShell, as Azure CLI is cross-platform.
- Provide instructions for creating self-signed certificates using OpenSSL (common on Linux/macOS) as an alternative to New-SelfSignedCertificate.
- Use generic file paths or note differences for Linux/macOS (e.g., /home/user/appgwcert.pfx).
- Clarify that Azure PowerShell can be run on Linux/macOS, and provide guidance for those environments.
- Include a note or section for Linux/macOS users outlining equivalent commands and tools.
Create Pull Request
Artifact Signing
Set up signing integrations to use Artifact Signing
...ticles/artifact-signing/how-to-signing-integrations.md
High Priority
View Details →
Detected Bias Types
windows_tools
powershell_heavy
missing_linux_example
windows_first
Summary
The documentation is heavily focused on Windows-based tools and workflows, especially SignTool and PowerShell. All setup instructions, prerequisites, and examples are Windows-specific, with no mention of Linux or macOS alternatives for direct signing. Even in sections referencing cross-platform integrations (e.g., GitHub Actions, Azure DevOps), the details and examples are omitted, and only links are provided. Linux and macOS users are left without guidance for native or CLI-based signing workflows.
Recommendations
- Add explicit guidance or examples for Linux/macOS users where possible, especially for SDK-based or cross-platform signing scenarios.
- Clarify early in the document if Artifact Signing with SignTool is Windows-only, and direct non-Windows users to supported alternatives (e.g., GitHub Actions, SDK usage).
- Expand the 'Use other signing integrations' section with at least one end-to-end example for a non-Windows platform (e.g., using GitHub Actions or the SDK on Linux).
- If native Linux/macOS CLI tools are not supported, state this clearly and provide recommended workflows for those users.
Application Gateway
Scaling and Zone-redundant Application Gateway v2
...eway/application-gateway-autoscaling-zone-redundant.md
Medium Priority
View Details →
Detected Bias Types
powershell_heavy
windows_first
Summary
The documentation page provides a link to a tutorial for creating an autoscaling, zone-redundant Application Gateway using Azure PowerShell, but does not mention or link to equivalent instructions for Azure CLI or ARM templates, which are cross-platform. The PowerShell example is highlighted in the 'Next steps' section, potentially signaling Windows-first bias.
Recommendations
- Add links or references to tutorials for creating autoscaling, zone-redundant Application Gateway using Azure CLI and ARM/Bicep templates.
- Ensure that cross-platform tools (Azure CLI, REST API, ARM/Bicep) are mentioned alongside PowerShell in 'Next steps' and throughout the documentation.
- Where PowerShell is referenced, clarify that equivalent functionality is available via CLI and templates, and provide links.
Application Gateway
Overview of mutual authentication on Azure Application Gateway
.../application-gateway/mutual-authentication-overview.md
Medium Priority
View Details →
Detected Bias Types
powershell_heavy
windows_first
missing_linux_example
Summary
The documentation provides configuration examples and references primarily using Azure PowerShell, with PowerShell examples shown first and in greater detail. Azure CLI is mentioned, but with less detail and fewer examples. There are no explicit Linux/macOS-specific instructions or examples, and the 'Next steps' section directs users to a PowerShell-focused guide. Portal support is noted as unavailable, but no Linux-specific tools or workflows are highlighted.
Recommendations
- Provide equally detailed Azure CLI examples alongside PowerShell, including step-by-step instructions for all major configuration tasks.
- Add explicit guidance for Linux/macOS users, such as how to prepare certificates using common Linux tools (e.g., OpenSSL), and reference relevant Linux command-line workflows.
- Ensure that CLI examples are not only present but also comprehensive, covering all configuration scenarios addressed in PowerShell.
- In 'Next steps', link to both PowerShell and CLI/Linux-focused guides for mutual authentication configuration.
- Consider including Bicep or ARM template examples, which are platform-neutral, for users who prefer declarative approaches.
Azure Functions
Azure Functions Core Tools reference
...cles/azure-functions/functions-core-tools-reference.md
Medium Priority
View Details →
Detected Bias Types
windows_first
windows_tools
Summary
The documentation is generally cross-platform and describes Azure Functions Core Tools commands in an OS-agnostic way. However, there are several subtle biases: (1) Windows/Windows-specific issues are often mentioned first or exclusively, such as warnings about Python packaging on Windows and references to the creation of trusted certificates 'on your computer' (which is a Windows-centric pattern); (2) Some terminology and examples (e.g., .pfx certificates, trusted certificate creation, and references to the Microsoft Azure Storage Emulator) are more familiar to Windows users and may lack Linux/macOS equivalents or clarifications. There are no explicit PowerShell-heavy examples, but some Windows tools and patterns are referenced without always providing Linux/macOS alternatives.
Recommendations
- Wherever Windows-specific issues are mentioned (e.g., Python packaging), provide equivalent Linux/macOS guidance or clarify when the issue is Windows-only.
- When referencing tools like the Microsoft Azure Storage Emulator, add notes about the Linux/macOS alternatives (e.g., Azurite) and link to their documentation.
- When mentioning certificate generation or trusted certificate creation, clarify the behavior on Linux/macOS (e.g., how self-signed certificates are handled, or if user action is required).
- Ensure that all examples and warnings are explicitly cross-platform or provide platform-specific notes as needed.
- Consider adding a short section at the top clarifying that all commands are cross-platform unless otherwise noted, and link to any OS-specific setup guides.
App Service
Use TLS/SSL Certificates in App Code
...icles/app-service/configure-ssl-certificate-in-code.md
Medium Priority
View Details →
Detected Bias Types
windows_first
powershell_heavy
missing_linux_example
windows_tools
Summary
The documentation provides detailed, code-level examples for accessing certificates in Windows apps and containers (including C# and Java), but offers minimal or no equivalent code examples for Linux apps outside of .NET. Linux coverage is limited to C# file-based loading, with other languages (Node.js, PHP, Python, Java) referred to external documentation. Windows certificate store usage is described in detail, while Linux approaches are less thoroughly covered. Windows-specific tools and patterns (certificate store, thumbprint usage) are emphasized first.
Recommendations
- Add explicit code examples for loading certificates in Linux containers and apps for popular languages such as Node.js, Python, Java, and PHP.
- Provide Linux-focused .NET examples earlier or alongside Windows examples, not only in later sections.
- Include a brief explanation of Linux certificate handling and best practices, similar to the Windows certificate store discussion.
- Where possible, avoid referencing only Windows certificate store APIs and provide cross-platform alternatives or guidance.
- Reorder sections or use tabs to present Windows and Linux approaches in parallel, reducing the 'Windows-first' impression.
App Service
Environment Variables and App Settings Reference
...ob/main/articles/app-service/reference-app-settings.md
Medium Priority
View Details →
Detected Bias Types
windows_first
windows_tools
powershell_heavy
Summary
The documentation page covers environment variables and app settings for Azure App Service across Windows and Linux platforms. However, there is a noticeable Windows bias: Windows-specific paths (e.g., D:\home), tools (e.g., msbuild, Web Deploy/MSDeploy), and configuration patterns (e.g., applicationHost.config, IIS, machineKey) are often mentioned first or exclusively. Windows terminology and examples appear before Linux equivalents, and some sections (such as build automation and logging) focus heavily on Windows-native tools and settings, with Linux alternatives referenced later or less prominently. Linux-specific settings are present, but Windows-centric information dominates in order and detail.
Recommendations
- Ensure Linux examples and paths (e.g., /home) are given equal prominence alongside Windows examples, especially in introductory tables and explanations.
- Where Windows tools (e.g., msbuild, Web Deploy/MSDeploy) are referenced, provide Linux alternatives or clarify their applicability.
- Reorder sections or tables so Linux and Windows information is presented in parallel, rather than Windows-first.
- Expand Linux-specific guidance (e.g., Oryx build automation, logging, deployment) to match the detail provided for Windows.
- Add explicit notes when a setting or feature is Windows-only, and provide Linux equivalents or workarounds where possible.
Medium Priority
View Details →
Detected Bias Types
powershell_heavy
missing_linux_example
windows_tools
Summary
The documentation provides a PowerShell-only example for enabling diagnostic logging, with no equivalent Azure CLI, Bash, or cross-platform instructions. It also references tools like Excel and Visual Studio for log analysis, which are primarily Windows-focused, and does not mention Linux/macOS alternatives. There are no Linux/macOS-specific examples or guidance, which may hinder non-Windows users.
Recommendations
- Add Azure CLI examples for enabling diagnostic logging, as Azure CLI is cross-platform and widely used on Linux/macOS.
- Include Bash or shell script examples where appropriate.
- Mention cross-platform tools for log analysis, such as jq, pandas (Python), or open-source log viewers, in addition to Excel and Visual Studio.
- Clarify that PowerShell Core is available cross-platform, if PowerShell must be used, and provide installation guidance.
- Reference Power BI Desktop for macOS (if/when available) or suggest alternative visualization tools for non-Windows users.
Application Gateway
Configure Azure Application Gateway TCP/TLS proxy
...n/articles/application-gateway/how-to-tcp-tls-proxy.md
Medium Priority
View Details →
Detected Bias Types
windows_first
missing_linux_example
Summary
The documentation demonstrates a bias toward Windows by exclusively using a Windows-based SQL Server VM as the backend and referencing SQL Server Management Studio (a Windows-only tool) for client connectivity. No Linux or macOS alternatives are provided for either the backend (e.g., SQL Server on Linux) or client (e.g., sqlcmd, Azure Data Studio, or other cross-platform tools). The instructions and screenshots are Windows-centric, potentially creating friction for Linux/macOS users.
Recommendations
- Include instructions for deploying SQL Server on Linux as a backend VM, or clarify that Windows is required if that's the case.
- Provide examples of connecting to the SQL Server via cross-platform tools such as sqlcmd (available on Linux/macOS), Azure Data Studio, or other open-source SQL clients.
- Mention any OS-specific requirements or limitations explicitly, so Linux/macOS users know if Windows is required.
- Add screenshots or command-line examples relevant to Linux/macOS environments where appropriate.
Application Gateway
Migrate from V1 to V2 - Azure Application Gateway
...lob/main/articles/application-gateway/migrate-v1-v2.md
Medium Priority
View Details →
Detected Bias Types
powershell_heavy
missing_linux_example
windows_tools
windows_first
Summary
The documentation is heavily focused on Azure PowerShell scripts and cmdlets for migration, with all examples and instructions provided exclusively in PowerShell syntax. There is no mention of Bash, Azure CLI, or cross-platform scripting alternatives. The installation and execution instructions assume a Windows/PowerShell environment, and there are no Linux/macOS-specific guidance or parity. This creates friction for users on Linux/macOS who may prefer or require Azure CLI or Bash-based workflows.
Recommendations
- Provide equivalent Azure CLI (az) commands and Bash script examples for all migration steps.
- Clarify whether the PowerShell scripts can be run in Azure Cloud Shell (which supports PowerShell and Bash) and provide guidance for Linux/macOS users.
- Add explicit instructions for running migration scripts from Linux/macOS, including prerequisites and troubleshooting.
- Mention and link to any available cross-platform tools or REST API alternatives for migration.
- If PowerShell is required, state this clearly and explain how Linux/macOS users can install and use PowerShell Core.
Application Gateway
What is Azure Application Gateway v2?
.../blob/main/articles/application-gateway/overview-v2.md
Medium Priority
View Details →
Detected Bias Types
powershell_heavy
windows_first
Summary
The documentation page for Azure Application Gateway v2 shows moderate Windows bias. Migration guidance and tutorials are centered on Azure PowerShell scripts, with no mention of Azure CLI or ARM templates for Linux/macOS users. The registration/unregistration preview commands are labeled as Azure CLI but use PowerShell cmdlets, which may confuse non-Windows users. Additionally, the 'Next steps' section links only to PowerShell-based tutorials, omitting Linux-friendly alternatives.
Recommendations
- Provide equivalent Azure CLI and/or ARM template examples for migration and deployment tasks.
- Clarify command syntax: If PowerShell is used, label it accurately; if Azure CLI is intended, provide true CLI commands.
- Add links to tutorials or guides that use Azure CLI or portal-based workflows.
- Ensure that Linux/macOS users can follow all critical workflows without requiring PowerShell.
Medium Priority
View Details →
Detected Bias Types
powershell_heavy
missing_linux_example
windows_tools
Summary
The documentation repeatedly references and recommends an Azure PowerShell script as the primary migration tool, without mentioning Azure CLI, Bash, or Linux/macOS-compatible alternatives. All migration automation examples and scripts are PowerShell-based, and there are no Linux/macOS-specific instructions or parity guidance. This creates friction for users on non-Windows platforms.
Recommendations
- Provide equivalent Azure CLI or Bash script examples for migration tasks, or clearly state if such alternatives are unavailable.
- Explicitly mention platform compatibility for the PowerShell script (e.g., if it works with PowerShell Core on Linux/macOS).
- Add guidance for Linux/macOS users on how to run the migration scripts (e.g., using Azure Cloud Shell, which supports PowerShell and Bash).
- If only PowerShell is supported, acknowledge this limitation and provide workarounds or alternatives for non-Windows users.
Automation
Disaster recovery for Azure Automation
...in/articles/automation/automation-disaster-recovery.md
Medium Priority
View Details →
Detected Bias Types
powershell_heavy
missing_linux_example
windows_tools
Summary
The documentation provides disaster recovery guidance for Azure Automation, which applies to both Linux and Windows VMs. However, all migration scripts and automation examples are exclusively PowerShell-based, with no mention of Bash, Azure CLI, or Python alternatives. The instructions for Hybrid Runbook Worker reference both Windows and Linux, but all migration and runbook automation is presented only with PowerShell scripts and workflows, which are traditionally Windows-centric tools. This creates friction for Linux/macOS users who may prefer or require non-PowerShell solutions.
Recommendations
- Provide equivalent migration scripts or runbooks using Azure CLI and/or Python to support Linux/macOS users.
- Include explicit examples or tabs for Bash/Azure CLI where PowerShell is currently used.
- Clarify if PowerShell Core (cross-platform) is supported and provide guidance for running scripts on Linux/macOS.
- Reference or link to any existing Linux/macOS-friendly tools or documentation for Automation account asset migration.
Medium Priority
View Details →
Detected Bias Types
windows_first
powershell_heavy
windows_tools
Summary
The documentation provides both Windows and Linux guidance for TLS upgrades, but Windows instructions and PowerShell cmdlets are mentioned first and more frequently. Several backup and retention operations reference Windows PowerShell cmdlets without Linux CLI or scripting equivalents, and Windows registry settings are linked before Linux OpenSSL guidance. Linux examples are present but less detailed and not always given equal prominence.
Recommendations
- Provide Azure CLI or Bash script equivalents for PowerShell cmdlet examples, especially for backup/export operations.
- Ensure Linux guidance is presented alongside Windows instructions, not after or as an afterthought.
- Add explicit instructions or links for managing Automation assets and DSC nodes from Linux/macOS environments.
- Include references to Linux tools (e.g., az CLI, shell scripts) where Windows tools (PowerShell, registry) are mentioned.
- Balance the order of platform-specific guidance so Linux and Windows are treated equally.
Automation
Use Microsoft Entra ID in Azure Automation to authenticate to Azure
...ob/main/articles/automation/automation-use-azure-ad.md
Medium Priority
View Details →
Detected Bias Types
powershell_heavy
windows_tools
missing_linux_example
windows_first
Summary
The documentation page heavily relies on Windows PowerShell examples and tools, such as PSCredential, Get-AutomationPSCredential, and Az modules. All code samples are in PowerShell, with no mention of Bash, Python, or Linux/macOS alternatives. The instructions for creating credential assets and managing Azure resources are exclusively PowerShell-based, and Windows terminology is used throughout. There is no guidance for Linux/macOS users or cross-platform scripting.
Recommendations
- Add equivalent Bash or Python examples for credential asset creation and Azure authentication, using Azure CLI or SDKs.
- Clarify whether Azure Automation runbooks can be authored in languages other than PowerShell and provide links or examples if so.
- Mention cross-platform tools (e.g., Azure CLI, REST API, Python SDK) where applicable, and note any limitations.
- Explicitly state if certain steps are PowerShell-only and provide guidance for Linux/macOS users on alternatives or workarounds.
- Reorder sections to avoid always presenting Windows/PowerShell solutions first.
Automation
Configure runbook input parameters in Azure Automation
...b/main/articles/automation/runbook-input-parameters.md
Medium Priority
View Details →
Detected Bias Types
powershell_heavy
windows_tools
windows_first
Summary
The documentation page heavily focuses on PowerShell and Windows-centric tools and patterns, with most examples, screenshots, and workflows centered around PowerShell, PowerShell Workflow, and graphical runbooks (which are PowerShell-based). Windows/PowerShell terminology and tools are used throughout, and PowerShell examples are presented before Python. There is minimal coverage of Python runbooks, and no mention of Bash, Linux shell, or cross-platform CLI usage. Assigning parameters and calling runbooks is almost exclusively demonstrated with PowerShell cmdlets and Windows-centric workflows.
Recommendations
- Add examples for starting runbooks and passing parameters using Azure CLI (az), which is cross-platform and widely used on Linux/macOS.
- Provide Python runbook parameter usage examples beyond referencing another tutorial, including how to pass parameters from CLI or REST API.
- Include guidance for Linux/macOS users, such as how to use Bash or shell scripts to invoke runbooks via REST API or Azure CLI.
- Clarify which features are PowerShell/Windows-specific and which are cross-platform, to help non-Windows users navigate the documentation.
- Present Python and cross-platform examples alongside PowerShell, not only after or as an afterthought.
Automation
Manage certificates in Azure Automation
...n/articles/automation/shared-resources/certificates.md
Medium Priority
View Details →
Detected Bias Types
powershell_heavy
windows_tools
windows_first
Summary
The documentation is heavily PowerShell-centric, with all certificate management (creation, upload, and deployment) examples using PowerShell cmdlets. There are no CLI, Bash, or Linux-native examples for certificate management tasks. The only non-PowerShell examples are for retrieving certificates in Python runbooks, but all asset management and deployment workflows are shown with PowerShell. The documentation also recommends PowerShell as a workaround for portal limitations, and PowerShell examples are consistently presented first.
Recommendations
- Add Azure CLI examples for certificate creation, upload, and management to provide parity for Linux/macOS users.
- Include Bash or cross-platform scripting examples where possible, especially for tasks like uploading certificates or deploying Resource Manager templates.
- When recommending workarounds (e.g., for CSP accounts), mention Azure CLI or REST API alternatives, not just PowerShell.
- Consider reordering or parallelizing examples so that PowerShell and cross-platform approaches are presented equally.
- Clarify which steps are platform-agnostic (e.g., using the Azure portal, Resource Manager templates) and which are PowerShell-specific.
Automation
Manage credentials in Azure Automation
...in/articles/automation/shared-resources/credentials.md
Medium Priority
View Details →
Detected Bias Types
powershell_heavy
windows_first
missing_linux_example
Summary
The documentation is heavily focused on PowerShell cmdlets and Windows-centric patterns for managing credentials in Azure Automation. All CLI examples are in PowerShell, and there is no mention of Bash, Linux shell, or cross-platform CLI alternatives. The 'Create a new credential asset' section only provides a Windows PowerShell example, with no Linux or macOS equivalent. The documentation assumes use of PowerShell and Windows tools throughout, creating friction for Linux/macOS users.
Recommendations
- Add Azure CLI examples for credential asset management, which are cross-platform and usable on Linux/macOS.
- Explicitly state whether PowerShell Core (pwsh) is supported and provide examples for it if so.
- Clarify if credential management is possible via REST API or SDKs, and provide relevant examples.
- Mention or link to any Linux/macOS-compatible tools or workflows for Azure Automation credential management.
- Reorder sections to present cross-platform options (Azure portal, Azure CLI, SDKs) before Windows PowerShell.
Azure App Configuration
Monitor Azure App Configuration
...s/azure-app-configuration/monitor-app-configuration.md
Medium Priority
View Details →
Detected Bias Types
windows_first
powershell_heavy
windows_tools
Summary
The documentation provides instructions for monitoring Azure App Configuration using the Azure Portal, Azure CLI, and PowerShell. In the CLI section, it mentions opening 'Windows PowerShell' as an example of a command console application, and the PowerShell section is specifically Windows-oriented. PowerShell is presented as a primary automation option alongside the cross-platform Azure CLI. The CLI section lists 'Windows PowerShell' before more generic terms like 'command console application.' There are no explicit Linux/macOS shell examples (e.g., Bash), and no mention of Linux/macOS-specific considerations, which may create friction for non-Windows users.
Recommendations
- Clarify that Azure CLI can be used from Bash, zsh, or any terminal on Linux/macOS, not just PowerShell or Windows.
- In CLI instructions, list 'Bash' or 'Terminal' alongside 'Windows PowerShell' to acknowledge Linux/macOS users.
- Explicitly state that PowerShell Core is cross-platform, or provide Bash equivalents where possible.
- Add a note or section for Linux/macOS users, confirming that all features are available and providing any OS-specific tips if needed.
- Reorder CLI instructions to mention generic 'terminal' or 'command prompt' before Windows-specific tools.
Azure Change Tracking Inventory
Azure Change Tracking and Inventory Overview by Using Azure Monitor Agent
...change-tracking-inventory/overview-monitoring-agent.md
Medium Priority
View Details →
Detected Bias Types
windows_first
missing_linux_example
Summary
The documentation covers Azure Change Tracking and Inventory for both Windows and Linux, but several sections (notably registry key tracking) are Windows-specific without Linux equivalents or explanations. Windows registry keys are discussed in detail, while Linux configuration tracking (such as monitoring changes to system files or daemons) is not covered with similar depth or examples. Windows terminology and concepts are presented first or exclusively in some areas, creating friction for Linux users seeking parity.
Recommendations
- Add equivalent Linux examples for configuration tracking, such as monitoring changes to /etc files, systemd service files, or other relevant Linux configuration files.
- Include a section on tracking Linux-specific artifacts (e.g., systemd units, cron jobs, package manager logs) to match the Windows registry key tracking section.
- Clarify which features are Windows-only and which are cross-platform, and provide guidance for Linux users where features differ or are unavailable.
- Ensure screenshots and walkthroughs show both Windows and Linux scenarios where applicable.
Azure Functions
Quickstart: Create a Durable Functions app that uses the MSSQL storage provider
...n/articles/azure-functions/durable/quickstart-mssql.md
Medium Priority
View Details →
Detected Bias Types
powershell_heavy
windows_first
missing_linux_example
Summary
The documentation demonstrates a notable Windows/PowerShell bias, especially in the local SQL Server setup section. All Docker setup commands are provided only in PowerShell, and there are no equivalent Bash or shell script examples for Linux/macOS users. The text references installing PowerShell on all platforms, but this is not the native or most common shell for Linux/macOS users. Additionally, the order and language of instructions frequently assume a Windows/PowerShell context first, with Linux alternatives as an afterthought or omitted.
Recommendations
- Provide equivalent Bash/shell script examples for Docker-based SQL Server setup, including database creation and validation, alongside the PowerShell examples.
- Explicitly show how to run the Docker and sqlcmd commands in a native Linux/macOS terminal (e.g., using bash variables and syntax).
- Clarify that PowerShell is not required on Linux/macOS and that all steps can be performed in Bash or zsh.
- When referencing tools or commands (e.g., Visual Studio Code, Docker), note any platform-specific differences or prerequisites.
- In all code blocks, provide both PowerShell and Bash versions where applicable, or use a more platform-agnostic approach.
Azure Functions
Deployment technologies in Azure Functions
...s/azure-functions/functions-deployment-technologies.md
Medium Priority
View Details →
Detected Bias Types
windows_first
powershell_heavy
Summary
The documentation provides deployment guidance for Azure Functions across multiple platforms, but Windows-centric tools (Visual Studio, Azure CLI, references to Kudu/scm) are often mentioned first or exclusively in example lists. Linux-specific guidance is present, but Windows tools and terminology (e.g., Visual Studio, Kudu, 'Windows-only' deployment options) are prioritized or explained in greater detail. Some deployment technologies (FTPS, Local Git, Source Control) are noted as 'Windows-only' without Linux alternatives or workarounds being clearly described.
Recommendations
- Ensure Linux/macOS equivalents are always mentioned alongside Windows tools, especially in example lists and 'How to use it' sections.
- Provide explicit Linux/macOS command-line examples (e.g., Bash, Core Tools usage) where only Windows/PowerShell or Visual Studio are referenced.
- Clarify when a deployment method is Windows-only and offer alternative Linux/macOS approaches or links to relevant Linux documentation.
- Consider reordering example lists so that cross-platform tools (e.g., Azure Functions Core Tools, Azure CLI) are mentioned before Windows-specific tools.
- Add more detail on Linux-specific deployment behaviors and troubleshooting, especially for methods marked 'Windows-only'.
Azure Functions
Migrate C# app from in-process to isolated worker model
...es/azure-functions/migrate-dotnet-to-isolated-model.md
Medium Priority
View Details →
Detected Bias Types
powershell_heavy
windows_first
Summary
The documentation provides only Azure PowerShell scripts for identifying function apps to migrate, without offering equivalent Azure CLI or Bash examples. PowerShell is primarily used on Windows, and presenting it as the sole option creates friction for Linux/macOS users. Additionally, PowerShell instructions are given first and exclusively, reinforcing a Windows-first bias.
Recommendations
- Add Azure CLI (az) examples alongside PowerShell scripts for identifying function apps to migrate.
- Explicitly mention that either PowerShell or Azure CLI can be used, and provide guidance for both environments.
- Where possible, provide Bash shell script examples for steps that involve scripting or automation.
- Ensure that instructions for updating app settings, deploying, and managing slots reference cross-platform tools (e.g., Azure CLI, VS Code) in addition to Visual Studio and PowerShell.
Application Gateway
Troubleshoot Application Gateway for Containers
...cation-gateway/for-containers/troubleshooting-guide.md
Low Priority
View Details →
Detected Bias Types
windows_first
Summary
The documentation provides both Linux and Windows command examples for filtering logs, but the Linux example is presented first, followed by the Windows example. All other instructions and examples use cross-platform tools (kubectl, helm) and are not Windows-specific. No sections are Windows-only or missing Linux/macOS equivalents.
Recommendations
- Maintain parity by always providing both Linux and Windows examples where OS-specific commands differ.
- Consider using tabbed sections or clear headings for OS-specific commands, as already done, to improve clarity.
- If possible, mention that most commands are cross-platform and only filtering/log parsing differs.
Azure Functions
Guide for running C# Azure Functions in an isolated worker process
...icles/azure-functions/dotnet-isolated-process-guide.md
Low Priority
View Details →
Detected Bias Types
windows_first
windows_tools
powershell_heavy
Summary
The documentation provides a generally cross-platform guide for running C# Azure Functions in an isolated worker process, but there are several areas where Windows tools, patterns, and examples are mentioned first or exclusively. Windows-specific instructions (such as PowerShell and Visual Studio) are often listed before Linux equivalents, and some CLI commands are presented in a Windows-centric manner. While Linux is supported and referenced, Windows approaches are sometimes prioritized or explained in greater detail.
Recommendations
- Ensure that Linux and macOS equivalents are always presented alongside Windows instructions, especially in sections about deployment, debugging, and performance optimizations.
- When listing tools or methods (e.g., Visual Studio, Azure CLI, PowerShell), alternate the order or explicitly state cross-platform applicability.
- Add more explicit Linux/macOS examples for CLI commands, file paths, and environment variable configuration.
- Where PowerShell is referenced, provide Bash or shell equivalents.
- Clarify any platform-specific limitations or differences, and link to Linux/macOS-specific guides where appropriate.
Low Priority
View Details →
Detected Bias Types
powershell_heavy
windows_first
Summary
The documentation provides Azure CLI examples for both Bash and PowerShell, but the PowerShell (Windows) examples are given immediately after Bash in every step, and are labeled 'Formatted for PowerShell'. There is no explicit Linux/macOS bias, but the presence of PowerShell examples throughout and the order in which they are presented (always Bash first, then PowerShell) suggests a mild Windows bias. However, Bash examples are present and usable for Linux/macOS users.
Recommendations
- Clarify that Bash examples are suitable for Linux/macOS users and PowerShell for Windows users.
- Consider adding a note at the top of the CLI section indicating which shell is appropriate for each platform.
- Ensure parity by verifying that all Bash commands work as expected on Linux/macOS.
- Optionally, use tabbed code blocks labeled 'Bash (Linux/macOS)' and 'PowerShell (Windows)' for clearer distinction.
Low Priority
View Details →
Detected Bias Types
powershell_heavy
windows_first
Summary
The documentation provides both Bash and PowerShell examples for Azure CLI commands, but PowerShell examples are given for every step and are formatted with Windows-specific syntax. Bash examples are present, but PowerShell versions are shown immediately after, suggesting parity but also a slight Windows-first bias. There are no missing Linux examples, but the PowerShell formatting and variable usage may create friction for Linux/macOS users.
Recommendations
- Clearly label Bash and PowerShell sections, possibly using tabs or headings for each platform.
- Ensure Bash examples are shown first, or alternate the order to avoid Windows-first bias.
- Add brief notes clarifying which example is for which OS/shell.
- Consider including macOS-specific notes if there are any platform differences.
- Review variable usage and syntax to ensure Bash examples are fully compatible with Linux/macOS environments.
API Management
Deploy an Azure API Management Instance to Multiple Azure Regions
...management/api-management-howto-deploy-multi-region.md
Low Priority
View Details →
Detected Bias Types
windows_first
powershell_heavy
Summary
The documentation primarily uses Azure portal and Azure CLI examples, but in the section about disabling routing to a regional gateway, it mentions Azure PowerShell cmdlets alongside Azure CLI and REST API. The PowerShell tool is referenced before Linux-native equivalents, and no explicit Linux/macOS-specific guidance or examples are provided. However, the CLI and REST API examples are cross-platform, and the overall workflow is not Windows-specific.
Recommendations
- Ensure that Azure CLI examples are presented before PowerShell examples, as CLI is cross-platform.
- Explicitly mention that Azure CLI and REST API commands work on Linux/macOS, and provide any relevant shell syntax tips if needed.
- If PowerShell is referenced, clarify that Azure PowerShell is available on Linux/macOS, or provide Bash alternatives where appropriate.
- Add a note that all steps can be completed on Linux/macOS unless there is a Windows-only requirement.
App Service
Configure gateway-required virtual network integration for your app
...service/configure-gateway-required-vnet-integration.md
Low Priority
View Details →
Detected Bias Types
windows_only_feature
Summary
The documentation is intentionally focused on a Windows-only feature: gateway-required virtual network integration for Azure App Service. The page explicitly states that this integration only works for Windows plans and cannot be used from a Linux app. All examples, instructions, and troubleshooting steps are therefore Windows-centric by design.
Recommendations
- No changes needed for Linux parity, as the feature is not available for Linux apps.
- Consider adding a prominent note at the top clarifying that Linux users must use regional virtual network integration, with a direct link to relevant Linux-compatible documentation.
App Service
Install a TLS/SSL Certificate for Your App
...main/articles/app-service/configure-ssl-certificate.md
Low Priority
View Details →
Detected Bias Types
windows_tools
windows_first
powershell_heavy
Summary
The documentation provides both Azure CLI and Azure PowerShell examples for RBAC permissions, but PowerShell is featured equally and sometimes before Linux-native tools. Windows-specific certificate tools (IIS, Certreq.exe) are mentioned for certificate export, while Linux/OpenSSL instructions are present but not always prioritized. Some automation links reference PowerShell scripts alongside CLI, but Linux equivalents are not always given first. Overall, Linux users can complete all tasks, but Windows tools and patterns are referenced frequently and sometimes before Linux alternatives.
Recommendations
- When listing automation options, consistently show Azure CLI (cross-platform) examples before PowerShell.
- For certificate export, prioritize OpenSSL instructions and clarify that IIS/Certreq.exe are Windows-only.
- Add explicit notes or links for Linux/macOS users where Windows tools are referenced.
- Ensure screenshots and UI instructions are OS-neutral or clarify if any steps differ for Linux-hosted apps.
- Consider adding a section summarizing Linux/macOS certificate management best practices for Azure App Service.
App Service
Migrate from gateway-based to regional virtual network integration
.../app-service/migrate-gateway-based-vnet-integration.md
Low Priority
View Details →
Detected Bias Types
windows_first
powershell_heavy
Summary
The documentation provides example commands for Azure portal, Azure CLI, and Azure PowerShell in all procedural sections. While Azure CLI is cross-platform, Azure PowerShell is primarily used on Windows and is presented alongside CLI examples. In several places, PowerShell examples are given equal prominence to CLI, and the tab order is 'portal', 'cli', 'powershell', which may subtly prioritize Windows tools. However, Linux/macOS users are fully supported via Azure CLI, and no critical steps are Windows-only. There are no missing Linux examples, and no exclusive mention of Windows tools or patterns.
Recommendations
- Consider listing Azure CLI examples before Azure PowerShell to reinforce cross-platform parity.
- Explicitly note that Azure CLI is recommended for Linux/macOS users and that PowerShell is optional.
- If possible, clarify that all CLI steps are fully supported on Linux/macOS.
- Add a brief statement in the prerequisites or migration steps indicating that all procedures can be completed from Linux/macOS using Azure CLI.
Application Gateway
Quickstart: Deploy Application Gateway for Containers ALB Controller - Helm
...application-gateway-for-containers-alb-controller-helm.md
Low Priority
View Details →
Detected Bias Types
windows_first
powershell_heavy
windows_tools
Summary
The documentation provides both Azure CLI and Azure PowerShell examples throughout, but PowerShell is featured equally and sometimes first, and Windows-specific tooling (winget) is mentioned for Helm installation. While Linux examples are present, Windows tools and patterns are referenced prominently, and PowerShell is given parity with Azure CLI rather than Bash. The Helm installation section gives Windows instructions first, and only briefly notes Linux installation. There are no Bash-only or Linux-first examples, and PowerShell is used for resource management tasks that could be done with Bash/Azure CLI. However, Linux users can complete all tasks, and the Azure CLI is cross-platform.
Recommendations
- Provide Bash examples alongside Azure CLI for Linux/macOS users, especially for scripting and environment setup.
- In the Helm installation section, list Linux installation instructions before Windows, or present both equally.
- Mention package managers for Linux (apt, yum, snap) for Helm installation, not just curl.
- Clarify that Azure CLI commands can be run in Bash or PowerShell, and provide Bash syntax where relevant.
- Consider reducing PowerShell-specific examples unless they offer unique functionality not available in Azure CLI.
- Ensure all steps can be completed with Azure CLI/Bash on Linux/macOS, and highlight cross-platform compatibility.
Azure Cache For Redis
Deploy Azure Cache for Redis using Bicep
...s/azure-cache-for-redis/redis-cache-bicep-provision.md
Low Priority
View Details →
Detected Bias Types
powershell_heavy
windows_first
Summary
The documentation provides both Azure CLI and Azure PowerShell examples for deploying and managing Azure Cache for Redis using Bicep. However, PowerShell examples are included throughout, which are primarily relevant to Windows users. The CLI examples are present and shown first in each section, but there is no explicit mention of Linux/macOS compatibility or shell-specific guidance. There are no Linux-specific tools or patterns referenced, and the documentation does not mention Bash or shell scripting, nor does it clarify that Azure CLI works cross-platform.
Recommendations
- Explicitly state that Azure CLI commands work on Linux, macOS, and Windows, and recommend it as the preferred cross-platform tool.
- Add notes or sections clarifying that PowerShell is primarily for Windows users, while Azure CLI is suitable for Linux/macOS.
- Consider including Bash shell scripting examples or references for Linux users, especially for automation scenarios.
- Add a brief mention of how to install Azure CLI on Linux/macOS, or link to relevant installation guides.
Azure Cache For Redis
Azure Cache for Redis with Azure Private Link
...n/articles/azure-cache-for-redis/cache-private-link.md
Low Priority
View Details →
Detected Bias Types
windows_first
powershell_heavy
Summary
The documentation provides step-by-step instructions using the Azure Portal UI, Azure PowerShell, and Azure CLI. The PowerShell section is presented before the Azure CLI section, and PowerShell is a Windows-centric tool, which may create a perception of Windows preference. However, the CLI section is present and complete, and the portal instructions are platform-agnostic. No critical steps are Windows-only, and Linux/macOS users can complete all tasks using the Azure CLI.
Recommendations
- Present Azure CLI examples before PowerShell examples, as CLI is cross-platform and more accessible to Linux/macOS users.
- Explicitly mention that Azure CLI commands work on Windows, Linux, and macOS.
- Where possible, clarify that PowerShell Core is available cross-platform, or link to documentation for installing PowerShell on Linux/macOS.
- Consider adding a short note at the start of the scripting sections to help users choose between CLI and PowerShell based on their OS.
Azure Functions
App settings reference for Azure Functions
...ain/articles/azure-functions/functions-app-settings.md
Low Priority
View Details →
Detected Bias Types
windows_first
windows_tools
Summary
The documentation is generally cross-platform and covers both Windows and Linux scenarios for Azure Functions app settings. However, there are minor instances of Windows bias: Windows-specific syntax (e.g., %HOME% in AzureWebJobs_TypeScriptPath) is used without a Linux equivalent, and Windows-only settings (e.g., WEBSITE_NODE_DEFAULT_VERSION) are described before Linux alternatives. Azure CLI and PowerShell are mentioned as preferred tools for managing settings, but Linux-native tools (e.g., Bash) are not referenced. Overall, Linux parity is strong, but minor improvements could be made.
Recommendations
- For settings with OS-specific syntax (e.g., AzureWebJobs_TypeScriptPath), provide both Windows and Linux examples.
- When mentioning Windows-only settings (e.g., WEBSITE_NODE_DEFAULT_VERSION), explicitly state Linux alternatives or link to relevant Linux documentation.
- When recommending Azure CLI or PowerShell for managing settings, also mention Bash or other Linux-native scripting tools.
- Review the order of examples and settings to ensure Linux and Windows are treated equally (e.g., in WEBSITE_TIME_ZONE, Linux is listed second; consider listing both together or alternating order).
Azure Functions
Azure Functions networking options
...ticles/azure-functions/functions-networking-options.md
Low Priority
View Details →
Detected Bias Types
powershell_heavy
windows_first
Summary
The documentation provides both Azure CLI and PowerShell examples for configuring virtual network triggers, but the PowerShell example is given equal prominence and detail. The Hybrid Connections feature is explicitly Windows-only, but this is clearly stated and justified. In the automation section, only Azure CLI and ARM template examples are provided, which are cross-platform. Throughout the page, there is no evidence of Windows-only tools or patterns being mentioned exclusively or before Linux equivalents, but the PowerShell example is present alongside CLI. The subnet sizing recommendations for Windows and Linux are clearly differentiated, with Linux guidance provided. Overall, minor bias is present due to the inclusion of PowerShell examples and Windows-first language in some sections, but Linux parity is generally maintained.
Recommendations
- Where PowerShell examples are given, ensure that equivalent Azure CLI examples are always provided and shown first, as CLI is cross-platform.
- Consider adding bash or Linux-specific scripting examples where relevant, especially in automation sections.
- Continue to clearly indicate Windows-only features (such as Hybrid Connections) to avoid confusion.
- Review the order of examples to ensure CLI (cross-platform) is prioritized over PowerShell (Windows-centric).
Azure Functions
Migrate Consumption plan apps to Flex Consumption in Azure Functions
...unctions/migration/migrate-plan-consumption-to-flex.md
Low Priority
View Details →
Detected Bias Types
windows_first
Summary
The documentation provides parallel, detailed instructions for both Linux and Windows users throughout, with clear pivots and tabs for each platform. However, in several sections (notably the 'Assess your existing app' and 'Migration Steps'), the Windows/portal/CLI instructions are presented before the Linux equivalents, and some advanced configuration scripts and troubleshooting steps are more detailed for Windows. There are no missing Linux examples, and Linux-specific migration tooling (such as the az functionapp flex-migration CLI) is highlighted. No critical steps are Windows-only, and Linux users can complete the migration end-to-end.
Recommendations
- Where possible, present Linux and Windows instructions in parallel or alternate which platform appears first in each section to avoid implicit prioritization.
- Ensure that advanced troubleshooting and configuration examples are equally detailed for both platforms.
- Continue to clearly mark platform-specific features and tools, and maintain parity in depth and clarity of examples.
Azure Functions
Troubleshoot Python function apps in Azure Functions
...n/articles/azure-functions/recover-python-functions.md
Low Priority
View Details →
Detected Bias Types
windows_first
powershell_heavy
windows_tools
Summary
The documentation generally maintains good cross-platform coverage, but there are several instances where Windows tools, commands, or patterns are presented before their Linux equivalents, or with more detail. In some troubleshooting sections, PowerShell and Windows command-line examples are given first, and Windows-specific tools (like 'py') are referenced before Unix equivalents. However, Linux/macOS guidance is present throughout, and critical tasks are not Windows-only.
Recommendations
- When providing command-line examples, present Linux/macOS (bash) and Windows (PowerShell/cmd) examples side-by-side or in parallel tabs, rather than listing Windows first.
- When referencing tools like 'py' (Windows Python launcher), clarify that 'python3' is the equivalent on Linux/macOS, and consider listing 'python3' first since Azure Functions runs on Linux.
- In sections where PowerShell or Windows commands are given, ensure bash/Linux equivalents are always present and not secondary.
- Where possible, use neutral language and avoid implying Windows as the default development environment, especially since Azure Functions Python apps run on Linux.
- Review all code snippets and instructions to ensure Linux/macOS users are equally supported and not required to infer their own equivalents.
Azure Functions
How to target Azure Functions runtime versions
...b/main/articles/azure-functions/set-runtime-version.md
Low Priority
View Details →
Detected Bias Types
windows_first
powershell_heavy
Summary
The documentation provides both Windows and Linux guidance, but Windows/PowerShell examples are often presented first or alongside Azure CLI, while Linux-specific instructions are separated and sometimes less prominent. Azure PowerShell is given as a primary option for viewing and updating settings, even though it is not supported for some Linux-specific tasks. Linux instructions rely more heavily on Azure CLI and are sometimes described as requiring support intervention for advanced scenarios.
Recommendations
- Ensure Linux examples are presented with equal prominence and clarity as Windows/PowerShell examples.
- Where possible, provide Linux-specific instructions alongside Windows instructions, rather than in separate sections or pivots.
- Clarify when Azure PowerShell is not supported for Linux apps, and offer alternative CLI or scripting solutions.
- Add more explicit Linux portal instructions if available, or clarify portal limitations for Linux users.
- Consider showing Azure CLI examples first, as it is cross-platform, before PowerShell examples.
Azure Functions
Storage considerations for Azure Functions
...ain/articles/azure-functions/storage-considerations.md
Low Priority
View Details →
Detected Bias Types
windows_first
powershell_heavy
Summary
The documentation generally covers storage considerations for Azure Functions across platforms, but there are minor signs of Windows bias. Windows-specific plans and settings are mentioned before Linux equivalents in several places, and PowerShell examples are provided alongside Azure CLI, sometimes with Windows-focused language. However, Linux-specific guidance is also present, especially in the section about mounting file shares, which is clearly marked as Linux-only.
Recommendations
- Ensure that Linux and macOS examples are provided wherever Windows/PowerShell examples are given, especially in sections about configuration and deployment.
- When describing settings or plans, avoid listing Windows options first unless there is a technical reason.
- Clarify parity between Windows and Linux for features like Azure Files, deployment settings, and scaling, and explicitly note any limitations or differences.
- Where PowerShell is mentioned, also provide Bash or CLI equivalents for Linux/macOS users.
- Consider adding a summary table or section highlighting feature parity and platform-specific limitations.