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 476-500 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 examples for command-line operations, omitting equivalent instructions for Linux users (such as Azure CLI or Bash). The use of PowerShell cmdlets and Windows-centric tooling is emphasized, with no mention of cross-platform or Linux-native alternatives. This may hinder accessibility and usability for developers working on non-Windows platforms.
Recommendations
- Add Azure CLI examples alongside PowerShell for all command-line operations, as Azure CLI is cross-platform and widely used on Linux and macOS.
- Explicitly mention that PowerShell examples are Windows-centric and provide Bash or shell script equivalents where possible.
- Include a section or callout for Linux/macOS users, guiding them to use Azure CLI or REST API for per-app scaling.
- Ensure that future documentation does not assume a Windows environment by default, and strive for parity in tooling and example coverage.
Create Pull Request
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/reference-app-settings.md
...ob/main/articles/app-service/reference-app-settings.md
High Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Powershell Heavy
Missing Linux Example
Summary
The documentation page demonstrates a Windows-first bias in several areas. Windows-specific tools, paths, and behaviors are often mentioned before or instead of their Linux equivalents. Many examples and explanations use Windows conventions (such as D:\home, .bat files, and Windows process names like w3wp.exe) without always providing Linux alternatives. Some settings are described only in the context of Windows tools or workflows (e.g., MSDeploy, Web Deploy, IIS, applicationHost.config), and Linux-specific guidance is sometimes missing or less detailed.
Recommendations
- For every Windows-specific example (such as file paths like D:\home or %HOME%), provide the Linux equivalent (e.g., /home or $HOME) alongside.
- When referencing Windows tools (e.g., MSDeploy, Web Deploy, IIS), also mention or link to Linux deployment methods and tools (such as Oryx, Kudu for Linux, or CLI-based deployments).
- Avoid using Windows process names (like w3wp.exe) or configuration files (like applicationHost.config) without clarifying their Linux/container equivalents or stating that they are not applicable.
- Ensure that all environment variable descriptions specify applicability to both Windows and Linux, or clearly state when a variable is platform-specific.
- Add Linux/POSIX shell command examples where PowerShell or Windows batch examples are given.
- Review and expand sections where Linux behaviors or settings are only briefly mentioned or omitted, ensuring Linux users have parity in guidance and troubleshooting steps.
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 exhibits a Windows bias by referencing Windows-specific paths (e.g., D:\home), tools, and deployment conventions throughout, without providing equivalent Linux examples. Windows containers are mentioned before Linux containers, and instructions for checking folder sizes and environment variables rely on Windows-centric site extensions and Kudu, which are more familiar to Windows users. There are no explicit Linux shell or file path examples, nor guidance for Linux-based App Service environments.
Recommendations
- Add Linux-specific examples for file paths (e.g., /home/site/wwwroot) and environment variables.
- Include instructions for checking folder sizes and cache status using Linux shell commands (e.g., du, ls) in addition to Windows tools.
- Mention Linux containers and built-in Linux environments alongside Windows containers, and provide parity in explanations.
- Clarify which instructions apply to Windows, Linux, or both, and provide guidance for Linux users where behavior or tooling differs.
- Reference Linux-compatible site extensions or alternatives for disk usage and diagnostics.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/overview-managed-identity.md
...main/articles/app-service/overview-managed-identity.md
High Priority
View Details →
Detected Bias Types
Powershell Heavy
Windows Tools
Windows First
Summary
The documentation provides extensive PowerShell examples and references, which are primarily relevant to Windows environments. PowerShell is featured as a first-class automation option alongside Azure CLI and ARM templates, but there is no mention of Bash, shell scripting, or Linux-native tooling. The CLI examples use 'az', which is cross-platform, but the PowerShell sections are detailed and sometimes offer functionality not available in CLI (e.g., user-assigned identity for Functions). There are no explicit Linux shell or Bash examples, and PowerShell is presented as a default scripting language for automation, which may not be familiar or preferred by Linux users.
Recommendations
- Add Bash or shell script examples for common tasks, especially where PowerShell is featured.
- Clarify that Azure CLI commands work identically on Linux, macOS, and Windows, and provide explicit Linux terminal examples where possible.
- Where PowerShell is used for automation, offer equivalent Bash or Python scripting examples to ensure Linux users have parity.
- Avoid presenting PowerShell as the only or primary scripting automation language; balance with Linux-native options.
- Explicitly mention cross-platform compatibility in sections discussing automation and scripting.
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 referencing Windows-specific tools (IIS, Procdump, web.config), providing PowerShell as the only CLI example, and linking to Windows-focused resources. There is a lack of Linux-specific troubleshooting guidance, and Linux-native tools or patterns are not mentioned. The Kudu console is described in terms of PowerShell and DOS commands, with no mention of Bash or Linux shell support. Diagnostic and mitigation steps (such as auto-heal and profiler) are described with a Windows/.NET focus, and links point to Windows-centric articles.
Recommendations
- Provide Linux-specific examples and instructions alongside Windows ones, especially for enabling diagnostics, collecting logs, and using the Kudu console (e.g., mention Bash support and Linux command equivalents).
- Reference Linux-native tools and patterns (such as using tail, grep, or journalctl for logs, and Linux process dump tools like gcore or dotnet-dump for .NET Core apps on Linux).
- Clarify which features and tools are available or behave differently on Linux App Service plans (e.g., Application Insights Profiler, auto-heal, web.config triggers).
- Include links to Linux-focused documentation and troubleshooting guides.
- When mentioning PowerShell, also provide Azure CLI or Bash alternatives for cross-platform parity.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/troubleshoot-diagnostic-logs.md
...n/articles/app-service/troubleshoot-diagnostic-logs.md
High Priority
View Details →
Detected Bias Types
Windows First
Missing Linux Example
Windows Tools
Summary
The documentation page demonstrates a Windows-first bias: logging types and features are described for Windows in more detail and before Linux equivalents. Several logging features (web server logging, detailed error messages, failed request tracing) are documented only for Windows, with no Linux alternatives or explanations. Windows-specific tools and file paths (e.g., Log Parser, D:\home\LogFiles) are mentioned, while Linux equivalents are not provided. Linux logging is described more briefly, and some features are explicitly unavailable or not explained for Linux.
Recommendations
- Provide equivalent Linux examples and instructions for all logging types, or clearly state if a feature is unavailable on Linux.
- Include Linux file paths and access methods alongside Windows paths (e.g., /home/LogFiles vs D:\home\LogFiles) in all relevant sections.
- Mention Linux-compatible tools for log analysis (e.g., grep, less, jq) where Windows tools like Log Parser are referenced.
- Clarify any feature gaps between Windows and Linux, and suggest workarounds or alternatives for Linux users.
- Ensure that Linux and container scenarios are described with the same level of detail as Windows scenarios, including code/configuration 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 First
Missing Linux Example
Windows Tools
Summary
The documentation demonstrates a moderate Windows bias. While Azure CLI is used for most automation steps (which is cross-platform), the tutorial and code samples focus exclusively on .NET (C#) and reference Windows-centric tools and workflows. SQL Server Management Studio (SSMS) and Active Directory Integrated authentication are mentioned without Linux alternatives. Local debugging guidance and publishing instructions prioritize Visual Studio and Git Bash, with no mention of Linux-native editors or deployment tools. There are no Linux-specific examples for connecting to SQL Database, nor are cross-platform alternatives to SSMS (like Azure Data Studio) suggested.
Recommendations
- Add Linux-specific instructions for local debugging, such as using Azure Data Studio or sqlcmd on Linux.
- Include examples of connecting to Azure SQL Database from Linux environments, both for administration and app development.
- Mention cross-platform editors (e.g., VS Code, JetBrains Rider) and deployment workflows for Linux/Mac users.
- Provide alternative publishing instructions using Azure CLI or Git from Linux terminals.
- Reference Azure Data Studio as a cross-platform alternative to SSMS for database management.
- Clarify that Azure CLI and jq commands work on Linux, and provide troubleshooting tips for common Linux shell issues.
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
Windows Tools
Missing Linux Example
Summary
The documentation demonstrates a Windows-centric bias. Visual Studio for Windows is presented as the primary development environment, with detailed steps and UI navigation. PowerShell and Windows-specific tools (e.g., sqlcmd in PowerShell, Visual Studio) are used for critical steps like granting database permissions, with no equivalent Linux or cross-platform alternatives shown. Linux or macOS development environments are only briefly mentioned (Azure CLI tab), and there are no examples for connecting to SQL Database or running sqlcmd from Linux/macOS terminals. The documentation assumes a Windows workflow for key operations, leaving Linux users to infer or adapt steps.
Recommendations
- Provide explicit Linux/macOS examples for all command-line operations, especially for connecting to Azure SQL Database (e.g., using sqlcmd or Azure Data CLI from Bash).
- Include instructions for using cross-platform editors (e.g., Visual Studio Code) for all steps, not just authentication.
- When presenting multiple environments, avoid putting Windows/PowerShell first or giving them more detail—present all supported platforms equally.
- Add a section or tab for Linux/macOS users in the 'Set up your development environment' and 'Grant permissions' steps, with commands and tools native to those platforms.
- Mention and demonstrate the use of Azure Data CLI (azdata) or sqlcmd for Linux/macOS, and provide installation instructions if needed.
- Ensure all screenshots and UI navigation steps are either cross-platform or have equivalents for non-Windows environments.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/configure-encrypt-at-rest-using-cmk.md
...les/app-service/configure-encrypt-at-rest-using-cmk.md
High Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Missing Linux Example
Summary
The documentation page demonstrates a Windows bias primarily through the exclusive mention and prioritization of Windows tools (Azure Storage Explorer with Windows-specific tabs), lack of Linux-specific instructions or examples, and absence of cross-platform alternatives for key steps such as generating SAS tokens and uploading package files. All command-line examples use Azure CLI, which is cross-platform, but GUI instructions and references are Windows-centric.
Recommendations
- Provide explicit instructions and screenshots for using Azure Storage Explorer on Linux and macOS, or mention its cross-platform availability.
- Include alternative methods for generating SAS tokens and uploading files using platform-agnostic tools (e.g., Azure CLI, azcopy) with examples for Linux/macOS.
- Avoid referencing Windows-specific tabs or features without noting Linux/macOS equivalents.
- Add a section or callouts for Linux users, highlighting any differences or additional steps required.
- Ensure troubleshooting and FAQ sections address platform-specific issues for both Windows and Linux users.
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 shows a moderate Windows bias, particularly in the 'Memory resources' and 'Node.js apps' sections. It references Windows-specific tools and patterns (such as web.config and iisnode) without providing equivalent Linux guidance or examples. While there is some mention of Linux (e.g., PM2 for Node.js), Windows-centric configuration is presented first and more thoroughly, and Linux alternatives are not always provided.
Recommendations
- For auto-healing and memory management, provide Linux-native configuration guidance (e.g., app settings, startup scripts, or Linux-specific diagnostic tools) alongside or before Windows/web.config instructions.
- In the Node.js section, include Linux-specific configuration and troubleshooting advice, such as using PM2, systemd, or other process managers, and clarify when iisnode is relevant (Windows only).
- Wherever Windows tools (like web.config or iisnode) are mentioned, explicitly state their platform scope and offer Linux equivalents or alternatives.
- Ensure that all code/configuration examples are provided for both Windows and Linux environments, or clearly indicate when a feature is platform-specific.
- Consider a more balanced structure, presenting Linux and Windows options in parallel or in a platform-neutral order.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/deploy-run-package.md
...s/blob/main/articles/app-service/deploy-run-package.md
High Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Missing Linux Example
Summary
The documentation exhibits a Windows-first bias by referencing Windows directory paths (e.g., D:\home\site\wwwroot) before Linux equivalents, and describing deployment behaviors primarily in terms of Windows file systems. There are no explicit Linux or cross-platform command-line examples, and the documentation assumes familiarity with Windows-style paths and conventions. Linux-specific details are mentioned only parenthetically or not at all, and there are no Linux-specific troubleshooting or deployment instructions.
Recommendations
- Present both Windows and Linux directory paths together and with equal prominence (e.g., D:\home\site\wwwroot (Windows) and /home/site/wwwroot (Linux)).
- Include Linux-specific examples and troubleshooting steps, especially where file paths, permissions, or behaviors differ.
- Provide cross-platform command-line examples, or explicitly note when commands are OS-agnostic.
- Avoid assuming Windows as the default environment; use neutral or dual-path notation throughout.
- Add a section or callouts for Linux users, highlighting any differences or considerations unique to Linux App Service environments.
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 terminology and tools (such as PowerShell) are emphasized, and Windows-specific instructions or examples are often presented before Linux equivalents. While Azure CLI examples are provided (which are cross-platform), PowerShell is highlighted as a primary automation tool, and there are no Linux shell (bash) or scripting examples. The portal instructions and screenshots are Windows-centric, and Linux-specific guidance is minimal or absent.
Recommendations
- Provide bash shell scripting examples alongside PowerShell for automation, especially for Linux users.
- When listing commands or instructions, alternate the order or present Linux and Windows options together, rather than always listing Windows first.
- Include screenshots or instructions for Linux environments (for example, using Azure CLI in a Linux terminal, or referencing Linux-specific deployment patterns).
- Clarify when instructions or features are Windows-only, and provide equivalent Linux guidance where possible.
- Expand the 'Automate with scripts' section to include bash or shell script examples for Linux users.
- Ensure that terminology and tool references are balanced between Windows and Linux (e.g., avoid assuming PowerShell is the default scripting environment).
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/app-service-hybrid-connections.md
...articles/app-service/app-service-hybrid-connections.md
High Priority
View Details →
Detected Bias Types
Windows First
Powershell Heavy
Windows Tools
Missing Linux Example
Summary
The documentation demonstrates a moderate Windows bias. Windows instructions, tools, and troubleshooting steps are often presented first or exclusively, with more detail and screenshots for Windows GUI tools. PowerShell commands are used for connectivity tests, while equivalent Linux commands are not provided. The Windows GUI for Hybrid Connection Manager is featured, but Linux users are limited to CLI with less visual guidance. Some troubleshooting steps and examples are Windows-specific or lack Linux alternatives.
Recommendations
- Present Windows and Linux instructions/examples in parallel, not sequentially or with Windows first.
- For every PowerShell command (e.g., Test-NetConnection), provide the Linux equivalent (e.g., nc, telnet, or curl).
- Include Linux screenshots or terminal output where Windows GUIs are shown, to provide parity for Linux users.
- Expand troubleshooting steps to include Linux-specific guidance and commands.
- Clarify any differences in feature support or limitations between Windows and Linux up front.
- Where GUI tools are only available on Windows, suggest alternative workflows or monitoring methods for Linux users.
- Ensure all code snippets and configuration steps are available for both platforms.
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
Powershell Heavy
Windows Tools
Windows First
Missing Linux Example
Summary
The documentation provides both Linux and Windows instructions for configuring data sources in Tomcat and JBoss on Azure App Service. However, the Windows section is notably more detailed, featuring extensive PowerShell scripting and Windows-specific file paths and tools. The Linux instructions are generally more concise and rely on shell scripting, but lack parity in depth and troubleshooting guidance compared to Windows. Windows tools (PowerShell, cmd) are emphasized, and Windows-specific patterns (copying Tomcat locally, using %LOCAL_EXPANDED%) are described in detail, while Linux equivalents are less elaborated. Some examples (such as advanced configuration and troubleshooting) are only present for Windows, and the Windows configuration steps are presented after Linux but with greater emphasis and length.
Recommendations
- Expand Linux instructions to match the detail and troubleshooting depth of Windows, including more comprehensive shell script examples and explanations.
- Provide equivalent Linux automation scripts (e.g., Bash scripts for startup configuration) with step-by-step guidance similar to the PowerShell example.
- Include Linux-specific troubleshooting tips and best practices for modifying Tomcat/JBoss configuration files.
- Ensure that all advanced configuration scenarios covered for Windows (such as copying Tomcat, marker files, and XSL transforms) are also addressed for Linux, with appropriate tooling (e.g., using rsync/cp, marker files, etc.).
- Balance the use of platform-specific tools by offering cross-platform alternatives (e.g., using Python or Java for XML transforms instead of PowerShell or shell-only solutions).
- Review the order and emphasis of examples to ensure Linux instructions are not secondary to Windows, and that both platforms are treated with equal importance.
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, Azure CLI, or cross-platform alternatives. References to running scripts assume a Windows/PowerShell environment, and there is no mention of Linux or macOS-compatible instructions. This may hinder users on non-Windows platforms from following the guidance effectively.
Recommendations
- Provide Bash or Azure CLI script alternatives for all PowerShell examples, especially for resource discovery tasks.
- Explicitly mention that PowerShell Core is cross-platform, or provide instructions for running scripts on Linux/macOS if PowerShell is required.
- When referencing downloadable scripts, offer both PowerShell and Bash versions, or at least note how Linux/macOS users can adapt the scripts.
- Ensure that all automation and scripting guidance is platform-neutral or includes both Windows and Linux/macOS instructions.
- Instruct users on how to use Azure CLI for resource queries and management wherever possible, as it is cross-platform.
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 hosting or migration scenarios. All downloadable tools are Windows executables or PowerShell scripts, and there are no Linux command-line or tool equivalents provided. The documentation repeatedly references PowerShell and Windows-specific technologies, with no guidance for users running .NET apps on Linux or using Bash/CLI tools.
Recommendations
- Include guidance and examples for migrating .NET apps hosted on Linux servers (e.g., Apache, Nginx, Kestrel) to Azure App Service.
- Provide Linux-compatible migration tools or scripts, or document manual migration steps for Linux environments.
- Add Bash or Azure CLI examples alongside PowerShell scripts for discovery and migration tasks.
- Clearly indicate in tool descriptions whether Linux is supported, and provide alternative recommendations if not.
- Highlight any Azure App Service migration features or best practices that are specific to Linux-based .NET deployments.
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 Windows and Linux, but there are several areas of Windows bias. Windows examples and tools (like Kudu, FTPS, and web.config) are mentioned explicitly and sometimes before Linux equivalents. Some instructions, especially around process management and diagnostics, are more detailed for Windows (e.g., using Kudu's Process Explorer), while Linux relies on SSH access. Windows-specific notes (such as web.config for Tomcat) are present, but Linux equivalents are not always discussed. There are also references to Windows-specific deployment conventions and tools, and some features (like Tomcat patch version pinning) are described as more configurable on Windows than Linux.
Recommendations
- Ensure that Linux examples are always presented alongside Windows examples, with equal detail and clarity.
- Where Windows tools (such as Kudu, FTPS, web.config) are mentioned, provide Linux alternatives (e.g., SSH, SCP, Linux config files) and link to their documentation.
- Avoid presenting Windows instructions or tools first unless there is a technical reason; alternate the order or present both together.
- Expand Linux troubleshooting and diagnostics sections to match the detail given for Windows (e.g., process management, file access).
- Clarify any feature parity gaps (such as patch version pinning for Tomcat) and provide workarounds or roadmap notes for Linux users.
- Review all notes and tips for Windows-specific advice and add equivalent Linux guidance where possible.
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 focuses exclusively on discovering ASP.NET web apps hosted on IIS web servers within VMware environments, which are Windows-centric technologies. There is no mention of Linux-based hosting scenarios, such as .NET apps running on Kestrel, Apache, or Nginx, nor are there any Linux-specific discovery tools or examples provided.
Recommendations
- Include guidance for 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 scripts.
- Clarify whether Azure Migrate supports Linux-hosted .NET apps and, if so, document the process.
- Mention Linux environments explicitly where applicable, or state current limitations if Linux is not supported.
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 examples reference Windows-specific tools, paths, and patterns (e.g., web.config, node.exe, named pipes, Win32 error codes, IIS, Kudu CMD/PowerShell). There are no Linux equivalents or cross-platform guidance, and Linux scenarios are not mentioned or supported in the examples.
Recommendations
- Add equivalent examples and troubleshooting steps for Node.js applications running on Azure App Service Linux, including configuration and diagnostic tools.
- Mention Linux-specific process management (e.g., PM2, systemd) and logging paths, and provide guidance for common Linux deployment patterns.
- Include references to Linux error codes and diagnostic commands (e.g., journalctl, tail, top) alongside Windows/PowerShell examples.
- Clearly indicate which sections apply only to Windows and provide parity by linking or embedding Linux documentation where relevant.
- Provide guidance for debugging and profiling Node.js apps on Linux, including use of tools like node-inspect, strace, or perf.
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 exhibits a Windows-first bias, with examples and terminology that prioritize Windows scenarios and tools. Windows-specific SKUs, containers, and calculation examples are given, while Linux equivalents are not mentioned or are only referenced generically. Windows tools and patterns (e.g., Visual Studio remote debugging, Web Deploy) are listed without Linux alternatives, and there are no explicit Linux-focused examples or guidance.
Recommendations
- Provide parallel examples and calculations for Linux containers and App Service plans, not just Windows.
- List Linux-compatible deployment and debugging tools (e.g., SSH, SFTP, VS Code Remote) alongside Windows tools like Visual Studio and Web Deploy.
- Include Linux-specific notes where behaviors or requirements differ (e.g., IP address usage for Linux containers).
- Ensure that all examples, tables, and recommendations mention both Windows and Linux scenarios where applicable.
- Add explicit Linux command-line examples or references (e.g., using Azure CLI from Bash, Linux networking tools) where relevant.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/deploy-azure-pipelines.md
...ob/main/articles/app-service/deploy-azure-pipelines.md
High Priority
View Details →
Detected Bias Types
Windows First
Missing Linux Example
Windows Tools
Powershell Heavy
Summary
The documentation demonstrates a Windows-first bias, especially in deployment examples and troubleshooting. Web Deploy (a Windows-specific tool) is featured prominently, and the only explicit agent pool example for Web Deploy uses 'windows-latest'. There are no equivalent Linux-based deployment examples for Web Deploy, and troubleshooting assumes a Windows environment. While some YAML examples use 'ubuntu-latest', advanced deployment scenarios and error messages focus on Windows agents and tools. There is a lack of parity in Linux-specific guidance, especially for .NET and Web Deploy scenarios.
Recommendations
- Provide equivalent Linux-based deployment examples where possible, especially for .NET apps.
- Clearly indicate when a feature or tool (such as Web Deploy) is Windows-only, and suggest Linux alternatives (e.g., ZIP deploy, FTP, or Azure CLI).
- Add troubleshooting sections for Linux agents, including common issues and solutions.
- Ensure that all code snippets and agent pool examples are balanced between 'windows-latest' and 'ubuntu-latest', or clarify OS requirements.
- Where Windows tools or patterns are mentioned, provide Linux equivalents or note their absence.
- Expand FAQs to address Linux agent scenarios and limitations.
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 on Windows-based deployment and configuration patterns for ASP.NET apps. Examples and instructions reference Windows tools (Visual Studio, Kudu CMD/PowerShell, Windows file paths), and there is a lack of equivalent Linux examples or guidance for ASP.NET apps running on Linux App Service. The documentation assumes a Windows environment for most configuration tasks and does not provide parity for Linux users.
Recommendations
- Add explicit instructions and examples for configuring ASP.NET apps on Linux App Service, including how to check .NET Framework versions and access environment variables.
- Provide Linux shell (bash) equivalents for commands currently shown only in CMD/PowerShell.
- Mention Linux-specific deployment tools and patterns, such as using VS Code, FTP/SFTP, or Linux-based build pipelines.
- Clarify which steps are Windows-specific and offer alternative steps for Linux environments where applicable.
- Include screenshots or navigation steps for Linux-based Kudu/SSH consoles if available.
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, especially in the .NET and Python sections. Windows-centric tools (Visual Studio, Azure PowerShell) are listed first or exclusively, with Linux alternatives appearing later or not at all. For Python, examples and quickstarts default to Windows tabs, and Linux instructions are not clearly highlighted. The 'Next step' call-to-action also prioritizes an ASP.NET (typically Windows-first) workflow. Other stacks (Java, Node.js, PHP) show better Linux parity, but overall, Windows tools and workflows are more prominent.
Recommendations
- Ensure Linux and cross-platform CLI examples are presented before or alongside Windows/PowerShell examples.
- Add explicit Linux instructions and tabs for Python quickstarts, not just Windows.
- Highlight VS Code and CLI workflows as primary options, with Visual Studio and PowerShell as alternatives.
- Balance the order of tool presentation (e.g., list CLI and VS Code before Visual Studio/Azure PowerShell).
- Include Linux-specific deployment and troubleshooting examples for all stacks.
- Make the 'Next step' call-to-action more inclusive (e.g., offer choices for Linux/CLI and other stacks, not just ASP.NET).
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 exclusively providing 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 the absence of cross-platform command-line alternatives may disadvantage Linux or macOS users. Additionally, the documentation references Azure PowerShell before mentioning ARM templates, reinforcing a Windows-centric approach.
Recommendations
- Add equivalent Azure CLI (az) examples for all PowerShell commands, showing how to enable per-app scaling and configure number of workers using the CLI.
- Include Bash script examples or generic REST API calls to demonstrate cross-platform approaches.
- When presenting multiple tool options, list cross-platform tools (e.g., Azure CLI) before or alongside PowerShell to avoid a 'Windows-first' impression.
- Explicitly state that the instructions are applicable to all platforms, and clarify any platform-specific requirements if present.
- Consider adding a table or section comparing PowerShell, Azure CLI, and ARM template approaches for per-app scaling.
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 shows a moderate Windows bias. Windows examples and instructions are consistently presented before Linux equivalents, and some tooling references (such as directory structure and runtime casing) are more Windows-centric. There are also minor inconsistencies and omissions in Linux instructions, such as missing the --sku parameter in one Linux example and using different runtime syntax. Additionally, some advanced troubleshooting steps reference Windows-style navigation and tools, with less detail for Linux environments.
Recommendations
- Alternate the order of Windows and Linux instructions, or present them side-by-side, to avoid always prioritizing Windows.
- Ensure parity in all example commands and parameters (e.g., always include --sku for both platforms, use consistent runtime naming conventions).
- Provide explicit Linux-specific troubleshooting steps and navigation instructions, especially for file system access and log review.
- Clarify any differences in directory structure or command syntax between platforms, and avoid assuming Windows conventions (such as backslashes or case sensitivity).
- Where possible, use platform-neutral language and tools, or provide both Windows and Linux alternatives for all steps.