← Back to Dashboard
254
Pages Scanned
51
Pages Flagged
254
Changed Pages
20.1%
% Pages Flagged

Live Progress

🔴 Connecting...
17%
Phase: discovery
Processing: Initializing...
Activity Feed
00:00:57 Scan started

Scan Information

Started At: 2025-08-18 00:00:57

Finished At: In Progress

Status: cancelled

Target Repo: Azure

Current Phase: discovery

Files Queued: 1430

Files Completed: 241

Problematic Pages

51 issues found
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 →
Reviewed by: Unknown
Issues: 4 bias types
Detected Bias Types
⚠ī¸ windows_first ⚠ī¸ missing_linux_example ⚠ī¸ windows_tools ⚠ī¸ powershell_heavy
Summary
The documentation page exhibits a strong Windows bias. All migration tools and examples focus exclusively on migrating from Windows environments, specifically IIS servers, and make heavy use of PowerShell scripts. There is no mention of Linux-based hosting environments (such as Apache or Nginx), nor are there migration tools or instructions for Linux-origin .NET apps. The documentation references only Windows containers for unsupported apps, and all downloadable tools are for Windows. Linux scenarios are entirely absent.
Recommendations
  • Include migration guidance and tools for .NET apps hosted on Linux servers (e.g., Apache, Nginx, Kestrel).
  • Provide Linux shell (bash) script equivalents for PowerShell-based migration steps.
  • List Linux-based migration tools and resources alongside Windows tools in all tables and sections.
  • Add examples and walkthroughs for migrating .NET Core/ASP.NET Core apps running on Linux to Azure App Service (both Linux and Windows plans).
  • Clarify which migration tools (if any) support Linux-origin apps, and if not, provide alternative recommendations.
  • Ensure parity in documentation structure and prominence for Linux and Windows migration paths.
GitHub Create Pull Request
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 →
Reviewed by: Unknown
Issues: 3 bias types
Detected Bias Types
⚠ī¸ windows_tools ⚠ī¸ windows_first ⚠ī¸ missing_linux_example
Summary
The documentation page shows a subtle Windows bias by referencing Windows-specific tools and patterns (such as web.config and iisnode) without providing Linux equivalents or clarifying cross-platform differences. For example, configuring auto-healing via web.config and tuning Node.js apps with iisnode settings are both Windows/IIS-specific, but no Linux or cross-platform alternatives are mentioned. While there is a brief mention of running on Linux with PM2, the overall guidance and examples tend to assume a Windows/IIS environment by default.
Recommendations
  • For features like auto-healing, provide Linux-specific configuration guidance (e.g., using app settings, startup scripts, or environment variables) alongside web.config instructions.
  • When referencing iisnode or web.config, clarify that these are Windows/IIS-specific and offer equivalent Linux-native approaches (such as using PM2, process.json, or other Node.js process managers).
  • Include explicit Linux examples and configuration snippets wherever Windows-specific tools or files are mentioned.
  • Add a section or callout summarizing key differences in configuration and troubleshooting between Windows and Linux App Service plans.
  • Ensure that all best practices are presented in a cross-platform manner, or clearly indicate when a recommendation is platform-specific.
GitHub Create Pull Request
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 →
Reviewed by: Unknown
Issues: 3 bias types
Detected Bias Types
⚠ī¸ windows_first ⚠ī¸ powershell_heavy ⚠ī¸ windows_tools
Summary
The documentation demonstrates a mild Windows bias. In sections where both Windows and Linux are relevant (such as SKU availability), the Windows example is presented first. Automation examples are given for both Azure CLI (cross-platform) and Azure PowerShell (Windows-centric), but no Linux shell scripting or Bash-specific guidance is provided. The portal UI instructions and screenshots do not differentiate between Windows and Linux hosting, potentially assuming a Windows-centric workflow. There is no explicit omission of Linux functionality, but the ordering and tool selection favor Windows users.
Recommendations
  • Alternate the order of Windows and Linux examples, or present them together to avoid implicit prioritization.
  • Provide Bash or shell script automation examples alongside PowerShell, especially for Linux users.
  • Clarify in UI instructions and screenshots when steps are identical or different for Linux and Windows App Service plans.
  • Explicitly mention that Azure CLI commands are cross-platform and suitable for both Windows and Linux environments.
  • Consider including a table or section summarizing differences (if any) in scaling or deployment steps between Windows and Linux App Service plans.
GitHub Create Pull Request
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 →
Reviewed by: Unknown
Issues: 3 bias types
Detected Bias Types
⚠ī¸ windows_first ⚠ī¸ powershell_heavy ⚠ī¸ windows_tools
Summary
The documentation demonstrates a mild Windows bias. Windows-specific information and examples are often presented first (e.g., SKU availability), and Azure PowerShell (a Windows-centric tool) is given its own section with example scripts, while Linux-native tools or shell scripting are not. The documentation mentions Windows and Linux support, but the automation and scripting focus is on Azure CLI and PowerShell, with no Linux shell or bash-specific examples. Portal instructions are generic, but the overall pattern prioritizes Windows tools and workflows.
Recommendations
  • Provide bash or shell script examples for Linux users alongside PowerShell examples.
  • When listing SKU availability or commands, alternate the order or present Windows and Linux options together to avoid 'Windows first' ordering.
  • Explicitly mention that Azure CLI is cross-platform and can be used from Linux/macOS terminals, not just Cloud Shell.
  • Include notes or examples for Linux-native automation (e.g., using bash scripts, environment variables, or integrating with Linux CI/CD pipelines).
  • Where PowerShell is referenced, clarify that Azure PowerShell is available cross-platform, but also provide parity with Linux-native scripting approaches.
