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 1226-1250 of 2121 flagged pages
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/overview-patch-os-runtime.md
...main/articles/app-service/overview-patch-os-runtime.md
High Priority
View Details →
Detected Bias Types
Windows First
Missing Linux Example
Windows Tools
Powershell Heavy
Summary
The documentation page exhibits a Windows bias by focusing on Windows-specific tools, commands, and examples. It references Windows registry paths, uses Windows-centric terminology (e.g., Patch Tuesday), and provides instructions and examples that are only applicable to Windows-based App Service instances. There is a lack of equivalent Linux-based examples or guidance, and the documentation does not clarify differences or provide parity for Linux App Service environments.
Recommendations
- Add explicit sections or notes for Linux-based App Service instances, including how OS and runtime patching works for Linux.
- Provide Linux-specific examples for querying OS and runtime versions (e.g., using /etc/os-release, lsb_release, or other Linux commands in Kudu Bash).
- Clarify which instructions or commands apply only to Windows and which to Linux, or provide side-by-side examples for both platforms.
- Avoid referencing Windows registry or tools (such as reg query) without Linux equivalents, or provide alternative Linux commands.
- Mention Linux patching cadence and mechanisms if they differ from Windows, and link to relevant Linux documentation.
Create Pull Request
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/overview-diagnostics.md
...blob/main/articles/app-service/overview-diagnostics.md
High Priority
View Details →
Detected Bias Types
Windows First
Missing Linux Example
Windows Tools
Powershell Heavy
Summary
The documentation demonstrates a Windows-first bias by frequently specifying features as 'Windows apps only' (e.g., Application Insights integration, Proactive CPU monitoring, Proactive auto-healing, Navigator) without providing Linux equivalents or alternatives. Some advanced diagnostic tools and workflows are described as available only for Windows, and there are no Linux-specific troubleshooting examples or command-line instructions. Linux support is mentioned but not detailed, and Linux-specific features are less emphasized or lack parity in explanation.
Recommendations
- Provide equivalent Linux examples and workflows where possible, or clearly state limitations and suggest alternative approaches for Linux users.
- Include Linux-specific troubleshooting steps, screenshots, and command-line (e.g., Bash) instructions alongside or before Windows/Powershell examples.
- Highlight Linux diagnostic tools and features with the same level of detail as Windows features, including proactive monitoring and auto-healing capabilities.
- Where features are Windows-only, offer guidance or workarounds for Linux users, and maintain parity in documentation structure and depth.
- Add a comparison table 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/overview-local-cache.md
...blob/main/articles/app-service/overview-local-cache.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-style paths (e.g., D:\home), describing behaviors and folder structures in Windows terms, and omitting equivalent Linux paths or behaviors. There are no Linux-specific examples or instructions, and tools/extensions mentioned (such as Azure Web Apps Disk Usage) are not clarified for Linux. The feature is described as unsupported for Linux containers, but there is little guidance for Linux App Service users overall.
Recommendations
- Include Linux-specific examples and path references (e.g., /home/site/wwwroot) alongside Windows examples.
- Clarify which features and tools (such as Azure Web Apps Disk Usage) are available or have equivalents on Linux App Service.
- Provide explicit instructions or notes for Linux App Service users, even if only to state limitations or alternatives.
- Where features are unsupported on Linux, offer links or guidance to Linux-compatible alternatives (such as App Cache or KuduLite).
- Ensure that all code snippets, environment variable checks, and troubleshooting steps are presented for both Windows and Linux environments where applicable.
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
Windows Tools
Missing Linux Example
Summary
The documentation page demonstrates a Windows bias in several areas: IP restriction features and configuration examples are described specifically for 'App Service on Windows', with references to Windows-specific tools (web.config and IIS dynamicIpSecurity). There are no equivalent Linux examples or mentions of how to achieve similar security configurations on App Service for Linux. This may leave Linux users without guidance for important security features.
Recommendations
- Provide parallel instructions and examples for App Service on Linux wherever Windows-specific features (such as IP restrictions via web.config) are mentioned.
- Explicitly state which features are Windows-only and offer alternative approaches or workarounds for Linux users.
- Include Linux-relevant configuration files (such as nginx.conf or .htaccess) and command-line examples where appropriate.
- Review the documentation for other sections where Windows tools or patterns are referenced and ensure Linux parity in guidance and examples.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/overview-managed-identity.md
...main/articles/app-service/overview-managed-identity.md
High Priority
View Details →
Detected Bias Types
Powershell Heavy
Windows Tools
Windows First
Summary
The documentation provides extensive examples using Azure PowerShell and references to PowerShell modules, which are most commonly used on Windows. In several sections, PowerShell is given equal or greater prominence than cross-platform tools, and there is no explicit mention of Linux-specific shell usage or guidance for Linux users. The documentation assumes familiarity with Windows-centric tools and patterns, potentially disadvantaging Linux users.
Recommendations
- Explicitly state that Azure CLI and ARM templates are fully cross-platform and provide shell-agnostic examples (e.g., Bash, zsh) where possible.
- For PowerShell examples, clarify that PowerShell Core is available on Linux and macOS, and provide equivalent Bash or shell script examples for common tasks.
- Avoid using PowerShell as the only scripting example; always pair with Bash/Azure CLI where possible.
- Add notes or sections highlighting any differences or prerequisites for Linux users, such as installation steps for Azure CLI or PowerShell Core on Linux.
- Review and adjust the order of examples so that cross-platform tools (Azure CLI, ARM templates) are presented before or alongside PowerShell, rather than after.
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
Windows Tools
Missing Linux Example
Summary
The documentation page demonstrates a mild Windows bias. Windows platforms and tools are consistently mentioned first in lists (e.g., 'Windows code' before 'Linux code'), and deployment via Visual Studio (a Windows-centric tool) is highlighted as a primary method. While Linux and Bash are acknowledged, there are no Linux-specific deployment examples or references to Linux-native tools (e.g., VS Code, SCP, or Linux CLI patterns). The documentation also lacks explicit Linux-focused guidance or parity in example scenarios.
Recommendations
- Alternate the order of Windows and Linux mentions, or list them alphabetically to avoid implicit prioritization.
- Add Linux-specific deployment examples, such as using Azure CLI, SCP, or VS Code on Linux.
- Include references to Linux-native tools and workflows (e.g., deploying from a Linux terminal, using Bash scripts for automation).
- Provide links to tutorials or quickstarts that demonstrate Linux-based development and deployment.
- Clarify that Visual Studio is not required and highlight cross-platform alternatives (e.g., Visual Studio Code, GitHub Actions, Azure CLI).
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 page demonstrates a subtle Windows bias. While the content is generally platform-agnostic, there are specific sections that focus on Windows Containers (with detailed subnet/IP calculations) without providing equivalent Linux container guidance. The mention of Kudu console UI (primarily associated with Windows-based App Service) and the lack of Linux-specific examples or troubleshooting steps further reinforce this bias. Linux-specific deployment/networking considerations are only briefly mentioned (e.g., a single note about Linux continuous deployment network dependencies), and there are no Linux container subnet/IP sizing examples, nor references to Linux-native tools or troubleshooting methods.
Recommendations
- Add a parallel section for Linux Containers, including subnet/IP address calculation examples and any platform-specific limits or considerations.
- Include Linux-native tools (such as SSH, Bash, or Azure CLI examples run from Linux) in relevant sections, especially for troubleshooting or environment variable inspection.
- Balance references to Kudu console UI with equivalent Linux troubleshooting tools or interfaces (e.g., SSH into Linux App Service, using the Azure CLI).
- Where Windows-specific features or limitations are discussed, provide a corresponding Linux section or explicitly state if the limitation does not apply to Linux.
- Expand the Linux continuous deployment section to include more comprehensive guidance and examples, similar to the detail provided for Windows Containers.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/provision-resource-terraform.md
...n/articles/app-service/provision-resource-terraform.md
High Priority
View Details →
Detected Bias Types
Windows First
Powershell Heavy
Windows Tools
Summary
The documentation shows some Windows bias in the prerequisites section, where Windows and PowerShell options are listed before Linux equivalents, and Windows-specific tooling (PowerShell, Visual Studio Code) is emphasized. However, the main Terraform examples are provided for both Linux and Windows App Service plans, and the implementation steps use Bash commands, which are cross-platform.
Recommendations
- List Linux/Bash options before Windows/PowerShell in the prerequisites to avoid 'windows_first' ordering.
- Ensure that all command-line examples are clearly marked as cross-platform or provide explicit Linux/macOS and Windows (PowerShell/CMD) alternatives where relevant.
- Mention Linux-native editors (such as Vim, Nano, or VS Code on Linux) alongside Visual Studio Code to avoid the impression of Windows tooling preference.
- In the prerequisites, clarify that Azure Cloud Shell is available in both Bash and PowerShell, and that both are accessible from any OS.
- If referencing PowerShell, also reference Bash or other shells for parity, especially in step-by-step instructions.
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 generally provides parity between Linux and Windows deployment options, especially in CLI and VS Code workflows. However, there are subtle biases: (1) In the Visual Studio Code deployment section, the Windows workflow is described in more detail and with more steps, including troubleshooting for missing web.config, which is a Windows-specific concern. (2) The use of Visual Studio Code and FileZilla as recommended tools may be more familiar to Windows users, with no mention of Linux-native alternatives. (3) Some troubleshooting and configuration notes (such as web.config generation) are only present for Windows, with no equivalent Linux-specific guidance. (4) In some cases, Windows deployment steps are listed before Linux, or have more elaborate instructions, which can reinforce a Windows-centric perspective.
Recommendations
- Ensure that Linux and Windows deployment instructions are equally detailed, including troubleshooting tips specific to Linux (e.g., permissions, common deployment issues).
- When referencing tools like FileZilla or Visual Studio Code, also mention popular Linux-native alternatives (e.g., gFTP, GNOME Terminal, or other editors like Vim/Emacs) and clarify cross-platform compatibility.
- Where Windows-specific configuration (such as web.config) is discussed, provide parallel Linux-specific notes (such as startup script configuration, permissions, or environment variable handling).
- In tabbed or pivoted instructions, present Linux and Windows options in a consistent order or randomize the order to avoid reinforcing a default preference.
- Review all screenshots and UI references to ensure they are not exclusively from Windows environments; include Linux UI examples where possible.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/quickstart-dotnetcore.md
...lob/main/articles/app-service/quickstart-dotnetcore.md
High Priority
View Details →
Detected Bias Types
Windows First
Powershell Heavy
Windows Tools
Missing Linux Example
Summary
The documentation exhibits several forms of Windows bias. Visual Studio (Windows-only) is presented as the primary IDE, with detailed, screenshot-rich steps for both .NET 8.0 and .NET Framework 4.8. PowerShell is given its own section, and PowerShell-based deployment steps are provided in detail, but Linux shell equivalents are not always present or are less detailed. In the PowerShell section, Linux deployment is explicitly discouraged, and the only provided publish steps use Windows-style paths and tools (e.g., Compress-Archive). Some CLI steps use Windows-centric commands and directory structures. Visual Studio for Mac is only mentioned in a table, with no corresponding walkthrough. There are also places where Windows is the default or first-mentioned OS, and Linux options are secondary or omitted.
Recommendations
- Provide parity for Linux users by including detailed, step-by-step instructions for Linux shell (bash) alongside PowerShell, especially for tasks like zipping and deploying files.
- Include screenshots and walkthroughs for Visual Studio Code and command-line workflows on Linux, not just Windows.
- Where PowerShell is used, offer equivalent bash/zsh commands and note any platform-specific differences.
- Avoid language that discourages Linux use (e.g., 'We recommend Azure PowerShell for creating apps on the Windows hosting platform. To create apps on Linux, use a different tool...'). Instead, provide clear, supported Linux workflows.
- Add explicit Visual Studio for Mac instructions or clarify its limitations.
- Ensure all file paths and command examples are shown in both Windows and Linux formats where relevant.
- When listing OS options (e.g., in Azure portal or CLI), present Linux and Windows equally, not always with Windows first.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/quickstart-python-1.md
.../blob/main/articles/app-service/quickstart-python-1.md
High Priority
View Details →
Detected Bias Types
Windows First
Powershell Heavy
Missing Linux Example
Summary
While the documentation is titled and themed around Linux, there are several instances where Windows-specific tools and patterns are presented first or exclusively. For example, in the 'Set up your initial environment' and 'Run the sample' sections, PowerShell and Cmd examples are given alongside or before Bash, and in some cases, Bash/Linux-specific guidance is minimal or missing. The documentation sometimes assumes familiarity with Windows command-line tools (e.g., 'py -3'), and does not always provide parity for Linux users, especially in the Django section where Bash, PowerShell, and Cmd are all shown, but the Bash example is not always presented first or emphasized.
Recommendations
- Present Bash/Linux examples first in all code blocks and tabs, especially since the quickstart is Linux-focused.
- Ensure all command-line instructions use Linux-native commands and patterns as the default, with Windows variants as secondary.
- Where 'py -3' is used (a Windows launcher), clarify or provide the equivalent Linux command (usually 'python3') and explain any differences.
- Review all sections for any missing Linux-specific instructions or troubleshooting tips, and add them where necessary.
- Consider removing or de-emphasizing PowerShell and Cmd tabs unless the documentation is explicitly cross-platform, or clearly mark them as alternatives.
- Audit for any references to Windows-only tools or patterns, and provide Linux equivalents or alternatives.
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 page demonstrates a Windows bias in several ways: Windows-specific paths and tools are often mentioned first or exclusively (e.g., 'D:\home', references to 'w3wp.exe', 'applicationHost.config', and use of Windows time zone documentation). Many environment variable descriptions and examples are tailored to Windows (such as default paths, process names, and configuration files), with Linux equivalents either mentioned later, less prominently, or omitted. Some features are described only in the context of Windows tools or patterns (e.g., MSDeploy, Web Deploy, IIS), and PowerShell/Windows-centric terminology is prevalent. Linux-specific details are sometimes present but are less thorough or appear as afterthoughts.
Recommendations
- For every environment variable or feature that behaves differently on Windows and Linux, provide both Windows and Linux examples side by side, including file paths, process names, and configuration file locations.
- Avoid referencing Windows tools (e.g., MSDeploy, Web Deploy, IIS, applicationHost.config) without also providing Linux alternatives or clarifying their applicability.
- When listing default values or behaviors, present Linux and Windows defaults together, not with Windows first or exclusively.
- Where possible, link to both Windows and Linux documentation for referenced concepts (e.g., time zones, logging, process management).
- Review all examples and ensure that Linux users are not required to mentally translate Windows-centric instructions.
- Add Linux-specific troubleshooting and configuration notes where only Windows-specific ones are currently present.
- Ensure parity in depth and clarity for both platforms, especially in sections like build automation, logging, and deployment.
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 Visual Studio's Package Manager Console (PowerShell-based), but it lists the Visual Studio/PowerShell method second. However, the Visual Studio/PowerShell example is included, which is Windows-specific, while no explicit Linux or cross-platform GUI alternative is mentioned. The focus on Visual Studio and its tools, without mentioning Linux IDEs or editors, and the lack of explicit Linux shell examples (e.g., bash), indicates a mild Windows bias.
Recommendations
- Add explicit Linux/macOS shell instructions (e.g., bash/zsh) for installing NuGet packages, clarifying that the .NET CLI works cross-platform.
- Mention and provide examples for using popular Linux editors/IDEs (e.g., VS Code, JetBrains Rider) alongside Visual Studio.
- Clarify that the .NET CLI commands are platform-agnostic and can be run on Windows, Linux, or macOS.
- If referencing GUI tools, include cross-platform options or note their availability.
- Avoid referencing PowerShell/Visual Studio-specific tools without offering Linux/macOS equivalents or alternatives.
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
Missing Linux Example
Windows Tools
Summary
The documentation demonstrates a Windows-first bias, particularly in the 'Application Initialization (AppInit)' section, where detailed instructions and references are provided for Windows (IIS Application Initialization Module), while Linux is only briefly mentioned with a single environment variable and no further explanation or example. Several features and troubleshooting steps are described in depth for Windows, with Linux alternatives either missing or only linked without detail. Windows tools and patterns (such as IIS modules and .NET Core stdout logging) are highlighted, while Linux equivalents are not discussed.
Recommendations
- Provide equally detailed Linux examples and explanations, especially for application initialization and warm-up mechanisms. For example, include a step-by-step guide for configuring WEBSITE_WARMUP_PATH on Linux, with sample configuration and expected behavior.
- When referencing Windows-specific tools (like IIS Application Initialization Module or .NET Core stdout logging), also mention and explain Linux-native equivalents or approaches (such as using startup scripts, health probes, or Linux logging best practices).
- Ensure that for every Windows feature or troubleshooting step described, a Linux equivalent is either described or explicitly noted as unavailable, with suggested workarounds if possible.
- Structure sections so that Linux and Windows approaches are presented with parity, rather than Windows-first with Linux as an afterthought.
- Add practical Linux command-line or configuration examples where appropriate, not just links.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/samples-resource-manager-templates.md
...cles/app-service/samples-resource-manager-templates.md
High Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Missing Linux Example
Summary
The documentation provides both Linux and Windows examples for basic App Service deployments, but Windows scenarios are often listed before Linux equivalents, and there are more Windows-specific templates (e.g., Windows container, Windows with MySQL/PostgreSQL) than Linux ones. Some advanced scenarios (e.g., App with connected resources) are only shown for Windows, with Linux equivalents missing. There is also a lack of parity in the depth and variety of Linux-focused examples compared to Windows.
Recommendations
- Ensure that for every Windows-specific template (e.g., App with MySQL/PostgreSQL, App with SQL Database), there is a Linux equivalent provided and linked.
- Present Linux and Windows examples in parallel or alternate their order to avoid implicit prioritization of Windows.
- Add more advanced Linux scenarios, such as Linux app with Azure SQL Database, Linux app with Blob storage, and Linux app with Redis cache.
- Where possible, use neutral language and avoid grouping Linux examples separately from the main list to reinforce parity.
- Review and update the documentation regularly to ensure Linux and Windows feature parity as Azure evolves.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/scenario-secure-app-access-microsoft-graph-as-user.md
...https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/scenario-secure-app-access-microsoft-graph-as-user.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 prioritizing Windows-centric tools and workflows. Package installation instructions are given first for the .NET Core CLI (cross-platform), but then for the Visual Studio Package Manager Console, which is Windows-only and uses PowerShell syntax. There are no explicit Linux or macOS-specific instructions or mentions of alternative editors or package managers. Visual Studio (Windows) is referenced without mention of VS Code or other cross-platform IDEs. The documentation assumes familiarity with Windows tooling and omits Linux-specific guidance.
Recommendations
- Add explicit instructions for Linux/macOS users, such as using the .NET CLI in Bash or Zsh terminals.
- Mention and provide examples for using Visual Studio Code (cross-platform) alongside or instead of Visual Studio.
- Clarify that the .NET CLI commands work on all platforms, and provide terminal commands for Bash (Linux/macOS) where appropriate.
- Avoid referencing Windows-only tools (like the Visual Studio Package Manager Console) without offering cross-platform alternatives.
- Where UI navigation is described (e.g., opening the console), include steps for cross-platform editors or command lines.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/scenario-secure-app-access-storage.md
...cles/app-service/scenario-secure-app-access-storage.md
High Priority
View Details →
Detected Bias Types
Windows First
Powershell Heavy
Missing Linux Example
Windows Tools
Summary
The documentation page demonstrates a bias towards Windows environments by prioritizing Windows-specific tools and workflows. The Package Manager Console (a Visual Studio/Windows feature) is highlighted alongside the .NET CLI, and only PowerShell commands are shown for package installation. There are no explicit Linux or cross-platform shell examples, and Visual Studio (primarily a Windows IDE) is referenced without mention of alternatives like VS Code or command-line workflows common on Linux.
Recommendations
- Add explicit Linux/macOS instructions for installing the required NuGet packages, such as using the .NET CLI in Bash or Zsh.
- Mention and provide examples for using cross-platform editors like Visual Studio Code, or clarify that Visual Studio is Windows-only.
- Present the .NET CLI (dotnet add package) instructions before or at least equally with the Package Manager Console, emphasizing its cross-platform nature.
- Avoid referencing Windows-specific tools (like the Package Manager Console) without offering Linux/macOS equivalents.
- Include notes or examples for running the sample code on Linux and macOS, ensuring parity in developer experience.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/troubleshoot-http-502-http-503.md
...articles/app-service/troubleshoot-http-502-http-503.md
High Priority
View Details →
Detected Bias Types
Powershell Heavy
Windows Tools
Missing Linux Example
Summary
The documentation page demonstrates a bias towards Windows by referencing PowerShell and DOS commands as the primary means of interacting with the Kudu debug console, and by mentioning the use of Windows-specific tools like ProcDump. There are no examples or mentions of Linux shell commands or Linux-native troubleshooting tools, despite Azure App Service supporting Linux-based apps.
Recommendations
- Include examples of using Bash or Linux shell commands in the Kudu debug console, alongside PowerShell and DOS commands.
- Mention Linux-compatible alternatives to ProcDump for memory dumps, or clarify if ProcDump is available in Linux containers.
- Provide parity in troubleshooting steps and tool recommendations for both Windows and Linux-based App Service environments.
- Explicitly state when a tool or command is Windows-only, and provide equivalent instructions for Linux users.
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 page demonstrates a Windows-first bias by providing more detailed instructions and features for Windows App Service apps, such as web server logging, detailed error messages, and failed request tracing, which are not available or documented for Linux. Several sections (e.g., enabling web server logging, detailed errors, failed request tracing) only mention Windows, with no Linux equivalents or alternatives. Additionally, Windows-specific tools and log formats (e.g., W3C log format, Log Parser, references to D:\ paths) are highlighted, while Linux-specific tools or patterns are not discussed.
Recommendations
- Clearly indicate feature parity or lack thereof for Linux vs. Windows in each section, and provide Linux alternatives or workarounds where possible.
- Add explicit Linux examples and instructions for all logging types, or state if a feature is not supported on Linux.
- Include Linux-relevant tools and log file paths (e.g., /home/LogFiles) alongside Windows examples.
- For sections that are Windows-only (e.g., web server logging, failed request tracing), provide guidance on equivalent troubleshooting/logging approaches for Linux (such as using OpenTelemetry, custom logging, or third-party tools).
- Balance the order of presentation so that Linux and Windows are given equal prominence, or group instructions by platform.
- Reference Linux-friendly log analysis tools in addition to Windows tools like Log Parser.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/troubleshoot-domain-ssl-certificates.md
...es/app-service/troubleshoot-domain-ssl-certificates.md
High Priority
View Details →
Detected Bias Types
Windows First
Missing Linux Example
Powershell Heavy
Summary
The documentation exhibits a mild Windows bias. In troubleshooting steps and FAQs, Windows-specific tools and commands (such as 'ipconfig /flushdns') are mentioned without Linux/macOS equivalents. PowerShell is referenced explicitly for resource movement, but no CLI or Bash alternatives are provided. There are no Linux-specific troubleshooting commands or examples, and Windows tools are mentioned before or instead of cross-platform or Linux-native tools.
Recommendations
- When providing command-line troubleshooting steps (e.g., flushing DNS cache), include equivalent commands for Linux (e.g., 'sudo systemd-resolve --flush-caches' or 'sudo resolvectl flush-caches') and macOS ('sudo dscacheutil -flushcache; sudo killall -HUP mDNSResponder').
- When referencing PowerShell cmdlets (e.g., 'Move-AzResource'), also mention the equivalent Azure CLI command (e.g., 'az resource move') and provide Bash syntax where appropriate.
- Where Windows tools or patterns are mentioned, ensure Linux and macOS alternatives are also described, or link to relevant documentation.
- Add troubleshooting examples or notes that are relevant to Linux-based environments, especially for common tasks like certificate conversion, DNS troubleshooting, and file uploads.
- Review the order of tool/command presentation to avoid always listing Windows/PowerShell first; consider grouping by platform or explicitly stating cross-platform options.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/troubleshoot-dotnet-visual-studio.md
...icles/app-service/troubleshoot-dotnet-visual-studio.md
High Priority
View Details →
Detected Bias Types
Windows First
Missing Linux Example
Windows Tools
Summary
The documentation is heavily oriented toward Windows and Visual Studio workflows, with all examples and instructions assuming the use of Visual Studio on Windows. There are no references to Linux-based development environments, cross-platform tools, or command-line alternatives (such as Azure CLI or VS Code). All screenshots, file paths, and tool references are Windows-specific, and there is no guidance for users developing or troubleshooting from Linux or macOS systems.
Recommendations
- Add parallel instructions and examples for Linux and macOS users, including how to perform similar troubleshooting tasks using cross-platform tools like Azure CLI, VS Code, or Kudu.
- Include command-line examples for enabling diagnostics, downloading logs, and remote debugging that work on Linux/macOS (e.g., using Azure CLI, SSH, or REST APIs).
- Reference and provide guidance for using VS Code's Azure extensions, which are cross-platform, for tasks like remote debugging and log streaming.
- Clarify which steps are Windows/Visual Studio-specific and provide alternative steps for non-Windows environments.
- Mention and link to documentation for App Service troubleshooting using the Azure portal and Kudu/SCM site, which are accessible from any OS.
- Avoid assuming the presence of Windows-only features (like Server Explorer, Solution Explorer, or File Explorer) and provide alternatives where possible.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/troubleshoot-performance-degradation.md
...es/app-service/troubleshoot-performance-degradation.md
High Priority
View Details →
Detected Bias Types
Powershell Heavy
Windows Tools
Windows First
Missing Linux Example
Summary
The documentation page demonstrates a Windows bias by referencing Windows-specific tools (such as PowerShell, IIS logs, and SysInternals Procdump), mentioning Windows-centric features (like .NET Profiler for Windows), and providing examples and instructions that assume a Windows environment. There is a lack of Linux-specific guidance, tools, or examples, and Linux workflows are not mentioned or are omitted entirely.
Recommendations
- Provide equivalent Linux examples and instructions alongside Windows ones, such as using Bash/SSH instead of only PowerShell.
- Mention and link to Linux-specific diagnostic tools (e.g., using strace, lsof, or Linux-native logging) where Windows tools like Procdump or IIS logs are referenced.
- Clarify when a feature or tool is Windows-only, and offer Linux alternatives or note limitations for Linux-based App Service plans.
- Include references to Linux App Service documentation, such as how to access logs, use the Kudu console on Linux, or collect memory dumps on Linux.
- Balance the order of presentation so that Linux and Windows approaches are given equal prominence, rather than listing Windows first or exclusively.
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
Powershell Heavy
Summary
The documentation provides both Windows and Linux instructions using Azure CLI, but Windows is consistently presented first in all platform-specific pivots. Additionally, references to Azure portal UI and 'Advanced Tools' (Kudu), which are more familiar to Windows users, are used without mentioning Linux-native equivalents. There is also a lack of Linux-specific troubleshooting or command-line (bash) examples outside of the Azure CLI context, and no mention of Linux shell or scripting patterns. The documentation does not provide PowerShell-specific commands, but the overall structure and tool references show a subtle Windows bias.
Recommendations
- Alternate the order of platform pivots so that Linux instructions are sometimes presented first, or use a neutral introduction before splitting into platform-specific instructions.
- Where possible, provide Linux-native troubleshooting steps or mention Linux shell commands/scripts for common tasks (e.g., using bash, tailing logs, or using SSH).
- When referencing Azure portal features like 'Advanced Tools', clarify their availability and behavior on both Windows and Linux App Service plans, or provide Linux-specific alternatives if differences exist.
- Ensure that all screenshots and UI walkthroughs are equally applicable to both platforms, or provide separate images where necessary.
- Explicitly state when a command or feature is identical across platforms to reinforce parity.
- Consider including a section or callout highlighting any platform-specific caveats or differences, especially for Linux users.
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 First
Powershell Heavy
Windows Tools
Missing Linux Example
Summary
The documentation demonstrates a Windows bias by prioritizing Windows-centric tools and workflows, such as Visual Studio, Solution Explorer, and PowerShell/Package Manager Console, while omitting equivalent Linux or cross-platform alternatives. There are no explicit Linux or CLI-based development/publishing examples, and the local development and debugging guidance is focused on Windows environments. The documentation assumes the use of Windows-based development tools and does not provide parity for Linux users.
Recommendations
- Provide equivalent Linux and cross-platform examples for development, publishing, and debugging (e.g., using VS Code, dotnet CLI, Azure CLI, and GitHub Actions).
- Include instructions for updating packages and managing dependencies using the dotnet CLI (e.g., 'dotnet add package') instead of only referencing Visual Studio and PowerShell.
- Offer guidance for local debugging and authentication flows on Linux/macOS, including how to obtain tokens and connect to Azure SQL Database from non-Windows environments.
- Mention and demonstrate cross-platform editors (e.g., VS Code) and workflows alongside Windows-specific tools.
- Clarify which steps are platform-agnostic and which are Windows-specific, and provide alternatives where possible.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/tutorial-connect-msi-azure-database.md
...les/app-service/tutorial-connect-msi-azure-database.md
High Priority
View Details →
Detected Bias Types
Windows First
Powershell Heavy
Windows Tools
Summary
The documentation demonstrates a moderate Windows bias, particularly in the 'Set up your dev environment' section. Visual Studio for Windows is presented first and in more detail, while macOS and cross-platform scenarios are treated as exceptions or afterthoughts. Windows-specific tools (Visual Studio, Azure PowerShell) are mentioned before their Linux/macOS equivalents, and PowerShell is given its own tab, whereas Linux-specific shells or tools are not. There are no explicit Linux command-line or shell examples, and the guidance for Linux users is less direct, often referring to Azure CLI as a workaround.
Recommendations
- Present cross-platform or Linux-native tools (such as Azure CLI) before or alongside Windows-specific tools.
- Add explicit Linux/macOS shell examples and instructions, not just references to Azure CLI.
- Include development environment setup instructions for common Linux IDEs (e.g., JetBrains Rider, VS Code on Linux) and shell environments.
- Avoid treating macOS/Linux as exceptions; instead, structure sections so that Windows, macOS, and Linux are presented with parity.
- Where PowerShell is mentioned, also provide Bash/zsh equivalents for Linux/macOS users.
- Clarify that Azure CLI and VS Code are fully cross-platform and highlight their use on Linux/macOS.