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 851-875 of 2121 flagged pages
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 →
Detected Bias Types
Windows First
Powershell Heavy
Windows Tools
Missing Linux Example
Summary
The documentation demonstrates a moderate Windows bias. PowerShell examples are provided alongside Azure CLI, but there are references to Windows-specific tools (IIS, Certreq.exe) for certificate export without equivalent Linux instructions. In automation and FAQ sections, PowerShell is mentioned before or alongside CLI, but Linux-native tools or workflows are not equally highlighted. The document assumes familiarity with Windows tooling and does not provide parity for Linux users in several steps.
Recommendations
- For certificate export, provide explicit Linux/OpenSSL instructions alongside or before Windows/IIS/Certreq.exe steps.
- Where PowerShell is shown, ensure Azure CLI (cross-platform) examples are always present and, where possible, shown first.
- In automation and FAQ sections, include Bash scripting or Linux-native automation examples, not just PowerShell.
- Reference Linux and macOS environments explicitly in prerequisites and examples, not just Windows.
- Where Windows-specific tools are mentioned (e.g., IIS, Certreq.exe), add equivalent Linux/macOS guidance or links.
- Review screenshots and UI instructions to ensure they are not Windows-centric if the portal experience is cross-platform.
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 →
Detected Bias Types
Windows First
Windows Tools
Missing Linux Example
Summary
The documentation exhibits a Windows-first bias by referencing Windows directory paths (e.g., D:\home\site\wwwroot) before Linux equivalents, and by describing deployment behaviors and manual steps (such as creating directories and files) only in terms of Windows paths. There are no explicit Linux or cross-platform command-line examples, and the documentation does not provide Linux-specific instructions or clarify differences in behavior for Linux-based App Service plans.
Recommendations
- Provide Linux directory paths alongside Windows paths wherever file system locations are mentioned (e.g., /home/site/wwwroot in addition to D:\home\site\wwwroot).
- Include explicit Linux/macOS shell command examples (e.g., using Bash) where manual file operations are described, or clarify if such manual steps are not required or differ on Linux-based App Service plans.
- Clarify any behavioral differences between Windows and Linux App Service environments, especially regarding file system structure and deployment nuances.
- Ensure that all examples, troubleshooting steps, and notes are cross-platform or provide platform-specific instructions as needed.
- Add a section or callout summarizing key differences and considerations for Linux users.
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 demonstrates a mild Windows bias. In the prerequisites and quickstart links, 'windows' is explicitly listed as a tab, and there is a lack of explicit Linux/macOS command-line or deployment examples. The instructions for setting environment variables and deployment reference the Azure portal and Visual Studio (Windows-centric tools) without mentioning Linux alternatives or command-line equivalents. There are no PowerShell-specific commands, but the absence of Linux shell examples and the prioritization of Windows tools and patterns indicate a subtle bias.
Recommendations
- Add explicit Linux/macOS tabs or examples alongside Windows in all quickstart and setup links.
- Include Linux shell (bash) commands for environment variable setup and deployment, not just portal or Visual Studio instructions.
- Mention cross-platform deployment tools (e.g., Azure CLI, GitHub Actions) and provide examples for both Windows and Linux.
- Clarify that the instructions apply to both Windows and Linux, and provide any OS-specific notes where necessary.
- Where Visual Studio is mentioned, also mention VS Code and command-line alternatives for Linux users.
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, referencing only Windows-centric tools and cmdlets (e.g., New-AzAppServicePlan, Set-AzAppServicePlan), and omitting equivalent examples for Linux/macOS users (such as Azure CLI or Bash). The PowerShell approach is presented first and most prominently, with no mention of cross-platform alternatives.
Recommendations
- Add equivalent Azure CLI examples for all PowerShell commands, as Azure CLI is cross-platform and widely used on Linux and macOS.
- Include Bash scripting examples where appropriate, especially for configuring app settings or deploying ARM templates.
- Explicitly state that PowerShell examples are for Windows and provide links or inline examples for Linux/macOS users.
- Reorganize sections so that cross-platform tools (Azure CLI, ARM templates) are presented before or alongside PowerShell.
- Mention that Azure Cloud Shell supports both Bash and PowerShell, and show how to use both for these tasks.
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 presented alongside or immediately after CLI, with no explicit mention of Linux shell alternatives (e.g., Bash scripting or jq for JSON parsing). There is also a note that outbound IPv6 support is only available for Windows apps, with no Linux parity or roadmap. No Linux-specific tools or workflows are mentioned, and the documentation does not clarify that Azure CLI commands are cross-platform or provide Linux-specific context.
Recommendations
- Explicitly state that Azure CLI commands are cross-platform and can be run on Linux, macOS, and Windows.
- Provide Linux shell (bash) examples for parsing JSON output from Azure CLI, such as using jq or grep, especially in sections where PowerShell is shown.
- When listing command-line examples, present Azure CLI (cross-platform) before PowerShell, or group them under clear OS headings.
- For features (like outbound IPv6) that are Windows-only, clearly indicate the lack of Linux support and, if possible, provide a roadmap or alternatives for Linux users.
- Include troubleshooting or environment notes for Linux users where relevant (e.g., differences in DNS tools or network testing).
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 subtle Windows bias. Windows-specific features and limitations (such as Windows Containers subnet sizing and Windows Server Active Directory) are discussed in detail, while Linux-specific scenarios are only briefly mentioned or relegated to a single section. There is a lack of Linux-focused examples, and Windows terminology and patterns (e.g., Kudu console, Windows Containers) are referenced without equivalent Linux context. The only explicit Linux mention is in the context of continuous deployment network dependencies, which is brief and lacks parity with the Windows coverage.
Recommendations
- Add Linux-specific examples and scenarios, such as subnet sizing and limitations for Linux containers, to match the detail given for Windows Containers.
- Provide parity in troubleshooting and operational guidance for both Windows and Linux environments (e.g., mention Linux equivalents for Kudu console or clarify if Kudu is available for Linux).
- Include Linux-focused deployment and integration patterns, not just a single note about continuous deployment network dependencies.
- When listing limitations or features, always clarify applicability to both Windows and Linux, or provide separate sections if behaviors differ.
- Review terminology to ensure cross-platform neutrality (e.g., avoid assuming Kudu or Windows tools are the default).
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/troubleshoot-performance-degradation.md
...es/app-service/troubleshoot-performance-degradation.md
High Priority
View Details →
Detected Bias Types
Powershell Heavy
Windows Tools
Windows First
Missing Linux Example
Summary
The documentation page demonstrates a Windows bias by focusing on Windows-specific tools (IIS, Procdump, PowerShell), referencing Windows terminology (web.config, .NET Profiler for Windows), and omitting Linux-specific instructions or equivalents. Examples and tool mentions (e.g., Kudu console, Procdump, PowerShell) are Windows-centric, with no parallel guidance for Linux-based App Service environments.
Recommendations
- Provide Linux-specific instructions and examples alongside Windows ones, especially for diagnostics, logging, and troubleshooting steps.
- Mention Linux equivalents for tools like Procdump (e.g., gcore, dotnet-dump) and clarify which features are available on Linux App Service plans.
- Include guidance for enabling diagnostics and collecting logs on Linux-based App Service (e.g., using XPlat diagnostics, Application Insights for Linux).
- Avoid assuming IIS or web.config is present; note differences for Linux (e.g., nginx, Apache, appsettings.json).
- When referencing PowerShell, also provide Azure CLI or Bash examples for parity.
- Clarify in each section whether the feature or tool applies to Windows, Linux, or both App Service environments.
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, with detailed instructions and features (such as web server logging, detailed error messages, and failed request tracing) provided exclusively or primarily for Windows. Linux and container scenarios are often mentioned secondarily, with less detail and fewer features. Some tools and log formats referenced (e.g., W3C logs, Log Parser) are Windows-centric, and there are missing Linux equivalents or examples.
Recommendations
- Provide equivalent, detailed instructions for enabling and accessing all available logging features on Linux and container-based App Service plans.
- Clearly indicate which features are Windows-only and, where possible, suggest Linux/container alternatives or workarounds.
- Include Linux-specific examples and tools for accessing and analyzing logs (e.g., using tail, less, grep, or open-source log viewers).
- List Linux/container logging capabilities and limitations in a dedicated section or table for transparency.
- Avoid referencing only Windows tools (such as Log Parser) without suggesting cross-platform or Linux-native alternatives.
- Where features are not available on Linux, provide guidance or links to feature requests or roadmap information.
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 exhibits a strong Windows bias. All migration tools and examples focus exclusively on migrating from Windows environments, specifically from IIS servers. Only Windows-based tools (such as the App Service Migration Assistant MSI and PowerShell scripts) are mentioned, with no Linux or cross-platform migration tools or scenarios discussed. The documentation repeatedly references PowerShell and Windows containers, and there are no examples or guidance for migrating .NET apps from Linux servers or using Linux-native tools.
Recommendations
- Include examples and guidance for migrating .NET apps hosted on Linux servers (e.g., Apache, Nginx, Kestrel) to Azure App Service.
- List and describe any available cross-platform or Linux-native migration tools, or clarify if such tools are not currently available.
- Provide parity in documentation by offering Linux shell (bash) script examples alongside PowerShell scripts.
- Mention Linux containerization options and how to migrate Linux-hosted .NET apps to Azure App Service (Linux).
- Clarify in the introduction that the current tools are Windows/IIS-focused, and provide links or guidance for Linux scenarios if available.
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 shows subtle Windows bias by referencing Windows-specific configuration files (web.config), mentioning iisnode settings for Node.js apps, and omitting Linux-native equivalents or examples. While there is a brief mention of Linux (regarding PM2 and multi-core), most configuration and troubleshooting guidance assumes a Windows/IIS environment, with no parallel Linux or cross-platform instructions.
Recommendations
- Provide Linux-native configuration examples (e.g., using app settings, environment variables, or Linux startup scripts) alongside or before Windows-specific ones like web.config.
- When referencing iisnode or web.config, clarify that these are Windows/IIS-specific and provide equivalent instructions for Linux-based App Service environments (e.g., using process.json, ecosystem.config.js for PM2, or other Linux process managers).
- Ensure all troubleshooting and best practice sections include both Windows and Linux scenarios, or clearly indicate when a recommendation is platform-specific.
- Highlight cross-platform tools and patterns where possible, and avoid assuming IIS or Windows as the default hosting environment.
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. In sections where both Windows and Linux are relevant (such as SKU availability), Windows examples and commands are listed before Linux equivalents. Automation examples are provided for both Azure CLI (cross-platform) and Azure PowerShell (Windows-centric), but no Linux shell or scripting examples are given. The UI instructions and screenshots are based on the Azure Portal, which is platform-agnostic, but the inclusion of Azure PowerShell as a primary automation method and the ordering of Windows before Linux in command examples suggest a subtle preference for Windows environments.
Recommendations
- Provide Linux shell scripting examples (e.g., Bash) alongside Azure PowerShell for automation, or clarify that Azure CLI is fully cross-platform.
- Alternate the order of Windows and Linux examples, or present them in parallel, to avoid the perception of Windows-first bias.
- Explicitly state the cross-platform nature of Azure CLI and highlight its suitability for both Windows and Linux users.
- If referencing Azure PowerShell, consider also mentioning or linking to Bash scripting or other Linux-native automation approaches.
- Ensure that all features and steps are equally documented for both Windows and Linux, especially in sections where differences exist.
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
Summary
The documentation demonstrates a mild Windows bias. Windows terminology and instructions are often presented first (e.g., 'Windows SKU availability' before 'Linux SKU availability'). Azure PowerShell is featured as a primary automation tool, and there is a general emphasis on Windows-specific scenarios (such as the distinction between Windows source code apps and containers). While Linux is mentioned and examples are provided, Windows patterns and tools are generally foregrounded.
Recommendations
- Ensure Linux examples and instructions are presented with equal prominence and, where possible, before or alongside Windows examples.
- Expand automation sections to include Bash scripting examples for Linux users, not just Azure CLI and PowerShell.
- Clarify when instructions or features are Windows-specific versus Linux-specific, and provide parallel guidance for both platforms.
- Include more Linux-centric troubleshooting and operational notes, especially in sections that currently focus on Windows behaviors or tools.
- Consider adding a table or matrix summarizing feature availability and differences between Windows and Linux for Premium V4.
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 the discovery of ASP.NET web apps running on IIS web servers within VMware environments, which are Windows-centric technologies. There are no references to Linux-based web servers (such as Apache or Nginx), nor are there examples or guidance for discovering .NET apps hosted on Linux. All tools and workflows mentioned (Azure Migrate appliance, IIS) are Windows-specific, and Linux scenarios are not addressed.
Recommendations
- Include information and examples for discovering .NET web apps hosted on Linux servers (e.g., Kestrel, Apache, Nginx).
- Mention whether Azure Migrate supports Linux-based .NET app discovery, and if not, clarify this limitation.
- Provide parity in documentation by listing Linux discovery steps, tools, and dashboards where applicable.
- If discovery is Windows-only, explicitly state this in the introduction to set expectations for Linux users.
- Add links to resources or documentation for migrating Linux-hosted .NET apps to Azure App Service, if available.
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, such as PowerShell commands for connectivity testing and GUI-based management. Linux support is present but less emphasized, with some features (like the GUI) unavailable and some troubleshooting steps lacking Linux equivalents.
Recommendations
- Provide Linux command-line equivalents for all PowerShell or Windows-specific troubleshooting steps (e.g., use 'nc' or 'telnet' for TCP connectivity testing instead of only 'Test-NetConnection').
- When listing instructions or tools, present both Windows and Linux options together or alternate which is presented first.
- Where the Windows GUI is referenced, clarify Linux alternatives or explicitly state the lack thereof, and suggest CLI workflows as first-class options.
- Expand troubleshooting sections to include Linux-native commands and tools (e.g., 'systemctl' for service management, 'dig' or 'host' for DNS lookups).
- Ensure that all code snippets and examples are available for both platforms, not just Windows.
- Consider adding a parity table or section that summarizes feature differences and available tools for Windows and Linux users.
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 page demonstrates a Windows bias primarily in the section addressing Azure Traffic Manager endpoints, where only a PowerShell script is provided for identifying affected resources. There are no equivalent Bash, Azure CLI, or cross-platform script examples for Linux or macOS users. The instructions for running the script explicitly reference PowerShell, and there is no mention of how to perform the same task using tools commonly available on Linux. Elsewhere, while REST API and Azure CLI commands are referenced (which are cross-platform), the only concrete script-based automation example is Windows/PowerShell-centric.
Recommendations
- Provide equivalent Bash or Azure CLI scripts for identifying Traffic Manager profiles with non-Azure endpoints, ensuring Linux and macOS users have a clear path.
- When referencing automation scripts, offer both PowerShell and Bash (or at least Azure CLI) alternatives, and indicate their platform compatibility.
- Explicitly state that Azure CLI and REST API commands are cross-platform, and provide example invocations in both Windows (PowerShell) and Linux (Bash) shells where appropriate.
- Avoid presenting Windows/PowerShell solutions first or exclusively; instead, present cross-platform solutions or clearly label platform-specific instructions.
- Consider including a table or section summarizing available tools/scripts for each platform (Windows, Linux, macOS) for all major operational tasks described.
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 reference Windows-specific tools, paths, and patterns (e.g., web.config, node.exe, named pipes, Win32 error codes, Kudu CMD/PowerShell, d:\home\LogFiles). There are no examples or guidance for Linux-based App Service environments, and Linux equivalents (such as PM2, systemd, or Linux file paths) are not mentioned. The document assumes the use of Windows-native concepts and tools throughout.
Recommendations
- Add equivalent sections for Node.js applications running on Azure App Service for Linux, including configuration, troubleshooting, and best practices.
- Provide Linux-specific examples (e.g., using PM2 or systemd for process management, Linux file paths, and log locations).
- Reference Linux-native debugging and profiling tools (such as node --inspect, top, htop, or Linux-based log analysis).
- Where possible, present cross-platform guidance or clearly indicate when a step is Windows-only, and provide a Linux alternative.
- Include screenshots and instructions for the Azure App Service Linux environment (e.g., Bash/Kudu Bash console) alongside Windows CMD/PowerShell examples.
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 Windows bias by focusing exclusively on Windows-based deployment and configuration patterns for ASP.NET apps. All runtime version discovery examples use Windows file paths and Kudu CMD/PowerShell consoles, with no mention of Linux equivalents. The use of Visual Studio as the primary deployment tool and references to Windows-specific tools and directories further reinforce this bias. There are no examples or instructions for Linux-based App Service environments, nor any mention of Bash or Linux shell commands.
Recommendations
- Provide parallel instructions and examples for Linux-based App Service environments, including how to check .NET runtime versions and access diagnostic tools on Linux.
- Include Linux/Bash shell commands alongside CMD/PowerShell examples, especially for tasks like listing installed runtimes.
- Mention and demonstrate deployment workflows using cross-platform tools (e.g., dotnet CLI, VS Code) in addition to Visual Studio.
- Clarify which instructions apply only to Windows App Service plans and provide links or sections for Linux-specific guidance.
- Reference Linux file paths and environment variable access patterns where appropriate.
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 page exhibits a mild Windows bias. While most command-line examples use the cross-platform Azure CLI, the instructions for generating a SAS URL specifically reference the Azure Storage Explorer with a link that defaults to Windows tabs. There are no explicit Linux or macOS alternatives or mentions for uploading files or generating SAS tokens, and the Storage Explorer instructions may imply a Windows-centric workflow. No PowerShell or CMD scripts are present, but the lack of Linux-native tool examples (such as using az CLI or REST API for SAS generation/upload) is notable.
Recommendations
- Provide explicit instructions or examples for generating SAS URLs and uploading files using Azure CLI or REST API, which are cross-platform and work on Linux/macOS.
- Avoid linking to Storage Explorer documentation with Windows-specific tabs by default; mention that Storage Explorer is available on multiple platforms, or provide platform-agnostic instructions.
- Add a section or callout for Linux/macOS users, clarifying how to perform each step without relying on GUI tools or Windows-specific workflows.
- Where GUI tools are mentioned, always provide an equivalent CLI alternative to ensure parity for Linux users.
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
Windows Tools
Missing Linux Example
Windows First
Summary
The documentation page demonstrates a Windows bias by providing only PowerShell-based CLI examples for per-app scaling, with no equivalent examples for Linux users (such as Azure CLI/bash). The PowerShell approach is presented first and exclusively, and there is no mention of cross-platform or Linux-native tooling or workflows.
Recommendations
- Add equivalent Azure CLI (az) examples for all PowerShell commands to support Linux and macOS users.
- Explicitly mention that PowerShell examples are for Windows and provide guidance for cross-platform users.
- Consider providing bash shell scripts or instructions for Linux environments.
- Reorder or parallelize examples so that Windows and Linux approaches are given equal prominence.
- Clarify that ARM templates are cross-platform, and highlight this as an option for all users.
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 exhibits a Windows-first bias by referencing Windows-style paths (e.g., D:\home\site\wwwroot) before Linux equivalents, and by describing deployment behaviors primarily in terms of Windows directory structures. There are no explicit Linux or cross-platform command-line examples, and Linux-specific nuances are only mentioned in passing. The documentation also refers to Windows-centric deployment patterns and tools (such as FTP with Windows paths) without providing Linux alternatives or examples.
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-specific or cross-platform command-line examples, especially for file paths and deployment steps.
- Explicitly mention any differences in behavior or requirements for Linux-based App Service plans.
- Provide examples using Linux-native tools (e.g., SCP, SFTP, rsync) alongside FTP or Windows tools.
- Clarify any platform-specific limitations or features, and ensure parity in troubleshooting and deployment guidance for both Windows and Linux environments.
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 →
Detected Bias Types
Windows First
Powershell Heavy
Windows Tools
Missing Linux Example
Summary
The documentation demonstrates a moderate Windows bias. PowerShell examples are provided alongside Azure CLI, but there are explicit references to Windows tools (IIS, Certreq.exe) for certificate export, and automation examples link to both Azure CLI and PowerShell but not to Bash or Linux-native scripting. When discussing certificate creation, Windows tooling is mentioned before Linux equivalents. There is no explicit Linux-focused workflow or parity in some sections, and Windows-specific scenarios (such as outbound client certificates) are called out without Linux alternatives.
Recommendations
- When mentioning certificate export, provide Linux-native instructions (e.g., using OpenSSL) before or alongside Windows tools like IIS and Certreq.exe.
- For automation, include Bash or shell script examples in addition to Azure CLI and PowerShell, and clarify that Azure CLI commands work cross-platform.
- Where Windows-specific scenarios are described (e.g., outbound client certificates for Windows containers), explicitly state the Linux support status and provide Linux alternatives or workarounds if available.
- Ensure that all step-by-step instructions and screenshots are not Windows-centric, or provide parallel Linux guidance where applicable.
- Review FAQ and scenario sections to ensure Linux and cross-platform use cases are addressed equally.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/troubleshoot-performance-degradation.md
...es/app-service/troubleshoot-performance-degradation.md
High Priority
View Details →
Detected Bias Types
Powershell Heavy
Windows Tools
Windows First
Missing Linux Example
Summary
The documentation page exhibits a Windows bias by emphasizing Windows-specific tools and patterns such as IIS diagnostics, PowerShell, and SysInternals Procdump, while omitting or downplaying equivalent Linux troubleshooting methods. Examples and links are often Windows-centric, and there is little to no mention of Linux-specific diagnostics, commands, or workflows for App Service on Linux.
Recommendations
- Provide parallel Linux examples and instructions for all diagnostic and troubleshooting steps, including log collection, process dumps, and debugging.
- Mention Linux equivalents for tools like Procdump (e.g., gcore, gdb) and explain how to use them in App Service on Linux.
- When referencing PowerShell or DOS commands in Kudu, also describe how to use the Bash shell and relevant Linux commands if the app is running on Linux.
- Clarify when a feature or tool is Windows-only, and offer alternative guidance for Linux-based App Service environments.
- Include links to Linux-specific documentation for Application Insights Profiler, diagnostic logging, and troubleshooting.
- Balance the order of presentation so that Linux and Windows approaches are given equal prominence, or clearly indicate which instructions apply to which OS.
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 bias toward Windows by referencing Visual Studio and its NuGet package manager as the primary method for installing packages, with CLI instructions only mentioned secondarily. There are no explicit Linux or cross-platform development environment examples (e.g., VS Code, JetBrains Rider, or command-line editors), and no Linux-specific deployment or configuration steps are provided. The workflow assumes a GUI-based, Windows-centric development pattern, with no mention of Linux shell commands or tools.
Recommendations
- Provide explicit Linux and cross-platform instructions for package installation (e.g., using dotnet CLI and NuGet CLI) before or alongside Visual Studio instructions.
- Include examples and screenshots for Linux-based development environments, such as VS Code or JetBrains Rider, and mention command-line editors (vim, nano) for file editing.
- Add Linux-specific deployment steps, such as using Azure CLI from a Bash shell, and clarify that all steps can be performed on Linux as well as Windows.
- Avoid assuming the use of Visual Studio or right-click context menus; describe file creation and editing in a way that is editor-agnostic.
- Explicitly state that the instructions are cross-platform and highlight any differences or prerequisites 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 the PowerShell examples are given equal prominence to CLI, and there is no explicit mention of Linux-specific tools or shell environments. In the section on outbound IPv6 support, it is explicitly stated that outbound IPv6 is only available for Windows apps, with Linux apps limited to IPv4. There are no Linux-specific command-line or scripting examples (e.g., Bash scripting, curl for querying metadata), and PowerShell is referenced without clarification that it is cross-platform or how to use it on Linux.
Recommendations
- Clarify that Azure PowerShell can be used on Linux and macOS, or provide Bash/shell script equivalents for PowerShell commands.
- Provide Linux-native examples for querying app properties, such as using curl with the Azure Instance Metadata Service or jq for JSON parsing.
- Explicitly mention when a feature is Windows-only (as is done for outbound IPv6), and provide guidance or workarounds for Linux users where possible.
- When listing command-line options, present Azure CLI (which is cross-platform) before PowerShell, and clarify the environment for each example.
- Add a note or section on how to use these commands in common Linux environments, including any prerequisites or differences.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/overview-vnet-integration.md
...main/articles/app-service/overview-vnet-integration.md
High Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Missing Linux Example
Summary
The documentation page demonstrates a Windows bias by providing detailed information and calculations specifically for Windows Containers, mentioning Windows Server Active Directory domain join, and referencing Windows-specific features (e.g., NetBIOS). Linux is only mentioned in passing, with a single note about Linux continuous deployment network dependencies, and there are no Linux-specific configuration or example sections. There are no PowerShell or CLI examples for either platform, but the focus on Windows-specific limitations and features, as well as the order of presentation, indicates a Windows-first approach.
Recommendations
- Add a parallel section for Linux Containers, including subnet/IP requirements, limitations, and sample calculations similar to the Windows Containers section.
- Provide Linux-specific examples or notes where behaviors differ (e.g., file system mounting, authentication, or networking).
- Ensure that any Windows-specific limitations or features are clearly marked as such, and that Linux equivalents (or the lack thereof) are explicitly documented.
- Include CLI examples (az CLI, Bash) for common tasks, and ensure parity with any Windows or PowerShell examples if/when they are added.
- Review the order of presentation to avoid always listing Windows features or limitations first; consider grouping by platform or providing a comparison table.