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 926-950 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 demonstrates a Windows bias by focusing on Windows-specific concepts, tools, and examples. It provides instructions and examples that are either exclusive to Windows environments (such as referencing the Windows registry, web.config, and Windows-specific patching), or do not mention Linux equivalents. The Kudu console examples and runtime version queries are all Windows-centric, and there is no guidance for Linux-based App Service plans. The only runtime configuration file mentioned is web.config (Windows/IIS), and the note about Node.js versioning explicitly references 'Windows App Service'.
Recommendations
- Include equivalent instructions and examples for Linux-based App Service plans, such as how to check OS and runtime versions on Linux.
- Provide Linux-specific configuration file examples (e.g., appsettings.json, environment variables, or startup scripts) alongside web.config.
- Clarify when instructions or examples apply only to Windows, and provide parallel Linux instructions where possible.
- Mention Linux patching cadence and mechanisms if they differ from Windows.
- In tables and code samples, add Linux shell commands (e.g., cat /etc/os-release, lsb_release -a) for querying OS information.
- Avoid referencing Windows registry or Windows-specific tools without Linux alternatives.
Create Pull Request
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 demonstrates a moderate Windows bias. Visual Studio (Windows-only) is presented as the primary IDE, with detailed, image-rich instructions, while Visual Studio for Mac is only mentioned in a table and not covered in the main flow. PowerShell is given a dedicated section, but Linux shell (bash) is only referenced via Azure CLI, and the PowerShell section explicitly recommends using Azure CLI for Linux. In PowerShell deployment steps, only Windows file paths and commands (e.g., Compress-Archive, cd bin\Release\net8.0\publish) are shown, with no Linux equivalents. Some PowerShell Linux deployment instructions are commented out and not visible to users. Throughout, Windows tools and patterns (e.g., Solution Explorer, right-click Publish) are emphasized, and screenshots are exclusively from Windows environments.
Recommendations
- Provide parity in instructions and screenshots for Linux and macOS users, especially for command-line and VS Code workflows.
- Include explicit bash/zsh shell commands and file paths alongside PowerShell commands, particularly for packaging and deploying with Azure CLI.
- Uncomment and surface the PowerShell Linux deployment instructions, or better yet, provide cross-platform PowerShell Core examples.
- Add more guidance for Visual Studio for Mac and clarify any differences in steps or UI.
- Balance the order of presentation so that cross-platform tools (CLI, VS Code) are not always secondary to Windows/Visual Studio.
- Where possible, use neutral language and examples that work on all platforms, or clearly indicate platform-specific steps.
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
Powershell Heavy
Summary
The documentation is heavily focused on Windows and Visual Studio workflows, with all examples and instructions assuming a Windows environment and Visual Studio as the primary tool. There is no mention of Linux-based development environments, cross-platform tooling, or alternative editors/IDEs. All file paths, configuration steps, and screenshots are Windows/Visual Studio-centric. Tools like Log Parser and FTP instructions are Windows-oriented, and there are no CLI or Linux-native alternatives provided.
Recommendations
- Add equivalent instructions and examples for Linux and macOS environments, including how to troubleshoot and debug Azure App Service apps using VS Code, Azure CLI, or other cross-platform tools.
- Include examples using Azure CLI, az webapp log, and remote debugging via VS Code or other editors, not just Visual Studio.
- Provide guidance for accessing logs and files using SFTP/FTP clients available on Linux/macOS, and mention cross-platform tools for log analysis (e.g., jq, grep, awk, or open-source log viewers).
- Mention and show how to configure and manage App Service apps using the Azure Portal and Azure CLI, not just through Visual Studio's Server Explorer.
- When referencing file paths or configuration files, use platform-agnostic notation or provide both Windows and Linux/macOS examples.
- List Linux/macOS alternatives to Windows-specific tools like Log Parser, or recommend open-source, cross-platform log analysis tools.
- Explicitly state the supported platforms for each feature, and if something is Visual Studio/Windows-only, suggest alternative approaches for other platforms.
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 displays a mild Windows bias in the prerequisites section, where Windows and PowerShell options are listed before Linux alternatives, and there is a strong emphasis on Visual Studio Code (a Microsoft tool). However, the main Terraform examples are provided for both Linux and Windows containers in parallel, and the implementation steps use Bash commands, which are cross-platform. There are no missing Linux examples, but the ordering and tool recommendations slightly favor Windows users.
Recommendations
- List Linux/Bash options before Windows/PowerShell in the prerequisites to avoid the impression of Windows-first bias.
- Include explicit mention that Bash commands work on both Linux and macOS, not just Windows (via WSL or Git Bash).
- Provide alternative editor instructions for users who do not use Visual Studio Code (e.g., nano, vim, or other editors).
- Clarify that the Azure Cloud Shell is available in both Bash and PowerShell, and works identically across platforms.
- Where possible, balance the mention of Windows and Linux tools and avoid defaulting to Microsoft-centric tooling.
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
Powershell Heavy
Windows Tools
Missing Linux Example
Summary
The documentation exhibits a Windows-first bias in several ways: Windows-specific paths and tools are often mentioned before or instead of Linux equivalents (e.g., 'D:\home' before '/home'), and many environment variables and examples reference Windows concepts (such as IIS, Web Deploy, MSDeploy, and .NET/ASP.NET specifics) without always providing Linux or cross-platform alternatives. Some sections, especially around build automation and deployment, provide detailed Windows/Kudu/MSDeploy guidance but only briefly mention Oryx/Linux or relegate Linux info to separate tabs. Several environment variables are described as 'Windows only' or default to Windows behaviors, and some features/tools (like Web Deploy) are described in detail for Windows but not for Linux. There are also cases where Linux-specific examples or usage patterns are missing or less detailed.
Recommendations
- For every Windows-specific path or tool mentioned (e.g., 'D:\home', IIS, MSDeploy), provide the Linux equivalent (e.g., '/home', Nginx/Apache, Oryx) side-by-side or in parallel.
- Ensure that all environment variable descriptions specify both Windows and Linux behaviors, defaults, and paths where applicable.
- Where build and deployment automation is discussed, give equal prominence and detail to Oryx/Linux workflows as to Kudu/Windows workflows, rather than relegating Linux to a secondary tab.
- Add Linux-specific examples and usage notes in all relevant sections, especially where only Windows or PowerShell examples are currently given.
- Avoid Windows-centric language such as 'applicationHost.config', 'w3wp.exe', or '%HOME%' without also providing Linux context (e.g., 'web.config', 'dotnet', '/home', '$HOME').
- Where features are not available or behave differently on Linux, clearly state this and provide Linux alternatives or workarounds if possible.
- Review all tables and examples for parity, ensuring that Linux users can find relevant, actionable information without needing to infer or search elsewhere.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/samples-bicep.md
...e-docs/blob/main/articles/app-service/samples-bicep.md
High Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Missing Linux Example
Summary
The documentation page shows some evidence of Windows bias. Windows-specific samples (such as 'basic Windows app', 'Windows container app', and 'App with MySQL on Windows') are present and sometimes precede or are more detailed than Linux equivalents. There is also a lack of parity in certain scenarios: for example, there is a sample for 'App with MySQL on Windows' but not for Linux, and Windows containers are mentioned without a Linux container counterpart. Additionally, the documentation does not provide Linux-specific tools, patterns, or examples where relevant.
Recommendations
- Ensure that for every Windows-specific sample (e.g., Windows app, Windows container, MySQL on Windows), there is a corresponding Linux sample (e.g., Linux app, Linux container, MySQL on Linux).
- Present Linux and Windows examples in parallel or alternate their order to avoid always listing Windows first.
- Add explicit Linux container deployment samples to match the Windows container example.
- Where possible, mention cross-platform tools and avoid referencing only Windows-specific tools or patterns.
- Review all scenarios to ensure Linux users have equivalent guidance and sample coverage.
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
Powershell Heavy
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: Windows-specific tools (e.g., Visual Studio Code, FileZilla) are mentioned without Linux alternatives; in the VS Code workflow, the Windows deployment path is more complex and described in greater detail, with additional troubleshooting steps and screenshots. The use of 'right-click' and GUI-driven instructions is more common in Windows contexts. Some sections (e.g., web.config generation) are only discussed for Windows, and Linux-specific troubleshooting or nuances are not equally covered. There is also a lack of explicit Linux tool recommendations (e.g., Linux FTP clients), and Windows is sometimes mentioned first or in more detail.
Recommendations
- When mentioning tools like Visual Studio Code or FileZilla, explicitly note their cross-platform availability or suggest Linux-native alternatives (e.g., GNOME Files, lftp, or command-line sftp).
- Ensure that troubleshooting and configuration steps (such as web.config or build automation) are equally detailed for Linux, or explicitly state when they are not needed on Linux.
- Balance the order of presentation: alternate between Linux-first and Windows-first examples, or present both together where possible.
- Where GUI instructions are given (e.g., 'right-click'), clarify equivalent actions for Linux desktop environments or provide command-line alternatives.
- Add Linux-specific tips or troubleshooting sections, especially for common issues (e.g., file permissions, case sensitivity, or package installation differences).
- In all screenshots and walkthroughs, ensure that Linux and Windows environments are equally represented.
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 focused on deploying Python apps to Azure App Service on Linux and generally uses cross-platform Azure CLI commands, there are several instances of Windows bias. In command examples, Windows-specific shells (PowerShell, Cmd) are often presented alongside or even before Bash, and in some cases, Linux-specific instructions are missing or less detailed. The use of 'py -3' (a Windows Python launcher) in PowerShell and Cmd examples, without clear Linux alternatives, may confuse Linux users. The documentation does not always provide parity in example commands or troubleshooting steps for Linux users.
Recommendations
- Ensure that Bash (Linux/macOS) examples are always presented first, especially in a Linux-focused quickstart.
- Where multiple shell examples are given, provide equal detail and clarity for Bash/Linux as for Windows shells.
- Avoid using Windows-specific Python launchers (like 'py -3') in cross-platform documentation; prefer 'python3' which works on Linux/macOS and is increasingly standard on Windows.
- Explicitly note any differences in command usage or environment setup between Windows and Linux, rather than assuming cross-platform equivalence.
- Review all troubleshooting and setup steps to ensure Linux users are fully supported and not directed to Windows-centric solutions.
- Where possible, consolidate examples to use the most cross-platform commands (e.g., 'python3'), and only add platform-specific tabs where absolutely necessary.
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 in several areas. Windows-specific features and tools (such as IIS Application Initialization and .NET Core stdout logging) are discussed in detail, with Linux equivalents mentioned only briefly or as afterthoughts. Linux guidance is often limited to a single sentence or setting, lacking the depth and examples provided for Windows. There are no Linux-specific code samples or detailed configuration instructions, and Windows terminology and modules are referenced without parallel Linux explanations.
Recommendations
- Provide equally detailed Linux examples and explanations alongside Windows ones, especially for features like application initialization and logging.
- Include Linux-specific tools, modules, and configuration patterns (e.g., NGINX/Apache warm-up, systemd service readiness, Linux logging best practices) where relevant.
- When referencing Windows features (such as IIS Application Initialization), immediately follow with the Linux equivalent, including step-by-step instructions or links to relevant documentation.
- Add sample configuration snippets or code for Linux environments, not just mention environment variables.
- Ensure that all features and troubleshooting steps are described for both platforms, or clearly state if a feature is Windows-only and suggest alternatives for Linux.
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) and omitting Linux-native equivalents. It assumes the use of Windows development environments and does not provide parallel instructions for Linux users, particularly for publishing, package management, and local debugging. There is also a lack of explicit Linux or cross-platform guidance for key steps.
Recommendations
- Provide Linux and cross-platform alternatives for all development and deployment steps, such as using the dotnet CLI for package management and publishing instead of Visual Studio and Package Manager Console.
- Include instructions for common Linux editors (e.g., VS Code, JetBrains Rider) and terminal-based workflows.
- Offer examples for connecting to SQL Database using Linux-native tools (e.g., sqlcmd on Linux, Azure Data Studio) alongside SSMS.
- Clarify which steps are platform-agnostic and which are Windows-specific, and provide equivalent commands or guidance for macOS and Linux.
- Explicitly mention and demonstrate how to perform local debugging and authentication flows on non-Windows platforms.
- Where screenshots are provided, include or reference Linux/macOS UI equivalents if applicable.
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 demonstrates a mild Windows bias. In troubleshooting steps, Windows-specific commands (e.g., 'ipconfig /flushdns') are mentioned without Linux/macOS equivalents. The FAQ references PowerShell cmdlets for resource movement but does not mention Azure CLI or cross-platform alternatives. There are no Linux or macOS-specific troubleshooting steps or examples, and Windows tools/commands are given exclusively or first in relevant contexts.
Recommendations
- When suggesting DNS cache clearing, include Linux/macOS equivalents (e.g., 'sudo systemd-resolve --flush-caches' or 'sudo dscacheutil -flushcache').
- When referencing PowerShell cmdlets (e.g., Move-AzResource), also provide Azure CLI equivalents (e.g., 'az resource move').
- Wherever commands or tools are mentioned, ensure parity by including cross-platform or OS-specific alternatives.
- Add examples or notes for Linux/macOS users in troubleshooting steps, especially where platform-specific actions are required.
- Review the documentation for other implicit Windows assumptions and address them to ensure inclusivity for all major platforms.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/scripts/terraform-backup.md
.../main/articles/app-service/scripts/terraform-backup.md
High Priority
View Details →
Detected Bias Types
Windows First
Missing Linux Example
Windows Tools
Summary
The documentation is focused exclusively on creating an Azure Windows web app, with no mention of Linux web apps or examples for Linux. All references, including verification steps, are tailored to Windows web apps, and there is no guidance or parity for Linux-based scenarios.
Recommendations
- Add a parallel section or quickstart for creating an Azure Linux web app with a backup using Terraform.
- Include examples and code snippets for both Windows and Linux web apps, or clearly indicate how to adapt the steps for Linux.
- In verification steps, show how to use the Azure CLI to check both Windows and Linux web apps, or clarify any differences.
- Update the checklist and outputs to mention Linux web app scenarios where applicable.
- Consider a more neutral title or provide links to equivalent Linux documentation for users interested in non-Windows stacks.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/scripts/terraform-secure-backend-frontend.md
...p-service/scripts/terraform-secure-backend-frontend.md
High Priority
View Details →
Detected Bias Types
Windows First
Missing Linux Example
Windows Tools
Summary
The documentation exclusively demonstrates deploying App Service on Windows, using only azurerm_service_plan with os_type set to 'Windows' and azurerm_windows_web_app resources. There are no examples or mentions of Linux-based App Service plans or azurerm_linux_web_app resources, nor any guidance for Linux users. This creates a Windows-centric bias and omits Linux parity for users who may wish to deploy Linux-based web apps.
Recommendations
- Add parallel examples for deploying Linux-based App Service plans using os_type = 'Linux' and azurerm_linux_web_app resources.
- Explicitly mention that both Windows and Linux App Service plans are supported, and provide guidance or links for Linux scenarios.
- Where possible, use neutral naming (e.g., azurerm_app_service_plan and azurerm_web_app) or show both Windows and Linux resource blocks to illustrate cross-platform support.
- Clarify any differences in configuration or prerequisites between Windows and Linux App Service deployments.
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 by presenting detailed instructions and features for Windows App Service apps before Linux equivalents, and in some cases, omitting Linux support entirely (e.g., web server logging, detailed error messages, failed request tracing). Several advanced logging features are described as Windows-only, and examples or references to tools (such as Log Parser and W3C log formats) are Windows-centric. Linux and container scenarios are generally treated as secondary, with less detail and fewer examples.
Recommendations
- Provide equivalent, detailed step-by-step instructions and feature descriptions for Linux and container-based App Service apps wherever possible.
- Explicitly state feature parity or limitations for Linux vs. Windows at the start of each relevant section, and link to Linux-specific alternatives or workarounds if a feature is not available.
- Include Linux-specific examples for log access, streaming, and analysis (e.g., using Linux CLI tools, tailing logs, or parsing logs with common Linux utilities).
- Mention and recommend cross-platform or Linux-native tools for log analysis, not just Windows tools like Log Parser.
- Where features are Windows-only, suggest alternative approaches for Linux users (such as using OpenTelemetry, custom logging, or third-party monitoring solutions).
- Ensure that all code and configuration examples are provided for both Windows and Linux stacks, or clearly indicate when a feature is not supported on one platform.
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
Windows First
Summary
The documentation page demonstrates a Windows bias by referencing PowerShell and DOS commands as the primary or only command-line examples, mentioning Windows-specific tools (ProcDump, Sysinternals), and omitting equivalent Linux tooling or shell examples. The Kudu debug console is described in terms of PowerShell and DOS commands, with no mention of Bash or Linux commands. The guidance for managing and restarting the app highlights Azure PowerShell but does not mention Azure CLI or Linux-native approaches.
Recommendations
- Include examples and instructions for using Bash or Linux shell commands in the Kudu debug console, alongside PowerShell and DOS.
- Mention and provide guidance for Linux-native diagnostic tools (e.g., gcore, strace, lsof) as alternatives to ProcDump for memory dumps and troubleshooting.
- Reference Azure CLI commands for app management and restarting, not just Azure PowerShell, to ensure parity for Linux and cross-platform users.
- When listing command-line options or tools, present cross-platform options together or in parallel sections, rather than defaulting to Windows-first.
- Clarify that Kudu supports both Windows and Linux containers, and highlight any differences in available tools or shell environments.
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 greater detail, with Visual Studio for Mac and cross-platform options following. Windows-specific tools (Visual Studio, Azure PowerShell) are mentioned before their Linux/macOS equivalents. PowerShell is included as a primary authentication method, and the overall structure assumes familiarity with Windows-centric development environments and workflows.
Recommendations
- Reorder the 'Set up your dev environment' section to present cross-platform or Linux/macOS options (such as Azure CLI and Visual Studio Code) before or alongside Windows-specific tools.
- Provide explicit Linux/macOS setup instructions and examples, including common shell environments (bash/zsh) and package managers (apt, yum, brew) for installing Azure CLI and SDKs.
- Balance the detail level between Visual Studio for Windows and other development environments (VS Code, JetBrains IDEs, command-line).
- Clarify that PowerShell is optional and provide equivalent bash/zsh commands where relevant.
- Add troubleshooting tips or notes for Linux/macOS users, especially for authentication and environment setup.
- Where possible, use neutral language and tool-agnostic instructions, emphasizing cross-platform compatibility.
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 demonstrates a Windows bias by focusing on Windows-specific tools (IIS diagnostics, Procdump, PowerShell, web.config), referencing Windows in links and tool names, and omitting Linux-specific instructions or examples. Diagnostic and mitigation steps are described primarily in the context of Windows environments, with no mention of Linux equivalents or cross-platform alternatives.
Recommendations
- Provide Linux-specific examples and instructions for diagnostics, such as using Linux logs, strace, lsof, or other native tools.
- When mentioning PowerShell or DOS commands in Kudu, also mention Bash and Linux shell support, and provide equivalent Linux command examples.
- Reference both Windows and Linux App Service environments when discussing features like Application Insights Profiler, Kudu, and auto-heal, clarifying any differences.
- Include links to Linux-focused documentation or blog posts where available.
- Avoid Windows-centric terminology (e.g., web.config, IIS, Procdump) without also describing Linux alternatives (e.g., appsettings, NGINX/Apache logs, gcore for dumps).
- Explicitly state when a feature or tool is only available on Windows, and suggest Linux workarounds or alternatives.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/tutorial-custom-container.md
...main/articles/app-service/tutorial-custom-container.md
High Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Missing Linux Example
Powershell Heavy
Summary
The documentation is structured with a clear separation between Windows and Linux instructions using pivots. However, the Windows section is presented first and is significantly more prescriptive, with detailed step-by-step instructions using Windows-specific tools (Visual Studio, Windows Explorer, PowerShell scripts, Docker for Windows). The Windows example is tightly coupled to the Windows ecosystem (e.g., installing fonts via Windows Explorer, using .sln files, and PowerShell scripts), while the Linux section is more generic, CLI-focused, and uses a different sample app (Django/Flask vs. ASP.NET). There is no Linux equivalent for the Windows-specific scenario (custom fonts in the OS), and the Windows workflow is heavily dependent on Visual Studio and PowerShell, with no cross-platform alternatives suggested.
Recommendations
- Provide Linux-first or at least parallel Linux and Windows instructions, ensuring neither is prioritized by order or detail.
- For scenarios like installing custom fonts or OS-level dependencies, include a Linux example (e.g., installing fonts in a Linux container) to demonstrate parity.
- Offer cross-platform alternatives to Visual Studio and PowerShell, such as VS Code, Docker CLI, or Bash scripts, and reference them in both pivots.
- Where possible, use sample apps and workflows that are analogous across both platforms, so users can see how to achieve similar outcomes regardless of OS.
- Explicitly mention when a scenario is only possible on Windows or Linux, and provide rationale or workarounds for the other platform.
- Avoid assuming the user is on Windows in shared prerequisites or introductory sections; clarify platform-specific requirements in each pivot.
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
Uneven Detail
Windows Tools
Summary
The documentation provides both Windows and Linux pivots for deployment steps, but Windows instructions and terminology are often presented first, and some details (such as directory structure and runtime versions) are clearer or more consistent for Windows. The use of Azure portal UI steps and references to 'Advanced Tools' (Kudu), which are more familiar to Windows users, further reinforce a Windows-centric approach. There is also inconsistent parity in runtime versions and directory naming between platforms.
Recommendations
- Alternate the order of Windows and Linux pivots throughout the documentation, or present Linux instructions first in some sections to avoid implicit prioritization.
- Ensure that runtime versions and directory structures are consistent and clearly explained for both Windows and Linux (e.g., use the same Node.js version in both pivots unless there is a technical reason).
- Where Azure portal tools are referenced (such as 'Advanced Tools'), clarify their availability and behavior on both Windows and Linux App Service plans.
- Provide explicit notes or troubleshooting steps for Linux-specific issues, such as file permissions, case sensitivity, or differences in deployment tooling.
- Review all examples and ensure that any command-line or portal-based steps are equally detailed and accurate for both platforms.
- Consider adding a summary table or section comparing Windows and Linux behaviors, limitations, or best practices for App Service authentication.
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 shows a clear Windows bias. Windows/PowerShell tools and workflows are prioritized or exclusively presented in several key steps, such as connecting to Azure SQL Database (using sqlcmd in PowerShell) and development environment setup (Visual Studio for Windows, Visual Studio Code, Azure PowerShell). There are no explicit Linux or cross-platform command-line examples for database access or development, and the instructions assume a Windows-centric development environment.
Recommendations
- Provide explicit Linux/macOS examples for connecting to Azure SQL Database, such as using sqlcmd in Bash or Azure Data Studio.
- Include cross-platform development environment instructions, such as using Visual Studio Code or JetBrains Rider on Linux/macOS, and clarify how to configure authentication in those environments.
- When showing command-line examples (e.g., sqlcmd), provide both Windows (PowerShell/cmd) and Linux/macOS (Bash) variants, including installation instructions for required tools on all platforms.
- Avoid assuming Visual Studio for Windows as the default IDE; mention and provide parity for Visual Studio Code and other cross-platform editors.
- Highlight any platform-specific differences or requirements, especially for .NET development on Linux/macOS.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/app-service-best-practices.md
...ain/articles/app-service/app-service-best-practices.md
High Priority
View Details →
Detected Bias Types
Windows First
Missing Linux Example
Windows Tools
Summary
The documentation demonstrates a Windows bias by referencing Windows-specific configuration files (web.config), mentioning Windows-native tools (iisnode) for Node.js apps, and omitting equivalent Linux-native examples or tools. While there is a brief mention of running on Linux with PM2, the overall guidance and examples prioritize Windows patterns and tools, with Linux alternatives either missing or mentioned secondarily.
Recommendations
- Provide Linux-native configuration examples alongside or before Windows-specific ones (e.g., show how to configure auto-healing or memory limits for Linux-based App Service plans, not just via web.config).
- Include Linux-native process managers and configuration files (e.g., systemd, supervisord, or PM2 ecosystem files) when discussing Node.js app hosting, not just iisnode.
- When referencing tools or settings (like iisnode or web.config), explicitly note their applicability (Windows-only) and provide equivalent Linux guidance.
- Ensure that troubleshooting and best practices sections include parity for both Windows and Linux App Service environments, with clear, side-by-side examples where possible.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/app-service-asp-net-migration.md
.../articles/app-service/app-service-asp-net-migration.md
High Priority
View Details →
Detected Bias Types
Windows First
Powershell Heavy
Windows Tools
Missing Linux Example
Summary
The documentation page demonstrates a strong Windows bias. All migration tools and examples focus exclusively on migrating from Windows environments, specifically IIS servers, and use Windows-specific tools such as the App Service Migration Assistant (MSI installer) and PowerShell scripts. There is no mention of Linux-based hosting environments (e.g., Apache, Nginx), nor are there examples or tools for migrating .NET apps from Linux servers. The documentation also refers to Windows containers and does not provide parity for Linux containers or Linux-based migration scenarios.
Recommendations
- Include migration guidance and tools for .NET apps hosted on Linux servers (e.g., Apache, Nginx, Kestrel).
- Provide Linux shell (bash) script examples alongside PowerShell scripts for discovery and migration.
- Mention and document migration paths for .NET Core/ASP.NET Core apps running on Linux.
- Add references to Linux-compatible tools or clarify if current tools are Windows-only.
- Ensure that documentation tables and tool descriptions explicitly state platform support and offer alternatives for Linux users.
- Highlight containerization options for both Windows and Linux containers, not just Windows Containers.
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 exhibits 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 used as the default for network testing, and Windows-specific tools (such as the Hybrid Connection Manager GUI) are emphasized, while Linux alternatives are less detailed or missing. Some troubleshooting steps and examples are only provided for Windows, and GUI-based workflows are not available for Linux users.
Recommendations
- Provide Linux command-line equivalents for all PowerShell examples (e.g., use 'nc' or 'telnet' for network testing instead of only 'Test-NetConnection').
- When presenting instructions, alternate the order or present Linux and Windows instructions side by side, rather than always listing Windows first.
- Expand Linux installation and usage instructions to match the detail and clarity of the Windows sections, including more screenshots or terminal output where possible.
- Offer Linux-specific troubleshooting steps, including commands for checking service status, network connectivity, and DNS resolution.
- Clarify any feature gaps (such as the absence of a Linux GUI) and suggest alternative workflows or third-party tools for Linux users.
- Ensure that all programmatic and CLI examples are explicitly cross-platform and tested on both Windows and Linux.
App Service
https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/app-service/configure-authentication-file-based.md
...les/app-service/configure-authentication-file-based.md
High Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Missing Linux Example
Summary
The documentation page demonstrates a Windows-first bias by referencing the Windows file path (C:\home\site\wwwroot) as the default location for the configuration file, and only later mentioning the Linux equivalent. The example path is Windows-specific, and there is no explicit Linux example or screenshot. Additionally, the instructions and examples focus on Windows conventions and tools, with Linux-specific requirements (absolute paths) only mentioned as a note, rather than being presented equally in the main instructions.
Recommendations
- Present both Windows and Linux file paths side-by-side in all relevant instructions and examples (e.g., 'C:\home\site\wwwroot\auth.json' for Windows and '/home/site/wwwroot/auth.json' for Linux).
- Include explicit Linux examples and screenshots where applicable.
- Avoid using Windows paths as the default or only example; instead, provide both or use a platform-agnostic placeholder.
- Clarify platform-specific requirements (such as absolute vs. relative paths) in the main instruction steps, not just in notes.
- Where tools or commands are referenced, ensure Linux equivalents are provided or mentioned equally.
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 by listing Windows-related commands and tools (such as Azure PowerShell) after Azure CLI, but still giving them prominent, separate sections. The use of PowerShell is highlighted, and the documentation refers to the Azure portal UI, which is more familiar to Windows users. There are no explicit Linux shell or scripting examples beyond the Azure CLI, and no mention of Linux-native tools or patterns. While Linux is acknowledged (e.g., Linux SKU availability), practical Linux-specific automation or scripting guidance is missing.
Recommendations
- Add explicit Linux shell (bash) scripting examples alongside PowerShell, especially for automation tasks.
- Clarify that Azure CLI commands work cross-platform and can be used in Linux/macOS environments.
- Include references to Linux-native tools or scripting environments where appropriate.
- Ensure that any UI instructions are platform-neutral or clarify parity for Linux users.
- Consider providing a table or side-by-side examples for both PowerShell and bash where scripting is discussed.