App Service
806
Total Pages
669
Linux-Friendly Pages
137
Pages with Bias
17.0%
Bias Rate
Bias Trend Over Time
Pages with Bias Issues
247 issues found
Showing 76-100 of 247 flagged pages
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 YAML snippets referencing Windows-specific images (e.g., 'windows-latest') and App Service for Windows. There are no Linux container examples, nor any mention of how to adapt the pipeline for Linux-based workloads. The prerequisites and deployment steps exclusively reference Windows tooling and patterns, omitting Linux alternatives.
Recommendations
- Add parallel examples and instructions for deploying Linux containers to App Service, including YAML snippets using 'ubuntu-latest' or other Linux VM images.
- Include a section in prerequisites for Linux-based apps and Dockerfiles.
- Mention and demonstrate the use of App Service for Containers (Linux) and the corresponding deployment task settings.
- Clarify which steps are Windows-specific and provide guidance for adapting them to Linux scenarios.
- Ensure variable names and pipeline pool settings are not hardcoded to Windows unless strictly required by the scenario.
Create Pull Request
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/deploy-intelligent-apps-dotnet-to-azure-sql.md
...service/deploy-intelligent-apps-dotnet-to-azure-sql.md
High Priority
View Details →
Detected Bias Types
Windows First
Missing Linux Example
Windows Tools
Summary
The documentation demonstrates a bias toward Windows environments by exclusively referencing Windows-centric workflows and tools (e.g., right-clicking in Visual Studio, using Azure Data Studio, and referencing ADO.NET connection strings). There are no explicit Linux or cross-platform CLI examples, nor are Linux-specific tools or deployment patterns discussed. The instructions and code samples assume a Windows GUI workflow and do not mention alternatives for Linux users, such as using VS Code, command-line tools, or Linux-native SQL editors.
Recommendations
- Add explicit instructions for Linux users, such as using VS Code or JetBrains Rider for .NET development, and provide command-line alternatives for file creation and editing.
- Include examples of connecting to Azure SQL using cross-platform tools like sqlcmd, Azure CLI, or DataGrip, and mention how to run the sample app on Linux (e.g., dotnet run).
- Reference Linux-native editors and workflows (e.g., nano, vim, or VS Code) for editing files and managing code.
- Provide guidance for installing .NET SDK and dependencies on Linux distributions (Ubuntu, Fedora, etc.), including package manager commands.
- Ensure all code samples and deployment steps are platform-agnostic or include both Windows and Linux instructions where workflows differ.
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 Tools
Windows First
Missing Linux Example
Summary
The documentation provides both Azure CLI and PowerShell examples, but PowerShell instructions are given equal prominence and detail, which is a Windows-centric tool. There are references to Windows-specific issues (e.g., native Node.js modules lacking Windows binaries), and troubleshooting mentions Windows errors before Linux equivalents. The use of PowerShell and references to Git Credential Manager (commonly used on Windows) further reinforce a Windows bias. There is no explicit mention of Linux-specific tools or troubleshooting steps, and Linux terminal examples are less detailed.
Recommendations
- Add explicit Linux shell examples alongside PowerShell, especially for steps like creating and configuring web apps.
- Include troubleshooting notes for common Linux/macOS issues (e.g., file permissions, SSH keys, case sensitivity).
- Mention Linux equivalents for Git Credential Manager (such as libsecret or credential helpers) and clarify cross-platform authentication steps.
- Ensure that error messages and resolutions cover both Windows and Linux scenarios, including platform-specific build errors.
- Balance the prominence of PowerShell and CLI examples, perhaps by listing CLI (cross-platform) first and PowerShell second.
- Add notes or links for installing and using Azure CLI and Git on Linux/macOS, not just generic installation links.
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
Powershell Heavy
Missing Linux Example
Summary
The documentation exhibits several signs of Windows bias. Windows-specific paths (e.g., D:\home\site\wwwroot) are mentioned before Linux equivalents, and the Kudu UI ZIP deploy feature is noted as unavailable for Linux, with only a brief suggestion to use FTP or API instead. The instructions for accessing Kudu (via Azure portal > Advanced Tools) are tailored to Windows environments, and PowerShell examples are provided throughout, while Linux-specific shell examples are limited to generic CLI or cURL commands. There is little discussion of Linux-native tools or workflows, and some features (e.g., ZIP deploy UI) are described as unavailable on Linux without offering Linux alternatives or parity.
Recommendations
- Present Linux and Windows paths and behaviors equally, ideally side-by-side, rather than listing Windows first.
- For features unavailable on Linux (e.g., Kudu ZIP deploy UI), provide detailed Linux alternatives and workflows, such as step-by-step FTP or API usage, and link to Linux-specific guides.
- Include Linux-native tooling and shell examples (e.g., scp, rsync, or Linux file system navigation) where appropriate, not just Azure CLI and cURL.
- Clarify which features are cross-platform and which are Windows-only, and avoid implying Windows as the default or primary environment.
- Expand documentation for Linux users, including troubleshooting, environment setup, and integration with common Linux deployment pipelines.
- Consider adding a parity table or section summarizing feature availability and differences between Windows and Linux App Service environments.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/includes/deploy-github-actions/deploy-github-actions-publish-profile.md
...ithub-actions/deploy-github-actions-publish-profile.md
High Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Missing Linux Example
Summary
The documentation provides platform-specific examples for deploying various app types to Azure Web Apps. For ASP.NET (classic), only a Windows-based workflow is shown, using Windows-specific tools (NuGet, MSBuild) and runs-on: windows-latest. In contrast, all other stacks (ASP.NET Core, Java, Tomcat, Node.js, Python) use Ubuntu runners and cross-platform tools. There is no Linux-based example for classic ASP.NET, and Windows tools are mentioned exclusively for that stack.
Recommendations
- Add a Linux-based workflow example for classic ASP.NET, if supported (e.g., using Mono or .NET Core for legacy projects).
- If classic ASP.NET deployment is only supported on Windows, clarify this limitation explicitly in the documentation.
- Where possible, mention cross-platform alternatives to Windows-only tools (NuGet, MSBuild) or note their platform restrictions.
- Ensure that all stacks have both Windows and Linux examples if supported, or clearly state platform requirements for each.
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 primarily referencing Windows-centric development patterns and tools. Instructions for creating and editing files use Visual Studio and right-click context menus, which are exclusive to Windows environments. NuGet package installation is described first via Visual Studio (Windows), with CLI instructions mentioned second. There are no explicit Linux or cross-platform editor instructions (e.g., VS Code, command line, or text editors like nano/vim). The deployment and configuration steps do not mention Linux-specific workflows or tools, and there are no examples of using Linux shell commands or Linux-native editors.
Recommendations
- Add instructions for creating and editing files using cross-platform tools such as VS Code, nano, or vim, and include command-line examples for file creation.
- Present NuGet CLI installation instructions before or alongside Visual Studio instructions to avoid Windows-first ordering.
- Include Linux-specific deployment steps or mention that the process is identical on Linux, clarifying any differences.
- Reference cross-platform editors and workflows throughout, not just Windows-exclusive tools.
- Provide screenshots or terminal commands for Linux environments where appropriate.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/includes/deploy-github-actions/deploy-github-actions-openid-connect.md
...github-actions/deploy-github-actions-openid-connect.md
High Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Missing Linux Example
Summary
The documentation provides platform-specific deployment examples for several languages. For ASP.NET (classic), the workflow exclusively uses Windows runners and Windows-only tools (NuGet, MSBuild), with no Linux alternative or mention. In contrast, all other language examples (ASP.NET Core, Java, Tomcat, Node.js, Python) use Ubuntu runners and cross-platform tools. The ASP.NET section is presented before Java, Node.js, and Python, and does not offer parity for Linux users, indicating a Windows bias in that section.
Recommendations
- Add an ASP.NET (classic) deployment example using Linux runners, if supported, or clarify platform limitations.
- Mention Linux-compatible alternatives to NuGet and MSBuild, or note their platform restrictions.
- Ensure all language tabs provide both Windows and Linux runner options where possible.
- Explicitly state platform requirements and limitations for each example to inform users of cross-platform support.
- Consider reordering or grouping examples so that Windows-specific workflows do not appear to be the default or preferred approach.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/includes/deploy-github-actions/deploy-github-actions-service-principal.md
...hub-actions/deploy-github-actions-service-principal.md
High Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Missing Linux Example
Summary
The documentation provides platform-specific examples for several languages. For ASP.NET (classic), only a Windows-based workflow is shown, using Windows-specific tools (NuGet, MSBuild) and 'runs-on: windows-latest'. In contrast, all other stacks (ASP.NET Core, Java, Tomcat, Node.js, Python) use 'runs-on: ubuntu-latest' and cross-platform tools. There is no Linux-based example for classic ASP.NET, nor any mention of Mono or cross-platform build alternatives for .NET Framework. Windows tools and patterns (NuGet, MSBuild, Windows paths) are used exclusively for ASP.NET, and the Windows workflow is presented before Linux alternatives (which are missing for ASP.NET).
Recommendations
- Add a Linux-based example for classic ASP.NET, using Mono or other cross-platform build tools if possible.
- Mention cross-platform alternatives to NuGet and MSBuild for .NET Framework projects, or clarify their platform limitations.
- Explicitly state platform requirements and limitations for each workflow, so users know if Windows is required.
- Consider reordering or grouping examples so that Linux and Windows parity is clear for each language stack.
- For ASP.NET, provide guidance or links for building and deploying on Linux if supported, or explain why only Windows is shown.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/includes/deploy-intelligent-apps/deploy-intelligent-apps-linux-python-pivot.md
...ent-apps/deploy-intelligent-apps-linux-python-pivot.md
High Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Missing Linux Example
Summary
The documentation page exhibits a Windows-first bias, primarily by referencing Windows in quickstart links and deployment instructions, and mentioning Visual Studio as a deployment tool. There is a lack of explicit Linux-specific examples or instructions, especially for deployment, environment variable management, and local development. While some cross-platform elements (like Azure CLI and bash) are referenced in quickstart links, Linux tooling and patterns are not given equal prominence or clarity.
Recommendations
- Add explicit Linux deployment instructions, including examples using Linux-native tools (e.g., VS Code on Linux, GitHub Actions, Azure CLI from bash).
- Ensure that quickstart and sample links do not default to Windows tabs, or provide clear Linux/Bash tabs as the first option.
- Mention Linux environment variable management (e.g., using export in bash, .env files) alongside portal-based configuration.
- Include troubleshooting steps for common Linux deployment issues (e.g., file permissions, case sensitivity).
- Reference Linux-friendly editors and workflows (e.g., VS Code, nano, vim) in addition to Visual Studio.
- Clarify that all code and configuration steps work equally on Linux and Windows, and highlight any platform-specific caveats.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/includes/quickstart-python/remove-resource-group-visual-studio-code-2.md
...t-python/remove-resource-group-visual-studio-code-2.md
High Priority
View Details →
Detected Bias Types
Windows Tools
Missing Linux Example
Windows First
Summary
The documentation describes deleting a resource group by right-clicking in a graphical interface, which is a pattern most commonly associated with Windows environments. There is no mention of equivalent Linux workflows, such as using command-line tools (e.g., Azure CLI or Bash). The instructions implicitly assume a Windows-style GUI is being used, and do not provide parity for Linux users.
Recommendations
- Add instructions for deleting a resource group using Azure CLI, including example commands for Bash.
- Clarify which interface is being referenced (e.g., Azure Portal) and mention that the process is the same across platforms if true.
- If applicable, provide screenshots or examples for both Windows and Linux environments.
- Ensure that Linux users are not excluded by offering non-GUI alternatives.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/includes/tutorial-python-postgresql-app/deploy-zip-azure-portal-1.md
...ial-python-postgresql-app/deploy-zip-azure-portal-1.md
High Priority
View Details →
Detected Bias Types
Windows Tools
Windows First
Missing Linux Example
Summary
The documentation references the Azure portal UI, which is a graphical tool commonly used on Windows. There are no examples or instructions for configuring application settings via Linux-friendly methods such as the Azure CLI, Bash, or ARM templates. The instructions implicitly assume use of the portal, which is often associated with Windows workflows, and do not provide parity for Linux users or those preferring command-line interfaces.
Recommendations
- Add equivalent instructions for configuring application settings using the Azure CLI (az webapp config appsettings set) with Bash examples.
- Include ARM template or Bicep configuration snippets for automation and cross-platform usage.
- Explicitly mention that the Azure portal is accessible from any OS, but provide alternatives for users who prefer command-line or automated approaches.
- Ensure that future documentation provides both GUI and CLI examples, with CLI examples not being relegated to secondary status.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/includes/webjobs-create/webjob-types.md
...es/app-service/includes/webjobs-create/webjob-types.md
High Priority
View Details →
Detected Bias Types
Windows First
Powershell Heavy
Windows Tools
Missing Linux Example
Summary
The documentation page demonstrates Windows bias by listing Windows file types and tools (cmd, bat, exe, PowerShell) first and in greater detail, including explicit mention of PowerShell scripts. Windows examples are more numerous and specific, while Linux sections only mention shell scripts (*.sh*) and provide fewer concrete examples. There is a lack of parity in examples and supported file types between Windows and Linux sections.
Recommendations
- Expand Linux sections to list supported file types beyond *.sh*, such as *.py* (Python), *.pl* (Perl), *.rb* (Ruby), *.js* (Node.js), and *.jar* (Java), where applicable.
- Provide explicit examples for Linux, similar to the Windows sections, e.g., 'Using Bash: *.sh*, Using Python: *.py*, Using Node.js: *.js*'.
- Mention Linux tools and runtimes (e.g., Bash, Python, Node.js) with the same specificity as Windows tools (cmd, PowerShell).
- Ensure that examples for language-specific scripts (Java, Node.js, Python) are present in both Windows and Linux sections.
- Consider reordering or presenting Windows and Linux information in parallel to avoid implicit prioritization of Windows.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/includes/webjobs-create/webjobs-supported-platforms.md
...includes/webjobs-create/webjobs-supported-platforms.md
High Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Powershell Heavy
Summary
The documentation lists Windows hosting options before Linux and gives precedence to Windows-specific file types (.exe, .cmd, .bat) and PowerShell scripts (.ps1) before mentioning Bash scripts and other cross-platform scripting languages. This ordering and emphasis may suggest a bias toward Windows environments and tooling.
Recommendations
- Alternate the order of platform and file type listings to avoid implying priority (e.g., list Linux options first in some sections).
- Provide equal prominence to Linux-native tools and scripting formats (e.g., highlight Bash scripts and Linux containers alongside Windows equivalents).
- Add explicit examples for both Windows and Linux environments to demonstrate parity.
- Clarify that all listed scripting languages and runtimes are equally supported on both platforms, where applicable.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/migrate-sidecar-multi-container-apps.md
...es/app-service/migrate-sidecar-multi-container-apps.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 requiring PowerShell for both the script-based migration and for decoding base64 values, providing only PowerShell script examples, and listing PowerShell as a prerequisite. There are no Linux shell (bash/sh) equivalents, and Windows tools and patterns (PowerShell scripting, Windows-style command syntax) are mentioned exclusively and before any Linux alternatives. The manual migration also references PowerShell for base64 decoding, omitting Linux shell commands.
Recommendations
- Provide bash/sh script equivalents for all PowerShell commands, especially for base64 decoding and running migration scripts.
- Offer a Linux-compatible migration script (e.g., update_sidecars.sh) and document its usage alongside the PowerShell script.
- List prerequisites for both Windows and Linux environments, including bash or compatible shells.
- Ensure all examples (script and manual) include both PowerShell and bash/sh commands, presented side-by-side or in separate sections.
- Clarify that Azure CLI is cross-platform and show usage in both Windows and Linux contexts.
- Avoid assuming PowerShell is available by default; mention installation steps for both PowerShell and bash if needed.
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-native tools (such as Azure CLI or Bash). The use of PowerShell cmdlets and parameters is exclusive, and there is no mention of Linux shell commands or cross-platform alternatives. This may disadvantage users working on Linux or macOS environments.
Recommendations
- Add Azure CLI examples for all PowerShell commands shown, demonstrating equivalent functionality in Bash or other Linux shells.
- Include notes or sections clarifying cross-platform support and usage, especially for developers not using Windows.
- Reference Linux-native tools (e.g., Bash, Azure CLI) alongside PowerShell, and avoid presenting Windows tools as the default or only option.
- Ensure that ARM template examples are supplemented with CLI or REST API examples that can be run from any platform.
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 Tools
Windows First
Missing Linux Example
Summary
The documentation page demonstrates Windows bias in several areas: diagnostic information collection and process monitoring are described only for Windows applications (mentioning Process Explorer and memory dumps), with no Linux equivalents or guidance. Windows-specific features (such as the x-ms-auth-internal-token header) are called out, while Linux alternatives or limitations are not explained. In sections where platform differences exist, Windows is mentioned first or exclusively, and Linux parity is not addressed.
Recommendations
- Add equivalent instructions and tooling for Linux-based App Service instances, such as how to collect diagnostics and monitor processes (e.g., using SSH, Linux process tools, or Azure diagnostics extensions).
- Clearly indicate which features are Windows-only and provide Linux alternatives or workarounds where possible.
- Include examples and screenshots for Linux App Service instances, especially in sections on diagnostics and monitoring.
- Where platform-specific limitations exist (such as the x-ms-auth-internal-token header), explain what Linux users should expect and how to achieve similar security or monitoring outcomes.
- Ensure that documentation structure and order does not consistently prioritize Windows features over Linux, and present both platforms equally where possible.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/overview-local-cache.md
...blob/main/articles/app-service/overview-local-cache.md
High Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Missing Linux Example
Summary
The documentation page exhibits a Windows bias by referencing Windows-specific paths (e.g., D:\home), mentioning Windows containers before Linux containers, and omitting Linux-specific examples or equivalents. Tools and folder structures are described using Windows conventions, and there are no Linux command-line or file path examples. The instructions and troubleshooting steps assume a Windows environment, with no parity for Linux users.
Recommendations
- Include Linux-specific examples, such as file paths (/home/site, /var/log, etc.) and command-line instructions for Linux environments.
- Mention Linux containers and KuduLite earlier and provide guidance for enabling and managing local cache in Linux-based App Service environments.
- Clarify differences in folder structure, environment variables, and cache behavior between Windows and Linux App Service plans.
- Provide equivalent troubleshooting steps and best practices for Linux users, including how to inspect environment variables and manage cache/logs.
- Ensure that references to tools (e.g., Azure Web Apps Disk Usage) are available or have alternatives for Linux environments.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/overview-managed-instance.md
...main/articles/app-service/overview-managed-instance.md
High Priority
View Details →
Detected Bias Types
Windows First
Powershell Heavy
Windows Tools
Missing Linux Example
Summary
The documentation for Managed Instance on Azure App Service is heavily Windows-centric. All examples, configuration instructions, and tooling references are specific to Windows (e.g., PowerShell scripts, registry, COM, MSI, IIS, GAC, RDP). There are no Linux equivalents, examples, or tooling mentioned, and the platform is explicitly stated as Windows-only. Windows features and patterns are described in detail, while Linux support is only referenced as an alternative in the 'Choosing the Right Hosting Option' section.
Recommendations
- Clearly state Windows-only support in the introduction and limitations sections to set expectations.
- Where possible, provide parity documentation for Linux (or container) hosting options, including configuration, scripting, and troubleshooting workflows.
- Add comparative tables or sections that highlight differences and similarities between Windows and Linux hosting options on App Service.
- Reference Linux tools (e.g., Bash, shell scripts, systemd, Linux file paths) and patterns in relevant sections, even if only to clarify their absence or future roadmap.
- Include links to Linux-focused documentation for users seeking non-Windows solutions.
- If Linux support is planned, add a roadmap or FAQ addressing future parity.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/overview-security.md
...cs/blob/main/articles/app-service/overview-security.md
High Priority
View Details →
Detected Bias Types
Windows First
Missing Linux Example
Windows Tools
Summary
The documentation page exhibits subtle Windows bias, particularly in the 'Network security' section, where IP access restrictions mention configuring dynamic IP restrictions through web.config files on Windows apps, without referencing Linux equivalents. There are no explicit Linux-specific examples or instructions throughout the page, and Windows-centric configuration patterns (e.g., web.config) are mentioned before or instead of cross-platform or Linux alternatives. No PowerShell-heavy bias is present, but the overall guidance assumes or prioritizes Windows deployment scenarios.
Recommendations
- Include Linux-specific instructions or examples alongside Windows ones, such as how to configure IP restrictions for Linux-based App Service apps (e.g., using app settings, .htaccess for Apache, or nginx config).
- Avoid referencing Windows-only configuration files (like web.config) without mentioning Linux equivalents or providing cross-platform alternatives.
- Where platform-specific security features or behaviors differ, explicitly call out differences and provide guidance for both Windows and Linux App Service environments.
- Add examples or links for Linux deployment scenarios, such as securing FTP/FTPS deployments on Linux, configuring TLS/SSL certificates, and managing environment variables.
- Review and update documentation to ensure parity in tooling and configuration references, avoiding implicit prioritization of Windows patterns.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/overview-private-endpoint.md
...main/articles/app-service/overview-private-endpoint.md
High Priority
View Details →
Detected Bias Types
Windows First
Powershell Heavy
Windows Tools
Summary
The documentation page exhibits mild Windows bias. In the 'Related content' section, Windows-centric tools (Azure PowerShell and ARM templates) are listed before Linux-friendly options (Azure CLI, Terraform). PowerShell is given its own quickstart link, and ARM templates are more commonly used in Windows environments. There are no explicit Linux shell examples, and the page does not mention Linux-specific tools or patterns. However, the page does state that private endpoints work for both Windows and Linux apps, and does include a Terraform script link (which is cross-platform).
Recommendations
- Ensure that Azure CLI examples and quickstarts are listed before or alongside PowerShell and ARM template options, as CLI is more commonly used on Linux.
- Add explicit Linux shell (bash) command examples where relevant, especially in sections discussing DNS or network configuration.
- Mention Linux-specific considerations or troubleshooting steps if any exist for private endpoints.
- Clarify that all listed tools (CLI, PowerShell, ARM templates, Terraform) are cross-platform, and provide guidance for both Windows and Linux users.
- Consider adding a section or note on using private endpoints from Linux-based environments, including sample commands and best practices.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/overview.md
.../azure-docs/blob/main/articles/app-service/overview.md
High Priority
View Details →
Detected Bias Types
Windows Tools
Windows First
Missing Linux Example
Powershell Heavy
Summary
The documentation page demonstrates a Windows bias, particularly in the section describing Managed Instance (preview), which exclusively highlights Windows-specific features such as COM, registry access, MSI, drive mapping, and PowerShell scripts. Windows tools and patterns (e.g., RDP, IIS, ACL, MSMQ) are mentioned without Linux equivalents or alternatives. The Linux and container support is only referenced as 'not supported' for Managed Instance, with no examples or details for Linux users. Command-line tooling mentions Azure PowerShell before Azure CLI, and there are no Linux-specific deployment or management examples.
Recommendations
- Add Linux-specific examples and scenarios, especially in sections discussing deployment, management, and automation.
- When listing command-line tools, mention Azure CLI before or alongside Azure PowerShell, and provide Bash shell examples.
- For features exclusive to Windows (e.g., COM, registry), clarify Linux alternatives or workarounds, or explicitly state the parity gap.
- Include Linux/container-focused quickstart and decision guides, with clear instructions and links.
- Balance tool and pattern mentions by referencing Linux-native tools (e.g., Bash, SSH, systemd) where applicable.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/quickstart-custom-container.md
...in/articles/app-service/quickstart-custom-container.md
High Priority
View Details →
Detected Bias Types
Windows First
Powershell Heavy
Windows Tools
Missing Linux Example
Summary
The documentation page demonstrates a Windows bias by listing Windows pivots and tools (such as Visual Studio, Powershell, and Windows CLI) before their Linux equivalents. There are multiple pivots for Windows-specific tools and workflows, including Powershell and Visual Studio, while Linux pivots are fewer and focus mainly on Visual Studio Code and the Azure Portal. There is no explicit Linux CLI or shell example provided, and Windows tools are mentioned more frequently and prominently.
Recommendations
- Add Linux CLI and shell examples (e.g., Bash, Azure CLI on Linux) to match the Windows CLI and Powershell pivots.
- Ensure Linux pivots are listed with equal prominence and order as Windows pivots.
- Include examples using common Linux tools and workflows, such as Docker commands in Bash.
- Balance the number of Windows and Linux pivots to provide parity in guidance.
- Explicitly mention Linux alternatives when referencing Windows-specific tools (e.g., Visual Studio vs Visual Studio Code).
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/routine-maintenance-downtime.md
...n/articles/app-service/routine-maintenance-downtime.md
High Priority
View Details →
Detected Bias Types
Windows First
Powershell Heavy
Windows Tools
Missing Linux Example
Summary
The documentation page exhibits a Windows bias by consistently presenting Windows-specific features, tools, and examples before their Linux equivalents. Windows concepts such as IIS Application Initialization and .NET Core stdout logging are described in detail, while Linux alternatives are mentioned briefly or as afterthoughts. There is a lack of parity in example depth and guidance for Linux users, and Windows terminology and tools are referenced more frequently throughout the document.
Recommendations
- Provide equally detailed Linux examples and explanations for features like application initialization, warm-up, and logging.
- Introduce Linux-specific tools and patterns (e.g., systemd, Nginx, Apache, container health checks) alongside Windows/IIS features.
- Ensure that Linux options (such as WEBSITE_WARMUP_PATH) are described with the same depth and practical guidance as Windows features.
- Avoid presenting Windows features first; alternate or parallelize explanations for Windows and Linux where possible.
- Include troubleshooting and testing scenarios specifically tailored for Linux environments, not just Windows.
- Reference Linux documentation and best practices for logging, start-up, and health checks.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/resources-kudu.md
...-docs/blob/main/articles/app-service/resources-kudu.md
High Priority
View Details →
Detected Bias Types
Windows Tools
Windows First
Missing Linux Example
Summary
The documentation page for Kudu service overview demonstrates a Windows bias by referencing IIS diagnostic dumps, IIS processes, and deployment webhooks specifically for Windows apps. There are no explicit examples or mentions of Linux-specific features, tools, or deployment patterns, and Windows-related terminology (IIS, Windows apps) is presented without Linux equivalents or parity.
Recommendations
- Include examples and documentation for Linux-based App Service environments, such as how to access Linux diagnostic logs or manage Linux processes via Kudu.
- Clarify which features are Windows-specific and provide Linux alternatives or note feature parity (e.g., mention Docker logs for Linux apps alongside IIS dumps for Windows).
- Add deployment webhook instructions for Linux apps if supported, or explicitly state any limitations.
- Ensure that references to server management (e.g., IIS) are balanced with equivalent Linux technologies (e.g., Nginx, Apache) where applicable.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/quickstart-nodejs.md
...cs/blob/main/articles/app-service/quickstart-nodejs.md
High Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Missing Linux Example
Summary
The documentation provides both Linux and Windows deployment instructions, but Windows-specific tools and patterns (such as web.config, Application Insights, and resource group naming conventions) are mentioned in detail, sometimes before or with more emphasis than their Linux equivalents. Some sections, especially under Visual Studio Code deployment, provide more granular steps for Windows (e.g., web.config generation) without equivalent Linux-specific troubleshooting or configuration guidance. The CLI instructions default to Linux, but Windows is always called out as a special case, and some troubleshooting notes (e.g., web.config) are only present for Windows. There is also a slight tendency to mention Windows-specific requirements (like web.config) without offering Linux-specific configuration notes.
Recommendations
- Ensure Linux-specific troubleshooting and configuration steps (such as dealing with startup scripts, environment variables, or permissions) are included and given equal prominence to Windows-specific notes.
- Where Windows-specific tools or files (e.g., web.config) are discussed, provide equivalent Linux context (e.g., startup command configuration, app settings) and cross-reference Linux documentation.
- Balance the order and detail of instructions so that Linux and Windows are presented with parity, both in depth and in sequence.
- Include Linux-specific deployment caveats, such as file permissions, default startup scripts, or common issues, similar to the detailed Windows notes.
- If advanced options (like Application Insights or resource group naming) are discussed for Windows, ensure Linux users are informed of their equivalents or differences.