App Service
432
Total Pages
240
Linux-Friendly Pages
192
Pages with Bias
44.4%
Bias Rate
Bias Trend Over Time
Pages with Bias Issues
2121 issues found
Showing 776-800 of 2121 flagged pages
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 moderate Windows bias. Windows terminology and tools (such as Azure PowerShell) are presented prominently and sometimes before Linux equivalents. While both Windows and Linux SKU availability commands are shown, automation examples focus on Azure CLI and Azure PowerShell, with no mention of Linux-native scripting (e.g., Bash) or deployment patterns. The use of the Azure portal is described in a way that is platform-neutral, but the automation and scripting sections lean toward Windows-centric tools and workflows.
Recommendations
- Add explicit Bash scripting examples for Linux users alongside PowerShell examples in the automation section.
- Clarify that Azure CLI commands are cross-platform and can be used on Linux, macOS, and Windows.
- Include references to Linux-native tools or workflows where relevant (e.g., Bash scripts, deployment via Linux terminals).
- Ensure that Linux examples are presented with equal prominence and, where possible, before or alongside Windows examples.
- Mention that the Azure portal is accessible from any OS, and highlight any OS-specific considerations if they exist.
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 by focusing exclusively on migration scenarios and tools for ASP.NET web apps running on Windows/IIS servers. All migration tools and scripts referenced are for Windows (including MSI installers and PowerShell scripts), with no mention of Linux-based hosting environments, migration from Linux servers, or Linux command-line examples. The documentation does not provide parity for Linux users or address migration of .NET apps hosted on Linux platforms.
Recommendations
- Include migration guidance and tools for .NET apps hosted on Linux (e.g., Apache, Nginx, Kestrel).
- Provide Linux-specific examples and command-line instructions (e.g., Bash scripts, CLI commands) alongside or before Windows/PowerShell examples.
- Reference or develop migration tools that support Linux environments, and document their usage.
- Clarify in the introduction that the current tools are Windows-centric, and provide links or guidance for Linux users where possible.
- Highlight any limitations or future plans for Linux support in the migration tooling.
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 page exclusively discusses discovery of .NET web apps hosted on IIS web servers within VMware environments, which are Windows-centric technologies. There is no mention of Linux-based hosting scenarios (e.g., .NET apps on Apache, Nginx, or Kestrel), nor are there examples or guidance for discovering .NET apps on Linux servers. All tools and workflows referenced (Azure Migrate appliance, IIS) are Windows-specific.
Recommendations
- Include information about discovering .NET web apps hosted on Linux servers, such as those running on Apache, Nginx, or Kestrel.
- Provide parity in examples and workflows for both Windows (IIS) and Linux-based hosting environments.
- Mention any Azure Migrate capabilities or limitations for Linux-hosted .NET apps, or clarify if such scenarios are unsupported.
- Add links to documentation or tools relevant for Linux-based .NET app discovery and migration.
- Explicitly state the scope of the documentation if it is intentionally limited to Windows/IIS, and provide references for Linux users.
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 First
Missing Linux Example
Windows Tools
Summary
The documentation page exhibits subtle Windows bias. While it is generally cross-platform, it references Windows-specific configuration files (web.config), tools (iisnode), and patterns before or instead of Linux equivalents. Linux-specific instructions are minimal and not consistently provided alongside Windows examples.
Recommendations
- Provide Linux-specific configuration guidance wherever Windows-specific files (like web.config) are mentioned. For example, explain how to configure auto-healing or similar features for Linux-based App Service plans.
- When referencing tools like iisnode (Windows/IIS-specific), also mention and provide guidance for Linux process managers (e.g., PM2, systemd) for Node.js apps.
- Ensure that examples and troubleshooting steps are given for both Windows and Linux App Service environments, especially in sections about configuration, diagnostics, and process management.
- Explicitly state when a feature or recommendation is Windows-only, and offer Linux alternatives or workarounds where possible.
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 some Windows bias by presenting Azure PowerShell automation after Azure CLI, referencing PowerShell as a primary scripting tool, and using terms and screenshots that are more familiar to Windows users. While Linux is mentioned (e.g., Linux containers, --linux-workers-enabled), there are no Linux shell-specific examples, and the automation section does not provide Bash or Linux-native scripting patterns. The portal instructions and screenshots are platform-neutral, but the scripting focus leans toward Windows tools.
Recommendations
- Add explicit Bash or Linux shell script examples alongside Azure PowerShell, especially in the automation section.
- Clarify that Azure CLI commands can be run on both Windows and Linux, and provide sample shell scripts for Linux users.
- When mentioning PowerShell, also mention Bash or other Linux-native scripting environments to ensure parity.
- Ensure that any references to tools or patterns (such as PowerShell) are balanced with Linux equivalents, or note when a tool is cross-platform.
- Consider including a section or call-out specifically for Linux users, highlighting any differences or best practices.
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 troubleshooting steps are often presented first or exclusively, with more detail and screenshots for Windows GUI tools. PowerShell commands are used for connectivity testing without equivalent Linux commands. Some features, such as the Hybrid Connection Manager GUI, are only available on Windows, and this is noted, but Linux alternatives are not always described with equal depth. Troubleshooting and connectivity testing examples are Windows-centric, and Linux users are sometimes directed to generic alternatives or left to infer equivalent steps.
Recommendations
- Provide Linux-first or parallel Linux examples alongside Windows instructions, especially for common tasks like connectivity testing (e.g., show 'nc' or 'telnet' commands as alternatives to PowerShell's Test-NetConnection).
- Include Linux screenshots or terminal output where Windows GUI screenshots are shown, or at least provide equivalent CLI walkthroughs.
- Expand troubleshooting steps to include Linux-specific commands and procedures, such as using 'ss', 'netcat', or 'curl' for network diagnostics.
- Where features are Windows-only (e.g., GUI tools), offer detailed Linux CLI alternatives and explicitly note any limitations or workarounds.
- Ensure that installation and upgrade instructions for Linux are as detailed and prominent as those for Windows, including package dependencies and service management.
- Review the order of presentation so that Linux and Windows are given equal prominence, rather than consistently listing Windows first.
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
Powershell Heavy
Windows Tools
Windows First
Summary
The documentation provides both Linux and Windows instructions for configuring data sources in Tomcat and JBoss on Azure App Service. However, the Windows section relies heavily on PowerShell scripts and Windows-specific patterns (such as .cmd files, %HOME% paths, and Windows environment variables), while the Linux section uses shell scripts and Linux tools. The Windows instructions are more verbose and detailed, with step-by-step PowerShell automation, whereas Linux instructions are more concise and assume familiarity with shell scripting. The documentation sometimes presents Windows tooling and patterns before Linux equivalents, and the Windows section uses Windows-native tools exclusively for configuration tasks.
Recommendations
- Provide equivalent Linux shell script examples for every PowerShell script shown for Windows, ensuring parity in automation and clarity.
- Where Windows-specific tools (e.g., PowerShell, .cmd files) are used, offer Linux alternatives (e.g., bash scripts) side-by-side.
- Standardize the structure and depth of instructions for both platforms, so Linux users receive equally detailed guidance.
- Avoid presenting Windows tools or patterns before Linux equivalents in sections that apply to both platforms; use parallel presentation or platform-specific tabs.
- Explicitly mention cross-platform considerations and differences at the start of each section to help users navigate platform-specific steps.
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 equivalents. Tools and folder structures are described only in the context of Windows environments, and there is no guidance for Linux-based App Service plans. The only mention of Linux is to state that the feature is unsupported for Linux containers, but there are no examples or instructions for Linux App Service environments.
Recommendations
- Provide parallel examples and explanations for Linux-based App Service plans, including Linux file paths and environment variables.
- Clarify which features and instructions apply to Windows, Linux, or both, ideally with clear sections or callouts.
- Include Linux-native tools or commands (e.g., using du or ls to check folder sizes) alongside Windows tools.
- Mention and link to documentation for Linux equivalents or alternatives (such as App Cache for Linux) more prominently.
- Avoid using only Windows paths (D:\home, D:\local) and instead provide Linux path equivalents (e.g., /home/site, /home/LogFiles) where appropriate.
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 Windows bias by exclusively providing PowerShell-based examples for per-app scaling, with no equivalent examples for Linux-native tools (such as Bash/CLI). The use of Azure PowerShell cmdlets is emphasized, and there is no mention of cross-platform alternatives like the Azure CLI. This may make it less accessible for Linux or macOS users who do not use PowerShell.
Recommendations
- Add equivalent Azure CLI (az) examples for all PowerShell commands to ensure Linux and macOS users can follow along easily.
- Explicitly mention that per-app scaling can be configured using Azure CLI, and provide sample commands.
- Consider providing Bash script examples where appropriate, or at least note cross-platform compatibility.
- Reorganize sections so that cross-platform tools (Azure CLI, ARM templates) are presented before or alongside PowerShell examples, rather than PowerShell first.
- Clarify in the introduction that all features are available regardless of OS, and link to cross-platform tooling documentation.
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
Missing Linux Example
Windows Tools
Powershell Heavy
Summary
The documentation page demonstrates a strong Windows bias. It exclusively references Windows-based deployment patterns, tools, and file paths (e.g., Kudu CMD/PowerShell, D:\ paths, Visual Studio publishing). There are no Linux-specific instructions, examples, or mentions of Linux-based App Service environments. The guidance assumes a Windows hosting environment throughout, omitting Linux equivalents for runtime inspection, configuration, and diagnostics.
Recommendations
- Add parallel instructions and examples for Linux-based App Service environments, including how to check installed .NET runtimes and access diagnostic tools.
- Include Linux shell (bash) commands and file paths where appropriate, especially for runtime version inspection and environment variable access.
- Mention and demonstrate deployment workflows that are common on Linux (e.g., using dotnet CLI, VS Code, or GitHub Actions) alongside Visual Studio.
- Clarify in each section whether the instructions apply to Windows, Linux, or both, and provide links to Linux-specific documentation where available.
- Provide guidance on accessing logs and debugging information in Linux containers or App Service on Linux, not just via Windows tools like Kudu CMD/PowerShell.
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 Windows-specific tools (Azure Storage Explorer) and providing instructions that are either Windows-centric or lack Linux/macOS alternatives. The Storage Explorer SAS generation link is explicitly for Windows, and there is no mention of Linux-compatible tools or workflows for uploading files or generating SAS tokens. All command-line examples use Azure CLI, which is cross-platform, but the absence of Linux-specific guidance or parity in tooling references can disadvantage Linux users.
Recommendations
- Include instructions or links for using Azure Storage Explorer on Linux/macOS, or mention its cross-platform availability if applicable.
- Provide alternative methods for uploading files and generating SAS tokens using cross-platform tools such as the Azure CLI or azcopy, with explicit examples.
- Avoid labeling links or sections as 'Windows' unless there is a parallel for other operating systems, or provide equivalent Linux/macOS tabs or notes.
- Audit the documentation for other Windows-centric patterns and ensure Linux users have clear, first-class guidance for all steps.
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
Missing Linux Example
Windows First
Summary
The documentation demonstrates a Windows bias primarily by providing a PowerShell script as the only automation example for identifying impacted Azure Traffic Manager profiles (Scenario 2). There are no equivalent Bash, Azure CLI, or cross-platform script examples for Linux/macOS users. The instructions for running the script explicitly reference PowerShell, and there is no mention of alternatives or parity for non-Windows environments. While other sections use Azure CLI and REST API (which are cross-platform), the only automation script provided is Windows-centric, and the PowerShell approach is presented first and exclusively.
Recommendations
- Provide equivalent Bash or Azure CLI scripts for Linux/macOS users to identify non-Azure Traffic Manager endpoints, or at least reference how to achieve the same result using cross-platform tools.
- When recommending scripts or automation, offer both PowerShell and Bash (or CLI) examples, and clarify their platform compatibility.
- Explicitly mention that the PowerShell script can be run on PowerShell Core (which is cross-platform) if applicable, or provide installation guidance for non-Windows users.
- Adopt a 'platform-neutral' approach by presenting Azure CLI or REST API examples before or alongside PowerShell scripts.
- Audit future documentation for similar scenarios where only Windows/PowerShell tooling is referenced, and ensure Linux/macOS parity is considered.
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-based Azure App Service environments, specifically those using iisnode. All configuration and troubleshooting steps reference Windows concepts, tools, and file paths (e.g., node.exe, web.config, named pipes, Win32 error codes, d:\home\LogFiles). Examples and instructions are provided only for Windows environments, with no mention of Linux-based Azure App Service or cross-platform alternatives. Tools like Kudu are referenced with CMD/PowerShell, and there is no parity for Bash or Linux-native workflows.
Recommendations
- Add equivalent sections and examples for Linux-based Azure App Service environments, including configuration, troubleshooting, and file locations.
- Provide Linux/Bash command-line examples in addition to (or instead of) CMD/PowerShell, and reference Linux-native tools where appropriate.
- Clarify early in the document that the content is specific to Windows App Service, and provide links or references to Linux-focused documentation for Node.js on Azure.
- Where possible, use cross-platform Node.js concepts and tools (such as PM2 for process management) and avoid Windows-specific terminology (e.g., node.exe, Win32 error codes) unless necessary.
- Include troubleshooting steps and log file locations for Linux-based deployments (e.g., /home/LogFiles, /var/log, etc.).
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 and instructions before Linux, despite the page title listing Linux first. The Windows section is brief and only mentions browser-based SSH, while the Linux section provides detailed CLI-based SSH instructions and examples. There is a lack of parity in example depth and tool coverage: Windows users are not given CLI or PowerShell alternatives, and Linux users are not given browser-based SSH instructions. The documentation also refers to Windows containers as requiring 'no modifications' while Linux containers require 'additional configurations', potentially implying Windows is easier by default. Furthermore, Windows tools and patterns (browser SSH) are mentioned exclusively for Windows, with no equivalent CLI/PowerShell guidance.
Recommendations
- Provide equivalent CLI or PowerShell instructions for Windows containers, or explicitly state their absence and any workarounds.
- Ensure both Windows and Linux sections have similar depth and example coverage (e.g., both should cover browser-based SSH and CLI-based SSH if supported).
- If a feature is not supported on one platform (e.g., CLI SSH for Windows), clearly explain why and suggest alternatives.
- Avoid language that implies one platform is easier or more supported than the other; instead, neutrally describe the requirements for each.
- Consider reordering or parallelizing the documentation so that Linux and Windows instructions are presented side-by-side for each feature.
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 page demonstrates a Windows bias by referencing Windows directory paths (e.g., D:\home\site\wwwroot) before Linux equivalents, using Windows-style path separators in examples, and omitting explicit Linux/Bash command examples or Linux-specific instructions. The focus is on Windows conventions and tools, with limited mention of Linux environments or parity.
Recommendations
- Present both Windows and Linux directory paths together, or list Linux paths first where appropriate (e.g., '/home/site/wwwroot' before 'D:\home\site\wwwroot').
- Include Linux/Bash command examples alongside Azure CLI, especially where file paths or manual steps are shown.
- Use cross-platform path notation (e.g., '<project-root>/app_data/jobs/...') or provide both Windows (\) and Linux (/) path examples.
- Explicitly mention differences or considerations for Linux-based App Service plans, including any variations in deployment directories or behaviors.
- Add troubleshooting notes or caveats specific to Linux environments if applicable.
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 primarily referencing Windows-centric workflows and tools (e.g., Visual Studio, right-click context menus), and omitting explicit Linux or cross-platform alternatives for key steps such as file creation, package installation, and deployment. Command-line or editor-agnostic instructions are not provided, and Linux-specific guidance is missing.
Recommendations
- For file creation and editing steps, provide equivalent CLI commands (e.g., using 'touch', 'nano', or 'vim') and/or instructions for popular cross-platform editors (e.g., VS Code) alongside Visual Studio instructions.
- When referencing package installation, include explicit .NET CLI commands (e.g., 'dotnet add package Microsoft.SemanticKernel') in addition to NuGet/Visual Studio GUI steps.
- Clarify that all steps can be performed on Linux, macOS, or Windows, and provide any OS-specific notes as needed (e.g., for environment variable configuration).
- For deployment, mention cross-platform deployment options (e.g., using 'az webapp deploy', 'dotnet publish', or GitHub Actions) and not just portal-based workflows.
- Where screenshots or UI navigation are referenced, provide alternative text-based instructions for users not on Windows or not using Visual Studio.
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 →
Detected Bias Types
Missing Linux Example
Windows Tools
Windows First
Summary
The documentation assumes a development environment based on GitHub Codespaces and Azure App Service, both of which are cross-platform but are typically associated with Windows-centric workflows. All examples and instructions use .NET (a historically Windows-first framework), and there is no mention of Linux-specific tooling, deployment, or terminal commands. The tutorial omits any Linux shell or non-Windows environment considerations, and does not provide parity for developers using Linux locally or alternative editors/IDEs.
Recommendations
- Explicitly mention that all commands and steps work on both Windows and Linux, or provide Linux-specific notes where differences exist.
- Include examples of running the app and deploying from a native Linux terminal (e.g., bash), not just from Codespaces.
- Reference Linux-native editors (e.g., VS Code on Linux, Vim, etc.) and clarify that .NET Core and Azure CLI are fully supported on Linux.
- If any step is different on Linux (such as environment variable handling or file paths), provide those details.
- Add a note or section for developers running the sample locally on Linux, including prerequisites (e.g., installing .NET SDK and Azure CLI on Ubuntu).
- Ensure security best practices mention Linux-specific considerations (such as file permissions or SELinux/AppArmor if relevant).
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
High Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Missing Linux Example
Summary
The documentation page demonstrates a mild Windows bias. In the prerequisites and quickstart links, 'windows' is specified first in tabbed instructions, and there is a lack of explicit Linux or cross-platform deployment examples. The guidance for environment variable setup and deployment references the Azure portal and Visual Studio, both of which are more commonly associated with Windows workflows. There are no explicit Linux shell or deployment examples, and no mention of Linux-specific tools or patterns, despite the 'linux-related-content' tag.
Recommendations
- Provide explicit Linux (and macOS) command-line examples for environment variable setup and deployment, such as using Bash or zsh.
- Include instructions for deploying from Linux environments, such as using Azure CLI from a Linux terminal, or deploying via GitHub Actions or other cross-platform CI/CD tools.
- When referencing quickstarts or sample apps, ensure that Linux tabs/examples are given equal prominence to Windows, or provide a neutral (cross-platform) default.
- Mention and demonstrate use of Linux-native editors (e.g., VS Code on Linux, nano, vim) or terminal workflows where appropriate.
- Clarify that all Python and Azure CLI commands are cross-platform unless otherwise noted, and avoid implying that Visual Studio is required for deployment.
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
Summary
The documentation provides both Azure CLI and Azure PowerShell examples for finding outbound IP addresses, but PowerShell examples are always listed after CLI and are included in every relevant section. There are no explicit Linux shell or Bash script examples beyond the use of Azure CLI, and no mention of Linux-specific tools or patterns. Additionally, outbound IPv6 support is noted as being available only for Windows apps, with no Linux parity.
Recommendations
- Clarify that Azure CLI commands work cross-platform (Windows, macOS, Linux) and are the recommended approach for Linux users.
- Explicitly state that PowerShell examples are primarily for Windows users, and consider providing Bash script equivalents for common tasks.
- Where PowerShell is shown, consider also showing a Bash or shell script example for Linux users, especially for tasks involving parsing or automation.
- For outbound IPv6 support, clarify the roadmap or alternatives for Linux users, or provide a link to track Linux support status.
- In sections where only PowerShell and CLI are shown, add a note or example for Linux users if there are any OS-specific caveats or differences.
- Review the ordering of examples to avoid implicit prioritization of Windows tools; consider presenting CLI (cross-platform) first, then PowerShell, then any OS-specific notes.
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 subtle Windows bias by providing detailed subnet/IP calculation examples specifically for Windows Containers, mentioning Windows Server Active Directory domain join as a non-supported feature, and referencing Kudu (a tool with a Windows-centric history) for environment variable inspection. While Linux is mentioned in the context of continuous deployment network dependencies, there is a lack of parity in example depth and troubleshooting guidance for Linux scenarios. No Linux-specific subnet/IP calculation examples or Linux-native tools are discussed.
Recommendations
- Add equivalent subnet/IP calculation examples for Linux containers and Linux App Service plans, including any unique considerations.
- Provide Linux-specific troubleshooting steps and references to Linux-native tools (e.g., bash, curl, netcat) for network diagnostics.
- Balance the mention of Kudu with references to Linux-native diagnostic environments (e.g., SSH, bash console in App Service for Linux).
- Clarify any differences in environment variable access or behavior between Windows and Linux App Service environments.
- Ensure that all feature limitations and configuration steps are equally documented for both Windows and Linux, including any Linux-specific caveats.
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 demonstrates a Windows bias by referencing Windows-specific tools (IIS, Procdump, SysInternals), focusing on .NET/ASP.NET examples, and highlighting PowerShell and DOS commands in the Kudu Console. There is a lack of Linux-specific troubleshooting guidance, and Linux-native tools or command-line examples are not mentioned. The Application Insights Profiler section links specifically to enabling the .NET Profiler for Windows, and the Kudu Console is described in terms of Windows shell commands. No parity is provided for Linux-based App Service environments.
Recommendations
- Include Linux-specific troubleshooting steps and examples, such as using Bash in the Kudu Console, and mention Linux-native diagnostic tools (e.g., strace, lsof, top).
- Provide guidance for enabling and interpreting logs on Linux-based App Service plans, including differences from Windows (e.g., no IIS, different log file locations).
- When referencing PowerShell or DOS commands, also provide equivalent Bash or Linux shell commands.
- Link to documentation for Application Insights Profiler and diagnostic features as they apply to Linux-based App Service environments.
- Clarify when features or tools are Windows-only and provide alternatives or workarounds for Linux users.
- Add examples and guidance for troubleshooting Node.js, Python, Java, or other non-.NET apps, especially as they run on Linux App Service.
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 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. Windows-specific tools and log formats (e.g., W3C, Log Parser, .NET logging) are mentioned, while Linux equivalents or alternatives are not provided. Linux logging instructions are brief, and several logging features are either unavailable or not explained for Linux, leading to missing Linux examples.
Recommendations
- Clearly indicate which logging features are exclusive to Windows and which are available on Linux, and provide parity where possible.
- Add equivalent Linux examples and instructions for all logging scenarios, or explicitly state if a feature is not supported on Linux.
- Include Linux-friendly tools and log formats, and suggest open-source alternatives to Windows tools like Log Parser.
- Provide more detailed guidance for Linux/container logging, including how to access, parse, and analyze logs.
- Where features are not available on Linux, suggest workarounds or best practices for Linux users.
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 First
Missing Linux Example
Windows Tools
Summary
The documentation page demonstrates a subtle Windows bias by referencing Windows-specific tools and patterns (such as web.config and iisnode) without providing equivalent Linux guidance or examples. While there is some mention of Linux (e.g., using PM2 for Node.js), most configuration and troubleshooting advice assumes a Windows environment, and Linux alternatives are not consistently presented.
Recommendations
- For every mention of Windows-specific configuration files (e.g., web.config), provide equivalent instructions for Linux (e.g., app settings, environment variables, or startup scripts).
- When referencing iisnode or IIS-based settings, include guidance for Node.js apps running on Linux, such as using PM2, Nginx, or other process managers.
- Ensure all code/configuration examples are provided for both Windows and Linux environments, or clearly indicate when a step is platform-specific.
- Where possible, use cross-platform terminology and tools, or provide side-by-side instructions for both platforms.
- Expand troubleshooting and best practices sections to explicitly address Linux-based App Service environments, including differences in diagnostics, scaling, and process management.
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 are no examples or guidance for migrating .NET apps from Linux environments, nor are Linux-native tools or command-line examples provided. The documentation repeatedly references Windows-specific technologies and omits any mention of Linux-based .NET hosting or migration scenarios.
Recommendations
- Add guidance and examples for migrating .NET apps hosted on Linux servers (e.g., Apache, Nginx) to Azure App Service.
- Include Linux-native tooling or scripts (such as Bash or shell scripts) for discovery, assessment, and migration.
- Mention and document migration paths for .NET Core or ASP.NET Core apps running on Linux.
- Ensure parity in documentation by providing Linux examples alongside Windows examples, rather than focusing solely on Windows/IIS.
- Reference cross-platform tools and approaches where possible, and clarify any Windows-only limitations in the tools described.
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 exhibits a mild Windows bias. In several sections, Windows terminology and tools (such as Azure PowerShell) are presented before or more prominently than their Linux counterparts. The Azure CLI is included, which is cross-platform, but the PowerShell section is given equal prominence, and there is no mention of Bash scripting or Linux-native automation. The portal UI instructions do not clarify parity for Linux users, and screenshots are Windows-centric. There are no explicit Linux shell script examples, and the documentation does not discuss Linux-specific considerations or workflows.
Recommendations
- Ensure that Linux and cross-platform automation examples (e.g., Bash scripts) are provided alongside or before PowerShell examples.
- Clarify in portal instructions and screenshots whether the experience is identical for Linux-hosted apps and users.
- Add explicit notes or sections for Linux users, including any differences or considerations when using the Premium V3 tier.
- Consider including Linux-native CLI usage patterns (e.g., Bash for loops, environment variables) in automation sections.
- Review screenshots and UI instructions to ensure they are not Windows-specific or clarify if the experience is the same on Linux.