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 601-625 of 2121 flagged pages
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 demonstrates a Windows-centric bias by emphasizing Windows-specific tools (IIS, Procdump, PowerShell), referencing Windows-only features (such as .NET Profiler for Windows), and omitting Linux-specific troubleshooting steps or examples. The Kudu console section highlights PowerShell and DOS commands, with no mention of Bash or Linux shell. There are no Linux-specific diagnostic or logging instructions, and the documentation links to Windows-focused resources.
Recommendations
- Include equivalent Linux troubleshooting steps and examples, such as using Bash in Kudu, Linux-specific diagnostic tools, and log file locations.
- When mentioning PowerShell or DOS commands, also provide Bash or shell command equivalents for Linux-based App Service environments.
- Reference both Windows and Linux in tool descriptions and links (e.g., Application Insights Profiler availability and setup for Linux).
- Add guidance for enabling and accessing logs and diagnostics on Linux App Service plans, including differences in log formats and locations.
- Ensure that external links and references (such as to Procdump or IIS features) are balanced with Linux alternatives or clearly indicate platform applicability.
Create Pull Request
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 exhibits a Windows-first bias: logging features and instructions for Windows apps are presented in greater detail and before Linux equivalents. Several logging types (web server logging, detailed error messages, failed request tracing) are described as Windows-only, with no Linux alternatives or workarounds provided. Example code and tool recommendations (such as Log Parser and references to IIS/W3C log formats) are Windows-centric. Linux logging instructions are brief and lack parity in detail or features.
Recommendations
- Provide equivalent Linux/container logging features or clearly document alternatives/workarounds for Linux users.
- Present Linux and Windows instructions in parallel sections or tables to avoid Windows-first ordering.
- Include Linux-specific examples and code snippets (e.g., using Python logging, Node.js logging, or Linux command-line tools to access logs).
- Mention cross-platform tools for log analysis instead of or alongside Windows-only tools like Log Parser.
- Clarify any feature gaps for Linux and suggest best practices or third-party solutions where Azure App Service does not provide parity.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/app-service-configure-premium-v4-tier.md
...s/app-service/app-service-configure-premium-v4-tier.md
High Priority
View Details →
Detected Bias Types
Windows First
Powershell Heavy
Windows Tools
Missing Linux Example
Summary
The documentation demonstrates a Windows bias by frequently presenting Windows-related information and tools before Linux equivalents, providing PowerShell automation examples but omitting Bash/Linux shell examples, and referencing Windows-specific patterns and terminology. While Linux is mentioned, there is a lack of parity in scripting examples and some instructions are more detailed for Windows users.
Recommendations
- Provide Bash or shell script examples alongside PowerShell for automation, especially in the 'Automate with scripts' section.
- Ensure that Linux-specific instructions (such as for custom containers) are as detailed as Windows instructions.
- When listing availability or features, avoid listing Windows first by default; alternate or provide both together.
- Clarify any differences in behavior or limitations for both Windows and Linux, not just Windows.
- Include screenshots or walkthroughs for Linux-based workflows where applicable, not just portal-based or Windows-centric flows.
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
Missing Linux Example
Windows Tools
Powershell Heavy
Summary
The documentation is heavily focused on Windows environments, specifically Azure App Service on Windows with iisnode. All configuration, troubleshooting, and examples are tailored to Windows, referencing Windows-specific tools (e.g., iisnode, web.config, named pipes, Win32 error codes, Kudu CMD/PowerShell). There are no Linux equivalents or cross-platform guidance, and Linux-specific scenarios or tools are not mentioned or linked.
Recommendations
- Add a parallel section or page for Node.js on Azure App Service for Linux, including best practices and troubleshooting steps relevant to Linux environments.
- Provide Linux-specific configuration and troubleshooting examples (e.g., using PM2, NGINX/Apache, Linux file paths, environment variables).
- Include examples of accessing logs, debugging, and profiling on Linux-based App Service (e.g., using SSH, Bash, Linux log directories).
- Reference Linux tools and patterns (such as systemd, journalctl, Bash scripts) alongside or before Windows tools where appropriate.
- Clearly indicate at the top of the page that the content is Windows-specific, and provide links to Linux documentation for parity.
- Avoid assuming the use of Windows-only features (like web.config, named pipes, Win32 error codes) without offering Linux alternatives or explanations.
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 subtle Windows bias by referencing Windows-specific tools (such as web.config and iisnode) without providing equivalent Linux-native guidance or examples. The configuration and troubleshooting sections mention Windows-centric patterns first or exclusively, and there is a lack of parity in examples or instructions for Linux-based App Service environments.
Recommendations
- For features like auto-healing, provide Linux-native configuration guidance (e.g., reference app settings, environment variables, or Linux-specific config files) alongside web.config instructions.
- When mentioning iisnode or web.config for Node.js apps, include equivalent Linux process managers (such as PM2, systemd, or environment-based configuration) and clarify which settings apply to Linux vs. Windows App Service.
- Add explicit Linux examples or notes in all sections where only Windows tools or patterns are mentioned, ensuring that users running on Linux App Service have clear, actionable instructions.
- Review and update troubleshooting and best practices sections to ensure both Windows and Linux App Service environments are addressed equally, ideally with side-by-side examples.
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 environments, specifically IIS servers, with no mention of Linux-based web servers or cross-platform migration scenarios. PowerShell scripts are the only automation method referenced, and all downloadable tools are for Windows. There are no Linux or cross-platform migration tools, examples, or guidance provided.
Recommendations
- Include migration scenarios and tools for Linux-based .NET web apps (e.g., apps hosted on Apache, Nginx, or Kestrel on Linux).
- Provide Linux shell (bash) script equivalents for PowerShell automation tasks.
- Mention and document any cross-platform or Linux-compatible migration tools, or clarify if such tools do not exist.
- Add examples and walkthroughs for migrating .NET apps from Linux environments to Azure App Service.
- Ensure that documentation tables and tool lists explicitly state platform compatibility and provide parity where possible.
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 and tools (such as the GUI and PowerShell) are often mentioned first or exclusively, with Linux alternatives provided later or not at all. Troubleshooting and connectivity testing examples use Windows-specific tools (e.g., PowerShell's Test-NetConnection) without equivalent Linux commands. The Hybrid Connection Manager GUI is only available on Windows, and this is not always clearly signposted early. Some management and troubleshooting steps assume a Windows environment, and Linux users are sometimes directed to less-featured CLI alternatives.
Recommendations
- Ensure all command-line examples (e.g., connectivity tests) are provided for both Windows (PowerShell) and Linux (bash), such as including 'nc', 'curl', or 'telnet' commands alongside 'Test-NetConnection'.
- When listing instructions or tools, avoid always listing Windows first; alternate or present both platforms in parallel.
- Clearly state at the top of relevant sections when a feature (like the GUI) is Windows-only, and provide equivalent CLI workflows for Linux users.
- In troubleshooting sections, provide Linux-native diagnostic steps (e.g., 'nslookup', 'dig', 'nc', 'curl') alongside Windows ones.
- Where screenshots or UI steps are Windows-only, provide CLI or text-based alternatives for Linux users.
- Review for any missing Linux-specific guidance, especially for installation, upgrades, and management, and ensure parity with Windows instructions.
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. For example, in the 'Premium V3 availability' section, the Windows SKU availability command is listed before the Linux command. The automation section provides both Azure CLI and Azure PowerShell examples, but PowerShell (a Windows-centric tool) is given equal prominence, and no Linux shell-specific scripting (e.g., bash) is shown. The UI walkthroughs and screenshots are based on the Azure Portal, which is platform-agnostic, but there are no explicit Linux-native instructions or examples beyond the CLI command with --linux-workers-enabled.
Recommendations
- Present Linux and Windows options in parallel or alternate their order to avoid always listing Windows first.
- Include bash or shell script examples for Linux users alongside PowerShell examples.
- Explicitly mention that Azure CLI commands work cross-platform, and provide examples of running them in both Windows and Linux environments.
- Where possible, add screenshots or notes relevant to Linux users (e.g., using Azure CLI in a Linux terminal).
- Clarify in the automation section that PowerShell is optional and not required for Linux users.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/app-service-managed-certificate-changes-july-2025.md
...e/app-service-managed-certificate-changes-july-2025.md
High Priority
View Details →
Detected Bias Types
Powershell Heavy
Windows Tools
Missing Linux Example
Windows First
Summary
The documentation page shows a moderate Windows bias, particularly in its guidance for identifying impacted resources. PowerShell scripts are recommended and detailed for key scenarios (e.g., identifying Traffic Manager endpoints), but there are no equivalent Bash, Azure CLI, or cross-platform script examples. The only scripting guidance for deep configuration checks points to PowerShell scripts, and instructions for running them assume a Windows/PowerShell environment. While Azure CLI and REST API references are present for certificate management, the diagnostic and automation examples are Windows-centric, and Linux/macOS users are left without parity.
Recommendations
- Provide equivalent Bash or cross-platform (e.g., Python, Azure CLI) scripts for all PowerShell script recommendations, especially for identifying Traffic Manager endpoints and retrieving site config values.
- When referencing scripts, clarify platform compatibility and offer both Windows (PowerShell) and Linux/macOS (Bash/CLI) options.
- Include explicit Azure CLI examples for all automation and diagnostic tasks, not just for certificate management.
- Avoid assuming the user has access to PowerShell or a Windows environment; mention how Linux/macOS users can achieve the same results.
- Where possible, link to or provide scripts that can be run in Azure Cloud Shell, which supports both Bash and PowerShell, and clarify usage for both shells.
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 exclusively discusses discovery of .NET web apps deployed on IIS web servers within VMware environments, which are Windows-specific technologies. There are no mentions of Linux-based web servers (such as Apache or Nginx), nor are there any examples or guidance for discovering .NET apps running on Linux. All tools and patterns referenced (IIS, Azure Migrate appliance for IIS) are Windows-centric.
Recommendations
- Include information on discovering .NET web apps hosted on Linux servers, such as those running on Apache, Nginx, or Kestrel.
- Provide equivalent discovery steps, tooling, or references for Linux environments.
- Add examples or case studies for .NET Core/ASP.NET Core apps deployed on Linux, reflecting modern cross-platform .NET usage.
- Clarify in the introduction if the discovery process is currently limited to IIS/Windows, and provide a roadmap or links for Linux support 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 subtle Windows bias by referencing Windows-specific tools (Azure Storage Explorer) and providing instructions that are either Windows-centric or lack Linux alternatives. The only tool-specific example for generating a SAS is linked with a Windows tab, and there is no mention of Linux-native tools or cross-platform alternatives for file upload or SAS generation. All command-line examples use Azure CLI, which is cross-platform, but the supporting tooling and workflow references are Windows-first.
Recommendations
- Include explicit instructions or links for performing key tasks (such as uploading files and generating SAS tokens) using Linux-native tools (e.g., Azure CLI, azcopy, or REST API) alongside Storage Explorer.
- When referencing GUI tools like Azure Storage Explorer, clarify their cross-platform availability and provide screenshots or instructions for both Windows and Linux (and macOS) where applicable.
- Avoid linking to documentation with Windows-specific tabs by default; ensure parity by linking to generic or cross-platform instructions.
- Mention and provide examples for using azcopy or Azure CLI for file uploads and SAS generation, which are fully cross-platform.
- Audit all steps to ensure that Linux users are not left to infer or research alternative workflows.
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 project root location and only providing a Windows example for where to place the configuration file. Linux is mentioned only in a note, with no Linux-specific example or illustration. The documentation also refers to Windows paths and conventions before Linux, and does not provide equivalent Linux command-line or file path examples.
Recommendations
- Provide both Windows and Linux file path examples when describing where to place the configuration file (e.g., C:\home\site\wwwroot\auth.json for Windows, /home/site/wwwroot/auth.json for Linux).
- Instruct users on how to deploy or locate the configuration file on both Windows and Linux App Service environments.
- When referencing platform-specific behaviors (such as configFilePath requirements), present Linux and Windows information in parallel, rather than Windows first.
- Include Linux-specific notes or examples wherever Windows-specific tools, paths, or conventions are mentioned.
- Consider adding a table or section summarizing differences between Windows and Linux App Service environments for this feature.
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 Windows bias, particularly in the .NET/ASP.NET sections, where Windows tools (Visual Studio, Azure PowerShell) are listed before Linux-friendly or cross-platform options. PowerShell is specifically called out as a deployment tool, but there is no mention of Bash or Linux shell equivalents. In the Python section, 'windows' is present in the tab parameters for CLI and VS Code instructions, and Linux-specific instructions are not clearly prioritized or separated. The 'Next step' call-to-action is for deploying an ASP.NET app, which is most commonly associated with Windows. In contrast, Linux-first or cross-platform approaches are less visible or are listed after Windows-centric tools. Some stacks (PHP, Node.js) do better, but the overall structure and example ordering favor Windows.
Recommendations
- For each stack, ensure that Linux and cross-platform tools (e.g., Azure CLI, Bash, VS Code) are listed before or alongside Windows-specific tools like Visual Studio and PowerShell.
- Where PowerShell is mentioned, also provide equivalent Bash or Azure CLI examples, and make these visible and easy to find.
- In the Python section, clarify and separate Linux and Windows instructions, and avoid defaulting to 'windows' in tab parameters for CLI examples.
- Balance the 'Next step' call-to-action by either making it stack-neutral or providing Linux-friendly options (e.g., 'Deploy a Node.js app on Linux').
- Audit all quickstart and deployment links to ensure Linux parity and that Linux users are not required to adapt Windows-centric instructions.
- Consider adding a table or section summarizing tool parity for Windows and Linux users for each stack.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/configure-language-dotnet-framework.md
...les/app-service/configure-language-dotnet-framework.md
High Priority
View Details →
Detected Bias Types
Windows First
Missing Linux Example
Windows Tools
Powershell Heavy
Summary
The documentation page demonstrates a Windows bias by focusing exclusively on Windows-based deployment and configuration patterns for ASP.NET apps. All runtime version examples reference 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 shell or cross-platform examples, and the documentation assumes the use of Visual Studio and Windows-centric workflows.
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, especially for runtime version discovery and environment variable access.
- Mention and demonstrate cross-platform deployment tools (such as Azure CLI, GitHub Actions, or VS Code) alongside Visual Studio.
- Clarify when instructions or features are Windows-only, and provide links or references to Linux-specific documentation where available.
- Balance the order of presentation so that Linux and Windows approaches are presented together or Linux is not consistently omitted or placed after Windows.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/troubleshoot-diagnostic-logs.md
...n/articles/app-service/troubleshoot-diagnostic-logs.md
High Priority
View Details →
Detected Bias Types
Windows First
Missing Linux Example
Windows Tools
Summary
The documentation demonstrates a Windows-first bias by providing more detailed instructions and features for Windows App Service apps, such as web server logging, detailed error messages, and failed request tracing, which are either unavailable or not documented for Linux apps. Examples and tool mentions (like Log Parser and W3C log formats) are Windows-centric, and Linux-specific guidance is minimal or missing for several logging features.
Recommendations
- Provide equivalent, step-by-step instructions for enabling and accessing web server logging, detailed error messages, and failed request tracing for Linux-based App Service apps, or clearly state if these features are unavailable.
- Include Linux-specific examples and file paths alongside Windows examples, especially in sections describing log file locations and structures.
- Mention and recommend cross-platform or Linux-native tools (e.g., jq, grep, less, or open-source log viewers) for log analysis, not just Windows tools like Log Parser.
- Clarify any feature gaps between Windows and Linux App Service plans up front, and link to Linux-specific troubleshooting/logging documentation where available.
- Ensure parity in code samples for logging (e.g., provide Python, Node.js, or Java examples, not just .NET/ASP.NET).
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 prescriptive, with step-by-step PowerShell and batch script examples. Windows-specific tools and environment variables (e.g., PowerShell, %HOME%, %LOCAL_EXPANDED%) are emphasized, and the Windows workflow is described in greater detail than the Linux equivalent. Linux instructions are present and functional, but the Windows approach is more thoroughly documented and uses Windows-native scripting and tools.
Recommendations
- Provide equally detailed Linux examples, including a full sample startup script (e.g., Bash) for automating Tomcat configuration changes, similar to the PowerShell script for Windows.
- Where Windows-specific tools (PowerShell, batch files) are used, offer direct Linux equivalents (e.g., Bash scripts) and explain their usage.
- Ensure that Linux instructions are as step-by-step and prescriptive as the Windows ones, including troubleshooting tips and environment variable usage.
- Highlight cross-platform approaches (such as using Azure CLI or environment variables) before platform-specific solutions.
- Where possible, use neutral, platform-agnostic terminology and structure (e.g., refer to 'startup scripts' generically, then provide both Bash and PowerShell examples).
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 Visual Studio and GUI-based instructions (e.g., right-clicking folders, using NuGet package manager) without providing equivalent Linux or cross-platform command-line alternatives. There are no explicit Linux or macOS examples for project setup, package installation, or deployment, and the documentation assumes the use of Windows-centric tools and workflows.
Recommendations
- Provide explicit instructions for Linux/macOS users, such as using the dotnet CLI for project/file creation (e.g., 'dotnet new razor', 'dotnet add package').
- Include examples for installing and managing NuGet packages via the command line (dotnet CLI), not just through Visual Studio.
- Replace or supplement GUI-based steps (like 'right-click to add a file') with equivalent CLI commands (e.g., 'touch OpenAI.razor' or 'echo' commands).
- Clarify that all code and deployment steps are cross-platform, and specify any OS-specific differences where relevant.
- Add a section or callouts for deploying and testing the app locally on Linux/macOS, including environment variable management and troubleshooting tips.
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
Windows Tools
Powershell Heavy
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. In some sections, Windows instructions or tools (such as Kudu, FTPS, and web.config) are mentioned specifically or with more detail, and Windows-specific patterns (like using Kudu's Process Explorer) are described before or instead of Linux equivalents. Some advanced troubleshooting and configuration steps are more detailed for Windows, and certain features (like Tomcat baseline configuration) are explicitly marked as Linux-only, with no equivalent Windows guidance. There are also references to Windows-specific tools and conventions (e.g., C:\ paths, web.config, Kudu), and in some cases, Linux command-line or troubleshooting examples are less comprehensive.
Recommendations
- Ensure that all examples and instructions are provided for both Linux and Windows, with equal detail and prominence.
- When mentioning tools like Kudu or FTPS, clarify their availability and usage on both platforms, or provide Linux-native alternatives where appropriate.
- Avoid Windows-first ordering in sections that apply to both platforms; alternate or parallelize instructions for Linux and Windows.
- Where features are Linux-only (such as Tomcat baseline configuration), provide a clear explanation and, if possible, suggest equivalent approaches or workarounds for Windows users.
- Expand Linux troubleshooting and configuration examples to match the depth provided for Windows, including advanced scenarios.
- Review all CLI and scripting examples to ensure both Bash (Linux) and PowerShell (Windows) variants are included where relevant.
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 ways. Windows-specific paths and tools (such as D:\home, Web Deploy/MSDeploy, and references to IIS, w3wp.exe, and applicationHost.config) are mentioned frequently and often before or instead of their Linux equivalents. Many environment variable descriptions and examples default to Windows conventions, with Linux details sometimes appearing as an afterthought or not at all. There are also numerous references to Windows-specific behaviors, tools, and error messages, while Linux-specific guidance is less detailed or omitted.
Recommendations
- Ensure that all environment variable descriptions and examples include both Windows and Linux paths, formats, and behaviors where applicable.
- When mentioning tools or deployment methods (e.g., Web Deploy/MSDeploy), provide equivalent Linux-native alternatives or clarify their applicability.
- Avoid defaulting to Windows paths (e.g., D:\home) in examples; instead, show both Windows and Linux paths side by side.
- Balance the level of detail for Windows and Linux throughout the documentation, especially in troubleshooting and configuration sections.
- Where Windows-specific settings or behaviors are described, explicitly state if and how they differ on Linux, and provide Linux-specific guidance.
- Review and expand Linux-specific sections (such as Oryx build automation) to match the depth and clarity of the Windows/Kudu sections.
- Audit for references to Windows-only tools, error messages, or file structures, and add Linux equivalents or clarifications as needed.
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-first bias by referencing Windows file paths (e.g., D:\home\site\wwwroot) before Linux equivalents, using Windows directory separators in examples, and omitting explicit Linux command-line or file path examples. The instructions and troubleshooting sections focus on Windows conventions, and there are no Linux-specific deployment or troubleshooting examples provided.
Recommendations
- Provide Linux file path examples (e.g., /home/site/wwwroot) alongside Windows paths in all relevant sections.
- Include Linux command-line examples (such as Bash or shell commands) where appropriate, especially for manual file operations.
- Use platform-agnostic language and directory separators (e.g., <root>/site/wwwroot) or clearly indicate both Windows and Linux variants.
- Add troubleshooting notes specific to Linux environments, such as permissions or case sensitivity issues.
- Ensure that any references to tools or workflows (such as FTP paths or directory creation) are explained for both Windows and Linux users.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/troubleshoot-performance-degradation.md
...es/app-service/troubleshoot-performance-degradation.md
High Priority
View Details →
Detected Bias Types
Powershell Heavy
Windows Tools
Windows First
Missing Linux Example
Summary
The documentation page demonstrates a Windows bias by focusing on Windows-specific tools (IIS, Procdump, PowerShell), referencing Windows terminology (web.config, .NET Profiler for Windows), and omitting equivalent Linux guidance or examples. Linux-specific diagnostic methods, tools, and code samples are not provided, and Windows approaches are often mentioned first or exclusively.
Recommendations
- Provide Linux-specific instructions and examples alongside Windows ones, especially for diagnostics, logging, and profiling.
- Mention Linux equivalents for tools such as IIS diagnostics (e.g., Nginx/Apache logs), Procdump (e.g., gcore, dotnet-dump), and PowerShell (e.g., Bash/CLI commands).
- Clarify which features or instructions are Windows-only and offer alternative steps for Linux-based App Service environments.
- Include code/configuration samples for both Windows (.NET/web.config) and Linux (Node.js, Python, etc.) stacks.
- Update references and links to include Linux-focused documentation where available.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/overview-inbound-outbound-ips.md
.../articles/app-service/overview-inbound-outbound-ips.md
High Priority
View Details →
Detected Bias Types
Windows First
Powershell Heavy
Missing Linux Example
Summary
The documentation provides both Azure CLI and Azure PowerShell examples for finding outbound IP addresses, but PowerShell (a Windows-centric tool) is given equal prominence to Azure CLI, and in some cases, is presented before or alongside it without clarifying cross-platform applicability. There are no explicit Linux shell or Bash-native examples (other than the nslookup and curl commands), and the PowerShell examples may not be directly usable on Linux systems without additional setup. Outbound IPv6 support is noted as being available only for Windows apps, but this is a platform limitation rather than documentation bias.
Recommendations
- Clearly indicate that Azure CLI commands are cross-platform and preferred for Linux/macOS users, while PowerShell is primarily for Windows (unless using PowerShell Core).
- Present Azure CLI examples before PowerShell examples to avoid the perception of Windows-first bias.
- Where PowerShell is shown, clarify its platform compatibility (e.g., note if it works with PowerShell Core on Linux).
- Add explicit Bash or shell-native examples where possible, especially for common tasks like parsing JSON output from Azure CLI.
- In sections about platform-specific features (like outbound IPv6), clarify that limitations are due to service capabilities, not documentation focus.
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). The use of PowerShell cmdlets is presented as the primary method for configuration, and there is no mention of cross-platform or Linux-first approaches. This may hinder accessibility for Linux users or those working in cross-platform environments.
Recommendations
- Add equivalent Azure CLI examples for all PowerShell commands shown, using Bash syntax.
- Explicitly mention that PowerShell examples are for Windows and provide guidance for Linux/macOS users.
- Where possible, use cross-platform tools (e.g., Azure CLI) as the primary example, or present them before PowerShell.
- Include notes or links to documentation for configuring per-app scaling using REST API or SDKs, which are platform-agnostic.
- Review and update documentation metadata (such as devx-track-azurepowershell) to ensure cross-platform parity is prioritized.
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 Azure App Service, both of which are cross-platform but the tutorial is heavily oriented toward .NET and Azure tooling. There are no explicit Linux or macOS terminal instructions, and the workflow references tools and deployment patterns (such as Azure Developer CLI and App Service) that are more familiar to Windows/.NET developers. There are no mentions of Linux-specific environments, shell commands, or alternative editors/IDEs. All code and examples are .NET/C#-centric, with no parity for other platforms or languages.
Recommendations
- Add explicit instructions or notes for running the tutorial on Linux and macOS, including shell command equivalents and environment setup.
- Mention that .NET Core and Azure CLI are cross-platform, and provide bash/zsh shell command examples alongside dotnet CLI commands.
- Include a section or callout for deploying to Azure App Service from Linux/macOS terminals, or using VS Code on Linux.
- Reference alternative editors (such as VS Code) and clarify that the tutorial is not limited to Windows.
- If possible, provide parity examples for other common web stacks (e.g., Node.js/Express, Python/Flask) to broaden accessibility.
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
Missing Linux Example
Windows Tools
Summary
The documentation page demonstrates a Windows bias by referencing Windows-specific paths (e.g., D:\home), using Windows-centric terminology and folder structures, and omitting Linux-specific examples or equivalents. Tools and instructions (such as Kudu/SCM) are described in a way that assumes a Windows environment, and there is no mention of how to perform similar operations on Linux-based App Service plans. Linux and container scenarios are only mentioned in passing, mainly to state that the feature is not supported, without providing guidance or alternatives for Linux users.
Recommendations
- Provide equivalent Linux path examples (e.g., /home/site) alongside Windows paths.
- Include instructions and screenshots for enabling and managing local cache on Linux-based App Service plans, or explicitly clarify feature parity and alternatives.
- Mention Linux-compatible tools or commands (such as Bash, Azure CLI on Linux) where relevant.
- Clarify differences in folder structure and environment variables for Linux App Service environments.
- If the feature is unsupported on Linux, offer guidance or links to alternative caching strategies or features for Linux/container users.