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 426-450 of 2121 flagged pages
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
Minor Missing Linux Example
Summary
The documentation uses platform pivots to provide both Windows and Linux instructions, but Windows examples and terminology are generally presented first. Some instructions and directory structures are more detailed for Windows, and certain tools and patterns (such as 'Advanced Tools' in the Azure portal) are described in a way that aligns more closely with Windows environments. There is also a minor inconsistency in the runtime versions between Windows and Linux examples, and some steps (like directory navigation) are more explicit for Windows.
Recommendations
- Alternate the order of platform pivots so that Linux instructions are sometimes presented first, or present both platforms side-by-side where possible.
- Ensure parity in detail and clarity between Windows and Linux instructions, including directory structures and command examples.
- Standardize runtime versions and naming conventions across both platforms to avoid confusion (e.g., use 'NODE:20LTS' vs 'NODE:20-lts' consistently).
- When referencing Azure portal tools or features (like 'Advanced Tools'), clarify if they are available and behave identically on both Windows and Linux App Service plans.
- Review all examples and troubleshooting steps to ensure Linux users are not left with less information or less explicit guidance.
Create Pull Request
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 PowerShell-based workflows, especially for development and database administration tasks. Visual Studio for Windows is presented first and in more detail, while Linux/macOS workflows are either absent or less emphasized. Key steps such as connecting to SQL Database for permission grants rely on PowerShell and sqlcmd, with no explicit Linux or cross-platform alternatives. The use of Windows-centric tools and patterns (Visual Studio, PowerShell) is prevalent, and Linux-native or cross-platform equivalents are not provided or are less visible.
Recommendations
- Provide explicit Linux/macOS examples for all command-line steps, especially for connecting to Azure SQL Database (e.g., using sqlcmd or Azure Data CLI on Linux/macOS).
- Include instructions for setting up and using Visual Studio Code or JetBrains Rider on Linux/macOS for development and debugging, not just Visual Studio for Windows.
- When listing development environments, avoid putting Windows/Visual Studio first by default; present all major platforms equally or in parallel tabbed sections.
- For database permission grants, show how to use sqlcmd or Azure Data CLI on Linux/macOS, and clarify any prerequisites or differences.
- Avoid assuming PowerShell is available; provide Bash or shell alternatives for all scripts and commands.
- Explicitly mention and support Linux and macOS in all setup and troubleshooting sections.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/app-service-best-practices.md
...ain/articles/app-service/app-service-best-practices.md
High Priority
View Details →
Detected Bias Types
Windows First
Missing Linux Example
Windows Tools
Summary
The documentation page demonstrates a Windows bias by referencing Windows-specific tools and patterns (such as web.config and iisnode) without providing equivalent Linux guidance or examples. Linux-specific configuration methods are not mentioned in sections where Windows approaches are described, and Windows tools are referenced first or exclusively.
Recommendations
- For features like auto-healing, provide Linux-specific configuration instructions (e.g., using application settings or startup scripts) alongside or before mentioning web.config.
- When referencing iisnode or web.config for Node.js apps, include guidance for Linux-based App Service plans, such as using PM2, environment variables, or other process managers.
- Ensure that all examples and troubleshooting steps are provided for both Windows and Linux environments, or clearly indicate when a feature is platform-specific.
- Where possible, use cross-platform terminology and tools, or provide parallel instructions for both operating systems.
- Add explicit Linux configuration examples for common scenarios (e.g., memory/CPU troubleshooting, process management) to achieve 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 web servers within VMware environments, which are Windows-centric technologies. There are no references to Linux-based hosting, such as Kestrel or Apache/Nginx, nor are there examples or guidance for discovering .NET apps on Linux servers. All discovery capabilities and tooling mentioned (Azure Migrate appliance, IIS) are Windows-specific, with no Linux equivalents or parity.
Recommendations
- Include explicit guidance or notes about discovering .NET apps hosted on Linux servers, such as those running Kestrel, Apache, or Nginx.
- Provide examples or documentation links for Linux-based discovery scenarios, if supported.
- Clarify whether the Azure Migrate appliance supports Linux environments, and if not, state this limitation clearly.
- If Linux discovery is not supported, suggest alternative approaches or tools for Linux users.
- Ensure future documentation covers both Windows and Linux hosting scenarios for .NET apps to improve cross-platform parity.
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 ASP.NET apps from Windows/IIS environments, with repeated references to PowerShell scripts and Windows-specific tools. There is no mention of Linux-based .NET hosting environments (e.g., Apache, Nginx), nor are there any Linux command-line or migration examples. The documentation assumes the source environment is always Windows/IIS, omitting guidance for users migrating from Linux servers.
Recommendations
- Add examples and guidance for migrating .NET web apps hosted on Linux servers (e.g., Apache, Nginx, Kestrel) to Azure App Service.
- Include Linux shell (bash) script equivalents for PowerShell-based migration steps.
- Mention and link to any available tools or manual processes for assessing and migrating .NET apps from Linux environments.
- Clarify in tool descriptions whether they support Linux-based migrations, and if not, provide alternative recommendations.
- Present migration scenarios for both Windows and Linux environments, ensuring parity in documentation structure and detail.
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 Traffic Manager endpoints, without offering Bash, Azure CLI, or cross-platform alternatives. References to PowerShell are made without mention of Linux/macOS compatibility or equivalent Bash/CLI scripts. This may disadvantage users on non-Windows platforms, as the guidance assumes access to and familiarity with PowerShell and Windows tooling.
Recommendations
- Provide equivalent Bash or Azure CLI scripts for all PowerShell examples, especially for resource discovery and automation tasks.
- When referencing scripts or automation, explicitly state whether they are cross-platform or provide alternatives for Linux/macOS users.
- List Azure CLI and REST API commands before or alongside PowerShell commands to avoid a 'Windows-first' impression.
- Clarify in the documentation that PowerShell Core is available cross-platform, or provide instructions for running scripts on Linux/macOS if no alternative is available.
- Ensure that all referenced GitHub scripts or tools have clear cross-platform compatibility notes or alternatives.
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 network testing without equivalent Linux examples. The Windows GUI for Hybrid Connection Manager is featured, while Linux users are limited to CLI with less visual guidance. Some troubleshooting steps and tool references (e.g., Test-NetConnection) are Windows-specific, and Linux alternatives are not always provided.
Recommendations
- Provide Linux equivalents for all PowerShell commands (e.g., suggest 'nc', 'telnet', or 'curl' for network testing).
- When referencing tools like 'Test-NetConnection', include the Linux alternative alongside the Windows example.
- Balance the order of presentation: alternate which OS is presented first, or present both together where possible.
- Offer more visual aids or step-by-step CLI examples for Linux users, compensating for the lack of GUI.
- Explicitly mention any feature parity or limitations between Windows and Linux at the start of each relevant section.
- Where GUI-only features exist for Windows, suggest or develop CLI/alternative workflows for Linux.
- In troubleshooting, include Linux-native commands for DNS lookup (e.g., 'dig', 'host', or 'nslookup') and endpoint testing.
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 demonstrates a Windows bias by referencing Windows-style paths (e.g., D:\home), describing folder structures and behaviors using Windows conventions, and mentioning Windows-specific tools and deployment patterns (such as Kudu/SCM and Azure Web Apps Disk Usage) without providing equivalent Linux examples or clarifying differences for Linux-based App Service plans. There are no Linux command-line examples or explicit guidance for Linux users, and Linux container support is only mentioned in a note about lack of support, not in positive examples.
Recommendations
- Include parallel Linux examples and path conventions (e.g., /home/site/wwwroot) alongside Windows paths.
- Clarify differences in local cache behavior for Linux-based App Service plans and provide explicit guidance for Linux users.
- Mention and provide examples of Linux-compatible tools or commands for checking disk usage and environment variables.
- Where features are unsupported on Linux, offer alternative recommendations or workarounds for Linux users.
- Ensure that all code snippets, folder references, and troubleshooting steps are presented for both Windows and Linux environments.
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
Powershell Heavy
Windows Tools
Missing Linux Example
Summary
The documentation generally provides both Linux and Windows instructions, but there are several areas where Windows is prioritized or receives more detailed coverage. Windows-specific tools and patterns (such as Kudu, Advanced Tools, and FTPS) are mentioned prominently, sometimes before Linux equivalents. Some sections (e.g., Java Flight Recorder, logging, and process management) provide more step-by-step detail for Windows, including GUI navigation, while Linux instructions are more command-line focused or less detailed. There are also references to Windows-specific behaviors (like web.config) and tools without always providing Linux alternatives or parity in explanation.
Recommendations
- Ensure that Linux and Windows instructions are presented with equal prominence and detail, ideally side-by-side or with Linux-first ordering where appropriate.
- Where Windows-specific tools (e.g., Kudu, FTPS, Advanced Tools) are referenced, provide equivalent Linux-native approaches or clarify if not applicable.
- Expand Linux examples to match the step-by-step detail given for Windows, especially for tasks like process management, log retrieval, and profiler usage.
- Avoid referencing Windows-specific configuration files (like web.config) without noting their irrelevance on Linux, and provide Linux-specific configuration guidance where applicable.
- Review all sections for parity in troubleshooting, deployment, and configuration guidance, ensuring Linux users are not left with less actionable information.
- Where possible, use cross-platform CLI tools (e.g., Azure CLI, SSH) as the primary example, and only supplement with OS-specific tools as needed.
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
Missing Linux Example
Windows Tools
Summary
The documentation demonstrates a Windows bias by providing detailed examples and calculations specifically for Windows Containers, referencing Windows-specific SKUs (e.g., I1v2 Windows), and listing Windows-centric tools and ports (such as Visual Studio remote debugging and Web Deploy) without equivalent Linux examples or tools. Linux is mentioned only in passing, with no concrete examples or parity in guidance.
Recommendations
- Add equivalent examples and calculations for Linux Containers, including how IP address requirements may differ.
- When referencing App Service plan SKUs, include both Windows and Linux variants, or clarify if guidance applies to both.
- List Linux-relevant deployment and debugging tools/ports (e.g., SSH, SFTP, VS Code Remote) alongside Windows tools.
- Provide Linux-specific notes or caveats where behaviors or requirements differ.
- Ensure that all sample calculations, tables, and recommendations are presented for both Windows and Linux scenarios, or explicitly state when guidance is OS-agnostic.
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. In sections where both Windows and Linux are relevant (such as SKU availability), Windows examples and commands are presented before Linux ones. The automation section provides both Azure CLI (cross-platform) and Azure PowerShell (Windows-centric) examples, but does not mention Bash scripting or Linux-native automation tools. The UI walkthroughs and screenshots are based on the Azure Portal, which is platform-agnostic, but there is no mention of Linux-specific considerations or parity checks.
Recommendations
- Present Linux and Windows options in parallel or alternate their order to avoid always listing Windows first.
- Include Bash scripting examples alongside PowerShell for automation, especially for Linux users.
- Explicitly mention that Azure CLI commands work on both Windows and Linux, and provide sample shell environments (e.g., Bash, zsh) where appropriate.
- If there are any Linux-specific considerations or limitations, call them out explicitly.
- Add a note or section on deploying and managing App Service plans from Linux environments, including any differences in experience or tooling.
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-based Node.js applications running on Azure App Service, specifically using iisnode. All configuration, troubleshooting, and operational guidance is tailored to Windows environments, with exclusive references to Windows tools (IIS, iisnode, web.config, named pipes, Win32 error codes, Kudu CMD/PowerShell), and no mention of Linux equivalents or cross-platform approaches. There are no examples or instructions for Linux-based App Service environments.
Recommendations
- Provide equivalent guidance and examples for Node.js applications running on Azure App Service for Linux, including configuration, troubleshooting, and diagnostics.
- Include Linux-specific tools and patterns (e.g., PM2, systemd, nginx, environment variables) alongside or before Windows-specific ones.
- Offer parallel code/configuration snippets for both Windows (web.config/iisnode) and Linux (e.g., process.json for PM2, nginx config).
- Reference Linux file paths, error logs, and diagnostic approaches (e.g., /home/LogFiles, journalctl, tailing logs) where appropriate.
- Clarify at the top of the document that the content is Windows-specific, and link to a Linux-focused best practices page if available.
- Avoid assuming the use of Windows-only features (like named pipes, Win32 error codes, web.config) without noting their absence or alternatives on Linux.
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
Missing Linux Example
Summary
The documentation page demonstrates a mild Windows bias. Windows-related information and examples are often presented before Linux equivalents, and PowerShell scripting is given equal prominence to Azure CLI, but without any Linux shell (bash) scripting examples. The automation section provides both Azure CLI and PowerShell examples, but does not include a bash script or Linux-specific automation workflow. Additionally, the portal-based instructions do not clarify cross-platform differences, and the 'Development tools' section references UI elements without noting any OS-specific behaviors.
Recommendations
- Provide Linux shell (bash) script examples alongside Azure CLI and PowerShell, especially in the automation section.
- When listing SKU availability commands, present Linux and Windows commands in parallel, or clarify that both are equally supported.
- Explicitly mention any differences in portal experience or tooling between Windows and Linux where relevant.
- Add a section or callout for Linux users, highlighting any unique considerations or best practices for Linux App Service plans.
- Ensure that all scripting and automation guidance is cross-platform, or clearly indicate when a tool or workflow is Windows-specific.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/deploy-run-package.md
...s/blob/main/articles/app-service/deploy-run-package.md
High Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Missing Linux Example
Summary
The documentation page demonstrates a Windows-first bias by referencing Windows file paths (e.g., D:\home\site\wwwroot) before Linux equivalents, and by providing detailed operational instructions and examples using Windows-style paths. There is a lack of Linux-specific examples or parity in instructions, and Windows patterns/tools are mentioned exclusively or with greater detail.
Recommendations
- Provide Linux file path examples (e.g., /home/site/wwwroot) alongside or before Windows paths in all relevant sections.
- Include explicit Linux-specific instructions or notes where operational differences exist (such as file system permissions or path separators).
- Ensure all deployment and troubleshooting steps reference both Windows and Linux environments equally, including directory creation and file placement.
- Add Linux terminal command examples where appropriate, especially for manual steps (e.g., creating directories or files).
- Review all references to Windows tools or patterns and ensure Linux alternatives are mentioned with equal prominence.
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
Windows Tools
Missing Linux Example
Windows First
Summary
The documentation page demonstrates a Windows bias by providing only PowerShell examples for per-app scaling, referencing Azure PowerShell cmdlets exclusively, and omitting equivalent CLI or Linux-native instructions. There are no Bash, Azure CLI, or cross-platform scripting examples, and the PowerShell approach is presented first and solely for command-line configuration.
Recommendations
- Add equivalent Azure CLI (az) examples for all PowerShell cmdlet instructions, as Azure CLI is cross-platform and widely used on Linux and macOS.
- Include Bash scripting examples where appropriate, especially for configuring app settings or deploying ARM templates.
- Explicitly mention that PowerShell examples can be run on any platform with PowerShell Core, or clarify platform requirements.
- Reorder or parallelize sections so that PowerShell and CLI/Linux-native instructions are presented together, avoiding a 'Windows-first' impression.
- Reference Linux tools or workflows where relevant, such as using curl or jq for REST API calls, or deploying with Terraform.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/troubleshoot-performance-degradation.md
...es/app-service/troubleshoot-performance-degradation.md
High Priority
View Details →
Detected Bias Types
Powershell Heavy
Windows Tools
Windows First
Missing Linux Example
Summary
The documentation page demonstrates a Windows bias by focusing on Windows-specific tools (IIS, Procdump, PowerShell), referencing Windows terminology (web.config, IIS logs), and providing examples or links that are Windows-centric. There is little to no mention of Linux-specific equivalents or guidance for Linux-based App Service environments, and PowerShell is referenced as the primary CLI tool for management. Diagnostic and troubleshooting steps are described in terms of Windows tools and patterns, with Linux parity missing throughout.
Recommendations
- Include Linux-specific instructions and examples for enabling diagnostics, collecting logs, and troubleshooting (e.g., reference Linux log file locations, use of SSH, and Linux-native tools).
- When mentioning PowerShell, also provide equivalent Azure CLI (az) commands and Bash examples.
- Clarify which features or steps apply to both Windows and Linux App Service plans, and note any differences.
- Reference Linux equivalents for tools like Procdump (e.g., gcore, gdb, or dotnet-dump for .NET apps on Linux).
- Provide links to Linux-focused documentation where available (e.g., enabling diagnostic logging on Linux App Service).
- Avoid using Windows terminology (such as web.config, IIS, or DOS commands) without also mentioning Linux equivalents (such as appsettings.json, Kestrel, or Bash commands).
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 exhibits subtle Windows bias by referencing Azure Storage Explorer with a direct link to its Windows tab and not mentioning Linux alternatives or parity. There are no explicit Linux or cross-platform instructions for uploading files or generating SAS tokens, and the only GUI tool mentioned is Storage Explorer, which is often associated with Windows. All command-line examples use Azure CLI, which is cross-platform, but the lack of Linux-specific guidance or examples (such as using azcopy, native Linux tools, or Storage Explorer on Linux) may leave Linux users underserved.
Recommendations
- Explicitly mention that Azure Storage Explorer is available for Windows, macOS, and Linux, and provide links or instructions for all platforms.
- Include alternative command-line methods for uploading files and generating SAS tokens, such as using azcopy or Azure CLI commands, which work on Linux.
- Avoid linking directly to Windows-specific tabs or instructions; use platform-neutral links or provide parallel instructions for Linux/macOS.
- Add a note or section for Linux users, highlighting any differences or additional steps required.
- Where GUI tools are mentioned, suggest equivalent CLI workflows for users who prefer or require command-line operations.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/configure-language-dotnet-framework.md
...les/app-service/configure-language-dotnet-framework.md
High Priority
View Details →
Detected Bias Types
Windows First
Missing Linux Example
Windows Tools
Powershell Heavy
Summary
The documentation page demonstrates a Windows bias by focusing exclusively on Windows-based deployment and configuration patterns for ASP.NET apps. It references Windows-specific tools (Visual Studio, Kudu, CMD, PowerShell), provides only Windows file paths and commands, and omits Linux-based equivalents or examples. There is no mention of how to perform these tasks on Linux-based App Service plans or containers, nor are Linux shell commands or tools referenced.
Recommendations
- Add equivalent Linux-based instructions and examples for each configuration task, especially for listing .NET Framework/Mono runtimes and accessing diagnostic logs.
- Include Linux shell (bash) commands and file paths alongside CMD/PowerShell examples.
- Clarify which instructions apply to Windows App Service plans and which to Linux, and provide parity in coverage.
- Reference cross-platform deployment tools (such as Azure CLI, Git, or VS Code) in addition to Visual Studio.
- Provide guidance for users deploying to Linux containers or App Service on Linux, including how to set environment variables and access logs.
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 server-level data sources in Tomcat, but the Windows section is longer, more detailed, and uses Windows-specific tools (PowerShell, .cmd files, Windows environment variables) without always providing Linux equivalents or parity in explanation. Windows instructions are more step-by-step and reference Windows tools and patterns (e.g., PowerShell scripts, .cmd startup files) extensively, while Linux instructions are more concise and assume familiarity with shell scripting and Linux package management. In some places, the Windows approach is described first or in more detail, and the Linux approach is less elaborated.
Recommendations
- Ensure that Linux and Windows sections are equally detailed, with step-by-step instructions and explanations for both platforms.
- Where Windows-specific tools (e.g., PowerShell, .cmd) are used, provide Linux equivalents (e.g., Bash scripts) and explain their usage in similar depth.
- Present Linux and Windows instructions in parallel or side-by-side, rather than giving more prominence or detail to Windows.
- Avoid assuming more technical familiarity for Linux users; provide clear, beginner-friendly guidance for both platforms.
- Where possible, use cross-platform tools (e.g., Azure CLI, Bash scripts) in examples, or provide both Windows and Linux command/script samples.
- Review the order of presentation to avoid implicit prioritization of Windows approaches.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/includes/deploy-intelligent-apps/deploy-intelligent-apps-linux-dotnet-pivot.md
...ent-apps/deploy-intelligent-apps-linux-dotnet-pivot.md
High Priority
View Details →
Detected Bias Types
Windows First
Missing Linux Example
Windows Tools
Summary
The documentation demonstrates a Windows bias by prioritizing Windows-centric tools and workflows (e.g., Visual Studio, right-click actions, NuGet Package Manager) and omitting explicit Linux or cross-platform alternatives. There are no Linux-specific instructions or examples for common tasks such as file creation, package installation, or deployment, and the CLI instructions are referenced only as secondary options. The documentation assumes a GUI-based development environment typical of Windows, with no mention of Linux editors, terminal commands, or deployment nuances.
Recommendations
- Provide explicit Linux and cross-platform instructions for all steps, including file creation (e.g., using 'touch' and editors like 'vim' or 'nano'), package installation (e.g., using 'dotnet add package'), and deployment.
- List CLI-based instructions before or alongside GUI-based (Visual Studio) instructions to ensure parity.
- Reference cross-platform tools (e.g., VS Code, dotnet CLI) equally or before Windows-only tools.
- Include screenshots or code snippets that show Linux terminal usage where appropriate.
- Clarify that all steps can be performed on Linux and provide troubleshooting tips for common Linux-specific issues.
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-specific deployment methods (Web Deploy) are described in detail, with explicit instructions to use Windows agents and references to IIS and web.config. Linux deployment is mentioned as an option, but Linux-specific examples, troubleshooting, or tools are lacking. The primary detailed example for deploying with Web Deploy is only for Windows, and the FAQ reinforces this by stating Web Deploy is only supported on Windows agents. There are no Linux shell or command-line examples, and Windows patterns (such as web.config and IIS) are referenced without Linux equivalents.
Recommendations
- Provide equivalent Linux deployment examples, such as using zip deploy or FTP/SFTP, and include Linux-specific troubleshooting steps.
- When mentioning deployment methods like Web Deploy, also highlight and provide examples for Linux-friendly alternatives (e.g., Kudu REST API, zip deploy, or container-based deployments).
- Avoid referencing Windows tools (e.g., IIS, web.config) without mentioning Linux equivalents (e.g., Nginx, Gunicorn, app.yaml for Python, etc.) where appropriate.
- Ensure that all YAML and Classic pipeline examples show both Windows and Linux agent configurations, and clarify any differences in steps or requirements.
- Include at least one end-to-end example for a Linux-based stack (e.g., Node.js or Python on Linux App Service) with Linux agent, including build, publish, and deploy steps.
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 page demonstrates a moderate Windows bias. While it does mention 'web app on Linux' in the introduction and uses Azure CLI (which is cross-platform) for most command-line examples, several aspects reveal a Windows-centric approach: PowerShell examples are always provided alongside CLI, sometimes with more detail; Windows-specific tools and configuration patterns (such as Web.config and IIS applicationInitialization) are referenced without Linux equivalents; and troubleshooting and advanced configuration sections assume a Windows environment (e.g., file paths, IIS rewrite rules). There are no explicit Linux-specific examples or notes for Linux-based App Service scenarios, and some features (like auto swap) are noted as unsupported on Linux, but without alternative guidance.
Recommendations
- Provide explicit Linux-specific examples or notes where features differ (e.g., clarify how to handle warm-up and swap on Linux-based App Service, or what configuration files/settings are relevant).
- When referencing Windows-specific tools or configuration (such as Web.config, IIS, or PowerShell), add equivalent guidance for Linux (e.g., appsettings.json, startup scripts, or Bash/Cloud Shell commands).
- In troubleshooting sections, include Linux-relevant file paths, logs, and error handling steps.
- Where features are unsupported on Linux (e.g., auto swap), suggest alternative workflows or workarounds for Linux users.
- Ensure parity in detail and clarity between PowerShell and CLI examples, and consider leading with CLI (cross-platform) examples rather than PowerShell (Windows-centric).
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 a moderate Windows bias, particularly in the .NET section, where Windows tools (Visual Studio, Azure PowerShell) are listed before cross-platform or Linux-native tools. The 'Next step' callout exclusively promotes deploying an ASP.NET app (a Windows-centric stack). In the Python section, example links default to 'windows' tabs, and PowerShell is offered as a primary automation tool in .NET. Linux-specific examples are present but often secondary or less emphasized, and in some stacks (e.g., PHP), only Linux is mentioned, but overall parity is inconsistent.
Recommendations
- Ensure that for every Windows tool or example (e.g., Visual Studio, PowerShell), a Linux equivalent (e.g., VS Code, Azure CLI, Bash) is provided and given equal prominence.
- Avoid listing Windows tools first by default; alternate the order or group by platform.
- In call-to-action/next-step sections, provide options for both Windows and Linux stacks, or make the next step stack-agnostic.
- For Python and other cross-platform stacks, ensure that example links and tabs do not default to 'windows' but offer both 'windows' and 'linux' options equally.
- Where PowerShell is mentioned, also mention Bash/Azure CLI equivalents.
- Audit all quickstart and tutorial links to ensure Linux users are not required to adapt Windows-centric instructions.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/overview-inbound-outbound-ips.md
.../articles/app-service/overview-inbound-outbound-ips.md
High Priority
View Details →
Detected Bias Types
Windows First
Powershell Heavy
Missing Linux Example
Summary
The documentation provides both Azure CLI and Azure PowerShell examples for retrieving outbound IP addresses, but PowerShell examples are always presented immediately after CLI, and there are no explicit Linux shell or Bash script examples beyond the basic nslookup and curl commands. The note about outbound IPv6 support is Windows-specific, and there is no mention of Linux-specific tools or parity in outbound IPv6 support. The documentation assumes familiarity with Windows-centric tools (PowerShell) and features, and does not provide Linux-first or Linux-specific guidance where differences exist.
Recommendations
- When presenting command-line examples, alternate the order of Azure CLI and PowerShell, or clearly indicate that Azure CLI is cross-platform and preferred for Linux/macOS users.
- Explicitly state that Azure CLI commands work on Linux, macOS, and Windows, and provide Bash script examples for common tasks where appropriate.
- Where outbound IPv6 support is Windows-only, clarify the lack of Linux support and provide a roadmap or workaround for Linux users if possible.
- Include Linux-native tools (e.g., dig, ip, ifconfig) in examples where relevant, especially for network troubleshooting.
- Add a section or callout summarizing any platform-specific limitations or differences, especially regarding outbound IPv6 support.
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 Azure PowerShell examples and references, which are primarily Windows-centric. PowerShell is featured prominently alongside Azure CLI, and in some cases, PowerShell is the only scripting example provided for certain tasks (e.g., assigning user-assigned identities to Functions). There is no mention of Linux-specific shell commands or tools (such as Bash scripts or curl/wget for HTTP requests), and PowerShell is presented as a default automation tool, which may not be as familiar or available to Linux users. Additionally, PowerShell examples are sometimes given before or instead of more cross-platform alternatives.
Recommendations
- Add Bash or shell script examples for all tasks currently demonstrated with PowerShell, especially for token retrieval and identity assignment/removal.
- Where HTTP requests are shown, provide curl or wget command-line examples in addition to PowerShell's Invoke-RestMethod.
- Clarify that Azure CLI is fully cross-platform and, where possible, prefer it over PowerShell for automation examples.
- Explicitly mention Linux/macOS compatibility in relevant sections, and ensure that all code snippets are runnable on those platforms.
- For sections where PowerShell is the only option (e.g., assigning user-assigned identities to Functions), state the limitation clearly and provide any available workarounds for Linux users.