Study guide
2.5 Webhooks, Service Hooks & Microsoft Teams ChatOps
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
2.5 Webhooks, Service Hooks & Microsoft Teams ChatOps
Key Takeaways Explain This Topic AI
Service hooks are event-driven outbound HTTP POSTs configured per project; they fire on events such as build completed, release deployment approval pending and pull request merge attempted.
GitHub signs webhook deliveries with X-Hub-Signature-256 over the raw request body, while Azure DevOps service hooks are unsigned and must be protected with Basic authentication or a secret URL plus IP allowlisting.
The Azure Boards and Azure Pipelines apps for Microsoft Teams authenticate as the individual who signed in, so the feed breaks when that person leaves.
Approvals actioned from a Teams card still enforce the underlying Azure DevOps environment approval permissions.
Use a GitHub App installation rather than OAuth or a personal access token for the Azure Boards to GitHub connection so AB# work item linking survives personnel changes.
Last updated: September 2026
2.5 Webhooks, Service Hooks & Microsoft Teams ChatOps
Documentation tells people what the system does; event-driven integration tells them what it just did. Azure DevOps service hooks and GitHub webhooks push lifecycle events to external consumers, and the Microsoft Teams apps turn those events into approvals and notifications engineers can act on without leaving chat.
Service Hooks, Webhooks & Event-Driven Collaboration
Service Hooks allow external services (such as Microsoft Teams, Slack, Azure Functions, or custom HTTP endpoints) to subscribe to events in Azure DevOps. +--------------------+ +-----------------------+ +---------------------+
- | AZURE DEVOPS | Event | AZURE DEVOPS | JSON | EXTERNAL CONSUMER |
- | PUBLISHER | ------> | SERVICE HOOK | ------> | (Teams / Webhook) |
- | (Pipelines/Boards) | | (Generates HMAC Token)| | (Validates Digest) |
- +--------------------+ +-----------------------+ +---------------------+
- Service Hook Architecture
Publishers: Azure DevOps services that generate events ( Pipelines , Repos , Boards , Artifacts ).
Event Triggers: Specific actions that fire notifications:
git.push : Code pushed to a repository branch.
git.pullrequest.created / git.pullrequest.merged : PR lifecycle events.
build.complete : CI pipeline completed.
release.deployment.approval.pending : Release paused awaiting human approval.
workitem.created / workitem.updated : Work tracking updates.
Consumers: Target endpoints that consume event payloads ( Microsoft Teams , Slack , Azure Service Bus , Azure Functions , Webhooks ).
Webhook Payloads and HMAC Signature Verification
When using generic Webhooks as the consumer, Azure DevOps sends an HTTP POST request containing a JSON payload. To prevent man-in-the-middle tampering, unauthorized payload injection, and replay attacks, Azure DevOps allows configuring a Secret Token .
Azure DevOps computes a Hash-based Message Authentication Code (HMAC) using SHA-1 or SHA-256 over the raw JSON payload with the shared secret token.
Azure DevOps places this signature in the HTTP request header (e.g., X-Hub-Signature ).
The receiving external endpoint calculates its own HMAC digest over the incoming raw request body using the pre-shared secret.
If the computed digest matches the header signature, the payload is authentic and unaltered. If they mismatch, the receiving endpoint rejects the request with HTTP 401/403.
Microsoft Teams ChatOps for Azure DevOps
Microsoft Teams provides two first-party integrated apps for Azure DevOps ChatOps:
1. Azure Boards App for Microsoft Teams
Channel Commands: Run slash commands directly in Teams channels:
@azure boards link [project-url] : Connects the Teams channel to an Azure Boards project.
@azure boards create : Launches an interactive modal card in Teams to create new User Stories, Bugs, or Tasks.
@azure boards query [query-name] : Executes a shared flat query and posts the results into the conversation.
Interactive Work Item Cards: Displays rich Adaptive Cards when work item URLs are pasted. Users can update status, change assignees, and add discussion comments directly from Teams.
2. Azure Pipelines App for Microsoft Teams
Channel Commands:
@azure pipelines subscribe [pipeline-url] : Subscribes the channel to pipeline build and deployment notifications.
@azure pipelines subscriptions : Displays active subscriptions with options to add branch or stage filters (e.g., filter notifications strictly to stageName = 'Production' ).
Interactive Deployment Approvals: When a YAML pipeline deployment reaches an Environment with Approval Checks , the Azure Pipelines Teams app posts an interactive Adaptive Card into the channel.
Seamless Approval Gate: Designated approvers can review the commit hash, pipeline run details, and release notes, and click Approve or Reject with optional comments directly inside Microsoft Teams. Azure Pipelines immediately resumes the deployment stage upon receiving the authenticated approval webhook.
Service Hook Triggers and Actions Reference Table
Event Trigger Event Source Typical Filter Target Consumer Primary Use Case
build.complete Azure Pipelines Pipeline Name, Build Result (Failed) Microsoft Teams / Slack Instant engineering alert on broken CI builds
release.deployment.approval.pending Azure Pipelines Environment Name (Production) Teams (Actionable Card) Interactive mobile/desktop release approvals
git.pullrequest.created Azure Repos Target Branch ( refs/heads/main ) Slack / Teams Channel Peer review awareness and prompt turnaround
workitem.updated Azure Boards Field Changed ( State = Blocked ) Custom Webhook / Logic App Escalation alert to engineering leads
git.push Azure Repos Branch ( refs/heads/main ) External Webhook (HMAC) Triggers third-party compliance audits or mirror repos
Webhook Security and Connection Governance
Webhook endpoints are unauthenticated HTTP listeners by default, so the exam expects three controls on every custom integration:
Signature verification. GitHub signs each delivery with X-Hub-Signature-256 , an HMAC-SHA256 of the raw body using the webhook secret. Compute the digest over the raw payload bytes before any JSON parsing, and compare with a constant-time function. Azure DevOps service hooks do not sign payloads, so protect those consumers with a Basic-auth header or a hard-to-guess URL path plus an IP allowlist.
Replay protection. Persist the delivery GUID ( X-GitHub-Delivery ) and reject repeats. Service hooks retry on non-2xx responses, so a slow consumer that returns 500 will legitimately receive the same event several times.
Least-privilege consumers. A webhook receiver that opens work items needs only the Azure Boards scope; do not reuse an organization-wide PAT.
Connection governance differs between the two Teams apps and the Boards-GitHub link:
Integration Authenticates as Governance note
Azure Boards app for Teams The user who ran @Azure Boards signin Personal OAuth grant; the channel loses the feed when that user leaves
Azure Pipelines app for Teams The user who subscribed the channel Approvals actioned in Teams still honour Azure DevOps environment permissions
Azure Boards <-> GitHub connection A GitHub App installation (preferred) or OAuth/PAT One connection per Azure DevOps project; the GitHub App survives personnel changes
Prefer the GitHub App installation for the Boards-GitHub connection: OAuth and PAT connections inherit a single human identity and break the AB# mention linking the moment that account is disabled.
AZ-400 Exam Pitfalls & Traps
Selecting Project Wiki When Versioning is Required:
Exam Trap: An exam question requires documentation that must branch alongside source code for versioned microservice releases.
Answer: Never select Project Wiki. You must select Publish Code as Wiki pointing to the repository's documentation directory.
Relying Exclusively on Client-Side Git Hooks for Commit Governance:
Exam Trap: Implementing Husky commit-msg hooks to enforce enterprise commit message standards.
Answer: Client-side hooks alone fail compliance audits because any developer can run git commit --no-verify . Enterprise enforcement requires Azure Repos PR status checks and build validation policies .
Ignoring Webhook Payload Authentication:
Exam Trap: Validating incoming Azure DevOps webhook payloads by checking the User-Agent header or basic IP allowlisting.
Answer: User-agent headers are easily spoofed. The cryptographically secure approach is HMAC signature verification using a pre-shared secret token .