248
Pages Scanned
48
Pages Flagged
248
Changed Pages
19.4%
% Pages Flagged
Scan Information
Started At: 2026-02-01 00:00:10
Finished At: 2026-02-10 18:44:36
Status: completed
Target Repo: Azure
Current Phase: discovery
Files Queued: 248
Files Completed: 248
Problematic Pages
48 issues found
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_first
powershell_heavy
windows_tools
missing_linux_example
Summary
The documentation is heavily Windows-centric, especially in the SignTool integration section. All setup instructions, prerequisites, and examples are for Windows environments, using Windows-specific tools (SignTool.exe, MSI installers, WinGet, PowerShell). There are no Linux/macOS equivalents or alternative signing tool instructions provided. Other integrations (GitHub Actions, Azure DevOps, SDK) are mentioned but not documented in detail here.
Recommendations
- Add explicit guidance for Linux/macOS users, including supported signing tools and setup instructions.
- If SignTool is Windows-only, clarify its platform limitations and direct Linux/macOS users to alternative integrations (e.g., SDK, GitHub Actions).
- Provide step-by-step examples for setting up Artifact Signing with GitHub Actions, Azure DevOps, and the SDK, including Linux/macOS runners.
- List platform compatibility for each integration at the top of the article.
- Where possible, offer cross-platform installation instructions (e.g., .NET runtime, SDK usage).
Create Pull Request
Azure Relay
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-relay/includes/relay-hybrid-connections-dotnet-get-started-server.md
...https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-relay/includes/relay-hybrid-connections-dotnet-get-started-server.md
High Priority
View Details →
Detected Bias Types
windows_first
missing_linux_example
Summary
The documentation instructs users to create a Console App (.NET Framework) project in Visual Studio, which is only available on Windows. All instructions and examples assume the use of Visual Studio and .NET Framework, with no mention of cross-platform alternatives (such as .NET Core/.NET 5+ or Visual Studio Code). There are no Linux/macOS-specific instructions or examples provided.
Recommendations
- Add instructions for creating a cross-platform .NET project (e.g., .NET Core or .NET 5+) using the 'dotnet' CLI, which works on Linux and macOS.
- Include examples for using Visual Studio Code or JetBrains Rider, which are available on Linux/macOS.
- Clarify whether the Microsoft.Azure.Relay SDK and Hybrid Connections are supported on non-Windows platforms, and provide guidance for those environments if so.
- If .NET Framework is required and the feature is Windows-only, explicitly state this limitation at the beginning of the documentation.
Medium Priority
View Details →
Detected Bias Types
windows_tools
powershell_heavy
windows_first
Summary
The documentation page provides both Windows and Linux guidance for TLS upgrades, but consistently references Windows tools (PowerShell cmdlets) for resource management and backup tasks. Examples and instructions for exporting or managing resources (runbooks, DSC nodes, configurations) are almost exclusively given using Windows PowerShell cmdlets, with no Linux or cross-platform CLI alternatives. Windows registry settings and links are presented before Linux equivalents in some sections.
Recommendations
- Include Azure CLI and/or REST API examples for resource management tasks (e.g., exporting runbooks, managing DSC nodes) alongside PowerShell cmdlets.
- Provide Linux/macOS-specific instructions or scripts for backup and export operations, not just Windows PowerShell.
- Where possible, mention cross-platform tools (e.g., Azure CLI, Python SDK) before or alongside Windows-specific tools.
- Balance the order of presentation so Linux guidance is not consistently secondary to Windows instructions.
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 is heavily focused on PowerShell and Windows-centric tools and patterns. All code examples use PowerShell, and references to credential handling and module installation are exclusively in the context of PowerShell and Windows. There are no examples or guidance for Linux/macOS users (e.g., Bash, Azure CLI, Python SDK), nor is there mention of how to perform these tasks outside of PowerShell. The use of terms like 'Windows PowerShell' and reliance on PSCredential and PowerShell cmdlets further reinforce the Windows bias.
Recommendations
- Add equivalent examples using Azure CLI, Bash, or Python for Linux/macOS users.
- Clarify whether Azure Automation runbooks can be authored in languages other than PowerShell and provide links or examples if so.
- Mention cross-platform alternatives for credential management and authentication (e.g., Azure CLI's az login with service principal).
- Explicitly state any limitations or requirements for PowerShell/Windows if they exist, or highlight cross-platform support if available.
Azure Relay
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-relay/includes/relay-hybrid-connections-dotnet-get-started-client.md
...https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-relay/includes/relay-hybrid-connections-dotnet-get-started-client.md
Medium Priority
View Details →
Detected Bias Types
windows_first
missing_linux_example
Summary
The documentation exclusively describes creating a .NET Framework console application in Visual Studio, a Windows-only workflow. There are no instructions or examples for Linux/macOS users (e.g., using .NET Core/.NET 5+ with VS Code or CLI tools). The NuGet package installation steps are also Visual Studio-centric, omitting cross-platform alternatives.
Recommendations
- Add instructions for creating a .NET Core/.NET 5+ console application using the dotnet CLI, which works on Linux/macOS.
- Include NuGet package installation steps using the dotnet CLI (e.g., 'dotnet add package Microsoft.Azure.Relay').
- Mention that the sample code works with .NET Core/.NET 5+ and can be run on Linux/macOS, not just Windows.
- Provide alternative development environment suggestions (e.g., VS Code, JetBrains Rider) for non-Windows users.
Azure Relay
Hybrid Connections - HTTP requests in .NET
...ay-hybrid-connections-http-requests-dotnet-get-started.md
Medium Priority
View Details →
Detected Bias Types
windows_first
missing_linux_example
Summary
The tutorial assumes use of Visual Studio and .NET on Windows, with all examples and instructions referencing Visual Studio and C# console applications. There is no mention of cross-platform development tools (e.g., VS Code, CLI) or guidance for Linux/macOS users, despite .NET Core/.NET 5+ being cross-platform.
Recommendations
- Add instructions for creating and running the .NET applications using cross-platform tools like Visual Studio Code or the .NET CLI.
- Clarify that the tutorial works on Linux/macOS as well as Windows, and provide any necessary platform-specific notes (e.g., how to install .NET SDK, run console apps).
- Include example commands for building and running the applications on Linux/macOS terminals.
- Mention alternative editors for non-Windows users.
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 page provides detailed, step-by-step code examples for accessing TLS/SSL certificates in Windows environments (including Windows apps and containers), using Windows certificate store APIs and Java's Windows-MY keystore. In contrast, Linux guidance is limited: Linux-specific code samples are only provided for C#, and other languages (Node.js, PHP, Python, Java) are referenced generically with no examples. Windows tools and patterns (certificate store, thumbprint usage, environment variables) are described first and in more detail, while Linux equivalents are mentioned later and with less depth.
Recommendations
- Add explicit code examples for loading certificates in Linux environments for popular languages (Node.js, Python, Java, PHP), not just C#.
- Present Linux and Windows guidance in parallel, or use tabs to avoid Windows-first ordering bias.
- Expand Linux-specific instructions, including how to handle certificate permissions, file formats, and environment variables.
- Reference Linux tools (such as OpenSSL, keytool, etc.) where appropriate, alongside Windows tools.
- Clarify any differences in certificate handling between Windows and Linux, especially for container scenarios.
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
missing_linux_example
Summary
The documentation page provides comprehensive coverage of environment variables and app settings for Azure App Service, but there is a noticeable Windows bias. Many examples and descriptions reference Windows paths (e.g., D:\home), Windows-specific tools (e.g., msbuild, Web Deploy/MSDeploy), and Windows conventions before Linux equivalents. Several environment variables and settings are described primarily in the context of Windows, with Linux details often appearing as secondary notes or omitted. Some sections (e.g., build automation, logging, TLS/SSL paths) focus on Windows tools and patterns, with Linux alternatives given less prominence or missing entirely.
Recommendations
- Ensure Linux and macOS examples are provided alongside Windows examples, especially for environment variable paths, deployment, and logging.
- Present Linux and Windows instructions in parallel, or use tabs to separate platform-specific guidance, rather than listing Windows first.
- Where Windows tools (e.g., msbuild, Web Deploy/MSDeploy) are mentioned, include Linux-native alternatives (e.g., Oryx, zip deploy, relevant CLI commands) and clarify platform applicability.
- Expand documentation of Linux-specific environment variables and behaviors, especially for logging, TLS/SSL, and build automation.
- Review all examples and default values to ensure Linux paths (e.g., /home/site/wwwroot) are shown as often as Windows paths (e.g., D:\home\site\wwwroot).
Application Gateway
Tutorial: Improve web application access - Azure Application Gateway
.../articles/application-gateway/tutorial-autoscale-ps.md
Medium Priority
View Details →
Detected Bias Types
powershell_heavy
missing_linux_example
windows_tools
Summary
The tutorial exclusively uses Azure PowerShell and Windows PowerShell cmdlets for all steps, including certificate creation, resource management, and file paths. There are no Bash, Azure CLI, or Linux/macOS-specific instructions or examples. Windows tools (e.g., New-SelfSignedCertificate, Export-PfxCertificate) are used for certificate creation, which are not available on Linux/macOS by default.
Recommendations
- Provide equivalent Azure CLI (az) commands for all resource creation and management steps.
- Include instructions for creating self-signed certificates on Linux/macOS (e.g., using OpenSSL) and exporting them to PFX format.
- Use platform-neutral file paths in examples, or note differences for Linux/macOS.
- Add a section clarifying cross-platform options and limitations, with links to relevant Linux/macOS documentation.
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 includes a 'Next steps' section that links to a tutorial for creating an autoscaling, zone redundant application gateway using Azure PowerShell, but does not provide equivalent guidance or links for Linux/macOS users (e.g., Azure CLI or ARM templates). The only example for creating the gateway is PowerShell-focused, which is most commonly used on Windows.
Recommendations
- Add equivalent tutorials or links for creating autoscaling, zone redundant application gateways using Azure CLI and ARM templates.
- Ensure that examples and walkthroughs are provided for both PowerShell and CLI, and consider listing CLI examples first or side-by-side to avoid implicit Windows-first bias.
- Explicitly mention cross-platform options for management (e.g., Azure CLI, REST API) in relevant sections.
Medium Priority
View Details →
Detected Bias Types
powershell_heavy
windows_first
missing_linux_example
Summary
The documentation provides explicit instructions for enabling diagnostic logging via PowerShell, but does not offer equivalent examples for Azure CLI, Bash, or other cross-platform tools. PowerShell is Windows-centric, and its use is presented before any mention of platform-neutral alternatives. There are no Linux/macOS-specific instructions or CLI examples, which may create friction for non-Windows users.
Recommendations
- Add equivalent Azure CLI examples for enabling diagnostic logging, as Azure CLI is cross-platform and widely used on Linux/macOS.
- Clarify that PowerShell is one option and provide links or inline instructions for Bash/CLI users.
- Consider including sample scripts for log retrieval and analysis using platform-neutral tools (e.g., jq, awk, Azure CLI).
- Mention that the Azure portal is accessible from any OS and highlight its parity.
- If referencing log converter tools, note their compatibility or alternatives for Linux/macOS users.
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
Summary
The documentation is heavily focused on Azure PowerShell scripts for migration, with all examples, instructions, and downloadable tools provided exclusively in PowerShell. There are no Bash, Azure CLI, or Linux/macOS shell equivalents or guidance. The installation and usage instructions assume a Windows/PowerShell environment and do not address how Linux/macOS users can perform the migration or run the scripts.
Recommendations
- Provide equivalent migration instructions and scripts using Azure CLI and/or Bash for Linux/macOS users.
- Explicitly document how to run the PowerShell scripts in cross-platform environments, such as via PowerShell Core (pwsh) on Linux/macOS, including prerequisites and troubleshooting tips.
- Add examples for Azure CLI commands to retrieve resource IDs and manage certificates, as alternatives to PowerShell.
- Clarify whether the provided scripts are compatible with PowerShell Core and, if so, include installation and usage steps for Linux/macOS.
- If some migration steps are only possible via PowerShell, state this explicitly and provide guidance for Linux/macOS users (e.g., using Azure Cloud Shell, which supports PowerShell in-browser).
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
missing_linux_example
Summary
The documentation page for Azure Application Gateway v2 shows a moderate Windows/PowerShell bias. Migration guidance and preview registration/unregistration instructions are provided exclusively using Azure PowerShell commands, with no equivalent Azure CLI (bash) or REST API examples. The main tutorial link points to a PowerShell-based workflow. This creates friction for Linux/macOS users who may prefer bash/CLI or other cross-platform tools.
Recommendations
- Add Azure CLI (bash) examples alongside PowerShell for migration and preview registration/unregistration steps.
- Provide REST API or ARM template alternatives for key operations.
- Ensure tutorial links include both PowerShell and Azure CLI workflows.
- Explicitly mention that all commands can be run from Azure Cloud Shell (which supports both bash and PowerShell), and clarify platform-neutral options.
Medium Priority
View Details →
Detected Bias Types
powershell_heavy
missing_linux_example
windows_tools
Summary
The documentation repeatedly references an Azure PowerShell script as the primary or sole migration tool, without mentioning Azure CLI, Bash, or cross-platform alternatives. There are no Linux/macOS-specific instructions or examples, and the PowerShell script is referenced as the default approach for migration tasks.
Recommendations
- Provide equivalent Azure CLI commands or scripts for migration tasks, or clarify if only PowerShell is supported.
- Explicitly state platform compatibility for the PowerShell script (e.g., if it works with PowerShell Core on Linux/macOS).
- Add Linux/macOS usage examples or troubleshooting notes for non-Windows users.
- If PowerShell is the only supported method, clarify this and provide installation guidance for PowerShell Core on Linux/macOS.
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_first
Summary
The documentation for disaster recovery in Azure Automation is heavily focused on PowerShell scripts and workflows, with no mention of Bash, Python, or other Linux-native scripting options for asset migration. All migration examples and instructions are PowerShell-based, and tabs for installation and Hybrid Runbook Worker management default to Windows, even though Linux is supported. This creates friction for Linux/macOS users who may not use PowerShell as their primary automation tool.
Recommendations
- Provide equivalent Bash or Python scripts for asset migration between Automation accounts, or clarify if PowerShell is required regardless of OS.
- Include Linux/macOS-specific instructions and examples for tasks such as Hybrid Runbook Worker installation and management.
- Add notes or guidance for Linux users on how to run PowerShell scripts (e.g., via PowerShell Core on Linux/macOS), or offer alternative approaches.
- Ensure that tabs and examples are presented in a neutral order (e.g., 'Windows | Linux') and that Linux instructions are not secondary.
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
missing_linux_example
windows_first
Summary
The documentation is heavily focused on PowerShell and Windows-centric tooling, with nearly all code examples and workflows using PowerShell cmdlets or C# SDKs. There is minimal coverage of Linux/macOS command-line usage, and no examples are provided for starting runbooks from Bash, Azure CLI, or non-Windows environments. The only non-PowerShell runbook type discussed is Python, but even there, examples for starting or managing Python runbooks from Linux/macOS are absent. The REST API is mentioned, but no cross-platform command-line examples (e.g., using curl or az CLI) are given. This creates friction for Linux/macOS users and those who prefer Azure CLI over PowerShell.
Recommendations
- Add Azure CLI examples for starting runbooks and passing parameters, including az automation runbook commands.
- Provide Bash/curl examples for invoking the REST API to start runbooks and pass parameters.
- Clarify that PowerShell cmdlets can be used cross-platform, but also provide explicit instructions for Linux/macOS users (e.g., using PowerShell Core on Linux).
- Include at least one end-to-end example for managing Python runbooks from a Linux/macOS environment.
- Reorder sections or provide parallel examples so that Linux/macOS-friendly methods (Azure CLI, REST API with curl) are not always after PowerShell/Windows methods.
Automation
Manage credentials in Azure Automation
...in/articles/automation/shared-resources/credentials.md
Medium Priority
View Details →
Detected Bias Types
powershell_heavy
windows_tools
windows_first
Summary
The documentation page for managing credentials in Azure Automation is heavily focused on PowerShell and Windows-centric tooling. All CLI examples are in PowerShell, and references to cmdlets and objects (such as PSCredential) are specific to Windows/PowerShell environments. The creation of credential assets via CLI is only shown using Windows PowerShell, with no equivalent Bash, Azure CLI, or Linux shell examples. The documentation also lists PowerShell cmdlets first and in more detail, with Python examples present but less emphasized and no mention of Linux-native tools or workflows.
Recommendations
- Add equivalent examples for creating and managing credential assets using Azure CLI (az automation credential) or REST API, which are cross-platform.
- Clarify whether PowerShell Core (pwsh), which runs on Linux/macOS, is supported for these cmdlets, and provide examples if so.
- Explicitly mention Linux/macOS compatibility for Python runbooks and credential management.
- If graphical runbooks or portal actions are platform-agnostic, highlight this to reassure non-Windows users.
- Include a note or section for Linux/macOS users on how to manage credentials outside of PowerShell, if possible.
Automation
Manage certificates in Azure Automation
...n/articles/automation/shared-resources/certificates.md
Medium Priority
View Details →
Detected Bias Types
powershell_heavy
windows_first
missing_linux_example
Summary
The documentation page for managing certificates in Azure Automation is heavily focused on PowerShell, with all command-line examples using PowerShell cmdlets and no equivalent Bash, CLI, or Linux-native instructions. The portal workaround also recommends PowerShell specifically. While Python examples are provided for runbooks, there are no Linux shell or Azure CLI examples for certificate management tasks, and PowerShell is consistently presented first and in greater detail.
Recommendations
- Add Azure CLI examples for certificate management tasks (creating, retrieving, deleting certificates) to provide parity for Linux/macOS users.
- Include Bash or shell script examples for uploading and managing certificates where possible.
- Clarify which steps are platform-agnostic (e.g., Azure portal, Resource Manager templates) and which are Windows/PowerShell-specific.
- Present cross-platform options (PowerShell, CLI, Python) side-by-side or in tabs, rather than leading with PowerShell.
- Explicitly mention any limitations or differences for Linux/macOS users, such as the availability of PowerShell Core on non-Windows systems.
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
windows_tools
missing_linux_example
Summary
The documentation generally describes Azure Change Tracking and Inventory as supporting both Windows and Linux, with several sections explicitly mentioning both platforms. However, the 'Track registry keys' section is entirely Windows-specific, listing only Windows registry keys and providing no equivalent Linux configuration file or daemon tracking examples. Additionally, while file and service/daemon tracking are described as cross-platform, there are no Linux-specific examples or details (e.g., tracking /etc files, systemd units, or package managers). Windows terminology and tools (registry, Windows services) are mentioned in detail, while Linux equivalents are not discussed or are only referenced generically.
Recommendations
- Add Linux-specific examples for tracking configuration changes, such as monitoring changes to /etc/passwd, /etc/ssh/sshd_config, or systemd service files.
- Include a section or table similar to the registry key list, but for important Linux configuration files or directories commonly tracked (e.g., /etc, /var/log, /usr/lib/systemd/system).
- When describing features, provide parallel examples for both Windows and Linux (e.g., 'Track Windows registry keys or Linux configuration files').
- Clarify in the 'Track registry keys' section that this feature is Windows-only and suggest Linux alternatives if available.
- Where screenshots or UI references are made, ensure Linux VMs are shown or mentioned alongside Windows VMs.
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
missing_linux_example
Summary
The documentation page demonstrates a moderate Windows bias, primarily in the 'Identify function apps to migrate' section, where only Azure PowerShell is used to enumerate function apps. There are no CLI (az) or Bash examples, and PowerShell is presented as the default/only option for discovery. The rest of the guide is largely platform-neutral, focusing on C# code and project configuration, but the initial migration step may create friction for Linux/macOS users.
Recommendations
- Provide equivalent Azure CLI (az) commands for discovering function apps and their runtime configuration, alongside PowerShell examples.
- Explicitly mention that both Azure PowerShell and Azure CLI are supported, and link to cross-platform instructions.
- When scripting or automating, offer Bash or shell script examples for Linux/macOS users.
- Consider reordering or presenting CLI and PowerShell examples side-by-side, rather than PowerShell-only or PowerShell-first.
Azure Netapp Files
Azure NetApp Files for Azure Government
...b/main/articles/azure-netapp-files/azure-government.md
Medium Priority
View Details →
Detected Bias Types
powershell_heavy
windows_first
Summary
The documentation provides access instructions for Azure NetApp Files in Azure Government via Portal, Azure CLI, REST API, and PowerShell. While the CLI and REST API sections are platform-neutral, the PowerShell section is detailed and includes multiple connection types and commands, which may be more relevant for Windows users. The PowerShell section appears after CLI, but is more extensive and includes classic deployment models and Microsoft-specific tools. There are no explicit Linux/macOS examples or mentions of Bash, nor are there instructions for using Linux-native tools (other than Azure CLI).
Recommendations
- Add explicit examples for Linux/macOS users, such as using Bash or zsh with Azure CLI.
- Clarify that Azure CLI is cross-platform and works on Linux/macOS, and provide installation links for those platforms.
- If PowerShell is recommended for cross-platform use, mention PowerShell Core and provide instructions for installing and using it on Linux/macOS.
- Ensure parity in example depth: if PowerShell connection types are listed, consider listing equivalent CLI commands for classic and modern authentication scenarios.
Azure Netapp Files
Create an SMB volume for Azure NetApp Files
...-netapp-files/azure-netapp-files-create-volumes-smb.md
Medium Priority
View Details →
Detected Bias Types
windows_tools
missing_linux_example
powershell_heavy
Summary
The documentation is focused on creating and managing SMB volumes for Azure NetApp Files, which inherently involves Windows-centric technologies such as SMB, Active Directory, and NTFS permissions. However, the sections on managing permissions and share properties exclusively reference Windows tools (MMC, Windows SMB client) and do not provide equivalent instructions or examples for Linux/macOS users, despite SMB client support on those platforms. There are no Linux or macOS command-line examples for mounting or managing SMB shares, nor guidance for setting permissions from non-Windows clients.
Recommendations
- Add instructions or references for mounting SMB volumes from Linux and macOS clients using tools like 'mount.cifs' or 'smbclient'.
- Include examples of setting SMB permissions from Linux (e.g., using 'smbcacls' or 'setfacl' where applicable).
- Clarify which management tasks (such as modifying share permissions) must be performed from a Windows system, and which can be accomplished from Linux/macOS.
- Provide links to relevant Linux/macOS SMB client documentation or Azure guides.
- Consider a parity table or section outlining what is and is not supported from non-Windows clients.
Azure Netapp Files
Create volume replication for Azure NetApp Files
...etapp-files/cross-region-replication-create-peering.md
Medium Priority
View Details →
Detected Bias Types
powershell_heavy
windows_first
Summary
The documentation page provides feature registration instructions using Azure PowerShell cmdlets first, with only a brief mention that Azure CLI commands are also available. The PowerShell examples are shown explicitly, while CLI usage is referenced but not demonstrated. This ordering and example choice may create friction for Linux/macOS users who are more likely to use Azure CLI.
Recommendations
- Provide explicit Azure CLI command examples alongside PowerShell examples for feature registration and status checking.
- Present CLI and PowerShell examples in parallel or indicate which is recommended for cross-platform use.
- Clarify that both PowerShell and CLI are supported and provide links to relevant CLI documentation.
- Consider listing CLI examples first or equally to avoid implicit prioritization of Windows tooling.
Azure Netapp Files
Create a capacity pool for Elastic zone-redundant service in Azure NetApp Files
...icles/azure-netapp-files/elastic-capacity-pool-task.md
Medium Priority
View Details →
Detected Bias Types
powershell_heavy
windows_first
Summary
The documentation mentions PowerShell and the Az.NetAppFiles module as a primary tool for managing Azure NetApp Files, with explicit instructions to update the module and a link to PowerShell documentation. While Azure CLI and REST API are also referenced, PowerShell is singled out with more detail and a dedicated update command, suggesting a Windows-first approach. No Linux-specific tools or examples (such as Bash or shell scripting) are provided, and PowerShell is mentioned before REST API and CLI in the prerequisites.
Recommendations
- Provide equivalent instructions for updating and using Azure CLI for Linux/macOS users, including explicit commands and links to CLI documentation.
- Mention cross-platform compatibility of Azure CLI and clarify that all steps can be performed on Linux/macOS using CLI or REST API.
- Add examples or notes for Linux/macOS users, such as how to install/update Azure CLI and reference relevant documentation.
- Balance the order of tool mentions so that CLI and REST API are not always listed after PowerShell.
Azure Netapp Files
SMB performance best practices for Azure NetApp Files
...ure-netapp-files/azure-netapp-files-smb-performance.md
Medium Priority
View Details →
Detected Bias Types
windows_first
powershell_heavy
windows_tools
missing_linux_example
Summary
The documentation is heavily Windows-centric, with examples, commands, and tooling almost exclusively referencing Windows environments (e.g., PowerShell cmdlets, Windows Performance Monitor, Hyper-V adapters). There are no Linux or macOS SMB client examples, nor any mention of how to perform equivalent monitoring or configuration tasks on those platforms. While SMB is a cross-platform protocol, the guidance here assumes Windows clients and tools throughout.
Recommendations
- Include SMB client configuration and performance tuning examples for Linux (e.g., using mount.cifs, smbclient, or kernel parameters).
- Provide equivalent Linux commands for monitoring SMB connections and performance (such as using 'smbstatus', 'nload', 'iftop', or 'perf').
- Mention relevant Linux SMB client features (e.g., support for SMB Multichannel in recent kernels, how to enable/verify it).
- Add notes or sections clarifying differences in SMB client behavior and performance tuning between Windows and Linux/macOS.
- Where PowerShell or Windows-specific tools are referenced, offer Linux alternatives or explicitly state if no equivalent exists.
Azure Netapp Files
Troubleshoot volume errors for Azure NetApp Files
...in/articles/azure-netapp-files/troubleshoot-volumes.md
Medium Priority
View Details →
Detected Bias Types
windows_tools
powershell_heavy
windows_first
Summary
The documentation page covers troubleshooting for Azure NetApp Files volumes across SMB, NFS, and dual-protocol scenarios. While it is not Windows-only, several sections show Windows bias: PowerShell commands are provided for Kerberos encryption settings, and instructions reference Windows tools (Active Directory Users and Computers, Server Manager) without Linux/macOS equivalents. In some cases, Windows-centric terminology and steps appear before or instead of cross-platform alternatives.
Recommendations
- Provide equivalent Linux/macOS commands or tools for tasks currently described only with PowerShell or Windows GUI (e.g., setting Kerberos encryption types, managing AD accounts).
- When referencing Active Directory management, clarify how Linux/macOS administrators can perform similar actions (e.g., using ldapmodify, samba-tool, or other cross-platform utilities).
- Balance example order so that Linux/NFS troubleshooting steps are presented alongside or before Windows/SMB steps where appropriate.
- Explicitly mention cross-platform alternatives for mounting, DNS troubleshooting, and Kerberos ticket management (e.g., kinit, nslookup, systemctl).
Azure Relay
Authenticate from an application - Azure Relay
.../main/articles/azure-relay/authenticate-application.md
Medium Priority
View Details →
Detected Bias Types
windows_first
powershell_heavy
missing_linux_example
Summary
The documentation primarily demonstrates authentication using .NET console applications, which are most commonly run on Windows. The highlighted code samples and walkthroughs focus exclusively on .NET and do not provide equivalent examples for Linux/macOS environments or other languages/platforms. Additionally, instructions for running the sample application do not mention cross-platform compatibility or alternative steps for Linux/macOS users. The 'Next steps' section lists Azure PowerShell before Azure CLI, subtly prioritizing Windows tooling.
Recommendations
- Explicitly state whether the .NET sample is cross-platform and provide instructions for running it on Linux/macOS (e.g., using .NET Core/.NET 5+).
- Add code samples or walkthroughs for Java and JavaScript, as referenced in the 'Samples' section, to demonstrate authentication from non-Windows environments.
- In the 'Next steps' section, list Azure CLI before Azure PowerShell or clarify that both are available on all platforms.
- Include troubleshooting notes or environment setup instructions for Linux/macOS users.
- Where possible, use language-neutral or cross-platform examples in highlighted code sections.
Azure Relay
Authenticate with managed identities for Azure Relay resources
.../articles/azure-relay/authenticate-managed-identity.md
Medium Priority
View Details →
Detected Bias Types
windows_first
missing_linux_example
windows_tools
Summary
The documentation page demonstrates a notable Windows bias. The primary walkthrough for authenticating with managed identities uses a Windows 10 VM, references RDP for access, and links only to instructions for enabling managed identity on Windows VMs. There are no equivalent Linux VM instructions or examples, and the sample app workflow is tailored to Windows environments. While sample code is cross-platform (.NET, Java, JavaScript), the step-by-step guidance is Windows-centric.
Recommendations
- Add parallel instructions for enabling managed identity on Linux VMs, linking to the appropriate Azure documentation.
- Include a Linux-based walkthrough for running the sample application, covering SSH access, file transfer (e.g., SCP), and execution on Linux.
- Reference both Windows and Linux VM creation guides, or provide a generic VM creation step with OS-specific links.
- Where RDP is mentioned, also mention SSH for Linux VMs.
- Clarify that the sample app can run on both Windows and Linux, and provide any OS-specific prerequisites or commands.
Azure Relay
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-relay/includes/relay-hybrid-connections-http-requests-dotnet-get-started-client.md
...id-connections-http-requests-dotnet-get-started-client.md
Medium Priority
View Details →
Detected Bias Types
windows_tools
missing_linux_example
windows_first
Summary
The documentation assumes the use of Visual Studio and .NET Framework, both of which are primarily Windows tools. There are no instructions or examples for creating the client application on Linux or macOS (e.g., using .NET Core/SDK and cross-platform editors like VS Code). The NuGet package installation steps are Visual Studio-specific, and there is no mention of command-line alternatives (e.g., dotnet CLI).
Recommendations
- Add instructions for creating the console application using the .NET CLI (dotnet new console) to support Linux/macOS users.
- Mention that the Microsoft.Azure.Relay package can be installed using the dotnet CLI (dotnet add package Microsoft.Azure.Relay).
- Clarify that the code sample works with .NET Core/.NET 5+ and is not limited to .NET Framework, if applicable.
- Provide editor-agnostic instructions or mention alternatives like VS Code.
- If there are Windows-only requirements, explicitly state them at the beginning.
Azure Relay
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-relay/includes/relay-hybrid-connections-http-requests-dotnet-get-started-server.md
...id-connections-http-requests-dotnet-get-started-server.md
Medium Priority
View Details →
Detected Bias Types
windows_tools
missing_linux_example
Summary
The documentation instructs users to create a .NET Framework console app using Visual Studio and NuGet Package Manager, both of which are Windows-centric tools. There are no instructions or examples for creating or running the server on Linux or macOS, nor is there mention of .NET Core/.NET 5+ (cross-platform) alternatives.
Recommendations
- Provide parallel instructions for creating a console app using .NET Core or .NET 5+ (which are cross-platform) via the dotnet CLI.
- Include guidance for installing the Microsoft.Azure.Relay NuGet package using the CLI (e.g., 'dotnet add package') for non-Windows users.
- Clarify whether the sample code is compatible with .NET Core/.NET 5+ and, if not, note that the instructions are Windows-only.
- If possible, add a section for Linux/macOS users, or explicitly state if only Windows is supported for this scenario.
Azure Relay
Integrate Azure Relay with Azure Private Link Service
...blob/main/articles/azure-relay/private-link-service.md
Medium Priority
View Details →
Detected Bias Types
powershell_heavy
missing_linux_example
windows_first
Summary
The documentation provides detailed instructions for integrating Azure Relay with Azure Private Link Service, but command-line automation is only demonstrated using Azure PowerShell. There are no CLI (az cli), Bash, or Linux/macOS-specific examples, and the validation steps explicitly reference creating a Windows VM, with no mention of Linux alternatives. Windows tools and workflows are prioritized or exclusively shown, which may create friction for Linux/macOS users.
Recommendations
- Add equivalent Azure CLI (az cli) examples for creating and managing private endpoints, as Azure CLI is cross-platform and widely used on Linux/macOS.
- In the validation section, provide instructions for creating a Linux VM and running the nslookup command from a Linux shell, or clarify that the validation steps apply equally to Linux VMs.
- Where possible, use neutral language (e.g., 'create a virtual machine') and provide both Windows and Linux options, or explicitly state that the steps are OS-agnostic unless there is a Windows-specific requirement.
- If PowerShell is shown, consider also showing Bash/CLI equivalents, or link to relevant cross-platform documentation.
Azure Relay
Azure Relay Hybrid Connections - WebSockets in .NET
...e-relay/relay-hybrid-connections-dotnet-get-started.md
Medium Priority
View Details →
Detected Bias Types
windows_tools
missing_linux_example
windows_first
Summary
The documentation assumes the use of Visual Studio (a Windows-centric IDE) and .NET Framework, with no mention of cross-platform .NET (Core/5+) or alternative development environments (e.g., VS Code, CLI). There are no instructions or examples for Linux/macOS users, and all steps reference Visual Studio without alternatives.
Recommendations
- Add instructions for using cross-platform .NET (e.g., .NET 6/7/8) and clarify if .NET Framework is required or if .NET Core/5+ is supported.
- Provide guidance for developing and running the sample applications using the .NET CLI (dotnet new, dotnet run), which works on Linux/macOS.
- Mention and provide examples for using VS Code or other cross-platform editors.
- Explicitly state OS requirements if the sample is Windows-only, or clarify cross-platform compatibility.
Azure Relay
Configure IP firewall for Azure Relay namespace
...n/articles/azure-relay/ip-firewall-virtual-networks.md
Medium Priority
View Details →
Detected Bias Types
windows_first
missing_linux_example
Summary
The documentation provides instructions for configuring IP firewall rules for Azure Relay namespaces, focusing on the Azure portal and Resource Manager templates. However, when referencing deployment of the ARM template, it links only to PowerShell-based deployment instructions, with no mention of Linux/macOS CLI alternatives (such as Azure CLI or Bash). This creates a subtle Windows-first bias and omits Linux/macOS-friendly guidance.
Recommendations
- Add instructions or links for deploying the ARM template using Azure CLI (az deployment group create) and Bash, which are cross-platform and preferred by many Linux/macOS users.
- When referencing deployment methods, mention both PowerShell and Azure CLI/Bash options, or provide a table with platform-specific instructions.
- Ensure that screenshots and UI references are not Windows-specific unless necessary; clarify that the Azure portal is cross-platform.
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 Windows and Linux-friendly instructions for most certificate management tasks, but there is a mild bias toward Windows. Windows tools (IIS, Certreq.exe) are mentioned before Linux alternatives, and PowerShell examples are given alongside Azure CLI, but not Bash or Linux-native commands for Azure resource management. Export instructions for certificates reference Windows tools first, with OpenSSL (Linux/macOS) covered second. No critical steps are Windows-only, but Windows patterns are presented before Linux equivalents.
Recommendations
- Present Linux/OpenSSL instructions before or alongside Windows/IIS/Certreq.exe steps for certificate export.
- Include Bash/Azure CLI examples for resource management tasks (e.g., role assignment, certificate binding) before or alongside PowerShell.
- Explicitly mention that all steps can be performed on Linux/macOS where applicable.
- Add links to Linux/macOS certificate management documentation where relevant.
Azure App Configuration
Configuration Provider Overview
...e-app-configuration/configuration-provider-overview.md
Low Priority
View Details →
Detected Bias Types
windows_first
Summary
The documentation lists .NET provider libraries (Microsoft.Extensions.Configuration.AzureAppConfiguration, Microsoft.Azure.AppConfiguration.AspNetCore, Microsoft.Azure.AppConfiguration.Functions.Worker, Microsoft.Configuration.ConfigurationBuilders.AzureAppConfiguration) first in the table, before Java, Python, JavaScript, and Go equivalents. The .NET Framework provider is included, which is Windows-only, but the overall page is not Windows-specific. No PowerShell-specific examples, Windows tools, or Windows-only patterns are present. All sample links are cross-platform (e.g., .NET Core, Java, Python, JavaScript, Go), and feature parity is tracked for all major languages/platforms. There are no missing Linux/macOS examples, and no exclusive mention of Windows tools.
Recommendations
- Consider reordering the provider libraries table to group cross-platform providers (e.g., .NET Core, Java, Python, JavaScript, Go) before Windows-only (.NET Framework) providers.
- Explicitly note which providers are Windows-only (e.g., .NET Framework) and which are cross-platform.
- Add a brief statement clarifying that most providers (except .NET Framework) work on Linux/macOS as well as Windows.
- Ensure that sample links and documentation for .NET Core/Standard highlight cross-platform compatibility.
API Center
Import APIs from Azure API Management - Azure API Center
...main/articles/api-center/import-api-management-apis.md
Low Priority
View Details →
Detected Bias Types
windows_first
Summary
The documentation provides both Bash and PowerShell examples for Azure CLI commands, but PowerShell examples are consistently shown immediately after Bash, and some notes clarify differences in variable syntax. There are no Windows-specific tools or patterns used, and Linux/macOS users are not blocked from completing any tasks. However, the presence of PowerShell examples alongside Bash may create a slight perception of Windows-first bias.
Recommendations
- Ensure Bash examples are shown first, as is currently done.
- Clarify in the prerequisites that Azure CLI is fully cross-platform and all examples work on Linux, macOS, and Windows.
- Consider grouping Bash and PowerShell examples together visually, or using tabs to allow users to select their shell preference.
- Explicitly mention that all commands are supported on Linux/macOS unless otherwise noted.
Low Priority
View Details →
Detected Bias Types
windows_first
powershell_heavy
Summary
The documentation provides both Bash and PowerShell examples for Azure CLI commands, but PowerShell examples are shown immediately after Bash in each step, and PowerShell-specific formatting is explicitly called out. This creates a slight Windows-first impression, though Linux/macOS users are not blocked from completing the task.
Recommendations
- Clearly label Bash and PowerShell examples with headings or tabs, so users can easily find the example relevant to their platform.
- Consider presenting Bash (Linux/macOS) examples first, or in parallel tabs, to avoid implicit prioritization of Windows/PowerShell.
- Add a brief note clarifying that Bash examples are for Linux/macOS and PowerShell for Windows, to help users choose appropriately.
Low Priority
View Details →
Detected Bias Types
windows_first
Summary
The documentation provides both Bash and PowerShell (Windows) examples for Azure CLI commands, but the PowerShell examples are always shown after the Bash examples. There are no exclusive Windows tools or patterns, and Linux/macOS users are fully supported.
Recommendations
- Maintain the current approach of providing both Bash (Linux/macOS) and PowerShell (Windows) examples.
- Optionally, clarify at the top of the CLI section that both Bash and PowerShell examples are provided for user convenience.
- If possible, provide a tabbed interface or clearer separation to help users quickly find their preferred shell.
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_tools
powershell_heavy
windows_first
Summary
The documentation references Azure PowerShell cmdlets (set-azapimanagement) alongside Azure CLI and REST API for managing regional gateways, and lists PowerShell before CLI in the list of tools. However, all command-line examples provided are Azure CLI, which is cross-platform. No explicit Linux/macOS examples or tools are given, and there is no mention of Linux-specific considerations or parity in the walkthroughs. The documentation assumes use of the Azure portal and CLI, which are available on all platforms, but the presence and ordering of PowerShell references may create minor friction for Linux/macOS users.
Recommendations
- Ensure that all command-line examples are provided for both Azure CLI and Azure PowerShell, or clarify platform compatibility for each tool.
- Explicitly state that Azure CLI is cross-platform and preferred for Linux/macOS users, while PowerShell is available on all platforms but may require additional installation steps.
- If PowerShell is mentioned, provide equivalent Bash or shell script examples for Linux/macOS users.
- Review ordering of tool references to list Azure CLI before PowerShell, or group them neutrally.
- Add a short note in the prerequisites or tool usage sections about platform compatibility and installation instructions for CLI and PowerShell on Linux/macOS.
Low Priority
View Details →
Detected Bias Types
windows_first
missing_linux_example
Summary
The documentation generally presents Azure App Service plans in a cross-platform manner, mentioning both Windows and Linux as supported operating systems. However, the 'Managed Instance on Azure App Service' section is Windows-only and features Windows-specific tooling (PowerShell, RDP, IIS, registry, MSI installers) without Linux equivalents or parity notes. While this is clearly marked as a Windows-only preview feature, the documentation could better clarify Linux limitations and alternatives for similar scenarios. Additionally, some links (such as pricing details) default to Windows tabs, and there are no explicit Linux-focused examples or guidance for scaling, cost, or feature parity.
Recommendations
- Explicitly clarify in the 'Managed Instance' section that Linux users should use other hosting options, and link to Linux/container alternatives.
- Where features or examples are Windows-only, add notes or links to equivalent Linux guidance (if available) or state that no equivalent exists.
- Ensure pricing and feature comparison links include Linux tabs or direct users to Linux-specific documentation.
- Add Linux-specific examples or callouts in general sections (e.g., scaling, cost, deployment slots) to demonstrate parity.
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 Azure CLI and PowerShell examples for all major steps, with PowerShell examples shown alongside CLI and portal instructions. While the page is not Windows-only, PowerShell is a Windows-centric tool (though available cross-platform), and its inclusion may suggest a slight Windows bias. However, Azure CLI examples are present and shown before PowerShell, and all instructions are applicable to both Linux and Windows users. No critical Linux examples are missing, and no Windows-only tools or patterns are mentioned.
Recommendations
- Clarify that Azure PowerShell is available cross-platform (Windows, Linux, macOS) to avoid the perception of Windows exclusivity.
- Consider including Bash script examples or explicit Linux/macOS command-line instructions where relevant, especially for common tasks.
- Add a note or section highlighting that all Azure CLI commands work natively on Linux/macOS, and PowerShell Core is supported on those platforms.
- Ensure parity in troubleshooting or advanced configuration examples, referencing Linux/macOS tools if applicable.
Application Gateway
Quickstart: Deploy Application Gateway for Containers ALB Controller
...ploy-application-gateway-for-containers-alb-controller.md
Low Priority
View Details →
Detected Bias Types
windows_first
Summary
The documentation provides both Windows and Linux instructions for installing Helm, but the Windows example (using PowerShell and winget) is presented before the Linux example. All other commands and examples use Azure CLI, Bash, or Kubernetes tools, which are cross-platform and do not show bias toward Windows.
Recommendations
- Present Linux and Windows installation instructions for Helm in parallel tabs or sections, or list Linux first to avoid implicit prioritization.
- Ensure that any future examples or troubleshooting steps include both Linux and Windows variants if platform-specific commands are needed.
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 generally maintains good cross-platform coverage, but there are several instances where Windows tools, commands, or configuration steps are mentioned before their Linux equivalents, and some sections (such as ReadyToRun and preview .NET SDK deployment) provide Windows instructions first or in more detail. Azure PowerShell is listed as a primary resource creation method, and some CLI examples use Windows-centric syntax. However, Linux equivalents are usually present, and the guide does not prevent Linux/macOS users from completing any tasks.
Recommendations
- Ensure that Linux and macOS instructions are always presented alongside or before Windows instructions, especially in CLI sections.
- Where Azure PowerShell is mentioned, also mention Azure CLI as the primary cross-platform tool, and clarify that PowerShell is optional.
- For ReadyToRun and deployment sections, provide Linux examples with equal prominence and detail as Windows examples.
- Review CLI code blocks to ensure they use platform-neutral syntax where possible, and clarify any OS-specific requirements.
- In tables or lists of options, alternate the order or group by platform rather than always listing Windows first.
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
powershell_heavy
Summary
The documentation generally covers both Windows and Linux scenarios for Azure Functions app settings, but there are some areas of Windows bias. Windows-specific examples (e.g., path syntax, environment variable delimiters) are sometimes presented first or exclusively. PowerShell-specific settings are documented in detail, while Linux shell equivalents are not mentioned. Some references to Windows tools (e.g., Azure PowerShell) are made before Linux alternatives (e.g., Azure CLI). However, most settings are OS-agnostic, and Linux-specific settings and considerations are included where relevant.
Recommendations
- Ensure that examples using file paths or environment variable delimiters include both Windows and Linux formats, or clarify OS-specific differences.
- When referencing tools for managing app settings (e.g., Azure CLI, Azure PowerShell), present both options equally and avoid prioritizing Windows tools.
- For PowerShell-specific settings, consider mentioning if there are equivalent settings or considerations for Bash or other Linux shells, or clarify that these are PowerShell-only.
- Where settings have OS-specific behavior (e.g., WEBSITE_TIME_ZONE), ensure both Windows and Linux examples are shown side-by-side.
- Review the ordering of examples and tool references to avoid consistently listing Windows options first.
Azure Functions
Deployment technologies in Azure Functions
...s/azure-functions/functions-deployment-technologies.md
Low Priority
View Details →
Detected Bias Types
windows_first
powershell_heavy
windows_tools
Summary
The documentation generally presents deployment methods and examples in a cross-platform manner, referencing both Windows and Linux hosting plans. However, there is a subtle Windows bias: Windows-specific deployment technologies (such as source control, local Git, and FTPS) are mentioned as 'Windows-only' in the availability table, and Windows hosting plans are often listed first. Examples and tool recommendations (Visual Studio, Visual Studio Code, Azure CLI, Core Tools) are mostly cross-platform, but Visual Studio (a Windows tool) is frequently highlighted. The documentation does not provide explicit Linux/macOS command-line examples or mention Linux-specific tooling (e.g., bash scripts) where relevant. There is also a tendency to describe Windows deployment flows before Linux equivalents, and some sections (like remote build) discuss Windows first.
Recommendations
- Where deployment methods are Windows-only, clarify alternatives for Linux/macOS users and link to relevant guides.
- Provide Linux/macOS-specific examples or command-line snippets (e.g., bash, zsh) alongside Windows/PowerShell examples.
- When listing tools (Visual Studio, VS Code, CLI), explicitly note platform compatibility and suggest Linux/macOS alternatives where applicable.
- In tables and lists, alternate the order of Windows and Linux hosting plans to avoid implicit prioritization.
- Add explicit guidance for Linux users in sections where Windows flows are described first (e.g., remote build, deployment slots).
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
powershell_heavy
windows_tools
Summary
The documentation provides both Linux and Windows migration paths, but Windows/PowerShell/Azure CLI examples and instructions are often presented first or in greater detail, especially in the Windows pivot sections. Windows-centric tools and patterns (such as Azure CLI commands, PowerShell scripts, and portal workflows) are emphasized, and some advanced migration steps (like collecting app settings, configuring identities, and troubleshooting) are described primarily using Windows-oriented tools. While Linux parity is generally maintained, the structure and example order may create friction for Linux/macOS users.
Recommendations
- Ensure Linux and Windows instructions/examples are presented with equal prominence and detail in each relevant section.
- Where possible, provide Linux/macOS-specific command-line examples (e.g., bash scripts, Linux-native tools) alongside PowerShell/Windows examples.
- Avoid presenting Windows/PowerShell examples before Linux equivalents; use neutral ordering or clearly separate pivots.
- Explicitly note any differences in tool usage or required steps for Linux/macOS users, especially for troubleshooting and advanced configuration.
- Review and update troubleshooting and recovery sections to include Linux-native diagnostic commands and workflows.
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 is generally cross-platform, but there are minor signs of Windows bias. In the 'Mount file shares' section, both Azure CLI (Linux-friendly) and PowerShell (Windows-centric) examples are provided, but PowerShell is shown after CLI. There are references to features that are 'Windows only' (e.g., Consumption plan), but these are clearly marked and justified. The documentation does not omit Linux examples where relevant, and Linux-specific instructions are present for mounting file shares. Overall, Linux parity is good, with only minor ordering and emphasis bias.
Recommendations
- Continue to provide both Azure CLI and PowerShell examples for all relevant tasks.
- Where features differ by OS, clearly label sections as 'Windows only' or 'Linux only' to avoid confusion.
- Consider listing CLI (cross-platform) examples before PowerShell in all sections to reinforce platform neutrality.
- Ensure that any references to Windows-specific features are accompanied by Linux alternatives or clear notes about platform support.
Azure Government
Azure guidance for secure isolation
...es/azure-government/azure-secure-isolation-guidance.md
Low Priority
View Details →
Detected Bias Types
windows_first
windows_tools
powershell_heavy
Summary
The documentation is generally cross-platform and covers both Windows and Linux scenarios for Azure secure isolation. However, there is a consistent pattern of mentioning Windows tools, technologies, and patterns first (e.g., Hyper-V, BitLocker, Windows Firewall), and Windows-specific terminology is more prevalent throughout. In a few places, PowerShell is referenced as a primary automation tool, and Windows-centric features are described in greater detail than their Linux equivalents. Linux is supported and referenced, but often appears after Windows or as an addendum.
Recommendations
- Ensure Linux and Windows examples are presented with equal prominence, or alternate which platform is shown first.
- Where Windows-specific tools (e.g., BitLocker, Windows Firewall, Hyper-V) are mentioned, ensure the Linux equivalents (e.g., dm-crypt, iptables/firewalld, KVM) are also referenced with equal detail, unless the feature is Azure/Windows-only.
- When referencing automation or management tools, include Azure CLI and Bash examples alongside PowerShell.
- Review callout boxes and 'how-to' links to ensure Linux-focused resources are equally visible.
- In tables and summary sections, list Linux and Windows guidance side-by-side, not with Windows first.