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 401-425 of 2121 flagged pages
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
Windows Tools
Powershell Heavy
Missing Linux Example
Summary
The documentation exhibits a moderate Windows bias. Windows installation and usage instructions are consistently presented before Linux equivalents, and Windows-specific tools (GUI, MSI installer) are described in detail, while Linux users are limited to CLI and manual installation. Troubleshooting examples use PowerShell commands without Linux alternatives. Some features (like the GUI) are only available on Windows, and this is noted, but Linux parity is not addressed. Linux instructions are present but less detailed and sometimes lack direct equivalents to Windows workflows.
Recommendations
- Present Linux and Windows instructions side-by-side or in parallel tabs, rather than always listing Windows first.
- Provide Linux equivalents for all troubleshooting commands (e.g., use 'nc', 'telnet', or 'ss' for connectivity checks instead of only PowerShell).
- Expand Linux installation instructions to include common package managers (yum, dnf, zypper) and clarify supported distributions.
- Offer a Linux GUI alternative or roadmap, or clarify if/when one will be available.
- Ensure all screenshots and examples have Linux counterparts where possible.
- Explicitly mention any feature gaps between Windows and Linux, and provide workarounds or alternatives for Linux users.
- Include more Linux-centric troubleshooting steps and examples, such as using systemd for service management.
Create Pull Request
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/app-service-asp-net-migration.md
.../articles/app-service/app-service-asp-net-migration.md
High Priority
View Details →
Detected Bias Types
Windows First
Missing Linux Example
Windows Tools
Powershell Heavy
Summary
The documentation page exhibits a strong Windows bias. All migration tools and examples focus exclusively on migrating ASP.NET apps from Windows/IIS environments. Only Windows-based tools (App Service Migration Assistant, PowerShell scripts) are mentioned, and there is no mention of Linux-based migration scenarios, tools, or examples. The documentation assumes the source environment is Windows, and does not address .NET apps hosted on Linux or provide parity for Linux users.
Recommendations
- Add guidance and tools for migrating .NET apps hosted on Linux (e.g., Apache, Nginx) to Azure App Service.
- Include Linux shell (bash) script examples alongside PowerShell for discovery and migration tasks.
- Document migration scenarios for .NET Core/ASP.NET Core apps running on Linux, not just ASP.NET Framework on Windows/IIS.
- Mention and link to any cross-platform migration tools or clarify current tool limitations regarding Linux.
- Ensure that tool download links and documentation are not Windows-only, or clearly state platform support.
- Provide parity in documentation structure and examples for both Windows and Linux migration paths.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/app-service-managed-certificate-changes-july-2025.md
...e/app-service-managed-certificate-changes-july-2025.md
High Priority
View Details →
Detected Bias Types
Powershell Heavy
Windows Tools
Missing Linux Example
Windows First
Summary
The documentation demonstrates a Windows bias primarily through the exclusive use of PowerShell scripts for advanced resource discovery and mitigation (e.g., identifying Traffic Manager endpoints). There are no equivalent Bash, Azure CLI, or cross-platform script examples provided for Linux or macOS users. PowerShell is referenced as the default automation tool for scenarios where ARG queries are insufficient, and no Linux-native alternatives are mentioned. This may hinder Linux users or those working in cross-platform environments from easily following the guidance.
Recommendations
- Provide Bash or Azure CLI script equivalents for all PowerShell scripts, especially for resource discovery and automation tasks.
- When referencing scripts, explicitly mention cross-platform compatibility or provide instructions for both Windows (PowerShell) and Linux/macOS (Bash/CLI).
- List Azure CLI and REST API options before or alongside PowerShell to avoid the impression that Windows tooling is primary.
- Include notes or links to Linux/macOS-friendly tools and scripting approaches where automation is discussed.
- Review all example commands and ensure parity between Windows and Linux environments, especially for common administrative tasks.
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 tools and patterns (such as web.config and iisnode) without providing equivalent Linux guidance or examples. Linux is only mentioned in passing, and there are no Linux-specific configuration examples or references to Linux-native tools. The use of Windows-centric configuration files and modules (e.g., web.config, iisnode) is presented as the default or only option, which may confuse or exclude Linux users.
Recommendations
- Provide Linux-specific configuration examples alongside or in place of Windows-centric ones (e.g., show how to configure auto-healing or process management using Linux-native files or tools).
- When referencing web.config or iisnode, clarify their applicability (e.g., that web.config is for Windows-based App Service plans) and provide alternatives for Linux-based plans (such as app settings, environment variables, or startup scripts).
- Include Linux-native process management recommendations (e.g., systemd, supervisord, or PM2 for Node.js) where appropriate.
- Ensure that troubleshooting and best practice sections explicitly address both Windows and Linux hosting scenarios, with clear, parallel guidance.
- Add examples or links for configuring Node.js and other apps on App Service for Linux, including startup commands, environment variable usage, and diagnostic tooling.
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 page demonstrates a moderate Windows bias. Windows-related information and examples are often presented first (e.g., SKU availability), and Azure PowerShell (a Windows-centric tool) is given a dedicated automation section. There is a lack of Linux-specific automation examples (e.g., Bash scripts), and no mention of Linux-native tools or workflows. The documentation assumes familiarity with Windows tools and patterns, with Linux alternatives either presented second or omitted.
Recommendations
- Present Linux and Windows information in parallel or alternate their order to avoid always listing Windows first.
- Add Linux-native automation examples (e.g., Bash scripts) alongside PowerShell examples.
- Explicitly mention cross-platform compatibility for CLI commands and clarify when a tool or example is Windows-specific.
- Include references to Linux-native tools or workflows where relevant (e.g., scripting with Bash, using Linux shells).
- Ensure that screenshots and UI instructions are not Windows-centric or clarify when steps differ for Linux users.
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 focusing exclusively on Windows-based deployment and configuration patterns for ASP.NET apps. All runtime version examples use Windows file paths and tools (CMD, PowerShell, Kudu), with no mention of Linux equivalents or how to perform similar tasks on Linux-based App Service plans. There are no Linux-specific instructions or examples, and Windows tools and patterns are presented as the default or only option.
Recommendations
- Add parallel instructions and examples for Linux-based App Service plans, including how to check installed .NET runtimes and access diagnostic tools.
- Include Linux shell (bash) commands and file paths where appropriate, alongside Windows CMD/PowerShell examples.
- Clarify in each section whether the instructions apply to Windows, Linux, or both, and provide links to Linux-specific documentation if available.
- Mention Linux equivalents to Kudu (such as SSH or the Linux-based Kudu Lite) and how to use them for diagnostics and file inspection.
- Ensure that environment variable and configuration guidance covers both Windows and Linux hosting environments, noting any differences.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/app-service-hybrid-connections.md
...articles/app-service/app-service-hybrid-connections.md
High Priority
View Details →
Detected Bias Types
Windows First
Powershell Heavy
Windows Tools
Missing Linux Example
Summary
The documentation demonstrates a moderate Windows bias. Windows instructions, tools, and troubleshooting steps are often presented first or exclusively, with some Linux equivalents either missing or less detailed. Windows-specific tools (such as the GUI and PowerShell commands) are emphasized, while Linux alternatives are sometimes less visible or not provided at parity.
Recommendations
- Provide Linux and Windows instructions side-by-side or in parallel tabs throughout the documentation, not just in installation sections.
- Where PowerShell commands are given for troubleshooting (e.g., Test-NetConnection), provide equivalent Linux commands (e.g., nc, curl, or telnet) for network testing.
- Mention Linux CLI and scripting patterns as prominently as Windows/PowerShell ones.
- Ensure that all features and management options (such as GUI vs CLI) are clearly documented for both platforms, and clarify any feature gaps.
- In troubleshooting sections, include Linux-native tools and commands (e.g., netcat, dig, systemctl for service management) alongside Windows tools.
- Avoid assuming the reader is on Windows by default; use neutral language and structure to present both platforms equally.
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., web.config, node.exe, named pipes, Win32 error codes, Kudu CMD/PowerShell). There are no examples or guidance for Linux-based App Service environments, and Linux equivalents (such as process management, logging, or configuration patterns) are not mentioned.
Recommendations
- Add a parallel section or separate guide for Node.js on Azure App Service Linux, covering best practices and troubleshooting for that environment.
- Provide Linux-specific examples, including configuration (e.g., using PM2 or systemd), log file locations, and common troubleshooting steps.
- When referencing tools or paths (e.g., web.config, node.exe, d:\home\LogFiles), include Linux equivalents (e.g., server.js, /home/LogFiles, environment variables).
- Mention cross-platform Node.js debugging and profiling tools, and show how to use them on both Windows and Linux.
- Avoid assuming the use of Windows-only features (like iisnode, named pipes, Win32 error codes) without clarifying their scope or providing Linux alternatives.
- Balance the order of presentation so that Linux and Windows are treated equally, or clarify early that the guide is Windows-specific and link to Linux guidance.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/deploy-azure-pipelines.md
...ob/main/articles/app-service/deploy-azure-pipelines.md
High Priority
View Details →
Detected Bias Types
Windows First
Powershell Heavy
Windows Tools
Missing Linux Example
Summary
The documentation demonstrates a Windows bias in several ways: Windows agents and tools (such as Web Deploy) are featured prominently, with examples and troubleshooting focused on Windows scenarios. The 'Deploy using Web Deploy' section only provides a Windows-based example, and troubleshooting for Web Deploy is Windows-specific. While there is some mention of Linux (e.g., 'Azure Web App on Linux'), Linux-specific deployment methods and troubleshooting are not covered in equal detail. There are no Linux shell or cross-platform script examples, and Windows agent images are often referenced first or exclusively in key sections.
Recommendations
- Provide equivalent Linux-based deployment examples, especially for scenarios like 'Deploy using Web Deploy' where only Windows is currently shown.
- Include troubleshooting guidance for Linux agents, not just Windows (e.g., what to do if a deployment fails on Linux).
- When referencing agent images, list both Windows and Linux options equally, or alternate their order.
- Offer cross-platform script examples (e.g., Bash as well as PowerShell) where scripts are shown.
- Clarify which features or tasks are Windows-only and suggest Linux alternatives where possible.
- Expand the FAQ and error messages to include Linux agent scenarios and solutions.
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 primarily in terms of Windows paths. There are no explicit Linux or cross-platform command-line examples, and manual deployment instructions (such as creating directories or files) are only described with Windows-style paths. Linux-specific nuances or examples are missing.
Recommendations
- Present both Windows and Linux directory paths together throughout the documentation (e.g., D:\home\site\wwwroot (Windows) and /home/site/wwwroot (Linux)).
- Include explicit Linux/macOS command-line examples where relevant, especially for manual steps like creating directories or files.
- Clarify when instructions or behaviors differ between Windows and Linux App Service environments.
- Add troubleshooting notes or caveats specific to Linux deployments, if any.
- Ensure that all references to file paths, deployment locations, and manual steps are given in both Windows and Linux formats.
- Consider adding a section or callout summarizing cross-platform differences in ZIP deployment behavior.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/deploy-staging-slots.md
...blob/main/articles/app-service/deploy-staging-slots.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. While it mentions 'web app on Linux' in the introduction and notes that some features (like auto swap) are not supported on Linux, the majority of technical examples and advanced configuration references (such as custom warm-up using Web.config and IIS's applicationInitialization) are Windows-centric. The command-line examples are provided for both Azure CLI (cross-platform) and Azure PowerShell (primarily Windows), but there is a notable lack of Linux-native or shell-specific guidance. Additionally, advanced troubleshooting and configuration (e.g., rewrite rules in Web.config) assume a Windows/IIS environment, with no equivalent Linux/NGINX/Apache examples or notes.
Recommendations
- Provide explicit Linux-specific examples and guidance, especially for advanced configuration and troubleshooting (e.g., show how to configure custom warm-up and rewrite rules for Linux-based web apps using NGINX or Apache).
- Clarify in each section whether the instructions apply to both Windows and Linux App Service plans, and offer alternatives or workarounds for Linux where features are not supported.
- Balance the prominence of PowerShell and Azure CLI examples, and consider including Bash shell scripts or Linux command-line idioms where appropriate.
- Where Windows-specific tools or configuration files (like Web.config or IIS settings) are referenced, add parallel instructions or notes for Linux-based deployments (e.g., appsettings.json for .NET Core on Linux, NGINX config for Node/Python apps).
- Explicitly state limitations or differences for Linux throughout the documentation, not just in feature notes, to help Linux users avoid confusion.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/environment/networking.md
...ob/main/articles/app-service/environment/networking.md
High Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Missing Linux Example
Summary
The documentation shows a Windows bias by referencing Windows-specific SKUs (e.g., I1v2 Windows), providing detailed IP address calculations only for Windows Containers, and listing Windows-centric tools (Visual Studio remote debugging, Web Deploy) in port tables without mentioning Linux equivalents or alternatives. There are no Linux-specific examples or parity in the detailed scenarios, and Linux container/app scenarios are not illustrated with the same depth.
Recommendations
- Provide equivalent Linux container/app examples, including IP address calculations and scaling considerations.
- Mention Linux-compatible deployment and debugging tools (e.g., SSH, SFTP, VS Code Remote) alongside or before Windows tools.
- Ensure port tables include Linux-relevant ports and tools, or clarify which ports/tools are OS-specific.
- Balance references to Windows and Linux SKUs and features throughout the documentation.
- Add Linux-specific notes or callouts where behaviors or requirements differ.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/tutorial-ai-integrate-azure-ai-agent-dotnet.md
...service/tutorial-ai-integrate-azure-ai-agent-dotnet.md
High Priority
View Details →
Detected Bias Types
Missing Linux Example
Windows Tools
Windows First
Summary
The documentation assumes a development environment based on GitHub Codespaces and .NET, which is cross-platform, but all terminal instructions and deployment flows are tailored to Azure App Service (a Windows-centric PaaS, though it does support Linux), and there is no mention of Linux-specific workflows, tools, or command-line environments. There are no Linux shell (bash) examples, and the documentation implicitly assumes use of Visual Studio Code or similar tools common on Windows. Additionally, there is no mention of how to run or test the app locally on a Linux machine, nor any reference to Linux package managers or deployment patterns.
Recommendations
- Include explicit instructions for running the sample app on Linux, such as using bash/zsh terminals and Linux-specific commands where appropriate.
- Provide examples for deploying to Azure App Service (Linux) and clarify any differences in configuration or deployment steps.
- Mention alternative editors and development environments common on Linux (e.g., Vim, Emacs, JetBrains Rider) in addition to Codespaces/VS Code.
- Add notes about installing .NET SDK and required dependencies on Linux distributions (e.g., apt, yum, zypper).
- Ensure that all CLI commands are shown in both PowerShell and bash syntax where differences exist.
- Clarify that Azure App Service supports both Windows and Linux, and provide links to documentation for both hosting environments.
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 page demonstrates a mild Windows bias by referencing Azure Storage Explorer with a Windows-specific tab for generating SAS tokens and not mentioning Linux alternatives or parity. There is no mention of Linux-native tools or cross-platform command-line alternatives for uploading files or generating SAS tokens. The only tool for managing storage is Storage Explorer, which is referenced with a Windows-specific tab, and no Linux instructions or screenshots are provided. All command-line examples use Azure CLI, which is cross-platform, but the file upload and SAS generation steps are not shown for Linux users.
Recommendations
- Provide explicit instructions or examples for uploading files and generating SAS tokens using Azure CLI or other cross-platform tools, not just Storage Explorer.
- If referencing Azure Storage Explorer, clarify its availability on Linux and macOS, and provide instructions or screenshots for those platforms.
- Add Linux-specific or cross-platform examples for all steps, especially for file upload and SAS generation.
- Avoid referencing Windows-specific tabs or UI elements without mentioning their equivalents on other platforms.
- Consider including a table or section comparing methods for Windows, Linux, and macOS users.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/getting-started.md
...docs/blob/main/articles/app-service/getting-started.md
High Priority
View Details →
Detected Bias Types
Windows First
Powershell Heavy
Windows Tools
Missing Linux Example
Summary
The documentation page demonstrates a moderate Windows bias, particularly in the .NET/ASP.NET section, where Windows-centric tools (Visual Studio, Azure PowerShell) are listed before cross-platform or Linux-native alternatives. Some sections (notably .NET and Python) reference Windows or PowerShell tools prominently or by default, and the 'Next step' callout specifically promotes an ASP.NET (Windows-associated) quickstart. Linux-specific or cross-platform examples are less emphasized or appear later, and in some cases, Linux CLI or tooling is not given equal prominence.
Recommendations
- Ensure that for every Windows or PowerShell example, an equivalent Linux/CLI example is provided and given equal or higher prominence.
- In tool lists, alternate the order or explicitly label tools as 'Windows', 'Linux', or 'Cross-platform' to avoid implicit prioritization.
- Expand the use of Azure CLI and VS Code examples, which are cross-platform, and ensure they are listed before or alongside Windows-specific tools.
- For the 'Next step' callout, provide options for multiple stacks (e.g., .NET on Linux, Node.js, Python) rather than defaulting to ASP.NET.
- Audit all quickstart and tutorial links to ensure Linux and cross-platform instructions are as discoverable and complete as their Windows counterparts.
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 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, Linux web servers (such as Apache or Nginx), or discovery processes for .NET apps running on Linux. All examples and capabilities are described in the context of Windows tools and environments, with no Linux parity.
Recommendations
- Include information about discovering .NET web apps hosted on Linux servers, such as those running on Apache, Nginx, or Kestrel.
- Provide parallel examples and instructions for Linux environments, including any differences in the Azure Migrate appliance setup or supported features.
- Mention whether agentless discovery is supported for Linux-based .NET apps, and if not, clarify the limitations and suggest alternative approaches.
- Add references to documentation or tools relevant to Linux-based .NET app discovery and migration.
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 page demonstrates a Windows-first bias by referencing the Windows file path (C:\home\site\wwwroot) as the primary example for file placement, and only later mentioning the Linux equivalent. The instructions and examples focus on Windows conventions, with Linux-specific guidance provided as a note rather than integrated into the main steps. There are no Linux shell or command-line examples, and the documentation does not provide parity in examples or instructions for Linux users.
Recommendations
- Present both Windows and Linux file paths and conventions side-by-side in all relevant steps and examples.
- Include explicit Linux examples (e.g., using /home/site/wwwroot/auth.json) in the main instructional flow, not just in notes.
- Add Linux-specific guidance or command-line examples where applicable (e.g., how to create or deploy the configuration file on Linux-based App Service).
- Avoid referencing Windows paths or tools as the default; instead, clarify platform differences up front and treat both platforms equally throughout the documentation.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/manage-scale-per-app.md
...blob/main/articles/app-service/manage-scale-per-app.md
High Priority
View Details →
Detected Bias Types
Powershell Heavy
Missing Linux Example
Windows Tools
Windows First
Summary
The documentation page demonstrates a Windows bias by 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 and the absence of cross-platform command-line instructions or references to Linux environments may hinder accessibility for Linux users. Additionally, PowerShell is presented as the primary method before ARM templates, reinforcing a Windows-centric approach.
Recommendations
- Add equivalent Azure CLI examples for all PowerShell commands, showing how to enable per-app scaling and configure numberOfWorkers using az commands.
- Include Bash scripting examples where appropriate, especially for app-level configuration.
- Explicitly mention that PowerShell examples are cross-platform only if true, or clarify if they require Windows.
- Reorder sections or provide parallel examples so that Linux-friendly tools (Azure CLI, Bash) are presented alongside or before PowerShell.
- Add a note or table summarizing all available tooling (PowerShell, Azure CLI, ARM templates, Portal) and their platform compatibility.
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 Tomcat data sources, but the Windows section is notably more detailed and uses Windows-specific tools and scripts (PowerShell, .cmd files, Windows environment variables). The Windows instructions are longer, more step-by-step, and rely on Windows-native patterns, while the Linux section is more concise and expects familiarity with shell scripting and Linux tools. The order of presentation sometimes places Windows instructions before or more prominently than Linux equivalents, and the Windows approach is described as the 'simplest way.'
Recommendations
- Ensure Linux and Windows instructions are equally detailed and parallel in structure, with matching step-by-step guides and troubleshooting notes.
- Avoid describing the Windows approach as 'simplest' unless the same is said for Linux; strive for neutral language.
- Where possible, provide cross-platform (e.g., Bash and PowerShell) script examples side-by-side, or reference equivalent tooling for Linux (e.g., Bash scripts instead of only PowerShell).
- List Linux and Windows instructions in the same order in each section, or present them in tabs to avoid implicit prioritization.
- Highlight any differences in capabilities or limitations between platforms explicitly, rather than assuming Windows as the default.
- If using environment variables or file paths, always show both Windows and Linux formats together.
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
Missing Linux Example
Summary
The documentation generally provides parity between Linux and Windows, but there are several areas where Windows is prioritized or Linux is underrepresented. Windows examples and tools (such as Kudu, FTPS, and web.config) are sometimes mentioned first or exclusively, and some advanced troubleshooting or configuration steps are described in more detail for Windows. In a few places, Linux-specific instructions are less detailed or omitted, and Windows-centric tools or patterns (like Kudu/Process Explorer) are referenced without clear Linux alternatives.
Recommendations
- Ensure that for every Windows example or tool mentioned (such as Kudu, FTPS, or web.config), a Linux equivalent or alternative is provided and described with equal detail.
- Avoid mentioning Windows-first patterns (such as referencing Kudu/Process Explorer for PID discovery) without immediately providing the Linux method (e.g., using SSH and ps/jcmd).
- Where possible, present Linux and Windows instructions side-by-side or in parallel tabs, rather than Windows-first.
- Expand Linux troubleshooting and configuration sections to match the depth and clarity of Windows sections (e.g., for log analysis, file download, and advanced diagnostics).
- Review references to Windows-specific files (like web.config) and clarify their (non-)applicability to Linux, offering Linux-native alternatives where appropriate.
- Audit for any missing Linux examples, especially in advanced or edge-case scenarios, and add them to ensure full parity.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/overview-managed-identity.md
...main/articles/app-service/overview-managed-identity.md
High Priority
View Details →
Detected Bias Types
Powershell Heavy
Windows Tools
Windows First
Summary
The documentation demonstrates a moderate Windows bias. PowerShell is featured heavily as a primary automation/scripting example, and some CLI code blocks are labeled as 'azurepowershell-interactive' even when using Azure CLI. PowerShell is a Windows-centric tool, and its prominence may disadvantage Linux users. Additionally, there is no mention of Linux-specific shell usage (e.g., Bash), and PowerShell examples are often provided before or in greater detail than their CLI counterparts. There are no explicit Linux-only examples or references to Linux-native tools.
Recommendations
- Ensure all CLI examples are clearly labeled and use Bash syntax where appropriate, especially for Azure CLI commands.
- Provide Bash shell script equivalents for PowerShell automation examples, particularly for token retrieval and scripting scenarios.
- Avoid labeling Azure CLI code blocks as 'azurepowershell-interactive' to prevent confusion.
- Explicitly mention that Azure CLI commands work cross-platform and can be run in Bash on Linux/macOS.
- Where PowerShell is used, add a note or alternative example for Linux users who may not have PowerShell installed.
- Consider adding a section or callout for Linux/macOS users, highlighting any differences or tips for those environments.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/tutorial-connect-app-access-sql-database-as-user-dotnet.md
...utorial-connect-app-access-sql-database-as-user-dotnet.md
High Priority
View Details →
Detected Bias Types
Windows Tools
Windows First
Missing Linux Example
Summary
The documentation demonstrates a moderate Windows bias. It references Windows-centric tools (such as SQL Server Management Studio and Visual Studio), and provides detailed instructions for publishing from Visual Studio before mentioning Git Bash. There are no explicit Linux or cross-platform alternatives for some steps (e.g., connecting to SQL Database with tools other than SSMS, or publishing from non-Windows environments). The documentation assumes familiarity with Windows tooling and patterns, and does not provide equivalent Linux-first or cross-platform examples for all scenarios.
Recommendations
- Include explicit instructions and examples for Linux/macOS users, such as using Azure Data Studio or sqlcmd for database management, and VS Code or CLI-based deployment workflows.
- When listing tools (e.g., SSMS, Visual Studio), mention cross-platform alternatives (e.g., Azure Data Studio, VS Code) and provide links or brief usage instructions.
- Provide Linux/macOS command-line examples for all Azure CLI and git operations, ensuring parity with Windows instructions.
- When referencing publishing workflows, present cross-platform methods (e.g., Azure CLI, GitHub Actions, VS Code) before or alongside Windows-specific tools like Visual Studio.
- Clarify when a tool or step is Windows-only, and offer alternatives for other operating systems.
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-specific paths (e.g., D:\home), tools, and deployment conventions throughout, without providing equivalent Linux examples or clarifications. The only site extension mentioned for checking disk usage is Azure Web Apps Disk Usage, which is Windows-centric. Linux container support is only mentioned in a note as unsupported, and there are no Linux-specific instructions, examples, or file path references. The documentation assumes a Windows environment as the default context.
Recommendations
- Include Linux file path equivalents (e.g., /home/site) alongside Windows paths (D:\home) in all relevant sections.
- Clearly indicate when instructions or features are Windows-only, and provide Linux alternatives or workarounds where possible.
- Mention and provide examples for Linux-compatible tools or commands for tasks such as checking disk usage (e.g., using du or ls commands in KuduLite).
- Add explicit instructions or notes for enabling, configuring, and troubleshooting local cache (or its alternatives) on Linux-based App Service plans.
- Ensure that all code snippets, configuration examples, and best practices are presented for both Windows and Linux environments, or clarify when a feature is not available on one platform.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/includes/deploy-intelligent-apps/deploy-intelligent-apps-linux-dotnet-pivot.md
...ent-apps/deploy-intelligent-apps-linux-dotnet-pivot.md
High Priority
View Details →
Detected Bias Types
Windows First
Missing Linux Example
Windows Tools
Summary
The documentation demonstrates a Windows bias by prioritizing Windows/Visual Studio workflows (e.g., right-clicking to add files, using Visual Studio's NuGet package manager) and omitting explicit Linux or cross-platform command-line instructions for key steps. There are no Linux-specific examples or references to Linux-native tools or editors, and the guidance assumes a GUI-based, Windows-centric development environment.
Recommendations
- Provide equivalent Linux and cross-platform instructions for all steps, especially for file creation (e.g., using 'touch' or a text editor), and package installation (e.g., using 'dotnet CLI' or 'nuget CLI').
- List command-line instructions before or alongside GUI/Windows-specific instructions to ensure parity.
- Explicitly mention that all steps can be performed on Linux/macOS, and provide examples using common Linux editors (e.g., nano, vim) and terminal commands.
- Include screenshots or terminal output from Linux environments where appropriate.
- Clarify that Azure App Service supports deployment from Linux and provide deployment instructions using Linux tools (e.g., Azure CLI on Linux, VS Code).
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/reference-app-settings.md
...ob/main/articles/app-service/reference-app-settings.md
High Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Powershell Heavy
Missing Linux Example
Summary
The documentation exhibits a Windows-first bias in several areas. Windows-specific paths, tools, and conventions are mentioned before or instead of Linux equivalents. Many environment variable descriptions and examples use Windows paths (e.g., D:\home), reference Windows-specific tools (e.g., msbuild, Web Deploy/MSDeploy), and discuss Windows behaviors in more detail. Linux-specific information is often less detailed, appears after Windows content, or is missing entirely. Some features are described as 'Windows only' without clear Linux alternatives or parity.
Recommendations
- For every environment variable or feature that behaves differently on Windows and Linux, provide parallel examples and explanations for both platforms.
- When mentioning file paths, always include both Windows and Linux formats (e.g., D:\home and /home).
- Avoid using Windows-specific tools (like msbuild, Web Deploy/MSDeploy) as the default or only example; include Linux-native equivalents or alternatives (such as Oryx, Kudu for Linux, or CLI commands).
- In tables and explanations, do not default to Windows terminology or behaviors; explicitly state platform differences and ensure Linux is not an afterthought.
- Where features are Windows-only, clearly state whether there is Linux parity or a roadmap for it, and provide Linux workarounds if available.
- Add Linux/POSIX shell command examples where PowerShell or CMD is used.
- Review and expand Linux-specific documentation sections (such as Oryx build automation) to match the detail and clarity given to Windows/Kudu.