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 826-850 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
Powershell Heavy
Windows Tools
Missing Linux Example
Summary
The documentation demonstrates a moderate Windows bias. Windows is frequently presented first in tabbed instructions, and Windows-specific tools (such as the GUI for Hybrid Connection Manager and PowerShell commands) are emphasized or exclusively available. Troubleshooting steps and connectivity tests often use PowerShell examples without providing equivalent Linux commands. The Linux experience is sometimes less fully described (e.g., no GUI, less detail in some steps), and in troubleshooting, Linux-native tools are not always mentioned.
Recommendations
- Alternate the order of Windows and Linux instructions in tabbed sections, or present both equally where possible.
- For every PowerShell example (e.g., Test-NetConnection), provide an equivalent Linux command (such as nc, curl, or telnet).
- Expand Linux-specific instructions, especially in troubleshooting and connectivity testing, to match the detail and guidance given for Windows.
- Where GUI tools are only available for Windows, explicitly note this and provide enhanced CLI/alternative guidance for Linux users.
- In troubleshooting, include Linux-native tools (e.g., nslookup, dig, netcat) alongside Windows tools.
- Ensure all steps and screenshots that are provided for Windows are matched with Linux equivalents where feasible.
Create Pull Request
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/configure-ssl-certificate.md
...main/articles/app-service/configure-ssl-certificate.md
High Priority
View Details →
Detected Bias Types
Windows Tools
Windows First
Powershell Heavy
Missing Linux Example
Summary
The documentation demonstrates a moderate Windows bias. Windows tools and patterns (IIS, Certreq.exe, PowerShell) are mentioned explicitly, sometimes without Linux equivalents or with Windows-first ordering. PowerShell and Azure CLI are both shown for some automation, but in certificate export/import scenarios, Windows tools are referenced directly, and Linux workflows are less detailed or only briefly mentioned (e.g., OpenSSL). There are missing Linux-specific examples for some certificate management tasks, and the documentation assumes familiarity with Windows-centric approaches.
Recommendations
- For every mention of Windows tools (IIS, Certreq.exe), provide equivalent Linux workflows (e.g., using OpenSSL, certbot, or other common Linux utilities) with step-by-step instructions.
- When showing automation or scripting, always provide both Azure CLI (cross-platform) and PowerShell examples, and present them in parallel tabs, not with PowerShell first.
- Explicitly mention Linux and macOS compatibility for all command-line instructions, and clarify any OS-specific prerequisites or differences.
- Add troubleshooting tips or notes for Linux users, especially for certificate export/import and file format handling.
- Review all screenshots and UI references to ensure they are not Windows-specific, or add clarifying notes for Linux users where needed.
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 exhibits a Windows bias primarily in the section addressing Azure Traffic Manager endpoints, where only a PowerShell script is provided for identifying non-Azure endpoints. There are no equivalent Bash, Azure CLI, or cross-platform scripting examples for Linux or macOS users. The instructions for running the script explicitly reference PowerShell and Windows-style workflows (e.g., '.\TrafficManagerNonAzureEndpoints.ps1'), and no alternative is mentioned. This may hinder Linux/macOS users who do not have access to PowerShell or prefer native tools. Elsewhere, while REST API and Azure CLI commands are referenced, the only concrete scripting example is PowerShell, and there is a general lack of explicit Linux-first or cross-platform guidance.
Recommendations
- Provide equivalent Bash or Azure CLI scripts for identifying non-Azure Traffic Manager endpoints, or at least reference how to run the PowerShell script on Linux/macOS (e.g., via PowerShell Core).
- When referencing scripts, clarify their cross-platform compatibility or provide alternatives for Linux/macOS users.
- Wherever PowerShell is used, offer Azure CLI or Bash alternatives, especially for discovery and automation tasks.
- Explicitly mention that Azure CLI commands are cross-platform and provide example invocations in both Windows (cmd/PowerShell) and Linux/macOS (Bash) syntax.
- Consider including a table or section summarizing all available tools/scripts for each OS, ensuring Linux users are not left out.
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 and troubleshooting steps reference Windows-specific tools, paths, and patterns (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 pm2, systemd, or Linux file paths) are not mentioned.
Recommendations
- Provide equivalent guidance and examples for Node.js applications running on Azure App Service Linux, including configuration, troubleshooting, and profiling steps.
- Include Linux-specific tools and patterns (e.g., using pm2, systemd, Linux file paths, and environment variables) alongside or before Windows-specific instructions.
- Offer cross-platform examples where possible, or clearly separate Windows and Linux sections to avoid confusion.
- Reference Linux troubleshooting tools (such as top, htop, journalctl, or Linux log file locations) and explain how to access logs and debug on Linux-based App Service.
- Clarify in the introduction that the page is Windows-specific, or provide links to Linux-focused documentation if available.
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). The use of PowerShell cmdlets and parameters is exclusive, and there is no mention of how to perform these tasks on Linux or macOS environments. The ARM template section is platform-neutral, but all imperative (command-line) instructions are Windows-centric.
Recommendations
- Add Azure CLI examples for all PowerShell commands, showing how to create and configure per-app scaling using az commands.
- Include Bash shell examples where appropriate, especially for scripting scenarios.
- Explicitly mention that the PowerShell examples are cross-platform only if they are (e.g., Azure PowerShell Core), or clarify if they are Windows-only.
- Present Azure CLI (or REST API) examples before or alongside PowerShell to avoid a 'Windows-first' impression.
- Add a note or section for Linux/macOS users, guiding them to equivalent tooling and commands.
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 exhibits a Windows-first bias by consistently referencing Windows file paths (e.g., D:\home\site\wwwroot) before Linux equivalents, and in some sections, omitting Linux paths entirely. The instructions and examples focus on Windows directory structures and deployment patterns, with minimal or no explicit Linux-specific guidance or examples. There is also a reliance on Windows-centric terminology and tools, such as the use of backslashes in paths and references to drive letters, which may not be familiar or applicable to Linux users.
Recommendations
- Provide Linux file path equivalents (e.g., /home/site/wwwroot) alongside Windows paths in all relevant sections, not just in introductory remarks.
- Include explicit Linux-focused examples and instructions, especially for manual deployment steps (e.g., creating directories, handling permissions).
- Avoid using Windows drive letters and backslashes as the default; present both Windows and Linux path formats in parallel.
- Clarify any differences in behavior or requirements between Windows and Linux App Service environments.
- Where tools or commands are platform-specific, offer alternatives or note cross-platform compatibility.
- Review and update all references to deployment directories and file operations to ensure Linux parity and clarity.
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: logging types and features are described in detail for Windows before Linux, and several logging features (web server logging, detailed error messages, failed request tracing) are only available or described for Windows. Linux instructions are less detailed and sometimes missing. Windows-specific tools and file paths are mentioned (e.g., Log Parser, D:\home\LogFiles), while Linux equivalents are not provided.
Recommendations
- Provide Linux parity by explicitly stating which logging features are available or unavailable for Linux, and offer alternative solutions or workarounds where features are Windows-only.
- Include Linux-specific examples, such as file paths (/home/LogFiles), and recommend cross-platform tools for log analysis instead of or in addition to Windows-only tools like Log Parser.
- Structure sections to present both Windows and Linux instructions in parallel, rather than focusing on Windows first and relegating Linux to later or shorter sections.
- Clarify limitations for Linux (e.g., lack of web server logging, detailed error messages, failed request tracing) and suggest best practices for Linux users.
- Where possible, provide code or configuration examples for popular Linux stacks (Node.js, Python, Java, etc.), not just .NET/ASP.NET.
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 frequently referencing Windows-specific tools and patterns, such as PowerShell, IIS diagnostics, and SysInternals Procdump. Examples and instructions for troubleshooting and diagnostics are primarily oriented toward Windows environments, with little to no mention of Linux equivalents or cross-platform alternatives. The Kudu console is described as supporting PowerShell and DOS commands, but there is no mention of Bash or Linux shell support. Diagnostic features like Failed Request Tracing and .NET Profiler are referenced with Windows-specific links and terminology, and there is no guidance for Linux-based App Service environments.
Recommendations
- Include Linux-specific troubleshooting steps and examples, such as using Bash in the Kudu console, Linux diagnostic tools, and log formats.
- Reference Linux equivalents for IIS features, such as Apache/Nginx error logs and tracing.
- Provide parity in instructions for enabling diagnostics and profiling for Linux-based App Service plans (e.g., Application Insights for Node.js, Python, Java).
- Add examples for managing and restarting apps using Azure CLI and Bash, not just PowerShell.
- Clarify which features and tools are available on Linux App Service plans and provide links to relevant documentation.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/includes/deploy-intelligent-apps/deploy-intelligent-apps-linux-dotnet-pivot.md
...ent-apps/deploy-intelligent-apps-linux-dotnet-pivot.md
High Priority
View Details →
Detected Bias Types
Windows First
Missing Linux Example
Windows Tools
Summary
The documentation page demonstrates a Windows bias by primarily referencing Windows-centric tools and workflows (such as Visual Studio and right-click context menus), and omitting explicit Linux or cross-platform alternatives. Instructions for package installation and project manipulation are given with a Windows-first perspective, and there are no Linux-specific or cross-platform command-line examples for common tasks such as file creation, navigation, or package management.
Recommendations
- Provide explicit Linux and cross-platform instructions for all steps, especially for project/file creation and package installation (e.g., using dotnet CLI and text editors like VS Code or nano).
- When referencing Visual Studio or right-click actions, also describe equivalent CLI commands (e.g., 'dotnet new razor' or 'touch OpenAI.razor') and mention cross-platform editors.
- For NuGet package installation, show both Visual Studio GUI and dotnet CLI commands (e.g., 'dotnet add package Microsoft.SemanticKernel').
- Avoid assuming the use of Windows-specific tools or workflows; ensure all steps can be followed on Linux and macOS.
- Add a section or callouts for Linux/macOS users, highlighting any differences or additional steps required.
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 retrieving outbound IP addresses, but PowerShell examples are always presented after CLI and without explicit mention of cross-platform compatibility. There is no explicit mention that Azure PowerShell can be used on Linux/macOS, nor are there any Bash or Linux-native command examples (other than nslookup and curl). The outbound IPv6 support section specifically notes that outbound IPv6 is only available for Windows apps, with no Linux parity or roadmap. There are no Linux-specific troubleshooting or example scenarios, and the documentation does not clarify which commands are cross-platform or provide Linux-specific guidance where behavior differs.
Recommendations
- Explicitly state that Azure PowerShell is cross-platform and can be used on Linux/macOS, or clarify if any commands are Windows-only.
- Provide Bash or Linux-native command examples (e.g., using jq with az CLI output) where appropriate, especially for common tasks like querying IP addresses.
- Add a note or table summarizing feature parity (such as outbound IPv6 support) between Windows and Linux App Service plans, and provide guidance or alternatives for Linux users where features are missing.
- Ensure that examples and instructions are not presented in a 'Windows first' order; consider alternating or grouping by platform.
- Include troubleshooting steps or caveats for Linux users, especially where network tools or behaviors may differ.
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. It provides detailed subnet/IP calculations specifically for Windows Containers, mentions Windows Server Active Directory domain join as a non-supported feature, and references Kudu (primarily a Windows-based tool) for environment variable inspection. While Linux is mentioned in the context of continuous deployment, there are no Linux-specific configuration or troubleshooting examples, and Windows-specific scenarios are described in greater detail.
Recommendations
- Add parallel examples and calculations for Linux containers and Linux-based App Service plans, not just Windows Containers.
- Include Linux-specific limitations, best practices, and troubleshooting steps where relevant (e.g., for environment variables, scaling, and networking).
- Mention Linux-native tools (such as SSH, Bash, or Linux-based diagnostic tools) alongside or instead of Windows tools like Kudu.
- Ensure that any Windows-specific features or limitations are matched with Linux equivalents or explicitly state when a feature is Windows-only.
- Provide balanced coverage in examples and sample calculations for both Windows and Linux scenarios.
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 Windows bias by referencing Windows-specific configuration files (web.config), mentioning iisnode settings for Node.js apps, and omitting equivalent Linux-native examples or tools. While there is a brief mention of running on Linux with PM2, most configuration and troubleshooting guidance assumes a Windows/IIS environment, and Linux alternatives are not presented or are mentioned only secondarily.
Recommendations
- For every mention of web.config or IIS/iisnode, provide equivalent Linux-native configuration examples (e.g., environment variables, process managers like systemd or PM2).
- When discussing auto-healing or diagnostics, include instructions for both Windows (web.config/IIS) and Linux (startup scripts, App Service settings, or container health checks).
- If referencing iisnode, also describe how to configure Node.js apps on Linux App Service (e.g., using PM2, npm scripts, or custom startup commands).
- Ensure that all troubleshooting and best practice sections include Linux-specific guidance where applicable, not just Windows/IIS-centric advice.
- Consider reordering examples or providing parallel examples for both platforms to avoid a 'Windows first' impression.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/app-service-asp-net-migration.md
.../articles/app-service/app-service-asp-net-migration.md
High Priority
View Details →
Detected Bias Types
Windows First
Missing Linux Example
Windows Tools
Powershell Heavy
Summary
The documentation page exhibits a strong Windows bias. All migration tools and examples focus exclusively on Windows environments, particularly IIS servers and PowerShell scripts. There is no mention of Linux-based .NET hosting scenarios, Linux migration tools, or cross-platform alternatives. The documentation assumes the source environment is Windows and does not provide guidance for users migrating from Linux servers or using Linux-native tools.
Recommendations
- Include migration guidance and tools for .NET apps hosted on Linux (e.g., Apache, Nginx, Kestrel).
- Provide Linux shell (bash) script examples alongside PowerShell scripts.
- Mention and document any cross-platform migration tools or clarify if current tools are Windows-only.
- Add a section addressing migration from Linux-based environments, including common challenges and solutions.
- Ensure parity in documentation for both Windows and Linux users by listing Linux options and examples wherever Windows tools/scripts are mentioned.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/app-service-configure-premium-v4-tier.md
...s/app-service/app-service-configure-premium-v4-tier.md
High Priority
View Details →
Detected Bias Types
Windows First
Powershell Heavy
Windows Tools
Summary
The documentation demonstrates a mild Windows bias by presenting Windows-related information and tools before Linux equivalents, and by including Azure PowerShell (a Windows-centric tool) as a primary automation method. While Linux is mentioned and Azure CLI examples are provided (which are cross-platform), the ordering and emphasis tend to favor Windows. There are no Linux shell or scripting examples, and the 'Automate with scripts' section highlights PowerShell after CLI, but does not provide Bash or Linux-native automation examples.
Recommendations
- Ensure Linux and Windows instructions/examples are presented with equal prominence and in parallel where possible.
- Add Bash or shell script examples for Linux users, especially in the automation section.
- When listing tools or commands, avoid always listing Windows/PowerShell first; alternate or present both together.
- Clarify in the 'Automate with scripts' section that Azure CLI is fully cross-platform and may be preferred for Linux users.
- Where screenshots or UI steps are shown, note any OS-specific differences or provide Linux-specific guidance if applicable.
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. While both Windows and Linux are mentioned as supported platforms, and Azure CLI examples are provided (which are cross-platform), the structure and ordering of content often present Windows-first. For example, in the 'Premium V3 availability' section, the Windows SKU availability command is listed before the Linux one. Additionally, the automation section provides both Azure CLI and Azure PowerShell examples, but PowerShell (a Windows-centric tool) is given a dedicated section, while no Linux shell (e.g., Bash) or scripting examples are provided. The use of PowerShell-specific parameters (like -WorkerSize) also reinforces a Windows-centric approach. There are no explicit Linux shell or scripting examples, and the documentation does not mention Linux-specific considerations or tools beyond the single CLI command for Linux workers.
Recommendations
- Alternate the order of Windows and Linux examples to avoid always listing Windows first.
- Provide Bash or shell script examples for Linux users, especially in the automation section.
- Include Linux-specific notes or troubleshooting tips where relevant.
- Clarify that Azure CLI commands are cross-platform and can be run on both Windows and Linux.
- If PowerShell examples are included, consider also including equivalent Bash or shell scripting examples for parity.
- Ensure screenshots and UI instructions are not Windows-centric (e.g., avoid only showing Windows UI if there are differences).
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/configure-authentication-file-based.md
...les/app-service/configure-authentication-file-based.md
High Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Missing Linux Example
Summary
The documentation demonstrates a Windows-first bias by referencing the Windows file path (C:\home\site\wwwroot) as the default location for the configuration file, mentioning Windows path conventions first, and omitting Linux command-line or file system examples. Linux support is mentioned only as a note, and no Linux-specific instructions or examples are provided for file creation or deployment.
Recommendations
- Present both Windows and Linux file paths side-by-side 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).
- Include explicit Linux examples and instructions, such as how to create or deploy the configuration file using Linux commands (e.g., using 'touch', 'cp', or 'vi').
- Avoid assuming Windows as the default environment; instead, clarify instructions for both platforms equally.
- Where platform-specific behavior exists (such as path requirements), provide a clear, parallel example for each platform in the main instruction flow, not just in a note.
- Consider adding a table or section summarizing differences and best practices for both Windows and Linux App Service environments.
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 commands) are often presented first or exclusively, with Linux alternatives sometimes less detailed or missing. Windows-specific troubleshooting steps and tools are emphasized, and some features (like the Hybrid Connection Manager GUI) are only available on Windows, with Linux users directed to CLI alternatives. Some troubleshooting commands are only shown for Windows/PowerShell, with no direct Linux equivalents provided.
Recommendations
- Present Linux and Windows instructions in parallel, or alternate which OS is presented first in each section.
- Where PowerShell commands are provided for troubleshooting (e.g., Test-NetConnection), include equivalent Linux commands (e.g., nc, curl, or telnet).
- For GUI-only features on Windows, provide more detailed CLI instructions for Linux users, including screenshots or step-by-step guides.
- In troubleshooting sections, ensure all diagnostic steps have Linux equivalents, not just Windows/PowerShell.
- Highlight Linux support and parity where available, and clearly note any feature gaps.
- Consider providing more examples and sample commands for Linux users, especially for common tasks like connectivity testing and service management.
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 in the section addressing Azure Traffic Manager endpoints, where only a PowerShell script is provided for identifying non-Azure endpoints. There are no equivalent Bash, Azure CLI, or cross-platform script examples for Linux/macOS users. The instructions for running the script assume a Windows/PowerShell environment, and no alternative is offered. While the rest of the documentation uses Azure Resource Graph (ARG) queries and Azure CLI/REST API references (which are cross-platform), the exclusive use of PowerShell for a key scenario and lack of Linux/macOS guidance indicate a bias.
Recommendations
- Provide an equivalent Bash or Azure CLI script for identifying non-Azure Traffic Manager endpoints, or at least link to a cross-platform solution.
- Explicitly mention that the PowerShell script can be run on PowerShell Core (pwsh) on Linux/macOS, if applicable, and provide installation instructions.
- When referencing scripts or tools, offer both Windows (PowerShell) and Linux/macOS (Bash/CLI) examples where possible.
- Review other sections for subtle Windows-first language or assumptions, and clarify that all CLI/API instructions are cross-platform.
- Consider including a table or section summarizing which tools/scripts are available for each platform.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/configure-language-dotnet-framework.md
...les/app-service/configure-language-dotnet-framework.md
High Priority
View Details →
Detected Bias Types
Windows First
Missing Linux Example
Windows Tools
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 these 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.
Recommendations
- Add equivalent instructions and examples for Linux-based App Service plans, including how to check available .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.
- Clarify when instructions are Windows-specific and provide parallel Linux guidance, or explicitly state if a feature is not available on Linux.
- Mention Linux deployment tools and patterns (e.g., SSH, bash, Linux containers) alongside Windows tools like Kudu and PowerShell.
- Provide links to Linux-specific documentation or troubleshooting guides for ASP.NET apps on Azure App Service (Linux).
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 web servers (such as Apache or Nginx), nor are there examples or guidance for discovering .NET apps running on Linux. All discovery capabilities and references are tailored to Windows/IIS scenarios, omitting Linux equivalents.
Recommendations
- Include information on discovering .NET web apps hosted on Linux servers (e.g., Kestrel, Apache, Nginx).
- Provide examples or references for Linux-based discovery workflows, including any supported tools or limitations.
- Clarify in the introduction whether Linux-hosted .NET apps are supported or not, and if not, provide guidance or links to relevant migration resources.
- Ensure parity in documentation by mentioning both Windows and Linux scenarios where applicable, and by providing platform-agnostic guidance where possible.
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 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 examples, and Linux troubleshooting or deployment patterns are not mentioned. The use of Windows paths and error codes further reinforces the Windows-centric approach.
Recommendations
- Provide parallel documentation or sections for Linux-based Azure App Service environments, including configuration and troubleshooting steps relevant to Linux.
- Include Linux-specific examples, such as using PM2 or systemd for process management, and nginx or Apache for reverse proxying.
- Reference Linux file paths, error logs, and common debugging tools (e.g., journalctl, tail, lsof) alongside or instead of Windows-specific ones.
- Offer guidance on differences between iisnode (Windows) and alternatives like Azure App Service for Linux, including how to configure and debug Node.js apps in those environments.
- Balance the order of presentation so that Linux and Windows are given equal prominence, or clearly indicate when content is Windows-only and link to Linux equivalents.
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 packages, and by using Windows-centric UI actions (e.g., right-clicking in Solution Explorer) without providing equivalent Linux or cross-platform instructions. While CLI alternatives are mentioned for NuGet, there are no explicit Linux or cross-platform development environment examples, nor is there guidance for using common Linux editors or deployment workflows.
Recommendations
- Provide explicit Linux and cross-platform instructions for all steps, including file creation and editing (e.g., using VS Code, nano, or command-line tools).
- List CLI-based package installation (e.g., dotnet CLI) before or alongside Visual Studio/NuGet Manager instructions.
- Include deployment instructions using Azure CLI and/or GitHub Actions, not just portal-based workflows.
- Avoid assuming Visual Studio or Windows-specific workflows; clarify that any editor or OS can be used.
- Show environment variable setup using both Azure Portal and CLI (az command), and mention how to set secrets locally on Linux/macOS.
- Add a note or section for Linux/macOS users, highlighting any differences or additional steps.
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
Missing Linux Example
Windows First
Summary
The documentation demonstrates a mild Windows bias by referencing Azure Storage Explorer (which is primarily a GUI tool with a strong Windows association) for uploading files and generating SAS tokens, and by linking to Storage Explorer instructions with a '?tabs=windows' parameter. There are no Linux-specific instructions or CLI-based alternatives for these steps, and the only detailed example for generating a SAS is via the Windows-centric Storage Explorer. While the rest of the guide uses Azure CLI (which is cross-platform), the initial setup and file upload steps lack Linux parity.
Recommendations
- Provide Azure CLI or AzCopy command-line examples for uploading package files and generating SAS tokens, ensuring Linux users have clear, first-class instructions.
- Avoid linking only to Windows-specific tabs or instructions; ensure links and examples are either cross-platform or explicitly include Linux/macOS alternatives.
- Mention cross-platform tools (e.g., AzCopy, Azure CLI) before or alongside GUI tools like Storage Explorer, and clarify their availability on Linux.
- Add a note or section highlighting Linux/macOS compatibility and any differences in workflow, especially for steps currently described only with Windows tools.
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 data sources in Tomcat and JBoss on Azure App Service. However, in the Tomcat server-level configuration section, the Windows instructions are more detailed, appear first, and rely heavily on Windows-specific tools and scripting (PowerShell, .cmd files, Windows environment variables). The Linux instructions are present and functional, but the Windows approach is described in greater depth and with more step-by-step scripting, while the Linux approach is more concise and assumes more user familiarity with shell scripting and Linux tools.
Recommendations
- Ensure Linux and Windows instructions are presented in parallel structure and depth, with equal detail and step-by-step guidance.
- Provide Linux shell script examples with the same level of explanation as the Windows PowerShell scripts.
- Where possible, use cross-platform tools or highlight equivalent Linux tools (e.g., bash scripts, Linux environment variables) alongside Windows tools.
- Avoid presenting Windows instructions or tools before Linux equivalents; use side-by-side tabs or pivots for parity.
- Expand Linux sections to include troubleshooting, best practices, and automation tips similar to those given for Windows.
- Ensure all code samples (e.g., for deploying JDBC drivers) are shown for both platforms with matching clarity.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/configure-language-java-security.md
...ticles/app-service/configure-language-java-security.md
High Priority
View Details →
Detected Bias Types
Linux First
Missing Windows Example
Linux Tools
Summary
The documentation page demonstrates a Linux-first bias, especially in the sections about Java key store management. It provides detailed instructions and examples for Linux environments (e.g., file paths, SSH, keytool usage) but omits equivalent instructions or examples for Windows-based App Service environments. There are no PowerShell or Windows command-line examples, and Windows-specific file paths or tools are not mentioned. The documentation assumes Linux as the default or primary environment for Java apps on Azure App Service.
Recommendations
- Add parallel instructions and examples for Windows-based App Service environments, including file paths for Java key stores (e.g., %JAVA_HOME%\lib\security\cacerts), and describe where certificates are stored on Windows.
- Include examples of how to interact with the Java key store on Windows, such as using Command Prompt or PowerShell, and reference the Windows version of the keytool documentation.
- Mention how to open a remote session or terminal on Windows App Service (e.g., Kudu/SCM site) and provide equivalent keytool usage instructions.
- Ensure that all environment variable references use both Linux ($VAR) and Windows (%VAR%) syntax where appropriate.
- Balance the order of presentation so that Windows and Linux instructions/examples are given equal prominence, or clarify when a feature is Linux-only.