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 526-550 of 2121 flagged pages
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-based CLI examples for per-app scaling, with no equivalent examples for Linux-native tools (such as Azure CLI/bash). The exclusive use of PowerShell cmdlets and the absence of Linux or cross-platform command-line instructions may hinder accessibility for Linux or macOS users. Additionally, the documentation metadata and custom tags emphasize Azure PowerShell, reinforcing the Windows-centric approach.
Recommendations
- Add equivalent Azure CLI (az) examples for all PowerShell commands shown, using bash syntax to support Linux/macOS users.
- Explicitly mention that both PowerShell and Azure CLI can be used, and provide guidance for users on different platforms.
- Include a section or callout for Linux/macOS users, highlighting any differences or considerations.
- Review and update documentation metadata and custom tags to reflect cross-platform tooling, not just Azure PowerShell.
- Consider the order of presentation: present Azure CLI and PowerShell examples side-by-side or with equal prominence, rather than PowerShell first or exclusively.
Create Pull Request
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/overview-managed-identity.md
...main/articles/app-service/overview-managed-identity.md
High Priority
View Details →
Detected Bias Types
Powershell Heavy
Windows Tools
Windows First
Missing Linux Example
Summary
The documentation displays a moderate Windows bias. PowerShell is featured prominently as a primary automation tool, and there are no explicit Linux shell (bash) or cross-platform scripting examples outside of Azure CLI. In several sections, PowerShell examples are provided, but Linux-native equivalents (e.g., bash scripts, curl commands) are missing. The documentation assumes familiarity with PowerShell and Windows tooling, and does not address Linux-specific workflows or tools beyond the Azure CLI.
Recommendations
- Add bash and curl examples alongside PowerShell for token retrieval and identity management, especially in sections currently showing only PowerShell scripts.
- Explicitly mention that Azure CLI commands are cross-platform and provide sample shell scripts for Linux/macOS environments.
- Where PowerShell is used for automation, provide equivalent bash scripts or note any limitations for Linux users.
- In sections where PowerShell is the only programmatic example (e.g., retrieving tokens, assigning identities), ensure parity by including Linux-native command-line examples.
- Review the ordering of examples to avoid always listing Windows/PowerShell first; consider rotating or grouping by platform.
- Clarify in notes or callouts when a feature or command is not available on Linux, and suggest alternatives if possible.
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 mild Windows bias. While the content is mostly platform-neutral, there are sections that provide detailed information and calculations specifically for Windows Containers, without equivalent details for Linux containers. Windows-specific features and limitations (such as extra IP usage for Windows Containers) are discussed in depth, while Linux-specific scenarios are only briefly mentioned (e.g., a short note about Linux continuous deployment network dependencies). There are no Linux command-line or configuration examples, and the troubleshooting and management sections reference tools and UI patterns more familiar to Windows users (e.g., Kudu console UI), with no mention of Linux equivalents.
Recommendations
- Add equivalent sections for Linux Containers, including subnet/IP usage calculations and any unique limitations or considerations.
- Provide Linux-specific examples or notes where Windows-specific ones are given (e.g., if Windows Containers have extra IP requirements, clarify if/how Linux Containers differ).
- Include Linux command-line examples (e.g., using Azure CLI or Bash) for common tasks such as configuring VNet integration, in addition to or instead of portal/UI instructions.
- Reference Linux-friendly tools (such as SSH, Bash, or Linux-native troubleshooting utilities) alongside or instead of Windows-centric tools like Kudu.
- Ensure parity in troubleshooting steps and management guidance for both Windows and Linux hosting scenarios.
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 page demonstrates a Windows bias in several ways: Windows-specific deployment methods (Web Deploy) are described in detail, with explicit instructions to use Windows agents, while Linux alternatives are not discussed. The FAQ and error messages focus on Windows agent requirements, and there is no equivalent coverage for Linux deployment tools or troubleshooting. Examples and templates often default to .NET/ASP.NET (traditionally Windows-centric), and Windows-specific deployment patterns (e.g., Web Deploy, IIS references) are mentioned without Linux parity.
Recommendations
- Provide equivalent Linux deployment examples, especially for scenarios where Web Deploy is not available (e.g., using zip deploy, FTP, or Kudu REST API on Linux agents).
- Include troubleshooting steps and error messages relevant to Linux agents, not just Windows.
- When referencing deployment methods, mention Linux-compatible alternatives alongside Windows tools, and clarify which methods are cross-platform.
- Balance .NET/ASP.NET examples with examples for Node.js, Python, Java, etc., and ensure these include both Windows and Linux deployment scenarios.
- Explicitly state platform limitations (e.g., Web Deploy is Windows-only) and suggest best practices for Linux users.
- Add links to documentation on Linux deployment tools and patterns, such as Azure CLI, SCP, or Git-based deployments.
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 the PowerShell examples are presented alongside CLI without clarifying that Azure PowerShell is primarily a Windows tool. There is no explicit mention of Linux-specific tools or shell environments, and the PowerShell examples may not be directly usable on Linux systems. Additionally, the outbound IPv6 support section highlights that outbound IPv6 is only available for Windows apps, with no Linux support, but does not offer Linux alternatives or guidance.
Recommendations
- Clarify that Azure PowerShell examples are primarily for Windows users and may require additional setup on Linux.
- Provide explicit Linux shell (bash) examples where possible, especially for common tasks like querying IP addresses.
- When mentioning features only available on Windows (e.g., outbound IPv6), offer guidance or workarounds for Linux users, or clearly state the lack of parity.
- Consider presenting Azure CLI examples before PowerShell, as CLI is cross-platform and more universally applicable.
- Add notes or links to documentation on how to use Azure PowerShell on Linux if PowerShell examples are retained.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/configure-authentication-file-based.md
...les/app-service/configure-authentication-file-based.md
High Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Missing Linux Example
Summary
The documentation page demonstrates a Windows-first bias by referencing the Windows deployment path (C:\home\site\wwwroot) as the default location for the configuration file, and only later mentioning the Linux equivalent. The example path in the instructions is Windows-specific, and Linux instructions are relegated to a note. There are no Linux-specific examples or screenshots, and the documentation does not provide parity in guidance for Linux users. Additionally, the documentation refers to Windows path conventions and does not provide a Linux example in the main instructional steps.
Recommendations
- Present both Windows and Linux paths side by side in all relevant steps, not just in notes.
- Use platform-agnostic language and examples where possible (e.g., refer to '/home/site/wwwroot/auth.json' and 'C:\home\site\wwwroot\auth.json' together).
- Include explicit Linux examples and instructions in the main flow, not just as an afterthought or in notes.
- Clarify differences in path requirements (relative vs. absolute) in a table or highlighted section for quick reference.
- Where tools or file locations are mentioned, provide both Windows and Linux equivalents with equal prominence.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/environment/networking.md
...ob/main/articles/app-service/environment/networking.md
High Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Missing Linux Example
Summary
The documentation demonstrates a Windows bias by referencing Windows-specific SKUs and features first (e.g., 'I1v2 Windows'), providing detailed IP address calculations only for Windows Containers, and listing Windows-centric tools (Visual Studio remote debugging, Web Deploy) in port tables without mentioning Linux equivalents or alternatives. There are no Linux-specific examples or parity in technical details, especially regarding container IP usage or deployment/debugging tools.
Recommendations
- Provide equivalent examples and calculations for Linux Containers, including how IP address usage differs (if at all) from Windows Containers.
- When listing App Service plan OS/SKU combinations, mention Linux SKUs alongside Windows, or clarify if differences exist.
- In port tables, include Linux-relevant deployment and debugging tools (e.g., SSH, SFTP, VS Code Remote), or note if certain features are Windows-only.
- Ensure that any technical notes or calculations (such as IP address requirements) are presented for both Windows and Linux, or explicitly state if they are not applicable to Linux.
- Review the order of presentation to avoid always listing Windows first; alternate or group by OS where appropriate.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/deploy-run-package.md
...s/blob/main/articles/app-service/deploy-run-package.md
High Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Missing Linux Example
Summary
The documentation demonstrates a Windows-first bias by referencing Windows directory paths (e.g., D:\home\site\wwwroot) before Linux equivalents, and by describing deployment flows and file locations primarily in Windows terms. There are no explicit Linux or cross-platform command-line examples, and the instructions for manual deployment (e.g., creating directories or files) use Windows-style paths without showing Linux equivalents. Additionally, tools and patterns referenced (such as directory structures and file creation) are described in a Windows-centric way.
Recommendations
- Provide Linux/macOS directory path equivalents (e.g., /home/site/wwwroot) alongside Windows paths in all relevant sections, not just in passing.
- Include explicit Linux/macOS command-line examples (e.g., using Bash or shell commands) for tasks such as creating directories or files, in addition to or instead of Windows examples.
- When describing manual steps (like creating packagename.txt or directories), show both Windows and Linux commands (e.g., mkdir, echo > file.txt) or use cross-platform tools.
- Avoid referencing only Windows tools or patterns (such as drive letters or backslashes); use forward slashes or note both styles where appropriate.
- Ensure that troubleshooting and notes sections mention Linux-specific considerations where relevant.
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 bias toward Windows by referencing Visual Studio and its NuGet package manager as the primary method for installing Semantic Kernel, with CLI instructions only mentioned secondarily. There are no explicit Linux or cross-platform development environment examples (e.g., VS Code, JetBrains Rider, or command-line workflows). The instructions for file operations (e.g., 'Right-click the Pages folder') assume a GUI-based IDE, typical of Windows/Visual Studio, and do not provide equivalent command-line or editor-agnostic steps. No Linux-specific deployment, configuration, or troubleshooting guidance is provided.
Recommendations
- Provide parallel instructions for Linux users, such as using VS Code or JetBrains Rider, and include command-line alternatives for file creation and editing.
- List CLI-based NuGet installation instructions before or alongside Visual Studio GUI instructions, emphasizing cross-platform compatibility.
- Avoid GUI-specific language like 'Right-click' or provide equivalent command-line instructions (e.g., 'Create a new file named OpenAI.razor in the Pages directory').
- Include Linux-specific notes for environment variable configuration, deployment, and troubleshooting, especially for App Service deployments from non-Windows systems.
- Explicitly mention that all steps can be performed on Linux, Mac, or Windows, and provide any necessary prerequisites or differences for non-Windows platforms.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/reference-app-settings.md
...ob/main/articles/app-service/reference-app-settings.md
High Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Powershell Heavy
Missing Linux Example
Summary
The documentation exhibits a Windows-first bias in several areas. Windows-specific paths (e.g., D:\home), tools (e.g., Web Deploy/MSDeploy, IIS, w3wp.exe), and configuration patterns are mentioned or prioritized, often without equivalent Linux examples or with Linux information presented as secondary. Many environment variables and descriptions are tailored to Windows or reference Windows behaviors, with Linux details sometimes appended or omitted. Some features and settings are described only in the context of Windows tools or processes, and examples often use Windows paths or conventions.
Recommendations
- For every Windows-specific example or path (e.g., D:\home), provide the Linux equivalent (e.g., /home).
- When referencing Windows tools (e.g., Web Deploy/MSDeploy, IIS, w3wp.exe), also mention or link to Linux-native alternatives or clarify their applicability.
- Ensure that Linux-specific behaviors, defaults, and limitations are described with equal prominence and detail as Windows.
- Where features are not available or differ on Linux, explicitly state this and provide guidance or workarounds.
- In tables and descriptions, avoid listing Windows details first by default; consider parallel presentation (Windows | Linux) or alternating order.
- Add Linux/POSIX shell examples where PowerShell or Windows command-line examples are given.
- Audit for environment variables or settings that are Windows-only and clearly mark them as such, while also highlighting Linux-only or cross-platform equivalents.
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, without providing equivalent Linux examples or clarifying Linux-specific behaviors. The only mention of Linux is in the context of unsupported scenarios, and there are no Linux shell or file system examples. Tools like Kudu are referenced without noting their differences or availability on Linux App Service. The guidance and examples are tailored to Windows environments, leaving Linux users with little actionable information.
Recommendations
- Provide parallel Linux examples for file paths (e.g., /home/site/wwwroot instead of D:\home\site).
- Clarify how local cache works (or does not work) on Linux App Service plans, including any differences in behavior, configuration, or limitations.
- Include Linux shell commands or instructions where appropriate, especially for tasks like checking folder sizes or environment variables.
- Mention Linux-specific tools or equivalents to Kudu (such as KuduLite), and clarify any differences in management or diagnostics.
- Clearly indicate in each section whether the instructions apply to Windows, Linux, or both, and provide guidance for Linux users where possible.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/tutorial-auth-aad.md
...cs/blob/main/articles/app-service/tutorial-auth-aad.md
High Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Missing Linux Example
Summary
The documentation demonstrates a mild Windows bias. Windows instructions and examples are consistently presented before Linux equivalents, and some tooling references (such as directory structure and deployment commands) are more tailored to Windows conventions. There are also sections (e.g., troubleshooting with 'Advanced Tools') that reference Windows-centric Azure portal features without clarifying Linux parity or alternatives. Some steps, such as directory navigation, use Windows-style paths or assumptions. While Linux instructions are present, they are sometimes less detailed or appear as adaptations rather than first-class guidance.
Recommendations
- Alternate the order of Windows and Linux instructions or present them side-by-side to avoid always prioritizing Windows.
- Ensure all tooling and troubleshooting steps are equally applicable to Linux App Service, or clearly document Linux-specific equivalents (e.g., clarify if 'Advanced Tools' is available and behaves the same on Linux).
- Use neutral directory structures and command syntax where possible, or provide both Windows and Linux variants explicitly.
- Review all examples and ensure Linux instructions are as detailed and complete as Windows ones, including any differences in deployment, configuration, or troubleshooting.
- Where features or tools are Windows-only, explicitly note this and provide Linux alternatives or workarounds.
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 and patterns (such as IIS diagnostics, Procdump, and PowerShell), referencing Windows in links and tool names, and omitting Linux-specific troubleshooting guidance or examples. There are no Linux command-line or diagnostic tool examples, and the Kudu Console is described in terms of PowerShell and DOS commands, with no mention of Bash or Linux shell usage. The Application Insights Profiler section links only to Windows-specific documentation. Overall, Linux users are left without clear guidance for equivalent troubleshooting steps.
Recommendations
- Include Linux-specific troubleshooting steps and examples, such as using Bash in the Kudu Console, and mention Linux-compatible diagnostic tools.
- Provide parity in documentation links (e.g., link to both Windows and Linux versions of Application Insights Profiler setup).
- When describing Kudu Console, mention that Bash is available for Linux-based App Service plans and provide relevant examples.
- Add examples for collecting diagnostics and logs on Linux-based App Service plans, such as using stdout/stderr logs, and reference Linux log file locations.
- Avoid using Windows terminology (e.g., IIS, web.config, Procdump) without clarifying Linux equivalents or alternatives.
- Ensure that PowerShell is not the only CLI example; include Azure CLI and Bash examples where appropriate.
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. While the main configuration steps use Azure CLI (cross-platform), several critical operations and examples reference Windows-centric tools (e.g., SQL Server Management Studio, Visual Studio, and sqlcmd) without offering Linux or cross-platform alternatives. Publishing instructions prioritize Visual Studio and Git Bash, but do not mention Linux-native editors or deployment workflows. Local debugging guidance is focused on Visual Studio remote debugging, with no mention of Linux or VS Code debugging. There are no explicit Linux command-line or tool examples for database management or local development.
Recommendations
- Provide equivalent instructions for Linux and macOS users, such as using Azure Data Studio or sqlcmd on Linux for database management.
- Include examples for publishing/deploying from Linux environments, such as using VS Code, Azure CLI, or Git from a Linux terminal.
- Offer local debugging guidance for Linux (e.g., using VS Code remote debugging or Azure CLI for token acquisition).
- When referencing tools like SQL Server Management Studio, also mention cross-platform alternatives (e.g., Azure Data Studio) and provide links.
- Ensure that all command-line examples are explicitly cross-platform, and clarify any OS-specific requirements or differences.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/tutorial-connect-msi-sql-database.md
...icles/app-service/tutorial-connect-msi-sql-database.md
High Priority
View Details →
Detected Bias Types
Windows First
Powershell Heavy
Missing Linux Example
Windows Tools
Summary
The documentation demonstrates a Windows bias by prioritizing Windows and Visual Studio (Windows) workflows, using PowerShell and Windows-specific tools (e.g., sqlcmd, Visual Studio menus), and omitting explicit Linux or cross-platform command-line examples for key steps such as database permission grants. Linux development environments are only briefly mentioned via Azure CLI, with no detailed guidance for Linux users on tasks like connecting to SQL Database or running migrations.
Recommendations
- Provide explicit Linux/macOS examples for connecting to Azure SQL Database, such as using sqlcmd or Azure Data Studio on Linux/macOS, or using Dockerized tools.
- Include bash/zsh command-line instructions for all steps currently shown only with PowerShell or Windows tools.
- Reorganize sections so that cross-platform or Linux-native workflows (e.g., Azure CLI, VS Code) are presented alongside or before Windows/PowerShell-specific instructions.
- Clarify which steps are platform-agnostic and which are Windows-specific, and offer alternatives where possible.
- Add guidance for running and debugging .NET apps on Linux/macOS, including database migration and publishing steps using dotnet CLI and VS Code.
- Ensure all screenshots and menu paths have Linux/macOS equivalents or note when a feature is Windows-only.
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 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 Azure PowerShell is highlighted, but no mention is made of Linux-native scripting approaches beyond the CLI.
Recommendations
- Present Linux and Windows commands/examples in parallel or alternate their order to avoid always listing Windows first.
- Include Bash shell scripting examples for automation, not just Azure CLI and PowerShell.
- When referencing tools, clarify their cross-platform availability (e.g., Azure CLI runs on Windows, Linux, and macOS).
- Explicitly mention that both Azure CLI and PowerShell can be used on Linux, and provide links or notes for Linux users.
- Consider adding a table or section summarizing automation options for both Windows and Linux environments.
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
Powershell Heavy
Windows Tools
Missing Linux Example
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, and rely heavily on PowerShell scripts. There is no mention of Linux-based hosting environments (such as Apache or Nginx on Linux), nor are there any Linux-specific migration tools, instructions, or examples. The documentation consistently refers to Windows tools and patterns, with no Linux parity.
Recommendations
- Add migration guidance and tooling for .NET apps hosted on Linux servers (e.g., Apache, Nginx, Kestrel).
- Provide Linux shell (bash) script equivalents for PowerShell-based migration steps.
- Include examples and walkthroughs for migrating .NET Core/ASP.NET Core apps from Linux environments to Azure App Service.
- Mention and link to any Azure Migrate or App Service tools that support Linux-based workloads, or clarify current limitations.
- Ensure documentation tables and tool descriptions clearly indicate OS support and provide parity where possible.
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 (a Windows IIS module) as the default Node.js integration, and omits Linux-specific equivalents or examples in several sections. Although there is a brief mention of running on Linux with PM2, the overall guidance and examples are Windows-centric, with Linux alternatives either missing or less emphasized.
Recommendations
- For features like auto-healing, provide Linux-specific configuration guidance (e.g., app settings, startup scripts) alongside or before Windows/web.config instructions.
- When discussing Node.js hosting, explain the differences between iisnode (Windows) and PM2 or other process managers (Linux), and offer configuration examples for both platforms.
- Wherever a Windows tool or pattern is mentioned (e.g., web.config, iisnode), explicitly mention the Linux equivalent or alternative, and provide code/configuration samples.
- Ensure that troubleshooting and best practice sections include parity for both Windows and Linux App Service environments, with clear headings or callouts for each.
- Consider adding a table or matrix summarizing which features and configurations apply to Windows, Linux, or both, to help users quickly find relevant guidance.
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 moderate Windows bias. Windows-related information and tooling (e.g., PowerShell) are presented before Linux equivalents, and some instructions or examples are Windows-centric. While Linux is mentioned (e.g., Linux SKU availability), Linux-specific automation examples (such as Bash scripting) are missing, and PowerShell is highlighted as a primary automation tool. There is also a lack of parity in examples for Linux users, particularly in scripting and automation sections.
Recommendations
- Provide Linux/Bash scripting examples alongside PowerShell for automation tasks.
- Ensure that Linux-specific instructions and tools are given equal prominence and are not always listed after Windows equivalents.
- Include explicit Linux container deployment examples where relevant.
- Clarify any differences in process or tooling for Linux users, especially where the Azure portal or CLI may behave differently.
- Add a section or callout for Linux users to highlight any unique considerations or best practices.
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 mentioned first in installation and usage instructions, and Windows-specific tools (such as the Hybrid Connection Manager GUI and PowerShell commands) are highlighted or exclusively available. Troubleshooting steps and connectivity tests use PowerShell commands without providing equivalent Linux commands. The Linux experience is often described as lacking features (e.g., no GUI), and some instructions are less detailed for Linux users.
Recommendations
- Alternate the order of Windows and Linux instructions so Linux is not always second.
- Where PowerShell commands are given (e.g., Test-NetConnection), provide equivalent Linux commands (e.g., nc, telnet, or curl).
- Expand Linux installation and usage instructions to match the detail level of Windows sections.
- Where a GUI is not available on Linux, suggest or document equivalent CLI workflows and provide screenshots or examples.
- In troubleshooting, provide Linux-native commands for DNS resolution (e.g., dig, host, nslookup) and connectivity testing.
- Ensure all features and steps are covered for both platforms, or clearly state any limitations with suggested workarounds.
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 or only option.
Recommendations
- Add parallel instructions and examples for Linux-based App Service plans, including how to check installed .NET runtimes and access diagnostic tools on Linux.
- Include Linux shell (bash) commands and file paths where appropriate, alongside or in place of Windows CMD/PowerShell examples.
- Clarify which instructions apply only to Windows-based hosting and provide clear guidance for Linux-based hosting scenarios.
- Reference Linux-specific tools (such as SSH, bash, or Linux Kudu equivalents) where relevant.
- Ensure that all configuration and troubleshooting steps are covered for both Windows and Linux environments to achieve parity.
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, with step-by-step PowerShell scripts and explicit use of Windows-specific tools and environment variables. The Windows approach relies heavily on PowerShell and Windows directory conventions, while the Linux instructions are more concise and assume familiarity with shell scripting and Linux tools. In some places, Windows examples and tools (like PowerShell and Windows paths) are presented before or more prominently than their Linux equivalents.
Recommendations
- Ensure Linux and Windows instructions are equally detailed, providing step-by-step guidance and example scripts for both platforms.
- Avoid assuming greater familiarity with Linux tooling; provide explicit Linux shell script examples where PowerShell is used for Windows.
- Present Linux and Windows instructions in parallel or in the same level of detail/order, rather than giving Windows first or more prominence.
- Where possible, use cross-platform tools or highlight them (e.g., Azure CLI, bash scripts) instead of Windows-only tools like PowerShell.
- Include troubleshooting and best practices sections for both Linux and Windows environments to ensure parity.
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 servers within VMware environments, which are Windows-centric technologies. There are no references to 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 examples assume a Windows/IIS context, omitting Linux scenarios entirely.
Recommendations
- Include guidance and examples for discovering .NET apps hosted on Linux web servers (e.g., Apache, Nginx, Kestrel).
- Mention whether Azure Migrate supports Linux-based .NET app discovery, and if not, clarify this limitation.
- Provide parity in documentation by listing Linux discovery steps, tools, or limitations alongside Windows/IIS instructions.
- Reference Linux-specific migration resources or tools where applicable.
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. It exclusively references Windows tools, file paths, and configuration patterns (e.g., web.config, node.exe, named pipes, Win32 error codes, IIS, Kudu CMD/PowerShell). There are no Linux or cross-platform equivalents, examples, or troubleshooting steps provided. The entire guide assumes a Windows deployment and omits any mention of Linux-based App Service or general Node.js hosting best practices outside the Windows ecosystem.
Recommendations
- Add a parallel section or a separate guide for Node.js on Azure App Service Linux, covering equivalent configuration, troubleshooting, and best practices.
- Include Linux-specific examples (e.g., using PM2, systemd, or NGINX as a reverse proxy) and reference Linux file paths and logs.
- When discussing tools like Kudu, provide instructions for both CMD/PowerShell (Windows) and Bash (Linux) environments.
- Avoid assuming the use of web.config, IIS, or iisnode; mention alternatives for Linux (e.g., app.js as entry point, environment variables, process managers).
- Reference both Windows and Linux error codes and log locations where applicable.
- Balance the order of presentation so that Linux and Windows are treated equally, or clearly indicate when content is Windows-specific in the title and introduction.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/app-service-managed-certificate-changes-july-2025.md
...e/app-service-managed-certificate-changes-july-2025.md
High Priority
View Details →
Detected Bias Types
Powershell Heavy
Windows Tools
Missing Linux Example
Windows First
Summary
The documentation demonstrates a Windows bias by providing PowerShell scripts as the only automation example for identifying impacted Traffic Manager endpoints, without offering equivalent Bash or cross-platform CLI scripts. References to running scripts assume a Windows/PowerShell environment, and there is no mention of Linux or macOS alternatives. The guidance for automation and scripting is Windows-centric, which may hinder users on Linux or macOS from following the instructions directly.
Recommendations
- Provide equivalent Bash or Azure CLI scripts for all PowerShell examples, especially for identifying Traffic Manager endpoints.
- Explicitly mention that the PowerShell scripts can be run on PowerShell Core (cross-platform) or provide instructions for Linux/macOS users.
- Where automation is referenced, offer both Windows (PowerShell) and Linux/macOS (Bash/CLI) alternatives, or clarify if a solution is cross-platform.
- Add notes or links to documentation on running PowerShell scripts on non-Windows platforms if PowerShell is required.
- Review all scripting and automation guidance to ensure Linux and macOS users are not excluded or forced to adapt Windows-centric instructions.