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 451-475 of 2121 flagged pages
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/reference-app-settings.md
...ob/main/articles/app-service/reference-app-settings.md
High Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Powershell Heavy
Missing Linux Example
Summary
The documentation exhibits a Windows-first bias in several areas: Windows paths and conventions are often mentioned before or instead of Linux equivalents (e.g., 'D:\home' before '/home'), Windows-specific tools and settings (such as MSDeploy, Web Deploy, and IIS) are referenced without always providing Linux alternatives, and some configuration examples use Windows environment variable syntax or reference Windows-only features. While there are sections for Linux (e.g., Oryx build, Linux-specific variables), Windows terminology and tools are generally foregrounded, and Linux examples or explanations are sometimes missing or less detailed.
Recommendations
- For every environment variable or feature that behaves differently on Windows and Linux, provide both Windows and Linux examples side by side.
- When referencing file paths, always show both Windows (e.g., 'D:\home') and Linux ('/home') formats together.
- Avoid using Windows environment variable syntax (e.g., '%HOME%') exclusively; include Linux syntax ('$HOME') as well.
- When mentioning deployment tools (e.g., MSDeploy, Web Deploy), explicitly state their Linux alternatives or note if not available.
- Ensure that Linux-specific build and deployment flows are as thoroughly documented as Windows ones, with equal detail and prominence.
- Review all sections for references to Windows-only features or behaviors and clarify their applicability to Linux or provide Linux equivalents where possible.
- In tables and lists, avoid placing Windows-specific information first by default; alternate or present both platforms equally.
Create Pull Request
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/troubleshoot-diagnostic-logs.md
...n/articles/app-service/troubleshoot-diagnostic-logs.md
High Priority
View Details →
Detected Bias Types
Windows First
Missing Linux Example
Windows Tools
Summary
The documentation demonstrates a Windows-first bias: logging types and features are described for Windows in more detail and before Linux, with several logging types (web server logging, detailed error messages, failed request tracing) only available or documented for Windows. Linux instructions are less detailed and sometimes omitted. Windows-specific tools and formats (e.g., W3C log format, Log Parser, Web.config) are referenced without Linux equivalents.
Recommendations
- Provide Linux-specific examples and instructions for all logging types, or clearly state if a feature is unavailable on Linux.
- Document Linux equivalents or alternatives for Windows-only tools and patterns (e.g., suggest open-source log viewers for Linux, explain how to access and interpret logs on Linux).
- Present Windows and Linux instructions in parallel sections or tables to ensure parity and avoid Windows-first ordering.
- Clarify any feature gaps between Windows and Linux, and link to relevant feature request or roadmap pages if Linux support is planned.
- Expand code examples to include Linux-appropriate frameworks and logging libraries, not just ASP.NET and .NET.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/tutorial-auth-aad.md
...cs/blob/main/articles/app-service/tutorial-auth-aad.md
High Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Missing Linux Example
Summary
The documentation demonstrates a moderate Windows bias. Windows-specific instructions and examples are consistently presented before their Linux equivalents (windows_first). There are several references to Windows tools and patterns, such as directory names and runtime strings, that are more familiar to Windows users (windows_tools). In a few places, Linux-specific details or troubleshooting steps are less emphasized or missing (missing_linux_example), and the Linux section sometimes uses less precise or inconsistent instructions compared to the Windows section.
Recommendations
- Alternate the order of Windows and Linux pivots throughout the documentation, or present both platforms side-by-side where possible, to avoid always prioritizing Windows.
- Ensure that all examples, troubleshooting steps, and explanations are equally detailed for both Windows and Linux, including consistent directory structures and runtime naming conventions.
- Where platform-specific commands or behaviors differ, provide explicit notes or callouts for both Windows and Linux users.
- Review all images, screenshots, and portal navigation steps to ensure they are not Windows-centric and are equally applicable to Linux deployments.
- Explicitly mention any differences in behavior, limitations, or requirements between Windows and Linux App Service environments.
- Consider adding a summary table or section that highlights key differences and similarities between Windows and Linux deployment steps.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/tutorial-connect-app-access-sql-database-as-user-dotnet.md
...utorial-connect-app-access-sql-database-as-user-dotnet.md
High Priority
View Details →
Detected Bias Types
Windows Tools
Windows First
Missing Linux Example
Summary
The documentation page demonstrates a bias toward Windows environments by referencing Windows-specific tools (such as SQL Server Management Studio and Visual Studio), presenting Windows/GUI-based workflows before mentioning any CLI or cross-platform alternatives, and omitting Linux-native or cross-platform equivalents for key steps (e.g., no mention of Azure Data Studio, VS Code, or Linux-compatible SQL tools). The instructions for publishing and database management are centered on Windows tools, and there is little guidance for users on Linux or macOS.
Recommendations
- Include examples using cross-platform tools such as Azure Data Studio and Visual Studio Code for database management and code publishing.
- Provide explicit instructions for Linux/macOS users, including how to connect to Azure SQL Database using sqlcmd or Azure Data Studio on non-Windows platforms.
- When referencing tools like SQL Server Management Studio or Visual Studio, also mention their cross-platform alternatives and provide parallel instructions.
- Ensure that CLI-based workflows are presented as primary or co-equal options, not just as alternatives to Windows GUI tools.
- Add notes or sections that address differences or additional steps required for Linux/macOS environments, especially for local debugging and publishing.
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-centric bias. Windows and PowerShell tools are prioritized or exclusively mentioned in several sections, especially for development environment setup and database permission granting. Visual Studio for Windows is described in detail, while Linux/macOS workflows are either missing, less detailed, or only referenced via Azure CLI. There are no explicit Linux-specific instructions for tasks like connecting to SQL Database or running migrations, and PowerShell/Windows tools are often the default or only example.
Recommendations
- Provide explicit Linux/macOS instructions for all steps, including connecting to Azure SQL Database (e.g., using sqlcmd on Linux, Azure Data Studio, or cross-platform tools).
- Ensure that examples using PowerShell or Windows-specific tools are accompanied by equivalent Bash/Azure CLI or cross-platform alternatives.
- Reorder sections so that cross-platform or CLI-based approaches are presented before or alongside Windows/PowerShell methods.
- Include guidance for developing and debugging with .NET on Linux/macOS (e.g., using VS Code, JetBrains Rider, or CLI tools), not just Visual Studio for Windows.
- Clarify that all steps can be performed on Linux/macOS where possible, and highlight any platform-specific limitations.
- Add migration and publishing instructions for Linux/macOS environments, using dotnet CLI and Git instead of only Visual Studio UI.
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 bias by presenting Windows/Powershell examples and terminology before Linux equivalents, focusing on Windows-specific tools (PowerShell), and omitting Linux-specific automation or command-line examples. While Azure CLI is cross-platform, the PowerShell section is presented as an equivalent, but there are no Linux shell (bash) or scripting examples. The documentation also refers to the Azure portal UI, which is platform-agnostic, but does not provide parity for Linux users in automation or scripting contexts.
Recommendations
- Provide Linux shell (bash) scripting examples alongside PowerShell for automation tasks.
- When listing SKU availability commands, present Linux and Windows examples together or alternate their order to avoid always listing Windows first.
- Clarify that Azure CLI commands are cross-platform and can be run on both Windows and Linux, and provide explicit bash examples where appropriate.
- Include notes or sections for Linux users, especially for automation, to ensure parity with Windows/PowerShell instructions.
- Consider including a table or matrix showing which features and commands apply to Windows, Linux, and containers for clarity.
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 is mentioned first. Automation examples are provided for both Azure CLI (cross-platform) and Azure PowerShell (Windows-centric), but there is no mention of Bash scripting or Linux-native automation tools. The portal UI instructions and screenshots do not distinguish between Windows and Linux hosting environments, and there is no explicit Linux-specific guidance or parity in scripting approaches.
Recommendations
- Alternate the order of Windows and Linux instructions/examples to avoid always presenting Windows first.
- Include Bash scripting examples for Linux users, especially in the automation section.
- Clarify in portal instructions and screenshots whether steps differ for Linux-hosted apps, or provide Linux-specific UI guidance if applicable.
- Explicitly mention that Azure CLI is cross-platform and suitable for Linux/macOS users, and consider linking to Linux-specific CLI installation guides.
- If PowerShell is included, consider also providing equivalent Bash or shell script examples to ensure Linux parity.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/configure-language-dotnet-framework.md
...les/app-service/configure-language-dotnet-framework.md
High Priority
View Details →
Detected Bias Types
Windows First
Missing Linux Example
Windows Tools
Summary
The documentation page demonstrates a Windows bias by focusing on Windows-specific deployment patterns, tools, and examples. It references Visual Studio and Windows file paths, and provides instructions for accessing .NET Framework versions using Windows-only tools (Kudu CMD/PowerShell) and directories. There are no Linux-specific examples, nor is there guidance for configuring ASP.NET apps in Linux App Service environments, despite Azure App Service supporting Linux. The documentation assumes Windows as the default platform for ASP.NET apps.
Recommendations
- Add equivalent instructions and examples for Linux-based App Service environments, including how to check .NET runtime versions and access environment variables.
- Include Linux shell (bash) commands and file paths where appropriate, such as for listing installed .NET runtimes.
- Mention Linux deployment tools and patterns (e.g., VS Code, CLI, FTP, Git) alongside Visual Studio.
- Clarify which steps are Windows-specific and provide links or inline guidance for Linux users.
- Ensure parity in troubleshooting and diagnostics instructions for both Windows and Linux environments.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/app-service-web-nodejs-best-practices-and-troubleshoot-guide.md
...rvice-web-nodejs-best-practices-and-troubleshoot-guide.md
High Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Missing Linux Example
Powershell Heavy
Summary
The documentation is heavily focused on Windows environments, specifically Azure App Service on Windows with iisnode. All configuration and troubleshooting steps reference Windows-specific tools, paths, and patterns (e.g., node.exe, web.config, iisnode, Win32 error codes, Kudu CMD/PowerShell). There are no examples or guidance for Linux-based Azure App Service environments, nor are Linux equivalents or cross-platform instructions provided.
Recommendations
- Add a parallel section or separate documentation for Node.js on Azure App Service for Linux, covering best practices and troubleshooting.
- Include Linux-specific configuration examples (e.g., using PM2, Nginx, or Apache as process managers/reverse proxies instead of iisnode/IIS).
- Provide Linux shell (bash) commands and file path examples alongside Windows CMD/PowerShell instructions.
- Reference Linux log file locations and troubleshooting tools (e.g., journalctl, systemd logs) where appropriate.
- Clarify at the top of the document that the current content is Windows-specific, and provide a link to Linux guidance if available.
- When discussing tools or settings (e.g., debugging, profiling), mention cross-platform alternatives and how to use them on Linux.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/app-service-managed-certificate-changes-july-2025.md
...e/app-service-managed-certificate-changes-july-2025.md
High Priority
View Details →
Detected Bias Types
Powershell Heavy
Windows Tools
Missing Linux Example
Windows First
Summary
The documentation demonstrates a Windows bias by providing PowerShell scripts as the only automation example for identifying impacted Traffic Manager endpoints, without offering Bash, Azure CLI, or cross-platform alternatives. References to 'open PowerShell' and running '.ps1' scripts are Windows-centric, and there is no mention of equivalent Linux/macOS workflows. Additionally, the PowerShell script is mentioned before any CLI or REST API options, and no Linux shell or cross-platform scripting options are provided for the same tasks.
Recommendations
- Provide equivalent Bash or Azure CLI scripts for all PowerShell examples, especially for identifying Traffic Manager endpoints.
- Explicitly mention that PowerShell Core is cross-platform, or provide instructions for running scripts on Linux/macOS if PowerShell is required.
- Where automation is referenced, offer both Windows (PowerShell) and Linux/macOS (Bash/CLI) examples side by side.
- Avoid language such as 'Open PowerShell' without also mentioning terminal/shell on other platforms.
- Ensure that CLI and REST API examples are given equal prominence and are not only referenced after PowerShell scripts.
- Consider linking to or providing sample scripts in Bash or Python for common administrative tasks.
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 Tomcat data sources, but the Windows section is notably more detailed, featuring extensive PowerShell scripting and Windows-specific file paths and tools. Windows configuration steps are more elaborate, with explicit use of PowerShell and Windows environment variables, while Linux instructions are more concise and rely on shell scripts. The order of presentation sometimes places Windows details before Linux equivalents, and the Windows approach uses Windows-native tools (PowerShell, .cmd files) without always offering Linux alternatives for similar automation or scripting.
Recommendations
- Ensure that Linux and Windows instructions are equally detailed, especially for advanced scenarios such as server-level configuration.
- Provide Linux shell script equivalents for all PowerShell automation shown in the Windows section, including robust examples for copying Tomcat, transforming XML, and managing marker files.
- Where possible, present Linux and Windows instructions in parallel or side-by-side tabs to avoid the perception of Windows-first bias.
- Highlight cross-platform tools and approaches (e.g., use of Azure CLI, bash scripting) before platform-specific tools like PowerShell.
- Explicitly mention differences in file system layout and permissions between Linux and Windows, and offer guidance for both platforms in all advanced scenarios.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/app-service-migration-discover-net.md
...cles/app-service/app-service-migration-discover-net.md
High Priority
View Details →
Detected Bias Types
Windows First
Missing Linux Example
Windows Tools
Summary
The documentation focuses exclusively on discovering ASP.NET web apps hosted on IIS servers within VMware environments, which are Windows-centric technologies. There are no examples, instructions, or mentions of discovering .NET apps hosted on Linux servers (e.g., Kestrel, Apache, Nginx), nor are Linux tools or patterns referenced. All discovery capabilities and resources are described in the context of Windows/IIS, with no Linux parity.
Recommendations
- Include information on discovering .NET web apps hosted on Linux servers, such as those running on Kestrel, Apache, or Nginx.
- Provide examples or documentation links for Linux-based discovery scenarios, if supported by Azure Migrate.
- Explicitly state if Linux-hosted .NET app discovery is not supported, and provide guidance or alternatives for Linux users.
- Ensure that future updates to the documentation mention both Windows and Linux environments where applicable, and provide parity in examples and tooling references.
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 demonstrates a Windows bias by referencing Windows file paths (e.g., D:\home\site\wwwroot) before Linux equivalents, describing deployment directories and behaviors primarily in Windows terms, and omitting explicit Linux/macOS command-line examples or file paths in several sections. The document also references Windows-style directory separators (\) and patterns (e.g., <project-root>\app_data\jobs\...), and does not provide parity for Linux-specific deployment nuances or troubleshooting.
Recommendations
- Present both Windows and Linux file paths and directory structures side by side throughout the documentation (e.g., D:\home\site\wwwroot and /home/site/wwwroot).
- Include Linux/macOS-specific command-line examples and notes where relevant, especially for file operations and deployment steps.
- Use platform-agnostic directory separators (e.g., <project-root>/app_data/jobs/...) or clarify both styles.
- Add troubleshooting tips and behavioral notes specific to Linux-based App Service environments.
- Ensure that all references to tools (such as Azure Storage Explorer) are accompanied by cross-platform alternatives or clarifications on their availability.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/app-service-asp-net-migration.md
.../articles/app-service/app-service-asp-net-migration.md
High Priority
View Details →
Detected Bias Types
Windows First
Missing Linux Example
Windows Tools
Powershell Heavy
Summary
The documentation page demonstrates a strong Windows bias. All migration tools and examples focus exclusively on migrating from Windows environments, specifically from IIS servers. Only Windows-based tools (App Service Migration Assistant, PowerShell scripts) are mentioned, and there are no references to Linux-based web servers (such as Apache or Nginx) or Linux migration scenarios. PowerShell is the only scripting environment referenced, and all download links are for Windows executables or scripts. There are no Linux command-line or tool examples, nor any mention of Linux-specific migration considerations.
Recommendations
- Include guidance and examples for migrating .NET apps hosted on Linux web servers (e.g., Apache, Nginx, Kestrel) to Azure App Service.
- Provide parity in tooling by referencing or developing migration tools that support Linux environments, and include download links for Linux-compatible versions.
- Add Linux shell (bash) script examples alongside PowerShell, and document equivalent Linux commands for discovery and migration.
- Mention Linux migration scenarios and considerations explicitly, including any limitations or differences compared to Windows migrations.
- Clarify in the documentation if certain tools are Windows-only, and suggest alternative approaches for Linux users.
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
Windows Tools
Missing Linux Example
Powershell Heavy
Summary
The documentation demonstrates a Windows bias in several ways: Windows-specific deployment methods (Web Deploy) are highlighted, and examples for these methods are only provided for Windows agents. Troubleshooting and FAQ sections focus on Windows agent requirements for certain features, with no Linux alternatives or parity. In some cases, Windows tools and patterns (such as IIS, Web Deploy, and web.config) are mentioned without Linux equivalents or guidance. Linux is mentioned as an option for agent selection, but detailed examples and troubleshooting for Linux scenarios are lacking.
Recommendations
- Provide equivalent Linux examples for all deployment scenarios, especially for advanced deployment methods (e.g., Web Deploy alternatives for Linux, or clarify limitations).
- When mentioning Windows-specific tools (e.g., Web Deploy, IIS, web.config), also mention Linux equivalents (e.g., Kudu, Nginx/Apache, app-specific config files) or note if none exist.
- In troubleshooting and FAQ sections, include Linux agent-specific guidance and error messages, not just Windows.
- Avoid assuming Windows as the default; when presenting agent selection, alternate the order or provide parallel instructions for both Windows and Linux.
- Where features are Windows-only, clearly state this and suggest best practices or workarounds for Linux users.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/app-service-best-practices.md
...ain/articles/app-service/app-service-best-practices.md
High Priority
View Details →
Detected Bias Types
Windows Tools
Missing Linux Example
Windows First
Summary
The documentation shows subtle Windows bias by referencing Windows-specific tools (such as web.config and iisnode) without equivalent Linux guidance, and by omitting Linux-specific configuration examples or alternatives. While there is a brief mention of running on Linux and using PM2, most configuration and troubleshooting advice defaults to Windows-centric approaches, and Linux parity is not consistently addressed.
Recommendations
- For features like auto-healing, provide Linux-native configuration guidance (e.g., how to configure auto-healing or equivalent on Linux-based App Service plans, since web.config is not used).
- When referencing iisnode or web.config, explicitly note their applicability (Windows only) and provide Linux alternatives (such as using process.json for PM2 or environment variables).
- Add Linux-specific troubleshooting and configuration examples wherever Windows-specific tools or patterns are mentioned.
- Ensure that all best practices and diagnostic steps are clearly documented for both Windows and Linux App Service environments, including any differences in supported features or configuration files.
- Where possible, present Linux and Windows approaches side by side, or clarify which instructions apply to which platform.
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 detailed guidance and screenshots for Windows users. PowerShell is referenced for network testing, while Linux equivalents are not provided. The GUI for Hybrid Connection Manager is only available on Windows, and this is noted, but the overall tone and depth of guidance favor Windows environments. Some troubleshooting and verification steps are Windows-specific, and Linux users are sometimes directed to less detailed or alternative methods.
Recommendations
- Provide Linux-first or side-by-side instructions and examples, especially for common tasks like installation, troubleshooting, and network testing.
- Include Linux equivalents for PowerShell commands (e.g., use 'nc', 'telnet', or 'curl' for connectivity tests).
- Offer more detailed Linux CLI usage examples and screenshots, matching the depth of Windows GUI coverage.
- Highlight any feature parity or limitations for Linux early and clearly, and suggest workarounds where possible.
- Ensure that troubleshooting sections include both Windows and Linux commands and tools.
- Where a GUI is not available on Linux, provide detailed CLI workflows and consider linking to community or third-party tools if appropriate.
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 parity between Linux and Windows, but there are several subtle signs of Windows bias. Windows examples and tools (such as Kudu, Advanced Tools, and FTPS) are sometimes mentioned first or exclusively, and certain troubleshooting and deployment workflows are described in more detail for Windows. Some sections, like Java Flight Recorder usage, provide more step-by-step guidance for Windows (e.g., using Kudu Process Explorer) than for Linux. There are also references to Windows-specific conventions (e.g., web.config, C:\ paths) and tools without always providing Linux equivalents or context. In a few places, Linux-specific instructions are less detailed or are omitted.
Recommendations
- Ensure that all examples and instructions are provided for both Linux and Windows, with equal detail and order of presentation.
- Where Windows tools (like Kudu/Advanced Tools, FTPS, web.config) are mentioned, provide Linux equivalents or clarify when they are not applicable.
- Avoid using Windows-first ordering in tabbed sections or lists; alternate or start with Linux where appropriate.
- Expand Linux troubleshooting and diagnostic sections to match the depth of Windows guidance (e.g., provide more details on finding PIDs, using SSH, or downloading files from Linux containers).
- Review for any missing Linux-specific examples, especially for deployment, logging, and advanced configuration scenarios.
- Where possible, use cross-platform tools and neutral terminology (e.g., use Azure CLI or REST API examples instead of PowerShell or Windows-only tools).
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/configure-encrypt-at-rest-using-cmk.md
...les/app-service/configure-encrypt-at-rest-using-cmk.md
High Priority
View Details →
Detected Bias Types
Windows Tools
Windows First
Missing Linux Example
Summary
The documentation page demonstrates a mild Windows bias. It references Azure Storage Explorer with a link that defaults to Windows instructions and does not mention Linux or cross-platform alternatives. There are no explicit Linux-specific instructions or examples, and the only tool-specific guidance (Storage Explorer) is presented as if Windows is the default environment. No PowerShell commands are present, but the absence of Linux CLI or tool alternatives and the 'windows' tab in the Storage Explorer link indicate a subtle preference for Windows.
Recommendations
- Explicitly mention that Azure Storage Explorer is cross-platform and provide links or instructions for Linux and macOS users.
- Wherever a tool is referenced (such as Storage Explorer), include notes or links for installation and usage on Linux.
- If there are command-line alternatives (e.g., using az CLI or other open-source tools) for uploading files or generating SAS tokens, provide those examples alongside GUI-based instructions.
- Avoid defaulting documentation links to Windows-specific tabs or sections; use neutral or cross-platform links.
- Add a brief section or note confirming that all Azure CLI commands shown work identically on Linux, macOS, and Windows.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/getting-started.md
...docs/blob/main/articles/app-service/getting-started.md
High Priority
View Details →
Detected Bias Types
Windows First
Powershell Heavy
Windows Tools
Missing Linux Example
Summary
The documentation page demonstrates a moderate Windows bias, especially in the .NET/ASP.NET sections, where Windows tools (Visual Studio, Azure PowerShell) are listed before cross-platform or Linux-native options. Some quickstart links default to Windows or PowerShell tabs, and there is inconsistent parity in Linux/CLI examples across stacks. The 'Next step' call-to-action specifically promotes an ASP.NET (typically Windows-centric) workflow, reinforcing the bias.
Recommendations
- Ensure that for every Windows or PowerShell example, a Linux/CLI/Azure CLI example is provided and given equal prominence.
- Reorder tool lists to alternate or start with cross-platform or Linux-native tools (e.g., Visual Studio Code, CLI) before Windows-only tools.
- Avoid defaulting quickstart links to Windows or PowerShell tabs; use neutral or user-detecting defaults.
- Add explicit Linux/CLI instructions or pivots where missing, especially for .NET workflows.
- Balance 'Next step' call-to-actions to include at least one Linux-native or cross-platform example (e.g., deploying with Azure CLI or from Linux).
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 page demonstrates a Windows bias by primarily referencing Windows development tools and workflows (e.g., Visual Studio, right-click actions, NuGet Package Manager), and omitting explicit Linux or cross-platform alternatives. Instructions for package installation and project setup are centered on Visual Studio and GUI actions, with only passing mention of CLI alternatives. There are no Linux-specific examples or guidance for common Linux development environments.
Recommendations
- Provide explicit Linux and cross-platform instructions for all steps, including project creation, file editing, and package installation (e.g., using dotnet CLI, VS Code, or JetBrains Rider).
- Include CLI-based examples for adding files and editing navigation, rather than only GUI/Visual Studio instructions.
- List CLI/NuGet CLI instructions before or alongside Visual Studio/NuGet Package Manager steps.
- Mention and demonstrate how to set environment variables and manage secrets on Linux (e.g., using Azure CLI, environment files, or Key Vault references via CLI).
- Clarify that the instructions are cross-platform, and highlight any OS-specific considerations for Linux users.
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 Tools
Powershell Heavy
Windows First
Missing Linux Example
Summary
The documentation demonstrates a moderate Windows bias. While it covers both Azure CLI and Azure PowerShell for command-line operations, PowerShell examples are consistently provided alongside CLI, and sometimes with more detailed explanations. Windows-specific tools and configuration patterns (such as Web.config and IIS applicationInitialization) are referenced without Linux equivalents. There is also a lack of explicit Linux-native configuration examples (e.g., for warm-up or rewrite rules), and troubleshooting sections reference Windows file paths and concepts. The documentation does mention 'web app on Linux' in the introduction, but practical parity in examples and troubleshooting is lacking.
Recommendations
- Provide Linux-native configuration examples, such as using appsettings.json, .env files, or startup scripts for warm-up and initialization, especially where Web.config or IIS is referenced.
- When discussing troubleshooting, include Linux file paths and logging locations (e.g., /home/LogFiles) in addition to Windows paths.
- Clarify which features (such as auto swap) are not supported on Linux, and suggest Linux-appropriate alternatives or workarounds.
- For rewrite rules and warm-up, provide Nginx/Apache or Kestrel equivalents alongside IIS/Web.config examples.
- Ensure that Azure CLI examples are presented at least as prominently as PowerShell, and consider leading with CLI (which is cross-platform) rather than PowerShell (which is traditionally Windows-centric).
- Explicitly mention any differences in slot behavior or configuration between Windows and Linux App Service plans.
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 page demonstrates a Windows bias by referencing Windows-specific SKUs and features first (e.g., 'I1v2 Windows'), providing detailed subnet/IP calculations only for Windows Containers, and listing Windows-centric tools (Visual Studio remote debugging, Web Deploy) in port tables without mentioning Linux equivalents or providing Linux-specific examples. There are no Linux-specific configuration or troubleshooting examples, and Linux container/app scenarios are not illustrated in the same detail as Windows.
Recommendations
- Provide parallel examples and calculations for Linux containers and App Service plans, similar to the detailed Windows Container IP address calculation.
- List Linux deployment and debugging tools (e.g., SSH, SFTP, VS Code Remote) alongside Windows tools in port tables and documentation.
- Ensure that any references to SKUs or features (such as standby instance behavior) include both Windows and Linux variants, or clarify differences.
- Add Linux-specific notes or examples where platform behavior differs, especially in networking, scaling, and deployment scenarios.
- Review the order of presentation to avoid always listing Windows first; consider alternating or grouping by OS.
- Include links to Linux-focused resources and troubleshooting guides where appropriate.
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
Missing Linux Example
Windows Tools
Summary
The documentation lists Windows file types and tools (cmd, bat, exe, PowerShell) in detail and with multiple examples, while Linux support is described more briefly and generically. Windows examples are given first and are more comprehensive, whereas Linux examples are minimal and lack parity in detail.
Recommendations
- Provide a more detailed list of supported file types for Linux, similar to the Windows section (e.g., mention .py, .pl, .rb, .js, .jar, etc., where applicable).
- Include explicit examples for Linux code and container tabs, matching the specificity of the Windows examples.
- Avoid listing Windows tools (cmd, bat, exe, PowerShell) exclusively; if mentioning tools, provide Linux equivalents (e.g., bash, python, node, etc.).
- Consider presenting Windows and Linux sections in parallel structure, ensuring both platforms receive equal detail and example coverage.
- Where possible, avoid always listing Windows first, or clarify that the order does not imply priority.
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 page demonstrates a moderate Windows bias. In sections where users are instructed to retrieve outbound IP addresses, both Azure CLI and Azure PowerShell examples are provided, but PowerShell is always listed after CLI and is not explicitly labeled as 'Windows only' or 'for Windows users.' There are no explicit Linux shell or Bash script examples beyond the use of Azure CLI, and no mention of platform-specific nuances for Linux users. Additionally, outbound IPv6 support is noted as being in public preview only for Windows apps, but this is a product limitation rather than a documentation bias. However, the documentation does not provide guidance or alternative suggestions for Linux users regarding this limitation.
Recommendations
- Clearly label PowerShell examples as 'for Windows users' and Azure CLI examples as 'cross-platform' or 'for Linux/macOS/Windows'.
- Provide explicit Bash or Linux shell command examples where appropriate, especially for common tasks like querying IP addresses.
- Where a feature is Windows-only (such as outbound IPv6 support), offer alternative guidance or workarounds for Linux users, or explicitly state the limitation and expected roadmap.
- Ensure that all instructions and examples are presented in a platform-neutral order, or alternate the order to avoid always listing Windows tools second.
- Add a section or callout summarizing any platform-specific differences or limitations, so Linux users are aware of what does and does not apply to them.