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 676-700 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 demonstrates a strong Windows bias: all migration tools and examples focus exclusively on migrating from Windows (IIS) environments, with repeated emphasis on PowerShell scripts and Windows-specific tools. There is no mention of Linux-based .NET hosting environments, nor are there migration paths, tools, or examples for Linux servers. The documentation assumes the source environment is always Windows/IIS, omitting Linux scenarios entirely.
Recommendations
- Add guidance and tooling for migrating .NET apps hosted on Linux (e.g., Apache, Nginx, Kestrel) to Azure App Service.
- Include Linux-based migration tool options or scripts (such as Bash or cross-platform .NET CLI commands) alongside PowerShell examples.
- Explicitly mention support (or lack thereof) for Linux source environments, and provide parity in documentation structure and examples.
- Highlight any differences or additional considerations when migrating from Linux environments.
- Ensure that documentation tables and feature lists include Linux scenarios where applicable, or clearly state if only Windows is supported.
Create Pull Request
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/app-service-best-practices.md
...ain/articles/app-service/app-service-best-practices.md
High Priority
View Details →
Detected Bias Types
Windows Tools
Missing Linux Example
Windows First
Summary
The documentation page demonstrates a mild Windows bias. It references Windows-specific tools (such as web.config and iisnode) without providing equivalent Linux alternatives or explanations. In the Node.js section, iisnode settings are mentioned as a configuration point, but there is no mention of Linux-native process managers or configuration files. The auto-healing feature is described as being configured via web.config, which is a Windows/IIS-centric approach, with no mention of Linux equivalents. While there is a brief mention of PM2 for Node.js on Linux, the overall pattern is to present Windows tools and patterns first or exclusively.
Recommendations
- For features like auto-healing, provide Linux-native configuration instructions (e.g., using application settings, environment variables, or startup scripts) alongside or instead of web.config.
- When referencing iisnode or web.config for Node.js apps, also mention Linux-native process managers (such as PM2 or systemd) and their configuration approaches.
- Ensure that all examples and configuration guidance are available for both Windows and Linux App Service environments, and present them in parallel or with clear distinctions.
- Where possible, avoid assuming the use of Windows/IIS-specific tools as the default; clarify when guidance is platform-specific.
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. PowerShell and Windows-specific tools are referenced without always providing Linux equivalents. The GUI for Hybrid Connection Manager is only available on Windows, and while Linux CLI instructions are present, some troubleshooting and testing steps (e.g., Test-NetConnection) are only shown for Windows/PowerShell. Linux users are sometimes directed to use generic tools (like nslookup or curl) but not always given parity in examples or troubleshooting steps.
Recommendations
- For every PowerShell or Windows-specific command (e.g., Test-NetConnection), provide the Linux equivalent (e.g., nc or telnet for TCP connectivity tests).
- When listing installation or usage instructions, alternate the order or present both Windows and Linux instructions side-by-side to avoid a 'Windows-first' impression.
- Where GUI tools are only available for Windows, clearly state this and provide enhanced CLI or alternative tooling guidance for Linux users.
- Expand troubleshooting sections to include Linux-native commands and workflows (e.g., systemctl for service management, journalctl/logs for diagnostics).
- Ensure that all example commands, especially for connectivity and diagnostics, are shown for both platforms.
- Consider adding a dedicated Linux troubleshooting section or quick reference for common tasks.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/app-service-managed-certificate-changes-july-2025.md
...e/app-service-managed-certificate-changes-july-2025.md
High Priority
View Details →
Detected Bias Types
Powershell Heavy
Windows Tools
Missing Linux Example
Windows First
Summary
The documentation demonstrates a Windows bias by providing PowerShell scripts as the only automation example for identifying impacted Azure Traffic Manager endpoints, without offering Bash, Azure CLI, or cross-platform alternatives. References to 'open PowerShell' and script execution instructions are Windows-centric. There is no mention of Linux/macOS-compatible approaches, and PowerShell is presented as the default or only automation tool for certain tasks.
Recommendations
- Provide equivalent Bash or Azure CLI scripts for all PowerShell examples, especially for resource discovery and automation tasks.
- Explicitly mention that PowerShell Core is cross-platform if PowerShell must be used, and provide instructions for Linux/macOS environments.
- When referencing scripts, include both Windows (PowerShell) and Linux/macOS (Bash/CLI) usage instructions, or clarify if the script is cross-platform.
- Avoid language such as 'open PowerShell' without also mentioning terminal or shell for non-Windows users.
- Where possible, use Azure CLI examples as the primary automation method, as it is natively cross-platform.
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 clear Windows bias. It exclusively references Windows-based deployment and management tools (such as Visual Studio, Kudu, CMD, and PowerShell), and all file paths and runtime details are specific to Windows environments. There are no examples or instructions for Linux-based App Service environments, nor are Linux command-line tools or patterns mentioned. The documentation assumes the use of Windows App Service instances and omits Linux parity in both configuration and troubleshooting steps.
Recommendations
- Add equivalent instructions and examples for Linux-based App Service environments, including how to check .NET runtime versions and access diagnostic tools.
- Include Linux shell (bash) commands and file paths where appropriate, alongside Windows examples.
- Mention and demonstrate how to use cross-platform tools (such as Azure CLI) in both Windows and Linux contexts.
- Clarify which steps or features are Windows-only and provide links or guidance for Linux users.
- Provide parity in troubleshooting and diagnostic guidance for Linux-hosted ASP.NET apps, including log access and environment variable management.
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 Visual Studio's NuGet package manager) and omitting explicit Linux or cross-platform command-line examples for key steps such as file creation, package installation, and deployment. There are no Linux-specific instructions or terminal/CLI commands for common developer tasks, and the documentation assumes a GUI-based workflow typical of Windows environments.
Recommendations
- Provide equivalent Linux (and macOS) instructions for file creation and project navigation, using CLI commands (e.g., 'touch', 'mkdir', 'nano', or 'code').
- Include .NET CLI commands for package installation (e.g., 'dotnet add package Microsoft.SemanticKernel') alongside or before Visual Studio/NuGet GUI instructions.
- Offer deployment instructions using Azure CLI or GitHub Actions, not just portal-based workflows.
- Explicitly mention cross-platform compatibility and provide examples for both Windows and Linux environments where relevant.
- Avoid assuming the use of Visual Studio or Windows-specific UI patterns; highlight VS Code or JetBrains Rider as alternatives.
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 web servers within VMware environments, which are Windows-centric technologies. There is no mention of Linux-based hosting scenarios, such as .NET apps running on Apache, Nginx, or Kestrel on Linux. All examples and references are tailored to Windows tools and patterns, with no Linux equivalents provided.
Recommendations
- Include information about discovering .NET web apps hosted on Linux servers, such as those running on Apache, Nginx, or Kestrel.
- Provide examples and guidance for Linux-based environments, including any Azure Migrate capabilities or limitations for Linux-hosted .NET apps.
- Mention Linux discovery tools or processes where applicable, and ensure parity in documentation structure and detail.
- Clarify in the introduction if the discovery feature is limited to Windows/IIS, or explicitly state support for Linux if available.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/configure-encrypt-at-rest-using-cmk.md
...les/app-service/configure-encrypt-at-rest-using-cmk.md
High Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Missing Linux Example
Summary
The documentation demonstrates a mild Windows bias. While most command-line examples use the cross-platform Azure CLI, the only graphical tool mentioned for uploading files and generating SAS tokens is Azure Storage Explorer, and the link for generating SAS tokens specifically references the Windows tab. There are no Linux-specific instructions or examples for uploading files or generating SAS tokens, nor are alternative Linux-friendly tools or methods (such as azcopy or CLI-based SAS generation) mentioned. The documentation assumes the use of graphical tools more common on Windows, and does not provide parity for Linux users.
Recommendations
- Include instructions and examples for uploading files and generating SAS tokens using cross-platform CLI tools such as azcopy or Azure CLI.
- When referencing Azure Storage Explorer, clarify its cross-platform availability and provide instructions for Linux/macOS users, or avoid linking specifically to the Windows tab.
- Add explicit Linux/macOS command-line examples for all steps currently described only with GUI tools.
- Consider mentioning alternative open-source or native Linux tools where appropriate.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/deploy-run-package.md
...s/blob/main/articles/app-service/deploy-run-package.md
High Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Missing Linux Example
Summary
The documentation page demonstrates a Windows bias by referencing Windows file paths (e.g., D:\home\site\wwwroot) before Linux equivalents, describing deployment behaviors primarily in terms of Windows directory structures, and omitting explicit Linux/macOS command-line examples or file path conventions. The instructions and troubleshooting sections focus on Windows patterns, with only brief mentions of Linux, and do not provide parity in examples or guidance for Linux users.
Recommendations
- Provide Linux/macOS-specific examples and file paths alongside Windows ones, ensuring both are equally visible and explained.
- When describing deployment directories, always mention both Windows (D:\home\...) and Linux (/home/...) paths together, not just as an afterthought.
- Include sample commands for Linux/macOS shells (e.g., bash) where relevant, especially for file operations or troubleshooting.
- Explicitly state any differences in behavior or requirements between Windows and Linux App Service environments.
- Add troubleshooting tips and notes that are relevant to Linux users, not just Windows.
- Ensure that all included code snippets, especially those involving file paths or system operations, have Linux equivalents.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/app-service-web-nodejs-best-practices-and-troubleshoot-guide.md
...rvice-web-nodejs-best-practices-and-troubleshoot-guide.md
High Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Missing Linux Example
Powershell Heavy
Summary
The documentation is heavily focused on Windows-based Node.js applications running on Azure App Service, specifically with iisnode. All configuration examples, troubleshooting steps, and tool references are tailored to Windows environments (e.g., node.exe, web.config, iisnode, named pipes, Win32 error codes, Kudu CMD/PowerShell). There are no Linux equivalents, examples, or guidance provided, and Linux-specific tools or deployment patterns are not mentioned.
Recommendations
- Add a parallel section or separate guide for Node.js applications running on Azure App Service Linux, covering configuration, deployment, and troubleshooting steps relevant to Linux environments.
- Provide Linux-specific examples (e.g., using environment variables, PM2, NGINX/Apache, systemd) alongside or before Windows/iisnode examples.
- Reference Linux tools and patterns (such as log file locations, process management, and debugging techniques) where appropriate.
- Avoid assuming the use of Windows-only features (like web.config, named pipes, Win32 error codes) without offering Linux alternatives or clarifying that these are Windows-specific.
- Include screenshots and walkthroughs for the Azure portal and Kudu/SSH experiences as they appear for Linux-based App Service plans.
- Clearly indicate at the top of the document that the content is Windows-specific, and provide a link to Linux-focused documentation if available.
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 more detailed and prescriptive, with step-by-step PowerShell scripts and explicit use of Windows-specific tools and paths. The Windows approach is described with more automation (PowerShell, .cmd files), while the Linux approach is more manual (shell scripts, apk, xsltproc). Windows-specific tools (PowerShell, .cmd) are featured prominently, and the Windows section appears before the Linux section in some places. However, both platforms are covered and Linux examples are present.
Recommendations
- Balance the level of detail: Expand the Linux section to provide equally detailed, step-by-step instructions, including example shell scripts that automate the process as thoroughly as the Windows PowerShell example.
- Parity in automation: Provide a ready-to-use Bash script for Linux that mirrors the automation provided by the Windows PowerShell script, including checks for idempotency and error handling.
- Tool parity: Where possible, suggest cross-platform tools or provide equivalent Linux-native commands/scripts for every Windows-specific tool or pattern (e.g., use Bash scripts instead of only PowerShell).
- Order of presentation: Consider presenting Linux and Windows instructions in parallel or in the same order throughout the documentation to avoid the perception of Windows-first bias.
- Clarify platform differences: Explicitly call out any differences in capabilities or limitations between Linux and Windows, and provide workarounds or alternatives for Linux where 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 page demonstrates a Windows-first bias by providing more detailed instructions, features, and examples for Windows App Service apps compared to Linux. Several logging types (web server logging, detailed error messages, failed request tracing) are documented only for Windows, with no Linux equivalents or alternatives described. Windows-specific tools and file paths are mentioned (e.g., Log Parser, D:\home\LogFiles), while Linux paths and tools are less emphasized or omitted. There are also sections where only .NET (Windows) logging to blob storage is supported, with other languages/platforms (often used on Linux) excluded or requiring code changes.
Recommendations
- Provide equivalent, step-by-step instructions for enabling web server logging, detailed error messages, and failed request tracing on Linux App Service (or clearly state if these features are unavailable).
- Include Linux-specific file paths and examples (e.g., /home/LogFiles) alongside Windows paths in all relevant sections.
- Mention Linux-compatible tools for viewing and parsing logs (e.g., less, tail, grep, jq) in addition to or instead of Windows tools like Log Parser.
- Clarify feature parity and limitations for Linux and container-based App Service plans, and offer workarounds or alternatives where features are missing.
- Expand code examples to include common Linux-targeted languages and frameworks (Node.js, Python, Java) with logging best practices for App Service.
- Where a feature is Windows-only, provide a clear note and suggest alternative approaches for Linux users.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/configure-linux-open-ssh-session.md
...ticles/app-service/configure-linux-open-ssh-session.md
High Priority
View Details →
Detected Bias Types
Windows First
Missing Linux Example
Windows Tools
Summary
The documentation page demonstrates a Windows-first bias by presenting Windows container information and browser SSH access before Linux container details and CLI-based SSH access. The Windows section lacks parity with Linux, as it does not provide any command-line or PowerShell examples for SSH access, nor does it mention Windows-native tools or alternatives. Conversely, the Linux section provides detailed Azure CLI and SSH command examples, but there is no equivalent for Windows containers. This creates an imbalance in guidance and may leave Windows users without clear instructions for non-browser SSH access.
Recommendations
- Provide equivalent command-line (e.g., PowerShell) or Azure CLI instructions for opening SSH sessions to Windows containers, if supported.
- If SSH via CLI is not supported for Windows containers, explicitly state this limitation and suggest alternative remote management options for Windows containers.
- Include references to Windows-native SSH clients or tools (such as PowerShell's SSH capabilities or PuTTY) where appropriate.
- Ensure that both Windows and Linux sections have comparable depth and clarity in their instructions, examples, and tool recommendations.
- Consider reordering or parallelizing the presentation so that Linux and Windows instructions are given equal prominence and structure.
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 examples for per-app scaling, with no equivalent examples for Linux-native tools (such as Azure CLI or Bash scripting). The use of PowerShell cmdlets (New-AzAppServicePlan, Set-AzAppServicePlan, Get-AzWebApp, Set-AzWebApp) is exclusive, and there is no mention of Linux or cross-platform workflows. ARM template examples are platform-neutral, but all imperative (command-line) guidance is Windows-centric.
Recommendations
- Add equivalent Azure CLI examples for all PowerShell commands, showing how to enable per-app scaling and configure number of workers using az appservice plan and az webapp commands.
- Include Bash script snippets for Linux users where appropriate.
- When introducing command-line instructions, present Azure CLI (cross-platform) examples before or alongside PowerShell examples.
- Explicitly mention that PowerShell examples are for Windows users and provide guidance for Linux/macOS users.
- Review related content and links to ensure Linux and cross-platform tooling is represented.
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 demonstrates a moderate Windows bias, especially in the .NET section, where Windows tools (Visual Studio, PowerShell) are listed before cross-platform or Linux-native options. Some quickstart and tutorial links default to Windows or PowerShell tabs, and Windows-specific tools are mentioned more prominently than their Linux equivalents. In contrast, Linux and CLI options are less emphasized or appear after Windows options. Other stacks (Java, Node.js, PHP) show better Linux parity, but the 'Next step' call-to-action also defaults to an ASP.NET (Windows-centric) example.
Recommendations
- Ensure that for every Windows/Powershell example or tool, an equivalent Linux/Bash/Azure CLI example is provided and given equal prominence.
- In tables and lists, alternate the order of Windows and Linux tools, or group them together under neutral headings (e.g., 'Command line (Windows, Linux)').
- Avoid defaulting to Windows tabs or PowerShell in quickstart/tutorial links; use neutral or platform-agnostic defaults, or provide clear tab choices.
- Add explicit Linux/CLI examples for .NET where missing, especially for creation and deployment steps.
- Balance the 'Next step' call-to-action by rotating or randomizing the stack, or providing a choice of language/platform.
- Review all sections for implicit prioritization of Windows tools and ensure Linux users receive equal guidance and visibility.
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 referencing Windows-specific tools (IIS, Procdump, web.config), focusing on PowerShell for management, and linking to Windows-centric resources. There is a lack of Linux-specific examples, tools, or guidance, and the documentation implicitly assumes a Windows-based App Service environment.
Recommendations
- Provide equivalent Linux troubleshooting steps and examples, such as using SSH, Bash, or Linux-native diagnostic tools.
- Mention Linux App Service differences, such as the absence of IIS and the use of different logging mechanisms.
- Include Linux-specific tools (e.g., strace, lsof, top) for diagnostics and profiling.
- Offer examples for managing and restarting apps using Azure CLI and Bash, not just PowerShell.
- Clarify when a feature or tool is Windows-only, and provide alternatives for Linux-based App Service.
- Update links and references to include Linux documentation and blog posts where available.
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. All file paths and folder references use Windows-style paths (e.g., D:\home), and there is no mention of equivalent Linux paths or behaviors. The only tool mentioned for checking disk usage is 'Azure Web Apps Disk Usage', with no Linux-native alternatives. The documentation refers to Kudu/SCM, which is more closely associated with Windows-based App Service environments, and does not provide Linux-specific instructions or examples. There are no Linux shell or command-line examples, and Linux-specific behaviors or caveats are not addressed, except for a brief note that the feature is not supported in Linux containers.
Recommendations
- Add Linux-specific examples and clarify file paths for Linux-based App Service environments (e.g., /home/site/wwwroot instead of D:\home\site).
- Mention Linux-native tools or commands (such as 'du' or 'ls') for checking disk usage and folder sizes.
- Provide parity in instructions for both Windows and Linux App Service environments, including any differences in behavior or configuration.
- Explicitly state any differences in how local cache works (or does not work) on Linux App Service plans, and provide links to relevant Linux documentation.
- Where features are unsupported on Linux, suggest alternative approaches or workarounds 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
Windows Tools
Summary
The documentation demonstrates a moderate Windows bias. While Azure CLI (cross-platform) examples are present and often listed first, PowerShell commands (specific to Windows) are also provided in parallel, but there are no explicit Linux shell or Bash script examples beyond the CLI. The documentation references features (such as outbound IPv6 support) as being available only for Windows apps, with no Linux parity or roadmap. There are no Linux-specific troubleshooting or tool references, and the only shell command shown outside of Azure CLI is 'nslookup', which is cross-platform but not contextualized for Linux users. The documentation does not mention or address differences in experience for Linux-hosted App Service apps except to note missing features.
Recommendations
- Where PowerShell examples are provided, also include equivalent Bash or shell script examples (where applicable), especially for common tasks like querying properties with Azure CLI.
- Explicitly note when features (such as outbound IPv6 support) are Windows-only, and provide a roadmap or workaround for Linux users if possible.
- Add troubleshooting tips or notes for Linux users, such as differences in DNS tools or command syntax (e.g., using 'dig' as an alternative to 'nslookup').
- Ensure that all CLI examples are tested and presented in a way that works seamlessly on both Windows and Linux terminals.
- Where screenshots or portal instructions are given, clarify that the experience is the same or note any differences for Linux-hosted apps.
- Consider including a section or callout specifically addressing Linux-hosted App Service scenarios, especially where feature parity is lacking.
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 demonstrates a mild Windows bias. Windows-specific features and limitations (e.g., Windows Containers subnet sizing, Windows Server Active Directory, NetBIOS) are discussed in detail, while Linux-specific scenarios are only briefly mentioned (e.g., a single note about Linux continuous deployment network dependencies). There are no Linux-specific configuration examples, troubleshooting steps, or parity in coverage for Linux container nuances. Windows terminology and tools (e.g., Kudu console, Windows Containers) are referenced without Linux equivalents or alternatives.
Recommendations
- Add Linux-specific examples and scenarios, such as subnet sizing for Linux containers, and clarify any differences in behavior or requirements.
- Include Linux-native tools or references (e.g., SSH, Bash, Linux environment variables) alongside or in place of Windows-centric tools like Kudu.
- Provide troubleshooting steps and configuration guidance that address common Linux deployment patterns (e.g., Docker Compose, Linux filesystem mounts, SELinux/AppArmor considerations).
- Ensure that when platform-specific limitations or features are discussed (e.g., Windows Containers), equivalent Linux information is provided or explicitly state if not applicable.
- Balance the order of presentation so that Linux and Windows are given equal prominence, or group platform-specific content under clearly labeled sections.
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 (and PowerShell) options before Linux equivalents, and by providing a PowerShell automation example but not a Bash/Linux shell script. The Azure portal UI instructions do not distinguish between Windows and Linux, but the scripting section gives more prominence to Windows-centric tools.
Recommendations
- Provide Linux shell (Bash) script examples alongside PowerShell for automation, especially for creating and managing App Service plans.
- When listing command-line options (e.g., Azure CLI commands), clarify any differences or requirements for Linux vs. Windows environments.
- Present Linux and Windows options in parallel or alternate their order to avoid always listing Windows first.
- Explicitly mention that the Azure CLI commands work cross-platform and provide any necessary notes for Linux users.
- If referencing portal UI steps, clarify if there are any differences for Linux-based App Service plans or containers.
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 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 (in the context of using PM2 for Node.js), most configuration and troubleshooting guidance assumes a Windows/IIS environment, and Linux-specific instructions or parity are lacking.
Recommendations
- Provide Linux-native configuration examples alongside Windows ones (e.g., mention app settings or environment variables instead of only web.config).
- Include Linux-specific troubleshooting steps and tools (such as using process managers like systemd or supervisord, or Linux-native diagnostic commands).
- When referencing iisnode or web.config, also describe how to achieve similar configurations on Linux-based App Service environments.
- Ensure that examples and recommendations are balanced between Windows and Linux, or clearly indicate when guidance is platform-specific.
- Add explicit Linux examples for auto-healing, scaling, and backup configurations where they differ from Windows.
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 OS and PowerShell scripts are mentioned for migration tasks, with no mention of Linux-based hosting environments, Linux migration tools, or cross-platform alternatives. The App Service Migration Assistant and related scripts are Windows-only, and there are no examples or guidance for migrating .NET apps from Linux servers or using Linux-native tools.
Recommendations
- Include migration guidance and tools for .NET apps hosted on Linux servers (e.g., Apache, Nginx, Kestrel).
- Provide Linux shell (bash) script equivalents for PowerShell-based migration steps.
- Mention and document any cross-platform or Linux-compatible migration tools, or clarify their absence.
- Add examples and scenarios for containerizing .NET apps on Linux and migrating them to Azure App Service (Linux).
- Explicitly state platform limitations for each tool and provide alternative recommendations for non-Windows environments.
- Ensure parity in documentation structure and examples for both Windows and Linux migration scenarios.
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 moderate Windows bias. Windows SKUs and examples are listed before Linux equivalents, and Azure PowerShell (a Windows-centric tool) is given equal prominence to Azure CLI, despite CLI being more cross-platform. Portal instructions and screenshots are Windows-focused, and there are no explicit Linux shell or scripting examples beyond the CLI. The documentation refers to Windows-specific behaviors and limitations before Linux ones.
Recommendations
- Present Linux and Windows examples in parallel, or alternate which comes first to avoid 'windows_first' bias.
- Emphasize Azure CLI as the primary automation tool, as it is cross-platform, and provide Bash shell script examples where appropriate.
- Include explicit Linux shell (Bash) automation examples, not just Azure CLI and PowerShell.
- Clarify in portal instructions and screenshots when steps or UI differ for Linux-hosted apps.
- Where Windows-specific limitations or behaviors are discussed, ensure Linux equivalents are also described if applicable.
- Consider a dedicated section for Linux container deployment, since the tier supports custom containers on Linux.
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 demonstrates a moderate Windows bias, especially in the .NET/ASP.NET section, where Windows tools (Visual Studio, Azure PowerShell) are listed before or alongside cross-platform or Linux-native options. Some quickstart links default to Windows or PowerShell tabs, and the 'Next step' action promotes an ASP.NET (typically Windows-centric) workflow. In Python and some other stacks, Windows is present in tab defaults and URLs, and Linux options are not always presented first or as equally as Windows ones.
Recommendations
- Ensure that Linux and cross-platform CLI examples are presented before or alongside Windows/PowerShell options in all language stacks.
- Avoid defaulting to Windows or PowerShell tabs/links in quickstart guides; instead, use neutral or Linux-first defaults where possible.
- For .NET/ASP.NET, explicitly provide Linux-based development and deployment workflows (e.g., using .NET CLI on Linux, VS Code on Linux, Azure CLI) and highlight them equally.
- In 'Next step' and similar callouts, rotate or randomize the stack/language to avoid always promoting Windows-centric workflows.
- Audit all quickstart and tutorial links to ensure Linux and cross-platform instructions are present, up-to-date, and as detailed as Windows equivalents.
- Where Windows tools are mentioned (e.g., Visual Studio, PowerShell), always mention Linux alternatives (e.g., VS Code, Azure CLI, Bash) in parallel.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/configure-authentication-file-based.md
...les/app-service/configure-authentication-file-based.md
High Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Missing Linux Example
Summary
The documentation demonstrates a Windows-first bias by referencing the Windows file path (C:\home\site\wwwroot) as the default location for the configuration file, and only later mentioning the Linux equivalent. There are no explicit Linux command-line or file path examples, and the instructions and examples default to Windows conventions. The only mention of Linux is in a note, which describes a limitation without providing a Linux-centric example or workflow.
Recommendations
- Provide Linux file path examples alongside Windows examples, or present Linux examples first when discussing cross-platform scenarios.
- Include explicit Linux command-line instructions or references (e.g., using bash or Linux file system conventions) where appropriate.
- Clarify and expand on Linux-specific behaviors or limitations, ideally with example commands or file paths for both platforms in all relevant sections.
- Avoid using Windows paths (e.g., C:\home\site\wwwroot) as the default in instructions; instead, present both Windows and Linux paths together or in parallel.
- Where platform differences exist, consider using a table or side-by-side comparison to make parity and differences clear.