GitHub Create Pull Request
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 →
Reviewed by: Unknown
Issues: 4 bias types
Detected Bias Types
⚠ī¸ windows_first ⚠ī¸ powershell_heavy ⚠ī¸ windows_tools ⚠ī¸ missing_linux_example
Summary
The documentation demonstrates a moderate Windows bias. Windows instructions and tools (such as PowerShell and GUI) are often presented first or exclusively, with Linux alternatives sometimes less detailed or missing. Troubleshooting and connectivity testing examples rely on Windows-specific tools (e.g., PowerShell's Test-NetConnection), and the GUI for Hybrid Connection Manager is only available on Windows, with Linux users directed to CLI without parity in features or screenshots. Some troubleshooting steps lack Linux command equivalents.
Recommendations
  • Provide Linux command-line equivalents for all Windows-specific instructions, such as replacing PowerShell's Test-NetConnection with Linux alternatives like nc (netcat) or curl.
  • When presenting installation or usage instructions, alternate the order or present both Windows and Linux instructions side by side to avoid 'windows_first' bias.
  • Include Linux screenshots or terminal output where Windows GUI screenshots are shown, to give Linux users visual parity.
  • Expand troubleshooting sections to include Linux-native tools and commands (e.g., using nslookup, dig, nc, or telnet for connectivity tests).
  • Clarify any feature gaps (such as the lack of a GUI on Linux) and, where possible, suggest open-source or cross-platform alternatives.
  • Ensure that all examples, especially for common tasks (testing connectivity, managing services), are provided for both Windows and Linux environments.
GitHub Create Pull Request
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 →
Reviewed by: Unknown
Issues: 3 bias types
Detected Bias Types
⚠ī¸ windows_first ⚠ī¸ windows_tools ⚠ī¸ missing_linux_example
Summary
The documentation demonstrates a mild Windows bias. While most command-line examples use the cross-platform Azure CLI, the only graphical tool mentioned is Azure Storage Explorer, and the instructions for generating a SAS URL link specifically to the Windows tab. There are no Linux- or macOS-specific instructions or alternative tools mentioned for uploading files or generating SAS tokens. The documentation does not acknowledge or provide parity for Linux users in these steps.
Recommendations
  • Provide instructions or links for using Azure Storage Explorer on Linux/macOS, or mention that it is cross-platform.
  • Include alternative methods for uploading files and generating SAS URLs using only the Azure CLI or other cross-platform tools, especially for users who may not use graphical tools.
  • Avoid linking directly to Windows-specific tabs or instructions; ensure that documentation covers all supported platforms equally.
  • Explicitly state when a tool or method is cross-platform, and provide any necessary installation or usage notes for Linux/macOS users.
GitHub Create Pull Request
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 →
Reviewed by: Unknown
Issues: 3 bias types
Detected Bias Types
⚠ī¸ windows_first ⚠ī¸ missing_linux_example ⚠ī¸ windows_tools
Summary
The documentation page focuses exclusively on discovering ASP.NET web apps hosted on IIS web servers within VMware environments, which are Windows-centric technologies. There are no examples or mentions of discovering .NET apps hosted on Linux (e.g., Kestrel, Apache, Nginx), nor are Linux-based discovery tools or scenarios discussed. All discovery capabilities and references assume a Windows/IIS environment, omitting Linux equivalents.
Recommendations
  • Include information on discovering .NET web apps hosted on Linux servers (e.g., using Kestrel, Apache, or Nginx).
  • Provide parallel examples or guidance for Linux-based environments, including supported discovery tools and workflows.
  • Explicitly state any limitations or lack of support for Linux-based .NET app discovery, if applicable.
  • Reference Linux documentation or migration guides where relevant.
  • Ensure that both Windows and Linux scenarios are addressed equally in future documentation updates.
GitHub Create Pull Request
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 →
Reviewed by: Unknown
Issues: 3 bias types
Detected Bias Types
⚠ī¸ powershell_heavy ⚠ī¸ windows_first ⚠ī¸ missing_linux_example
Summary
The documentation demonstrates Windows bias primarily in the guidance for identifying impacted Azure Traffic Manager endpoints, where only a PowerShell script is provided for detection, with no equivalent Bash, Azure CLI, or cross-platform alternative. The instructions for running the script assume a Windows/PowerShell environment, and there is no mention of Linux-compatible approaches. Elsewhere, CLI and REST API examples are provided, which are cross-platform, but the exclusive use of PowerShell for a key scenario stands out.
Recommendations
  • Provide equivalent Bash or Azure CLI scripts for identifying Traffic Manager endpoints with non-Azure types, ensuring Linux and macOS users can follow the guidance without requiring PowerShell.
  • When referencing scripts or tooling, mention both Windows (PowerShell) and Linux/macOS (Bash/CLI) options, or explicitly state cross-platform compatibility.
  • Consider including notes or links to cross-platform tools (such as Azure CLI or Azure Cloud Shell) wherever PowerShell scripts are referenced.
  • Review all example commands and scripts to ensure Linux parity, and add Linux/macOS-specific instructions where needed.
GitHub Create Pull Request
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 →
Reviewed by: Unknown
Issues: 4 bias types
Detected Bias Types
⚠ī¸ windows_first ⚠ī¸ missing_linux_example ⚠ī¸ windows_tools ⚠ī¸ powershell_heavy
Summary
The documentation is heavily focused on Windows environments, specifically Azure App Service on Windows with iisnode. All configuration examples, troubleshooting steps, and tool references (such as web.config, iisnode, named pipes, Win32 error codes, and Kudu CMD/PowerShell) are Windows-specific. There are no Linux equivalents or cross-platform guidance, and Linux tools or patterns are not mentioned at all.
Recommendations
  • Add equivalent guidance and examples for Node.js applications running on Azure App Service for Linux, including configuration, troubleshooting, and monitoring.
  • Include Linux-specific tools and patterns (e.g., using PM2 or systemd for process management, nginx or Apache for reverse proxy, Linux file paths, and log locations).
  • Provide examples for both Windows (web.config/iisnode) and Linux (e.g., server.js/PM2) side by side where applicable.
  • Reference Linux troubleshooting steps (such as using SSH, Bash, or Linux-native diagnostic tools) and clarify which steps are Windows-only.
  • Update section titles and introductions to clarify the scope (e.g., 'for Windows' vs. 'for Linux') and link to Linux-specific documentation if available.
GitHub Create Pull Request
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 →
Reviewed by: Unknown
Issues: 3 bias types
Detected Bias Types
⚠ī¸ windows_first ⚠ī¸ missing_linux_example ⚠ī¸ windows_tools
Summary
The documentation page demonstrates a Windows bias by exclusively referencing Windows-based tools and environments (such as Visual Studio, Kudu, CMD, and PowerShell) for configuration and diagnostics. All file paths and commands are Windows-specific, and there are no Linux-based examples or instructions for equivalent tasks. The guidance assumes the use of Windows App Service instances and does not address Linux App Service scenarios or tooling.
Recommendations
  • Add parallel Linux-based instructions and examples for each configuration task, especially for listing .NET runtimes and accessing diagnostic tools.
  • Include Linux file paths and shell commands (e.g., bash) where Windows CMD/PowerShell commands are shown.
  • Mention Linux App Service environments explicitly and provide guidance for users deploying to Linux-based App Service plans.
  • Reference cross-platform tools (such as the Azure CLI and Kudu's Bash console) equally alongside Windows tools.
  • Clarify when a step or tool is Windows-only, and provide alternatives for Linux users.
GitHub Create Pull Request
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 →
Reviewed by: Unknown
Issues: 3 bias types
Detected Bias Types
⚠ī¸ windows_first ⚠ī¸ missing_linux_example ⚠ī¸ windows_tools
Summary
The documentation page exhibits a 'windows_first' bias by describing Windows container SSH access before Linux, despite Linux being the more common SSH use case. The Windows section is brief and lacks technical depth, while the Linux section provides detailed CLI instructions and examples. However, there is a lack of parity: the Windows section does not offer any CLI or PowerShell-based SSH access examples, nor does it mention Windows-native SSH tools or alternatives. This asymmetry may confuse users seeking equivalent Windows command-line access. Additionally, the documentation references browser-based SSH for Windows but does not clarify if similar browser SSH is available for Linux, nor does it provide PowerShell or Windows SSH client examples.
Recommendations
  • Provide equivalent command-line SSH access instructions for Windows containers, including PowerShell or Windows SSH client usage if supported.
  • Clarify whether browser-based SSH is available for both Linux and Windows containers, and present this information in a parallel structure.
  • If CLI-based SSH is not supported for Windows containers, explicitly state this and suggest any available alternatives (such as RDP, PowerShell Remoting, or Windows OpenSSH client usage).
  • Ensure that both Linux and Windows sections include comparable levels of detail and example commands, so users on either platform can follow clear, actionable steps.
  • Consider restructuring the page to present Linux and Windows instructions side-by-side for each access method, to avoid implicit prioritization.
GitHub Create Pull Request
App Service https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/configure-ssl-certificate.md ...main/articles/app-service/configure-ssl-certificate.md
High Priority View Details →
Reviewed by: Unknown
Issues: 4 bias types
Detected Bias Types
⚠ī¸ windows_first ⚠ī¸ powershell_heavy ⚠ī¸ windows_tools ⚠ī¸ missing_linux_example
Summary
The documentation exhibits a moderate Windows bias. PowerShell is presented alongside Azure CLI for automation, but no Linux shell or bash-specific examples are given for certificate management tasks. Windows tools such as IIS and Certreq.exe are mentioned for certificate export, while Linux equivalents are not. In several places, Windows-specific scenarios (such as outbound certificate usage in Windows container apps) are highlighted, and Linux alternatives are omitted or not equally detailed.
Recommendations
  • Add explicit Linux and bash examples for certificate export, such as using OpenSSL for all relevant steps, not just one.
  • When referencing Windows tools like IIS or Certreq.exe, provide equivalent Linux instructions (e.g., using OpenSSL or certtool) for exporting certificates to .pfx.
  • In automation sections, include bash/Azure CLI scripts as first-class citizens, not just PowerShell.
  • Clarify feature parity or differences for Linux-based App Service apps, especially in FAQ answers that currently mention only Windows container support.
  • Ensure that Linux tools and workflows are mentioned at least as prominently as Windows tools, ideally before or alongside them.
GitHub Create Pull Request
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 →
Reviewed by: Unknown
Issues: 3 bias types
Detected Bias Types
⚠ī¸ windows_first ⚠ī¸ windows_tools ⚠ī¸ missing_linux_example
Summary
The documentation demonstrates a Windows bias by referencing Windows-style paths (e.g., D:\home\site\wwwroot) before Linux equivalents, using Windows directory separators in examples, and omitting explicit Linux/Bash command examples or Linux-specific instructions. The focus on Windows tools and patterns, such as directory structures and deployment paths, may make it less approachable for Linux users.
Recommendations
  • Present both Windows and Linux directory paths and examples side-by-side, or use platform-agnostic notation where possible.
  • Include explicit Linux/Bash command examples (e.g., using Bash or sh syntax) alongside Azure CLI commands.
  • Clarify when instructions or paths differ between Windows and Linux App Service environments.
  • Avoid using only Windows directory separators (\); include Linux-style (/) as well.
  • Add troubleshooting notes or tips relevant to Linux users, such as file permission considerations.
GitHub Create Pull Request
App Service https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/environment/overview.md ...blob/main/articles/app-service/environment/overview.md
High Priority View Details →
Reviewed by: Unknown
Issues: 3 bias types
Detected Bias Types
⚠ī¸ windows_first ⚠ī¸ windows_heavy ⚠ī¸ missing_linux_example
Summary
The documentation page demonstrates a Windows bias by consistently listing Windows workloads and SKUs before Linux equivalents, referencing Windows-specific plans and pricing as defaults, and omitting Linux-specific examples or details in several sections. Windows container limitations are called out explicitly, while Linux equivalents are not discussed in the same detail. There are no command-line or tooling examples, but the narrative and tables prioritize Windows terminology and scenarios.
Recommendations
  • Alternate the order of Windows and Linux mentions throughout the documentation to avoid always listing Windows first.
  • Where Windows-specific limitations or features are discussed (such as SKU support), provide equivalent information for Linux workloads and containers.
  • Include explicit Linux examples or callouts in pricing, scaling, and feature difference sections, especially where Windows is referenced as the default.
  • Clarify when statements apply to both Windows and Linux, or only to one, to avoid implying Windows is the primary or default scenario.
  • Add a section or table column for Linux-specific limitations or features, mirroring the Windows container notes.
GitHub Create Pull Request
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 →
Reviewed by: Unknown
Issues: 3 bias types
Detected Bias Types
⚠ī¸ windows_first ⚠ī¸ missing_linux_example ⚠ī¸ windows_tools
Summary
The documentation page demonstrates a Windows bias by prioritizing Windows/Visual Studio tools and workflows (e.g., right-clicking folders, using Visual Studio's NuGet package manager) and omitting explicit Linux or cross-platform command-line instructions for key steps. There are no Linux-specific examples or terminal commands for common developer actions, and the documentation assumes a GUI-based, Windows-centric development environment.
Recommendations
  • Provide equivalent Linux and cross-platform instructions for all steps, especially for file creation and package installation (e.g., using 'dotnet new', 'dotnet add package', and editing files via CLI or cross-platform editors).
  • Include terminal/command-line examples for creating and editing files, not just Visual Studio GUI actions.
  • Mention and demonstrate the use of cross-platform tools (e.g., VS Code, JetBrains Rider) alongside Visual Studio.
  • Ensure that all NuGet package installation steps include both Visual Studio and dotnet CLI commands, with equal prominence.
  • Explicitly state that the instructions are applicable to both Windows and Linux, and provide notes or tips for Linux users where workflows differ.
GitHub Create Pull Request
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 →
Reviewed by: Unknown
Issues: 4 bias types
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 command-line examples for per-app scaling, without any equivalent examples for Linux users (e.g., Azure CLI, Bash). The use of PowerShell cmdlets (New-AzAppServicePlan, Set-AzAppServicePlan, Get-AzWebApp, Set-AzWebApp) is exclusive to Windows environments or requires extra setup on Linux. No Linux-native tools or shell examples are provided, and PowerShell is presented as the primary (and only) scripting interface for these operations.
Recommendations
  • Add equivalent Azure CLI (az) command examples for all PowerShell cmdlets shown, as Azure CLI is cross-platform and widely used on Linux.
  • Provide Bash or shell script snippets where appropriate, especially for app-level configuration.
  • Explicitly mention that PowerShell examples can be run on Linux with PowerShell Core, but recommend Azure CLI for native Linux workflows.
  • Reorder sections or provide parallel examples so that Linux-friendly (CLI) approaches are presented alongside or before PowerShell.
  • Include a note or table summarizing the available tools for both Windows and Linux users, with links to installation instructions.
GitHub Create Pull Request
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 →
Reviewed by: Unknown
Issues: 4 bias types
Detected Bias Types
⚠ī¸ windows_first ⚠ī¸ powershell_heavy ⚠ī¸ missing_linux_example ⚠ī¸ windows_tools
Summary
The documentation page exhibits a moderate Windows bias. PowerShell examples are provided alongside Azure CLI, but there are no explicit Linux shell or Bash-specific examples for querying outbound IPs (other than a generic nslookup and curl). Azure PowerShell is featured equally with Azure CLI, but the PowerShell examples are not marked as Windows-specific, and there is no mention of Linux alternatives for PowerShell commands. Outbound IPv6 support is noted as available only for Windows apps, but this is a platform limitation, not a documentation bias. However, the overall pattern is that Windows/PowerShell tooling is presented as a default or first-class option, with little explicit Linux parity.
Recommendations
  • Clearly label PowerShell examples as Windows-specific, and provide equivalent Bash or Linux shell commands where possible.
  • For sections showing Azure CLI and PowerShell, consider using tabbed code blocks labeled 'Azure CLI (cross-platform)' and 'PowerShell (Windows)' to clarify platform applicability.
  • Where PowerShell is used to retrieve properties (e.g., outbound IPs), provide a Bash/Unix shell example using Azure CLI and jq or similar tools.
  • Explicitly mention when a feature or command is Windows-only, especially in the context of outbound IPv6 support.
  • Add a note or section on using Azure CLI in Bash/Linux environments, and ensure all CLI examples are tested cross-platform.
  • For completeness, consider referencing cross-platform tools (e.g., dig, host) alongside nslookup for DNS queries.
GitHub Create Pull Request
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 →
Reviewed by: Unknown
Issues: 3 bias types
Detected Bias Types
⚠ī¸ windows_first ⚠ī¸ windows_tools ⚠ī¸ missing_linux_example
Summary
The documentation page demonstrates a subtle Windows bias. It provides detailed guidance and calculations specifically for Windows Containers, including subnet sizing and networking unit calculations, while Linux-specific guidance is limited to a brief note about continuous deployment network dependencies. There are no Linux container subnet/IP calculation examples, and Windows-specific features (e.g., Windows Server Active Directory, NetBIOS) are mentioned as unsupported, but Linux equivalents are not discussed. The overall pattern is to address Windows scenarios in more detail and earlier in the document, with Linux-specific information being sparse or absent.
Recommendations
  • Add equivalent subnet/IP calculation examples and networking unit guidance for Linux containers, similar to the detailed section for Windows Containers.
  • Include Linux-specific limitations or considerations (e.g., supported features, known issues) in parity with the Windows-focused notes.
  • Provide balanced examples and troubleshooting steps for both Windows and Linux container scenarios.
  • Ensure that Linux tools, patterns, and deployment considerations are mentioned alongside Windows ones, not only as afterthoughts.
  • Review the order of presentation so that Linux and Windows scenarios are treated with equal prominence and depth.
GitHub Create Pull Request
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 →
Reviewed by: Unknown
Issues: 4 bias types
Detected Bias Types
⚠ī¸ windows_first ⚠ī¸ powershell_heavy ⚠ī¸ windows_tools ⚠ī¸ missing_linux_example
Summary
The documentation page demonstrates a Windows-centric bias in several ways. It references Windows-specific tools (IIS, Procdump, PowerShell), and features (web.config, .NET Profiler for Windows), and provides examples and links that are either exclusive to or primarily focused on Windows environments. There is little to no mention of Linux-specific diagnostics, tools, or command-line examples, despite Azure App Service supporting Linux. The Kudu Console section highlights PowerShell and DOS commands, with no mention of Bash or Linux shell usage. Diagnostic and mitigation steps (such as auto-heal and profiler) are described in a way that assumes a Windows context, and Linux alternatives or differences are not addressed.
Recommendations
  • Add parallel Linux examples and instructions for all diagnostic and troubleshooting steps, including enabling logs, collecting dumps, and using the Kudu Console (e.g., mention Bash shell availability and Linux-compatible tools).
  • Clarify when features or tools are Windows-only (e.g., IIS logs, web.config, Procdump, .NET Profiler for Windows) and provide Linux equivalents or alternatives (such as using Application Insights with OpenTelemetry, or Linux-native profiling tools).
  • Include references and links to Linux-specific documentation for App Service, such as logging, diagnostics, and scaling on Linux.
  • When mentioning PowerShell or DOS commands, also provide Bash/Linux shell equivalents.
  • Review all screenshots and walkthroughs to ensure Linux users are represented, or clearly state when a feature is not available on Linux.
GitHub Create Pull Request
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 →
Reviewed by: Unknown
Issues: 3 bias types
Detected Bias Types
⚠ī¸ windows_first ⚠ī¸ missing_linux_example ⚠ī¸ windows_tools
Summary
The documentation demonstrates a Windows-first bias by providing more detailed instructions and features for Windows App Service apps, such as web server logging, detailed error messages, and failed request tracing, which are not available or documented for Linux. The examples and tooling references (e.g., Log Parser, W3C log format, .NET/ASP.NET logging) are Windows-centric, and Linux-specific guidance is minimal or absent in several sections.
Recommendations
  • Provide equivalent Linux examples and instructions for all logging types where possible, or clearly state feature parity gaps.
  • Add Linux-specific guidance for accessing and interpreting logs, including recommended tools and log formats.
  • When referencing tools (e.g., Log Parser), suggest cross-platform or Linux-native alternatives.
  • Ensure that sections are not structured with Windows as the default or primary platform; present Windows and Linux options in parallel where both are supported.
  • Expand code examples to include common Linux stacks (Node.js, Python, Java) and their logging patterns.
  • Clarify any limitations or differences for Linux explicitly and provide workarounds or alternatives where feasible.
GitHub Create Pull Request
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
High Priority View Details →
Reviewed by: Unknown
Issues: 3 bias types
Detected Bias Types
⚠ī¸ missing_linux_example ⚠ī¸ windows_tools ⚠ī¸ windows_first
Summary
The documentation assumes a development workflow centered on .NET, Azure App Service, and GitHub Codespaces, with all examples and instructions tailored to these environments. There are no explicit Linux or cross-platform terminal instructions, and the use of Azure Developer CLI (azd) and .NET CLI is described without clarifying their cross-platform compatibility. The documentation does not mention Linux-specific development environments, nor does it provide parity for Linux users who may not use Codespaces or Visual Studio. The security and deployment sections reference Azure-centric tools and patterns, which are more familiar to Windows/Azure users.
Recommendations
  • Explicitly state that all CLI commands (dotnet, azd) work on Linux, macOS, and Windows, and provide installation links for each OS.
  • Include instructions for running the sample app locally on Linux (e.g., using local terminal, VS Code, or JetBrains Rider) in addition to Codespaces.
  • Provide alternative deployment instructions for users who do not use GitHub Codespaces, such as using the Azure CLI from a local Linux shell.
  • Mention and link to Linux-friendly tools and editors (e.g., VS Code, Vim, Emacs) alongside Codespaces.
  • Clarify that Azure App Service and related tools are cross-platform, and highlight any OS-specific considerations.
  • If screenshots or UI steps are shown, ensure they are not Windows-specific or provide Linux/macOS equivalents where relevant.
GitHub Create Pull Request
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 →
Reviewed by: Unknown
Issues: 4 bias types
Detected Bias Types
⚠ī¸ windows_first ⚠ī¸ windows_tools ⚠ī¸ powershell_heavy ⚠ī¸ missing_linux_example
Summary
The documentation exhibits a mild Windows bias. Windows-specific tools and configuration steps are often mentioned first or exclusively, such as in ReadyToRun instructions, .NET preview version setup, and process architecture checks. PowerShell and Visual Studio are highlighted as primary tools, with Linux equivalents either mentioned later, less prominently, or not at all. Some CLI examples are Windows-centric, and Linux-specific nuances are sometimes relegated to notes or tabs. There are also areas where Linux-specific deployment or debugging workflows are not fully detailed.
Recommendations
  • Ensure all tool and command-line examples are provided for both Windows and Linux, ideally side-by-side or with equal prominence.
  • When listing options for creating or deploying resources, alternate the order (e.g., sometimes list Linux/CLI first, not always Windows/Visual Studio).
  • Include Linux-specific instructions for debugging, deployment, and configuration wherever Windows instructions are given.
  • Provide explicit bash and PowerShell examples for CLI commands, especially for scripting or automation.
  • Clarify any differences in behavior or requirements between Windows and Linux environments, especially for advanced features like ReadyToRun, cold start optimizations, and .NET preview support.
  • Where Visual Studio is mentioned, also mention cross-platform alternatives (e.g., Visual Studio Code, JetBrains Rider) and ensure parity in guidance.
  • Review all references to Azure PowerShell and ensure Azure CLI (which is cross-platform) is given equal or greater prominence.
GitHub Create Pull Request
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 →
Reviewed by: Unknown
Issues: 3 bias types
Detected Bias Types
⚠ī¸ windows_first ⚠ī¸ powershell_heavy ⚠ī¸ missing_linux_example
Summary
The documentation page demonstrates a Windows bias primarily in the 'Ways to create snapshots' section, where PowerShell is listed as a primary tool alongside Azure Portal, REST API, and Azure CLI, but there are no explicit Linux shell or Bash examples. PowerShell is mentioned before Linux-native scripting or command-line approaches, and there are no Linux/Unix-specific instructions or examples. The scripting example link provided points to a SQL Server T-SQL/PowerShell scenario, which is Windows-centric. There is also no mention of Linux automation patterns or tools (e.g., Bash, cron, shell scripts) for snapshot management.
Recommendations
  • Add explicit Bash or Linux shell command examples for creating and managing snapshots using Azure CLI.
  • Include references or links to Linux/Unix scripting patterns (e.g., using Bash scripts with az CLI) for automation.
  • Balance the order of tool mentions: list Azure CLI and REST API before PowerShell, or group them neutrally.
  • Provide example scripts for both Windows (PowerShell) and Linux (Bash) environments.
  • Reference Linux-native scheduling tools (e.g., cron jobs) for automating snapshot operations.
  • Ensure that all example links and code samples have Linux equivalents, not just Windows/PowerShell.
GitHub Create Pull Request
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 →
Reviewed by: Unknown
Issues: 4 bias types
Detected Bias Types
⚠ī¸ powershell_heavy ⚠ī¸ windows_tools ⚠ī¸ windows_first ⚠ī¸ missing_linux_example
Summary
The documentation page demonstrates a Windows bias primarily through the exclusive use of Azure PowerShell commands and references to the PowerShell Gallery for migration scripts. Azure CLI commands are shown, but only in the context of PowerShell (Set-AzContext, Get-AzProviderFeature, Register-AzProviderFeature), which are PowerShell cmdlets, not cross-platform Azure CLI commands. There are no explicit Linux/bash examples, and the documentation does not mention Linux tools or workflows. The 'Next steps' section also prioritizes PowerShell tutorials over CLI or portal-based workflows.
Recommendations
  • Provide equivalent Azure CLI (az) command examples for all PowerShell scripts and registration/unregistration steps, as Azure CLI is cross-platform and widely used on Linux/macOS.
  • When referencing scripts or tools (such as migration scripts), clarify if they are available for both PowerShell and Bash/CLI, and provide links or instructions for both.
  • In 'Next steps', include tutorials for Azure CLI and the Azure portal, not just PowerShell, and ensure parity in guidance.
  • Avoid using PowerShell-specific cmdlets (Set-AzContext, Get-AzProviderFeature, etc.) in sections labeled as 'Azure CLI'; use true Azure CLI commands (az ...).
  • Explicitly mention that all features and management tasks can be performed from Linux/macOS environments using Azure CLI or REST APIs, and provide examples where appropriate.
GitHub Create Pull Request
Azure Functions https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/functions-reference-python.md ...articles/azure-functions/functions-reference-python.md
High Priority View Details →
Reviewed by: Unknown
Issues: 3 bias types
Detected Bias Types
⚠ī¸ windows_first ⚠ī¸ windows_tools ⚠ī¸ powershell_heavy
Summary
The documentation demonstrates a mild Windows bias in several areas: Windows terminology ("command prompt") is used alongside or before cross-platform terms ("terminal"), and Windows-specific recommendations are made (e.g., suggesting remote build when developing on Windows, discouraging local builds on Windows). The documentation refers to the 'command prompt' and 'Visual Studio Code' as primary development environments, which are more common on Windows. There is also a subtle bias in the order of mentioning Windows-specific tools or patterns before their Linux equivalents, and in some cases, the documentation assumes a Windows context before clarifying Linux is required for hosting. However, Linux support is well-documented, and many examples are cross-platform.
Recommendations
  • Use fully cross-platform terminology throughout (e.g., always say 'terminal' instead of 'command prompt').
  • When listing development environments or tools, avoid putting Windows-specific options first or exclusively; instead, clarify cross-platform support and order neutrally.
  • Where recommendations are made (e.g., for remote vs. local build), explain the rationale for all platforms, not just Windows.
  • Explicitly provide Linux/macOS shell examples (e.g., bash/zsh) alongside any Windows-specific instructions, if any.
  • Clarify that Visual Studio Code is cross-platform, and suggest other editors (e.g., Vim, Emacs, PyCharm) where appropriate.
  • Avoid language like 'Use remote build when you're developing Python apps on Windows' without also explaining the implications for Linux/macOS users.
  • Ensure that all CLI commands are shown in a cross-platform way (e.g., use $ for shell prompts, not C:\> or cmd).
GitHub Create Pull Request
Azure Functions https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-functions/how-to-create-function-azure-cli.md ...es/azure-functions/how-to-create-function-azure-cli.md
High Priority View Details →
Reviewed by: Unknown
Issues: 3 bias types
Detected Bias Types
⚠ī¸ windows_first ⚠ī¸ powershell_heavy ⚠ī¸ windows_tools
Summary
The documentation demonstrates some Windows bias, particularly in the Java section, where PowerShell and Cmd examples are given alongside Bash, and Windows path conventions (e.g., backslashes in file paths) are referenced. The order of examples and mention of Windows-specific tools (PowerShell, Cmd) before or alongside Bash may suggest a Windows-first approach. However, the core CLI commands are generally cross-platform, and Linux tools like jq are mentioned. There are no outright missing Linux examples, but parity and prominence could be improved.
Recommendations
  • Present Bash (Linux/macOS) examples before PowerShell and Cmd in all code tabs to reinforce cross-platform parity.
  • Use platform-agnostic path conventions or provide both Windows (backslash) and Linux/macOS (slash) examples when referencing file paths.
  • Where PowerShell or Cmd is shown, ensure equivalent Bash or shell commands are always present and clearly labeled.
  • Avoid language that defaults to 'command prompt' or 'PowerShell'—use 'terminal' or 'shell' as the primary term.
  • Highlight Linux/macOS compatibility and usage tips, especially for environment variables, file permissions, and shell scripting.
  • Consider adding explicit notes or callouts for any platform-specific behavior or requirements.
GitHub Create Pull Request
Azure Netapp Files https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-netapp-files/configure-network-features.md ...icles/azure-netapp-files/configure-network-features.md
High Priority View Details →
Reviewed by: Unknown
Issues: 3 bias types
Detected Bias Types
⚠ī¸ powershell_heavy ⚠ī¸ windows_first ⚠ī¸ windows_tools
Summary
The documentation page exhibits a moderate Windows bias. PowerShell commands are presented prominently and in detail, often before or alongside Azure CLI and REST API examples. PowerShell is a Windows-centric tool, and its usage is emphasized in feature registration and volume management steps. There are no explicit Linux shell or Bash examples outside of Azure CLI, and the documentation does not mention or provide guidance for Linux-native tools or workflows. The structure and ordering of examples (PowerShell, Azure CLI, REST API, Portal) also tend to prioritize Windows/PowerShell approaches.
Recommendations
  • Provide explicit Bash/Linux shell command examples where applicable, especially for Azure CLI usage.
  • Clarify that Azure CLI commands can be run natively on Linux, macOS, and Windows, and provide sample shell prompts (e.g., $ for Bash) to reinforce cross-platform applicability.
  • Where PowerShell is used, offer equivalent Bash or shell script snippets for Linux users, especially for common tasks like feature registration and status checking.
  • If certain steps are only possible in PowerShell, explicitly state this and offer alternative guidance for Linux users.
  • Review the ordering of example tabs/sections to avoid always listing PowerShell first; consider rotating or randomizing, or listing Azure CLI (which is cross-platform) before PowerShell.
  • Add a brief section or note at the top clarifying tool compatibility and platform support for all command-line examples.
GitHub Create Pull Request
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 →
Reviewed by: Unknown
Issues: 3 bias types
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, referencing right-click actions in the portal UI (a pattern more familiar to Windows users), and omitting explicit Linux/Unix CLI or scripting examples. Although Azure CLI is mentioned, no concrete CLI command examples are provided, and there are no bash or shell script samples. This may make it less accessible for Linux administrators or those preferring cross-platform command-line tools.
Recommendations
  • Provide explicit Azure CLI command examples (e.g., 'az feature register ...') alongside PowerShell for all registration and status-check steps.
  • Include bash/shell script snippets where relevant, especially for automation scenarios.
  • Avoid UI instructions that assume Windows conventions (such as 'right-click'); instead, describe actions in a platform-neutral way (e.g., 'select the options menu').
  • Ensure parity in examples and instructions for both Windows and Linux users throughout the documentation.
  • Consider adding a section or callout for Linux/macOS users, highlighting any differences or tips for using the CLI or portal on non-Windows platforms.
GitHub Create Pull Request
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 →
Reviewed by: Unknown
Issues: 4 bias types
Detected Bias Types
⚠ī¸ windows_first ⚠ī¸ powershell_heavy ⚠ī¸ windows_tools ⚠ī¸ missing_linux_example
Summary
The documentation demonstrates a Windows bias by providing detailed, step-by-step instructions for setting SACLs on SMB shares using Windows GUI tools, while the equivalent Linux/NFS instructions are minimal and refer users to another page. Feature registration examples are given first in Azure PowerShell, with Azure CLI (cross-platform) only mentioned secondarily and without example commands. There are no Linux command-line examples for managing ACLs or audit settings, and Windows tools and workflows are described in more detail.
Recommendations
  • Provide parity in example detail for Linux/NFS workflows, including explicit command-line examples (e.g., setfacl, nfs4_setfacl) for setting Audit ACEs on NFSv4.1 volumes.
  • When presenting feature registration, show both Azure PowerShell and Azure CLI commands side by side, or lead with CLI as the cross-platform option.
  • Include screenshots or step-by-step instructions for Linux environments where applicable, not just Windows.
  • Avoid referencing only Windows administration hosts; explicitly mention and provide guidance for Linux administration hosts.
  • Ensure that all major actions (enabling/disabling logs, setting ACLs) have both Windows and Linux examples where supported.
GitHub Create Pull Request
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 →
Reviewed by: Unknown
Issues: 3 bias types
Detected Bias Types
⚠ī¸ windows_first ⚠ī¸ missing_linux_example ⚠ī¸ windows_tools
Summary
The documentation page demonstrates a Windows bias by providing restore examples and references that are focused exclusively on Windows VMs, especially in the encrypted VM restore scenario. Only Windows-specific links and PowerShell instructions are mentioned, with no equivalent Linux guidance or examples. There is no mention of Linux disk encryption or restore processes, nor are Linux-specific tools or commands referenced.
Recommendations
  • Include parallel examples and links for restoring encrypted Linux VMs, such as those using Azure Disk Encryption with Linux or other supported Linux encryption methods.
  • Reference Linux-specific documentation and tools (e.g., CLI, shell scripts) alongside PowerShell and Windows instructions.
  • Ensure that restore scenarios and workflows are described for both Windows and Linux VMs, with clear distinctions and parity in guidance.
  • Add links to Linux disk encryption documentation and FAQs where appropriate.
  • Review all restore scenario tables and ensure Linux is represented equally in both examples and troubleshooting guidance.
GitHub Create Pull Request
Backup https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/backup/automation-backup.md ...re-docs/blob/main/articles/backup/automation-backup.md
High Priority View Details →
Reviewed by: Unknown
Issues: 3 bias types
Detected Bias Types
⚠ī¸ powershell_heavy ⚠ī¸ windows_first ⚠ī¸ missing_linux_example
Summary
The documentation page demonstrates a Windows bias by consistently referencing PowerShell as the primary automation client, mentioning it before CLI and other cross-platform tools. Example workflows and automation scenarios are described using PowerShell and Azure Automation Runbooks (which are often PowerShell-based), with no explicit Linux shell (Bash) or cross-platform scripting examples. There are no Linux-specific examples or mentions of Bash scripting, and the guidance for automation is oriented toward Windows-centric tools and patterns.
Recommendations
  • Provide explicit Bash (Linux shell) examples alongside or before PowerShell examples for all automation scenarios.
  • When listing automation clients, alternate the order or explicitly state that both PowerShell and CLI are supported equally.
  • Include sample scripts and workflows using Azure CLI in Bash, especially for common tasks like configuring backups and exporting operational data.
  • Highlight cross-platform automation options (e.g., Python SDK, Terraform, Ansible) with concrete Linux-based usage examples.
  • Clarify that Azure Automation Runbooks can use Python or Bash, not just PowerShell, and provide links or examples for those.
  • Add a section or callout for Linux administrators, summarizing Linux-friendly automation approaches.
GitHub Create Pull Request
Backup https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/backup/azure-kubernetes-service-cluster-backup-concept.md ...kup/azure-kubernetes-service-cluster-backup-concept.md
High Priority View Details →
Reviewed by: Unknown
Issues: 3 bias types
Detected Bias Types
⚠ī¸ windows_first ⚠ī¸ powershell_heavy ⚠ī¸ missing_linux_example
Summary
The documentation page exhibits a mild Windows bias, primarily in the 'Next steps' section, where Azure PowerShell is mentioned before Azure CLI and is given as a primary method for backup operations. There are no explicit Linux/Unix shell (bash) examples or references, and PowerShell is highlighted as a main automation tool, which is more common on Windows. The documentation does not provide command-line examples in either PowerShell or bash, but the ordering and emphasis suggest a preference for Windows-centric tools.
Recommendations
  • Ensure parity by providing both Azure CLI (bash) and PowerShell examples for all operations, especially in 'Next steps' and linked articles.
  • When listing command-line tools or automation methods, mention Azure CLI (bash) before or alongside PowerShell to avoid implying a Windows-first workflow.
  • Explicitly state that all operations can be performed from Linux/macOS environments using Azure CLI, and provide links or examples for those platforms.
  • If possible, include a section or callout for Linux/macOS users to clarify any differences or prerequisites.
  • Review linked articles to ensure that Linux-friendly instructions are present and not overshadowed by PowerShell/Windows-specific guidance.
GitHub Create Pull Request
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 →
Reviewed by: Unknown
Issues: 3 bias types
Detected Bias Types
⚠ī¸ windows_first ⚠ī¸ windows_tools ⚠ī¸ missing_linux_example
Summary
The documentation references Windows-specific tools (Volume Shadow Copy Service - VSS) before mentioning the Linux equivalent (*fsfreeze*), and links to Windows-specific agent and extension documentation without providing Linux equivalents or links. There are no Linux-specific examples or links, and the language and references are Windows-first.
Recommendations
  • When mentioning backup consistency mechanisms, list Linux (*fsfreeze*) before or alongside Windows (VSS), not after.
  • Provide links to both Windows and Linux VM Agent and snapshot extension documentation, not just Windows.
  • Include Linux-specific examples or scenarios, such as how crash-consistent backup interacts with common Linux workloads.
  • Add a section or note clarifying the process for Linux VMs, including any limitations or best practices.
  • Ensure parity in documentation links and references for both operating systems throughout the page.
GitHub Create Pull Request
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 →
Reviewed by: Unknown
Issues: 3 bias types
Detected Bias Types
⚠ī¸ windows_first ⚠ī¸ missing_linux_example ⚠ī¸ windows_tools
Summary
The documentation demonstrates a Windows bias by prioritizing Windows-specific guidance and tools, providing examples and links for Windows scenarios first or exclusively, and omitting equivalent Linux-specific instructions. PowerShell and Windows-centric workflows are referenced without parallel Linux/CLI examples, and several links and guidance are Windows-only.
Recommendations
  • Provide parallel Linux examples and guidance wherever Windows/PowerShell instructions are given, especially for restore operations, network configuration, and post-restore steps.
  • Include links to Linux documentation (e.g., restoring Linux VMs, using Azure CLI/Bash for VM creation and disk attachment) alongside or before Windows links.
  • When referencing tools like PowerShell, also mention Azure CLI or Bash scripts for Linux users.
  • For post-restore steps, add Linux-specific troubleshooting (e.g., resetting SSH keys, reconfiguring cloud-init, handling Linux agents) with relevant commands and links.
  • Balance scenario tables and guidance to include both Windows and Linux VM restore scenarios, not just Windows-centric features (e.g., Hybrid Use Benefit, domain controllers, SQL VMs).
  • Ensure that all code snippets and command-line instructions have Linux/CLI equivalents, not just Windows CMD/PowerShell.
GitHub Create Pull Request
Backup https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/backup/backup-azure-sql-restore-cli.md ...b/main/articles/backup/backup-azure-sql-restore-cli.md
High Priority View Details →
Reviewed by: Unknown
Issues: 3 bias types
Detected Bias Types
⚠ī¸ windows_first ⚠ī¸ windows_tools ⚠ī¸ missing_linux_example
Summary
The documentation consistently assumes SQL Server workloads running on Windows-based Azure VMs, referencing 'SQLInstance', 'mssqlserver', and using naming conventions and patterns typical of Windows SQL Server deployments. There are no explicit examples, notes, or guidance for restoring SQL Server on Linux VMs, nor any mention of Linux-specific considerations or tools. The CLI examples and resource names all reflect Windows-centric SQL Server environments, and there is no parity for Linux SQL Server users.
Recommendations
  • Add explicit guidance and examples for restoring SQL Server databases running on Linux-based Azure VMs, including any differences in CLI usage, file paths, or prerequisites.
  • Include notes or sections that clarify support for SQL Server on Linux, and highlight any differences in restore operations or limitations.
  • Provide Linux-specific example resource names, file paths (e.g., /var/opt/mssql/data), and scenarios alongside or before Windows examples.
  • Mention any Linux-specific tools or troubleshooting steps relevant to SQL Server on Linux in Azure VMs.
  • Ensure that documentation language and examples are inclusive of both Windows and Linux SQL Server deployments, or clearly state if only Windows is supported.
GitHub Create Pull Request
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 →
Reviewed by: Unknown
Issues: 4 bias types
Detected Bias Types
⚠ī¸ windows_first ⚠ī¸ powershell_heavy ⚠ī¸ missing_linux_example ⚠ī¸ windows_tools
Summary
The documentation demonstrates a Windows bias by consistently presenting Windows-specific tools (such as VSS and PowerShell) first or exclusively, providing detailed instructions and examples for Windows (e.g., VSS integration, PowerShell restore), while Linux guidance is less detailed, generic, or requires user-supplied scripts. Linux examples are either missing or less prescriptive, and Windows tooling is referenced as the default or primary method.
Recommendations
  • Provide equally detailed, step-by-step Linux examples alongside Windows ones, especially for backup and restore operations.
  • Include sample pre/post scripts for common Linux workloads (e.g., MySQL, PostgreSQL) to parallel the VSS integration for Windows.
  • When referencing PowerShell for restore operations, also provide equivalent Azure CLI and/or Bash examples for Linux users.
  • Avoid always listing Windows tools and processes first; alternate or parallelize the order with Linux equivalents.
  • Clarify and expand on Linux-specific backup and restore best practices, including troubleshooting and automation guidance.
GitHub Create Pull Request
Backup https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/backup/backup-azure-vms-troubleshoot.md .../main/articles/backup/backup-azure-vms-troubleshoot.md
High Priority View Details →
Reviewed by: Unknown
Issues: 4 bias types
Detected Bias Types
⚠ī¸ windows_first ⚠ī¸ powershell_heavy ⚠ī¸ windows_tools ⚠ī¸ missing_linux_example
Summary
The documentation displays a notable Windows bias. Many troubleshooting steps and examples focus on Windows-specific tools (such as Event Viewer, Services.msc, Registry Editor, and command prompt commands like net start/stop, vssadmin, icacls, msdtc, regedit, etc.) and PowerShell cmdlets are provided for restore operations. Windows error scenarios are described in detail, often with step-by-step instructions, while Linux equivalents are either missing, less detailed, or only briefly mentioned. In several sections, Windows procedures are presented first or exclusively, with Linux guidance appearing later or only in specific cases. Some error resolutions and examples (e.g., VSS, BitLocker, Visual C++ Redistributable) are entirely Windows-centric, with no Linux alternatives or context.
Recommendations
  • For every Windows-specific troubleshooting step (e.g., using Event Viewer, Services.msc, Registry Editor, net commands), provide equivalent Linux instructions (e.g., using journalctl, systemctl, editing configuration files, checking logs in /var/log, etc.).
  • When PowerShell or Windows command prompt examples are given, also provide Bash or shell command equivalents for Linux VMs.
  • Ensure Linux error scenarios are described with the same level of detail as Windows, including common issues with Linux agents, file systems, and backup extensions.
  • Where Windows tools (e.g., VSS, BitLocker, Visual C++ Redistributable) are referenced, clarify their Linux counterparts or note if the issue is not applicable to Linux, and provide Linux-specific troubleshooting where relevant (e.g., LVM snapshots, SELinux, disk encryption with LUKS).
  • In tables and lists, avoid always listing Windows first; alternate or group by OS, or clearly label sections as 'Windows' and 'Linux'.
  • Add Linux-specific examples for restore operations, such as using Azure CLI or Bash scripts, and reference Linux documentation links where PowerShell is mentioned.
  • Review all error code sections to ensure Linux-specific errors and their resolutions are included and not just Windows-centric issues.
GitHub Create Pull Request
Backup https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/backup/manage-backup-vault.md ...-docs/blob/main/articles/backup/manage-backup-vault.md
High Priority View Details →
Reviewed by: Unknown
Issues: 3 bias types
Detected Bias Types
⚠ī¸ windows_first ⚠ī¸ powershell_heavy ⚠ī¸ missing_linux_example
Summary
The documentation page demonstrates a mild Windows bias. While most instructions are GUI/portal-based and thus platform-agnostic, the only explicit command-line references for moving Backup vaults mention PowerShell first, and the linked PowerShell module, with the CLI mentioned second. There are no explicit Linux/bash examples, nor are there references to Linux-native tools or scripting patterns. The absence of bash or Linux shell examples, and the ordering of PowerShell before CLI, may subtly prioritize Windows users.
Recommendations
  • When referencing command-line options, provide both Azure CLI (az) and PowerShell examples side by side, or list Azure CLI first as it is cross-platform.
  • Include explicit bash/Linux shell script examples where scripting is discussed or implied.
  • Clarify that Azure CLI commands work on Windows, Linux, and macOS, and provide sample commands in bash syntax.
  • Avoid listing PowerShell before CLI unless there is a technical reason; consider alternating order or grouping both under 'Command-line options'.
  • Add a section or note for Linux/macOS users to ensure parity in scripting and automation guidance.
GitHub Create Pull Request
Backup https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/backup/troubleshoot-azure-files.md .../blob/main/articles/backup/troubleshoot-azure-files.md
High Priority View Details →
Reviewed by: Unknown
Issues: 3 bias types
Detected Bias Types
⚠ī¸ powershell_heavy ⚠ī¸ windows_tools ⚠ī¸ missing_linux_example
Summary
The documentation demonstrates a bias toward Windows environments by providing PowerShell scripts (with no Bash or CLI equivalents), referencing scripts and tools that are typically Windows-centric, and omitting Linux or cross-platform command-line examples. There are no instructions or troubleshooting steps tailored for Linux users, and all automation references are to PowerShell scripts.
Recommendations
  • Provide equivalent Bash or Azure CLI scripts for all PowerShell script references, especially for tasks like finding the Recovery Services vault or undeleting file shares.
  • When mentioning scripts, explicitly state if they are cross-platform or provide separate instructions for Windows (PowerShell) and Linux/macOS (Bash/CLI).
  • Include Linux-specific troubleshooting steps or notes where relevant, such as for file share access, permissions, or automation.
  • Review all links to scripts and tools to ensure Linux users are not excluded, and add parity where gaps exist.
  • In general, avoid assuming the user is on Windows; use neutral language and cross-platform tools (like Azure CLI) as the primary example, or present both Windows and Linux options side by side.
GitHub Create Pull Request
Backup https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/backup/whats-new.md ...Docs/azure-docs/blob/main/articles/backup/whats-new.md
High Priority View Details →
Reviewed by: Unknown
Issues: 3 bias types
Detected Bias Types
⚠ī¸ windows_tools ⚠ī¸ windows_first ⚠ī¸ powershell_heavy
Summary
The documentation page for Azure Backup service release notes shows some evidence of Windows bias. Several features and updates reference Windows-specific tools (such as MARS agent and Microsoft Azure Backup Server), and Windows terminology is used without always providing Linux equivalents. In some cases, PowerShell is mentioned as a primary automation method, and Windows-based backup solutions (like MABS) are highlighted. While the page covers many cross-platform workloads (e.g., PostgreSQL, SAP HANA, AKS), the documentation tends to mention Windows tools and patterns first or exclusively, with less emphasis on Linux-native tooling or examples.
Recommendations
  • Wherever Windows-specific tools (e.g., MARS agent, MABS) are mentioned, clarify their platform limitations and provide equivalent Linux-native solutions or alternatives if available.
  • When referencing automation or scripting (e.g., PowerShell), also mention Azure CLI and provide example commands for both Windows and Linux environments.
  • Ensure parity in documentation by highlighting Linux support and tools (such as native Linux backup agents, shell scripts, or integration with Linux backup utilities) alongside Windows tools.
  • Add explicit notes or links to Linux documentation for features that are available cross-platform, to make it clear that Linux is equally supported.
  • Review the order of feature descriptions to avoid always listing Windows/PowerShell options first; alternate or group by platform where appropriate.
GitHub Create Pull Request
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 →
Reviewed by: Unknown
Issues: 3 bias types
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 examples for Linux users, such as Azure CLI or Bash scripts. The PowerShell examples are prominent, and there is no mention of cross-platform command-line alternatives, which may disadvantage users on Linux or macOS.
Recommendations
  • Add Azure CLI examples alongside PowerShell for all command-line operations, as Azure CLI is cross-platform and widely used on Linux.
  • Explicitly mention that PowerShell Core is available cross-platform, if PowerShell examples are retained, and clarify compatibility.
  • Provide Bash script examples for DNS record creation and verification, especially for users managing DNS outside Azure.
  • Ensure that all steps and screenshots are not Windows-specific and clarify when instructions are OS-agnostic.
  • Consider a 'Choose your platform' tab structure (Portal, PowerShell, Azure CLI, Bash) to improve parity and user experience.
GitHub Create Pull Request
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
Medium Priority View Details →
Reviewed by: Unknown
Issues: 2 bias types
Detected Bias Types
⚠ī¸ windows_first ⚠ī¸ missing_linux_example
Summary
The documentation page demonstrates a Windows-first bias by referencing the Windows deployment path (C:\home\site\wwwroot) first and providing a relative path example for Windows, while only later mentioning the Linux path and its requirements. There are no explicit Linux command-line or file system examples, and Linux-specific instructions are minimal and secondary.
Recommendations
  • Present Linux and Windows instructions/examples side by side or in parallel sections.
  • Provide explicit Linux file path examples (e.g., /home/site/wwwroot/auth.json) alongside Windows examples.
  • Clarify platform-specific differences early and equally, rather than mentioning Linux as an afterthought.
  • Include Linux command-line examples (e.g., using bash or Linux-native tools) where relevant.
  • Avoid using only Windows-style paths (C:\...) in initial instructions; always show both formats.
GitHub Create Pull Request
App Service https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/configure-authentication-provider-aad.md ...s/app-service/configure-authentication-provider-aad.md
Medium Priority View Details →
Reviewed by: Unknown
Issues: 2 bias types
Detected Bias Types
⚠ī¸ windows_first ⚠ī¸ missing_linux_example
Summary
The documentation page demonstrates a Windows bias by exclusively referencing the Azure portal UI and omitting any command-line examples, such as Azure CLI, PowerShell, or Bash. There are no platform-specific instructions, but the absence of Linux or cross-platform command-line examples means Linux users are not directly supported. All examples and instructions assume use of the Azure portal, which is platform-agnostic but often associated with Windows workflows. No Linux-specific tools, shell commands, or deployment patterns are mentioned.
Recommendations
  • Add Azure CLI examples for all configuration steps, including app registration, authentication provider setup, and application settings. Ensure these examples are cross-platform and runnable on Linux, macOS, and Windows.
  • Where PowerShell is relevant, provide equivalent Bash or shell commands, or explicitly reference Azure CLI as the preferred cross-platform tool.
  • Include notes or sections on how to perform key steps (such as setting application settings, managing secrets, or registering apps) using the command line on Linux systems.
  • Reference automation and scripting options (e.g., ARM/Bicep templates, Terraform) that are platform-independent.
  • Clarify that the Azure portal is accessible from any OS, but provide parity for users who prefer or require command-line or automated approaches, which are common in Linux environments.
GitHub Create Pull Request
App Service https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/configure-authentication-provider-github.md ...pp-service/configure-authentication-provider-github.md
Medium Priority View Details →
Reviewed by: Unknown
Issues: 2 bias types
Detected Bias Types
⚠ī¸ windows_first ⚠ī¸ missing_linux_example
Summary
The documentation focuses exclusively on configuring GitHub authentication via the Azure Portal UI, which is platform-agnostic but implicitly assumes a graphical interface more commonly associated with Windows environments. There are no command-line examples (such as Azure CLI or PowerShell), but also no Linux-specific or cross-platform terminal instructions. The absence of CLI-based or Linux-native configuration steps means Linux users do not see parity in guidance, and the documentation may feel Windows-centric by omission.
Recommendations
  • Add Azure CLI examples for configuring GitHub authentication, which work cross-platform (Windows, Linux, macOS).
  • Include instructions for configuring authentication using ARM templates or Bicep, which are platform-neutral.
  • Explicitly mention that the Azure Portal can be accessed from any OS, and provide links to CLI documentation for users who prefer terminal-based workflows.
  • If PowerShell examples are added in the future, ensure equivalent Azure CLI examples are provided alongside.
GitHub Create Pull Request
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 →
Reviewed by: Unknown
Issues: 2 bias types
Detected Bias Types
⚠ī¸ windows_first ⚠ī¸ missing_linux_example
Summary
The documentation page demonstrates a subtle Windows bias: in the initial quickstart and sample app links, the 'windows' tab is prioritized or included before Linux equivalents, and there are no explicit Linux-specific instructions or examples for environment setup, deployment, or command-line usage. While the main content is generally cross-platform (Python, Flask, Azure), there is a lack of parity in explicitly addressing Linux users, especially in setup and deployment steps.
Recommendations
  • Ensure that all quickstart and sample app links include Linux tabs or examples, and do not default to 'windows' first.
  • Explicitly mention Linux as a supported platform in setup and deployment instructions.
  • Provide Linux-specific command-line examples (e.g., bash, export commands) alongside any Windows (PowerShell/cmd) examples.
  • Include notes or sections for common Linux development environments (e.g., WSL, Ubuntu, CentOS) where relevant.
  • Review all referenced documentation links to ensure Linux parity in their content and tab ordering.
GitHub Create Pull Request
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
Medium Priority View Details →
Reviewed by: Unknown
Issues: 2 bias types
Detected Bias Types
⚠ī¸ windows_first ⚠ī¸ powershell_heavy
Summary
The documentation presents command-line instructions for both Azure PowerShell and Azure CLI, but consistently lists PowerShell (a Windows-centric tool) before CLI in all tabbed examples. There are no explicit Linux-only instructions or examples, and the use of PowerShell as the first example may suggest a Windows-first approach. However, Azure CLI (which is cross-platform and preferred by many Linux users) is included in all relevant sections, and no steps are exclusive to Windows or PowerShell. No Windows-only tools or patterns are mentioned, and the CLI examples are present and correct.
Recommendations
  • Alternate the order of PowerShell and CLI tabs, or list Azure CLI first to better reflect cross-platform parity.
  • Explicitly mention that Azure CLI commands work on Linux, macOS, and Windows, and consider providing Bash shell snippets or Linux terminal screenshots where appropriate.
  • Add a short note or section on using the Azure Cloud Shell, which is accessible from any OS and supports both PowerShell and Bash.
  • Ensure that any future examples or troubleshooting steps do not assume a Windows environment (e.g., avoid referencing Windows file paths or PowerShell-specific output parsing).
GitHub Create Pull Request
Azure App Configuration https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/azure-app-configuration/quickstart-go-web-app.md ...icles/azure-app-configuration/quickstart-go-web-app.md
Medium Priority View Details →
Reviewed by: Unknown
Issues: 2 bias types
Detected Bias Types
⚠ī¸ windows_first ⚠ī¸ powershell_heavy
Summary
The documentation provides environment variable setup instructions for Windows (cmd and PowerShell) before Linux/macOS, and includes both setx (cmd) and PowerShell examples. Linux/macOS instructions are present but always listed last. There are no missing Linux examples, but the ordering and explicit inclusion of multiple Windows shell types (cmd, PowerShell) before Linux suggests a mild Windows-first bias.
Recommendations
  • Alternate the order of platform instructions (sometimes list Linux/macOS first, or use tabs for OS selection).
  • Use tabbed or dropdown UI for OS-specific instructions to avoid implicit prioritization.
  • Ensure parity in detail and clarity for Linux/macOS instructions (which is already good here).
  • Consider mentioning cross-platform tools (e.g., direnv, dotenv) for environment variable management.
  • Explicitly state that all commands are cross-platform unless otherwise noted.
GitHub Create Pull Request
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
Medium Priority View Details →
Reviewed by: Unknown
Issues: 2 bias types
Detected Bias Types
⚠ī¸ windows_first ⚠ī¸ powershell_heavy
Summary
The documentation generally maintains good cross-platform parity, but there are subtle signs of Windows bias. In command-line examples, both Bash and Windows CMD are provided, but CMD examples are always listed second, which is a positive sign for Linux parity. However, the documentation refers to 'command prompt' in the getting started section, which is a Windows-specific term, and does not mention Linux shells (e.g., Bash, Zsh) equivalently. There is also a lack of explicit mention of Linux-specific tools or troubleshooting steps, and some terminology (e.g., 'command prompt', 'Terminal') is inconsistent. All Azure CLI examples are provided for both Bash and CMD, but there are no PowerShell-specific examples, which is good. There are no Windows-only tools or patterns, but the documentation could be more explicit in addressing Linux users and their environments.
Recommendations
  • In the getting started section, replace 'command prompt' with 'terminal or command prompt' or explicitly mention both Windows and Linux shells (e.g., 'command prompt (Windows) or terminal (Linux/macOS)').
  • Wherever 'Terminal' is mentioned, clarify that it refers to Bash, Zsh, or other shells on Linux/macOS, and Command Prompt or PowerShell on Windows.
  • Add troubleshooting tips or notes specific to Linux environments, such as file permissions, environment variable configuration, or common issues with Maven/Java on Linux.
  • Ensure that any references to environment variables (e.g., JAVA_HOME) include Linux export syntax as well as Windows set syntax.
  • Consider including at least one explicit example of running or debugging on a Linux system, or referencing Linux-specific documentation where appropriate.
  • Audit for any other subtle terminology that may assume a Windows-first perspective, and rephrase for cross-platform inclusivity.
GitHub Create Pull Request
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 →
Reviewed by: Unknown
Issues: 2 bias types
Detected Bias Types
⚠ī¸ missing_linux_example ⚠ī¸ windows_tools
Summary
The documentation page primarily describes known issues and workarounds for Azure VMware Solution, with very few platform-specific instructions. However, in the two entries related to VMware Tools remediation (CVE-2025-22247 and CVE-2025-22230), the workaround references the Azure VMware Solution Run command Set-Tools-Repo, which is likely to be a PowerShell or Windows-centric command. There are no explicit Linux or cross-platform command examples, nor is there mention of Linux-specific tooling or alternative instructions for non-Windows environments. No PowerShell scripts or Windows command-line examples are shown, but the lack of Linux parity in the remediation steps constitutes a subtle Windows bias.
Recommendations
  • For any command-line instructions (such as Set-Tools-Repo), clarify whether the command is platform-agnostic, or provide equivalent Linux/bash instructions if available.
  • Explicitly state if the remediation steps can be performed from Linux/macOS environments, and provide examples or guidance for those platforms.
  • Where possible, avoid assuming the use of Windows tools or interfaces; if a workaround is only available via a Windows tool, note this limitation and suggest alternatives or workarounds for Linux users.
  • Review all automation or scripting references to ensure they are either cross-platform or that Linux/macOS equivalents are documented.
GitHub Create Pull Request
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
Low Priority View Details →
Reviewed by: Unknown
Issues: 1 bias type
Detected Bias Types
⚠ī¸ missing_linux_example
Summary
The documentation page discusses assessing .NET web apps for migration to Azure App Service but does not provide any platform-specific examples or tools. However, it implicitly assumes a Windows/ASP.NET context by only referencing 'ASP.NET web apps' and not mentioning Linux-based .NET Core or cross-platform scenarios. There are no explicit Windows tools or PowerShell commands, but the absence of Linux or cross-platform guidance suggests a subtle Windows bias.
Recommendations
  • Explicitly mention support for both Windows (ASP.NET) and Linux (.NET Core) web apps where applicable.
  • Include examples or references for assessing Linux-hosted .NET apps, such as those running on .NET Core or ASP.NET Core.
  • Clarify whether the assessment tools and recommendations apply equally to Linux-based .NET workloads.
  • Add links or sections addressing Linux migration scenarios and any platform-specific considerations.
GitHub Create Pull Request
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 →
Reviewed by: Unknown
Issues: 1 bias type
Detected Bias Types
⚠ī¸ windows_first
Summary
The documentation exhibits a subtle 'windows_first' bias: the only explicit link for VM creation is to the Windows VM quickstart, and in the VM agent installation section, Windows instructions are listed before Linux. However, both Windows and Linux agent installation steps are present, and the rest of the documentation is platform-neutral, focusing on the Azure portal UI.
Recommendations
  • Provide parallel links for both Windows and Linux VM creation in the introduction, e.g., 'create a VM with the Azure portal (Windows | Linux)'.
  • Alternate the order of Windows and Linux instructions in the VM agent installation section, or present them side-by-side.
  • Ensure all screenshots and UI references are clearly applicable to both Windows and Linux VMs, or clarify any differences.
  • Where possible, mention Linux-specific considerations (e.g., agent verification steps) with the same level of detail as Windows.
GitHub Create Pull Request