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 226-250 of 2121 flagged pages
High Priority
View Details →
Detected Bias Types
Windows First
Missing Linux Example
Windows Tools
Powershell Heavy
Summary
The documentation page demonstrates Windows bias primarily in the 'Managed Instance on Azure App Service (preview)' section, which exclusively discusses Windows web apps, Windows-specific dependencies, and tools such as PowerShell and RDP. There are no Linux equivalents or examples provided for managed instance features, and Windows tools/patterns are mentioned without Linux alternatives. The general documentation mentions both Windows and Linux as supported operating systems, but advanced features and examples are Windows-centric.
Recommendations
- Provide equivalent Linux examples and features where possible, or explicitly state Linux limitations and roadmap.
- Include Linux-specific tooling and configuration patterns (e.g., Bash scripts, SSH access) alongside Windows tools like PowerShell and RDP.
- Clarify which features are Windows-only and offer guidance or alternatives for Linux users.
- Add parity tables or comparison charts showing feature availability for both Windows and Linux App Service plans.
- Ensure that documentation sections do not default to Windows-first explanations, and balance examples between platforms.
Create Pull Request
App Service
Operating System Functionality in Azure App Service
...articles/app-service/operating-system-functionality.md
High Priority
View Details →
Detected Bias Types
Windows First
Missing Linux Example
Windows Tools
Powershell Heavy
Summary
The documentation page is heavily focused on Windows-based App Service environments. It describes file paths using Windows environment variables (e.g., %SystemDrive%, %ResourceDrive%, %HOME%), references Windows-specific concepts like IIS, ASP.NET, COM components, and registry access, and mentions PowerShell scripts as examples of code execution. Linux is only briefly mentioned, with no equivalent examples or details about Linux file paths, tools, or diagnostic mechanisms. There are no Linux-specific instructions, examples, or parity for concepts like temporary storage, logging, or process identity.
Recommendations
- Add equivalent Linux examples for file paths, environment variables, and storage locations (e.g., $HOME, /tmp, /var/log).
- Include Linux-specific details for diagnostic logging (e.g., syslog, journald) and process management.
- Provide examples of running shell scripts (bash/sh) in Linux App Service environments, not just PowerShell.
- Discuss Linux container behaviors in more detail, including file system layout, permissions, and persistent storage.
- Mention Linux equivalents for concepts like IIS (e.g., Nginx, Apache) and registry (e.g., configuration files).
- Ensure that all sections (file access, network access, diagnostics, code execution) have Linux parity in explanations and examples.
High Priority
View Details →
Detected Bias Types
Windows First
Powershell Heavy
Missing Linux Example
Windows Tools
Summary
The documentation page exhibits several signs of Windows bias. PowerShell examples are provided alongside Azure CLI, but no Linux shell or Bash alternatives are given for PowerShell commands. Outbound IPv6 support is explicitly stated as available only for Windows apps, with Linux apps limited to IPv4. The documentation references Windows-centric tools and patterns (PowerShell, Azure PowerShell modules) without offering parity for Linux users. In some cases, Windows-specific features are mentioned before their Linux equivalents or Linux limitations are highlighted without guidance for alternatives.
Recommendations
- Provide Bash or Linux shell equivalents for all PowerShell command examples, or clarify when PowerShell is required.
- Explicitly state Linux support status for all features, and offer alternative solutions or workarounds for Linux users where features are Windows-only (e.g., outbound IPv6).
- Ensure that Azure CLI examples are presented before or alongside PowerShell, as Azure CLI is cross-platform.
- Where Windows-only features are mentioned, add a note or section for Linux users explaining limitations and possible future support.
- Include troubleshooting or verification steps for Linux environments, not just Windows (e.g., using dig or host for DNS lookups, not just nslookup).
App Service
Managed Instance on App Service overview (preview)
...main/articles/app-service/overview-managed-instance.md
High Priority
View Details →
Detected Bias Types
Windows First
Powershell Heavy
Windows Tools
Missing Linux Example
Summary
The documentation is heavily focused on Windows-specific features, tools, and configuration patterns. All examples and capabilities reference Windows technologies (PowerShell, registry, COM, MSI, IIS, GAC, RDP), and there is no mention of Linux equivalents or parity. The configuration and troubleshooting sections exclusively use Windows tooling and paths, and the platform is explicitly stated as Windows-only. Linux and container workloads are only referenced as unsupported or as alternatives in other hosting options.
Recommendations
- Clearly state Windows-only scope at the top of the documentation to set expectations.
- Where possible, provide comparative notes or links for Linux App Service equivalents (e.g., how configuration, logging, and storage work on Linux plans).
- Add a table or section highlighting feature parity and differences between Windows and Linux App Service plans.
- Include references to Linux documentation for users seeking similar capabilities on non-Windows platforms.
- If future Linux support is planned, note this and provide guidance for migration or feature requests.
App Service
Integrate your app with an Azure virtual network
...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 demonstrates a Windows bias by providing detailed Windows Containers-specific limits and calculations, mentioning Windows Server Active Directory domain join as a limitation, and referencing Windows-specific features (e.g., NetBIOS). Linux-specific guidance is limited to a brief mention of continuous deployment network dependencies, with no Linux container-specific subnet/IP calculations or examples. There are no PowerShell-heavy sections, but Windows patterns and limitations are described in more detail than Linux equivalents.
Recommendations
- Add a comparable section for Linux Containers, including subnet/IP address calculations and scaling guidance.
- List Linux-specific limitations (e.g., supported features, networking constraints) alongside Windows limitations.
- Provide Linux CLI examples (e.g., az CLI, bash) for common operations, not just generic CLI.
- Ensure parity in troubleshooting steps for both Windows and Linux container scenarios.
- Mention Linux authentication/domain join alternatives if relevant, or clarify differences.
- Review and balance the order of presentation so that Linux and Windows are treated equally (not Windows-first).
App Service
Use Private Endpoints for Apps
...main/articles/app-service/overview-private-endpoint.md
High Priority
View Details →
Detected Bias Types
Windows First
Powershell Heavy
Windows Tools
Summary
The documentation page demonstrates a Windows bias primarily in the ordering and selection of examples and tooling. In the 'Related content' section, Windows-centric tools (Azure PowerShell, ARM templates) are listed before Linux-friendly alternatives (Azure CLI, Terraform). PowerShell is highlighted as a primary automation method, and there is no explicit parity in Linux shell or Bash examples. The documentation references Windows-specific naming conventions and tools (e.g., Azure PowerShell) without ensuring equal visibility or instruction for Linux users. There are no explicit Bash or Linux shell examples, and the guidance assumes familiarity with Windows-based workflows.
Recommendations
- Ensure that Linux-friendly tools (e.g., Azure CLI, Bash scripts, Terraform) are listed before or alongside Windows tools in example and quickstart sections.
- Provide explicit Bash or Linux shell examples for all operations currently shown with PowerShell.
- Clarify that all features and steps are available for both Windows and Linux App Service plans, and highlight any differences.
- Add notes or sections for Linux users, including troubleshooting steps and environment-specific considerations.
- Review and balance the ordering of related links so that Linux and cross-platform tools are not secondary to Windows-centric ones.
App Service
Quickstart: Deploy an ASP.NET web app
...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 page exhibits several Windows biases. Visual Studio (Windows-only) is presented as the primary IDE, with detailed steps and screenshots for both .NET Core and .NET Framework. PowerShell instructions are included, but only for Windows, and PowerShell is recommended for Windows hosting, while Linux users are directed to use Azure CLI. The .NET Framework 4.8 workflow is exclusively Windows-based, with no Linux equivalent. Some steps (such as compressing/publishing with PowerShell) lack Linux shell alternatives. In several places, Windows is mentioned before Linux, and Windows-specific tools and patterns are more thoroughly documented.
Recommendations
- Provide equivalent Linux shell (bash) commands for steps currently shown only in PowerShell, such as compressing and publishing deployment artifacts.
- Include explicit instructions and screenshots for using Visual Studio Code and CLI on Linux, especially for .NET Core workflows.
- Clarify that .NET Framework is Windows-only, but ensure .NET Core/.NET instructions are fully cross-platform, with Linux-specific guidance where appropriate.
- Avoid recommending Windows tools (e.g., PowerShell) as the default for cross-platform scenarios; present CLI/bash options first or equally.
- Where screenshots or UI instructions are given for Windows, provide Linux equivalents (e.g., for Azure portal, VS Code on Linux).
- Add notes or pivots for macOS users where relevant.
App Service
Environment Variables and App Settings Reference
...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 exhibits a Windows bias in several ways: Windows-specific tools, paths, and patterns are mentioned first or exclusively in many environment variable descriptions (e.g., 'D:\home', references to IIS, Web Deploy/MSDeploy, w3wp.exe, and applicationHost.config). Windows-centric settings and behaviors are often described in more detail, with Linux equivalents either mentioned later, briefly, or omitted. Examples and links frequently point to Windows documentation or tools, and some features are described only for Windows (or with much more detail for Windows).
Recommendations
- Ensure all environment variable descriptions provide Linux equivalents (paths, behaviors, tooling) alongside Windows details.
- Where Windows tools (e.g., Web Deploy/MSDeploy, IIS, applicationHost.config) are referenced, provide Linux alternatives or clarify their absence/applicability.
- Balance examples and explanations so that Linux and Windows are treated equally, especially in sections like deployment, logging, and build automation.
- Add explicit Linux examples for environment variables, especially where only Windows examples or paths are given.
- Review references and links to ensure parity (e.g., time zones: link to Linux/ICU time zone lists as well as Windows time zones).
- Clarify when a feature or variable is Windows-only, and provide Linux alternatives or workarounds where possible.
- In tables and lists, avoid listing Windows settings first by default; alternate or group by OS for clarity.
High Priority
View Details →
Detected Bias Types
Windows First
Powershell Heavy
Windows Tools
Missing Linux Example
Summary
The documentation page exhibits Windows bias primarily in the Managed Instance section, which focuses on Windows-specific features such as COM, registry access, MSI, drive mapping, and PowerShell install scripts. Windows tools and patterns (PowerShell, RDP, IIS, ACLs, MSMQ) are mentioned exclusively, with no Linux equivalents or examples. The decision guide lists Windows/legacy features first and only briefly mentions Linux/container support as an alternative, without detail or parity in examples.
Recommendations
- Add equivalent Linux-focused examples and features where applicable, such as shell scripting, Linux file system access, and Linux service management.
- Provide parity in tooling examples (e.g., Bash, SSH, Linux package managers) alongside PowerShell and RDP.
- Expand the decision guide to include more detail on Linux/container scenarios, including supported features and limitations.
- Clarify which features are exclusive to Windows and which are available or have alternatives on Linux.
- Include links to Linux/container-specific quickstarts and operational guides, not just Windows/Managed Instance content.
App Service
Quickstart: Run a Custom Container on App Service
...in/articles/app-service/quickstart-custom-container.md
High Priority
View Details →
Detected Bias Types
Windows First
Powershell Heavy
Windows Tools
Summary
The documentation page presents Windows-specific pivots (Visual Studio, PowerShell, CLI) before their Linux equivalents and includes multiple Windows-only tools and workflows (e.g., PowerShell, Visual Studio). There is a heavier emphasis on Windows examples and tools, with Linux content appearing later and fewer Linux-specific pivots (e.g., no Linux CLI or shell examples).
Recommendations
- Ensure Linux pivots (e.g., VS Code, Azure Portal) are presented with equal prominence and ordering as Windows pivots.
- Add Linux CLI and shell examples (e.g., Bash, Azure CLI on Linux) to match the Windows PowerShell and CLI pivots.
- Include Linux-native tooling and workflows (e.g., Docker Compose, shell scripts) where Windows tools (PowerShell, Visual Studio) are used.
- Review the order of pivots to avoid always listing Windows options first; consider alternating or grouping by platform.
- Explicitly mention platform differences and provide guidance for both Windows and Linux users in each section.
App Service
Quickstart: Deploy Managed Instance on Azure App Service (Preview)
...in/articles/app-service/quickstart-managed-instance.md
High Priority
View Details →
Detected Bias Types
Powershell Heavy
Windows Tools
Windows First
Missing Linux Example
Summary
The documentation page exhibits a strong Windows bias. The only configuration (install) script provided is a PowerShell script (Install.ps1) that installs fonts specifically to C:\Windows\Fonts and modifies the Windows registry. All runtime and deployment examples use Windows-specific settings (ASPNET V4.8, C:\Windows\Fonts). There are no Linux equivalents or examples for configuration scripts, font installation, or runtime stacks. The documentation assumes a Windows environment for both app deployment and OS-level customization, with no mention of Linux-based Managed Instance plans or how to achieve similar outcomes on Linux.
Recommendations
- Provide equivalent configuration (install) script examples for Linux, such as Bash scripts that install fonts to /usr/share/fonts and update font cache.
- Include Linux runtime stack options (e.g., .NET Core, Node.js, Python) in the app details and deployment examples.
- Clarify whether Managed Instance supports Linux plans and, if so, document the differences and parity between Windows and Linux.
- Show how to deploy and configure a Linux-based Managed Instance, including OS-level customization steps.
- Ensure that both Windows and Linux users are addressed in prerequisites, deployment, and management sections.
App Service
Create a scheduled WebJob with prebuilt samples
...s/blob/main/articles/app-service/quickstart-webjobs.md
High Priority
View Details →
Detected Bias Types
Windows First
Powershell Heavy
Windows Tools
Missing Linux Example
Summary
The documentation displays a Windows bias by presenting the Windows tab and its sample table before the Linux tab, offering more script types and language samples for Windows (including CMD, Batch, PowerShell, and F#) than for Linux. Windows-specific tools and scripting languages are highlighted (CMD, Batch, PowerShell, F#), while Linux equivalents (such as shell scripts beyond Bash, or other common Linux scripting languages) are missing. There are no Linux-specific examples for PowerShell or F#, and the Linux table is less comprehensive. The documentation also refers to enabling settings for Windows containers and Linux apps together, but the overall pattern and example richness favor Windows.
Recommendations
- Present Windows and Linux tabs in parallel or alternate their order to avoid implicit prioritization.
- Expand Linux sample coverage to include equivalents for PowerShell (e.g., PowerShell Core on Linux), F#, and other common Linux scripting languages (e.g., Perl, Ruby).
- Add Linux-specific examples for shell scripting beyond Bash (e.g., Zsh, Perl, Ruby) if relevant.
- Ensure parity in the number and diversity of samples between Windows and Linux.
- Explicitly mention any platform-specific limitations or differences so users understand why certain samples are only available on one OS.
- Consider adding a summary table comparing available samples for both platforms to highlight parity or gaps.
High Priority
View Details →
Detected Bias Types
Windows Tools
Windows First
Missing Linux Example
Summary
The documentation page shows a subtle Windows bias by referencing IIS-specific features (such as downloading IIS diagnostic dumps, managing IIS processes, and site extensions) and mentioning deployment webhooks specifically for Windows apps. There are no explicit examples or guidance for Linux-based App Service environments, nor are Linux-specific tools or patterns mentioned. The documentation does not provide parity in describing features or usage for Linux-hosted apps.
Recommendations
- Add equivalent Linux-based features and instructions, such as how to access and manage processes or logs in Linux App Service environments.
- Clarify which features (e.g., IIS diagnostic dumps, site extensions, deployment webhooks) are Windows-only, and provide Linux alternatives or note their absence.
- Include examples and references for Linux-based deployments, such as how to use the Kudu console or REST API on Linux apps.
- Balance the mention of Windows and Linux tools, ensuring both are covered where applicable.
App Service
Tutorial - .NET Web app accesses Microsoft Graph as the app| Azure
...e/scenario-secure-app-access-microsoft-graph-as-app.md
High Priority
View Details →
Detected Bias Types
Windows First
Powershell Heavy
Missing Linux Example
Summary
The documentation provides installation instructions for the required NuGet packages using both the .NET Core CLI and the Visual Studio Package Manager Console. However, the Package Manager Console example uses PowerShell syntax and references Visual Studio, which is primarily a Windows tool. There are no explicit Linux-specific instructions or examples, such as using Linux-native IDEs or package managers. The CLI example is cross-platform, but the order of presentation puts Windows-centric tooling (Visual Studio/PowerShell) immediately after.
Recommendations
- Explicitly mention that the .NET Core CLI commands work on Linux, macOS, and Windows.
- Provide installation instructions using Linux-native editors (e.g., VS Code) or terminal-only workflows.
- Avoid referencing Visual Studio as the only IDE; mention alternatives like VS Code or JetBrains Rider.
- If using Package Manager Console, clarify that it is a Windows/Visual Studio feature and suggest cross-platform alternatives.
- Add a note or section for Linux users, including any environment setup steps or troubleshooting tips specific to Linux.
App Service
Tutorial - .NET Web app accesses storage by using managed identities | Azure
...cles/app-service/scenario-secure-app-access-storage.md
High Priority
View Details →
Detected Bias Types
Windows First
Powershell Heavy
Missing Linux Example
Summary
The documentation provides installation instructions for required packages using both the .NET Core CLI and the Visual Studio Package Manager Console. However, the Visual Studio instructions (which use PowerShell) are presented after the cross-platform .NET CLI, but there is no explicit mention of Linux or macOS environments, nor are there examples or guidance for Linux-specific workflows (e.g., using Bash, VS Code, or other editors common on Linux). The only IDE mentioned is Visual Studio, which is primarily a Windows tool, and the Package Manager Console is PowerShell-based, further reinforcing a Windows-centric approach.
Recommendations
- Explicitly mention Linux and macOS as supported platforms for the .NET CLI commands.
- Provide examples or guidance for using VS Code or other cross-platform editors, especially for Linux users.
- Clarify that the .NET CLI commands work on Windows, Linux, and macOS, and consider listing Linux instructions first or equally.
- Avoid referencing only Windows-specific tools (like Visual Studio and PowerShell) without mentioning alternatives for Linux.
- Add a note or section for Linux users, including common package installation patterns and troubleshooting tips.
App Service
Fix HTTP 502 and HTTP 503 Errors
...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 as the primary CLI tool for managing Azure resources, mentioning DOS commands in the Kudu console, and highlighting the use of Windows-specific tools like ProcDump. There are no Linux shell examples, nor are Linux-native troubleshooting tools or commands mentioned. The documentation assumes familiarity with Windows environments and does not provide parity for Linux users.
Recommendations
- Include examples using Bash/Azure CLI for managing and troubleshooting apps, alongside PowerShell examples.
- Mention Linux equivalents to ProcDump, such as gcore or dotnet-dump, for memory dump collection.
- Clarify that the Kudu debug console supports both PowerShell and Bash, and provide sample Bash commands.
- Add troubleshooting steps and tool recommendations relevant to Linux-based App Service environments.
- Ensure that instructions and screenshots do not assume a Windows-only workflow, and explicitly address cross-platform usage.
App Service
Routine Maintenance, Restarts, and Downtime
...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 by providing detailed explanations and links for Windows-specific features (such as IIS Application Initialization and .NET Core stdout logging) before mentioning Linux equivalents. Linux guidance is often limited to brief mentions (e.g., referencing WEBSITE_WARMUP_PATH) without examples or deep explanation. Windows tools and modules are referenced directly, while Linux alternatives are not described in comparable detail.
Recommendations
- Provide parallel, detailed examples for Linux throughout the documentation, especially for features like application initialization and logging.
- Include explicit Linux configuration steps and code samples (e.g., how to set WEBSITE_WARMUP_PATH, recommended logging strategies for Linux apps).
- Reference Linux-native tools and patterns (such as systemd, Nginx, or Apache warm-up strategies) where appropriate.
- Ensure that Linux guidance is presented with equal prominence and detail as Windows guidance, ideally side-by-side for direct comparison.
- Review all linked resources to ensure Linux users have access to equivalent documentation and troubleshooting guides.
App Service
Tutorial - .NET Web app accesses Microsoft Graph as the user | Azure
...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
Missing Linux Example
Summary
The documentation page demonstrates a Windows bias by presenting installation instructions for NuGet packages using Visual Studio's Package Manager Console (PowerShell) and referencing Visual Studio tooling before mentioning the cross-platform .NET CLI. There are no explicit Linux or macOS instructions, nor are Linux-specific tools or patterns discussed. The focus on Visual Studio and PowerShell may disadvantage developers using Linux environments.
Recommendations
- Add explicit instructions for installing NuGet packages on Linux/macOS, such as using the .NET CLI in Bash or zsh.
- Present the .NET CLI example before the Visual Studio/PowerShell example to emphasize cross-platform parity.
- Mention alternative editors (e.g., VS Code) and command-line usage for non-Windows platforms.
- Clarify that all code and configuration steps are platform-agnostic unless otherwise noted.
- Include troubleshooting notes or links for common Linux/macOS issues (e.g., file permissions, environment variables).
High Priority
View Details →
Detected Bias Types
Windows First
Missing Linux Example
Windows Tools
Summary
The documentation page displays a Windows bias by presenting Windows-specific logging features (web server logging, detailed error messages, failed request tracing) exclusively or with more detail than Linux equivalents. Windows instructions and features are listed first and in greater depth, while Linux logging is covered briefly and lacks parity in examples and tooling. References to Windows-only tools (e.g., Log Parser, W3C log format) are present, and several logging features are unavailable or undocumented for Linux. There are missing Linux-specific examples and guidance for equivalent troubleshooting and log access patterns.
Recommendations
- Provide Linux-specific examples and instructions for all logging types, including web server logging, error messages, and failed request tracing, or explicitly state their availability or alternatives.
- Ensure Linux and container logging features are described with equal detail, including log formats, access patterns, and retention policies.
- List Linux instructions and features alongside or before Windows equivalents to avoid 'Windows-first' ordering.
- Reference Linux-compatible tools for log analysis and access (e.g., grep, less, jq, custom scripts) and document how to use them with App Service logs.
- Clearly indicate any feature gaps between Windows and Linux, and suggest workarounds or alternative approaches for Linux users.
- Expand code examples to include Linux-friendly frameworks and logging libraries (e.g., Python logging, Node.js Winston, etc.), not just .NET/ASP.NET.
App Service
Troubleshoot Performance Degradation
...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 exhibits a Windows bias by predominantly referencing Windows-specific tools and patterns, such as PowerShell, IIS diagnostics, and SysInternals Procdump. Examples and links are focused on Windows environments, with little to no mention of Linux equivalents or cross-platform alternatives. The Kudu console is described in terms of PowerShell and DOS commands, and diagnostic features like Failed Request Tracing and .NET Profiler are discussed only in the context of Windows. There are no Linux-specific troubleshooting examples, nor are Linux-native tools or commands referenced.
Recommendations
- Include Linux-specific troubleshooting steps and examples, such as using SSH, Bash, or Linux-native diagnostic tools (e.g., strace, lsof, top, journalctl).
- When mentioning PowerShell or DOS commands, also provide Bash or shell command equivalents for Linux-based App Service environments.
- Reference Linux-compatible diagnostic extensions and tools, such as Application Insights SDKs for non-.NET stacks, and clarify which features are available on Linux.
- Add links to documentation for Linux App Service diagnostics, including enabling and accessing logs, collecting dumps, and using the Kudu console with Bash.
- Clarify which features (e.g., Failed Request Tracing, .NET Profiler) are Windows-only, and suggest Linux alternatives or workarounds where possible.
- Ensure that examples and screenshots reflect both Windows and Linux environments to provide parity for all users.
App Service
Tutorial: Connect a web app to SQL Database on behalf of the user
...utorial-connect-app-access-sql-database-as-user-dotnet.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 tools (SQL Server Management Studio, Integrated Windows authentication), providing examples and instructions that assume Windows environments (e.g., Visual Studio, SSMS), and omitting equivalent Linux tooling or workflows. Linux alternatives for database management, publishing, and local debugging are not mentioned, and Windows-centric terminology and links appear before or instead of cross-platform options.
Recommendations
- Add explicit instructions and examples for Linux users, including using Azure Data Studio, sqlcmd on Linux, and cross-platform editors like VS Code.
- Mention Linux-compatible publishing workflows, such as deploying via Azure CLI, GitHub Actions, or VS Code on Linux.
- Provide guidance for local debugging on Linux, including how to obtain and use access tokens, and alternatives to App Service authentication middleware.
- Reference cross-platform tools before or alongside Windows-only tools (e.g., list Azure Data Studio and sqlcmd before SSMS).
- Clarify that the tutorial is applicable to both Windows and Linux environments, and highlight any platform-specific steps.
App Service
Develop and deploy WebJobs using Visual Studio
.../main/articles/app-service/webjobs-dotnet-deploy-vs.md
High Priority
View Details →
Detected Bias Types
Windows First
Missing Linux Example
Windows Tools
Summary
The documentation page is heavily focused on Windows development workflows, specifically using Visual Studio. All examples, instructions, and screenshots are based on Visual Studio, a Windows-centric IDE. There is no mention of Linux development environments, alternative tools, or cross-platform command-line workflows. The documentation assumes the user is on Windows, omitting Linux or macOS equivalents for project creation, deployment, and configuration.
Recommendations
- Add instructions and examples for developing and deploying WebJobs using cross-platform tools such as VS Code, the Azure CLI, or GitHub Actions.
- Include Linux/macOS equivalents for project setup, file management, and deployment, such as using dotnet CLI commands and zip deployment.
- Provide screenshots or terminal examples for non-Windows environments.
- Clarify which steps are Windows-specific and offer alternatives for Linux users.
- Reference documentation for deploying WebJobs from Linux or macOS, and highlight any platform limitations or differences.
App Service
Tutorial: Access Azure databases with managed identity
...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 page demonstrates a moderate Windows bias. In the 'Set up your dev environment' section, Visual Studio for Windows is presented first and in more detail, while Visual Studio for Mac is described as lacking integration and requiring a workaround. Windows-specific tools (Visual Studio, Azure PowerShell) are mentioned before or more prominently than their Linux/macOS equivalents. Azure PowerShell is included as a development option, but no mention is made of Linux-native shells or tools (e.g., Bash, zsh), and the CLI instructions are generic, not tailored to Linux/macOS environments. There are no explicit Linux or macOS code samples or tool recommendations beyond the Azure CLI and Visual Studio Code.
Recommendations
- Add explicit Linux and macOS development environment setup instructions, including shell-specific guidance (e.g., Bash, zsh).
- Provide parity in tool recommendations, such as highlighting JetBrains Rider or other cross-platform IDEs alongside Visual Studio.
- Include example workflows for Linux users, such as using Azure CLI in Bash, and clarify that all CLI commands work on Linux/macOS.
- Present development environment options in a neutral order (e.g., alphabetical or grouped by platform), rather than leading with Windows.
- Add troubleshooting notes or FAQs relevant to Linux/macOS users, such as common permission or environment issues.
App Service
Tutorial: Build and Run a Custom Image in Azure App Service
...main/articles/app-service/tutorial-custom-container.md
High Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Powershell Heavy
Missing Linux Example
Summary
The documentation exhibits Windows bias in several ways. The Windows container tutorial is presented first, with detailed steps using Visual Studio, Windows Explorer, and PowerShell scripts (InstallFont.ps1). The prerequisites and workflow are heavily oriented toward Windows tools, and there are no equivalent Linux examples for scenarios such as installing fonts or using non-Windows development environments. The Linux section is more generic, focusing on Docker and Azure CLI, and does not provide parity for OS-level customization or desktop tooling. There is also a lack of cross-referencing or guidance for users who may want to perform similar customizations on Linux containers.
Recommendations
- Provide Linux-first or parallel examples for custom OS-level integrations, such as installing fonts or other system packages in Linux containers.
- Include Linux development environment instructions (e.g., using VS Code, Linux file managers, Bash scripts) alongside Windows/Visual Studio steps.
- Offer PowerShell alternatives for Linux (e.g., Bash scripts) and reference them in the relevant sections.
- Ensure that prerequisite lists and setup instructions cover both Windows and Linux platforms equally, including Docker Desktop for Linux and common Linux distributions.
- Add guidance for customizing Linux containers beyond basic Dockerfile edits, such as installing system packages, configuring environment variables, and troubleshooting OS-level integration issues.
- Balance screenshots and walkthroughs between Windows and Linux environments to help users on both platforms.
App Service
Build a scheduled WebJob using your preferred language
...ocs/blob/main/articles/app-service/tutorial-webjobs.md
High Priority
View Details →
Detected Bias Types
Windows First
Windows Tools
Windowscode Tabs
Powershell Heavy
Missing Linux Example
Summary
The documentation demonstrates a Windows bias, especially in the .NET section. Windows build and packaging instructions are presented first, with Linux equivalents following. References to 'windowscode' tabs and links are prevalent throughout, even in sections for other languages and platforms. The supported file types and CRON expression documentation are linked with '?tabs=windowscode', which may not be fully accurate for Linux users. There is a lack of parity in scripting and packaging examples for Linux in some pivots, and Windows-specific tools and patterns (e.g., win-x64, .exe) are emphasized.
Recommendations
- Present Linux and Windows instructions side-by-side or in parallel, rather than Windows first.
- Use neutral tab names (e.g., 'platform', 'os') instead of 'windowscode' for links and references.
- Ensure all language pivots provide explicit Linux instructions, including packaging and execution scripts.
- Include references to Linux tools (e.g., bash, zip, shell scripts) wherever Windows tools (e.g., PowerShell, .exe) are mentioned.
- Clarify differences in file types, execution, and deployment between Windows and Linux environments.
- Review and update links to documentation sections to use platform-appropriate tabs (e.g., '?tabs=linuxcode' where relevant).