508
Pages Scanned
62
Pages Flagged
508
Changed Pages
12.2%
% Pages Flagged
Live Progress
đ´ Connecting...
Phase: discovery
Processing: Initializing...
Activity Feed
00:00:06
Scan Information
Started At: 2025-08-24 00:00:06
Finished At: In Progress
Status: cancelled
Target Repo: Azure
Current Phase: discovery
Files Queued: 1012
Files Completed: 500
Problematic Pages
62 issues found
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/app-service-best-practices.md
...ain/articles/app-service/app-service-best-practices.md
High Priority
View Details â
Detected Bias Types
windows_tools
windows_first
missing_linux_example
Summary
The documentation demonstrates a mild Windows bias, primarily by referencing Windows-specific tools (such as web.config and iisnode) without providing equivalent Linux alternatives or examples. While there is a brief mention of Linux (in the Node.js/PM2 section), most configuration and troubleshooting guidance assumes a Windows environment or omits Linux-specific instructions.
Recommendations
- For features like auto-healing, provide Linux-specific configuration guidance (e.g., how to configure auto-healing for Linux-based App Service, or note if it's not available).
- When referencing web.config or iisnode, clarify their applicability (Windows only), and provide Linux equivalents or alternative approaches (e.g., app settings, startup scripts, or configuration files used in Linux containers).
- Ensure that all examples (such as memory dump, process recycling, or diagnostics) include both Windows and Linux approaches, or explicitly state platform limitations.
- In sections discussing Node.js, expand on Linux-native process management and monitoring tools (e.g., systemd, supervisord) alongside PM2.
- Audit the documentation for other Windows-centric terminology or features, and add Linux parity or clear notes about platform differences.
Create Pull Request
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/app-service-asp-net-migration.md
.../articles/app-service/app-service-asp-net-migration.md
High Priority
View Details â
Detected Bias Types
windows_first
missing_linux_example
windows_tools
powershell_heavy
Summary
The documentation page demonstrates a strong Windows bias: all migration tools and examples focus exclusively on Windows environments, specifically IIS servers and PowerShell scripts. There is no mention of Linux-based hosting, migration from Linux web servers, or equivalent Linux tools. The App Service Migration Assistant and related scripts are Windows-only, and containerization is discussed only in the context of Windows Containers. No Linux migration scenarios, commands, or tools are provided.
Recommendations
- Include migration guidance and examples for .NET apps hosted on Linux servers (e.g., Apache, Nginx).
- Provide Linux-compatible migration tools or document manual migration steps for Linux environments.
- Offer Bash or shell script equivalents for PowerShell-based migration scripts.
- Mention and link to Azure App Service for Linux documentation where relevant.
- Clarify tool/platform limitations up front and suggest alternative approaches for Linux users.
- Highlight containerization options for Linux-based .NET Core/ASP.NET Core apps, not just Windows Containers.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/app-service-configure-premium-v4-tier.md
...s/app-service/app-service-configure-premium-v4-tier.md
High Priority
View Details â
Detected Bias Types
windows_first
powershell_heavy
windows_tools
missing_linux_example
Summary
The documentation demonstrates a Windows-first bias by presenting Windows-related information and tools before Linux equivalents. Azure PowerShell (a Windows-centric tool) is given a dedicated section, while Linux-specific automation (e.g., Bash scripting) is not mentioned. The portal instructions and screenshots are Windows-oriented, and there are no Linux-specific examples for automating deployments or scaling operations. Although Azure CLI is cross-platform, the lack of explicit Linux/Bash scripting examples and the ordering of Windows information before Linux equivalents indicate a bias.
Recommendations
- Provide Linux/Bash scripting examples alongside PowerShell for automation tasks.
- Ensure Linux-specific instructions and screenshots are included where relevant, especially for portal workflows that may differ.
- Present Linux and Windows options in parallel, rather than listing Windows first.
- Include guidance for Linux container scenarios, especially since Premium V4 supports custom containers on Linux.
- Clarify any differences in experience or limitations between Windows and Linux throughout the documentation.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/app-service-configure-premium-v3-tier.md
...s/app-service/app-service-configure-premium-v3-tier.md
High Priority
View Details â
Detected Bias Types
windows_first
powershell_heavy
windows_tools
Summary
The documentation demonstrates a mild Windows bias: Windows examples and terminology are often presented before Linux equivalents, and Azure PowerShell (a Windows-centric tool) is given equal prominence to Azure CLI, despite the CLI being more cross-platform. The documentation also references the Azure portal UI, which is platform-agnostic but often more familiar to Windows users. There are no explicit Linux shell or scripting examples, and Linux-specific guidance is limited to a single CLI flag.
Recommendations
- Present Linux and Windows options side-by-side or in parallel sections, rather than listing Windows first.
- Include Linux shell scripting examples (e.g., Bash) alongside PowerShell examples for automation.
- Clarify that Azure CLI is fully cross-platform and can be used on Windows, macOS, and Linux.
- Expand on Linux-specific considerations, such as differences in deployment or troubleshooting.
- Where possible, provide parity in example depth and detail for both Linux and Windows environments.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/configure-authentication-file-based.md
...les/app-service/configure-authentication-file-based.md
High Priority
View Details â
Detected Bias Types
windows_first
windows_tools
missing_linux_example
Summary
The documentation demonstrates Windows bias by referencing the Windows file path (C:\home\site\wwwroot) first and in more detail, mentioning relative and absolute paths for Windows but only absolute paths for Linux. There are no Linux command-line or file-system examples, and the Linux-specific path is only mentioned in a note, not in the main instructions or examples. No Linux tools or patterns are referenced.
Recommendations
- Provide Linux file path examples (e.g., /home/site/wwwroot) alongside or before Windows paths in all relevant instructions and code samples.
- Include explicit Linux-focused instructions and examples, not just as a note, but integrated into the main steps.
- Mention both Windows and Linux behaviors equally when discussing platform differences (e.g., path formats, deployment locations).
- If referencing tools or file locations, always provide the Linux equivalent (e.g., show how to deploy or locate the config file on Linux App Service).
- Consider adding a table or section summarizing platform-specific differences for clarity.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/app-service-hybrid-connections.md
...articles/app-service/app-service-hybrid-connections.md
High Priority
View Details â
Detected Bias Types
windows_first
powershell_heavy
windows_tools
missing_linux_example
Summary
The documentation demonstrates a moderate Windows bias. Windows instructions, tools, and examples are often presented first or exclusively, especially in troubleshooting and GUI usage. PowerShell commands are referenced for network testing, and the GUI for Hybrid Connection Manager is only available on Windows, with Linux users relegated to CLI. Some troubleshooting steps and tools (e.g., Test-NetConnection) are Windows-specific, with no direct Linux equivalents provided. Linux support is present but less detailed and less user-friendly.
Recommendations
- When providing troubleshooting steps, include equivalent Linux commands (e.g., use 'nc' or 'telnet' for TCP connectivity instead of only PowerShell's Test-NetConnection).
- Present Windows and Linux instructions in parallel, or alternate which OS is presented first in each section to avoid a 'Windows-first' perception.
- Where GUI tools are only available on Windows, provide enhanced CLI guidance and scripts for Linux users to achieve parity.
- Expand Linux installation and usage sections with more detailed, step-by-step instructions, including common troubleshooting scenarios.
- In all code examples and command references, ensure both Windows and Linux equivalents are shown, especially for network diagnostics and endpoint testing.
- Explicitly acknowledge feature gaps (such as lack of GUI on Linux) and, where possible, offer workarounds or roadmap information.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/app-service-migration-discover-net.md
...cles/app-service/app-service-migration-discover-net.md
High Priority
View Details â
Detected Bias Types
windows_first
missing_linux_example
windows_tools
Summary
The documentation focuses exclusively on discovering ASP.NET web apps hosted on IIS web servers within VMware environments, which are Windows-centric technologies. There are no references to Linux-based hosting scenarios, such as .NET apps running on Kestrel, Apache, or Nginx, nor are there examples or guidance for discovering .NET apps on Linux servers. All discovery capabilities and tooling (Azure Migrate appliance, IIS) are described in a Windows context, with no Linux parity.
Recommendations
- Include explicit guidance and examples for discovering .NET web apps hosted on Linux servers (e.g., Kestrel, Apache, Nginx).
- Mention whether Azure Migrate supports Linux-based .NET app discovery, and if not, clarify the limitation.
- Provide parity in documentation by listing Linux discovery steps, tools, or limitations alongside Windows/IIS instructions.
- Reference Linux-compatible tools or scripts for app discovery, if available, or suggest alternative approaches for Linux environments.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/app-service-managed-certificate-changes-july-2025.md
...e/app-service-managed-certificate-changes-july-2025.md
High Priority
View Details â
Detected Bias Types
powershell_heavy
windows_tools
windows_first
missing_linux_example
Summary
The documentation demonstrates a Windows bias primarily in the section addressing Azure Traffic Manager endpoints. It exclusively recommends and documents a PowerShell script (with explicit PowerShell usage instructions) to identify non-Azure endpoints, without offering equivalent Bash, Azure CLI, or cross-platform alternatives. Throughout the page, while REST API and Azure CLI commands are referenced for certificate management, the only explicit script-based automation example is for PowerShell, and there is no mention of Linux shell or Bash scripting. This may disadvantage users on Linux or macOS, or those preferring non-Windows automation tools.
Recommendations
- Provide equivalent Bash or Azure CLI scripts for identifying non-Azure Traffic Manager endpoints, or reference cross-platform tools where possible.
- When recommending scripts or automation, offer both PowerShell and Bash (or at least Azure CLI) examples to ensure parity for Linux/macOS users.
- Explicitly state when a solution is Windows-only and offer alternatives for other platforms.
- Where possible, prefer Azure CLI or REST API examples for automation, as these are cross-platform.
- Review other sections for implicit Windows-first assumptions and ensure Linux users are equally supported in all procedural guidance.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/configure-language-java-data-sources.md
...es/app-service/configure-language-java-data-sources.md
High Priority
View Details â
Detected Bias Types
windows_first
powershell_heavy
windows_tools
Summary
The documentation provides both Linux and Windows instructions for configuring Tomcat data sources, but the Windows section is notably more detailed and prescriptive, with step-by-step PowerShell scripts and Windows-specific file paths and tools. Windows configuration is described with more explicit automation (PowerShell), while Linux relies on more generic shell scripting and manual steps. The Windows section also introduces Windows-specific patterns (startup.cmd, PowerShell, %HOME% paths) and tools (PowerShell, Windows environment variables) that have no direct Linux equivalents presented with the same level of detail. In some places, Windows instructions or tools are mentioned before or more prominently than their Linux counterparts.
Recommendations
- Provide equally detailed, step-by-step Linux automation scripts (e.g., bash scripts) for tasks that are automated with PowerShell on Windows, such as copying Tomcat, transforming XML, and setting up environment variables.
- Where Windows-specific tools or patterns are introduced (e.g., startup.cmd, PowerShell), offer direct Linux equivalents (e.g., startup.sh, bash scripting) with matching detail and sample code.
- Ensure that Linux instructions are not only present but are as comprehensive and prescriptive as Windows instructions, including error handling, idempotency, and automation tips.
- When listing instructions for both platforms, consider presenting Linux examples first or side-by-side to avoid the impression of Windows primacy.
- Include more Linux-native patterns and tools (e.g., systemd, cron, shell scripting best practices) where appropriate, and avoid assuming familiarity with Windows concepts in Linux sections.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/app-service-web-nodejs-best-practices-and-troubleshoot-guide.md
...rvice-web-nodejs-best-practices-and-troubleshoot-guide.md
High Priority
View Details â
Detected Bias Types
windows_first
windows_tools
missing_linux_example
powershell_heavy
Summary
The documentation is heavily focused on Windows environments, specifically Azure App Service on Windows with iisnode. All configuration and troubleshooting steps are tailored to Windows, referencing Windows-specific tools (iisnode, web.config, named pipes, Win32 error codes, Kudu CMD/PowerShell), and file paths (e.g., d:\home\LogFiles). There are no examples or guidance for Linux-based Azure App Service environments, nor are Linux equivalents or cross-platform alternatives mentioned.
Recommendations
- Add a parallel section or separate documentation for Node.js on Azure App Service Linux, covering configuration, deployment, and troubleshooting steps relevant to Linux environments.
- Include Linux-specific examples (e.g., using pm2, nginx, or other common Node.js process managers on Linux) and configuration files (such as process.json, ecosystem.config.js, or nginx.conf).
- Reference Linux file paths and logging locations alongside Windows paths.
- Provide guidance for using the Azure Cloud Shell (bash) and SSH-based troubleshooting, not just Kudu CMD/PowerShell.
- Mention cross-platform Node.js debugging and profiling tools, and clarify which steps are Windows-only.
- Clearly label the scope of the document as Windows-specific at the top, and link to Linux-focused documentation for parity.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/deploy-run-package.md
...s/blob/main/articles/app-service/deploy-run-package.md
High Priority
View Details â
Detected Bias Types
windows_first
windows_tools
missing_linux_example
Summary
The documentation demonstrates a Windows bias by referencing Windows directory paths (e.g., D:\home\site\wwwroot) before Linux equivalents, using Windows path separators in examples, and omitting explicit Linux command-line or file path examples. The instructions and troubleshooting sections focus on Windows conventions, with only brief mentions of Linux paths and no Linux-specific deployment or troubleshooting guidance.
Recommendations
- Provide Linux-specific examples alongside Windows ones, including directory paths (e.g., /home/site/wwwroot) and command-line instructions.
- Use platform-agnostic path notation or show both Windows and Linux paths in all relevant sections.
- Include troubleshooting steps and notes that address Linux-specific behaviors and issues.
- Ensure that all references to tools (such as Azure CLI) clarify their cross-platform availability and usage.
- Add explicit Linux/macOS shell command examples (e.g., bash) where appropriate, not just Azure CLI.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/configure-encrypt-at-rest-using-cmk.md
...les/app-service/configure-encrypt-at-rest-using-cmk.md
High Priority
View Details â
Detected Bias Types
windows_first
windows_tools
missing_linux_example
Summary
The documentation demonstrates a mild Windows bias by referencing Azure Storage Explorer (a GUI tool with a primary Windows focus) for uploading files and generating SAS tokens, and by providing a link that defaults to Windows instructions. There are no explicit Linux or cross-platform CLI examples for these steps, and no mention of Linux-native tools or workflows for uploading or managing blobs. All command-line examples use Azure CLI, which is cross-platform, but the initial file upload and SAS generation steps are Windows-centric.
Recommendations
- Provide explicit Linux and macOS instructions for uploading files and generating SAS tokens, such as using the Azure CLI (az storage blob upload, az storage blob generate-sas) or AzCopy.
- Include cross-platform command-line examples alongside or instead of GUI-based instructions, especially for critical steps like uploading and securing deployment packages.
- When referencing Azure Storage Explorer, clarify its availability on all platforms or provide alternative methods for Linux users.
- Ensure that documentation links and tabs do not default to Windows, and that Linux/macOS tabs are equally visible and complete.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/configure-language-dotnet-framework.md
...les/app-service/configure-language-dotnet-framework.md
High Priority
View Details â
Detected Bias Types
windows_first
windows_tools
missing_linux_example
Summary
The documentation page demonstrates a Windows bias by focusing exclusively on Windows-based deployment and configuration patterns for ASP.NET apps. All runtime version discovery steps use Windows file paths and tools (Kudu, CMD, PowerShell), with no mention of Linux equivalents. There are no examples or instructions for configuring or troubleshooting ASP.NET apps running on Linux App Service plans, nor any Linux shell or file system references.
Recommendations
- Add parallel instructions and examples for ASP.NET apps running on Linux App Service plans, including how to check installed .NET runtimes and access environment variables.
- Provide Linux shell (bash) commands for listing available .NET runtimes and SDKs in Linux containers or App Service for Linux.
- Mention and demonstrate how to use Kudu SSH or App Service SSH console for Linux-based apps.
- Clarify which instructions apply only to Windows App Service and provide links or sections for Linux-specific guidance.
- Include troubleshooting and diagnostic log access steps for Linux-based ASP.NET apps, referencing Linux file paths and tools.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/manage-scale-per-app.md
...blob/main/articles/app-service/manage-scale-per-app.md
High Priority
View Details â
Detected Bias Types
powershell_heavy
missing_linux_example
windows_tools
windows_first
Summary
The documentation page demonstrates a strong Windows bias by providing only PowerShell-based CLI examples for per-app scaling, with no equivalent examples for Linux users (e.g., Bash, Azure CLI). The use of Azure PowerShell cmdlets and the absence of cross-platform command-line alternatives or explicit mention of Linux tooling make the instructions less accessible to non-Windows users. Additionally, the documentation metadata and custom tags emphasize Azure PowerShell, reinforcing the Windows-centric approach.
Recommendations
- Add equivalent Azure CLI (az) examples for all PowerShell commands, as Azure CLI is cross-platform and widely used on Linux and macOS.
- Include Bash shell script examples where appropriate, especially for scripting scenarios.
- Explicitly mention that per-app scaling can be configured using Azure CLI and provide links or references to relevant documentation.
- Balance the order of examples by presenting Azure CLI or ARM template examples before or alongside PowerShell examples.
- Review metadata and custom tags to ensure they do not exclusively reference Windows/Powershell tooling.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/configure-linux-open-ssh-session.md
...ticles/app-service/configure-linux-open-ssh-session.md
High Priority
View Details â
Detected Bias Types
windows_first
missing_linux_example
windows_tools
Summary
The documentation page demonstrates a Windows-first bias by presenting Windows container information before Linux, and by providing more detailed, actionable SSH instructions and examples for Linux containers only. Windows containers are described as requiring no modifications, but there are no equivalent CLI or PowerShell examples for Windows containers, nor is there guidance for SSH access outside the browser. This leaves Linux users with richer, more practical guidance, while Windows users are limited to browser-based access and lack parity in tooling or command-line examples.
Recommendations
- Provide equivalent command-line (CLI or PowerShell) instructions for opening SSH sessions to Windows containers, or clearly state if such access is not possible and why.
- If browser-based SSH is the only supported method for Windows containers, explicitly mention this limitation and suggest any available workarounds or alternatives.
- Balance the order of presentation by either combining Linux and Windows guidance where possible or alternating which platform is presented first.
- Include references to Windows-native tools (such as PowerShell or Windows Terminal) for SSH access if supported, or clarify their absence.
- Ensure that both Linux and Windows sections contain comparable levels of detail, troubleshooting tips, and example commands.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/includes/deploy-intelligent-apps/deploy-intelligent-apps-linux-dotnet-pivot.md
...ent-apps/deploy-intelligent-apps-linux-dotnet-pivot.md
High Priority
View Details â
Detected Bias Types
windows_first
missing_linux_example
windows_tools
Summary
The documentation demonstrates a Windows bias by prioritizing Windows/Visual Studio workflows (e.g., right-clicking folders, using the NuGet package manager in Visual Studio) and omitting explicit Linux or cross-platform command-line instructions for common tasks such as file creation, package installation, and deployment. While some CLI links are provided, the main narrative and step-by-step instructions assume a Windows GUI environment, leaving Linux users without equivalent guidance.
Recommendations
- For every Visual Studio or GUI-based instruction (e.g., right-click to add files), provide equivalent command-line instructions suitable for Linux/macOS users (e.g., using 'touch' or 'mkdir').
- When referencing the NuGet package manager in Visual Studio, also include explicit 'dotnet add package' CLI commands for installing dependencies.
- Clarify that all .NET 8 Blazor development steps can be performed on Linux/macOS using the .NET CLI, and provide links or brief instructions for setting up the development environment on those platforms.
- When mentioning navigation in the Azure Portal, note that the experience is platform-agnostic, but also provide Azure CLI or ARM template alternatives for configuration steps where possible.
- Add a section or callout summarizing cross-platform compatibility and pointing to resources for Linux/macOS developers.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/overview-inbound-outbound-ips.md
.../articles/app-service/overview-inbound-outbound-ips.md
High Priority
View Details â
Detected Bias Types
windows_first
powershell_heavy
missing_linux_example
windows_tools
Summary
The documentation page demonstrates a moderate Windows bias. PowerShell examples are provided alongside Azure CLI, but there are no explicit Linux shell or Bash script examples for key operations (e.g., retrieving outbound IPs). In the section on outbound IPv6 support, it is noted that outbound IPv6 is only available for Windows apps, with Linux apps limited to IPv4. The documentation references Azure PowerShell cmdlets and does not mention Linux-native tools or workflows (such as Bash scripting, jq, or curl for API queries) except for a single 'curl' example for IPv6 testing. The order of examples often presents Windows/PowerShell before CLI or Linux-relevant methods.
Recommendations
- For every PowerShell example, provide an equivalent Bash/Azure CLI example, and ensure both are given equal prominence and ordering.
- Explicitly mention Linux support or limitations in all relevant sections, not only for IPv6 outbound.
- Where possible, include Linux-native tools (e.g., Bash with az CLI and jq) for querying properties, especially in 'Find outbound IPs' and similar sections.
- Avoid presenting Windows/PowerShell examples before CLI/Bash; alternate the order or present them in parallel tabs.
- Clarify in the documentation when a feature is Windows-only, and suggest workarounds or alternatives for Linux users.
- Expand the 'Test IPv6 connectivity' section with Windows and Linux command-line examples, if differences exist.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/overview-local-cache.md
...blob/main/articles/app-service/overview-local-cache.md
High Priority
View Details â
Detected Bias Types
windows_first
windows_tools
missing_linux_example
Summary
The documentation page demonstrates a Windows-first bias by exclusively referencing Windows-style paths (e.g., D:\home), using Windows-centric terminology, and omitting Linux-specific examples or instructions. Tools and folder structures are described only in the context of Windows, and there is no guidance for Linux-based App Service environments. The only mention of Linux is to state that the feature is unsupported for Linux containers, without further Linux-specific context or alternatives.
Recommendations
- Provide equivalent Linux path examples (e.g., /home/site) alongside Windows paths.
- Include instructions or notes for Linux-based App Service environments, even if only to clarify differences or limitations.
- Mention and describe Linux tools or commands where applicable, such as how to check folder sizes or environment variables in Linux environments.
- Clarify which features or settings apply to Windows, Linux, or both, and provide parity in documentation structure.
- If a feature is unsupported on Linux, offer links or references to Linux alternatives (such as App Cache) and describe how to use them.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/overview-vnet-integration.md
...main/articles/app-service/overview-vnet-integration.md
High Priority
View Details â
Detected Bias Types
windows_first
windows_tools
missing_linux_example
Summary
The documentation page demonstrates a Windows bias by providing detailed, specific guidance and calculations for Windows Containers (including subnet sizing and networking units), while Linux containers and apps are only briefly mentioned. The only explicit Linux-specific section is a short note about network dependencies for Linux continuous deployment, with no comparable depth or example calculations as provided for Windows. There are no Linux-specific examples or parity in the subnet/IP calculation guidance, and Windows terminology and patterns (such as Windows Server Active Directory, NetBIOS, and Windows Containers) are mentioned without Linux equivalents or alternatives.
Recommendations
- Add equivalent subnet/IP calculation examples and guidance for Linux containers and Linux App Service plans, similar to the detailed Windows Containers section.
- Include Linux-specific limitations, considerations, or best practices where applicable (e.g., for networking, scaling, or integration).
- Provide examples or references for Linux-based tools or patterns (e.g., integration with Linux authentication mechanisms, Linux-based storage mounts, etc.) where Windows-specific features are discussed.
- Ensure that Linux and Windows examples are presented with parity and, where possible, in parallel, rather than focusing on Windows first or exclusively.
- Clarify when guidance is Windows-specific and provide Linux alternatives or explicitly state if a feature/limitation applies to both platforms.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/troubleshoot-performance-degradation.md
...es/app-service/troubleshoot-performance-degradation.md
High Priority
View Details â
Detected Bias Types
powershell_heavy
windows_tools
windows_first
missing_linux_example
Summary
The documentation page demonstrates a Windows bias by referencing Windows-specific tools (such as IIS, Procdump, and PowerShell), providing links and examples that are Windows-centric, and omitting equivalent Linux guidance. Diagnostic and troubleshooting steps focus on Windows App Service features, with no mention of Linux-specific logging, diagnostic tools, or command-line examples. The Kudu console is described in terms of PowerShell and DOS commands, and links reference Windows Azure resources. There are no Linux command-line examples or references to Linux-native tools.
Recommendations
- Include Linux-specific troubleshooting steps, such as using SSH, Bash, or Linux-native diagnostic tools (e.g., strace, lsof, top).
- Provide examples and instructions for enabling diagnostics and collecting logs on Linux App Service plans, including differences in log file locations and formats.
- Mention and link to Linux equivalents for tools like Procdump (e.g., gcore, gdb) and explain how to collect memory dumps on Linux.
- Update references to the Kudu console to clarify differences between Windows and Linux App Service environments (e.g., Bash vs. PowerShell availability).
- Add parity in code and command examples, ensuring both Windows and Linux users are supported throughout the troubleshooting process.
- Where features are Windows-only (such as IIS-specific diagnostics), clearly state this and provide alternative guidance for Linux users.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/troubleshoot-diagnostic-logs.md
...n/articles/app-service/troubleshoot-diagnostic-logs.md
High Priority
View Details â
Detected Bias Types
windows_first
missing_linux_example
windows_tools
Summary
The documentation page demonstrates a Windows-first bias by providing detailed, step-by-step instructions and feature coverage for Windows App Service apps before Linux equivalents. Several logging features (web server logging, detailed error messages, failed request tracing) are described only for Windows, with no Linux or container alternatives or workarounds mentioned. Windows-specific tools and log formats (e.g., W3C, Log Parser, D:\ paths) are referenced without Linux parallels. Linux instructions are present but less detailed and sometimes limited to basic configuration, lacking parity with Windows features.
Recommendations
- Provide equivalent, detailed instructions for Linux and container-based App Service apps for all logging features, or clearly state if a feature is unavailable.
- Include Linux-specific examples, such as log file paths, tools for viewing logs (e.g., tail, less, jq), and troubleshooting steps.
- If certain logging types (web server logging, detailed error messages, failed request tracing) are not supported on Linux, explicitly mention this and suggest alternative approaches or workarounds.
- Avoid referencing only Windows tools (e.g., Log Parser, D:\ paths) and include Linux alternatives (e.g., /home/LogFiles, grep, awk).
- Structure sections so that Linux and Windows instructions are presented with equal prominence, or group them together for direct comparison.
- Expand code examples to include Linux-friendly languages and frameworks, not just .NET/ASP.NET.
Application Gateway
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/application-gateway/application-gateway-private-deployment.md
...tion-gateway/application-gateway-private-deployment.md
High Priority
View Details â
Detected Bias Types
windows_first
powershell_heavy
missing_linux_example
Summary
The documentation presents Azure PowerShell examples and references before Azure CLI, and uses PowerShell-specific cmdlets for status checks even in CLI sections. There are no explicit Linux/Bash shell examples, and the workflow assumes familiarity with PowerShell. The Azure Portal is also emphasized, which is platform-neutral but often associated with Windows-centric workflows. No Linux-specific tools, commands, or screenshots are provided.
Recommendations
- Ensure that CLI (az) examples are fully self-contained and do not reference PowerShell cmdlets (e.g., use 'az feature show' instead of 'Get-AzProviderFeature' in CLI sections).
- Provide Bash/Linux shell command examples alongside or before PowerShell, especially for status checks and scripting scenarios.
- Include explicit notes or sections for Linux/macOS users, clarifying that all CLI commands work cross-platform and providing sample shell commands where appropriate.
- Where screenshots or UI steps are shown, consider including CLI/Bash alternatives for parity.
- Review and update output examples to match the tool being demonstrated (e.g., show 'az' output in CLI sections, not PowerShell output).
Application Gateway
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/application-gateway/overview-v2.md
.../blob/main/articles/application-gateway/overview-v2.md
High Priority
View Details â
Detected Bias Types
powershell_heavy
windows_tools
missing_linux_example
windows_first
Summary
The documentation page demonstrates a Windows bias by providing migration and registration/unregistration examples exclusively using Azure PowerShell cmdlets (e.g., Set-AzContext, Get-AzProviderFeature, Register-AzProviderFeature), which are primarily associated with Windows environments. There are no equivalent Bash or cross-platform Azure CLI examples, and the only tutorial linked is for PowerShell. The documentation does not mention or provide Linux-native workflows or examples, nor does it clarify cross-platform compatibility for the provided commands.
Recommendations
- Provide equivalent Azure CLI (bash) examples for all PowerShell scripts and registration/unregistration steps, ensuring Linux and macOS users have clear guidance.
- Explicitly mention when a command is cross-platform, and clarify any platform-specific requirements.
- Include links to tutorials and documentation that use Azure CLI and/or ARM templates, not just PowerShell.
- Balance references to PowerShell and CLI in both text and linked resources, ensuring neither is prioritized without justification.
- Add a section or note highlighting cross-platform management options for Azure Application Gateway, including Linux/macOS support.
Application Gateway
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/application-gateway/quick-create-template.md
.../articles/application-gateway/quick-create-template.md
High Priority
View Details â
Detected Bias Types
powershell_heavy
missing_linux_example
windows_tools
Summary
The documentation demonstrates a Windows bias by providing only a PowerShell command for resource cleanup, referencing IIS (a Windows-only web server) for validation, and not offering Linux/CLI alternatives for these steps. There are no examples or guidance for users on Linux systems, and the validation step assumes a Windows environment.
Recommendations
- Provide equivalent Azure CLI commands for all PowerShell examples, especially for resource cleanup (e.g., az group delete).
- Include instructions for validating the deployment using a Linux-based web server (such as Nginx or Apache) in the backend VMs, or clarify how to adapt the template for Linux VMs.
- Offer both Windows and Linux examples side-by-side where possible, especially in testing and validation steps.
- Explicitly mention that the template deploys Windows VMs with IIS, and provide a link or alternative template for deploying Linux VMs if appropriate.
Automation
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/automation/automation-hrw-run-runbooks.md
...ain/articles/automation/automation-hrw-run-runbooks.md
High Priority
View Details â
Detected Bias Types
windows_first
powershell_heavy
windows_tools
missing_linux_example
Summary
The documentation exhibits a Windows-first and PowerShell-centric bias. Windows instructions, tools, and examples are consistently presented before their Linux equivalents, and in some sections, only Windows/PowerShell examples are provided. Windows-specific tools (e.g., Control Panel, cert store paths) are detailed, while Linux alternatives are less emphasized or less thoroughly explained. PowerShell is the default scripting language throughout, with limited or no examples for Bash or native Linux scripting. Some advanced features (like Hybrid Worker Credentials) are not supported or documented for Linux, and this is only noted as a limitation rather than providing alternatives.
Recommendations
- Present Linux and Windows instructions/examples in parallel or with equal prominence, rather than always listing Windows first.
- Provide equivalent Bash or Python examples for runbook authentication, starting runbooks, and other automation tasks, not just PowerShell.
- Include Linux-native tools and workflows (e.g., environment variable management, certificate/key management) with the same level of detail as Windows tools.
- Where features are unsupported on Linux (e.g., Hybrid Worker Credentials), suggest alternative approaches or workarounds for Linux users.
- Add more Linux-specific troubleshooting and logging guidance, matching the depth provided for Windows.
- Where possible, use cross-platform language (e.g., 'command line' instead of 'PowerShell prompt') and clarify when instructions are OS-specific.
Azure Cache For Redis
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-cache-for-redis/cache-how-to-redis-cli-tool.md
...s/azure-cache-for-redis/cache-how-to-redis-cli-tool.md
High Priority
View Details â
Detected Bias Types
windows_first
windows_tools
powershell_heavy
Summary
The documentation demonstrates a mild Windows bias. Windows-specific patterns and tools (such as WSL and Windows Terminal) are mentioned prominently, sometimes before or instead of native Linux alternatives. Azure PowerShell is referenced alongside Azure CLI, and in some cases, Windows-specific instructions are more detailed than their Linux counterparts.
Recommendations
- Provide native Linux and macOS installation and usage instructions with equal prominence to Windows/WSL instructions.
- When listing ways to retrieve cache keys, list Azure CLI (cross-platform) before Azure PowerShell (Windows-centric), and consider including REST API or SDK options.
- Avoid assuming Windows as the default environment; clarify that redis-cli runs natively on Linux and macOS, and only mention WSL as a workaround for Windows users.
- When referencing terminals, mention cross-platform options (e.g., GNOME Terminal, iTerm2, Windows Terminal) equally.
- Ensure all examples and troubleshooting steps are applicable and clearly described for both Linux and Windows users.
Azure Cache For Redis
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-cache-for-redis/cache-best-practices-performance.md
...re-cache-for-redis/cache-best-practices-performance.md
High Priority
View Details â
Detected Bias Types
windows_first
powershell_heavy
missing_linux_example
Summary
The documentation page demonstrates a subtle Windows bias. All command-line examples are shown using the `dos` code block, which implies Windows Command Prompt usage, and there are no explicit Linux/bash shell examples for redis-benchmark. While the tools discussed (redis-benchmark, memtier-benchmark) are cross-platform, the documentation does not provide Linux-specific guidance or parity in example commands. There is also a lack of mention of Linux-specific considerations or instructions, and the code block language choice may mislead Linux users.
Recommendations
- Provide all redis-benchmark examples in both Windows (cmd) and Linux (bash/sh) formats, using appropriate code block annotations (e.g., ```bash for Linux, ```cmd for Windows).
- Include explicit instructions or notes for Linux users, such as installation steps, command syntax differences, and environment-specific considerations.
- Mention that redis-benchmark and memtier-benchmark are cross-platform and clarify any OS-specific behaviors or requirements.
- Avoid using only 'dos' code blocks for CLI examples; use 'bash' or 'sh' for Linux and 'cmd' or 'powershell' for Windows, or provide both side by side.
- Add a section or callout for Linux users to ensure parity and inclusivity.
Azure Functions
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/dotnet-isolated-process-guide.md
...icles/azure-functions/dotnet-isolated-process-guide.md
High Priority
View Details â
Detected Bias Types
windows_first
windows_tools
powershell_heavy
missing_linux_example
Summary
The documentation demonstrates a moderate Windows bias. Windows-specific tools and configuration steps are often mentioned before or more prominently than their Linux equivalents. In several sections, Windows commands, settings, and tools (such as Visual Studio, PowerShell, and Windows-specific Azure CLI flags) are listed first or exclusively, while Linux alternatives are mentioned later or in less detail. Some deployment and configuration examples focus on Windows, with Linux instructions provided as secondary or in separate tabs. There is also a lack of explicit Linux shell or scripting examples, and PowerShell is referenced as a primary automation tool.
Recommendations
- Ensure that all command-line examples are provided for both Windows (PowerShell/CMD) and Linux (Bash), ideally side-by-side or in tabs.
- When listing tools or methods (e.g., Visual Studio, Visual Studio Code, Azure CLI, PowerShell), avoid always listing Windows-specific tools first; alternate the order or group by platform.
- Provide Linux-specific instructions and examples wherever Windows-specific ones are given (e.g., for setting environment variables, publishing, or debugging).
- Include Bash/Azure CLI examples for common tasks, not just PowerShell or Visual Studio workflows.
- Clarify when a tool or feature is Windows-only, and suggest Linux alternatives where possible.
- Review and update deployment and configuration sections to ensure Linux parity, including explicit references to Linux containers, shell commands, and file paths.
Azure Netapp Files
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-netapp-files/azure-netapp-files-create-volumes-smb.md
...-netapp-files/azure-netapp-files-create-volumes-smb.md
High Priority
View Details â
Detected Bias Types
windows_first
missing_linux_example
windows_tools
Summary
The documentation page demonstrates a Windows bias in several ways: it provides only Windows-based instructions and screenshots for managing SMB permissions (using Windows MMC and the Security tab in Windows SMB clients), does not mention or provide Linux client examples for accessing or managing SMB shares, and references Windows-specific tools and workflows without Linux equivalents. Linux SMB clients and tools (such as smbclient, mount.cifs, or setfacl) are not discussed, and the documentation assumes a Windows administrative environment.
Recommendations
- Add instructions and examples for accessing and managing SMB shares from Linux clients, including mounting SMB volumes using mount.cifs and managing permissions with setfacl or similar tools.
- Include Linux command-line examples (e.g., using smbclient or mount.cifs) alongside or after Windows examples to ensure parity.
- Mention Linux tools and workflows for SMB management where Windows tools (like MMC) are referenced.
- Provide screenshots or terminal output from Linux environments where relevant.
- Clarify in the 'Control access to an SMB volume' section how permissions can be managed from non-Windows clients, and note any limitations or differences.
Azure Functions
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/functions-reference-java.md
...n/articles/azure-functions/functions-reference-java.md
High Priority
View Details â
Detected Bias Types
windows_first
powershell_heavy
missing_linux_example
Summary
The documentation generally strives for cross-platform parity, but there are subtle Windows biases. Command-line examples are consistently provided for both Bash (Linux/macOS) and Cmd (Windows), but the Windows/Cmd tabs are always listed second, which is a positive. However, there is a slight overemphasis on Windows in some areas: references to 'command prompt' (a Windows term) in getting started, and the use of 'cmd' tabs (rather than 'powershell' or 'terminal') for Windows. There are no explicit Linux-only examples or Linux-specific troubleshooting, and some terminology (e.g., 'command prompt') may be confusing for Linux users. IDE instructions include both Windows- and Linux-friendly tools, but the initial mention of 'command prompt' before 'terminal' could be improved. No Windows-only tools are recommended, but the parity of examples could be more explicit.
Recommendations
- Replace 'command prompt' with 'terminal' or 'shell' in all cross-platform contexts, or use 'command prompt/terminal' to be inclusive.
- Wherever command-line examples are given, ensure the Bash (Linux/macOS) tab is listed first, and clarify that Cmd is for Windows.
- Add explicit notes or troubleshooting tips for Linux users where OS-specific issues may arise (e.g., file permissions, environment variable syntax).
- Consider including a short section or callout on Linux/macOS prerequisites or common issues, to balance the implicit Windows focus.
- Where possible, use 'terminal' as the default term and only specify 'command prompt' or 'Cmd' when referring to Windows-specific instructions.
- If possible, add at least one Linux/macOS-specific example or tip (e.g., setting JAVA_HOME in .bashrc) to demonstrate parity.
Azure Netapp Files
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-netapp-files/azure-netapp-files-mount-unmount-volumes-for-virtual-machines.md
...etapp-files-mount-unmount-volumes-for-virtual-machines.md
High Priority
View Details â
Detected Bias Types
windows_first
missing_linux_example
windows_tools
Summary
The documentation provides both Linux and Windows instructions for mounting NFS volumes, but there are subtle biases. The Windows section is presented after Linux, but the Windows instructions require first mounting on Linux and running chmod, which may not be intuitive for Windows-only administrators. The Windows example uses the Windows 'Mount' command and references Windows documentation, but does not provide a PowerShell example or alternative. The Linux section is more detailed, with explicit mount command examples and fstab configuration, while the Windows section is brief and lacks troubleshooting or advanced options. There is also an implicit assumption that Linux is the primary platform for NFS, with Windows as a secondary, less-supported use case.
Recommendations
- Provide a more complete Windows example, including PowerShell syntax and troubleshooting tips for common issues.
- Clarify the prerequisite for mounting on Linux (chmod) and explain why this is necessary for Windows users.
- Offer parity in detail between Linux and Windows sections, such as automounting on Windows (e.g., via persistent mounts or scripts).
- Include references to Linux and Windows tools equally, and consider presenting both platforms' instructions side by side for each step.
- Add troubleshooting guidance for both Linux and Windows, not just Linux.
- Explicitly mention any limitations or differences in NFS support between Linux and Windows early in the document.
Azure Netapp Files
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-netapp-files/manage-cool-access.md
...main/articles/azure-netapp-files/manage-cool-access.md
High Priority
View Details â
Detected Bias Types
powershell_heavy
windows_first
missing_linux_example
Summary
The documentation page demonstrates a Windows bias by providing only Azure PowerShell examples for feature registration, mentioning PowerShell before Azure CLI, and omitting explicit Linux/CLI/bash examples. The registration steps are shown with PowerShell commands, and while Azure CLI is mentioned, no CLI command-line examples are provided. There are no Linux-specific instructions or screenshots, and the workflow assumes a GUI experience typical of Windows environments.
Recommendations
- Provide explicit Azure CLI command examples alongside PowerShell for all registration and configuration steps, including full command syntax and expected output.
- Include bash shell examples for Linux users where appropriate, especially for scripting or automation tasks.
- Ensure that any GUI instructions clarify that the Azure Portal is cross-platform, and avoid language that assumes a Windows-only environment (e.g., 'right-click' could be replaced with 'select the context menu').
- Add a section or callout for Linux/macOS users, highlighting any differences or confirming parity.
- Where screenshots are used, ensure they do not display Windows-specific UI elements or clarify that the experience is the same across platforms.
Backup
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/backup/about-azure-vm-restore.md
...cs/blob/main/articles/backup/about-azure-vm-restore.md
High Priority
View Details â
Detected Bias Types
powershell_heavy
windows_first
missing_linux_example
windows_tools
Summary
The documentation page demonstrates a Windows bias by referencing PowerShell as the tool for restoring encrypted VMs, and by linking exclusively to Windows-specific encryption documentation. There are no Linux-specific examples, tools, or references for restoring Linux VMs, particularly in scenarios involving encryption or item-level restore. The documentation assumes Windows as the default context for advanced restore scenarios, omitting Linux parity.
Recommendations
- Include equivalent Linux restore instructions and examples, especially for scenarios involving encrypted VMs. Reference Azure CLI, Bash, or other Linux-native tools where appropriate.
- Add links to Linux VM encryption documentation (e.g., Azure Disk Encryption for Linux) and describe the restore process for encrypted Linux VMs.
- Ensure that item-level restore scenarios mention both Windows and Linux file systems, and clarify any differences in supported features or workflows.
- When referencing tools (e.g., PowerShell), also mention and provide examples for cross-platform tools such as Azure CLI or REST API.
- Review all scenario tables and ensure that Linux-specific considerations or limitations are explicitly documented alongside Windows information.
Azure Netapp Files
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-netapp-files/manage-file-access-logs.md
...articles/azure-netapp-files/manage-file-access-logs.md
High Priority
View Details â
Detected Bias Types
windows_first
powershell_heavy
missing_linux_example
windows_tools
Summary
The documentation exhibits a Windows bias by providing detailed, step-by-step instructions for setting SACLs (auditing) on SMB shares using the Windows GUI, while the equivalent Linux/NFSv4.1 instructions are minimal and refer users to another page. The registration example (in the commented-out section) uses Azure PowerShell first, with Azure CLI only mentioned as an alternative. There are no Linux command-line examples for setting Audit ACEs, and Windows tools and workflows are described in more detail and appear first.
Recommendations
- Provide step-by-step Linux command-line examples for setting Audit ACEs on NFSv4.1 shares, similar to the detailed Windows instructions for SMB.
- When describing feature registration, present both Azure PowerShell and Azure CLI examples side by side, or lead with the CLI, which is cross-platform.
- Avoid referring to Windows administration hosts and tools as the default; instead, clarify that equivalent operations can be performed from Linux systems and provide those instructions.
- Ensure parity in detail and clarity between Windows and Linux/NFS sections, including screenshots or command examples where appropriate.
- Explicitly mention and link to Linux tools (such as setfacl or nfs4_setfacl) for managing ACLs on NFS shares.
Azure Netapp Files
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-netapp-files/snapshots-introduction.md
.../articles/azure-netapp-files/snapshots-introduction.md
High Priority
View Details â
Detected Bias Types
windows_first
powershell_heavy
missing_linux_example
Summary
The documentation page demonstrates a Windows bias in the way it lists PowerShell as a primary tool for snapshot management, often mentioning it before or alongside Azure CLI and REST API, but without providing parity for Linux-specific tools or shell scripting. There are no Linux/Unix shell (bash) command examples or references, and scripting is only linked to a Microsoft Tech Community blog focused on SQL Server (a Windows-centric workload). The documentation does not provide explicit Linux/NFS client examples for snapshot operations, despite Azure NetApp Files' strong Linux/NFS use case.
Recommendations
- Provide explicit bash/Azure CLI command examples for common snapshot operations, such as creating, listing, and deleting snapshots, alongside or before PowerShell examples.
- Include Linux/NFS client examples for restoring files from snapshots, such as using standard Linux commands (cp, rsync) to access the .snapshot directory.
- When listing tools for manual or automated snapshot management, avoid listing PowerShell first or exclusively; instead, present Azure CLI and REST API equally or before PowerShell, and mention bash scripting.
- Add references or links to Linux-focused documentation or community resources for managing Azure NetApp Files snapshots.
- Ensure that scripting examples are cross-platform, or provide both PowerShell and bash equivalents.
Azure Resource Manager
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-resource-manager/templates/key-vault-parameter.md
...zure-resource-manager/templates/key-vault-parameter.md
High Priority
View Details â
Detected Bias Types
windows_first
powershell_heavy
windows_tools
Summary
The documentation provides both Azure CLI and PowerShell examples throughout, but the PowerShell examples are prominent and sometimes more detailed (e.g., handling secure strings). The PowerShell examples use Windows-specific cmdlets and patterns, and the documentation references Windows scenarios (such as installing a certificate on a Windows VM) before mentioning general or cross-platform scenarios. There is no mention of Linux-specific tools, shell scripting, or guidance for Linux users, and the PowerShell examples assume a Windows environment.
Recommendations
- Explicitly mention that Azure CLI is cross-platform and suitable for Linux, macOS, and Windows.
- Add Bash shell scripting examples alongside PowerShell, especially for parameter file creation and deployment steps.
- When referencing VM scenarios, provide both Windows and Linux quickstart links or examples.
- Clarify that PowerShell Core is available cross-platform, but provide Bash alternatives for Linux users.
- Ensure that any advanced scripting (such as secure string handling) has a Linux/Bash equivalent.
- Review and balance the order of examples so that Azure CLI (cross-platform) is presented first, or alternate the order to avoid implicit Windows-first bias.
Azure Resource Manager
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-resource-manager/templates/test-toolkit.md
...icles/azure-resource-manager/templates/test-toolkit.md
High Priority
View Details â
Detected Bias Types
powershell_heavy
windows_first
windows_tools
Summary
The documentation is heavily PowerShell-centric, reflecting the fact that the ARM template test toolkit is implemented as a set of PowerShell scripts. All usage examples, including those for Linux and macOS, require PowerShell (pwsh) and do not provide alternatives using native Linux/Unix shell tools or scripting languages. The Windows installation instructions are presented before Linux and macOS, and the overall workflow assumes familiarity with PowerShell commands and concepts (e.g., execution policy, Import-Module). There is no mention of using the toolkit outside PowerShell, nor are there any Bash, Python, or other cross-platform scripting examples.
Recommendations
- Clearly state at the beginning that the toolkit is PowerShell-based and required on all platforms.
- Consider providing or linking to wrapper scripts or Docker containers that allow running the toolkit without requiring users to install PowerShell, especially for Linux users.
- If possible, develop and document alternative usage patterns or tools for Linux users who may not be familiar with PowerShell (e.g., Bash scripts that invoke PowerShell, or a CLI wrapper).
- Present Linux and macOS instructions before or alongside Windows instructions to avoid the impression of Windows primacy.
- Explicitly acknowledge the PowerShell dependency as a limitation for some Linux environments and suggest workarounds or community solutions.
- Where possible, provide example commands in both Windows and Linux/macOS path formats and shell conventions.
Backup
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/backup/backup-azure-vms-agentless-multi-disk-crash-consistent-overview.md
...ure-vms-agentless-multi-disk-crash-consistent-overview.md
High Priority
View Details â
Detected Bias Types
windows_first
windows_tools
missing_linux_example
Summary
The documentation demonstrates a mild Windows bias by mentioning Windows-specific tools (Volume Shadow Copy Service, VM Agent, snapshot extension) before their Linux equivalents, and by linking only to Windows-specific agent/extension documentation. There are no Linux command or tool examples, and Linux mechanisms (fsfreeze) are mentioned only in passing, without links or further explanation.
Recommendations
- Provide equal prominence to Linux tools and mechanisms (e.g., link to documentation about fsfreeze and Linux VM agents/extensions).
- Include examples or references for both Windows and Linux environments when discussing backup mechanisms and requirements.
- Avoid listing Windows tools or documentation links before Linux equivalents; present both together or in parallel.
- Clarify any differences in agent/extension requirements for Linux VMs and provide relevant links.
- Add a section or note specifically addressing Linux backup considerations, including references to Linux documentation.
Backup
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/backup/backup-azure-vms-introduction.md
.../main/articles/backup/backup-azure-vms-introduction.md
High Priority
View Details â
Detected Bias Types
windows_first
missing_linux_example
windows_tools
Summary
The documentation demonstrates a Windows-first bias in several areas. In the snapshot creation section, Windows (VSS) is described in detail before Linux, and the Linux process is described only in terms of requiring custom scripts, with no concrete example or guidance. Windows-specific tools (VSS) are mentioned by name, while the Linux equivalent ('freeze') is only briefly referenced in a note. There are no Linux command examples or detailed walkthroughs, whereas PowerShell is mentioned for restore operations. Overall, Linux users receive less actionable guidance and fewer concrete examples.
Recommendations
- Provide concrete Linux examples for backup and restore operations, including sample pre/post scripts for common applications (e.g., MySQL, PostgreSQL).
- Mention Linux tools (such as 'fsfreeze', 'LVM snapshots', etc.) explicitly and describe their role in achieving consistency, similar to the VSS explanation for Windows.
- Balance the order of presentation: describe Linux and Windows processes in parallel, rather than always listing Windows first.
- Include Linux CLI (az CLI, bash) examples for backup and restore tasks, not just PowerShell.
- Offer troubleshooting guidance for Linux snapshot issues, similar to the linked Windows troubleshooting article.
Backup
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/backup/restore-azure-encrypted-virtual-machines.md
...les/backup/restore-azure-encrypted-virtual-machines.md
High Priority
View Details â
Detected Bias Types
powershell_heavy
windows_first
missing_linux_example
windows_tools
Summary
The documentation shows a Windows bias by providing explicit PowerShell instructions for restoring VMs from disks, referencing Windows-specific tools (such as OS disk swap documentation pointing to Windows), and only mentioning Linux-specific steps as a brief afterthought. There are no Linux CLI or automation examples, and Windows/PowerShell approaches are prioritized or exclusively detailed.
Recommendations
- Provide equivalent CLI and automation examples for Linux, such as using Azure CLI or Bash scripts to create a VM from restored disks.
- Include links to Linux-specific documentation for operations like OS disk swap, not just Windows.
- Ensure Linux restore steps are as detailed as Windows/PowerShell steps, including example commands and troubleshooting.
- Present Windows and Linux instructions in parallel or with equal prominence, rather than relegating Linux to a separate, less-detailed section.
Backup
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/backup/backup-azure-arm-restore-vms.md
...b/main/articles/backup/backup-azure-arm-restore-vms.md
High Priority
View Details â
Detected Bias Types
windows_first
missing_linux_example
windows_tools
powershell_heavy
Summary
The documentation demonstrates a Windows bias by prioritizing or exclusively mentioning Windows-specific tools, examples, and workflows. Windows and PowerShell are referenced more frequently and earlier than Linux equivalents. There are missing Linux-specific examples, and guidance for Linux users is minimal or absent, especially in advanced or troubleshooting scenarios.
Recommendations
- Provide Linux-specific examples alongside Windows ones, especially for tasks like restoring VMs, attaching disks, and post-restore steps.
- Include references to Azure CLI and Bash scripts, not just PowerShell, for automation and VM creation from restored disks.
- When mentioning Windows tools (e.g., bcdedit, netdom), also provide equivalent Linux troubleshooting steps (e.g., using GRUB, chroot, SSH recovery).
- Balance references to Windows and Linux documentation, such as linking to both Windows and Linux VM management guides.
- Explicitly state when a process or feature is OS-agnostic, and clarify any OS-specific limitations or requirements.
- Add Linux-focused troubleshooting and post-restore guidance, such as handling cloud-init, resetting SSH keys, or repairing bootloaders.
Backup
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/backup/sap-hana-database-instances-restore.md
...articles/backup/sap-hana-database-instances-restore.md
High Priority
View Details â
Detected Bias Types
windows_first
powershell_heavy
missing_linux_example
Summary
The documentation demonstrates a Windows bias by referencing PowerShell and CLI scripts for permission management without providing explicit Linux (bash) examples or guidance. The workflow and terminology are oriented around the Azure portal and PowerShell, with no mention of Linux-native tools or command-line patterns. There are no screenshots or instructions that show Linux environments, and the documentation assumes familiarity with Windows-centric tools.
Recommendations
- Provide explicit bash/Linux shell script examples for permission management and disk mounting, alongside or before PowerShell examples.
- Include screenshots or step-by-step instructions for restoring SAP HANA on Azure VMs running Linux, reflecting the typical SAP HANA deployment environment.
- Reference Linux-native tools (such as az CLI commands run from bash) and clarify any OS-specific steps for mounting and restoring disks.
- Avoid assuming PowerShell as the default scripting environment; mention both PowerShell and bash/CLI options equally.
- Add a section or callout specifically addressing Linux users, with guidance tailored to common Linux distributions used for SAP HANA.
Backup
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/backup/backup-sql-server-azure-troubleshoot.md
...rticles/backup/backup-sql-server-azure-troubleshoot.md
High Priority
View Details â
Detected Bias Types
windows_first
missing_linux_example
windows_tools
powershell_heavy
Summary
The documentation page demonstrates a strong Windows bias. All examples, file paths, and troubleshooting steps reference Windows-specific tools, directories (e.g., C:\Program Files), and processes. There is no mention of Linux-based SQL Server VMs, nor are there any Linux file paths, tools, or instructions. PowerShell is referenced as the automation method, and all extension and agent installation guidance is for Windows. This excludes users running SQL Server on Linux VMs in Azure, despite SQL Server's cross-platform support.
Recommendations
- Add parallel instructions and examples for SQL Server on Linux VMs, including Linux file paths (e.g., /opt/azureworkloadbackup), service names, and extension installation steps.
- Provide Linux-specific troubleshooting steps, such as checking systemd services, Linux permissions, and log file locations.
- Include Bash/CLI examples alongside PowerShell for automation and scripting tasks.
- Reference both Windows and Linux VM guest agent installation guides.
- Clearly indicate which steps are Windows-specific and which are Linux-specific, or provide a table comparing the two.
- Mention any limitations or differences in Azure Backup support for SQL Server on Linux VMs, if applicable.
CDN
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/cdn/cdn-map-content-to-custom-domain.md
.../main/articles/cdn/cdn-map-content-to-custom-domain.md
High Priority
View Details â
Detected Bias Types
powershell_heavy
missing_linux_example
windows_tools
Summary
The documentation provides detailed instructions and code samples for performing tasks using the Azure Portal (GUI) and Azure PowerShell, but does not include equivalent command-line examples for Linux/macOS users (e.g., Azure CLI or Bash). The PowerShell examples are presented as the only scripting/automation option, which may disadvantage users on non-Windows platforms. There is no mention of Linux-native tools or cross-platform alternatives.
Recommendations
- Add Azure CLI examples alongside PowerShell for all automation/scripted steps (e.g., adding/removing custom domains).
- Explicitly mention that Azure CLI is cross-platform and provide Bash-compatible command samples.
- Where PowerShell is referenced, clarify that it is available on Linux/macOS, but also offer native Bash/CLI alternatives.
- Ensure that all code blocks and automation steps have parity between PowerShell and CLI, so Linux users are not required to use PowerShell.
- Consider including a table or tabs for 'Azure CLI', 'PowerShell', and 'Portal' for each procedural section.
Bastion
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/bastion/configuration-settings.md
...s/blob/main/articles/bastion/configuration-settings.md
High Priority
View Details â
Detected Bias Types
windows_first
powershell_heavy
windows_tools
Summary
The documentation consistently lists Azure PowerShell (a Windows-centric tool) before Azure CLI (cross-platform) in configuration method tables. There are multiple references to PowerShell-specific cmdlets and patterns, and no explicit mention of Linux-native tools or workflows. While Azure CLI is included, the ordering and emphasis favor Windows/PowerShell, and there are no examples or guidance tailored specifically for Linux users.
Recommendations
- Alternate the order of Azure PowerShell and Azure CLI in tables and examples, or list Azure CLI first to reflect its cross-platform nature.
- Include explicit Linux shell (bash) command examples, especially for common configuration tasks.
- Add references to Linux-native tools or workflows where appropriate (e.g., scripting with bash, using SSH from Linux terminals).
- Clarify that both Azure CLI and PowerShell are cross-platform, but provide guidance for Linux users on installing and using these tools.
- Where possible, provide parity in documentation for both Windows and Linux environments, including screenshots or walkthroughs if relevant.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/app-service-migration-assess-net.md
...ticles/app-service/app-service-migration-assess-net.md
Medium Priority
View Details â
Detected Bias Types
missing_linux_example
windows_tools
Summary
The documentation page focuses on assessing .NET web apps for migration to Azure App Service but does not mention Linux environments, Linux-based .NET apps, or provide any Linux-specific guidance or examples. All referenced materials and terminology implicitly assume a Windows/ASP.NET context, and there is no discussion of Linux tools or assessment nuances for Linux-hosted .NET applications.
Recommendations
- Explicitly mention that .NET web apps can run on both Windows and Linux, and clarify if the assessment process covers both platforms.
- Include examples or notes for assessing .NET Core/ASP.NET Core apps running on Linux servers.
- Reference Linux-compatible tools or scripts for discovery and assessment, if available.
- Add guidance or links for users migrating from Linux environments, highlighting any differences in assessment or migration steps.
- Ensure parity in documentation by providing Linux-specific considerations, such as file system differences, environment variables, and deployment patterns.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/configure-language-java-security.md
...ticles/app-service/configure-language-java-security.md
Medium Priority
View Details â
Detected Bias Types
linux_first
missing_windows_example
Summary
The documentation page demonstrates a Linux-first bias in the sections related to Java key store and certificate management. It provides detailed instructions and examples specifically for Linux-based App Service environments, including file paths, environment variables, and SSH usage, while omitting equivalent instructions or references for Windows-based App Service environments. There are no PowerShell or Windows tool examples, and Windows-specific patterns are not mentioned.
Recommendations
- Add parallel instructions for managing Java key stores and certificates on Windows-based App Service, including file paths (e.g., where certificates are stored on Windows), environment variable usage, and any differences in process.
- Provide examples of how to interact with the Java key store using Windows tools (such as Command Prompt or PowerShell), and document how to access the keytool utility on Windows App Service.
- Clarify in each section whether the instructions apply to both Linux and Windows, or provide separate tabs/pivots for each OS.
- Ensure that references to SSH and Linux file paths are complemented with equivalent instructions for Windows Remote Desktop or Kudu Console where appropriate.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/includes/deploy-intelligent-apps/deploy-intelligent-apps-linux-python-pivot.md
...ent-apps/deploy-intelligent-apps-linux-python-pivot.md
Medium Priority
View Details â
Detected Bias Types
windows_first
missing_linux_example
Summary
The documentation page exhibits a subtle Windows bias by referencing Windows first in the quickstart links and not providing explicit Linux or cross-platform command-line examples. While the main content is OS-agnostic (Python/Flask), the quickstart and setup instructions default to Windows tabs, and there are no explicit Linux or bash shell examples for environment variable setup or deployment. There is also a reliance on Azure Portal UI steps, which may not be as accessible or preferred for Linux users who often use CLI tools.
Recommendations
- Ensure that quickstart and setup links default to cross-platform or Linux-first tabs, or provide parallel instructions for both Windows and Linux.
- Include explicit bash/Linux shell examples for setting environment variables and running the application, not just references to the Azure Portal.
- Wherever possible, provide Azure CLI commands for configuration and deployment steps, in addition to or instead of portal UI instructions.
- Review all code snippets and instructions to ensure they are platform-neutral or provide alternatives for both Windows and Linux environments.
- Clarify in the prerequisites and setup sections that the instructions are applicable to both Windows and Linux, and link to relevant Linux documentation where available.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/tutorial-ai-integrate-azure-ai-agent-dotnet.md
...service/tutorial-ai-integrate-azure-ai-agent-dotnet.md
Medium Priority
View Details â
Detected Bias Types
missing_linux_example
windows_first
Summary
The documentation assumes a development environment based on GitHub Codespaces and .NET, but does not provide any Linux-specific instructions or examples. All terminal commands and deployment steps are generic, but there is no mention of Linux shell usage, nor are there any references to Linux-specific tools or patterns. The workflow implicitly assumes familiarity with Windows-centric .NET development patterns, and there is no guidance for users developing or deploying from a native Linux environment.
Recommendations
- Explicitly mention that the tutorial works on both Windows and Linux environments, and provide any necessary differences (such as file paths or environment variable handling).
- Include Linux shell command equivalents where appropriate, especially for common tasks like running the app, installing dependencies, or deploying.
- Add a note about how to run the sample locally on Linux (e.g., using Bash, setting environment variables, or using Docker).
- If using Codespaces, clarify that it is a Linux-based environment and provide troubleshooting tips for users running locally on Linux.
- Where file paths or commands might differ between Windows and Linux, provide both versions or use cross-platform conventions.
Azure App Configuration
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-app-configuration/concept-enable-rbac.md
...rticles/azure-app-configuration/concept-enable-rbac.md
Medium Priority
View Details â
Detected Bias Types
windows_first
missing_linux_example
Summary
The documentation page demonstrates a subtle Windows bias by referencing Visual Studio Credential as the first and only concrete example of a development environment, which is primarily a Windows tool. There are no explicit Linux or cross-platform command-line examples, nor are Linux development environments (such as VS Code on Linux, CLI, or other editors) mentioned. Additionally, there are no PowerShell-specific commands, but the lack of Linux or cross-platform examples and the prioritization of Windows-centric tools indicate a 'windows_first' and 'missing_linux_example' bias.
Recommendations
- Include examples and references for Linux development environments, such as using VS Code, JetBrains Rider, or command-line interfaces.
- Provide explicit CLI-based instructions (e.g., using Azure CLI) for role assignment and authentication, which are cross-platform.
- Mention cross-platform credential options (such as Azure CLI Credential) alongside Visual Studio Credential.
- Ensure that all steps and tooling references are inclusive of both Windows and Linux users, avoiding the implication that Visual Studio is the default or only development environment.
Azure App Configuration
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-app-configuration/howto-labels-aspnet-core.md
...es/azure-app-configuration/howto-labels-aspnet-core.md
Medium Priority
View Details â
Detected Bias Types
missing_linux_example
windows_first
Summary
The documentation page demonstrates configuring environment-specific values in Azure App Configuration using an ASP.NET Core app. All examples and instructions assume the use of .NET (C#) and reference editing launchSettings.json, which is a pattern typical for Windows development environments. There are no examples or guidance for Linux-based workflows, such as using environment variables via shell or configuring for deployment on Linux servers/containers. The documentation does not mention or show how to set environment variables outside of launchSettings.json, which is not always used in Linux or containerized deployments.
Recommendations
- Add examples for setting environment variables using Linux shell commands (e.g., export ASPNETCORE_ENVIRONMENT=Production) and explain how to run the application in different environments from the command line.
- Mention how to configure environment variables in common Linux deployment scenarios, such as Docker containers or systemd services.
- Clarify that launchSettings.json is primarily used for local development and may not be present or used in production or Linux-based deployments.
- Provide parity in instructions by showing both Windows (launchSettings.json) and Linux (shell/environment) approaches for setting environment variables.
Azure Netapp Files
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-netapp-files/application-volume-group-considerations.md
...etapp-files/application-volume-group-considerations.md
Medium Priority
View Details â
Detected Bias Types
windows_first
windows_tools
Summary
The documentation exhibits a mild Windows bias by linking to Windows-specific instructions for creating proximity placement groups (PPGs) and referencing Windows documentation before or instead of Linux equivalents. There are no explicit PowerShell examples or commands, but the only direct link for PPG creation is to a Windows/portal-specific guide, and there is no mention of Linux tools or CLI-based workflows.
Recommendations
- Provide equivalent Linux-focused documentation links, such as how to create PPGs using the Azure CLI or ARM templates, not just the Azure portal (which is often shown with Windows VM examples).
- When referencing documentation for creating or managing resources (like PPGs), include both Windows and Linux VM scenarios, or use neutral, cross-platform examples.
- Explicitly mention that the procedures apply to both Windows and Linux VMs, or clarify any differences where relevant.
- Add example commands for both Azure CLI and PowerShell where appropriate, to ensure parity for Linux users.
- Review all linked documentation to ensure Linux users are not redirected to Windows-centric guides.
Azure Netapp Files
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-netapp-files/azure-netapp-files-solution-architectures.md
...app-files/azure-netapp-files-solution-architectures.md
Medium Priority
View Details â
Detected Bias Types
windows_first
windows_tools
Summary
The documentation generally maintains parity between Linux and Windows by providing separate, clearly labeled sections for each platform and a balanced set of solution references. However, in some areas, Windows examples or tools are mentioned first (e.g., 'Windows Apps and SQL Server solutions' precedes 'SAP on Azure solutions', and within SAP, Windows NetWeaver is listed before Linux), and certain Windows-specific tools (like DFS Namespaces and FSLogix) are referenced without Linux equivalents. There are no explicit PowerShell-heavy examples or missing Linux examples, but the ordering and tool mentions indicate a mild Windows bias.
Recommendations
- Ensure that Linux and Windows solutions are presented in parallel order or alternate which platform appears first in sections to avoid implicit prioritization.
- Where Windows-specific tools (e.g., DFS Namespaces, FSLogix) are mentioned, provide Linux/NFS alternatives or explicitly state when no direct Linux equivalent exists.
- For sections like SAP NetWeaver, consider listing Linux and Windows guides together or in alphabetical order.
- Highlight cross-platform tools and practices where possible, and ensure that any platform-specific guidance is balanced with equivalent guidance for the other platform.
- Review for any subtle language that may imply Windows is the default or primary use case, and adjust to reflect equal support for Linux.
Azure Netapp Files
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-netapp-files/large-volumes-requirements-considerations.md
...app-files/large-volumes-requirements-considerations.md
Medium Priority
View Details â
Detected Bias Types
powershell_heavy
windows_first
Summary
The documentation page demonstrates a mild Windows bias by providing an Azure PowerShell example for checking feature registration status, with the Azure CLI (cross-platform) alternative only mentioned in text and not shown as a code example. The PowerShell example is given first and is formatted as a code block, while the CLI is referenced parenthetically, making it less visible to Linux/macOS users. No Linux-specific tools or shell examples are provided, and the documentation does not explicitly mention Linux workflows in configuration steps, despite referencing Linux in performance benchmarks.
Recommendations
- Provide both Azure PowerShell and Azure CLI examples as code blocks, with equal prominence and ordering (or alternate which comes first based on context).
- Explicitly mention that Azure CLI commands work cross-platform (Windows, Linux, macOS) to encourage use by non-Windows users.
- Where relevant, include Linux shell (bash) examples for common administrative tasks, especially for steps that can be performed outside of Azure Portal.
- Review other configuration and management sections for similar patterns and ensure Linux parity in examples and tool references.
Azure Resource Manager
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-resource-manager/templates/template-test-cases.md
...zure-resource-manager/templates/template-test-cases.md
Medium Priority
View Details â
Detected Bias Types
windows_tools
windows_first
Summary
The documentation is largely platform-neutral, focusing on ARM template best practices and JSON examples. However, there is a subtle Windows bias in the references to the ARM TTK (test toolkit) and its test cases, which are linked to PowerShell (.ps1) scripts and the toolkit's GitHub repository. The only explicit tool reference is to a .ps1 test case, suggesting PowerShell as the primary interface, which is Windows-centric. There are no explicit Linux/CLI/bash examples or instructions, nor are Linux equivalents mentioned alongside the PowerShell references.
Recommendations
- When referencing the ARM TTK or its test cases, mention that the toolkit can be run cross-platform using PowerShell Core on Linux/macOS, or provide links to instructions for running it on non-Windows systems.
- Include CLI/bash examples or instructions where relevant, especially for running the toolkit or validating templates.
- When linking to .ps1 test cases or scripts, clarify that these can be executed on Linux/macOS with PowerShell Core, and provide guidance for Linux users.
- If there are any Linux-native tools or wrappers for ARM template validation, mention them alongside Windows/PowerShell options.
- Consider adding a 'Platform support' section that explicitly states the toolkit and guidance are cross-platform, and provide parity in instructions for both Windows and Linux users.
Azure Netapp Files
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-netapp-files/whats-new.md
...ocs/blob/main/articles/azure-netapp-files/whats-new.md
Medium Priority
View Details â
Detected Bias Types
windows_first
windows_tools
Summary
The documentation for Azure NetApp Files is generally cross-platform, referencing both Windows (SMB) and Linux (NFS) protocols and features. However, there is a subtle Windows bias in some areas: Windows/SMB/Active Directory features are often described first or in more detail, and Windows tools or patterns (such as Windows File Explorer, Windows client behaviors, and references to Windows-specific features like NTFS security style) are mentioned explicitly, sometimes without equivalent Linux examples or explanations. There are also several features and enhancements that are described primarily in the context of Windows environments (e.g., SMB Continuous Availability, Access-based Enumeration, non-browsable shares), with less emphasis or parallel explanation for Linux/NFS scenarios.
Recommendations
- When describing features that apply to both Windows/SMB and Linux/NFS, provide parallel examples and explanations for both platforms. For example, if describing how a feature affects Windows File Explorer, also describe the equivalent experience on Linux clients (e.g., using Nautilus, Dolphin, or command-line tools).
- Avoid listing Windows/SMB/Active Directory features first by default; alternate the order or present both together to reinforce parity.
- Where features are Windows-specific (e.g., NTFS security style, SMB Continuous Availability), explicitly state this and, where possible, mention if there is a Linux/NFS equivalent or alternative.
- For features like file access logs, non-browsable shares, and access-based enumeration, provide Linux/NFS-specific usage notes or examples, or clarify if the feature is not applicable to Linux.
- Ensure that protocol-agnostic features (e.g., backup, snapshots, quotas) include both Windows and Linux usage scenarios and client instructions.
- Where tools or client behaviors are mentioned (e.g., Windows File Explorer), also mention common Linux tools or commands (e.g., ls, mount, Nautilus) to provide a balanced perspective.
Azure Vmware
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-vmware/azure-vmware-solution-known-issues.md
...les/azure-vmware/azure-vmware-solution-known-issues.md
Medium Priority
View Details â
Detected Bias Types
windows_tools
missing_linux_example
Summary
The documentation page primarily describes known issues and their workarounds for Azure VMware Solution. While most content is platform-neutral, there are instances where only Windows-specific tools or commands are referenced (e.g., VMware Tools for Windows, use of Azure VMware Solution Run command without Linux alternatives). There are no explicit Linux or cross-platform command examples, and no mention of Linux-specific tools or remediation steps, which could disadvantage Linux administrators.
Recommendations
- When referencing remediation steps involving VMware Tools, clarify if the instructions apply to both Windows and Linux guests, or provide Linux-specific steps if different.
- If using Azure VMware Solution Run commands, specify whether these are applicable to both Windows and Linux VMs, and provide Linux command-line examples where relevant.
- Where possible, include parity examples for Linux (e.g., how to update VMware Tools on Linux VMs) alongside Windows instructions.
- Audit future documentation for implicit assumptions of a Windows-only environment and ensure Linux administrators are equally supported.
Communication Services
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/communication-services/concepts/sms/messaging-connect.md
...mmunication-services/concepts/sms/messaging-connect.md
Medium Priority
View Details â
Detected Bias Types
missing_linux_example
windows_first
Summary
The documentation page does not provide explicit Windows or PowerShell command-line examples, nor does it mention Windows-specific tools. However, there is a subtle 'windows_first' bias in the sense that the only SDK code examples provided are for C# (.NET) and JavaScript, with C# (a language most strongly associated with Windows development) presented first. There are no Linux-specific or cross-platform command-line examples (such as Bash, curl, or Python), and the SDK parity table shows Python and Java SDKs as 'coming soon' without offering alternative guidance for Linux users. The provisioning and operational instructions are entirely portal- and SDK-based, with no mention of CLI or automation approaches that are common in Linux environments.
Recommendations
- Add Linux-friendly command-line examples (e.g., using curl or Bash) for sending SMS via the API, especially in the 'SMS SDK Tutorial' section.
- Provide Python SDK examples as soon as the SDK is available, and consider including sample code for other cross-platform languages (e.g., Java, Go).
- Mention and provide Azure CLI or REST API instructions for provisioning and sending messages, as these are commonly used in Linux and automation scenarios.
- Explicitly state that all features are available cross-platform and clarify any platform-specific requirements or limitations.
- Ensure that future updates include parity in documentation and examples for both Windows and Linux development environments.
Communication Services
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/communication-services/tutorials/events-playbook.md
...es/communication-services/tutorials/events-playbook.md
Medium Priority
View Details â
Detected Bias Types
windows_first
missing_linux_example
Summary
The documentation consistently refers to the 'Teams Client (Web or Desktop)' without specifying OS, but elsewhere, when referencing Azure Communication Services quickstarts and resource creation, the documentation uses tabs or pivots defaulting to 'windows' (e.g., '?tabs=windows'). There are no explicit Linux or cross-platform CLI examples, and no mention of Linux-specific tools or instructions. This may create the impression that Windows is the primary or only supported environment, and Linux users may not find clear guidance.
Recommendations
- Ensure that all quickstart and resource creation links use neutral or cross-platform pivots/tabs (e.g., avoid '?tabs=windows' unless also providing '?tabs=linux' or '?tabs=mac').
- Explicitly mention that Teams clients and Azure Communication Services SDKs are cross-platform where applicable, and provide installation or usage instructions for Linux and macOS alongside Windows.
- Add Linux-specific examples or command-line instructions (e.g., using Bash, curl, or Azure CLI on Linux) where setup or configuration steps are described.
- Where UI or SDK pivots are shown, ensure Linux and macOS are first-class citizens in the documentation, not just Windows.
- Review all referenced quickstarts and ensure parity of examples and screenshots for Linux environments.
Cost Management Billing
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/cost-management-billing/manage/billing-subscription-transfer.md
...gement-billing/manage/billing-subscription-transfer.md
Medium Priority
View Details â
Detected Bias Types
windows_first
missing_linux_example
Summary
The documentation exclusively describes the transfer process using the Azure Portal web interface, with all screenshots and instructions tailored to a graphical user interface. There are no command-line examples provided, such as Azure CLI or PowerShell, which are cross-platform (with Azure CLI being especially Linux-friendly). There is no mention of Linux-specific tools, nor are there any references to performing these actions from non-Windows environments. The documentation implicitly assumes users will interact via a browser, which is platform-agnostic, but omits parity for users who prefer or require automation or command-line workflows, which are common in Linux environments.
Recommendations
- Add equivalent instructions for performing subscription transfer using Azure CLI commands, which are cross-platform and widely used on Linux.
- If possible, provide PowerShell examples as well, but ensure Azure CLI is presented first or alongside PowerShell to avoid Windows-first bias.
- Explicitly mention that all steps can be performed from any OS via the Azure Portal, but highlight command-line alternatives for automation and Linux users.
- Include links to Azure CLI documentation for managing subscriptions and billing, and provide example commands for common transfer scenarios.
- Review screenshots and language to ensure they do not assume a Windows environment (e.g., avoid showing Windows-specific browser UI or terminology).
Azure App Configuration
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-app-configuration/configuration-provider-overview.md
...e-app-configuration/configuration-provider-overview.md
Low Priority
View Details â
Detected Bias Types
windows_first
Summary
The documentation page lists .NET and ASP.NET Core providers (which are primarily Windows-centric technologies) first in the library table, with their samples and release notes, before mentioning Java, Python, JavaScript, and Go equivalents. There are no explicit Windows-only tools or PowerShell examples, but the ordering and emphasis on .NET/ASP.NET Core may suggest a subtle Windows-first bias.
Recommendations
- Reorder the provider libraries table to group by language family or present cross-platform options (e.g., Java, Python, Go) before or alongside .NET/ASP.NET Core to avoid the perception of Windows-first bias.
- Explicitly mention the cross-platform nature of .NET Core and ASP.NET Core, and clarify which libraries are usable on Linux/macOS as well as Windows.
- Add a note or section highlighting Linux and container-native usage patterns, such as integration with Kubernetes, to balance the focus.
- Ensure that future documentation includes Linux/macOS-specific guidance or examples where relevant, especially for setup, deployment, or troubleshooting.
Backup
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/backup/quick-backup-vm-portal.md
...cs/blob/main/articles/backup/quick-backup-vm-portal.md
Low Priority
View Details â
Detected Bias Types
windows_first
Summary
The documentation exhibits a mild 'windows_first' bias by linking to the Windows VM creation guide before the Linux equivalent and referencing Windows VM creation in the introductory section. However, throughout the rest of the document, instructions and examples are platform-neutral, focusing on the Azure portal UI. The only OS-specific section, about installing the VM agent, provides both Windows and Linux instructions with equal detail.
Recommendations
- When referencing VM creation, provide links to both Windows and Linux quickstart guides, or use a neutral link that allows the user to choose their OS.
- Ensure that introductory examples and links do not prioritize Windows over Linux unless there is a technical reason.
- Continue to provide parity in OS-specific instructions, as done in the VM agent installation section.