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 1201-1225 of 2121 flagged pages
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/deploy-azure-pipelines.md
...ob/main/articles/app-service/deploy-azure-pipelines.md
High Priority
View Details →
Detected Bias Types
Windows First
Missing Linux Example
Windows Tools
Powershell Heavy
Summary
The documentation demonstrates a Windows bias in several ways: Windows-based deployment methods (such as Web Deploy) are featured with explicit instructions and troubleshooting, while Linux equivalents are not discussed or are only mentioned in passing. Examples and templates often default to ASP.NET (a Windows-centric technology), and when deployment agent OS is specified, 'windows-latest' is highlighted for Web Deploy scenarios. There is little to no coverage of Linux-native deployment tools or troubleshooting for Linux agents, and the documentation assumes familiarity with Windows deployment patterns.
Recommendations
- Provide parallel Linux-based deployment examples, especially for scenarios where Windows-specific tools (like Web Deploy) are discussed.
- When introducing deployment templates or tasks, include examples for both Windows and Linux app types, and clarify any differences in configuration or prerequisites.
- Highlight Linux agent compatibility and limitations for each deployment method, and offer troubleshooting steps for Linux agents where relevant.
- Balance the focus on ASP.NET with examples for other stacks (Node.js, Python, Java) and clarify when instructions are Windows-specific.
- Reference Linux-native deployment tools or patterns (such as rsync, SCP, or container-based deployments) where appropriate.
- In FAQ and troubleshooting sections, address common issues for both Windows and Linux agents equally.
Create Pull Request
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/deploy-configure-credentials.md
...n/articles/app-service/deploy-configure-credentials.md
High Priority
View Details →
Detected Bias Types
Missing Linux Example
Windows First
Powershell Heavy
Summary
The documentation provides command-line examples for Azure CLI (cross-platform) and Azure PowerShell (Windows-centric), but does not include any Linux- or macOS-specific shell examples (e.g., Bash scripting, environment variable handling, or FTP/Git usage from Linux). In the section discussing shell-specific issues (escaping $ in Bash), only a note is provided, without a concrete Bash example. The PowerShell tab is always present, even when it is not supported, and is listed before the portal tab, reinforcing a Windows-first pattern.
Recommendations
- Add explicit Bash/Linux shell examples for relevant commands, especially where shell escaping or environment differences matter (e.g., using git remote add with $ in the username).
- Include examples of using standard Linux tools (e.g., curl, lftp, git) for FTP/S and Git deployments.
- Where PowerShell is not supported, consider omitting the tab or clearly indicating its absence, and provide parity by including a Bash/Linux tab.
- In tabbed command sections, alternate the order or default to CLI (cross-platform) or Bash before PowerShell to avoid Windows-first perception.
- Add troubleshooting notes or examples for common Linux/macOS issues (e.g., file permissions, SSH key usage, credential storage).
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/app-service-undelete.md
...blob/main/articles/app-service/app-service-undelete.md
High Priority
View Details →
Detected Bias Types
Powershell Heavy
Windows Tools
Missing Linux Example
Windows First
Summary
The documentation page demonstrates a strong Windows bias by exclusively providing PowerShell-based examples and instructions for restoring deleted Azure App Service apps. All command-line operations are shown using the Az PowerShell module, with no mention of cross-platform alternatives such as Azure CLI, Bash, or REST API. This approach assumes users are on Windows or have PowerShell installed, and does not address Linux-native workflows or tools. The documentation also introduces PowerShell before any other automation or scripting options, and omits Linux-specific guidance or examples.
Recommendations
- Add equivalent Azure CLI (az) command examples for all PowerShell cmdlets, as Azure CLI is cross-platform and widely used on Linux and macOS.
- Include Bash shell examples where applicable, especially for scripting or automation scenarios.
- Mention REST API options for restoring deleted apps, providing sample requests and responses.
- Clearly state that the PowerShell module can be used cross-platform (if true), or provide installation instructions for non-Windows environments.
- Reorganize sections to present cross-platform or platform-neutral options (such as Azure CLI or REST API) before or alongside PowerShell.
- Explicitly acknowledge Linux/macOS users and provide parity in instructions and troubleshooting steps.
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, troubleshooting, and examples are tailored for Windows, referencing Windows-specific tools (e.g., iisnode, web.config, named pipes, Win32 error codes, Kudu CMD/PowerShell, d:\ paths). There are no Linux equivalents or cross-platform instructions/examples, and Linux troubleshooting or deployment patterns are not mentioned.
Recommendations
- Add a parallel section or a separate guide for Node.js on Azure App Service for Linux, covering best practices and troubleshooting steps relevant to Linux environments.
- Provide Linux-specific examples for common tasks (e.g., configuration, debugging, log file locations, process management), using Linux tools and conventions (e.g., bash, systemd, Linux file paths).
- Reference Linux equivalents for Windows-specific tools and patterns (e.g., use of pm2 or systemd instead of iisnode, nginx/apache instead of IIS, environment variables instead of web.config).
- When mentioning troubleshooting steps (e.g., checking logs, profiling, debugging), include instructions for both Windows and Linux platforms, or clearly indicate which steps are platform-specific.
- Avoid assuming the use of Windows paths, tools, or error codes; provide cross-platform alternatives or clarify when something is Windows-only.
- Link to official Azure documentation for Node.js on Linux App Service where appropriate.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/app-service-web-tutorial-dotnet-sqldatabase.md
...service/app-service-web-tutorial-dotnet-sqldatabase.md
High Priority
View Details →
Detected Bias Types
Windows First
Missing Linux Example
Windows Tools
Powershell Heavy
Summary
The documentation is heavily oriented toward Windows and Visual Studio on Windows. All instructions, screenshots, and tooling references assume the user is on Windows, using Visual Studio, and deploying to Azure App Service (Windows). There are no examples or guidance for Linux or cross-platform development environments (e.g., Visual Studio Code, CLI, or deployment to App Service (Linux)). PowerShell and Windows-specific tools are used exclusively, with no mention of Bash, Azure CLI, or Linux-compatible workflows.
Recommendations
- Add parallel instructions and screenshots for Linux/macOS users, including using Visual Studio Code or JetBrains Rider.
- Include examples using Azure CLI and Bash for all steps currently shown with PowerShell or Visual Studio GUI.
- Provide guidance for deploying to Azure App Service (Linux) in addition to App Service (Windows).
- Document how to run and debug the sample app using .NET CLI commands (dotnet run, dotnet publish) instead of only Visual Studio.
- Show how to configure and connect to Azure SQL Database using cross-platform tools (e.g., Azure Data Studio, sqlcmd in Bash, or Azure CLI).
- Explicitly state which steps are Windows-only and offer alternatives for other platforms where possible.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/configure-authentication-customize-sign-in-out.md
...vice/configure-authentication-customize-sign-in-out.md
High Priority
View Details →
Detected Bias Types
Windows First
Missing Linux Example
Windows Tools
Summary
The documentation page demonstrates a Windows bias in the 'Server level (Windows apps only)' section, where only Windows/IIS (web.config) authorization is described, with no equivalent Linux example or mention of how to achieve similar functionality on Linux-based App Service plans. The use of Kudu and web.config is specific to Windows, and Linux alternatives are not discussed. Additionally, the section order presents the Windows-specific method before more general or cross-platform approaches.
Recommendations
- Add a section describing how to implement server-level authorization for Linux-based App Service apps, such as using .htaccess for Apache, nginx configuration, or middleware in common Linux web frameworks.
- Explicitly state the lack of server-level authorization support on Linux and suggest application-level or identity provider-level alternatives.
- Reorder the authorization section to present cross-platform or provider-level solutions before platform-specific (Windows) solutions.
- Where platform-specific tools (like Kudu or web.config) are mentioned, provide Linux equivalents or clear guidance for Linux users.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/deploy-ftp.md
...zure-docs/blob/main/articles/app-service/deploy-ftp.md
High Priority
View Details →
Detected Bias Types
Windows First
Powershell Heavy
Windows Tools
Missing Linux Example
Summary
The documentation demonstrates a Windows bias by prioritizing Windows-centric tools and workflows. PowerShell is given equal prominence to Azure CLI, but no Bash or Linux shell scripting examples are provided. The list of recommended FTP/S clients includes two Windows-focused tools (Visual Studio, WinSCP) and only one cross-platform option (Cyberduck), with no mention of Linux-native clients (e.g., lftp, FileZilla). There are no explicit Linux command-line or desktop environment instructions, and troubleshooting and connection examples reference Windows tooling and patterns.
Recommendations
- Add Linux/Bash shell scripting examples alongside PowerShell for all CLI operations.
- Include Linux-native FTP/S clients (e.g., lftp, FileZilla, GNOME Files) in the list of recommended clients.
- When listing tools or commands, alternate the order or provide parallel examples for both Windows and Linux users.
- Add troubleshooting steps and screenshots relevant to Linux environments.
- Clarify that Azure CLI commands work cross-platform and provide sample terminal output from Linux shells.
- Avoid assuming the use of Windows-specific tools (such as Visual Studio) as the default workflow.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/configure-basic-auth-disable.md
...n/articles/app-service/configure-basic-auth-disable.md
High Priority
View Details →
Detected Bias Types
Windows Tools
Windows First
Missing Linux Example
Summary
The documentation page demonstrates a moderate Windows bias. It references Windows-specific deployment tools (such as Web Deploy/MSDeploy) and patterns (like Visual Studio deployment) without providing equivalent Linux-native alternatives or examples. The documentation mentions 'Web Deploy' and 'MSBuild'—both Windows-centric tools—without clarifying Linux support or alternatives. In the Azure Pipelines section, there is detailed discussion of Windows agent behavior, but no comparable detail for Linux agents. There are no explicit Linux command-line or scripting examples, and the documentation does not mention Linux-native FTP or deployment tools, nor does it provide parity in troubleshooting or agent configuration for Linux users.
Recommendations
- Include Linux-native deployment tool examples (e.g., lftp, curl, git CLI) for verifying FTP or Git access.
- When referencing Visual Studio or MSDeploy, also mention cross-platform alternatives (such as VS Code, Azure CLI, or Git) and clarify their support on Linux.
- In sections discussing Azure Pipelines, provide explicit guidance for both Windows and Linux agents, including troubleshooting steps and behavioral notes for Linux.
- Add Linux-specific troubleshooting steps and examples for confirming authentication failures (e.g., using Linux FTP clients or Git from a Linux shell).
- Ensure that any mention of Windows tools or patterns is accompanied by Linux equivalents, or at least clarify if a feature is Windows-only.
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 in Azure App Service. All runtime version examples reference Windows file paths and tools (Kudu, CMD, PowerShell), with no mention of Linux equivalents or how to perform these tasks on Linux App Service plans. There are no Linux-specific examples or guidance, and Windows tools and patterns are presented as the default.
Recommendations
- Add equivalent instructions and examples for Linux App Service plans, including how to check .NET runtime versions and access diagnostic tools on Linux.
- When referencing tools like Kudu, CMD, or PowerShell, clarify their availability (Windows-only) and provide alternatives for Linux (e.g., SSH, Bash).
- Include Linux file paths and commands where appropriate, or explicitly state when a feature is Windows-only.
- Structure sections to address both Windows and Linux scenarios, or clearly indicate which instructions apply to which OS.
- Add a table or section summarizing feature parity and differences between Windows and Linux App Service for ASP.NET apps.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/configure-common.md
...ocs/blob/main/articles/app-service/configure-common.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. While it covers both Azure CLI (cross-platform) and Azure PowerShell (Windows-centric), several features and examples are either Windows-only or presented with a Windows-first perspective. Some advanced configuration options (like default documents, virtual directories, and handler mappings) are explicitly stated as Windows-only, with no Linux equivalents or workarounds mentioned. PowerShell examples are detailed and extensive, while Linux-specific nuances are only briefly mentioned or omitted. There is also a lack of parity in bulk editing capabilities between PowerShell and CLI, and some CLI examples use Windows-style paths or escape sequences without clear Linux guidance.
Recommendations
- Clearly indicate feature parity or lack thereof for both Windows and Linux throughout the documentation, especially for features that are Windows-only.
- Where features are Windows-only, suggest Linux alternatives or workarounds, or explicitly state that no equivalent exists.
- Provide Linux-specific examples and guidance, especially for CLI commands (e.g., path formats, escape characters, file handling).
- Balance the depth of PowerShell and CLI examples, ensuring that Linux users have equally detailed instructions.
- For sections where PowerShell cannot perform an action (e.g., bulk editing via JSON), suggest CLI as a cross-platform alternative.
- Add a summary table or section at the top that lists which features are available on Windows, Linux, or both.
- When referencing configuration files or paths, provide both Windows and Linux path examples where applicable.
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
Windows First
Missing Linux Example
Summary
The documentation demonstrates a mild Windows bias by referencing Azure Storage Explorer (a GUI tool with a primary focus on Windows) for uploading files and generating SAS tokens, and by linking to instructions that default to Windows tabs. There are no explicit Linux or cross-platform CLI alternatives provided for these steps, even though the rest of the guide uses Azure CLI (which is cross-platform). This may leave Linux users unclear on how to perform these actions without a Windows environment.
Recommendations
- Provide explicit Azure CLI (or azcopy) commands for uploading files to Azure Storage and generating SAS tokens, as these tools are cross-platform and suitable for Linux users.
- When referencing Azure Storage Explorer, clarify its availability on Linux and macOS, or provide alternative instructions for users who prefer CLI tools.
- Avoid linking to documentation pages with Windows-specific tabs as the default, or ensure that Linux/macOS instructions are equally prominent.
- Add a section or note summarizing cross-platform options for all major steps, especially for file upload and SAS generation.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/configure-gateway-required-vnet-integration.md
...service/configure-gateway-required-vnet-integration.md
High Priority
View Details →
Detected Bias Types
Windows First
Missing Linux Example
Windows Tools
Summary
The documentation is heavily biased towards Windows. Gateway-required virtual network integration is explicitly stated as unsupported for Linux apps, and all operational and troubleshooting examples (such as using PowerShell's Test-NetConnection and Windows tools like netstat) are Windows-centric. There are no Linux equivalents or guidance for Linux users, and Linux scenarios are not addressed.
Recommendations
- Clearly indicate at the beginning that gateway-required virtual network integration is not supported for Linux apps, and provide alternative guidance or links for Linux users.
- Where troubleshooting steps are provided using Windows tools (e.g., Test-NetConnection, netstat), include equivalent Linux commands (e.g., nc, curl, ss, netstat) for users managing resources from Linux VMs.
- If possible, provide a comparison table or section summarizing feature support and operational differences between Windows and Linux App Service plans.
- In sections that mention using the Azure portal or Kudu, clarify any differences in experience or availability for Linux-based apps.
- For all code or command-line examples, provide both Windows and Linux variants where applicable, or explicitly state when a feature is Windows-only.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/configure-custom-container.md
...ain/articles/app-service/configure-custom-container.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-specific instructions, tools, and examples are often presented first or in greater detail. PowerShell commands are provided alongside Bash, but Windows-specific tools (e.g., Kudu, IIS, .NET Framework) and patterns are described in more depth. Some advanced configuration and diagnostic sections (e.g., customizing memory, CPU, health ping, machine key injection) are detailed only for Windows containers, with no Linux equivalents. Linux instructions are present but sometimes less prominent or detailed.
Recommendations
- Ensure all advanced configuration sections (memory, CPU, health ping, machine key injection) have Linux equivalents or explicitly state if not supported.
- When presenting cross-platform commands, alternate the order (sometimes Linux/Bash first) or present them side-by-side.
- Expand Linux-specific diagnostic and troubleshooting guidance to match the depth of Windows sections (e.g., Kudu, SSH, logs).
- Clarify feature parity: if a feature is Windows-only, explicitly state so; if available on Linux, provide matching instructions.
- Balance the use of PowerShell and Bash examples, and ensure Linux-native tools and patterns (e.g., systemd, OpenSSH, Linux file paths) are described as thoroughly as Windows ones.
- Where Windows tools (e.g., IIS, .NET Framework) are mentioned, provide Linux analogs or note their absence.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/configure-language-dotnetcore.md
.../articles/app-service/configure-language-dotnetcore.md
High Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Powershell Heavy
Summary
The documentation exhibits a mild Windows bias by presenting Windows-specific instructions and tools (such as Kudu, CMD, and PowerShell) before their Linux equivalents, and by referencing Visual Studio and Windows deployment patterns as defaults. Linux instructions are present and generally comprehensive, but Windows tools and workflows are often mentioned first or exclusively, which may give the impression that Windows is the primary or preferred platform.
Recommendations
- Ensure parity in example order: Present Linux and Windows instructions side-by-side or alternate which platform is presented first to avoid the perception of a primary platform.
- Balance tool references: When referencing tools like Kudu (which is Windows-centric), also mention or link to the equivalent Linux troubleshooting or management tools (e.g., SSH, Oryx logs).
- Reduce Visual Studio/Windows defaults: When describing deployment workflows, clarify that Visual Studio is one option and highlight cross-platform alternatives (e.g., VS Code, CLI-based deployment) equally.
- Expand Linux-specific guidance: Where Windows-specific tools (like PowerShell or Kudu) are mentioned, ensure Linux alternatives are described with equal detail and visibility.
- Review terminology: Avoid phrases like 'already have all the supported .NET Core versions installed' for Windows without clarifying the Linux equivalent, to prevent assumptions about platform parity.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/deploy-container-azure-pipelines.md
...ticles/app-service/deploy-container-azure-pipelines.md
High Priority
View Details →
Detected Bias Types
Windows First
Missing Linux Example
Windows Tools
Summary
The documentation is heavily focused on deploying Windows containers, with all examples, variables, and instructions referencing Windows-specific settings (e.g., 'windows-latest' build agents, Web App for Containers (Windows), .NET/Windows app). There are no Linux container examples or references, and the documentation does not mention how to adapt the process for Linux-based containers or App Service for Linux.
Recommendations
- Provide parallel examples and instructions for deploying Linux containers, including YAML snippets using 'ubuntu-latest' or other Linux build agents.
- Mention both Windows and Linux App Service types, and clarify which steps or settings differ between them.
- Include notes or sections on how to adapt the pipeline for Linux-based applications, such as .NET Core or Node.js apps.
- Add Linux container deployment variables and sample values alongside the Windows ones.
- Explicitly state in the introduction that the guide is Windows-specific, or broaden the scope to cover both platforms equally.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/deploy-local-git.md
...ocs/blob/main/articles/app-service/deploy-local-git.md
High Priority
View Details →
Detected Bias Types
Windows First
Powershell Heavy
Windows Tools
Missing Linux Example
Summary
The documentation provides both Azure CLI and Azure PowerShell instructions, but there is a noticeable Windows bias. PowerShell is presented as a primary method alongside CLI, and several instructions (such as using a 'local PowerShell terminal') assume a Windows environment. There are no explicit Linux shell or macOS terminal examples for PowerShell steps, and troubleshooting references Windows-specific errors (e.g., native modules lacking Windows binaries). The documentation does not clarify cross-platform differences or provide parity for Linux users in PowerShell sections.
Recommendations
- Explicitly state that Azure CLI and Git commands work identically on Linux, macOS, and Windows, and provide example terminal commands for Linux/macOS where PowerShell is used for Windows.
- For PowerShell sections, clarify that PowerShell Core is cross-platform, or provide Bash equivalents for Linux/macOS users.
- In troubleshooting, avoid highlighting Windows-specific errors (such as native module Windows binary issues) without also mentioning common Linux/macOS issues.
- Wherever a 'local PowerShell terminal' is referenced, also mention 'Bash or other shell' for Linux/macOS users.
- Ensure that all code snippets and instructions are tested and presented for both Windows and Linux/macOS environments, or clearly indicate any platform-specific steps.
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 exhibits some Windows bias, particularly in the .NET and Python sections. Windows-specific tools (Visual Studio, Azure PowerShell) are listed before cross-platform or Linux-native options. In the .NET section, Windows tools are prioritized, and Azure PowerShell is mentioned without an equivalent Azure CLI example. In the Python section, the quickstart links default to 'windows' tabs, even when Linux is supported. Linux-specific instructions are less prominent or missing in some cases. Other stacks (Java, Node.js, PHP) are more Linux-friendly, but overall, Windows tools and patterns are often presented first or exclusively.
Recommendations
- Ensure that for every Windows-specific tool or example (e.g., Visual Studio, Azure PowerShell), there is an equivalent Linux-friendly or cross-platform alternative (e.g., Azure CLI, VS Code) presented with equal prominence.
- In quickstart tables, avoid defaulting to 'windows' tabs or pivots; instead, provide both Windows and Linux options side by side, or default to the most cross-platform approach.
- For .NET, add explicit Azure CLI examples and ensure Linux development environments are covered as thoroughly as Windows.
- Review all quickstart and tutorial links to ensure Linux instructions are not hidden behind secondary tabs or pivots.
- Where possible, use neutral language and tool ordering (e.g., list VS Code and CLI before Visual Studio and PowerShell) to avoid implying Windows is the default or preferred environment.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/identity-scenarios.md
...s/blob/main/articles/app-service/identity-scenarios.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 Microsoft-centric authentication libraries (MSAL, Microsoft.Identity.Web) and ASP.NET Core, which are most commonly associated with Windows development. Visual Studio and IDE integration are mentioned as benefits, but there is no mention of Linux development environments, cross-platform IDEs, or equivalent authentication solutions for non-Windows stacks. No Linux-specific examples, tools, or patterns are provided, and the documentation assumes familiarity with Windows-first technologies.
Recommendations
- Include examples and guidance for Linux-based development environments, such as using VS Code or JetBrains Rider on Linux.
- Mention and provide parity for authentication libraries and patterns commonly used in Linux or cross-platform stacks (e.g., Node.js, Python, Java, PHP).
- Highlight how App Service authentication works for apps deployed from Linux containers or running on App Service for Linux.
- Add references or links to documentation for configuring authentication in non-Windows environments.
- Clarify that the authentication solutions are cross-platform where applicable, and provide explicit instructions or examples for Linux users.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/invoke-openapi-web-app-from-azure-ai-agent-service.md
...https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/invoke-openapi-web-app-from-azure-ai-agent-service.md
High Priority
View Details →
Detected Bias Types
Missing Linux Example
Windows Tools
Windows First
Summary
The documentation demonstrates a bias toward Windows-centric workflows and tools. It focuses exclusively on Azure App Service (which is often associated with Windows hosting, though it supports Linux), .NET Blazor applications, and Azure CLI tooling without providing any Linux-specific or cross-platform deployment/management examples. There are no references to Linux-native tools, shell environments, or alternative deployment methods (such as using Bash scripts, Docker, or Linux-based CI/CD pipelines). The troubleshooting and log viewing sections also only mention the Azure Portal, not command-line or Linux-native monitoring options.
Recommendations
- Add explicit notes or examples for deploying and running the sample app on Linux-based App Service plans, including any differences in configuration or troubleshooting.
- Provide Linux/Bash shell command examples alongside Azure CLI commands, and clarify that azd and az CLI are cross-platform.
- Include references to Linux-native tools for log viewing and troubleshooting, such as using SSH, Kudu, or Azure CLI log streaming from Bash.
- Mention Docker-based deployment or containerization as an alternative, which is common in Linux environments.
- Clarify that App Service supports both Windows and Linux, and provide guidance for choosing the appropriate runtime stack.
- Expand the sample to include or reference non-.NET stacks (e.g., Node.js, Python) to ensure parity for Linux-first developers.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/deploy-staging-slots.md
...blob/main/articles/app-service/deploy-staging-slots.md
High Priority
View Details →
Detected Bias Types
Windows First
Powershell Heavy
Windows Tools
Missing Linux Example
Summary
The documentation demonstrates a Windows bias in several ways: PowerShell examples are provided alongside Azure CLI and portal instructions, with equal prominence, but there is no mention of Linux-native scripting or shell environments (e.g., Bash). The use of Windows-specific tools and configuration files, such as Web.config and applicationInitialization, is presented without Linux or cross-platform alternatives. Troubleshooting and advanced configuration sections reference Windows file paths (D:\home\LogFiles\eventlog.xml) and IIS-specific features, which may not apply to Linux-based App Service environments. Additionally, the auto swap feature is noted as unsupported on Linux, but no Linux-specific guidance or alternatives are offered.
Recommendations
- Add explicit Bash or Linux shell examples where scripting is demonstrated, especially alongside Azure CLI commands.
- Clearly indicate when features (such as auto swap) are not supported on Linux, and provide alternative workflows or mitigations for Linux users.
- When referencing configuration files like Web.config or IIS features, include parallel instructions for Linux-based apps (e.g., using app settings, startup scripts, or other Linux-appropriate mechanisms).
- In troubleshooting sections, mention log file locations and diagnostic steps for both Windows and Linux App Service environments.
- Review all examples and ensure that Linux users are not left without actionable guidance, especially where Windows/IIS-specific features are discussed.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/manage-scale-per-app.md
...blob/main/articles/app-service/manage-scale-per-app.md
High Priority
View Details →
Detected Bias Types
Powershell Heavy
Missing Linux Example
Windows Tools
Windows First
Summary
The documentation page demonstrates a strong Windows bias by exclusively providing PowerShell examples for per-app scaling, referencing only Windows-centric tools (Az PowerShell cmdlets), and omitting equivalent Linux-native or cross-platform CLI examples. The PowerShell section appears first and is the only command-line example provided, with no mention of Azure CLI (az), Bash, or other Linux-friendly approaches. This may hinder accessibility for Linux users or those working in non-Windows environments.
Recommendations
- Add equivalent Azure CLI (az) examples for all PowerShell commands, showing how to enable per-app scaling and configure worker counts using cross-platform tools.
- Include Bash shell script examples where appropriate, especially for configuring app settings via REST or CLI.
- Explicitly mention that PowerShell commands can be run cross-platform (if true), or clarify any platform limitations.
- Reorder sections or provide parallel examples so that Linux/cross-platform tools are not secondary to Windows/PowerShell.
- Reference Linux tools and workflows in the narrative, not just in code samples.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/manage-backup.md
...e-docs/blob/main/articles/app-service/manage-backup.md
High Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Powershell Heavy
Missing Linux Example
Summary
The documentation exhibits a moderate Windows bias. Windows paths, environment variables (e.g., %HOME%), and drive letters (e.g., D:\home\...) are used as primary examples, with Linux equivalents only mentioned secondarily or not at all. The instructions for file exclusion and directory navigation use Windows-style paths and terminology. The use of Kudu DebugConsole and FTP is described in a Windows-centric way. There are references to Azure PowerShell and Windows-specific features, while Linux command-line or scripting examples are missing. Although Linux is mentioned in some tables, practical Linux-specific instructions or examples are not provided.
Recommendations
- Provide Linux-specific examples alongside Windows examples, especially for file paths (e.g., /home/site/wwwroot instead of D:\home\site\wwwroot).
- When referencing environment variables, include both Windows (%HOME%) and Linux ($HOME) syntax.
- Show how to upload or edit the _backup.filter file using Linux tools (e.g., SCP, SFTP, or Linux shell commands) in addition to FTP/Kudu.
- Include sample commands or scripts for Linux users where PowerShell or Windows tools are mentioned.
- Ensure that all instructions referencing directories, file paths, or environment variables are presented in both Windows and Linux formats.
- Clarify any platform-specific limitations or differences in backup/restore behavior for Linux-based App Service apps.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/monitor-app-service.md
.../blob/main/articles/app-service/monitor-app-service.md
High Priority
View Details →
Detected Bias Types
Windows Tools
Powershell Heavy
Windows First
Missing Linux Example
Summary
The documentation page demonstrates a subtle Windows bias. It references PowerShell as a method to query Azure activity logs, and highlights integration with Visual Studio (a Windows-centric tool) for Application Insights. There are no explicit Linux or cross-platform command-line examples, nor are Linux-specific tools or workflows mentioned. The order of tool mentions (PowerShell before CLI) and the absence of Linux/Unix shell examples further reinforce the bias.
Recommendations
- When listing command-line options (e.g., for querying activity logs), mention Azure CLI and Bash examples before or alongside PowerShell.
- Include examples or references for Linux/macOS users, such as using Bash, Azure CLI, or cross-platform editors like VS Code.
- Balance tool mentions: if Visual Studio is referenced, also mention cross-platform IDEs/editors (VS Code, JetBrains Rider, etc.) where possible.
- Explicitly state that all monitoring features are available and supported on both Windows and Linux App Service plans.
- Add troubleshooting/log streaming examples for both Windows and Linux App Service environments.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/operating-system-functionality.md
...articles/app-service/operating-system-functionality.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-based App Service environments. It consistently uses Windows environment variables (e.g., %SystemDrive%, %ResourceDrive%, %HOME%), Windows file path conventions (e.g., d:\, c:\), and references to Windows-specific features such as IIS, ASP.NET, COM components, and the Windows registry. There are no Linux-specific examples, environment variables, or file system conventions. The only mention of Linux is a brief note at the beginning, with no further detail or parity in the rest of the document.
Recommendations
- Provide equivalent Linux examples and explanations for file paths, environment variables, and storage locations (e.g., use $HOME, /home/site/wwwroot, etc.).
- Include Linux-specific details for file access, temporary storage, and network configuration.
- Add sections or callouts that describe how the described functionality (e.g., diagnostic logs, process execution, registry access) maps to Linux containers in App Service.
- Mention Linux tools and patterns (e.g., Bash, shell scripts, Linux permissions) alongside Windows tools (e.g., PowerShell, IIS).
- Structure the documentation so that Linux and Windows information are presented in parallel, or clearly indicate when information is Windows-only.
- Clarify which features (such as registry access, IIS, COM components) are not applicable or have Linux equivalents, and provide guidance for Linux users.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/monitor-instances-health-check.md
...articles/app-service/monitor-instances-health-check.md
High Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Missing Linux Example
Summary
The documentation demonstrates a Windows bias by providing features and tooling (such as Process Explorer and diagnostic memory dumps) that are only available for Windows applications, without mentioning Linux equivalents or alternatives. Windows-specific capabilities are described in detail, while Linux users are left without guidance for similar tasks. Additionally, some notes and features are explicitly marked as Windows-only, and there are no Linux-specific examples or parity notes.
Recommendations
- For every Windows-specific feature (e.g., Process Explorer, diagnostic memory dumps), explicitly state whether a Linux equivalent exists. If not, provide alternative Linux troubleshooting or monitoring steps.
- Add Linux-specific examples or instructions where features or workflows differ, especially for diagnostics and process monitoring.
- When describing features, avoid presenting Windows capabilities first or exclusively; instead, structure sections to address both Windows and Linux users equally.
- Where a feature is Windows-only (e.g., x-ms-auth-internal-token header), clarify what Linux users should do instead, or provide a workaround if possible.
- Include screenshots or walkthroughs for Linux App Service where the portal experience or available options differ.