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 626-650 of 2121 flagged pages
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 exhibits a mild Windows bias. It provides detailed calculations and limitations specifically for Windows Containers, including subnet sizing and networking units, while not offering equivalent details for Linux containers. The only explicit mention of Linux is in the context of continuous deployment network dependencies, which is brief and lacks parity with the Windows-focused section. There are no Linux-specific examples, tools, or troubleshooting steps, and the documentation does not address Linux container-specific networking considerations.
Recommendations
- Add a parallel section detailing subnet sizing, networking unit calculations, and limitations for Linux containers, similar to the 'Windows Containers specific limits' section.
- Include Linux-specific examples or troubleshooting steps where relevant, especially in areas like scaling, networking, and deployment.
- Ensure that any Windows-specific guidance is matched with Linux equivalents, or explicitly state when a limitation or feature is Windows-only.
- Provide links to Linux container documentation or best practices for App Service VNet integration.
- Review the order of presentation to avoid always listing Windows scenarios first; consider a more balanced or side-by-side approach.
Create Pull Request
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/configure-language-java-deploy-run.md
...cles/app-service/configure-language-java-deploy-run.md
High Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Powershell Heavy
Missing Linux Example
Summary
The documentation provides both Linux and Windows examples for most tasks, but there are several areas where Windows is prioritized or receives more detailed coverage. Windows-specific tools (Kudu, FTPS, web.config) are mentioned, sometimes without Linux equivalents or with less detail. In some sections, Windows instructions appear before Linux, and certain advanced troubleshooting or deployment patterns (e.g., Kudu Process Explorer, web.config notes) are Windows-centric. Some features, such as Tomcat patch version pinning, are described as more flexible on Windows than Linux. There are also references to legacy Windows deployment conventions and tools without Linux alternatives.
Recommendations
- Ensure that Linux examples are always present and as detailed as Windows ones, especially for advanced troubleshooting and deployment scenarios.
- Where Windows tools (e.g., Kudu, FTPS, web.config) are mentioned, provide Linux equivalents or clarify Linux alternatives (e.g., SSH, SCP, Linux config files).
- Avoid presenting Windows instructions before Linux unless there is a technical reason; consider using neutral or Linux-first ordering.
- Expand documentation for Linux-specific workflows, such as container debugging, file access, and deployment, to match the depth of Windows coverage.
- Clarify any feature parity differences (e.g., Tomcat patch version pinning) and provide guidance for Linux users where limitations exist.
- Review all notes and tips to ensure Linux users are not left with unanswered questions or missing context compared to Windows 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 Windows bias by referencing Windows-specific tools and patterns (such as web.config and iisnode) without providing equivalent Linux guidance or examples. Linux-specific configuration and troubleshooting steps are largely absent, and Windows approaches are mentioned first or exclusively in several sections.
Recommendations
- For auto-healing configuration, provide Linux-native guidance (such as using application settings, environment variables, or Linux-specific configuration files) alongside or instead of web.config, which is Windows/IIS-specific.
- When discussing Node.js hosting, include Linux process managers (such as PM2, which is mentioned, but also clarify differences from iisnode) and provide examples for both Windows and Linux environments.
- Where iisnode is referenced, add parallel information for Linux-based Node.js hosting (e.g., using PM2, systemd, or other process managers) and clarify when each is applicable.
- Ensure that all troubleshooting and best practice steps are described for both Windows and Linux App Service plans, or clearly indicate when a feature is platform-specific.
- Review all examples and instructions to ensure Linux parity, adding Linux shell commands or configuration examples where only Windows/Powershell/web.config are currently shown.
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
Summary
The documentation page demonstrates a Windows bias primarily through the exclusive use of PowerShell scripts for advanced resource identification (e.g., identifying Traffic Manager endpoints and retrieving both site properties and config values). There are no equivalent Bash, Azure CLI, or cross-platform script examples provided for Linux or Mac users. The documentation assumes access to and familiarity with PowerShell, which is traditionally a Windows-centric tool, although it is now available cross-platform. However, no Linux-native or Bash alternatives are mentioned, and PowerShell is referenced as the default scripting environment for automation tasks.
Recommendations
- Provide equivalent Bash or Azure CLI script examples for all PowerShell scripts referenced, ensuring Linux and Mac users can perform the same tasks without needing PowerShell.
- When referencing scripts, clarify if they are cross-platform or provide explicit instructions for running them on Linux/Mac (e.g., using PowerShell Core).
- List Azure CLI and REST API options before or alongside PowerShell to avoid the impression that Windows tools are preferred or required.
- Where possible, use Azure CLI for automation examples, as it is natively cross-platform and familiar to both Windows and Linux users.
- Explicitly mention that PowerShell scripts can be run on Linux/Mac with PowerShell Core, or provide links to documentation on installing PowerShell on those platforms.
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 is heavily focused on Windows-based migration scenarios, tools, and patterns. All migration tools and examples target Windows environments, specifically IIS servers, and PowerShell scripts. There is no mention of Linux-based .NET hosting environments, migration from Linux servers, or equivalent Linux tools or scripts. The documentation assumes the source environment is always Windows/IIS, and all downloadable tools are Windows executables or PowerShell scripts.
Recommendations
- Add guidance and examples for migrating .NET apps hosted on Linux servers (e.g., Apache, Nginx, Kestrel) to Azure App Service.
- Include Linux-compatible migration tools or scripts, or clearly state if such tools are not available.
- Provide parity in documentation by listing Linux migration scenarios and tools alongside Windows ones, not just as an afterthought.
- Offer Bash or cross-platform CLI examples in addition to PowerShell.
- Clarify App Service support for Linux-based .NET workloads and provide links to relevant documentation.
- If Windows-only tools are a limitation, explicitly call this out and suggest manual migration steps for Linux users.
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 focuses exclusively on discovery of ASP.NET web apps running 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 tools or patterns referenced. The documentation assumes a Windows/IIS environment and omits Linux scenarios entirely.
Recommendations
- Include information about discovering .NET web apps hosted on Linux servers, such as those running Kestrel behind Nginx or Apache.
- Provide parallel examples or guidance for Linux-based environments, including any limitations or differences in Azure Migrate support.
- Mention Linux-compatible discovery tools or scripts if available, or clarify if discovery is currently Windows-only.
- Rephrase content to avoid assuming IIS/Windows as the default or only scenario for .NET app hosting.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/app-service-configure-premium-v3-tier.md
...s/app-service/app-service-configure-premium-v3-tier.md
High Priority
View Details →
Detected Bias Types
Windows First
Powershell Heavy
Windows Tools
Summary
The documentation demonstrates a mild Windows bias by presenting Windows-related information and tools before their Linux equivalents. For example, in the 'Premium V3 availability' section, the Windows SKU availability command is shown before the Linux command. The automation section provides both Azure CLI and Azure PowerShell examples, but PowerShell (a Windows-centric tool) is given equal prominence, and there are no explicit Linux shell (bash) script examples. Additionally, the use of Azure PowerShell is highlighted, which is more familiar to Windows users.
Recommendations
- Present Linux and Windows options in parallel or randomize their order to avoid always listing Windows first.
- Include explicit bash shell scripting examples alongside Azure PowerShell to improve parity for Linux users.
- Clarify that Azure CLI commands work cross-platform and can be run in bash, zsh, or other Linux shells.
- Where possible, provide screenshots or instructions for both Windows and Linux environments, especially for command-line tasks.
- Consider adding a note that Azure PowerShell is available cross-platform, but that bash scripting is also supported and common on Linux.
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 Tools
Windows First
Missing Linux Example
Summary
The documentation demonstrates a mild Windows bias by referencing Azure Storage Explorer (which is primarily a GUI tool with a strong Windows user base) and linking to instructions with a '?tabs=windows' parameter, suggesting a Windows-first approach. There are no explicit Linux or cross-platform command-line alternatives provided for generating SAS tokens or uploading files, and no mention of Linux-native tools or workflows. All command-line examples use Azure CLI, which is cross-platform, but the initial file upload and SAS generation steps are Windows-centric.
Recommendations
- Include explicit Linux and macOS instructions or clarify that Azure Storage Explorer is available cross-platform, if applicable.
- Provide command-line alternatives (e.g., using 'az storage blob upload' and 'az storage blob generate-sas') for uploading files and generating SAS tokens, ensuring parity for users on Linux and macOS.
- Avoid using '?tabs=windows' in links or ensure that Linux/macOS tabs are equally prominent and referenced.
- Mention and link to documentation for Linux-native tools or CLI workflows wherever a GUI tool is suggested.
- Add a note or section highlighting cross-platform compatibility and any OS-specific considerations.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/app-service-configure-premium-v4-tier.md
...s/app-service/app-service-configure-premium-v4-tier.md
High Priority
View Details →
Detected Bias Types
Windows First
Powershell Heavy
Windows Tools
Missing Linux Example
Summary
The documentation demonstrates a Windows bias by presenting Windows-related information and tools first, providing Azure PowerShell examples (which are Windows-centric) without equivalent Bash or Linux shell scripting examples, and referencing Windows-specific deployment scenarios before Linux. While Azure CLI commands are cross-platform, the PowerShell section lacks Linux parity. There is also a lack of explicit Linux container deployment automation examples.
Recommendations
- Provide Bash or Linux shell script equivalents for all Azure PowerShell examples, especially for automating tasks.
- Ensure Linux-specific deployment scenarios (such as custom containers) are given equal prominence and example coverage as Windows scenarios.
- When listing availability or commands, alternate the order or present Windows and Linux options side by side to avoid 'Windows first' ordering.
- Include explicit examples for deploying and scaling Linux container apps, not just source code apps.
- Clarify in each automation section which commands are cross-platform and which are Windows-specific, to guide users appropriately.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/configure-language-java-data-sources.md
...es/app-service/configure-language-java-data-sources.md
High Priority
View Details →
Detected Bias Types
Windows First
Powershell Heavy
Windows Tools
Summary
The documentation provides both Linux and Windows instructions for configuring data sources in Tomcat and JBoss on Azure App Service. However, in the Tomcat server-level configuration section, the Windows instructions are more detailed and rely heavily on Windows-specific tools (PowerShell, .cmd scripts, Windows environment variables). The Windows workflow is described after the Linux one, but the Windows steps are more elaborate, with more code and explanation. There is also a strong reliance on PowerShell and Windows file paths, while the Linux instructions use standard shell scripting and tools. Both platforms are covered, but the Windows approach is more thoroughly documented and uses Windows-specific tools.
Recommendations
- Ensure Linux and Windows sections have parity in detail and clarity. For example, provide more detailed Linux startup script examples, troubleshooting tips, and explanations similar to the Windows section.
- Where possible, use cross-platform tools or provide equivalent Linux-native commands/scripts for every Windows PowerShell example.
- Avoid assuming PowerShell or Windows CMD as the default scripting environment; always provide a Bash/sh alternative.
- Highlight Linux-native file paths, environment variables, and deployment patterns as prominently as Windows ones.
- Consider adding a summary table comparing the steps for Linux and Windows to help users quickly find the relevant instructions for their platform.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/includes/deploy-intelligent-apps/deploy-intelligent-apps-linux-dotnet-pivot.md
...ent-apps/deploy-intelligent-apps-linux-dotnet-pivot.md
High Priority
View Details →
Detected Bias Types
Windows First
Missing Linux Example
Windows Tools
Summary
The documentation demonstrates a Windows bias by prioritizing Windows/Visual Studio workflows (e.g., right-clicking folders, using NuGet Package Manager in Visual Studio) and omitting explicit Linux or cross-platform command-line examples for key steps such as file creation and package installation. There are no Linux-specific instructions or terminal/CLI-based workflows for non-Windows users, and the documentation assumes the use of the Azure Portal GUI for environment variable management, which may not be the primary workflow for Linux users.
Recommendations
- Provide equivalent Linux and cross-platform instructions for all steps, especially for file creation, navigation, and package installation (e.g., using dotnet CLI and text editors like VS Code or nano).
- Include CLI-based examples for managing environment variables and deploying to App Service, such as using Azure CLI or scripting.
- Avoid assuming Visual Studio or Windows GUI usage as the default; mention cross-platform editors and tools early and equally.
- Add explicit notes or sections for Linux/macOS users, ensuring parity in setup and deployment workflows.
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 several forms of Windows bias. Windows instructions and tools (such as the GUI and PowerShell commands) are often presented first or exclusively, with Linux alternatives either missing, less detailed, or relegated to secondary status. The troubleshooting section, for example, provides PowerShell commands for connectivity checks but omits equivalent Linux commands. The Hybrid Connection Manager GUI is only available on Windows, and this is noted, but the Linux CLI experience is less visually supported and lacks parity in some explanations. Windows-specific tools and patterns (like right-clicking in the portal or using MSI installers) are mentioned more prominently or exclusively.
Recommendations
- Provide Linux command-line equivalents for all troubleshooting steps, such as using 'nc' or 'telnet' instead of PowerShell's 'Test-NetConnection'.
- When listing instructions or examples, alternate the order or present both Windows and Linux options side by side, rather than always leading with Windows.
- Where GUI tools are Windows-only, enhance Linux documentation with screenshots and detailed CLI workflows to achieve parity.
- Avoid Windows-centric language such as 'right-click' in portal instructions, or clarify how these actions are performed on other platforms.
- Expand Linux installation and upgrade instructions to match the detail and clarity of the Windows MSI process.
- Ensure that all examples, especially for connectivity testing and troubleshooting, are provided for both Windows and Linux environments.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/overview-vnet-integration.md
...main/articles/app-service/overview-vnet-integration.md
High Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Missing Linux Example
Summary
The documentation page demonstrates a mild Windows bias. It provides detailed calculations and limits specifically for Windows Containers, while Linux equivalents are not discussed. Windows-specific features (e.g., Windows Server Active Directory domain join, NetBIOS) are mentioned in the 'not supported' list, but Linux-specific scenarios are not addressed. The only explicit Linux mention is in the context of continuous deployment, which is brief and lacks parity with the detailed Windows section. There are no Linux-specific examples, tools, or troubleshooting steps provided.
Recommendations
- Add a comparable section for Linux Containers, including subnet/IP calculations and any unique limitations or requirements.
- Provide Linux-specific examples or scenarios where relevant, such as networking behaviors or integration caveats.
- Ensure that troubleshooting and operational guidance covers both Windows and Linux App Service plans equally.
- Mention Linux-specific networking features or limitations, if any, to provide balanced coverage.
- Where Windows-only features are listed as unsupported, clarify if there are Linux equivalents and their support status.
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
Summary
The documentation page demonstrates a Windows bias by exclusively referencing Windows-based tools and workflows (such as Visual Studio, Kudu, CMD/PowerShell, and Windows file paths) when discussing configuration and diagnostics for ASP.NET apps on Azure App Service. There are no Linux-specific instructions or examples, and the documentation assumes the use of Windows environments throughout.
Recommendations
- Add equivalent Linux-based instructions and examples for each configuration task, such as using Bash or SSH in Kudu for Linux-based App Service plans.
- Include file paths and commands relevant to Linux containers or App Service on Linux (e.g., /home/site/wwwroot).
- Mention and provide examples for deploying and configuring ASP.NET apps on App Service for Linux, not just Windows.
- Clarify when instructions are Windows-specific and provide parallel guidance for Linux scenarios.
- Reference cross-platform tools (such as VS Code, Azure CLI, or GitHub Actions) alongside or instead of Windows-only tools like Visual Studio.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/app-service-web-nodejs-best-practices-and-troubleshoot-guide.md
...rvice-web-nodejs-best-practices-and-troubleshoot-guide.md
High Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Missing Linux Example
Powershell Heavy
Summary
The documentation is heavily focused on Windows environments, specifically Azure App Service on Windows with iisnode. All configuration and troubleshooting steps are tailored to Windows, referencing Windows-specific tools (e.g., iisnode, web.config, node.exe, Win32 error codes, Kudu CMD/PowerShell), and file paths use Windows conventions. There are no Linux or cross-platform examples, and Linux equivalents (such as Azure App Service for Linux or Linux-based Node.js hosting patterns) are not mentioned.
Recommendations
- Add a parallel section or separate documentation for Node.js on Azure App Service for Linux, covering equivalent best practices and troubleshooting steps.
- Include Linux-based configuration and deployment examples, such as using PM2, NGINX, or systemd, and reference Linux file paths and conventions.
- When discussing tools like Kudu, provide guidance for both Windows (CMD/PowerShell) and Linux (Bash/SSH) environments.
- Avoid assuming the presence of Windows-specific files (e.g., web.config, node.exe) and instead mention cross-platform alternatives where possible.
- Reference both Windows and Linux error codes and diagnostic methods, and provide links to relevant Linux documentation.
- Clearly indicate at the top of the article that the content is specific to Windows, and provide a link to Linux-focused documentation for parity.
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 exhibits a Windows-first bias. File paths and folder structures are consistently described using Windows conventions (e.g., D:\home), with no mention of Linux equivalents. Tools and features such as Kudu (SCM) are referenced without clarifying their availability or differences on Linux App Service. There are no Linux-specific examples or instructions, and the only mention of Linux is to state that the local cache feature is not supported for Linux containers, with no further guidance for Linux-based App Service users.
Recommendations
- Include Linux-specific file paths and folder structure examples (e.g., /home/site/wwwroot) alongside Windows paths.
- Clarify which features and tools (such as Kudu/SCM) are available or behave differently on Linux App Service.
- Provide equivalent instructions and examples for configuring local cache or its alternatives on Linux-based App Service plans.
- Explicitly state the differences in feature support and behavior between Windows and Linux App Service, and link to Linux-relevant documentation where appropriate.
- Where features are unsupported on Linux, offer guidance or alternatives (such as App Cache) with clear instructions for Linux users.
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 there are no explicit Linux shell or bash-specific examples beyond the use of Azure CLI. The only direct shell command shown outside of Azure CLI/PowerShell is 'nslookup', which is cross-platform. However, outbound IPv6 support is called out as being available only for Windows apps, with no Linux parity. There are no Linux-specific tools or workflows mentioned, and PowerShell is referenced without noting its cross-platform availability.
Recommendations
- Explicitly state that Azure CLI commands work on Linux, macOS, and Windows, and that PowerShell Core is cross-platform.
- Add bash or Linux-native command examples where appropriate, such as using 'curl' or 'dig' for DNS/IP lookups.
- When listing command examples, alternate the order (e.g., sometimes show CLI first, sometimes PowerShell) or clarify that both are supported on all platforms.
- Provide a note or roadmap for when outbound IPv6 support will be available for Linux apps, or clarify the limitation more prominently.
- Where PowerShell is used, specify if it is Windows PowerShell or cross-platform PowerShell Core, and provide installation links for non-Windows users.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/getting-started.md
...docs/blob/main/articles/app-service/getting-started.md
High Priority
View Details →
Detected Bias Types
Windows First
Powershell Heavy
Windows Tools
Missing Linux Example
Summary
The documentation page exhibits a moderate Windows bias, particularly in the .NET/ASP.NET sections. Windows tools (Visual Studio, PowerShell) are listed before or alongside cross-platform or Linux alternatives, and some examples or quickstarts default to Windows or PowerShell. In other stacks (Java, Node.js, PHP), Linux and CLI options are more prominent, but the 'Next step' callout at the end defaults to an ASP.NET (Windows-centric) quickstart. Some Python quickstarts also default to Windows tabs, and Linux parity is inconsistent across stacks.
Recommendations
- Ensure that Linux and cross-platform CLI examples are always presented alongside or before Windows/PowerShell examples, especially in .NET/ASP.NET sections.
- For each stack, provide explicit Linux and macOS instructions where relevant, not just Windows or Visual Studio/PowerShell.
- In the .NET/ASP.NET tables, add or highlight Linux/CLI options (e.g., .NET CLI on Linux, VS Code on Linux) and avoid listing Windows tools first.
- Review tab defaults in quickstart links to avoid defaulting to Windows/PowerShell unless the stack is Windows-only.
- Balance the 'Next step' callout to include a Linux or cross-platform example, or provide a choice of next steps for different platforms.
- Audit all quickstart and tutorial links to ensure Linux parity and that Linux users are not required to adapt Windows-specific instructions.
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 exhibits a Windows-first bias by referencing Windows file paths (e.g., D:\home\site\wwwroot) before Linux equivalents, and by providing operational details (such as directory structure and deployment artifacts) primarily in Windows terms. There are no explicit Linux command-line or file path examples, and Linux-specific nuances are not discussed. The documentation also references Windows-style directory separators (\) and omits Linux shell or deployment tool examples, despite mentioning that App Service supports Linux.
Recommendations
- Present both Windows and Linux file paths and directory structures side by side throughout the documentation (e.g., D:\home\site\wwwroot and /home/site/wwwroot).
- Include Linux shell (bash) command examples where relevant, especially for file operations or manual deployment steps.
- Clarify when instructions or behaviors differ between Windows and Linux App Service plans.
- Avoid using only Windows-style directory separators (\); provide Linux-style (/) as well.
- Add troubleshooting notes or caveats specific to Linux deployments, if any.
- Ensure that any referenced tools (e.g., Azure Storage Explorer) are cross-platform or suggest Linux alternatives if needed.
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 not described for Linux. Linux instructions are less detailed, and some features are missing entirely for Linux. Additionally, Windows-specific tools and formats (e.g., W3C log format, Log Parser, Web.config) are referenced without Linux equivalents.
Recommendations
- Provide equivalent step-by-step instructions and feature coverage for Linux App Service apps, or clearly state feature parity gaps.
- Include Linux-specific examples and tools for accessing, parsing, and analyzing logs (e.g., using tail, grep, less, jq, or open-source log viewers).
- When referencing log formats or tools (e.g., W3C, Log Parser), mention if/how Linux logs can be parsed or viewed, and suggest cross-platform alternatives.
- Clarify which features are Windows-only at the start of each section, and offer workarounds or alternatives for Linux where possible.
- Add code snippets or configuration examples for popular Linux frameworks (Node.js, Python, Java) alongside .NET/Windows examples.
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 describing Windows container SSH access before Linux, and by providing more detail and ease-of-use for Windows containers (no modifications needed) while Linux containers require extra configuration. There are no PowerShell-heavy examples, but the Windows section lacks parity with the Linux section, which provides detailed CLI examples. The Linux section is more comprehensive, but the initial focus and simplicity for Windows containers, as well as the lack of equivalent command-line tooling for Windows, indicate a bias.
Recommendations
- Provide equivalent command-line (e.g., PowerShell or Windows CLI) instructions for SSH access to Windows containers, or explicitly state their absence and offer alternatives.
- Present Linux and Windows instructions in parallel, with equal detail and order, to avoid a 'Windows-first' impression.
- Clarify any feature gaps (e.g., lack of Azure CLI support for Windows containers) and suggest workarounds or roadmap information.
- Ensure that both Linux and Windows sections include practical examples and troubleshooting tips.
- If Windows containers do not support CLI-based SSH, explain why, and provide guidance for users who may expect this feature.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/reference-app-settings.md
...ob/main/articles/app-service/reference-app-settings.md
High Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Powershell Heavy
Missing Linux Example
Summary
The documentation exhibits a Windows-first and Windows-heavy bias in several areas. Windows-specific paths, tools, and terminology are often mentioned before or instead of Linux equivalents. Many environment variables and examples reference Windows conventions (e.g., D:\home, %HOME%, .bat files, w3wp.exe), and Windows-specific tools like MSDeploy and Web Deploy are described in detail, while Linux alternatives are less prominent or missing. Some settings are described as 'Windows only' or default to Windows behaviors, and Linux-specific details are sometimes only provided as afterthoughts or not at all.
Recommendations
- For every Windows-specific path or example (e.g., D:\home, %HOME%), provide the Linux equivalent (/home, $HOME) side-by-side.
- When describing tools or deployment methods (e.g., MSDeploy, Web Deploy), also mention and document Linux-native alternatives (such as Oryx, Kudu for Linux, or SCP/rsync) with equal prominence.
- Avoid using Windows environment variable syntax (%VAR%) exclusively; always include Linux syntax ($VAR) in parallel.
- For settings that behave differently on Windows and Linux, clearly document both behaviors and provide usage examples for each platform.
- Where Windows-specific processes or binaries are referenced (e.g., w3wp.exe, .bat files), add Linux equivalents or clarify when there is no equivalent.
- Review all sections for missing Linux examples or explanations, and add them to ensure parity.
- Consider reordering content so that Windows and Linux are presented equally, rather than always listing Windows first.
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 First
Windows Tools
Missing Linux Example
Summary
The documentation demonstrates a Windows bias by referencing Windows-specific tools (IIS, Procdump, SysInternals), focusing on PowerShell for management, and linking to Windows-centric resources. There is little to no mention of Linux equivalents, and Linux-specific troubleshooting steps or tools are absent, despite Azure App Service supporting Linux environments.
Recommendations
- Include Linux-specific examples and instructions for all troubleshooting steps, such as using Bash or Azure CLI instead of only PowerShell.
- Mention Linux equivalents for diagnostic tools (e.g., use of strace, lsof, or gdb for memory dumps instead of Procdump).
- Clarify when a feature or tool is Windows-only and provide alternatives for Linux-based App Service plans.
- Add links to Linux-focused documentation and update references that currently only point to Windows/IIS resources.
- Provide sample code and configuration for both Windows (.NET/IIS) and Linux (Node.js, Python, Apache/Nginx) app stacks where relevant.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/manage-scale-per-app.md
...blob/main/articles/app-service/manage-scale-per-app.md
High Priority
View Details →
Detected Bias Types
Powershell Heavy
Missing Linux Example
Windows Tools
Windows First
Summary
The documentation page demonstrates a strong Windows bias by exclusively providing PowerShell examples for per-app scaling, with no equivalent examples for Linux-native tools or cross-platform CLI (such as Azure CLI or Bash). The only scripting examples use PowerShell cmdlets, which are traditionally associated with Windows environments. There is no mention of Linux command-line tools or workflows, and the PowerShell approach is presented first and exclusively, reinforcing a Windows-centric perspective.
Recommendations
- Add equivalent Azure CLI (az) examples for all PowerShell commands, as Azure CLI is cross-platform and widely used on Linux and macOS.
- Include Bash script examples for configuring per-app scaling, or at least show how to invoke Azure CLI commands from Bash.
- Explicitly mention that PowerShell examples can be run on Linux/macOS using PowerShell Core, or clarify platform compatibility.
- Reorder or parallelize examples so that Linux-friendly (CLI/Bash) and Windows (PowerShell) approaches are presented side-by-side or with equal prominence.
- Reference Linux tools and workflows where appropriate, and avoid assuming a Windows-only environment.
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 demonstrates a bias toward Windows and Microsoft-centric workflows. It assumes the use of .NET (a Microsoft technology), GitHub Codespaces, and Azure App Service, all of which are more commonly associated with Windows environments. There are no explicit Linux or cross-platform terminal examples, and the workflow references tools and patterns (such as NuGet, dotnet CLI, and Azure Developer CLI) that are most familiar to Windows users. No Linux-specific instructions, troubleshooting, or alternative commands are provided.
Recommendations
- Explicitly state that all CLI commands (dotnet, azd) work on Linux, macOS, and Windows, and provide any necessary installation links for Linux users.
- Include example terminal commands and screenshots from a Linux shell (e.g., bash) in addition to or instead of Codespaces/Windows-centric environments.
- Mention that the sample app and all steps can be run locally on Linux or macOS, not just in Codespaces or Windows.
- If any step is different on Linux (such as file paths, environment variables, or permissions), call out those differences.
- Reference Linux-native editors (e.g., VS Code on Linux, nano, vim) for code changes, not just Visual Studio or Codespaces.
- Add troubleshooting tips for common Linux issues (e.g., permissions, firewall, dotnet installation).