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 651-675 of 2121 flagged pages
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 Windows environments, specifically IIS servers and PowerShell scripts. There is no mention of Linux-based hosting scenarios, migration from Linux web servers, or Linux-compatible tools. The App Service Migration Assistant and related scripts are only available for Windows, and Windows terminology and tools are consistently prioritized and presented without Linux alternatives.
Recommendations
- Include migration guidance and tooling for .NET apps hosted on Linux web servers (e.g., Apache, Nginx).
- Provide Linux shell (bash) script equivalents for PowerShell-based migration steps.
- Mention and link to any Linux-compatible migration tools, or clarify the lack thereof and suggest workarounds.
- Add examples and documentation for containerizing and migrating .NET Core/ASP.NET Core apps running on Linux.
- Balance the presentation by explicitly addressing both Windows and Linux scenarios in tool tables and migration workflows.
- If Windows-only support is intentional, clearly state this limitation at the top of the documentation.
Create Pull Request
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/app-service-migration-discover-net.md
...cles/app-service/app-service-migration-discover-net.md
High Priority
View Details →
Detected Bias Types
Windows First
Missing Linux Example
Windows Tools
Summary
The documentation focuses exclusively on discovering ASP.NET web apps hosted on IIS servers within VMware environments, which are Windows-centric technologies. There are no references to Linux-based hosting, such as Kestrel or Apache/Nginx, nor are there any Linux-specific discovery instructions or examples. All tools and workflows mentioned (Azure Migrate appliance, IIS) are Windows-specific, and Linux scenarios are omitted.
Recommendations
- Include information about discovering .NET web apps hosted on Linux servers (e.g., using Kestrel, Apache, or Nginx).
- Provide parity in examples and workflows for both Windows (IIS) and Linux-based deployments.
- Mention any limitations or support status for Linux-based .NET app discovery with Azure Migrate.
- Add links to Linux-specific documentation or migration guides if available.
- Clarify in the introduction that the current guidance is Windows/IIS-specific, and outline steps for Linux users if supported.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/app-service-configure-premium-v4-tier.md
...s/app-service/app-service-configure-premium-v4-tier.md
High Priority
View Details →
Detected Bias Types
Windows First
Powershell Heavy
Windows Tools
Missing Linux Example
Summary
The documentation demonstrates a Windows-first bias in several ways: Windows SKU availability is shown before Linux, PowerShell scripting is featured alongside Azure CLI but no Linux shell (bash) examples are provided, and portal instructions are written generically but implicitly assume familiarity with Windows-centric tools. There is no mention of Linux-specific scripting or automation tools, and the PowerShell example is not paired with a bash or shell script equivalent.
Recommendations
- Present Linux and Windows instructions/examples in parallel, or alternate which comes first.
- Include bash or shell script examples for automation, not just Azure CLI and PowerShell.
- Explicitly mention Linux compatibility and provide Linux-specific guidance where relevant (e.g., for custom containers).
- Clarify when instructions are platform-agnostic versus platform-specific.
- Where PowerShell is shown, provide a comparable bash example for Linux users.
- Highlight any differences in process or tooling between Windows and Linux deployments.
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
Powershell Heavy
Windows Tools
Summary
The documentation generally provides parity between Linux and Windows, but there are subtle signs of Windows bias. In several sections, Windows instructions or tools (such as Kudu, Advanced Tools, and FTPS) are mentioned first or in more detail. Some diagnostic and profiler steps for Windows use the Kudu/SCM portal and FTPS, which are more familiar to Windows users, while Linux sections focus on SSH and CLI. There are also references to Windows-specific conventions (such as web.config) and file paths (C:\home), and some notes are specifically about Windows behavior. However, Linux coverage is strong, with detailed SSH, CLI, and container-based examples, and Linux is often mentioned explicitly in configuration and deployment examples.
Recommendations
- Ensure that Linux and Windows instructions are always presented in parallel, with neither platform consistently preceding the other.
- Where Windows tools like Kudu/SCM or FTPS are mentioned, provide equivalent Linux-native approaches (e.g., SCP, SFTP, rsync) or clarify that these tools are cross-platform.
- Avoid Windows-centric terminology (such as 'web.config') in general notes; clarify when something is Windows-only.
- For sections like Java Flight Recorder and logging, ensure Linux and Windows have equally detailed, step-by-step instructions, including troubleshooting tips.
- Highlight Linux-specific best practices and tools (e.g., using package managers, shell scripting) as prominently as Windows tools.
- Review for any subtle ordering bias (e.g., always listing Windows before Linux) and alternate the order or present both together.
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 listing Windows-specific options and tools before their Linux equivalents, providing PowerShell automation examples alongside Azure CLI, and referencing Windows-centric patterns (such as 'Windows containers' before 'Linux containers'). While Linux is supported and examples are present, Windows is consistently mentioned first or given equal prominence even where Linux is more common (e.g., scripting with PowerShell).
Recommendations
- Alternate the order of Windows and Linux mentions throughout the documentation, sometimes listing Linux first.
- Provide Bash or shell scripting examples alongside PowerShell, especially in automation sections.
- Clarify when instructions or tools are cross-platform (e.g., Azure CLI) and note any OS-specific differences.
- In sections discussing containers, mention Linux containers first or provide parity in explanation and examples.
- Where possible, add explicit Linux-focused guidance or troubleshooting steps, not just parity in commands.
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 generally provides both Windows and Linux instructions for installing and using the Hybrid Connection Manager, but there is a noticeable Windows-first bias. Windows instructions, tools, and screenshots are often presented before Linux equivalents, and some troubleshooting steps (such as using PowerShell's Test-NetConnection) only provide Windows examples. The GUI for Hybrid Connection Manager is only available on Windows, with Linux users directed to CLI usage. Some diagnostic steps and tools (e.g., PowerShell, GUI) are Windows-specific, and Linux alternatives are not always provided or are less detailed.
Recommendations
- Provide Linux command-line equivalents for all troubleshooting steps that currently only show Windows/PowerShell commands (e.g., suggest 'nc', 'telnet', or 'curl' for connectivity tests).
- Where GUI tools are only available on Windows, offer more detailed CLI instructions and screenshots for Linux users to achieve parity.
- Present Windows and Linux instructions in parallel or in a more balanced order, rather than always listing Windows first.
- Include Linux-specific troubleshooting tips and common issues, similar to the detail given for Windows.
- Where possible, provide cross-platform examples for all commands and tools, or explicitly state when a feature is Windows-only and suggest best alternatives for Linux.
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 concepts (e.g., node.exe, web.config, named pipes, Win32 error codes, IIS, PowerShell, CMD). 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 use of Windows command shells (CMD/PowerShell) is assumed throughout.
Recommendations
- Add a parallel section or page for Node.js on Azure App Service Linux, covering best practices and troubleshooting steps relevant to Linux environments.
- Include Linux-specific configuration and troubleshooting examples (e.g., using PM2, systemd, or Linux process management tools).
- Provide Linux shell (bash) command examples alongside Windows CMD/PowerShell examples.
- Reference Linux file paths and logging locations where appropriate.
- Clarify at the top of the page that the guidance is Windows-specific, and link to Linux-specific documentation if available.
- Mention cross-platform Node.js debugging and profiling tools, and provide instructions for both Windows and Linux environments.
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 demonstrates a subtle Windows bias by referencing Windows-specific configuration files (web.config), mentioning iisnode settings for Node.js apps, and omitting equivalent Linux-native configuration or troubleshooting examples. While there is a brief mention of running on Linux with PM2, most configuration and diagnostic guidance assumes a Windows environment or uses Windows-centric tools and patterns.
Recommendations
- Provide Linux-native equivalents for configuration steps, such as using environment variables or appsettings.json instead of web.config.
- Include examples for configuring auto-healing and diagnostics on Linux-based App Service plans.
- Mention and demonstrate Linux-native process managers (e.g., systemd, supervisord) where relevant, in addition to PM2.
- When referencing iisnode or web.config, clarify that these are Windows-specific and provide parallel guidance for Linux containers or App Service on Linux.
- Ensure troubleshooting and best practice sections include both Windows and Linux workflows, tools, and file locations.
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, especially in the .NET/ASP.NET section, where Windows tools (Visual Studio, Azure PowerShell) are listed before cross-platform or Linux-native tools. Some Python and database examples default to Windows tabs or instructions, and the 'Next step' call-to-action promotes an ASP.NET (typically Windows-centric) quickstart. Linux and CLI options are present but are often listed after Windows-centric tools or not highlighted equally.
Recommendations
- Ensure that for every Windows-specific tool or example (e.g., Visual Studio, Azure PowerShell), equivalent Linux or cross-platform alternatives (e.g., VS Code, Azure CLI, Bash) are listed with equal prominence and, where possible, listed first or side-by-side.
- Review all quickstart and tutorial links to ensure Linux tabs/examples are available and, if possible, default to cross-platform or Linux-first views.
- Avoid defaulting to Windows tabs or instructions in code samples and links, especially for languages and stacks that are commonly used on Linux (e.g., Python, Node.js, PHP).
- Balance the 'Next step' call-to-action by either rotating through different stacks or providing a neutral/cross-platform example, rather than defaulting to ASP.NET.
- Explicitly mention when steps or tools are cross-platform, and clarify when a tool is Windows-only.
- For .NET/ASP.NET, highlight .NET Core's cross-platform capabilities and provide explicit Linux deployment examples.
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
Missing Linux Example
Windows Tools
Summary
The documentation demonstrates a Windows/Powershell bias by providing only PowerShell scripts for advanced resource discovery (e.g., identifying Traffic Manager endpoints), without offering Bash, Azure CLI, or cross-platform alternatives. References to automation or scripting are exclusively PowerShell-based, and there are no Linux shell or Bash script equivalents. This may disadvantage users on Linux or macOS who do not use PowerShell.
Recommendations
- For every PowerShell script or automation example, provide an equivalent Bash or Azure CLI script where possible, or at least reference cross-platform alternatives.
- Explicitly mention that PowerShell Core is cross-platform if PowerShell is the only option, and provide installation guidance for non-Windows users.
- When linking to scripts or tools, clarify their platform compatibility and offer guidance for Linux/macOS users.
- Instruct users on how to use Azure CLI (which is cross-platform) for resource discovery tasks, especially for scenarios where only PowerShell scripts are currently referenced.
- Review all automation and scripting guidance to ensure Linux and macOS users are not excluded or left with a more difficult workflow.
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 exhibits a mild Windows bias. It provides detailed calculations and considerations 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 a brief note about continuous deployment network dependencies, which is less prominent and detailed compared to the Windows section. There are no Linux-specific examples, troubleshooting steps, or parity in container-specific guidance. The documentation also references Windows-centric features (e.g., Windows Server Active Directory domain join) and tools (Kudu console UI) without mentioning Linux alternatives.
Recommendations
- Add a parallel section detailing subnet/IP requirements and networking unit calculations for Linux containers, if applicable.
- Provide Linux-specific examples or notes wherever Windows-specific guidance is given (e.g., for container scaling, networking, and environment variables).
- Include troubleshooting steps and best practices for Linux-based App Service apps, matching the detail given to Windows scenarios.
- Mention Linux alternatives or equivalents for tools like the Kudu console UI, or clarify their cross-platform applicability.
- Ensure that any Windows-specific limitations or features are clearly marked as such, and provide Linux-specific notes where behavior differs.
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 server-level data sources in Tomcat, but the Windows section is longer, more detailed, and features Windows-specific tools (PowerShell, .cmd scripts, Windows environment variables) prominently. The Windows instructions are also presented before the Linux ones in the Tomcat section, and the PowerShell-based automation is described in detail, while the Linux automation is less elaborate. There are no missing Linux examples, but the Windows approach is more thoroughly explained and uses Windows-centric tooling.
Recommendations
- Ensure Linux and Windows instructions are equally detailed, especially for automation and scripting.
- Provide Linux shell script examples that match the depth and automation of the Windows PowerShell scripts.
- Where possible, present Linux and Windows instructions in parallel or with equal prominence, rather than Windows-first.
- Highlight cross-platform tools (such as Azure CLI, bash, or Python scripts) where feasible, instead of Windows-only tools like PowerShell.
- Clarify any platform-specific limitations or differences up front, so users can quickly find the relevant section.
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 deployment patterns, tools, and file paths (such as Kudu, CMD/PowerShell consoles, and Windows directory structures). There are no Linux-specific instructions, examples, or parity for Linux App Service environments, and the documentation assumes the use of Visual Studio and Windows-centric workflows.
Recommendations
- Add explicit sections or notes for configuring ASP.NET apps on Linux-based App Service plans, including how to check .NET runtime versions and access environment variables.
- Provide Linux shell (bash) command examples alongside CMD/PowerShell commands, especially for Kudu or SSH-based access.
- Mention Linux-specific deployment patterns and tools (such as using FTP, SCP, or Azure CLI from a Linux shell).
- Clarify when instructions are Windows-only and provide equivalent steps for Linux where possible.
- Include screenshots or references to Linux-based App Service environments in the Azure portal where relevant.
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 page demonstrates a bias toward Windows environments by referencing Visual Studio and its NuGet package manager as the primary method for installing dependencies, with CLI instructions only mentioned secondarily. There are no explicit Linux or cross-platform development environment examples (such as VS Code, JetBrains Rider, or command-line editors), nor are there any Linux-specific deployment or configuration instructions. The workflow assumes a GUI-based, Windows-centric development process and omits Linux terminal commands or guidance for common Linux scenarios.
Recommendations
- Provide explicit Linux and cross-platform instructions for all steps, including package installation (e.g., using dotnet CLI and NuGet CLI, not just Visual Studio).
- Include examples and screenshots for Linux-based development environments (e.g., VS Code on Ubuntu, JetBrains Rider, or command-line editors like Vim/Nano).
- When referencing tools, mention cross-platform or Linux-native tools first or equally (e.g., dotnet CLI before Visual Studio GUI).
- Add deployment and configuration steps that are specific to Linux environments, such as setting environment variables via the command line or using Azure CLI/Bash scripts.
- Ensure that all code and configuration examples are validated to work on both Windows and Linux platforms, and explicitly state any OS-specific requirements or differences.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/overview.md
.../azure-docs/blob/main/articles/app-service/overview.md
High Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Missing Linux Example
Summary
The documentation page subtly favors Windows by mentioning Windows-specific tools (such as Azure PowerShell) and development environments (Visual Studio) before or more prominently than their Linux or cross-platform equivalents. There are no explicit Linux command-line examples or references to Linux-specific tooling, and the mention of 'command line tools you already use' lists Azure PowerShell alongside Azure CLI, which may imply a Windows-first perspective. Linux support is mentioned in passing, but not demonstrated or exemplified.
Recommendations
- Provide explicit Linux command-line examples (e.g., bash, Azure CLI) alongside or before Windows/PowerShell examples.
- Highlight cross-platform IDEs and tools (such as Visual Studio Code, IntelliJ, Eclipse) equally, and clarify their support on Linux.
- When listing command-line tools, mention Azure CLI before Azure PowerShell to reflect cross-platform parity.
- Include references or links to Linux-specific deployment guides or troubleshooting resources.
- Ensure that application templates and marketplace offerings highlight Linux-friendly stacks and frameworks.
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 with a direct link to the Windows-specific tab for generating SAS tokens, without mentioning Linux or macOS alternatives. There are no explicit PowerShell examples, but the only GUI tool mentioned is typically associated with Windows. No Linux command-line or GUI alternatives are provided, and the documentation does not clarify cross-platform support for Storage Explorer or offer Linux-specific instructions.
Recommendations
- Explicitly state that Azure Storage Explorer is available on Windows, macOS, and Linux, and provide links or instructions for all platforms.
- Avoid linking directly to Windows-specific tabs in documentation; instead, use platform-neutral links or provide parallel instructions for Linux/macOS.
- Include command-line alternatives (e.g., using Azure CLI or azcopy) for generating SAS tokens, which work across platforms.
- If GUI instructions are given, provide screenshots or steps for Linux/macOS where the UI differs.
- Add a note or section clarifying that all Azure CLI commands are cross-platform and can be run on Windows, Linux, or macOS.
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
Windows First
Powershell Heavy
Windows Tools
Missing Linux Example
Summary
The documentation page demonstrates a Windows bias by referencing Windows-specific tools (IIS, Procdump, SysInternals), focusing on .NET/ASP.NET examples, and providing PowerShell-based management guidance without Linux or cross-platform equivalents. The Kudu console is described in terms of PowerShell and DOS commands, and links and examples are often Windows-centric. There is a lack of Linux-specific troubleshooting steps, tools, or examples, despite Azure App Service supporting Linux-based apps.
Recommendations
- Provide equivalent Linux-based troubleshooting steps and examples, such as using Bash in Kudu, and referencing Linux log file locations.
- Mention Linux-compatible tools for memory dumps and diagnostics (e.g., gcore, lsof, strace) alongside Procdump/SysInternals.
- Include examples for managing and restarting apps using Azure CLI (which is cross-platform), not just Azure PowerShell.
- Clarify which features or tools are available or behave differently on Linux-based App Service plans.
- Add application diagnostics examples for non-.NET stacks (Node.js, Python, Java) and how to enable logging/tracing for those environments.
- Balance references to Windows and Linux in both text and linked resources, ensuring parity in troubleshooting guidance.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/deploy-run-package.md
...s/blob/main/articles/app-service/deploy-run-package.md
High Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Missing Linux Example
Summary
The documentation demonstrates a Windows bias by referencing Windows file paths (e.g., D:\home\site\wwwroot) before Linux equivalents, focusing on Windows-style directory structures, and omitting explicit Linux command-line or file path examples. All deployment and troubleshooting examples use Windows paths, and there are no Linux-specific instructions or parity in examples.
Recommendations
- Provide Linux file path equivalents (e.g., /home/site/wwwroot) alongside Windows paths in all relevant sections, not just in passing.
- Include explicit Linux command-line examples or notes, especially where file system operations or directory creation are discussed.
- Clarify that Azure CLI commands are cross-platform, and, where relevant, show both Windows (cmd/PowerShell) and Linux (bash) command syntax.
- When mentioning directory structures or deployment paths, always present both Windows and Linux formats together.
- Add troubleshooting notes specific to Linux environments if any differences exist.
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 is presented alongside CLI without clarifying platform parity. There is no explicit mention of Linux-specific tools or shell environments, and PowerShell examples are included without noting that PowerShell is primarily a Windows tool (even though it is now cross-platform, many users still associate it with Windows). There are no Linux-specific command-line examples (e.g., using curl, jq, or bash scripting) for querying IP addresses via the REST API or Azure CLI output parsing. Additionally, outbound IPv6 support is noted as being available only for Windows apps, but this is a product limitation rather than a documentation bias.
Recommendations
- Clearly indicate which commands are cross-platform (e.g., Azure CLI) and which are Windows-centric (e.g., Azure PowerShell), and recommend CLI as the default for cross-platform compatibility.
- Add Linux-native command-line examples (e.g., using curl, jq, or bash scripting) for querying and parsing IP addresses, especially for users who may not use PowerShell.
- When presenting multiple command-line options, list Azure CLI examples first to emphasize cross-platform support.
- Explicitly state that PowerShell examples are optional and primarily for users who prefer or require PowerShell.
- Where product limitations exist (such as outbound IPv6 support only for Windows apps), clarify that this is a platform limitation and not a documentation bias.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/manage-scale-per-app.md
...blob/main/articles/app-service/manage-scale-per-app.md
High Priority
View Details →
Detected Bias Types
Powershell Heavy
Missing Linux Example
Windows Tools
Windows First
Summary
The documentation page demonstrates a strong Windows bias by providing only PowerShell-based CLI examples for per-app scaling, with no equivalent examples for Linux users (such as Azure CLI or Bash). The use of PowerShell cmdlets and the absence of cross-platform command-line instructions or explicit mention of Linux tooling may hinder accessibility for non-Windows developers.
Recommendations
- Add Azure CLI (az) examples for all PowerShell commands shown, as Azure CLI is cross-platform and widely used on Linux and macOS.
- Include Bash script examples where appropriate to illustrate configuration steps for Linux users.
- When introducing command-line examples, present Azure CLI or REST API options before or alongside PowerShell to avoid a 'Windows-first' impression.
- Explicitly state that per-app scaling can be configured using cross-platform tools, not just PowerShell.
- Review and update the documentation to ensure parity in instructions and examples for both Windows and Linux environments.
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 bias by referencing Windows-style paths (e.g., D:\home), using Windows-centric terminology and tools (such as Kudu/SCM), and omitting Linux-specific examples or guidance. While there is a note mentioning that the feature is not supported in Linux containers and a link to an alternative (App Cache), the main documentation and all examples are presented from a Windows perspective, with no parity for Linux App Service environments.
Recommendations
- Include equivalent Linux file paths and behaviors (e.g., /home/site) alongside Windows paths in all relevant sections.
- Provide explicit examples and instructions for enabling and managing local cache (or its alternatives) on Linux-based App Service plans.
- Clarify which features, settings, and tools are available or behave differently on Linux App Service, and provide links to Linux-specific documentation where appropriate.
- Where features are not supported on Linux, offer clear guidance and migration paths (such as using App Cache), including usage examples.
- Ensure that any references to tools (e.g., Kudu/SCM) mention their Linux equivalents (e.g., KuduLite) and note any differences in usage or availability.
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 demonstrates a Windows-first bias in several ways: Windows paths and conventions are often given as the primary or only example (e.g., 'D:\home'), Windows-specific tools and settings (such as MSDeploy, Web Deploy, and references to w3wp.exe) are described in detail, and Windows-specific environment variables and behaviors are explained more thoroughly or before their Linux equivalents. In some cases, Linux options are mentioned as exceptions or afterthoughts, and Linux-specific examples or explanations are missing or less detailed.
Recommendations
- For every environment variable or feature, provide both Windows and Linux examples side by side, especially for file paths, default values, and behaviors.
- Avoid presenting Windows as the default or primary platform; instead, use neutral language or alternate the order of Windows and Linux references.
- Include Linux-native tools and deployment patterns (e.g., rsync, scp, tar) where Windows tools like MSDeploy or Web Deploy are mentioned.
- Ensure that Linux-specific environment variables, behaviors, and troubleshooting steps are as detailed and prominent as their Windows counterparts.
- Where platform-specific behaviors exist, clearly indicate them in a comparative table or section, rather than embedding Linux as an exception in Windows-focused text.
- Add Linux/POSIX shell command examples (e.g., export, echo $VAR) where PowerShell or Windows command prompt examples are given.
- Review and expand documentation for Linux container scenarios, ensuring parity in depth and clarity with Windows container documentation.
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 documented for Linux. Examples and explanations for advanced logging features are focused on Windows, with Linux instructions being brief and lacking equivalent depth. Additionally, Windows-specific tools and log formats (e.g., W3C, Log Parser) are mentioned without Linux alternatives.
Recommendations
- Provide equivalent, detailed instructions for enabling and accessing advanced logging features (such as web server logging, detailed error messages, and failed request tracing) for Linux and container-based App Service apps, or clearly state if these features are unavailable.
- Include Linux-specific examples and tools for accessing and parsing logs, such as using tail, grep, or jq, and mention Linux log formats if they differ.
- Where features are Windows-only, add explicit notes and suggest alternative troubleshooting or logging strategies for Linux users.
- Balance the order of presentation so that Linux and Windows instructions are given equal prominence, or group them together for easy comparison.
- Expand the 'Add log messages in code' section to include more Linux-relevant frameworks and languages, with code samples for each.
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 shows a moderate Windows bias. Windows is mentioned first in availability, and PowerShell scripting is presented as a primary automation method alongside Azure CLI. There are no Linux shell (bash) or cross-platform scripting examples, and the portal instructions are Windows-centric. Linux is only referenced in the context of SKU availability, not in automation or deployment workflows.
Recommendations
- Provide bash shell scripting examples for Linux users alongside Azure PowerShell examples.
- When listing availability or instructions, present Windows and Linux options in parallel, not with Windows first.
- Clarify that Azure CLI is cross-platform and can be used from Linux, macOS, and Windows.
- Include screenshots or instructions for the Azure portal that are not Windows-specific (e.g., avoid showing only Windows UI elements or terminology).
- Explicitly mention Linux container scenarios in automation and deployment sections.
- Add a table or section summarizing differences and steps for both Windows and Linux App Service plans.
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 moderate Windows bias by presenting Windows-related information and tools before their Linux equivalents. In the 'Premium V3 availability' section, the Windows SKU availability command is listed before the Linux one. The automation section provides both Azure CLI and Azure PowerShell examples, but PowerShell is a Windows-centric tool, and no Linux shell scripting (e.g., Bash) examples are given. The use of the Azure portal UI, which is platform-agnostic but often associated with Windows workflows, is emphasized throughout. There are no explicit Linux shell or scripting examples beyond the Azure CLI, and no mention of Linux-specific considerations or tools.
Recommendations
- Present Linux and Windows options in parallel or alternate their order to avoid always listing Windows first.
- Include Bash or shell script examples for automation, especially for Linux users.
- Explicitly mention that Azure CLI commands work cross-platform and can be run on Linux, macOS, and Windows.
- If referencing PowerShell, clarify that PowerShell Core is cross-platform, or provide equivalent Bash commands where possible.
- Highlight any Linux-specific considerations or differences when using Premium V3, if applicable.