Study guide
13.3 Azure DevOps Projects, Teams & Permission Evaluation
Microsoft Certified: Azure DevOps Engineer Expert AZ-400
Track your progress as you read
Finished sections get a check mark.
1 Chapter 1: Flow of Work, Traceability & Work Tracking
1.1 Flow of Work, GitHub Flow & Feedback Cycles 1.2 Work Tracking with Azure Boards & GitHub Projects 1.3 End-to-End DevOps Traceability & Quality Tracking
2 Chapter 2: DevOps Metrics, Dashboards & Team Collaboration
2.1 DORA Metrics, Flow Metrics & Dashboard Design 2.2 Lifecycle Metrics Across the Six DevOps Phases 2.3 Work Item Queries, WIQL Charts & Analytics 2.4 Project Documentation: Wikis, Mermaid Diagrams & Release Notes 2.5 Webhooks, Service Hooks & Microsoft Teams ChatOps
3 Chapter 3: Git Branching Strategies & Pull Request Workflows
3.1 Git Branching Models & Strategy Design 3.2 Pull Request Workflows & Merge Strategies 3.3 Branch Policies, Quality Gates & Compliance Restrictions
4 Chapter 4: Repository Management, Optimization & Git Data Operations
4.1 Git LFS Architecture & .gitattributes Tracking 4.2 LFS History Migration, git-fat & File Locking 4.3 Git Repository Scaling, Scalar & Monorepo Governance 4.4 Repository Permissions & Git Tag Governance 4.5 Git Data Recovery & Sensitive-Data Scrubbing
5 Chapter 5: Package Management & Dependency Versioning
5.1 Selecting Package Tools: Azure Artifacts vs. GitHub Packages 5.2 Feed Scoping, Upstream Sources & Pipeline Authentication 5.3 Package Views, Immutability & Quality Promotion 5.4 Dependency Versioning: SemVer, CalVer & Automated Versioning 5.5 Pipeline Artifact Versioning & Artifact Storage Strategy
6 Chapter 6: Pipeline Infrastructure, Agents & Integration
6.1 Selecting a CI/CD Solution: Azure Pipelines vs. GitHub Actions 6.2 GitHub-Azure Pipelines Integration & Hybrid Migration 6.3 Hosted vs. Self-Hosted Agents & Runners 6.4 VMSS Elastic Pools, Container Jobs & Agent Governance 6.5 Pipeline Triggers, Filters & Concurrency Management
7 Chapter 7: YAML Pipeline Architecture & Reusable Elements
7.1 YAML Pipeline Anatomy: Stages, Jobs, Steps & Workspaces 7.2 Job Execution Order: DAG Dependencies, Parallelism & Conditions 7.3 Reusable Elements: Templates, Parameters & Variables 7.4 Variable Groups, Secret Variables & Key Vault Linking 7.5 YAML Environments, Checks & Deployment Approvals
8 Chapter 8: Testing Strategy, Quality Gates & Code Coverage
8.1 Test Strategy Design: Local, Unit & Integration Testing 8.2 Load, Stress & Performance Testing in Pipelines 8.3 Test Execution Tasks, Agents & Results Integration 8.4 Code Coverage Analysis & SonarQube Integration 8.5 Quality Gates, Release Gates & Governance Checks
9 Chapter 9: Modern Deployment Strategies & Zero-Downtime Delivery
9.1 Progressive Delivery: Blue-Green, Canary & Ring Deployments 9.2 Minimizing Downtime: Deployment Slots & Rolling Updates 9.3 Feature Flags with Azure App Configuration & Feature Manager 9.4 Designing the High-Priority Hotfix Path 9.5 Ordered Dependency Deployments, Resiliency & Rollback
10 Chapter 10: Artifact Deployment & Database DevOps
10.1 Containerized Application Delivery: ACR, AKS & Container Apps 10.2 Binary, Web App, Function & Scripted Deployments 10.3 Database DevOps: State-Based & Migration-Based Strategies
11 Chapter 11: Infrastructure as Code (IaC) & Azure Deployment Environments
11.1 Infrastructure as Code Strategy: Bicep, ARM & Terraform 11.2 Desired State Configuration & Azure Machine Configuration 11.3 Azure Deployment Environments (ADE) & Developer Self-Service
12 Chapter 12: Pipeline Maintenance, Health & Modernization
12.1 Pipeline Health, Flaky Tests & Reliability Engineering 12.2 Pipeline Optimization: Caching, Slicing & Concurrency 12.3 Artifact & Build Retention Governance 12.4 Modernizing CI/CD: Classic to YAML Migration
13 Chapter 13: Authentication, Authorization & Identity Governance
13.1 Microsoft Entra Service Principals & Managed Identities 13.2 Service Connections, Workload Identity & Personal Access Tokens 13.3 Azure DevOps Projects, Teams & Permission Evaluation 13.4 Access Levels, GitHub Roles & Outside Collaborators
14 Chapter 14: Secrets Management, Sensitive Data & DevSecOps Scanning
14.1 Azure Key Vault, Secret Variables & Secretless CI/CD 14.2 Security Scanning Strategy, GHAS & Secret Scanning 14.3 CodeQL SAST in Pipelines and Containers 14.4 Software Supply Chain, Container Scanning & Cloud Defender
15 Chapter 15: Telemetry Collection, Azure Monitor & Alerting
15.1 Azure Monitor Architecture, AMA & Data Collection Rules 15.2 Application Insights & Specialized Azure Monitor Insights 15.3 Alerting Rules, Action Groups & GitHub Repository Insights
16 Chapter 16: Telemetry Analysis, Distributed Tracing & SRE Practices
16.1 Distributed Tracing, Application Map & Exception Triage 16.2 KQL Log Analytics, SRE Observability & Error Budgets
13.3 Azure DevOps Projects, Teams & Permission Evaluation
Key Takeaways Explain This Topic AI
Permissions are evaluated across organisation, project and object scopes, and each entry is Allow, Deny or Not set (inherited).
An explicit Deny overrides an Allow from any other group at any level; only Project Collection Administrators membership can override a Deny.
A project owns its process, repositories, pipelines, feeds and security groups, so prefer one project with many teams unless you need genuine isolation.
Each team is backed by a security group and needs its area paths, iterations, working days and backlog levels configured before its board is usable.
Overlapping area paths between two teams double-count the same work item on both boards and corrupt velocity for both.
Last updated: September 2026
13.3 Azure DevOps Projects, Teams & Permission Evaluation
Effective enterprise DevOps governance requires maintaining the balance between engineering velocity and strict security control. In organizations with hundreds of engineers, external contractors, and automated pipelines, poorly structured permissions lead to unauthorized code modifications, accidental branch deletions, unvetted pipeline executions, and compliance failures.
For the AZ-400 exam, candidates must master the hierarchical security models of both Azure DevOps and GitHub Enterprise . This includes understanding built-in security groups, permission inheritance mechanics, explicit Deny evaluation logic, licensing Access Levels , and GitHub repository roles.
1. Azure DevOps Hierarchical Security Planes
Azure DevOps organizes security boundaries into three hierarchical planes: ┌─────────────────────────────────────────────────────────────────────────────┐
- │ 1. Organization Level (Project Collection) │
- │ • Project Collection Administrators (PCA) │
- │ • Global Policies, Auditing, Extension Installs, Billing, Org Licensing │
- └──────────────────────────────────────┬──────────────────────────────────────┘
- │ Governs
- ▼
- ┌─────────────────────────────────────────────────────────────────────────────┐
- │ 2. Project Level │
- │ • Project Administrators, Project Contributors, Project Readers │
- │ • Project Settings, Teams, Area/Iteration Paths, Service Connections │
- └──────────────────────────────────────┬──────────────────────────────────────┘
- │ Governs
- ▼
- ┌─────────────────────────────────────────────────────────────────────────────┐
- │ 3. Object Level (Individual Artifacts) │
- │ • Specific Git Repositories (Bypass policies, Force push, Manage branch) │
- │ • Specific Pipelines (Edit build pipeline, Queue builds, Delete) │
- │ • Specific Service Connections (Use, Administer) │
- │ • Specific Agent Pools and Variable Groups │
- └─────────────────────────────────────────────────────────────────────────────┘
- Built-In Security Groups & Default Roles
Azure DevOps provisions standard built-in security groups with pre-configured permission sets:
Project Collection Administrators (PCA) : The highest administrative authority in an organization. PCAs can perform all actions across all projects, modify organization settings, configure billing, manage auditing, and install extensions from the Visual Studio Marketplace.
Project Administrators : Full administrative control within a single project. Can create and delete teams, configure area and iteration paths, manage project-level permissions, and adjust service connections.
Project Contributors : The standard security group for software developers. Members can add, modify, and delete source code in Azure Repos, create and complete pull requests, queue builds, create and edit work items, and manage release definitions.
Project Readers : Read-only access to the project. Members can view code, pipelines, and work items, but cannot commit changes, queue builds, or alter settings.
Build Administrators / Release Administrators : Specialized groups with administrative authority over CI/CD pipelines, retention policies, and deployment environments without granting full Project Administrator privileges.
2. Permission Evaluation Mechanics: The Golden Rules
Understanding how Azure DevOps evaluates effective permissions is one of the most frequently tested concepts on the AZ-400 exam. [Permission Check Requested]
- │
- ▼
- Is there an explicit DENY on the user
or ANY group the user belongs to?
- / \
- YES NO
- / \
- ▼ ▼
- [ACCESS DENIED] Is there an explicit ALLOW on the user
(DENY ALWAYS WINS) or ANY group the user belongs to?
- / \
- YES NO
- / \
- ▼ ▼
- [ACCESS GRANTED] [INHERIT / NOT SET]
Evaluates parent scope.
If parent is NOT SET:
- EFFECTIVE DENY
- The Three Permission States
Allow : The user or group is explicitly granted permission to execute the action.
Deny : The user or group is explicitly blocked from executing the action.
Not Set (Inherited) : No explicit decision has been made at this level. The permission inherits its value from the parent container (e.g., from Organization down to Project, or Project down to Repository).
Core Evaluation Principles
Principle 1: Explicit Deny Always Wins : If a user is a member of two groups—one granting Allow and another granting Deny for the exact same permission—the effective permission is always Deny . An explicit Deny cannot be overridden by an Allow.
Principle 2: Direct Assignment Does Not Override Group Deny : If a user account is directly granted Allow on an object, but belongs to a security group that has Deny on that same object, the user is Deny . Deny is absolute.
Principle 3: "Not Set" Defaults to Deny : If an inherited permission resolves to "Not Set" all the way to the root level, the effective permission evaluated by the system is Deny .
Principle 4: Explicit Allow Beats Inherited Deny : If a permission is denied at the Project level through inheritance, an explicit Allow configured directly on a child object (such as a specific Git repository) will successfully grant access for that child object.
3. Configuring Azure DevOps Projects and Teams
Project and team structure is the container every other permission decision sits inside, so the blueprint asks you to configure it deliberately.
Choosing a project boundary. A project is the strongest isolation unit in Azure DevOps: it owns its own work item process, repositories, pipelines, feeds and security groups. Prefer one project with many teams when groups share a backlog, need cross-team queries, or want a single set of build agents and feeds. Split into multiple projects only when you need a genuinely separate process template, hard data isolation for a regulated or externally-staffed workstream, or a different administrative owner. Splitting is easy; merging later is not.
Process model. Each project is created from a process — Basic , Agile , Scrum or CMMI — and the process determines the work item types, states and fields. Inherited processes let you add fields, states, rules and custom work item types without XML; changing a project's process afterwards is possible between inherited processes but re-maps states, so decide before the backlog fills.
Creating and scoping a team. Every project starts with one default team. Each additional team gets its own backlog, board, sprint cadence and dashboards, and is backed by a security group of the same name. az devops project create --name Payments --process Agile --source-control git --visibility private --organization "$ORG"
az devops team create --name "Payments-Core" --project Payments --organization "$ORG"
Wiring the team to work. A team is only useful once its Team Configuration is set:
- Setting Effect
- Default area path New work items created by the team land in the team's area automatically
- Areas the team owns Determines which items appear on the team's backlog and board
- Iterations selected Only selected sprints appear in the team's sprint planning views
- Working days and capacity Drives burndown and capacity planning
- Backlog levels shown Whether the team plans at Epic, Feature or Story level
The most common misconfiguration is adding a team without selecting its iterations: the board renders, but sprint planning is empty and the burndown never draws. The second is overlapping area paths between two teams, which double-counts the same work item on both boards and corrupts velocity for both.