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 551-575 of 2121 flagged pages
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 provides both Linux and Windows instructions for most tasks, but there are several areas where Windows is prioritized or receives more detailed coverage. Windows-specific tools and patterns (such as Kudu, Advanced Tools, and web.config) are referenced, sometimes without Linux equivalents or with less detail for Linux. Some sections, like Java Flight Recorder usage, provide more step-by-step guidance for Windows (e.g., using Kudu Process Explorer), while Linux instructions assume more familiarity. In a few places, Windows is mentioned first or exclusively, and some advanced configuration notes are only present for Windows.
Recommendations
- Ensure that for every Windows-specific tool or workflow (e.g., Kudu, Advanced Tools, web.config), an equivalent Linux approach is described, or explicitly state if not applicable.
- Balance the order of presentation: alternate between Linux-first and Windows-first, or present both platforms in parallel.
- Provide equally detailed, step-by-step instructions for Linux as are given for Windows, especially for advanced diagnostics and configuration (e.g., finding Java process IDs, using SSH, log file locations).
- Where Windows-specific notes are given (such as not needing web.config for Tomcat), add corresponding Linux notes or clarify if not needed.
- Audit for any missing Linux examples, especially in sections where only Windows tools or paths are referenced, and add Linux equivalents.
- Review terminology to avoid implying Windows is the default or primary platform (e.g., avoid phrases like 'on Windows you can...' without a Linux counterpart).
Create Pull Request
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/configure-encrypt-at-rest-using-cmk.md
...les/app-service/configure-encrypt-at-rest-using-cmk.md
High Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Missing Linux Example
Summary
The documentation page demonstrates a moderate Windows bias. It references Azure Storage Explorer with a direct link to Windows-specific instructions for generating an SAS, and does not provide equivalent Linux or cross-platform alternatives for this step. All command-line examples use Azure CLI, which is cross-platform, but the only GUI tool mentioned is Storage Explorer with a Windows tab. There are no Linux-specific examples or notes about using Storage Explorer on Linux/macOS, nor are alternative Linux-native tools (such as azcopy or command-line SAS generation) discussed.
Recommendations
- Provide explicit instructions or links for generating SAS tokens using Azure CLI or azcopy, which are cross-platform, instead of referencing only the Storage Explorer Windows tab.
- Mention that Azure Storage Explorer is available on Linux and macOS, and provide relevant links or instructions for those platforms.
- Ensure that all GUI tool instructions are either cross-platform or are supplemented with equivalent Linux/macOS command-line alternatives.
- Avoid linking directly to Windows-specific tabs or documentation unless cross-platform alternatives are equally highlighted.
- Add a note or section for Linux/macOS users on how to perform each step, especially for uploading files and generating SAS tokens.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/app-service-best-practices.md
...ain/articles/app-service/app-service-best-practices.md
High Priority
View Details →
Detected Bias Types
Windows First
Missing Linux Example
Windows Tools
Summary
The documentation page demonstrates a subtle Windows bias. It references Windows-specific configuration files (web.config), mentions iisnode settings for Node.js apps (which are relevant only to Windows hosting), and lacks equivalent Linux configuration examples or references. While there is a brief mention of using PM2 on Linux, the overall guidance and troubleshooting sections focus on Windows tools and patterns, with Linux alternatives either missing or presented secondarily.
Recommendations
- Provide Linux-specific configuration examples alongside Windows ones, such as using app settings or environment variables instead of web.config.
- Include guidance for Node.js hosting on Linux (e.g., using PM2, configuring process managers, and relevant settings) in parity with iisnode/Windows guidance.
- When referencing tools or configuration files (like web.config or iisnode), clarify their platform scope and offer Linux equivalents (e.g., startup scripts, ecosystem.config.js for PM2).
- Ensure troubleshooting and diagnostics sections mention both Windows and Linux approaches where applicable.
- Review the order of presentation to avoid always listing Windows/Windows tools first; alternate or present both together.
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-style paths (e.g., D:\home\site\wwwroot) before Linux equivalents, and by providing detailed operational instructions (such as directory creation and file placement) only for Windows paths. There is a lack of Linux-specific examples or explicit parity in instructions, and Windows directory conventions are used throughout, with Linux paths mentioned only in passing.
Recommendations
- Provide Linux-specific examples and paths (e.g., /home/site/wwwroot) alongside Windows examples in all relevant sections.
- When describing operational steps (such as manually creating directories or files), include both Windows and Linux commands (e.g., mkdir for Windows and Linux).
- Ensure that all references to file paths, deployment locations, and troubleshooting steps are presented for both Windows and Linux environments, not just Windows.
- Explicitly state any differences in behavior or requirements between Windows and Linux App Service plans.
- Add example commands using Bash or other Linux-native tools where appropriate, not just Azure CLI.
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
Powershell Heavy
Windows Tools
Summary
The documentation page demonstrates a strong Windows bias. All migration tools and examples focus exclusively on migrating from Windows environments, specifically from IIS servers. The only scripts and automation mentioned are PowerShell-based, with no mention of Bash, Linux CLI, or Linux-native tools. The App Service Migration Assistant and related resources are only described for Windows workloads. There are no examples or guidance for migrating .NET apps from Linux servers or using Linux-based tools, and Windows terminology and tooling are always mentioned first or exclusively.
Recommendations
- Add explicit guidance and examples for migrating .NET apps hosted on Linux servers (e.g., Apache, Nginx, Kestrel).
- Provide Linux-native tooling or scripts (e.g., Bash scripts) for discovery, assessment, and migration, and document their usage.
- Include parity in documentation tables and sections for Linux-based migration scenarios, not just Windows/IIS.
- Mention cross-platform tools and approaches, such as Azure CLI or containerization workflows that work on both Windows and Linux.
- Ensure that migration assistant tools and documentation clarify their platform support and, if possible, expand support for Linux workloads.
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 exhibits a moderate Windows bias. Windows is mentioned first in SKU availability examples, and Azure PowerShell (a Windows-centric tool) is given equal prominence to Azure CLI for automation, without mentioning Linux-native scripting or shell examples. The use of PowerShell as a primary automation example and the ordering of Windows before Linux in several sections reinforce this bias. There are no explicit Linux shell (bash) or scripting examples beyond the Azure CLI, and the documentation does not address Linux-specific concerns or patterns outside of a single CLI flag.
Recommendations
- Alternate the order of Windows and Linux examples, or present Linux examples first where appropriate.
- Provide bash or shell scripting examples for automation, not just Azure CLI and PowerShell.
- Explicitly mention that Azure CLI commands work cross-platform and can be run natively on Linux/macOS, not just in Cloud Shell.
- Include Linux-specific troubleshooting or configuration notes where relevant.
- Ensure parity in screenshots and UI walkthroughs for both Windows and Linux app scenarios.
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 only PowerShell scripts for advanced resource discovery (e.g., identifying Traffic Manager endpoints), referencing PowerShell as the primary scripting tool, and omitting equivalent Bash or cross-platform CLI script examples. While Azure CLI and REST API commands are mentioned for certificate management, all automation and scripting guidance defaults to PowerShell, which is Windows-centric. There are no Linux shell (Bash) or cross-platform scripting examples, and PowerShell is introduced before or instead of alternatives.
Recommendations
- Provide equivalent Bash (Azure CLI) scripts for all PowerShell automation examples, especially for resource discovery and Traffic Manager endpoint identification.
- When referencing scripts, explicitly state if they are cross-platform or provide both Windows (PowerShell) and Linux (Bash) versions.
- Instruct users on how to use Azure CLI for all scenarios where PowerShell is currently recommended, ensuring parity for Linux and macOS users.
- Where possible, use Azure CLI as the primary example, as it is cross-platform, and mention PowerShell as an alternative.
- Review all external script references (e.g., GitHub) and ensure that Linux-compatible versions or instructions are available and linked.
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 scenarios, such as .NET apps running on Kestrel, Apache, or Nginx, nor are there examples or guidance for discovering .NET apps on Linux servers. All tools and workflows referenced (Azure Migrate appliance, IIS) are Windows-specific.
Recommendations
- Include information and examples for discovering .NET web apps hosted on Linux servers, such as those running on Kestrel, Apache, or Nginx.
- Describe whether Azure Migrate supports Linux-based .NET app discovery, and if so, provide equivalent instructions and tooling.
- Mention Linux environments explicitly in the overview and capabilities sections, or clarify if the feature is Windows-only.
- Provide parity in documentation by adding Linux-focused discovery scenarios, error handling, and remediation steps.
- Reference Linux tools and patterns where applicable, and ensure that links to further reading include Linux scenarios.
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 is a subtle Windows bias in several areas. Windows examples and tools (such as Kudu, Advanced Tools, and FTPS) are sometimes mentioned first or exclusively, and some instructions (like using Kudu Process Explorer) are Windows-specific without Linux equivalents. The documentation also refers to Windows-specific behaviors (e.g., web.config, C:\ paths) and tools before or more prominently than Linux alternatives. In a few cases, Linux troubleshooting or deployment patterns are less detailed or referenced only in passing.
Recommendations
- Ensure that for every Windows-specific tool or workflow (e.g., Kudu, Advanced Tools, FTPS), there is a clearly documented Linux equivalent or a note if not applicable.
- When listing commands or procedures, alternate the order or present Linux and Windows in parallel tabs to avoid always leading with Windows.
- Provide Linux-specific troubleshooting and process management guidance where Windows uses Kudu or other Windows-centric tools.
- Review all sections for parity in detail and clarity between Linux and Windows, especially for advanced scenarios (e.g., process management, file downloads, and configuration).
- Where a feature is not available or behaves differently on Linux, explicitly state this and suggest alternatives or workarounds.
- Avoid referencing Windows file paths (e.g., C:\home) or configuration files (e.g., web.config) without providing the Linux equivalent or clarifying their relevance.
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 referencing Visual Studio and its NuGet package manager as the primary method for installing dependencies, with CLI instructions mentioned only as an alternative. There are no explicit Linux or cross-platform development environment examples, and the workflow assumes the use of Windows-centric tools and patterns (e.g., right-clicking folders in Visual Studio). No Linux-specific instructions, screenshots, or terminal commands are provided for common tasks such as file creation, navigation, or deployment.
Recommendations
- Include explicit Linux/macOS instructions for all steps, such as using the dotnet CLI for project/file creation and package installation.
- Present CLI-based examples before or alongside Visual Studio/GUI instructions to ensure parity.
- Add notes or sections for common Linux development environments (e.g., VS Code, JetBrains Rider, or terminal-only workflows).
- Replace or supplement 'right-click' and GUI navigation steps with equivalent command-line instructions (e.g., 'dotnet new page', 'touch OpenAI.razor').
- Provide deployment and environment variable configuration steps using Azure CLI and/or ARM templates, not just Azure Portal.
- Ensure screenshots and code snippets reflect both Windows and Linux file paths and conventions where relevant.
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 page is heavily biased towards Windows environments. All examples, configuration settings, and troubleshooting steps are specific to Azure App Service on Windows, with exclusive references to Windows tools (IIS, iisnode, web.config, named pipes, Win32 error codes, PowerShell, CMD, etc.). There are no Linux or cross-platform equivalents provided, and Linux-based deployment or troubleshooting is not mentioned.
Recommendations
- Provide parallel documentation or sections for Node.js on Azure App Service for Linux, including configuration, troubleshooting, and best practices.
- Include Linux-specific examples (e.g., using PM2, nginx, or Kudu Bash console) alongside or before Windows examples.
- Mention Linux equivalents for Windows tools and patterns (e.g., systemd, environment variables, log file locations, error codes).
- Avoid assuming the use of web.config, iisnode, or named pipes; instead, describe cross-platform approaches or clearly indicate when a step is Windows-only.
- Add links to Linux-focused documentation or guides for Node.js on Azure App Service.
- Balance screenshots and walkthroughs between Windows and Linux environments.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/app-service-configure-premium-v3-tier.md
...s/app-service/app-service-configure-premium-v3-tier.md
High Priority
View Details →
Detected Bias Types
Windows First
Powershell Heavy
Windows Tools
Summary
The documentation demonstrates a mild Windows bias by presenting Windows-related information and tools before their Linux equivalents. In the 'Premium V3 availability' section, the Windows SKU availability command is listed before the Linux one. The automation section provides both Azure CLI (cross-platform) and Azure PowerShell (Windows-centric) examples, but the PowerShell example is given equal prominence, despite PowerShell being less common on Linux. The UI instructions and screenshots are based on the Azure Portal, which is platform-agnostic, but no mention is made of Linux-specific considerations or tools beyond the CLI command.
Recommendations
- Present Linux and Windows options in parallel or alternate their order to avoid always listing Windows first.
- Clarify that Azure PowerShell is available cross-platform, but note its prevalence on Windows and suggest Bash/CLI for Linux users.
- Add explicit Linux-focused automation examples, such as Bash scripts or references to ARM/Bicep templates, to balance the PowerShell example.
- Where relevant, mention any Linux-specific considerations or differences in the scaling process.
- Ensure that all command-line examples are clearly labeled for their intended platform, and consider providing more Linux-native context where possible.
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
Missing Linux Example
Windows Tools
Powershell Heavy
Summary
The documentation demonstrates a Windows bias in several ways: examples and templates are primarily focused on ASP.NET and .NET (Windows-centric stacks), Web Deploy (a Windows-only deployment method) is featured with explicit instructions and troubleshooting, and the use of Windows agents is assumed or required for certain deployment scenarios. Linux-specific deployment methods or troubleshooting are not equivalently covered, and Linux is only mentioned in passing (e.g., 'webAppLinux' as an app type), without dedicated examples or guidance for common Linux workflows.
Recommendations
- Provide parallel Linux-focused examples for all deployment scenarios, especially for stacks commonly deployed on Linux (Node.js, Python, Java).
- Include troubleshooting sections for Linux agents, not just Windows (e.g., what to do if a deployment fails on Ubuntu agents).
- Clearly indicate when a feature or task is Windows-only and offer Linux alternatives where possible (e.g., use of ZIP Deploy or FTP for Linux).
- Balance the order of presentation so that Linux and Windows options are given equal prominence, rather than defaulting to Windows-first.
- Add explicit examples of deploying to Linux App Service using Linux agents, including YAML snippets and agent pool configuration.
- Where Windows tools (like Web Deploy) are discussed, provide equivalent Linux-native deployment methods and their configuration.
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 page exhibits a Windows-first bias in several areas. Windows-specific paths (e.g., D:\home), tools (e.g., msbuild, Web Deploy/MSDeploy), and environment variables are often mentioned before or instead of their Linux equivalents. Some examples and defaults are provided only for Windows (such as time zones and logging), and Windows-specific behaviors are described in more detail. Linux-specific information is sometimes present but often appears as an afterthought or is less detailed. There are also references to Windows tools and patterns (like applicationHost.config, w3wp.exe, and .bat files) without equivalent Linux guidance or examples.
Recommendations
- For every Windows-specific example, provide a Linux equivalent (e.g., show both D:\home and /home paths).
- When referencing tools like msbuild or Web Deploy, mention Linux build/deployment tools (e.g., Oryx, Kudu for Linux) and provide parity in explanation.
- Avoid using Windows paths or environment variable syntax exclusively in examples; always show both Windows and Linux formats.
- When describing settings that behave differently on Windows and Linux, present both behaviors side by side, not with Windows first.
- Add Linux-specific troubleshooting and operational guidance where only Windows details are currently given (e.g., for logging, crash monitoring, or startup behaviors).
- Review all variable descriptions for implicit Windows assumptions (such as references to .bat files, applicationHost.config, or w3wp.exe) and clarify or supplement with Linux/container equivalents.
- Ensure that links to further documentation or references are available for both Windows and Linux scenarios.
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 shows a moderate Windows bias, particularly in the .NET/ASP.NET section, where Windows tools (Visual Studio, Azure PowerShell) are listed before cross-platform or Linux-native options. Some quickstart links default to Windows or PowerShell tabs, and Windows-specific tools are mentioned without always providing Linux equivalents. In the Python section, quickstart links include 'windows' in their tab parameters, which may prioritize Windows instructions. The 'Next step' call-to-action also promotes an ASP.NET (typically Windows-centric) workflow.
Recommendations
- Ensure that for every Windows/Powershell example or tool, an equivalent Linux/CLI example is provided and given equal prominence.
- Reorder tool lists so that cross-platform or Linux-native tools (e.g., CLI, Visual Studio Code) are mentioned before or alongside Windows-specific tools (e.g., Visual Studio, PowerShell).
- Review quickstart links and tab defaults to ensure they do not default to Windows or PowerShell, but rather offer a choice or default to cross-platform instructions.
- In the Python section, provide explicit Linux/macOS instructions or clarify that the steps are cross-platform if that is the case.
- Balance the 'Next step' call-to-action by offering a Linux-friendly or cross-platform example, not just an ASP.NET (Windows-centric) workflow.
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 examples are often presented first or exclusively, especially in troubleshooting and management sections. PowerShell commands are provided for connectivity testing, but equivalent Linux commands are missing. The GUI management experience is only available for Windows, with Linux users limited to CLI. Some troubleshooting steps and tool recommendations are Windows-centric, and Linux parity is not always addressed or is relegated to secondary status.
Recommendations
- Provide Linux command equivalents wherever PowerShell or Windows-specific commands are shown (e.g., use 'nc' or 'telnet' for TCP connectivity testing on Linux).
- When listing instructions or examples, alternate the order or present both Windows and Linux examples side-by-side to avoid 'windows_first' bias.
- Expand troubleshooting guidance to include Linux-native tools and commands (e.g., 'ss', 'netcat', 'dig', 'host' for DNS and connectivity checks).
- Clarify GUI limitations for Linux and suggest open-source or CLI alternatives where possible.
- Ensure all sections that mention Windows tools or patterns also mention their Linux equivalents, or explicitly state when a feature is unavailable on Linux.
- Consider adding a summary table of feature parity between Windows and Linux for Hybrid Connection Manager capabilities.
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 discovery examples use Windows file paths and Kudu's CMD/PowerShell consoles, with no mention of Linux-based App Service environments or their equivalents. There are no Linux-specific instructions or examples, and Windows tools and patterns (such as Visual Studio and web.config) are referenced throughout without Linux parity.
Recommendations
- Add equivalent instructions and examples for Linux-based App Service environments, such as using SSH or Bash in Kudu for Linux.
- Include Linux file paths and commands for checking installed .NET runtimes in Linux containers or App Service on Linux.
- Clarify which instructions apply only to Windows App Service plans and provide parallel guidance for Linux plans.
- Mention and provide examples for deploying and configuring ASP.NET apps using cross-platform tools (e.g., dotnet CLI) where possible.
- Reference Linux-specific configuration files or patterns (e.g., appsettings.json for ASP.NET Core on Linux) where appropriate.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/configure-encrypt-at-rest-using-cmk.md
...les/app-service/configure-encrypt-at-rest-using-cmk.md
High Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Missing Linux Example
Summary
The documentation demonstrates a mild Windows bias by referencing Azure Storage Explorer with a direct link to its Windows tab for generating SAS tokens, and by not mentioning or providing Linux-native alternatives for uploading files or generating SAS tokens. All command-line examples use Azure CLI, which is cross-platform, but there are no explicit Linux/macOS instructions or examples for storage management tasks that are shown via Storage Explorer. This may leave Linux users without clear guidance for those steps.
Recommendations
- Provide explicit instructions or examples for uploading files and generating SAS tokens using cross-platform or Linux-native tools, such as the Azure CLI (az storage blob upload, az storage blob generate-sas) or REST API.
- Avoid linking directly to Windows-specific tabs or instructions in tool documentation; instead, reference cross-platform guides or clarify that Storage Explorer is available on multiple platforms.
- Add a note or section highlighting Linux/macOS workflows for the relevant steps, ensuring parity and clarity for non-Windows users.
- If GUI tools are mentioned, also provide equivalent command-line alternatives suitable for headless or Linux environments.
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 noticeably more detailed, with extensive PowerShell scripting and Windows-specific patterns (e.g., use of startup.cmd, configure.ps1, and %HOME% variables). The Windows instructions are longer, more explicit, and introduce Windows tools and patterns (PowerShell, CMD scripting) that have no direct Linux equivalent in the documentation. While Linux instructions are present and functional, the Windows approach is more thoroughly explained and uses Windows-native tools, which may disadvantage Linux users seeking parity.
Recommendations
- Provide equally detailed, step-by-step Linux instructions for customizing Tomcat, including example shell scripts for startup automation, not just high-level descriptions.
- Offer Linux-native equivalents for Windows tools (e.g., show how to automate the server.xml transformation and Tomcat copying using Bash or shell scripts, not just mention 'startup script').
- Balance the length and depth of Linux and Windows sections to avoid the impression that Windows is the primary or preferred platform.
- Where PowerShell is used for Windows, provide Bash or shell script equivalents for Linux, including error handling and idempotency.
- Explicitly mention and link to Linux-specific tools or best practices for managing configuration files and environment variables.
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 patterns throughout. There are no Linux-specific examples or equivalent Linux paths provided. The only mention of Linux is in the context of unsupported scenarios, and all operational instructions and folder structures are described using Windows conventions. Additionally, tools like Kudu are referenced without mention of KuduLite or Linux alternatives, and the only tool suggested for disk usage is a Windows-centric site extension.
Recommendations
- Include Linux-specific examples and folder paths (e.g., /home/site) alongside Windows paths.
- Clarify how local cache works (or does not) on Linux-based App Service plans, and provide parity in operational instructions where possible.
- Reference KuduLite and provide instructions or links relevant to Linux App Service environments.
- When mentioning tools like 'Azure Web Apps Disk Usage', specify if they are available and how to use them on Linux App Service.
- Add a section or callouts for Linux users, even if only to clarify limitations and suggest alternatives (such as App Cache for containers and Linux).
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-specific tools (such as SQL Server Management Studio and Visual Studio), provides detailed publishing instructions for Visual Studio before mentioning Git Bash, and omits Linux-native alternatives for some tasks (e.g., connecting to SQL Database with sqlcmd or Azure Data Studio on Linux). There are no explicit PowerShell examples, but the overall workflow assumes a Windows-centric development environment, especially for code publishing and database management.
Recommendations
- Include explicit instructions and examples for Linux users, such as using Azure Data Studio or sqlcmd on Linux for database management.
- Provide parity in publishing instructions, giving equal prominence to cross-platform tools (e.g., VS Code, Git CLI) alongside Visual Studio.
- Mention and demonstrate Linux-compatible workflows for all steps, including local debugging and deployment.
- When referencing tools like SQL Server Management Studio, always mention cross-platform alternatives (e.g., Azure Data Studio) and provide links.
- Ensure that all CLI examples are tested and work on both Windows and Linux shells, and clarify any OS-specific prerequisites.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/overview-vnet-integration.md
...main/articles/app-service/overview-vnet-integration.md
High Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Missing Linux Example
Summary
The documentation page demonstrates a subtle Windows bias. Windows-specific features (such as Windows Containers and Windows Server Active Directory) are discussed in detail, with sample calculations and subnet sizing guidance provided only for Windows Containers. There is no equivalent example or detailed guidance for Linux containers or Linux-specific scenarios. Additionally, Windows terminology and tools (e.g., Kudu console, Windows Server AD) are mentioned without Linux alternatives or parity. Linux is only briefly mentioned in the context of continuous deployment network dependencies, and there are no Linux-specific configuration examples or troubleshooting notes.
Recommendations
- Add equivalent subnet sizing and resource planning guidance for Linux containers, including sample calculations.
- Provide Linux-specific examples or notes where Windows-specific features are discussed (e.g., mention Linux authentication options when discussing Windows Server AD).
- Include references to Linux-native tools or consoles (such as SSH or Bash) alongside mentions of the Kudu console.
- Ensure that all configuration and troubleshooting steps are platform-agnostic or provide parallel instructions for both Windows and Linux scenarios.
- Where Windows-specific limitations or features are listed, clarify whether they apply to Linux as well, and add Linux-specific limitations if any.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/manage-scale-per-app.md
...blob/main/articles/app-service/manage-scale-per-app.md
High Priority
View Details →
Detected Bias Types
Powershell Heavy
Missing Linux Example
Windows Tools
Windows First
Summary
The documentation page demonstrates a strong Windows bias by exclusively providing PowerShell examples for per-app scaling, with no equivalent examples for Linux-native tools or shells (such as Bash, Azure CLI, or REST API). The use of PowerShell cmdlets (New-AzAppServicePlan, Set-AzAppServicePlan, Get-AzWebApp, Set-AzWebApp) assumes a Windows or PowerShell Core environment. There are no examples or guidance for users on Linux or macOS, nor are cross-platform tools mentioned first or at all.
Recommendations
- Add Azure CLI examples for all PowerShell commands, as Azure CLI is cross-platform and widely used on Linux and macOS.
- Include Bash shell script examples where appropriate, especially for scripting scenarios.
- Mention REST API options for configuring per-app scaling, with example requests.
- Present cross-platform (CLI or REST) examples before or alongside PowerShell examples to avoid Windows-first ordering.
- Clearly indicate which tools are cross-platform and which are Windows-specific, guiding users to the best option for their OS.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/troubleshoot-performance-degradation.md
...es/app-service/troubleshoot-performance-degradation.md
High Priority
View Details →
Detected Bias Types
Powershell Heavy
Windows Tools
Windows First
Missing Linux Example
Summary
The documentation page demonstrates a Windows bias by focusing on Windows-centric tools and patterns, such as IIS diagnostics, PowerShell, and SysInternals Procdump, without providing equivalent Linux guidance. The Kudu Debug Console section highlights PowerShell and DOS commands, and references to diagnostic features (like Application Insights Profiler) are linked specifically to Windows instructions. There are no Linux-specific troubleshooting steps, examples, or mentions of Linux-native tools, despite Azure App Service supporting Linux.
Recommendations
- Add Linux-specific troubleshooting steps and examples, such as using SSH for diagnostics, Linux log file locations, and Linux-native tools (e.g., strace, lsof, top).
- When referencing diagnostic features (e.g., Application Insights Profiler), provide links and instructions for both Windows and Linux App Service environments.
- In sections mentioning Kudu, clarify the differences in available commands and tools between Windows and Linux App Service plans, and provide Linux shell (bash) examples.
- Avoid referencing only Windows tools (e.g., Procdump, IIS logs) without mentioning Linux equivalents or alternatives.
- Ensure parity in examples and guidance for both Windows and Linux App Service users throughout the 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 page demonstrates a Windows-first bias in several areas: logging types and features are described with Windows as the primary or only platform, with Linux support mentioned secondarily or omitted. Several logging features (web server logging, detailed error messages, failed request tracing) are described as Windows-only, with no Linux equivalents or workarounds provided. Example tools and file paths are often Windows-centric, and some features (like writing application logs to blob storage) are noted as unavailable for non-.NET (and thus often non-Windows) stacks. Linux-specific instructions are minimal and lack parity in detail and options.
Recommendations
- Provide Linux-specific examples and instructions for all logging types, or clearly state feature parity gaps and suggest alternatives.
- Where features are Windows-only (e.g., web server logging, detailed error messages, failed request tracing), offer Linux workarounds or third-party tool suggestions.
- Include Linux file paths and usage patterns alongside Windows ones in all relevant sections (e.g., log file locations, Kudu usage).
- If certain features (like application logging to blob storage) are not supported on Linux, provide code samples or links to community solutions for implementing similar functionality.
- Balance the order of presentation: do not always present Windows instructions first; alternate or group by platform.
- Expand 'Add log messages in code' with Linux/OSS stack examples (Node.js, Java, PHP, Python) and logging best practices for those environments.