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 1001-1025 of 2121 flagged pages
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/configure-language-php.md
...ob/main/articles/app-service/configure-language-php.md
High Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Powershell Heavy
Missing Linux Example
Summary
The documentation is structured with a clear separation between Windows and Linux instructions using platform pivots. However, several sections (notably 'Run Composer', 'Run Bower, Gulp, or Grunt') provide detailed, step-by-step deployment automation examples only for Windows (using KuduScript and npm), with no equivalent Linux guidance. Some Windows-specific tools and paths (e.g., KuduScript, d:\ paths) are mentioned, and in a few cases, Windows instructions or tools are described before Linux equivalents, indicating a 'windows_first' bias. There are also areas where Linux users are left to infer or research their own solutions, especially regarding custom deployment scripts and automation.
Recommendations
- Provide equivalent, detailed Linux examples for deployment automation tasks (e.g., running Composer, Bower, Gulp, Grunt) rather than only describing the Windows/KuduScript approach.
- Where Windows-specific tools (like KuduScript) are mentioned, clarify their availability or alternatives for Linux users, or provide Linux-native instructions.
- Ensure that both Windows and Linux pivots receive equal depth of explanation and example code, especially for common developer workflows.
- Avoid always presenting Windows instructions or tools first; consider alternating or presenting both platforms in parallel where possible.
- For Linux, include more practical examples for customizing deployment scripts, running build tools, and managing extensions, to match the detail given for Windows.
Create Pull Request
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/deploy-best-practices.md
...lob/main/articles/app-service/deploy-best-practices.md
High Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Missing Linux Example
Summary
The documentation demonstrates a subtle Windows bias by referencing Windows-specific tools (such as WebDeploy and Kudu's Windows process) before or more prominently than their Linux equivalents. There is a lack of explicit Linux command-line examples (e.g., SCP, SFTP, rsync) for deployment, and the documentation does not provide parity in describing Linux-native workflows or tools. The Kudu section describes its operation on Windows in more detail than on Linux. WebDeploy, a Windows-centric tool, is mentioned without Linux alternatives. No Linux shell or cross-platform deployment examples are provided outside of the GitHub Actions YAML, which is generic.
Recommendations
- Add explicit Linux-native deployment examples (e.g., using SCP, SFTP, rsync, or Azure CLI from a Linux shell) alongside or before Windows tools.
- Clarify Kudu's operation on both Windows and Linux App Service plans, giving equal detail for both.
- When mentioning WebDeploy (a Windows tool), also mention and provide guidance for Linux users (e.g., using FTP, Azure CLI, or other cross-platform tools).
- Provide sample deployment commands/scripts for both PowerShell/Windows CMD and Bash/Linux shell.
- Review the order of tool presentation to avoid always listing Windows tools or patterns first.
- Where possible, use neutral, cross-platform language and examples, or explicitly call out differences and options for both Windows and Linux users.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/configure-ssl-app-service-certificate.md
...s/app-service/configure-ssl-app-service-certificate.md
High Priority
View Details →
Detected Bias Types
Powershell Heavy
Windows First
Missing Linux Example
Summary
The documentation provides command-line examples for Azure CLI and Azure PowerShell, but does not include Linux-native or cross-platform shell (e.g., Bash) examples beyond Azure CLI. PowerShell is featured as a distinct section, and the FAQ references PowerShell specifically. There are no explicit Linux-specific tools or workflows mentioned, and no guidance for Linux certificate management outside of Azure CLI. The documentation does not mention or address Linux certificate stores, OpenSSL, or other common Linux patterns, and the ordering of examples places PowerShell after CLI but before any Linux-native approach (which is absent).
Recommendations
- Add explicit Bash or Linux-native examples for certificate export and management, especially for scenarios outside Azure CLI.
- Include references to common Linux tools (e.g., OpenSSL) for handling .pfx files after export, such as converting or installing certificates.
- In the FAQ, address Linux users by providing troubleshooting steps relevant to Linux environments (e.g., how to check certificate status or export using Bash/OpenSSL).
- Ensure parity in example ordering: if PowerShell is included, also include Bash or Linux shell examples, and consider presenting CLI/Bash before PowerShell.
- Mention any OS-specific considerations for importing/exporting certificates, such as differences in certificate stores or required tools on Linux.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/deploy-continuous-deployment.md
...n/articles/app-service/deploy-continuous-deployment.md
High Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Missing Linux Example
Summary
The documentation page demonstrates subtle Windows bias. The 'External Git' section explicitly states it is for 'Windows apps', with no mention of Linux or cross-platform scenarios. There are no examples or guidance for Linux-based deployments, nor are Linux-specific tools or workflows referenced. The documentation assumes a Windows-centric context in some areas and omits parity for Linux users.
Recommendations
- Clarify whether 'External Git' is supported for Linux apps, and if so, provide explicit instructions or examples for Linux-based deployments.
- Wherever a feature or workflow is described as 'for Windows apps', add a corresponding note or section for Linux apps, or state clearly if not supported.
- Include Linux-specific or cross-platform examples and references, especially in sections discussing manual deployment or advanced configuration.
- Review screenshots and UI references to ensure they are not Windows-specific, or provide Linux equivalents if the portal experience differs.
- Audit related links and references to ensure they include Linux-relevant documentation and troubleshooting resources.
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
Powershell Heavy
Windows First
Windows Tools
Missing Linux Example
Summary
The documentation demonstrates a moderate Windows bias. PowerShell is featured prominently, with a dedicated section and detailed steps, while Linux-specific shell or Bash examples are limited. The troubleshooting section references Windows-specific errors (e.g., native modules lacking Windows binaries), and the PowerShell workflow is described in detail. There is no explicit Linux or macOS terminal walkthrough for the same tasks, and the use of PowerShell is presented before or alongside CLI/portal options, but not after a Linux/Bash example. Some instructions (e.g., 'local terminal') are ambiguous but default to Windows/PowerShell context.
Recommendations
- Add explicit Linux/macOS terminal (Bash) walkthroughs for all steps, especially for creating/configuring the app and setting deployment branch.
- Ensure that CLI examples are presented before PowerShell, or provide parallel Linux and Windows instructions side-by-side.
- Include troubleshooting notes for common Linux/macOS issues (e.g., permissions, case sensitivity, SSH agent problems) alongside Windows-specific notes.
- Clarify when instructions are OS-agnostic and when they are specific to Windows or Linux, and use neutral terms like 'terminal' instead of 'PowerShell terminal' unless necessary.
- Reference Linux tools and patterns (e.g., Bash, zsh, Linux file paths) where appropriate, and avoid assuming Windows as the default environment.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/deploy-run-package.md
...s/blob/main/articles/app-service/deploy-run-package.md
High Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Missing Linux Example
Summary
The documentation page exhibits a Windows-first bias by referencing Windows file paths (e.g., D:\home\site\wwwroot) before Linux equivalents, using backslash path separators, and describing deployment behaviors primarily in Windows terms. There is a lack of explicit Linux/macOS command-line examples, and some instructions (such as manual file placement) only mention Windows-style paths. The documentation also refers to Windows-centric tools and patterns (e.g., backslash paths, drive letters) without always providing Linux alternatives or parity.
Recommendations
- Present Linux and Windows file paths together in all relevant sections (e.g., D:\home\site\wwwroot (Windows) and /home/site/wwwroot (Linux)).
- Include Linux/macOS-specific command-line examples and clarify any differences in behavior or file locations.
- Use forward slashes in file paths or provide both path formats where appropriate.
- Explicitly mention when instructions or behaviors differ between Windows and Linux App Service environments.
- Add troubleshooting notes or caveats for Linux users where necessary (e.g., file permissions, directory structure).
- Ensure parity in tool recommendations, avoiding exclusive references to Windows tools or patterns.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/environment/overview-certificates.md
...icles/app-service/environment/overview-certificates.md
High Priority
View Details →
Detected Bias Types
Powershell Heavy
Windows First
Missing Linux Example
Windows Tools
Summary
The documentation page demonstrates a Windows bias by providing only PowerShell commands and examples for certificate management, referencing Windows-specific certificate stores (e.g., Cert:\LocalMachine\Root), and explicitly stating that private client certificates are only supported from custom code in Windows code apps. There are no equivalent Linux or cross-platform instructions, and Linux scenarios are not addressed.
Recommendations
- Provide equivalent Linux instructions for uploading and managing certificates, including examples using Bash, OpenSSL, and Linux file paths.
- Clarify support for Linux-based App Service apps, including any limitations or alternative approaches.
- Include cross-platform or platform-agnostic examples where possible, or clearly label Windows-specific steps.
- Offer guidance for checking certificate installation and trust stores on Linux-based App Service workers (e.g., using Bash and OpenSSL commands).
- Explicitly state any feature parity gaps between Windows and Linux App Service environments, and link to relevant Linux documentation if available.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/deploy-zip.md
...zure-docs/blob/main/articles/app-service/deploy-zip.md
High Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Missing Linux Example
Summary
The documentation demonstrates some Windows bias, particularly in the following areas: (1) Windows paths and behaviors are often mentioned first or exclusively (e.g., 'D:\home\site\wwwroot' before '/home/site/wwwroot'); (2) The Kudu UI ZIP deploy method is only available for Windows, with Linux users told to use alternative methods; (3) The use of the Azure portal's 'Advanced Tools' (Kudu) is a Windows-centric workflow, and instructions for Linux users are less direct; (4) Some examples and notes (such as startup script deployment) reference Windows-specific paths or behaviors before Linux equivalents; (5) There are no Linux shell or SCP/rsync examples, and no mention of Linux-native tools for file transfer or deployment.
Recommendations
- When mentioning file paths or behaviors, present Linux and Windows variants equally, or mention Linux first where appropriate.
- Provide explicit Linux-native examples (e.g., using SCP, rsync, or Linux shell commands) for file deployment scenarios.
- Clarify which features are Windows-only and provide clear, step-by-step alternatives for Linux users, not just links.
- Where the Azure portal or Kudu UI is referenced, note the parity or lack thereof for Linux, and suggest equivalent Linux-friendly workflows.
- Avoid using Windows-centric terminology or tools as the default; instead, use cross-platform tools (like Azure CLI and cURL) as primary examples.
- Add a table or section summarizing feature parity and differences between Windows and Linux App Service environments.
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 demonstrates a moderate Windows bias, particularly in the .NET and Python sections. Windows tools like Visual Studio and Azure PowerShell are listed before cross-platform or Linux-native tools, and some quickstart links default to Windows or PowerShell tabs. In the Python section, the quickstart links include 'windows' in their tab parameters, suggesting a Windows-first approach. Linux-specific instructions are present but often secondary or less prominent. Other stacks (Java, Node.js, PHP) are more balanced or Linux-focused.
Recommendations
- Ensure that Linux and cross-platform tools (e.g., VS Code, CLI, Azure CLI) are listed before or alongside Windows-specific tools in all tables and quickstarts.
- For .NET and Python, provide explicit Linux/WSL and macOS instructions and examples, not just Windows/PowerShell.
- Avoid defaulting quickstart links to Windows tabs; use neutral or user-selectable defaults.
- Where Azure PowerShell is mentioned, also mention Azure CLI and Bash equivalents, especially for deployment and management tasks.
- Audit all quickstart and tutorial links to ensure Linux parity in instructions, screenshots, and code samples.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/environment/app-service-app-service-environment-geo-distributed-scale.md
...-service-app-service-environment-geo-distributed-scale.md
High Priority
View Details →
Detected Bias Types
Powershell Heavy
Missing Linux Example
Windows Tools
Windows First
Summary
The documentation page exclusively uses Azure PowerShell commands to demonstrate how to configure Traffic Manager and App Service Environments. There are no examples or references to equivalent steps using Azure CLI, Bash, or other cross-platform tools. The only automation approach shown is PowerShell, which is most commonly associated with Windows environments. This creates a bias toward Windows users and may hinder Linux/macOS users or those who prefer cross-platform tooling.
Recommendations
- Provide equivalent Azure CLI (az) command examples alongside the PowerShell examples for all resource creation and configuration steps.
- Explicitly mention that all steps can be performed from Linux/macOS using Azure CLI or the Azure Portal, and provide links or brief instructions.
- Include Bash script snippets or references for DNS lookups and other command-line tasks, not just screenshots.
- Reorganize sections so that cross-platform tools (Azure CLI, Portal) are mentioned before or alongside PowerShell, rather than PowerShell being the only or primary method.
- Add a note clarifying that PowerShell is available on Linux/macOS, but highlight the availability and parity of Azure CLI for users on all platforms.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/configure-ssl-bindings.md
...ob/main/articles/app-service/configure-ssl-bindings.md
High Priority
View Details →
Detected Bias Types
Powershell Heavy
Windows First
Missing Linux Example
Summary
The documentation page demonstrates a Windows bias by providing a PowerShell automation example but omitting equivalent Linux/bash examples. The scripting section lists PowerShell after Azure CLI, but only the PowerShell script is shown inline, with no Bash or Linux shell script provided. There is also a lack of explicit Linux tooling or command-line workflow guidance, and the automation focus is on Windows-native scripting environments.
Recommendations
- Add a Bash or shell script example for automating certificate binding, similar to the PowerShell example.
- Ensure that Azure CLI examples are shown inline, not just linked, and clarify that Azure CLI is cross-platform.
- Where scripting is discussed, explicitly mention that all steps can be performed on Linux, macOS, or Windows, and provide parity in example scripts.
- If referencing PowerShell, note that PowerShell Core is cross-platform, or provide both Windows PowerShell and Bash alternatives.
- Include screenshots or workflow notes for Linux users where UI or file paths may differ.
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 several sections, Windows or PowerShell tools and workflows are presented before or more prominently than their Linux equivalents. For example, the Azure PowerShell example is given its own section, while Linux-specific scripting or Bash examples are not provided. The portal UI instructions and screenshots are Windows-centric, and there is no mention of Linux command-line environments beyond the Azure CLI. Additionally, the 'Development tools' and 'Clone app' features are described without clarifying cross-platform parity.
Recommendations
- Provide Bash or Linux shell script equivalents alongside PowerShell examples, especially in automation sections.
- Clarify that Azure CLI commands work identically on Linux, macOS, and Windows, and consider including sample shell commands for Linux users.
- Balance the order of presentation: when listing tools or commands, alternate or parallelize Windows and Linux instructions.
- Include screenshots or instructions for Linux/macOS users where the experience differs, or explicitly state when the experience is the same.
- Explicitly mention cross-platform compatibility for features like 'Clone app' and 'Development tools', or note any platform-specific limitations.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/overview-webjobs.md
...ocs/blob/main/articles/app-service/overview-webjobs.md
High Priority
View Details →
Detected Bias Types
Windows First
Missing Linux Example
Windows Tools
Summary
The documentation page demonstrates a Windows bias by prioritizing Windows-specific tools and workflows (such as Visual Studio deployment to Windows App Service) and omitting explicit Linux deployment examples or Linux-native tools. The deployment section mentions Visual Studio deployment specifically for Windows App Service, and there are no Linux-specific instructions or examples. References to Kudu and App Service diagnostics are present, but these are available on both platforms; however, the lack of parity in deployment guidance is notable.
Recommendations
- Add explicit examples and instructions for deploying WebJobs to Linux-based App Service plans, including using cross-platform tools such as Azure CLI, zip deployment, and GitHub Actions.
- Clarify in the deployment section which methods are supported on Linux App Service (e.g., Visual Studio deployment is Windows-only, but zip deployment and CI/CD pipelines work on both).
- Include references to Linux-compatible development environments (such as VS Code or command-line tools) alongside Visual Studio.
- Provide parity in 'Next steps' and scenario links by including Linux-focused guides or notes where applicable.
- Explicitly mention any differences or limitations when running WebJobs on Linux App Service, if relevant.
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 Windows-first bias in several ways: Windows SKUs are listed before Linux, PowerShell scripting is given equal prominence to Azure CLI (which is more cross-platform), and there are no Linux shell (bash) or deployment examples outside of the Azure CLI. The use of Windows-centric terminology and tools (e.g., PowerShell, references to Windows-specific app types) is more prominent, and Linux-specific guidance is limited to a single CLI flag. There are no explicit Linux shell or deployment workflow examples, and the documentation does not address Linux-specific considerations for automation or troubleshooting.
Recommendations
- Present Linux and Windows options in parallel, rather than listing Windows first.
- Include bash shell script examples for Linux users, not just Azure CLI and PowerShell.
- Expand automation sections to show Linux-native scripting (e.g., bash) and workflows.
- Add explicit guidance for Linux-specific deployment scenarios, such as custom containers.
- Balance terminology and examples so that Linux users see their platform equally represented.
- Where PowerShell is mentioned, also mention bash or sh equivalents for parity.
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 First
Missing Linux Example
Summary
The documentation demonstrates a Windows bias primarily in the section addressing Azure Traffic Manager endpoints, where only a PowerShell script is provided for identifying impacted resources. There are no equivalent Bash, Azure CLI, or cross-platform alternatives, and the instructions explicitly reference PowerShell usage (e.g., 'Open PowerShell and navigate to the script location'). This may disadvantage Linux or macOS users who do not have access to PowerShell or prefer native tools. In all other areas, the documentation uses Azure Resource Graph queries and Azure CLI/REST API references, which are cross-platform.
Recommendations
- Provide equivalent Bash or Azure CLI scripts for identifying Traffic Manager profiles with non-Azure endpoints, or at least reference how to run the PowerShell script using PowerShell Core on Linux/macOS.
- When referencing scripts, clarify their cross-platform compatibility (e.g., note if the PowerShell script works with PowerShell Core on Linux/macOS).
- Offer example commands using Azure CLI or REST API for all scenarios where PowerShell is suggested, ensuring Linux parity.
- In step-by-step instructions, avoid assuming the user is on Windows (e.g., 'Open PowerShell') and instead provide generic, platform-neutral guidance or alternatives.
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
Summary
The documentation page demonstrates a Windows bias by providing only PowerShell examples for per-app scaling, with no equivalent examples for Linux users (such as Azure CLI or Bash). The use of PowerShell cmdlets and Windows-centric scripting patterns may exclude or confuse users who work primarily in Linux environments.
Recommendations
- Add equivalent Azure CLI examples for all PowerShell commands shown, using Bash syntax where appropriate.
- Explicitly mention that PowerShell is not required and that Linux/macOS users can use Azure CLI or REST APIs.
- Reorder or parallelize examples so that both PowerShell and CLI/Bash approaches are presented together.
- Include a note or section on how to perform the same tasks from Linux/macOS environments.
- Ensure terminology and instructions are platform-neutral where possible, or clarify when something is Windows-specific.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/overview-vnet-integration.md
...main/articles/app-service/overview-vnet-integration.md
High Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Missing Linux Example
Summary
The documentation exhibits a mild Windows bias. Windows-specific features and limitations (such as Windows Containers subnet sizing and Windows Server Active Directory domain join) are discussed in detail, while Linux-specific scenarios receive less attention. There are no Linux command-line examples or explicit Linux configuration walkthroughs. The only explicit Linux mention is in the context of continuous deployment network dependencies, which is brief and not accompanied by broader Linux guidance or parity in examples.
Recommendations
- Add Linux-specific configuration examples, especially for common scenarios such as integrating Linux-based App Service apps with virtual networks.
- Provide parity in coverage for Linux containers, including subnet sizing, resource requirements, and limitations, similar to the detailed section for Windows Containers.
- Include CLI and scripting examples (e.g., Azure CLI, Bash) for both Windows and Linux environments where relevant.
- Highlight any Linux-specific limitations or considerations (e.g., file system mounts, networking behaviors) to ensure users on both platforms are equally informed.
- Balance the order of presentation so that Windows and Linux scenarios are introduced together, or alternate which platform is mentioned first.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/includes/tutorial-microsoft-graph-as-app/introduction.md
...cludes/tutorial-microsoft-graph-as-app/introduction.md
High Priority
View Details →
Detected Bias Types
Powershell Heavy
Windows First
Windows Tools
Summary
The documentation page demonstrates a Windows bias by providing PowerShell as the first and most detailed scripting example for assigning Microsoft Graph API permissions, referencing Visual Studio (a Windows-centric IDE) for initial setup, and using PowerShell-specific modules and cmdlets. Although an Azure CLI example is included, the prominence and order of PowerShell examples, as well as the mention of Visual Studio, indicate a preference for Windows tools and workflows.
Recommendations
- Present Azure CLI examples before or alongside PowerShell examples to avoid implying PowerShell is the primary or preferred method.
- Explicitly mention that all Azure CLI commands work cross-platform (Windows, Linux, macOS) and provide guidance for Linux/macOS users.
- Include references to Linux-friendly development environments (e.g., VS Code, command-line deployment) instead of or in addition to Visual Studio.
- Review screenshots and UI instructions to ensure they are not Windows-specific or clarify if the steps are identical across platforms.
- Add a note or section highlighting parity and any differences in experience for Linux users.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/scenario-secure-app-access-microsoft-graph-as-app.md
...e/scenario-secure-app-access-microsoft-graph-as-app.md
High Priority
View Details →
Detected Bias Types
Windows First
Powershell Heavy
Missing Linux Example
Summary
The documentation provides installation instructions for the required NuGet packages using both the .NET Core CLI and the Visual Studio Package Manager Console (PowerShell-based), but does not mention or show Linux-specific workflows or tools. The order of presentation puts the Windows-centric Visual Studio/PowerShell method after the cross-platform CLI, but the only GUI-based workflow described is for Windows. There is no mention of Linux development environments, nor are there any Linux-specific troubleshooting or usage notes.
Recommendations
- Explicitly mention that the .NET Core CLI commands work on Linux, macOS, and Windows, and recommend them as the primary cross-platform method.
- Add a note or section for Linux users, e.g., how to install .NET SDK and run the commands on Linux.
- If GUI-based instructions are included for Visual Studio (Windows), consider adding equivalent instructions for Visual Studio Code, which is cross-platform.
- Avoid referencing only Windows tools (like Package Manager Console) without mentioning cross-platform alternatives.
- Include troubleshooting tips or environment setup notes for Linux users, such as setting environment variables for managed identities.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/configure-ssl-bindings.md
...ob/main/articles/app-service/configure-ssl-bindings.md
High Priority
View Details →
Detected Bias Types
Windows First
Powershell Heavy
Missing Linux Example
Summary
The documentation page demonstrates a mild Windows bias. While the main instructions are GUI-based (Azure Portal) and thus cross-platform, the 'Automate with scripts' section lists Azure CLI first but provides only a direct PowerShell script example, with no corresponding Bash/Linux shell script or explicit Linux automation guidance. There are no explicit Linux command-line examples, and PowerShell is highlighted via metadata and code inclusion. The page does mention a Linux-specific Node.js configuration guide, but only in passing.
Recommendations
- Provide explicit Bash/Linux shell script examples for automating certificate binding, alongside PowerShell.
- Ensure parity in automation examples by including both Azure CLI and PowerShell code blocks directly in the documentation, not just as links.
- Review metadata (such as ms.custom: devx-track-azurepowershell) to ensure it does not signal a Windows/PowerShell preference unless justified.
- Where scripting is discussed, clarify that Azure CLI is cross-platform and provide usage examples for both Windows and Linux environments.
- Consider including a section or callout for Linux users, especially for common tasks like uploading certificates or troubleshooting.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/app-service-configure-premium-v4-tier.md
...s/app-service/app-service-configure-premium-v4-tier.md
High Priority
View Details →
Detected Bias Types
Windows First
Powershell Heavy
Windows Tools
Summary
The documentation demonstrates a mild Windows bias by consistently mentioning Windows scenarios and tools first, providing Azure PowerShell examples (which are most commonly used on Windows), and referencing Windows-specific patterns (such as the distinction between Windows and Linux SKUs) before their Linux equivalents. While Linux is supported and Linux-specific commands are present, Windows is generally foregrounded in explanations and examples.
Recommendations
- Alternate the order of Windows and Linux instructions/examples throughout the documentation, or present them in parallel to avoid the perception of prioritizing one platform.
- Provide Bash or shell script automation examples alongside PowerShell, especially in the 'Automate with scripts' section, to ensure parity for Linux users.
- When referencing platform-specific features or limitations (such as SKU availability), clearly separate Windows and Linux guidance, and ensure both are equally detailed.
- Explicitly mention cross-platform compatibility for tools like Azure CLI, and clarify that PowerShell Core is available on Linux and macOS, or provide Bash equivalents.
- In the prerequisites and introductory sections, avoid defaulting to Windows terminology or patterns unless necessary.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/app-service-web-configure-tls-mutual-auth.md
...p-service/app-service-web-configure-tls-mutual-auth.md
High Priority
View Details →
Detected Bias Types
Windows First
Powershell Heavy
Windows Tools
Summary
The documentation demonstrates a moderate Windows bias. It provides detailed C#/.NET (ASP.NET Core and Web Forms) code samples first and in greater depth compared to other languages. The .NET samples are inherently Windows-centric, and the use of terms and patterns like 'HttpRequest.ClientCertificate' and 'System.Web' are specific to Windows/IIS environments. There is no mention of Linux-specific tools or command-line patterns (e.g., bash, OpenSSL, curl), and the documentation does not provide Linux shell or configuration examples for mutual TLS setup. The Azure CLI and Bicep/ARM examples are cross-platform, but the lack of Linux-focused troubleshooting, validation, or deployment steps (such as using OpenSSL to test mutual TLS) further highlights the bias.
Recommendations
- Add Linux-specific examples for validating mutual TLS, such as using OpenSSL or curl to test client certificate authentication.
- Provide equivalent shell (bash) commands for enabling client certificates and configuring exclusion paths, in addition to Azure CLI.
- Include troubleshooting steps or validation techniques that are common in Linux environments (e.g., using tcpdump, OpenSSL s_client).
- Balance the order of language samples, perhaps starting with a cross-platform language (like Node.js or Python) before Windows-centric .NET.
- Explicitly mention that the code samples are cross-platform where applicable, and clarify any Windows-only limitations.
- Reference Linux tools and patterns (such as /etc/ssl, certificate stores, or environment variables) where relevant.
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
Missing Linux Example
Summary
The documentation demonstrates a mild Windows bias. Windows-specific terminology and tools (such as Azure PowerShell and references to Windows containers) are introduced before or more prominently than their Linux counterparts. PowerShell scripting is given a dedicated section, but there is no equivalent example for Linux shell scripting (e.g., Bash). While Azure CLI is cross-platform, the documentation does not provide Linux-specific automation or deployment examples, and the PowerShell example uses Windows-centric parameters (e.g., WorkerSize values like 'Small', 'Medium', 'Large'). The portal instructions and screenshots do not clarify whether steps differ for Linux vs. Windows apps, and Linux container scenarios are mentioned only in passing.
Recommendations
- Provide explicit Bash shell scripting examples for Linux users alongside PowerShell examples.
- Clarify in portal instructions and screenshots whether steps differ for Linux vs. Windows App Service apps.
- When listing automation options, present Azure CLI (cross-platform) before PowerShell, and note that CLI is suitable for both Linux and Windows environments.
- Expand on Linux container scenarios with concrete examples or links to Linux-specific guidance.
- Where parameters or options differ between Windows and Linux (such as WorkerSize or available SKUs), call out those differences explicitly.
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 First
Missing Linux Example
Summary
The documentation demonstrates Windows bias primarily in the guidance for identifying Azure Traffic Manager profiles with unsupported endpoints. It exclusively recommends and documents a PowerShell script for this task, with no mention of Bash, Azure CLI, or cross-platform alternatives. The instructions for running the script assume a Windows/PowerShell environment, and there are no Linux/macOS-specific examples or guidance. Elsewhere, the documentation is more neutral, using REST API and Azure CLI references, but the lack of parity in the Traffic Manager scenario stands out.
Recommendations
- Provide an equivalent Bash or Azure CLI script for identifying Traffic Manager profiles with non-Azure endpoints, or document how to perform this task using cross-platform tools.
- Explicitly mention that the PowerShell script can be run on PowerShell Core (pwsh) on Linux/macOS, if applicable, and provide installation instructions if needed.
- When referencing scripts or tooling, offer both Windows (PowerShell) and Linux/macOS (Bash/CLI) options where possible.
- Add notes or examples for users on non-Windows platforms to ensure they can follow all mitigation and identification steps without requiring a Windows environment.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/scenario-secure-app-access-microsoft-graph-as-app.md
...e/scenario-secure-app-access-microsoft-graph-as-app.md
High Priority
View Details →
Detected Bias Types
Windows First
Powershell Heavy
Missing Linux Example
Summary
The documentation page demonstrates a Windows bias by presenting installation instructions for the NuGet packages using both the .NET Core CLI and the Visual Studio Package Manager Console (PowerShell), but does not provide explicit Linux or cross-platform alternatives beyond the .NET CLI. The Package Manager Console is a Windows/Visual Studio-specific tool, and its instructions are given equal prominence to the cross-platform .NET CLI, with no mention of Linux-specific environments or editors. There are no references to Linux development environments, nor are there any Linux-specific troubleshooting notes or examples.
Recommendations
- Emphasize the .NET Core CLI as the primary, cross-platform installation method and list it before any Windows-specific tools.
- Clearly label the Package Manager Console instructions as 'Windows/Visual Studio only' and consider moving them after the cross-platform instructions.
- Add explicit notes or examples for Linux/macOS users, such as using VS Code or JetBrains Rider, and mention that the .NET CLI works on all platforms.
- Include troubleshooting tips or environment setup notes for Linux/macOS users, if applicable.
- Audit other sections for implicit Windows assumptions (such as file paths, environment variable syntax, etc.) and provide Linux equivalents where needed.