Learning path
Microsoft Azure learning path: everything to study, topic by topic
Assesses Microsoft Azure readiness across the certification family (AZ-900, AZ-104, AZ-204, AZ-305, AZ-400, AZ-500, AZ-800, SC-900, DP-900, DP-203, DP-100, AI-900, AI-102): cloud fundamentals, identity, compute, networking, storage and data, security, governance and monitoring, DevOps and Bicep, hybrid Windows Server, and Azure AI services.
Short answer
To learn Microsoft Azure, work through 10 modules and 165 topics in the order they build on each other. It starts with Cloud & Azure Fundamentals, then moves on to Identity & Access and Compute. Use the map as a checklist, or measure your level and study only what is missing.
What you will study
Topics are grouped by module. Open one to see its objectives and key concepts.
1 · Cloud & Azure Fundamentals5 topics
Cloud Computing Concepts
Cloud computing characteristics, public/private/hybrid deployment models, IaaS/PaaS/SaaS, serverless, the shared responsibility model, CapEx versus OpEx, consumption-based pricing and the benefits of the cloud (elasticity, scalability, reliability, predictability, security, governance and manageability)
Objectives
- Classify a workload as IaaS, PaaS, SaaS or serverless and name who manages each layer
- Explain the financial and operational benefits of cloud adoption over on-premises
- Choose a deployment model for a given compliance or latency requirement
Key concepts
- IaaS vs PaaS vs SaaS
- shared responsibility model
- CapEx vs OpEx
- elasticity and scalability
- high availability and fault tolerance
- public, private and hybrid cloud
Azure Architecture & Resource Hierarchy
Regions, region pairs, availability zones, sovereign regions, the management group, subscription, resource group and resource hierarchy, Azure Resource Manager, and the portal, Cloud Shell, CLI, PowerShell, Azure Arc and Advisor tools
Objectives
- Describe the Azure resource hierarchy and where policies and access are inherited
- Explain how regions, region pairs and availability zones deliver resilience
- Select the right management tool (portal, CLI, PowerShell, Arc) for a task
Key concepts
- regions and region pairs
- availability zones
- management groups and subscriptions
- resource groups
- Azure Resource Manager
- Azure CLI, PowerShell and Cloud Shell
Azure Support Plans, SLAs & Service Lifecycle
Azure support plans (Basic, Developer, Standard, Professional Direct, Premier/Unified) and what each includes, opening support requests and quota or subscription limit increases from Help + support, service level agreements and the composite SLA and uptime percentage calculation, SLA service credits, and the preview (private and public) versus generally available service lifecycle, including that preview services carry no SLA
Objectives
- Choose the Azure support plan that matches response-time, phone support and cost requirements
- Calculate availability from SLA percentages and explain when service credits apply
- Explain what preview and general availability mean for support, SLA and production use
Key concepts
- support plan tiers
- support request and quota increase
- SLA uptime percentage
- composite SLA
- SLA service credits
- private and public preview vs general availability
Azure Pricing, Free Account & Cost Factors
Azure free account (credit, 12-month and always-free services, what happens when credit or the trial ends), subscription offer types and account types, factors that affect cost (resource type, region, VM size and operating system, usage, bandwidth and inbound versus outbound data transfer, egress between regions), billing for stopped (deallocated) VMs, free Entra ID versus paid public IPs, Azure Hybrid Benefit, and the Pricing Calculator and TCO Calculator
Objectives
- Predict which actions on a free or pay-as-you-go subscription generate charges
- Name the factors that change the price of a VM, storage or network resource
- Select the Pricing Calculator, TCO Calculator or Azure Hybrid Benefit for a cost question
Key concepts
- free account credit and always-free services
- subscription offer and account types
- regional price variation
- VM size and operating system pricing
- bandwidth and egress charges
- billing of deallocated VMs
Azure Management Tools: Portal, Cloud Shell, CLI & PowerShell
The Azure portal (blades, dashboards, URL and browser access from any device), Azure Cloud Shell with Bash or PowerShell, Azure CLI and Azure PowerShell installed on Windows, macOS and Linux, Azure mobile app, selecting the right management tool for a platform or automation need, and listing and managing resources with commands and cmdlets
Objectives
- Select the Azure management tool that fits a platform, device or automation requirement
- Explain what Cloud Shell provides without local installation
- Describe which operating systems support the CLI and PowerShell
Key concepts
- Azure portal and blades
- Cloud Shell Bash and PowerShell
- Azure CLI on Windows, macOS and Linux
- Azure PowerShell cmdlets
- portal access from any device
- choosing a management tool
2 · Identity & Access9 topics
Microsoft Entra ID: Users, Groups & External Identities
Microsoft Entra tenants, users and groups (assigned and dynamic), bulk operations, license assignment, administrative units, device identity (joined, hybrid joined, registered), guest users with B2B collaboration, External ID, self-service password reset and the identity types in Entra
Objectives
- Create and manage users, groups and licenses including bulk and dynamic membership
- Invite external users with B2B collaboration and govern their access
- Differentiate Entra joined, hybrid joined and registered devices
Key concepts
- tenants and directories
- dynamic groups
- license assignment
- B2B guest users and External ID
- device join states
- administrative units
Authentication, Conditional Access & Identity Governance
Entra authentication methods (passwordless, FIDO2, Authenticator, SSPR), multifactor authentication, Conditional Access policies and signals, Identity Protection risk policies, Privileged Identity Management, access reviews, entitlement management and Zero Trust-based access design
Objectives
- Design a Conditional Access policy set for users, devices and risk levels
- Use PIM to deliver just-in-time privileged access with approval and expiry
- Choose governance features (access reviews, entitlement management) to control access over time
Key concepts
- MFA and passwordless
- Conditional Access signals and grant controls
- Identity Protection user and sign-in risk
- Privileged Identity Management
- access reviews
- entitlement management
Azure RBAC & Access to Resources
Azure role-based access control: built-in and custom roles, scopes and inheritance, role assignments, deny assignments, the difference between Entra roles and Azure roles, access conditions, and troubleshooting effective access
Objectives
- Assign the least-privileged built-in role at the right scope
- Author a custom role definition for a specific need
- Troubleshoot why a user can or cannot perform an operation
Key concepts
- roles, scope and assignment
- Owner vs Contributor vs Reader
- custom roles
- Entra roles vs Azure roles
- User Access Administrator
- deny assignments
Application Identity: App Registrations & Managed Identities
App registrations and enterprise applications, service principals, OAuth 2.0 and OpenID Connect flows, Microsoft identity platform and MSAL, delegated versus application permissions, admin consent, Microsoft Graph, managed identities (system- and user-assigned) and workload identities
Objectives
- Register an application and choose the correct authentication flow
- Replace secrets with managed identities to access Azure resources
- Request and consent to Microsoft Graph permissions with least privilege
Key concepts
- app registration vs service principal
- OAuth 2.0 and OIDC flows
- MSAL
- delegated vs application permissions
- admin consent
- managed identities
Entra Password Protection, SSPR & Security Defaults
Microsoft Entra Password Protection (global and custom banned password lists, on-premises agent deployment with the proxy service and DC agent placement), self-service password reset methods, security questions and password writeback, security defaults and what they enforce, Entra ID license editions, and password policy administration in Microsoft Entra Domain Services
Objectives
- Deploy Entra Password Protection for on-premises Active Directory
- Configure SSPR with the required methods and password writeback for hybrid users
- Decide when security defaults are enough and when Conditional Access is needed
Key concepts
- custom banned password list
- Password Protection DC agent and proxy
- SSPR methods and security questions
- password writeback
- security defaults
- Entra ID Free, P1 and P2 editions
Microsoft Entra Connect: Sync, Sign-in Methods & Cloud Sync
Microsoft Entra Connect sync and its sign-in methods (password hash synchronization, pass-through authentication, federation), seamless single sign-on, domain and OU filtering of the sync scope, Entra Connect cloud sync agents and provisioning, IdFix remediation of directory errors, sync health monitoring, and user lifecycle automation with Microsoft Identity Manager
Objectives
- Choose a hybrid sign-in method for security, availability and on-premises dependency requirements
- Scope synchronization with OU and attribute filtering
- Monitor sync health and remediate directory errors before synchronizing
Key concepts
- password hash sync vs pass-through vs federation
- seamless SSO
- OU and domain filtering
- Entra Connect cloud sync
- IdFix directory remediation
- Connect Health monitoring
Enterprise Apps, SSO, Application Proxy & External Access
Enterprise application assignment and self-service access, single sign-on methods (SAML, OIDC, password-based, linked) for apps lacking identity provider support, Entra Application Proxy with Kerberos constrained delegation for on-premises apps, Microsoft Entra Domain Services for LDAP and Kerberos workloads, group naming policy, granting API permissions, external tenant access with B2B, Conditional Access scope and Entra role assignment
Objectives
- Publish an on-premises or SaaS application with the right SSO method
- Provide LDAP or Kerberos authentication to legacy workloads without domain controllers on premises
- Control who can request, be assigned and consent to enterprise applications
Key concepts
- enterprise app assignment
- SSO methods SAML and password-based
- Application Proxy and Kerberos SSO
- Entra Domain Services LDAP
- granting API permissions
- B2B access for external tenants
Identity Design: Managed Identity Tokens, PIM & Conditional Access
Designing application identity: system-assigned managed identities with Key Vault access, acquiring tokens from the instance metadata service (IMDS) and OAuth 2.0 endpoints, Privileged Identity Management for just-in-time access, access reviews as identity governance, and Conditional Access to restrict access to corporate devices
Objectives
- Choose managed identities over secrets to minimize administrative effort
- Describe how a workload obtains a token through IMDS to reach Key Vault
- Combine PIM, reviews and Conditional Access into a least-privilege design
Key concepts
- system-assigned managed identity
- IMDS token acquisition
- OAuth 2.0 token request
- Privileged Identity Management
- access reviews
- device-based Conditional Access
Microsoft Graph for Developers: Advanced Queries, Paging, Batching & Change Notifications
Advanced query capabilities on directory objects (ConsistencyLevel: eventual with $count, $search and complex $filter), following @odata.nextLink for paging and delta queries, JSON batching with POST /$batch up to 20 requests, change notification subscriptions (resource, changeType, notificationUrl, expiration and renewal, validation handshake, clientState) and handling throttling with Retry-After
Objectives
- Write Graph queries that use advanced directory filters correctly
- Page through large result sets and combine calls with batching
- Subscribe to change notifications and keep the subscription alive
Key concepts
- ConsistencyLevel eventual
- $count
- $search
- @odata.nextLink
- PageIterator
- delta query
- $batch limit of 20
- subscriptions
- expirationDateTime
- validationToken
- Retry-After
3 · Compute12 topics
Azure Virtual Machines & Scale Sets
VM sizes and series, managed disks and encryption, availability sets and zones, Virtual Machine Scale Sets and autoscale, images and extensions, resizing and moving VMs, Azure Hybrid Benefit and spot instances
Objectives
- Pick VM size, disk type and availability option for a workload
- Configure a scale set with autoscale rules
- Resize, redeploy or move a VM and understand the downtime impact
Key concepts
- VM sizes and families
- managed disk types
- availability sets vs zones
- scale sets and autoscale
- VM extensions and custom script
- Azure Disk Encryption
Azure App Service
App Service plans and pricing tiers, scaling up and out, autoscale, deployment slots and swap, custom domains and TLS certificates, networking features (VNet integration, private endpoints), app settings, backups and deployment methods
Objectives
- Choose an App Service plan tier for a feature and scale requirement
- Use deployment slots for zero-downtime releases and rollback
- Secure and network an App Service app with private access
Key concepts
- App Service plan tiers
- scale up vs scale out
- deployment slots
- custom domains and TLS
- VNet integration
- app settings and connection strings
Containers: ACI, ACR, Container Apps & AKS
Container images and registries (Azure Container Registry, tasks), Azure Container Instances, Azure Container Apps (revisions, scaling, Dapr), and Azure Kubernetes Service fundamentals for choosing the right container hosting option
Objectives
- Choose between ACI, Container Apps and AKS for a workload
- Build, store and deploy an image from Azure Container Registry
- Configure scaling and revisions in Azure Container Apps
Key concepts
- Azure Container Registry
- Azure Container Instances
- Azure Container Apps revisions and KEDA scaling
- AKS node pools
- container groups
- image build and push
Azure Functions & Serverless
Azure Functions triggers and bindings, hosting plans (Consumption, Flex Consumption, Premium, Dedicated), Durable Functions orchestrations, timeouts, scaling and cold start, configuration and Logic Apps as a low-code complement
Objectives
- Select a hosting plan based on scale, networking and cold-start needs
- Implement a function with the right trigger and output bindings
- Use Durable Functions for fan-out/fan-in or human-interaction workflows
Key concepts
- triggers and bindings
- hosting plans
- Durable Functions patterns
- cold start
- function app settings
- Logic Apps vs Functions
Azure IoT, Virtual Desktop, DevTest Labs & Bot Services
Azure IoT Hub and IoT Central for device ingestion, Azure Virtual Desktop host pools and session hosts, Microsoft Managed Desktop versus Azure Lab Services, Azure DevTest Labs VM templates, artifacts and cost policies, Azure AI Bot Service for digital assistants, and recognizing the core Azure service that fits a workload description
Objectives
- Match an IoT, virtual desktop, lab or bot requirement to the Azure service that delivers it
- Explain how DevTest Labs controls cost for dev and test environments
- Describe the role of IoT Hub in ingesting device telemetry
Key concepts
- IoT Hub device ingestion
- Azure Virtual Desktop host pools
- Managed Desktop vs Lab Services
- DevTest Labs templates and artifacts
- Azure AI Bot Service
- matching a workload to the Azure service
VM Operations: NICs, Redeploy, Images & Availability
VM network interface rules (same region and subscription as the VNet, attaching and switching), availability set fault and update domain counts, virtual machine scale sets across availability zones, redeploying a VM to a new host, generalizing a VM with sysprep and capturing an image, uploading prepared VHDs, Azure CycleCloud for HPC clusters, the on-premises data gateway, Serial Console and Application Health extension
Objectives
- Change a VM network by managing its NIC within platform constraints
- Choose availability sets, zones or scale sets for datacenter-failure resilience
- Generalize and capture a VM image and redeploy a VM after a platform issue
Key concepts
- NIC region and VNet rules
- fault and update domains
- scale sets across zones
- redeploy and generalize
- Azure CycleCloud
- on-premises data gateway
AKS & Container Operations: Networking, Ingress, Storage & Probes
AKS networking (kubenet versus Azure CNI, pod CIDR sizing, service endpoints through CNI), ingress controllers with a single IP and TLS termination, Kubernetes StorageClasses and volume provisioners, liveness and readiness probes, Microsoft Entra integration for AKS, ACR Tasks with base image triggers, secure environment variables in ACI, Dockerfile instruction ordering and Web App for Containers persistent storage and log streaming
Objectives
- Size and secure AKS networking and expose services through an ingress controller
- Configure storage classes and health probes for stateful and resilient workloads
- Automate image builds and handle secrets for containers
Key concepts
- Azure CNI vs kubenet and CIDR
- ingress controller with TLS
- StorageClass and volume provisioners
- liveness and readiness probes
- ACR Tasks base image triggers
- Entra integration for AKS
App Service WebJobs, Kudu, Logic Apps & Notification Hubs
App Service WebJobs types (continuous and triggered), Kudu console and custom deployment scripts, App Service log streaming and container logs, session state and client certificate header handling, Logic Apps workflow design in the designer with connectors and Teams notifications, and Azure Notification Hubs for push messages
Objectives
- Run background tasks with WebJobs and choose between WebJobs, Functions and Logic Apps
- Build a Logic Apps workflow with connectors for notifications and integration
- Troubleshoot App Service apps through log streaming and Kudu
Key concepts
- WebJobs continuous vs triggered
- Kudu custom deployment scripts
- log streaming
- Logic Apps designer and connectors
- Teams notification workflow
- Notification Hubs push
App Service & Functions Runtime Operations: Auto-Heal, Health Check, ARR Affinity, Run from Package, File System Logging, Isolated Worker & Queue Concurrency
App Service auto-heal rules (memory, request count, slow request and status code triggers with recycle actions), Health check with load balancer eviction of unhealthy instances, the ARR Affinity cookie and stateless scale-out, Run from package with WEBSITE_RUN_FROM_PACKAGE, App Service application and web server logging to the file system with its time limit, the .NET isolated worker model for Azure Functions versus the retiring in-process model, and queue trigger concurrency in host.json (batchSize, newBatchThreshold, maxDequeueCount, visibilityTimeout)
Objectives
- Configure health probing, auto-heal and session affinity for a scaled-out web app
- Deploy atomically with a run-from-package zip and enable temporary file system diagnostics
- Tune queue-triggered Functions concurrency and migrate to the isolated worker model
Key concepts
- auto-heal
- Health check
- ARR Affinity
- WEBSITE_RUN_FROM_PACKAGE
- file system logging
- isolated worker model
- queue trigger batchSize
- newBatchThreshold
- maxDequeueCount
- poison queue
App Service Connectivity, Authentication & Secrets: Hybrid Connections, Front Door Access Restrictions, Client Certificates, Built-in Authentication & APIM Key Vault Named Values
Hybrid Connections through Azure Relay to reach an on-premises host and port without inbound firewall rules, access restrictions that allow only Azure Front Door (AzureFrontDoor.Backend service tag plus the X-Azure-FDID header check), incoming client certificates and the X-ARR-ClientCert header, built-in authentication (Easy Auth) behavior for unauthenticated requests (redirect or HTTP 401) and the X-MS-CLIENT-PRINCIPAL header, and API Management named values that reference Key Vault secrets through a managed identity
Objectives
- Reach on-premises resources and lock an app down to Front Door
- Validate client certificates inside the app and configure built-in authentication behavior
- Keep secrets out of API Management policies with Key Vault-backed named values
Key concepts
- Hybrid Connections
- Hybrid Connection Manager
- AzureFrontDoor.Backend service tag
- X-Azure-FDID
- incoming client certificates
- X-ARR-ClientCert
- Easy Auth
- HTTP 401 for unauthenticated API calls
- named values
- Key Vault reference
Container Development: Dockerfile Instructions, Multi-Stage Builds, Layer Caching, Container Apps Secrets & Dapr, Web App for Containers Storage
Dockerfile instructions (FROM, WORKDIR, COPY, RUN, ENV, EXPOSE, ENTRYPOINT versus CMD), multi-stage builds that copy only build output to a small runtime image, ordering instructions for layer caching and .dockerignore, Azure Container Apps secrets referenced with secretRef or Key Vault, Dapr service invocation by app ID through the sidecar, and the WEBSITES_ENABLE_APP_SERVICE_STORAGE setting for persistent /home storage in Web App for Containers
Objectives
- Write an efficient Dockerfile with multi-stage builds and good layer ordering
- Pass secrets to Container Apps without baking them into images
- Call another Container App with Dapr and persist data in Web App for Containers
Key concepts
- Dockerfile instructions
- ENTRYPOINT vs CMD
- multi-stage build
- layer caching
- .dockerignore
- Container Apps secrets
- secretRef
- Dapr service invocation
- WEBSITES_ENABLE_APP_SERVICE_STORAGE
Compute & Hosting Design: App Service Environment v3, Dedicated Host, Batch with Spot VMs, ARO, Azure VMware Solution, SignalR, AKS Workload Identity & AKS Backup
App Service Environment v3 for isolated single-tenant App Service in a virtual network, Azure Dedicated Host for compliance and licensing, Azure Batch pools on Spot VMs for interruptible parallel work, Azure Red Hat OpenShift, Azure VMware Solution for vSphere workloads, Azure SignalR Service for real-time push, AKS workload identity with federated credentials for pods and Azure Backup for AKS cluster state and persistent volumes
Objectives
- Select the hosting platform from isolation, licensing, scale and portability requirements
- Reduce batch compute cost with Spot VMs while tolerating eviction
- Give AKS pods Azure access without secrets and protect cluster state with backup
Key concepts
- App Service Environment v3
- internal load balancer ASE
- Azure Dedicated Host
- Azure Batch
- Spot VMs
- Azure Red Hat OpenShift
- Azure VMware Solution
- Azure SignalR Service
- AKS workload identity
- federated credential
- AKS backup
4 · Networking4 topics
Virtual Networks, Subnets & Peering
Virtual networks and address spaces, subnets, IP addressing (public/private, static/dynamic), VNet peering and transitive routing, user-defined routes and system routes, NAT gateway, network interfaces and service endpoints
Objectives
- Design an address plan and connect VNets with peering
- Control traffic flow with user-defined routes
- Explain why peering is non-transitive and how to work around it
Key concepts
- address space and subnets
- VNet peering
- system routes and UDRs
- public IP SKUs
- NAT gateway
- network interfaces
Network Security: NSG, Firewall, Private Link & WAF
Network security groups and application security groups, Azure Firewall and policies, Azure Bastion, DDoS Protection, Web Application Firewall, service endpoints versus Private Link and private endpoints, and securing public access
Objectives
- Write NSG rules that enforce a tiered application design
- Choose between service endpoints and private endpoints for PaaS access
- Select Firewall, WAF or DDoS Protection for a given threat
Key concepts
- NSG rules and priority
- application security groups
- Azure Firewall
- Azure Bastion
- service endpoints vs private endpoints
- WAF and DDoS Protection
DNS & Load Balancing
Azure DNS public and private zones, DNS Private Resolver, Azure Load Balancer, Application Gateway, Front Door and Traffic Manager, health probes, routing methods, and choosing between regional and global, Layer 4 and Layer 7 options
Objectives
- Select the correct load-balancing service by layer and scope
- Configure private DNS zones for name resolution inside VNets
- Design global routing for failover or performance
Key concepts
- Azure DNS and private DNS zones
- Load Balancer SKUs
- Application Gateway
- Front Door
- Traffic Manager routing methods
- health probes
Hybrid Connectivity & Network Design
Site-to-site and point-to-site VPN Gateway, ExpressRoute circuits and peering, Virtual WAN, hub-and-spoke topology, BGP, forced tunneling, Network Watcher diagnostics and network architecture design decisions
Objectives
- Choose VPN, ExpressRoute or Virtual WAN for a hybrid requirement
- Design a hub-and-spoke network with centralized inspection
- Troubleshoot connectivity with Network Watcher tools
Key concepts
- VPN Gateway
- ExpressRoute
- Virtual WAN
- hub-and-spoke
- BGP and route propagation
- Network Watcher
5 · Storage & Data45 topics
Storage Accounts, Access & Redundancy
Storage account types and performance tiers, redundancy options (LRS, ZRS, GRS, GZRS), access tiers, shared access signatures, access keys, Entra ID authorization, storage firewalls and private endpoints, and customer-managed keys
Objectives
- Pick the redundancy option that meets durability and availability targets
- Grant least-privilege, time-limited access with SAS or Entra ID
- Lock down a storage account to private networks
Key concepts
- LRS, ZRS, GRS, GZRS
- access tiers
- SAS tokens and stored access policies
- shared keys vs Entra authorization
- storage firewall
- object replication
Blob Storage, Azure Files & Data Lake
Blob containers and blob types, lifecycle management, versioning, soft delete and immutability, AzCopy and Storage Explorer, Azure Files shares and snapshots, Azure File Sync, SDK properties and metadata, and hierarchical namespace for Data Lake Storage Gen2
Objectives
- Configure lifecycle rules and data protection for blob data
- Choose between Azure Files, Blob and Data Lake for a scenario
- Use AzCopy and the SDK to move data and manage blob properties
Key concepts
- blob types and tiers
- lifecycle management policies
- versioning, soft delete and immutability
- Azure Files and snapshots
- Azure File Sync
- hierarchical namespace
Azure SQL & Relational Data Services
Azure SQL Database, Managed Instance and SQL Server on VMs, DTU versus vCore purchasing models, elastic pools, serverless, high availability, geo-replication and failover groups, backups and PITR, and Azure Database for MySQL/PostgreSQL
Objectives
- Select the right Azure SQL deployment option and purchasing model
- Design high availability and disaster recovery for a relational workload
- Secure Azure SQL with encryption, auditing and network controls
Key concepts
- SQL Database vs Managed Instance vs SQL on VM
- DTU vs vCore
- elastic pools
- failover groups and geo-replication
- point-in-time restore
- TDE and Always Encrypted
Azure Cosmos DB
Cosmos DB APIs, request units and throughput modes, partition keys, the five consistency levels, global distribution and multi-region writes, change feed, indexing, and SDK usage for developers
Objectives
- Choose a partition key that avoids hot partitions
- Select a consistency level for a latency versus correctness trade-off
- Estimate and tune throughput with request units and autoscale
Key concepts
- APIs and data models
- request units
- partition key design
- five consistency levels
- multi-region writes
- change feed
Core Data Concepts & Analytics Workloads
Structured, semi-structured and unstructured data, relational concepts (tables, keys, normalization, views, indexes), transactional versus analytical workloads, data roles, batch versus streaming, data lakes, warehouses, lakehouses and Power BI
Objectives
- Classify data and pick a store for it
- Differentiate transactional and analytical workloads and the roles that own them
- Describe the elements of a large-scale analytics solution on Azure
Key concepts
- structured vs unstructured data
- normalization and keys
- OLTP vs OLAP
- batch vs streaming
- data warehouse vs lake vs lakehouse
- Power BI basics
Data Processing: Pipelines, Batch & Stream
Partition strategy, Azure Data Factory and Synapse pipelines, incremental loads, slowly changing dimensions, Spark and Databricks batch processing, Azure Stream Analytics and Event Hubs, windowing, late data handling, and pipeline management
Objectives
- Design a partitioned lake layout and an incremental ingestion pipeline
- Choose tumbling, hopping, sliding or session windows for a streaming query
- Handle failures, late data and reruns in a pipeline
Key concepts
- partitioning strategy
- Data Factory and Synapse pipelines
- incremental load and SCD
- Spark batch jobs
- Stream Analytics windowing
- triggers and pipeline error handling
Data Security, Monitoring & Optimization
Data encryption at rest and in transit, RBAC and POSIX ACLs on Data Lake, dynamic data masking and row-level security, Purview for data governance, monitoring pipelines and Spark jobs, data skew, shuffle, small files, and cost and performance tuning
Objectives
- Secure analytic data with the right combination of RBAC, ACLs and masking
- Diagnose a slow Spark or SQL pool job and name the fix
- Set up monitoring and alerts for pipelines
Key concepts
- ACLs and RBAC on Data Lake
- dynamic data masking and row-level security
- Purview catalog
- pipeline monitoring
- data skew and shuffle
- small file compaction
Microsoft Fabric & Semantic Models
Fabric workspaces, lakehouses, warehouses and Direct Lake, dataflows and notebooks, workspace roles and item security, deployment pipelines and version control, semantic models with DAX, star schema design, and Power BI performance tuning
Objectives
- Choose lakehouse, warehouse or dataflow for a Fabric scenario
- Design a star-schema semantic model and tune its performance
- Manage the analytics development lifecycle with Git and deployment pipelines
Key concepts
- lakehouse vs warehouse
- Direct Lake
- workspace roles and OneLake security
- deployment pipelines
- star schema and DAX measures
- model optimization
Analytics Types, Data Roles & Power BI
Descriptive, diagnostic, predictive, prescriptive and cognitive analytics, data roles (database administrator, data engineer, data analyst) and their responsibilities, data visualization concepts, Power BI Desktop versus the Power BI service and Report Builder, reports versus dashboards, and choosing visuals such as treemap, waterfall, line and bar charts
Objectives
- Match a business question to the analytics type that answers it
- Assign a data task to the right data role
- Choose the Power BI artifact and visual that fit a reporting need
Key concepts
- descriptive, diagnostic, predictive, prescriptive analytics
- database administrator vs data engineer vs analyst
- Power BI Desktop vs service
- reports vs dashboards
- choosing a Power BI visual
- Power BI Report Builder
Non-relational Data Models: Key-Value, Document, Column & Graph
Non-relational data models and when to choose each: key-value, document, column-family, graph with nodes and edges, and time series; Azure Table storage PartitionKey and RowKey, queue and file storage selection, and recognizing JSON objects, nested objects and arrays, XML and other semi-structured data formats
Objectives
- Pick the non-relational model that fits an access pattern
- Read JSON and XML structures and identify objects, nested objects and arrays
- Choose between Azure Table, Queue and File storage
Key concepts
- key-value stores and session data
- document stores and JSON structure
- column-family stores
- graph databases nodes and edges
- Table storage PartitionKey and RowKey
- time series data
SQL Client Tools & T-SQL Fundamentals
SQL Server Management Studio, Azure Data Studio, SQL Server Data Tools (SSDT), Visual Studio Code extensions and command-line tools for Azure SQL, MariaDB and PostgreSQL clients, T-SQL language categories (DDL, DML, DCL), INSERT, UPDATE and DELETE statements, SQL Database server-level firewall rules and server administrator accounts
Objectives
- Select the client tool that fits a platform and task
- Classify and write basic T-SQL data manipulation statements
- Explain how server-level firewall rules control access to Azure SQL Database
Key concepts
- SSMS vs Azure Data Studio
- SSDT
- T-SQL DDL, DML and DCL
- INSERT and UPDATE statements
- server-level firewall rules
- server admin accounts
Synapse SQL Pools, Databricks & Analytics Platforms
Azure Synapse Analytics architecture (massively parallel processing, dedicated SQL pool, serverless SQL pool over lake files and Parquet, PolyBase external tables), distribution choices (hash, replicated, round robin), columnstore indexes and rowgroup maintenance, COPY INTO loading, pausing pools to save cost, Azure Databricks and HDInsight Spark provisioning, notebooks and data source integration, Stream Analytics outputs and partition alignment, and Power BI DirectQuery versus Import
Objectives
- Choose a table distribution for fact and dimension tables
- Decide between dedicated and serverless SQL pools for serving and exploration
- Select Databricks, HDInsight or Synapse Spark for a processing requirement
Key concepts
- MPP dedicated SQL pool
- hash, replicated and round-robin distribution
- serverless SQL pool
- columnstore and rowgroups
- Databricks and HDInsight Spark
- COPY INTO and PolyBase
Azure SQL Security, Auditing & Operations
Microsoft Entra authentication for Azure SQL including integrated authentication, auditing destinations (storage, Log Analytics, Event Hubs), Defender for SQL threat detection and vulnerability assessment, long-term backup retention, automatic tuning, purchasing tier and elastic pool selection, BACPAC export and DACPAC deployment, and MySQL server firewall rules
Objectives
- Configure Entra-based authentication and auditing for Azure SQL
- Detect and respond to threats with Defender for SQL
- Select tiers, elastic pools, backups and export formats for operational needs
Key concepts
- Entra authentication for SQL
- auditing destinations
- Defender for SQL and vulnerability assessment
- long-term retention
- automatic tuning
- BACPAC vs DACPAC
Cosmos DB for Developers: Indexing, Change Feed & Integration
Cosmos DB composite indexing policies, the change feed and the change feed processor, server-side triggers, stored procedures, resource tokens for scoped client access, migration tooling, Azure Synapse Link for analytics, and Databricks integration
Objectives
- Design indexing policies for multi-property queries
- React to data changes with the change feed processor
- Give clients scoped access and analyze operational data without affecting transactions
Key concepts
- composite indexes
- change feed and change feed processor
- server-side triggers
- resource tokens
- Synapse Link
- data migration tools
Fabric Direct Lake Semantic Models & Performance
Direct Lake mode on OneLake, framing and reframing, fallback to DirectQuery and its triggers, guardrails per Fabric capacity SKU, V-Order, row group sizing, VertiPaq cardinality and compression, and diagnosing fallback to optimize semantic models
Objectives
- Explain when Direct Lake falls back to DirectQuery and how to prevent it
- Tune Delta layout for fast Direct Lake queries
- Diagnose and fix semantic model performance
Key concepts
- Direct Lake mode
- framing and reframing
- fallback to DirectQuery
- capacity SKU guardrails
- V-Order and row group size
- VertiPaq compression
Fabric Delta Maintenance, Shortcuts & Real-Time Intelligence
Delta table maintenance (OPTIMIZE compaction, VACUUM retention, V-Order tradeoffs, scheduled maintenance), OneLake shortcuts to internal and external storage with cross-region cost and latency, Eventstream streaming ingestion, and KQL time-series aggregation in an Eventhouse
Objectives
- Schedule Delta maintenance that balances storage, speed and time travel
- Use shortcuts to reference data without copying and understand their cost
- Ingest and aggregate streaming data with Eventstream and KQL
Key concepts
- OPTIMIZE and VACUUM
- scheduled table maintenance
- OneLake shortcuts
- shortcut cross-region cost
- Eventstream
- KQL in Eventhouse
Fabric Notebooks, Pipelines, Warehouse T-SQL & Git Integration
PySpark and Spark SQL notebooks, parameter cells and base parameters, orchestration from pipelines including On failure dependencies, Fabric Environments for libraries, choosing Spark notebooks or Dataflow Gen2, Warehouse visual query editor and cross-warehouse T-SQL with three-part names, Git integration update actions and branch-out workspaces, and DAX calculation groups
Objectives
- Choose notebooks, Dataflow Gen2 or T-SQL for a transformation
- Parameterize a notebook and orchestrate it from a pipeline with failure handling
- Manage Fabric items with Git integration and apply calculation groups
Key concepts
- PySpark and Spark SQL notebooks
- parameter cells
- pipeline On failure
- Fabric Environments
- Git integration and branch-out
- calculation groups
Storage Data Movement Tools & Blob/Queue SDK
Azure Import/Export service requirements by account and data type, AzCopy, copying storage through template export, preparing and uploading VHDs, blob SDK methods for metadata, leases and change feed, Azure Queue storage SDK code, SAS with stored access policy, per-tenant encryption scopes, and selecting storage account types for requirements
Objectives
- Choose the right tool to move data into and out of Azure Storage
- Use blob leases, metadata and change feed from SDK code
- Apply stored access policies and encryption scopes for scoped access
Key concepts
- Import/Export service
- AzCopy
- VHD upload
- blob metadata, lease and change feed in the SDK
- Queue storage SDK
- encryption scopes
Stream Analytics Query Design: Parallelism, Joins, Outputs & Functions
Azure Stream Analytics query design: embarrassingly parallel jobs with PARTITION BY and matching input and output partition counts, WITH steps feeding multiple outputs, stream-to-stream joins with DATEDIFF bounds, geospatial functions (CreatePoint, ST_DISTANCE, ST_WITHIN), built-in anomaly detection (AnomalyDetection_SpikeAndDip, AnomalyDetection_ChangePoint), and choosing an output sink for interactive queries versus archive
Objectives
- Design a fully parallel Stream Analytics job and explain what breaks parallelism
- Write multi-output, join, geospatial and anomaly detection queries
- Pick output sinks that match the consumption pattern
Key concepts
- PARTITION BY and embarrassingly parallel
- WITH steps and multiple outputs
- stream-to-stream temporal join DATEDIFF
- geospatial functions
- AnomalyDetection_SpikeAndDip
- output sink selection
- Cosmos DB and Azure SQL outputs
Stream Analytics & Event Hubs Operations: SU, Error Policy & Throughput
Operating streaming jobs: SU % utilization, backlogged input events and watermark delay for scaling streaming units, the output error handling policy (Retry versus Drop), input deserialization error metrics, and Event Hubs throughput units (1 MB/s or 1,000 events/s ingress per unit), auto-inflate and server-busy throttling
Objectives
- Diagnose a lagging job from SU, backlog and watermark metrics and scale it
- Choose an output error policy that matches data-loss tolerance
- Size Event Hubs throughput units and recognize throttling
Key concepts
- SU percent utilization
- backlogged input events
- watermark delay
- output error policy Retry Drop
- input deserialization errors
- Event Hubs throughput units
- auto-inflate
ADF & Databricks Orchestration: Triggers, IR, CI/CD & Job Repair
Orchestrating pipelines: self-hosted integration runtime high availability (multiple nodes) and scaling, Azure-SSIS integration runtime, Azure Batch with the Custom activity, Webhook activity callbacks, tumbling window trigger dependencies, pipeline concurrency, rerun from failed activity, ADF CI/CD promotion with adf_publish, plus Databricks job repair run, task values (dbutils.jobs.taskValues) and notebook orchestration (dbutils.notebook.run versus %run)
Objectives
- Make integration runtimes and triggers resilient and correctly ordered
- Promote ADF assets across environments and recover failed runs without redoing finished work
- Pass values and orchestrate notebooks and tasks in Databricks Jobs
Key concepts
- self-hosted IR high availability
- Azure-SSIS IR
- Batch Custom activity
- Webhook activity
- tumbling window dependency
- pipeline concurrency
- rerun from failed activity
- ADF CI/CD adf_publish
- Databricks repair run
- task values
- dbutils.notebook.run vs %run
Ingestion Patterns: Copy Activity, COPY INTO, Data Flows & Synapse Link
Loading data at scale: Copy activity source partitioning (partitionOption, parallelCopies) and sink copy behavior (PreserveHierarchy, FlattenHierarchy, MergeFiles), mapping data flow Parse transformation and schema drift, data flow cluster TTL, COPY INTO for dedicated SQL pools and its load parallelism, the Spark connector for a dedicated pool, parallel JDBC reads in Spark (partitionColumn, numPartitions) and Synapse Link for SQL
Objectives
- Tune Copy activity and Spark JDBC reads for parallel throughput
- Handle schema drift and semi-structured parsing in mapping data flows
- Load dedicated SQL pools with COPY INTO and choose Synapse Link where near-real-time replication fits
Key concepts
- copy activity source partitioning
- copy behavior
- mapping data flow Parse
- schema drift
- data flow cluster TTL
- COPY INTO
- COPY INTO load parallelism
- dedicated pool Spark connector
- parallel JDBC partitionColumn
- Synapse Link for SQL
Delta Lake Operations: Auto Loader, VACUUM, Change Data Feed & Constraints
Delta Lake on Databricks and Synapse Spark: Auto Loader (cloudFiles) incremental ingestion with schema inference, schema evolution and the rescued data column, VACUUM and retention to physically erase deleted data, change data feed (delta.enableChangeDataFeed, _change_type), CHECK and NOT NULL constraints, and foreachBatch with MERGE for streaming upserts
Objectives
- Ingest new files incrementally and survive schema changes with Auto Loader
- Erase data physically and consume row-level changes from a Delta table
- Enforce data quality with constraints and apply idempotent streaming upserts
Key concepts
- Auto Loader cloudFiles
- schemaEvolutionMode and rescuedDataColumn
- VACUUM retention
- change data feed
- CHECK constraints
- foreachBatch MERGE upsert
- time travel
Spark Transformations & Performance: Parse Modes, UDFs, Caching & Tables
Spark transformations and tuning: malformed-record parse modes (PERMISSIVE, DROPMALFORMED, FAILFAST), explode, explode_outer and posexplode on arrays and maps, avoiding slow Python UDFs in favor of built-in functions or pandas UDFs, DataFrame caching versus the Databricks disk cache, and managed versus external tables
Objectives
- Choose a parse mode that fits the tolerance for bad records
- Flatten nested data and replace UDFs with faster alternatives
- Cache correctly and pick the table type that matches data ownership
Key concepts
- PERMISSIVE DROPMALFORMED FAILFAST
- explode and explode_outer
- pandas UDF vs Python UDF
- df.cache and persist
- Databricks disk cache
- managed vs external tables
Synapse Dedicated SQL Pool Tuning: Caching, CTAS, Scaling & Data Movement
Tuning a Synapse dedicated SQL pool (formerly SQL Data Warehouse; Microsoft directs new analytics builds to Fabric Warehouse, but the pool remains supported): result set caching, CTAS versus UPDATE for large changes, scaling DWUs, data movement DMVs such as sys.dm_pdw_request_steps and sys.dm_pdw_dms_workers, and Query Store for plan regressions
Objectives
- Turn on and reason about result set caching
- Replace large UPDATE or DELETE statements with CTAS and a rename
- Find data movement and regressed plans with DMVs and Query Store
Key concepts
- result set caching
- CTAS versus UPDATE
- scale DWU
- sys.dm_pdw_request_steps
- ShuffleMove and BroadcastMove
- Query Store plan regression
- hash distribution
Synapse Serverless SQL, Shared Metadata & Power BI Connectivity
Synapse serverless SQL pool: reading Delta tables with OPENROWSET FORMAT='DELTA', UTF-8 collation Latin1_General_100_BIN2_UTF8 for string columns, cost control (billing per TB processed, sp_set_data_processed_limit), shared metadata from Spark databases, and Power BI Import versus DirectQuery connectivity
Objectives
- Query lake data with serverless SQL efficiently and cap spend
- Use Spark-created tables from serverless SQL
- Choose Import or DirectQuery for a freshness and size requirement
Key concepts
- OPENROWSET Delta
- UTF-8 collation
- sp_set_data_processed_limit
- shared metadata Spark to serverless
- Power BI Import vs DirectQuery
- CETAS
Data Engineering Security: Secret Scopes, Synapse RBAC, Unity Catalog & Exfiltration
Securing analytics platforms: Databricks secret scopes (Key Vault-backed versus Databricks-backed) read with dbutils.secrets.get, Synapse RBAC roles that are separate from Azure RBAC, Unity Catalog metastore, catalogs, schemas and GRANT, Synapse managed virtual network data exfiltration protection with approved tenants and managed private endpoints, and SQL Data Discovery and Classification
Objectives
- Keep credentials in Key Vault-backed secret scopes instead of notebooks
- Assign Synapse and Unity Catalog permissions at the right scope
- Block exfiltration and classify sensitive columns
Key concepts
- Databricks secret scopes
- Synapse RBAC roles
- Unity Catalog
- data exfiltration protection
- managed private endpoints
- Data Discovery and Classification
- sensitivity labels
Data Platform Monitoring & Retention: Spark Logs, Throttling & TTL
Observability and retention for data platforms: sending Synapse Spark application logs to Log Analytics with the diagnostic emitter, detecting storage throttling through ServerBusy and ClientThrottling transaction metrics, Databricks cluster log delivery and diagnostic settings, and Cosmos DB time to live (defaultTtl and per-item ttl)
Objectives
- Route Spark and cluster logs to a queryable store
- Detect throttling from storage metrics and respond
- Expire operational data automatically with Cosmos DB TTL
Key concepts
- Spark diagnostic emitter
- Log Analytics for Synapse
- storage throttling metrics
- Databricks log delivery
- Cosmos DB TTL
- diagnostic settings
Semantic Model Design: Calculation Groups, Dynamic Format Strings, Field Parameters, Perspectives & Usability
Calculation groups with calculation items and SELECTEDMEASURE for reusable time intelligence (YTD, prior year) and precedence, dynamic format strings with SELECTEDMEASUREFORMATSTRING, field parameters created with NAMEOF so users switch measures or dimensions in a visual, perspectives that expose focused subsets of a model (not a security feature), sort by column (month name by month number) and usability settings such as hiding key columns and setting Summarize by to None
Objectives
- Replace dozens of duplicated measures with a calculation group
- Let report users switch measures and axes with field parameters
- Make a model easier and safer to use with sorting, hidden keys and perspectives
Key concepts
- calculation groups
- SELECTEDMEASURE
- calculation item precedence
- dynamic format strings
- field parameters
- NAMEOF
- perspectives
- sort by column
- Summarize by None
- hide key columns
DAX Functions: DIVIDE, ISINSCOPE, INFO Functions & DAX Query View
DIVIDE with an alternate result to handle division by zero safely, ISINSCOPE to detect the current hierarchy level in a measure (percent of parent, subtotal handling), INFO.TABLES, INFO.MEASURES, INFO.COLUMNS and INFO.RELATIONSHIPS to read model metadata with DAX, and DAX query view in Power BI Desktop and the service to write EVALUATE queries, test measures with DEFINE and update the model with them
Objectives
- Write division and hierarchy-aware measures that behave correctly at every level
- Document and audit a model with INFO functions
- Develop and test DAX interactively in DAX query view
Key concepts
- DIVIDE alternate result
- ISINSCOPE
- hierarchy level detection
- INFO.TABLES
- INFO.MEASURES
- INFO.COLUMNS
- DAX query view
- DEFINE MEASURE
- EVALUATE
Semantic Model Memory & Compression: Cardinality, Auto Date/Time, Attribute Hierarchies & Calculated Columns
VertiPaq dictionary encoding and why high-cardinality columns (GUIDs, datetimes with seconds) compress poorly, splitting date and time and reducing precision, the hidden date tables created by auto date/time, attribute hierarchy memory and turning off IsAvailableInMdx for unused columns, the memory and refresh cost of calculated columns versus source or Power Query columns, and measuring model size with VertiPaq Analyzer
Objectives
- Find and shrink the columns that dominate model memory
- Replace auto date/time with one marked date table
- Move calculated columns upstream to cut model size and refresh time
Key concepts
- column cardinality
- dictionary encoding
- split date and time
- auto date/time overhead
- date table
- IsAvailableInMdx
- calculated column memory
- VertiPaq Analyzer
Semantic Model Scale & Refresh: Large Storage Format, Caching, Scale-Out, Performance Analyzer, APR, Hybrid Tables & Enhanced Refresh
The large semantic model storage format on Premium and Fabric capacity, query caching of first-load report results, query scale-out with read-only replicas, Performance Analyzer in Power BI Desktop to separate DAX query, visual rendering and other time, automatic page refresh with change detection against a DirectQuery measure, incremental refresh with hybrid tables (latest partition in DirectQuery), and the enhanced refresh REST API for partition-level refreshes with commit mode and parallelism
Objectives
- Diagnose whether a slow visual is caused by DAX, rendering or the model
- Scale a busy model with caching and scale-out replicas
- Refresh only the partitions that changed and keep recent data real time
Key concepts
- large semantic model storage format
- query caching
- query scale-out
- Performance Analyzer
- automatic page refresh change detection
- hybrid tables
- incremental refresh
- enhanced refresh API
- partition refresh
Fabric ALM: PBIP & TMDL, fabric-cicd, Variable Libraries, Warehouse dacpac, Best Practice Analyzer, Templates & .pbids
Power BI project (PBIP) folders with TMDL text files for Git diffs and merges, deploying repository items with the fabric-cicd Python library and parameter files, variable libraries with value sets per stage, Warehouse schema as code with SQL database projects, dacpac builds and SqlPackage publish, rule-based review of models with the Tabular Editor Best Practice Analyzer, Power BI template (.pbit) files and .pbids data source files for distributing connections
Objectives
- Version semantic models and reports as code and review changes in pull requests
- Promote items across stages with fabric-cicd and variable libraries
- Ship Warehouse schema changes as a dacpac and standardize model quality
Key concepts
- PBIP project
- TMDL
- fabric-cicd
- parameter file
- variable library value set
- dacpac
- SqlPackage publish
- Best Practice Analyzer
- pbit template
- pbids file
Warehouse T-SQL: Cross-Warehouse Queries, ROLLUP, STRING_AGG, TRY_CAST, APPROX_COUNT_DISTINCT, OPENROWSET & Visual Query Editor
Cross-warehouse queries with three-part names in one workspace, GROUP BY ROLLUP subtotals with GROUPING, STRING_AGG with WITHIN GROUP, TRY_CAST returning NULL on conversion failure, APPROX_COUNT_DISTINCT for fast approximate distinct counts, OPENROWSET over Parquet files in OneLake or storage, COPY INTO, and the Warehouse visual query editor that builds queries by drag and drop and generates T-SQL
Objectives
- Query across warehouses and lakehouse endpoints with T-SQL
- Pick the right T-SQL function for subtotals, string aggregation, safe conversion and approximate counts
- Explore files with OPENROWSET and build queries visually
Key concepts
- three-part names
- GROUP BY ROLLUP
- GROUPING function
- STRING_AGG
- TRY_CAST
- APPROX_COUNT_DISTINCT
- OPENROWSET Parquet
- visual query editor
Warehouse Operations: Time Travel, Table Clone, Statistics, DMVs, Query Insights, Endpoint Sync & Inferred Members
Warehouse T-SQL time travel with FOR TIMESTAMP AS OF within the retention window, zero-copy table clones, automatic and manual statistics maintenance, dynamic management views and KILL for live sessions, queryinsights views for long-running and frequently run queries, SQL analytics endpoint metadata sync lag for Lakehouse tables and how to force a refresh, and inferred dimension members for late-arriving dimension rows
Objectives
- Recover or compare data as of an earlier time using time travel and clones
- Troubleshoot slow or stuck queries with DMVs and query insights
- Handle stale endpoint metadata and late-arriving dimensions
Key concepts
- FOR TIMESTAMP AS OF
- CREATE TABLE AS CLONE OF
- CREATE STATISTICS
- UPDATE STATISTICS
- sys.dm_exec_requests
- KILL session
- queryinsights views
- SQL endpoint metadata sync
- inferred dimension member
Fabric Mirroring, Open Mirroring & the Fabric SQL Database Item
Database mirroring that continuously replicates an operational database into OneLake as Delta tables with a SQL analytics endpoint, open mirroring where applications write files with row markers to a landing zone, and the SQL database in Fabric (SQL engine for OLTP with automatic mirroring to OneLake), plus how to choose between mirroring, a SQL database, a Warehouse, a Lakehouse and pipelines
Objectives
- Choose mirroring instead of building copy pipelines
- Use open mirroring for sources without a built-in connector
- Select the right Fabric item for transactional versus analytical workloads
Key concepts
- Fabric mirroring
- mirrored database
- open mirroring landing zone
- row marker
- SQL database in Fabric
- OLTP vs analytics
- SQL analytics endpoint
- OneLake Delta replica
Dataflow Gen2 & Power Query: Fast Copy, Combine Files, Merge Join Kinds, Locale Conversion & Fill Down
Dataflow Gen2 Fast Copy for high-volume ingestion, Combine files from a folder (sample file query and function), merge join kinds (left outer, right outer, full outer, inner, left anti, right anti), changing type using a locale for dates and decimals, and Fill Down to propagate values into null cells
Objectives
- Speed up large ingestion with Dataflow Gen2 Fast Copy
- Combine many files with one schema and choose the right merge join kind
- Parse locale-specific values and fill grouped header cells correctly
Key concepts
- Fast Copy
- Combine files
- sample file query
- merge join kinds
- left anti join
- change type using locale
- Fill Down
- query folding
Pipeline Ingestion: REST Pagination, Event-Based Triggers & On-Premises Data Gateway
Copy activity with the REST connector and pagination rules for next-page links, event-based pipeline triggers from storage events through Fabric Activator and the Real-Time hub, and the on-premises data gateway for pipelines and Dataflow Gen2 reading on-premises sources
Objectives
- Ingest a paged REST API with a Copy activity
- Start a pipeline when a file lands in storage
- Reach on-premises SQL Server securely from pipelines
Key concepts
- REST connector pagination rules
- AbsoluteUrl pagination
- event-based trigger
- Fabric Activator
- BlobCreated event
- on-premises data gateway
- Copy activity
Spark in Fabric: Data Wrangler, mergeSchema, Exact Decimals, Semantic Link & OneLake File Explorer
Data Wrangler for low-code data preparation that generates PySpark or pandas code, Delta schema evolution on append with mergeSchema, exact decimal typing with DecimalType instead of floating point, semantic link (sempy) to read semantic model tables and evaluate measures or DAX from notebooks, and OneLake file explorer to sync workspace files to Windows
Objectives
- Prepare data visually and export the generated code
- Evolve a Delta schema safely on append and keep monetary values exact
- Combine notebooks with semantic models through semantic link
Key concepts
- Data Wrangler
- mergeSchema
- overwriteSchema
- DecimalType
- semantic link
- sempy evaluate_measure
- FabricDataFrame
- OneLake file explorer
Real-Time Intelligence: KQL, Time-Series Aggregation, Anomaly Detection, OneLake Availability & Dashboard Parameters
Kusto Query Language basics (where, summarize, bin, render), make-series for time-series aggregation, series_decompose_anomalies for anomaly detection, OneLake availability that exposes Eventhouse tables as Delta for Spark, SQL and Direct Lake, and Real-Time Dashboard parameters such as _startTime and _endTime used in tile queries
Objectives
- Write KQL to aggregate and chart streaming data
- Detect anomalies in a time series with built-in KQL functions
- Expose Eventhouse data to the lakehouse and build parameterized real-time dashboards
Key concepts
- KQL summarize and bin
- make-series
- series_decompose_anomalies
- Eventhouse
- OneLake availability
- Real-Time Dashboard parameters
- _startTime and _endTime
- Eventstream
Cosmos DB SDK Practices: Preferred Regions, Bulk Mode, Client Lifetime, 429 Retries, ETag Concurrency, Patch, Unique Keys, Conflict Resolution & MongoDB Migration
Configuring preferred regions in the Cosmos DB SDK, bulk mode with AllowBulkExecution, using a single long-lived CosmosClient, SDK retry options for 429 rate limiting (MaxRetryAttemptsOnRateLimitedRequests and wait time), optimistic concurrency with the item ETag and IfMatchEtag, partial document updates with Patch operations, unique key policies scoped to a logical partition, conflict resolution policies for multi-region writes (last writer wins or custom) and migrating MongoDB data with Azure Database Migration Service
Objectives
- Configure the SDK for latency, throughput and rate-limit resilience
- Prevent lost updates with ETags and update documents partially with Patch
- Design multi-region conflict handling and migrate MongoDB workloads
Key concepts
- ApplicationPreferredRegions
- AllowBulkExecution
- singleton CosmosClient
- 429 retry options
- ETag and IfMatchEtag
- Patch operations
- unique key policy
- last writer wins
- custom conflict resolution
- Azure Database Migration Service for MongoDB
Blob Storage for Developers: CORS, Index Tags, Static Website Hosting, ETag Concurrency & Range Requests
Cross-origin resource sharing rules on the Blob service for browser clients, blob index tags for key-value queries across a storage account versus metadata, static website hosting from the $web container with index and error documents, optimistic concurrency with ETags and conditional headers (If-Match, If-None-Match) versus leases, and range requests that return 206 Partial Content for resumable and parallel downloads
Objectives
- Allow a browser app to call Blob storage with the right CORS rule
- Find blobs by tag and host a static site from a storage account
- Prevent overwrites with conditional headers and download large blobs in ranges
Key concepts
- CORS rules
- preflight request
- blob index tags
- Find Blobs by Tags
- static website
- $web container
- ETag If-Match
- 412 Precondition Failed
- blob lease
- Range header 206
Open-Source Database Resilience: MySQL & PostgreSQL Flexible Server Zone-Redundant HA, Cross-Region Replicas & Long-Term Backup
Azure Database for MySQL and PostgreSQL flexible server high availability with a zone-redundant standby and synchronous replication versus same-zone HA, automatic failover behavior, read replicas including cross-region replicas for disaster recovery and promotion, geo-redundant backup, and long-term retention of PostgreSQL backups beyond the built-in 35 days
Objectives
- Choose zone-redundant HA, replicas or geo-redundant backup for an availability and RPO target
- Design disaster recovery for a flexible server across regions
- Meet multi-year retention requirements for PostgreSQL backups
Key concepts
- zone-redundant HA
- same-zone HA
- synchronous standby
- automatic failover
- read replicas
- cross-region replica
- promote replica
- geo-redundant backup
- long-term retention backup
Azure SQL & Cosmos DB Design Features: Elastic Jobs, Ledger Tables, Cosmos Data-Plane RBAC, Continuous Backup, Hybrid Benefit, Reserved Capacity & Oracle Database@Azure
Elastic jobs to run T-SQL across many Azure SQL databases, ledger tables with cryptographic digests for tamper evidence, Cosmos DB data-plane role-based access control with Microsoft Entra identities (disabling key-based access), continuous backup with point-in-time restore versus periodic backup, Azure Hybrid Benefit and reserved capacity to reduce cost, and Oracle Database@Azure for Exadata workloads
Objectives
- Schedule maintenance across many databases and prove tamper evidence with ledger
- Secure Cosmos DB with data-plane RBAC and recover data with continuous backup
- Reduce database cost with Hybrid Benefit and reserved capacity and place Oracle Exadata workloads
Key concepts
- elastic jobs
- target group
- ledger tables
- database digests
- Cosmos DB built-in data roles
- disable local authentication
- continuous backup
- point-in-time restore to a new account
- Azure Hybrid Benefit
- reserved capacity
- Oracle Database@Azure
Storage Solution Design: Encryption Scopes, NFS 3.0 on Blob, Object Replication, Elastic SAN, Azure NetApp Files & Storage Mover
Encryption scopes that isolate tenant data with separate keys within one storage account, NFS 3.0 protocol support on Blob storage with hierarchical namespace, asynchronous object replication between storage accounts (versioning and change feed), Azure Elastic SAN for consolidated block storage over iSCSI, Azure NetApp Files for enterprise NFS and SMB file workloads, and Azure Storage Mover for migrating on-premises file shares
Objectives
- Pick the storage service that fits protocol, performance and migration requirements
- Isolate tenant data with encryption scopes and replicate blobs across accounts
- Migrate file shares with Storage Mover
Key concepts
- encryption scope
- customer-managed key per scope
- NFS 3.0 blob
- hierarchical namespace
- object replication
- blob versioning and change feed
- Elastic SAN
- Azure NetApp Files
- capacity pool service level
- Storage Mover
6 · Security, Governance & Monitoring20 topics
Security & Compliance Concepts, Zero Trust
Shared responsibility, defense in depth, Zero Trust, the CIA triad, encryption and hashing, authentication versus authorization, identity providers, federation, directory services, and governance, risk and compliance concepts
Objectives
- Explain Zero Trust and defense in depth with Azure examples
- Differentiate authentication, authorization and accounting
- Describe how encryption and hashing protect data
Key concepts
- Zero Trust principles
- defense in depth
- CIA triad
- encryption and hashing
- federation and identity providers
- GRC concepts
Governance: Policy, Locks, Tags & Cost Management
Azure Policy definitions, initiatives, effects and remediation, resource locks, tags, management groups, Blueprints and landing zones, Cost Management and budgets, the pricing calculator, TCO, reservations, savings plans and Azure Hybrid Benefit
Objectives
- Enforce organizational standards with Azure Policy at scale
- Reduce and control cloud spend with budgets, tags and commitments
- Distinguish Policy, RBAC and locks
Key concepts
- Azure Policy effects
- initiatives and remediation
- resource locks
- tags and inheritance
- budgets and cost analysis
- reservations and savings plans
Azure Monitor, Log Analytics & Alerts
Azure Monitor metrics and logs, Log Analytics workspaces and KQL, diagnostic settings, alert rules and action groups, VM, container and network insights, Network Watcher, Service Health and Advisor, and monitoring design
Objectives
- Collect and query logs with diagnostic settings and KQL
- Create metric and log alerts that notify the right people
- Design a monitoring and logging solution for many subscriptions
Key concepts
- metrics vs logs
- Log Analytics and KQL
- diagnostic settings
- alert rules and action groups
- Service Health and Advisor
- workspace design
Application Insights & Instrumentation
Application Insights and OpenTelemetry instrumentation, availability tests, Application Map, live metrics, sampling, custom telemetry, alerts, KQL analysis, and troubleshooting application performance and failures
Objectives
- Instrument an application and choose between auto and manual instrumentation
- Use Application Insights to find the cause of failures and slow dependencies
- Tune sampling and retention to manage telemetry cost
Key concepts
- auto-instrumentation vs SDK
- availability tests
- Application Map
- sampling
- custom events and metrics
- failures and performance blades
Backup, High Availability & Disaster Recovery
Recovery Services and Backup vaults, backup policies and soft delete, Azure Site Recovery, RPO and RTO, availability zones and SLAs, composite SLA calculation, paired-region failover and business continuity design
Objectives
- Back up and restore VMs, files and databases
- Design for RPO and RTO targets using ASR and zone redundancy
- Calculate the composite SLA of a multi-tier solution
Key concepts
- Recovery Services vault
- backup policy and retention
- Azure Site Recovery
- RPO and RTO
- composite SLA
- zone-redundant design
Key Vault & App Configuration
Azure Key Vault secrets, keys and certificates, access policies versus RBAC, soft delete and purge protection, managed HSM, key rotation, customer-managed keys, Azure App Configuration and Key Vault references
Objectives
- Store and access secrets with managed identities and Key Vault
- Protect Key Vault against deletion and unauthorized use
- Separate configuration from secrets using App Configuration
Key concepts
- secrets, keys and certificates
- RBAC vs access policies
- soft delete and purge protection
- managed HSM
- key rotation
- App Configuration
Microsoft Defender for Cloud
Cloud security posture management, secure score and recommendations, regulatory compliance, Defender plans for servers, storage, SQL and containers, just-in-time VM access, adaptive hardening, alerts, workflow automation and multicloud connectors
Objectives
- Improve security posture using recommendations and secure score
- Enable the right Defender plans for the workload types in a subscription
- Automate response to alerts and recommendations
Key concepts
- secure score
- CSPM vs CWPP
- Defender plans
- just-in-time access
- regulatory compliance
- workflow automation
Microsoft Sentinel & Defender XDR
Microsoft Sentinel workspaces, data connectors, analytics rules, incidents, automation rules and playbooks, hunting and workbooks, UEBA, Defender XDR (endpoint, identity, email, cloud apps) and security operations workflows
Objectives
- Onboard data sources and build analytics rules in Sentinel
- Automate incident response with playbooks
- Explain how Defender XDR correlates signals across workloads
Key concepts
- data connectors
- analytics rules
- incidents and playbooks
- threat hunting with KQL
- Defender XDR
- UEBA
Compliance, Privacy & Microsoft Purview
Service Trust Portal, Microsoft privacy principles, Compliance Manager, sensitivity labels, DLP, retention and records management, Data Map and Unified Catalog, insider risk management, eDiscovery and audit
Objectives
- Describe Microsoft's compliance offerings and privacy principles
- Pick the Purview capability that protects or governs a given data scenario
- Explain the roles of eDiscovery, audit and insider risk
Key concepts
- Service Trust Portal
- Compliance Manager
- sensitivity labels
- DLP
- retention and records
- insider risk, eDiscovery and audit
Securing Compute, Storage & Databases
Advanced compute security: Azure Disk Encryption, confidential computing, trusted launch, AKS and container security; storage security (Defender for Storage, encryption scopes, immutability) and Azure SQL security (TDE, Always Encrypted, dynamic data masking, auditing, Entra authentication)
Objectives
- Choose the encryption layer (platform, CMK, ADE, Always Encrypted) for a requirement
- Harden VMs and containers with platform security features
- Secure Azure SQL data and monitor access
Key concepts
- Azure Disk Encryption
- confidential computing and trusted launch
- AKS security
- Defender for Storage
- TDE and Always Encrypted
- SQL auditing and masking
Trust, Privacy, Sovereign Clouds & Security Foundations
Microsoft Trust Center, Privacy Statement and compliance documentation, GDPR and data protection commitments, Azure Government and Azure China (21Vianet) sovereign clouds and their eligibility, the shared responsibility model for security, the Cloud Adoption Framework phases, authentication versus authorization, and identity as a managed SaaS service
Objectives
- Find the right Microsoft document or portal for privacy and compliance questions
- Decide when Azure Government or another sovereign cloud is the appropriate choice
- Describe the Cloud Adoption Framework phases and the shared responsibility split for security
Key concepts
- Microsoft Trust Center and Privacy Statement
- GDPR commitments
- Azure Government eligibility
- Azure China 21Vianet
- Cloud Adoption Framework phases
- authentication vs authorization
Governance Operations: Blueprints, Locks, Moves & Policy Remediation
Azure Blueprints and blueprint assignments, resource locks (CanNotDelete and ReadOnly), moving resources between resource groups and subscriptions, subscription ownership transfer, deployment history and exporting the deployed template, Azure Policy compliance evaluation and the managed identity used by remediation tasks, and tag-based governance operations
Objectives
- Package policies, roles and templates in a blueprint and assign it to subscriptions
- Choose the right lock and explain how it overrides Owner permissions
- Move resources or transfer a subscription and name the constraints that apply
Key concepts
- Azure Blueprints
- resource locks CanNotDelete and ReadOnly
- move resources between subscriptions
- subscription ownership transfer
- deployment history and template export
- Azure Policy remediation identity
Microsoft Defender XDR, Endpoint & Microsoft 365 Secure Score
Microsoft Defender XDR portal incidents and advanced hunting, Defender for Endpoint (supported platforms, network protection), Defender for Identity, Defender for Office 365, Defender for Cloud Apps (cloud app security), Microsoft 365 Secure Score versus the Defender for Cloud secure score, Intune device management and security baselines, and Sentinel integration with Defender XDR
Objectives
- Distinguish what each Defender product protects and which signals feed the Defender XDR portal
- Use incidents and advanced hunting to investigate across endpoints, identities and email
- Compare Microsoft 365 Secure Score with the Defender for Cloud secure score
Key concepts
- Defender XDR incidents
- advanced hunting
- Defender for Endpoint platforms
- Defender for Cloud Apps
- Microsoft 365 Secure Score
- Intune and security baselines
Microsoft Purview Audit, eDiscovery & Insider Risk
Microsoft Purview Audit (Standard and Premium/Advanced Audit, audit retention), eDiscovery (Standard and Premium), Insider Risk Management policies, alerts and case workflow, communication compliance, information barriers, and Customer Lockbox for controlled Microsoft engineer access
Objectives
- Select the Purview capability for an audit, legal discovery or insider threat requirement
- Describe the insider risk workflow from policy to alert to case
- Explain what information barriers and Customer Lockbox restrict
Key concepts
- Purview Audit and Advanced Audit
- audit log retention
- eDiscovery cases and holds
- Insider Risk Management
- information barriers
- Customer Lockbox
Information Protection, DLP & Compliance Manager
Microsoft Purview portal as the hub for data protection and governance, Compliance Manager score, improvement actions and action types (preventive, detective, corrective), sensitivity labels and their actions, trainable and pre-trained classifiers, data loss prevention including Endpoint DLP platform support, and retention policies and labels that preserve deleted content
Objectives
- Read a Compliance Manager score and classify improvement actions by type
- Apply sensitivity labels, DLP and retention to protect and keep data
- Choose between labels, classifiers and DLP policies for a data-protection need
Key concepts
- Compliance Manager score and actions
- sensitivity labels and label actions
- trainable and pre-trained classifiers
- data loss prevention and Endpoint DLP
- retention policies and labels
- Purview portal
Azure Monitor Logging: Agents, DCRs, Diagnostics & Workspace Design
Azure Monitor agent and legacy Log Analytics (MMA) agent deployment, data collection rules and endpoints, diagnostic settings to Log Analytics, storage and Event Hubs, Activity Log for control-plane and ARM deployment events, Network Watcher flow logs, workspace design and access, retention, pricing tiers, tables such as Event and Syslog, monitoring solutions scope, ITSM connector and synthetic availability tests
Objectives
- Collect VM and platform logs with the Azure Monitor agent and diagnostic settings
- Design workspaces for access, retention and cost
- Choose Activity Log, diagnostic logs or Network Watcher logs for an audit question
Key concepts
- Azure Monitor agent and DCR
- diagnostic settings destinations
- Activity Log
- Log Analytics workspace design
- retention and pricing tiers
- Event and Syslog tables
Fabric Governance: Domains, Endorsement, OneLake Catalog, Impact Analysis, Scanner APIs, Service Principal Settings & Workspace Monitoring
Fabric domains for federated governance, endorsement levels (Promoted, Certified, Master data) and who can set them, the OneLake catalog for discovery and governance insights, lineage impact analysis of downstream items, Power BI admin scanner APIs (getInfo, scanStatus, scanResult) for tenant metadata scanning, tenant settings that let service principals call Fabric and admin APIs, and workspace monitoring that logs workspace activity into an Eventhouse
Objectives
- Organize workspaces into domains with delegated administration
- Promote trusted content with endorsement and discoverability
- Scan metadata, assess impact and monitor workspace activity
Key concepts
- Fabric domains
- endorsement Promoted Certified
- master data endorsement
- OneLake catalog
- impact analysis
- scanner admin APIs
- service principal tenant settings
- workspace monitoring
Fabric Network & Item Security: Workspace Private Link, Trusted Workspace Access, Build Permission & Item Sharing
Workspace-level private link that restricts inbound access for chosen workspaces, trusted workspace access using workspace identity and resource instance rules on a firewalled ADLS Gen2 account, Build permission on a shared semantic model, and item sharing permissions for lakehouses and warehouses (Read, ReadData for T-SQL only, ReadAll for OneLake and Spark access)
Objectives
- Protect a single workspace with private link without changing the whole tenant
- Let Fabric reach a firewalled storage account without opening it publicly
- Grant the narrowest item permission for T-SQL-only or report-building users
Key concepts
- workspace-level private link
- tenant-level private link
- trusted workspace access
- workspace identity
- resource instance rule
- Build permission
- ReadData vs ReadAll
- item sharing
Application Insights Usage Analytics & Operations: Funnels, Retention, User Flows, Workbooks, Daily Cap, Release Annotations & ITSM Alerts
Usage analysis tools in Application Insights (users, sessions, events, funnels, retention, user flows, cohorts), Azure Workbooks that combine text, KQL queries and parameters, the daily volume cap on the Log Analytics workspace and what happens when it is reached, release annotations that mark deployments on charts, and creating ITSM work items from alerts
Objectives
- Choose the usage analysis tool that answers a product question
- Build shareable Workbooks and control ingestion cost with a daily cap
- Mark releases on charts and route alerts into an ITSM tool
Key concepts
- funnels
- retention
- user flows
- cohorts
- custom events
- Azure Workbooks
- daily cap
- release annotations
- ITSM connector
- KQL
Azure Monitor Platform Design: Managed Prometheus & Grafana, Network Watcher Flow Logs, Traffic Analytics, Connection Monitor, Entra Connect Health & Event Log Collection
Azure Monitor managed service for Prometheus with an Azure Monitor workspace, PromQL and Azure Managed Grafana for Kubernetes and application metrics, Network Watcher flow logs (NSG flow logs being retired in favor of virtual network flow logs) with Traffic Analytics, Connection Monitor for end-to-end connectivity and latency tests, Microsoft Entra Connect Health agents for sync and AD FS monitoring, and collecting Windows event logs and syslog with Azure Monitor Agent and data collection rules
Objectives
- Choose the monitoring service for metrics, network and identity health requirements
- Collect event logs and flow logs into Log Analytics with the supported agents and settings
- Design observability for Kubernetes with managed Prometheus and Grafana
Key concepts
- managed Prometheus
- Azure Monitor workspace
- Azure Managed Grafana
- virtual network flow logs
- Traffic Analytics
- Connection Monitor
- Entra Connect Health
- Azure Monitor Agent
- data collection rule
- Windows event log XPath
7 · DevOps & Infrastructure as Code21 topics
Infrastructure as Code: ARM Templates & Bicep
ARM template structure, Bicep syntax, parameters, variables and modules, deployment scopes, what-if, incremental versus complete mode, template specs, deployment stacks, exporting templates and IaC in pipelines (including Terraform awareness)
Objectives
- Author a parameterized Bicep module and deploy it at the right scope
- Preview and validate changes safely with what-if
- Choose between ARM, Bicep and Terraform for a team
Key concepts
- Bicep syntax and modules
- ARM template structure
- deployment scopes
- what-if
- incremental vs complete mode
- template specs and deployment stacks
DevOps Planning, Traceability & Metrics
Azure Boards and GitHub Projects, work item linking and traceability, flow of work (cycle time, lead time, WIP), DORA metrics, dashboards and queries, wikis, release notes, and team collaboration integrations such as Teams and Slack
Objectives
- Link work items to commits, builds and releases for end-to-end traceability
- Choose DevOps metrics that expose bottlenecks
- Configure dashboards and notifications for team awareness
Key concepts
- work item traceability
- cycle time and lead time
- DORA metrics
- Boards queries and dashboards
- wikis and documentation
- ChatOps integrations
Source Control: Branching & Repositories
Git branching strategies (trunk-based, GitHub flow, feature and release branches), branch policies and protection, pull request workflows, code owners, repository organization, Git LFS, large repository strategies, permissions and tags
Objectives
- Select a branching strategy for a team size and release cadence
- Enforce quality gates with branch policies and required reviewers
- Manage large files and repositories effectively
Key concepts
- trunk-based vs GitFlow
- branch policies
- pull request workflow
- Git LFS
- monorepo vs multi-repo
- repository permissions
Build Pipelines, Packages & Testing
YAML pipelines in Azure Pipelines and GitHub Actions, agents (Microsoft-hosted, self-hosted, scale set), templates, variables and variable groups, caching, Azure Artifacts package feeds and versioning, test strategy and pipeline health
Objectives
- Create reusable YAML templates for CI across repositories
- Pick agent types and tune pipeline speed
- Manage package versions and feeds with upstream sources
Key concepts
- YAML pipelines
- agents and pools
- pipeline templates
- Azure Artifacts feeds
- test pyramid in pipelines
- pipeline caching and health
Release & Deployment Strategies
Environments, approvals and checks, deployment gates, blue-green, canary, ring and progressive exposure deployments, feature flags, rolling updates, slots, deploying containers and IaC, hotfixes and rollback
Objectives
- Select a deployment pattern that matches risk tolerance
- Add approvals, checks and gates to protect production
- Design a rollback and hotfix procedure
Key concepts
- blue-green and canary
- ring deployments
- feature flags
- approvals and gates
- environments
- rollback strategies
DevSecOps: Pipeline Security & Compliance
Service connections and workload identity federation, managed identities for pipelines, Key Vault integration and secret scanning, GitHub Advanced Security and Defender for DevOps, SAST, SCA and dependency scanning, container image scanning and compliance gates
Objectives
- Remove stored secrets from pipelines using federation and Key Vault
- Add automated security and license scanning to CI/CD
- Design least-privilege access for pipelines
Key concepts
- workload identity federation
- service connections
- secret scanning
- SAST and SCA
- Dependabot and dependency review
- compliance gates
Git Advanced Operations & Version Control Choices
Git history rewriting and removing large files with BFG or filter-branch, git gc and prune maintenance, tags, .gitignore, importing repositories, external Git service connections, choosing between Git and TFVC, and choosing among Azure Repos, GitHub Enterprise, Bitbucket and Subversion, with Jenkins integration against Azure Repos
Objectives
- Purge large or sensitive files from Git history and maintain repository health
- Choose Git or TFVC and the right hosting service for a team's needs
- Import repositories and connect external Git services to pipelines
Key concepts
- BFG and filter-branch
- git gc and prune
- git tag
- gitignore
- Git vs TFVC
- choosing a version control host
Azure DevOps Organization Security & Administration
Azure DevOps users, licenses and access levels, security groups and least privilege, personal access token (PAT) authentication for third-party tools, wiki and dashboard permissions, agent pool roles, Continuous Assurance and project configuration drift, Dependency Tracker, GitHub App authentication for Azure Pipelines and Azure Boards, and monitoring tool categories
Objectives
- Grant least-privilege access and the right license level in Azure DevOps
- Authenticate external tools with PATs or GitHub Apps and manage their risk
- Control permissions for wikis, dashboards and agent pools
Key concepts
- users, licenses and access levels
- security groups and permissions
- personal access tokens
- agent pool roles
- GitHub App authentication
- Continuous Assurance
Azure DevOps Integrations: Service Hooks, Teams, Jenkins & Migration
Service hooks and notifications, Microsoft Teams integration with Azure Pipelines and Azure Boards, Logic Apps notifications, Jenkins and Octopus integration, mapping Azure DevOps services to Jira and other tools, TFS to Azure DevOps migration with the Database Import Service, GitHub notifications and the Log Analytics ITSM connector
Objectives
- Connect Azure DevOps events to chat, ticketing and CI tools
- Choose between notifications and service hooks
- Plan a TFS to Azure DevOps Services migration
Key concepts
- service hooks
- Azure Pipelines app for Teams
- Azure Boards and Teams
- Jenkins integration
- TFS Database Import Service
- ITSM connector
Visual Studio App Center: Mobile Distribution, Crash Reporting & Feedback
App Center build, test and distribute for mobile apps, distribution groups, iOS ad hoc distribution and signing certificates and provisioning, App Center SDK initialization, crash reporting and analytics, and in-app feedback tooling
Objectives
- Distribute beta builds to testers through distribution groups
- Set up signing and provisioning for iOS releases
- Collect crash and usage data with the App Center SDK
Key concepts
- distribution groups
- iOS ad hoc distribution
- signing certificates
- SDK initialization
- crash reporting
- beta release
Deployment Groups, Release Retention & DevTest Environments
Deployment groups and target agents for VMs, deployment queue settings, release retention policies, Azure DevTest Labs VM templates, artifacts and auto-shutdown, GitHub Codespaces development environments, and App Service backup and app settings
Objectives
- Deploy to groups of VMs with deployment groups and tags
- Configure release retention and queueing behavior
- Provide repeatable dev and test environments
Key concepts
- deployment groups
- deployment queue settings
- release retention
- DevTest Labs artifacts
- Codespaces
- App Service app settings and backup
Azure Automation: DSC, Update Management & Config Tooling
Azure Automation State Configuration (DSC) for Windows and Linux, automation account modules, Hybrid Runbook Worker, Update Management, Terraform tooling and testing frameworks such as Terratest and Yeoman, and Logic Apps Designer workflow automation
Objectives
- Enforce desired state on servers with Azure Automation DSC
- Patch servers at scale with Update Management
- Choose infrastructure testing and scaffolding tools
Key concepts
- Automation State Configuration DSC
- automation account modules
- Hybrid Runbook Worker
- Update Management
- Terratest and Yeoman
- DSC on Linux
Agile Practices, Test Plans & Technical Debt
Agile retrospectives, technical debt and how to measure and reduce it, test plans and test case association with work items, and quality metrics used to steer delivery
Objectives
- Run a retrospective that produces actionable improvements
- Measure and reduce technical debt
- Link test cases to work items and plans
Key concepts
- retrospectives
- technical debt metrics
- test plans and test cases
- work item association
- quality metrics
- reducing technical debt
IaC Governance & Inventory: Template Specs, Deployment Stacks, Azure Resource Graph, Bicep Linter, Image Builder & Compute Gallery
Template specs as versioned, RBAC-controlled templates, deployment stacks with deny settings and actionOnUnmanage to manage resource lifecycle, Azure Resource Graph KQL queries for inventory across subscriptions, Bicep linter rules configured in bicepconfig.json, and Azure VM Image Builder publishing versions to Azure Compute Gallery
Objectives
- Share approved templates and protect deployed resources with deployment stacks
- Query inventory across subscriptions with Resource Graph
- Enforce Bicep standards with the linter and build golden images with Image Builder
Key concepts
- template specs
- deployment stacks
- denyWriteAndDelete
- actionOnUnmanage
- Azure Resource Graph
- Search-AzGraph
- bicepconfig.json
- linter rules
- VM Image Builder
- Azure Compute Gallery
Azure Boards & Work Tracking: Inherited Processes, Kanban WIP Limits and Cumulative Flow, Sprint Capacity, Dependencies & Tool Migration Mapping
Customizing an inherited process in Azure Boards (custom fields, work item types, states and rules) versus the system processes, Kanban column WIP limits and the cumulative flow diagram for finding bottlenecks, sprint capacity planning with activity and days off, cross-team dependencies with Delivery Plans and dependency tracking extensions, and mapping Jira, Jenkins and Octopus Deploy to Azure Boards and Azure Pipelines
Objectives
- Customize work tracking with an inherited process without modifying system processes
- Use WIP limits and the cumulative flow diagram to find bottlenecks and plan sprint capacity
- Map tools such as Jira, Jenkins and Octopus Deploy to their Azure DevOps equivalents
Key concepts
- inherited process
- custom work item type
- Kanban WIP limit
- cumulative flow diagram
- cycle time and lead time
- sprint capacity
- Delivery Plans
- Dependency Tracker
- Jira to Azure Boards
- Jenkins to Azure Pipelines
Git Operations & Source Control Choices: Submodules, Reverting Merges, Cherry-Pick, Restoring Branches, Commit Signing, Importing Repositories & Hosting Options
Git submodules and how they pin a commit, reverting a merge commit with the mainline parent (-m 1) and re-merging afterwards, cherry-picking commits across branches, restoring a deleted Azure Repos branch, signed commits with GPG or SSH keys and verification, importing a Git repository into Azure Repos, and choosing between Git, Subversion, Bitbucket, GitHub Enterprise Server and other hosting for on-premises source
Objectives
- Undo a merge and move commits between branches correctly
- Recover deleted branches and sign commits to prove authorship
- Import repositories and select a source control platform for on-premises or cloud needs
Key concepts
- git submodule
- git revert -m 1
- revert of a revert
- cherry-pick
- deleted branches in Azure Repos
- GPG commit signing
- import repository
- GitHub Enterprise Server
- Subversion vs Git
- Bitbucket
GitHub Collaboration & Delivery Settings: Notifications, Subscriptions, Generated Release Notes, GitHub Packages with GITHUB_TOKEN & Artifact Retention
GitHub notification settings (participating and watching, email routing per organization), watching and unsubscribing from repositories and threads, automatically generated release notes grouped by labels with .github/release.yml, publishing packages and container images to GitHub Packages using the workflow GITHUB_TOKEN with packages: write, and workflow artifact retention days
Objectives
- Control notification volume with the right watch and routing settings
- Generate categorized release notes from pull requests and labels
- Publish to GitHub Packages from a workflow with least-privilege token permissions and manage artifact retention
Key concepts
- notification settings
- watching a repository
- participating notifications
- automatically generated release notes
- .github/release.yml
- GitHub Packages
- GITHUB_TOKEN packages write
- ghcr.io
- artifact retention-days
GitHub Actions in Practice: Step Conditions, Service Containers, Re-running Jobs, Actions Runner Controller, Actions Importer & Static Web Apps Previews
Conditional steps and jobs with if expressions and status functions (success, failure, always, cancelled), service containers for databases in tests, re-running failed jobs without repeating successful ones, Actions Runner Controller for autoscaled self-hosted runners on Kubernetes, GitHub Actions Importer to audit, forecast and migrate Jenkins and other CI pipelines, and Azure Static Web Apps pull request preview environments
Objectives
- Write conditional workflow logic that runs cleanup and notification steps correctly
- Run integration tests against service containers and re-run only failed jobs
- Scale self-hosted runners with ARC and migrate other CI systems with Actions Importer
Key concepts
- if conditions
- success(), failure() and always()
- service containers
- re-run failed jobs
- Actions Runner Controller
- runner scale sets
- GitHub Actions Importer
- audit and dry-run
- Static Web Apps preview environment
- closed pull request cleanup
Pipeline Secrets & Supply Chain Controls: Secret Variables, Log Masking, Secure Files, GITHUB_TOKEN Permissions, Environment Secrets, Decorators & Required Templates
Mapping secret pipeline variables into script environments, masking runtime-generated secrets in logs (issecret and add-mask), secure files in Azure Pipelines, least-privilege GITHUB_TOKEN permissions, GitHub environment secrets with required reviewers, pipeline decorators that inject steps into every pipeline, extends templates enforced with the required template check, and the retirement of Continuous Assurance tooling in favor of Defender for Cloud
Objectives
- Handle secrets in pipelines without leaking them in logs
- Restrict token permissions and scope secrets to protected environments
- Enforce organization-wide pipeline standards with decorators and required templates
Key concepts
- secret variables and env mapping
- issecret
- add-mask
- secure files
- permissions: contents read
- GITHUB_TOKEN least privilege
- environment secrets
- pipeline decorators
- extends template
- required template check
- Defender for Cloud DevOps security
Pipeline Quality Gates & Diagnostics: Flaky Tests, Test Impact Analysis, Load Testing Gate & Verbose Diagnostics
Detecting and managing flaky tests with rerun-failed-tests settings, test impact analysis that runs only tests affected by a code change, an Azure Load Testing task as a pipeline quality gate with failure criteria, and verbose diagnostics with System.Debug in Azure Pipelines and step debug logging in GitHub Actions
Objectives
- Reduce noise from flaky tests without hiding real failures
- Speed up builds with test impact analysis and gate releases on load test results
- Turn on verbose diagnostics to troubleshoot a failing pipeline
Key concepts
- flaky test detection
- rerunFailedTests
- test impact analysis
- runOnlyImpactedTests
- Azure Load Testing task
- failure criteria
- System.Debug
- ACTIONS_STEP_DEBUG
Database & App Service Deployment: DACPAC vs BACPAC, Deployment Job Hooks, Application Settings, Scheduled Backups & Database Firewall Rules
Deploying schema changes with a DACPAC and the SQL Azure DACPAC task versus exporting schema and data in a BACPAC, YAML deployment job lifecycle hooks (preDeploy, deploy, routeTraffic, postRouteTraffic, on failure and success), setting App Service application settings from a pipeline, configuring scheduled App Service backups, and opening Azure Database for MySQL firewall rules for pipeline agents
Objectives
- Choose DACPAC or BACPAC for schema deployment versus data movement
- Use deployment strategy hooks for verification and rollback
- Configure application settings, backups and database firewall access for deployments
Key concepts
- DACPAC
- SqlAzureDacpacDeployment
- BACPAC
- deployment job hooks
- routeTraffic
- on failure
- AzureAppServiceSettings
- slot settings
- scheduled backup
- MySQL firewall rule
8 · Integration & Solution Architecture7 topics
Azure API Management
API Management tiers and gateway, products, subscriptions and keys, policies (rate limit, transform, validate-jwt, caching), versions and revisions, OAuth 2.0 protection, developer portal and self-hosted gateway
Objectives
- Publish and protect an API with products, policies and OAuth
- Write policies that transform, cache or throttle requests
- Explain API versions versus revisions
Key concepts
- gateway, products and subscriptions
- policy expressions
- rate limiting and quotas
- versions vs revisions
- validate-jwt
- developer portal
Event-Driven & Message-Based Solutions
Event Grid topics, subscriptions and filters, Event Hubs partitions and consumer groups, Service Bus queues, topics and sessions, dead-lettering, Azure Queue Storage, delivery guarantees, and choosing between events and messages
Objectives
- Pick the right messaging or eventing service for a scenario
- Handle poison messages and retries with dead-lettering
- Design ordered, scalable event processing with partitions
Key concepts
- Event Grid vs Event Hubs vs Service Bus
- partitions and consumer groups
- queues and topics
- dead-letter queue
- message sessions and ordering
- at-least-once delivery
Solution Architecture, Data Integration & Migration
Well-Architected Framework pillars, choosing compute and application architectures (microservices, event-driven, serverless), data integration choices, Azure Migrate, Database Migration Service, Data Box, Storage Mover, landing zones and the 6 Rs of migration
Objectives
- Choose compute and application architecture against nonfunctional requirements
- Plan a migration with assessment, replication and cutover
- Balance cost, reliability, security and performance trade-offs
Key concepts
- Well-Architected pillars
- compute option selection
- microservices vs serverless
- Azure Migrate
- Database Migration Service
- landing zones
API Management Policies & Messaging Security
API Management Premium with VNet for private ingress, rate limiting and external OAuth authorization, exposing APIs to partners and importing OpenAPI definitions with PowerShell, Event Grid webhook delivery security and endpoint validation, Service Bus subscription filters (SQL, correlation, boolean) and asynchronous messaging, and Event Hubs capture with Functions
Objectives
- Expose APIs to partners with throttling and external OAuth without changing backends
- Secure Event Grid webhook delivery and validate subscriptions
- Route Service Bus messages with the right subscription filter
Key concepts
- APIM Premium VNet mode
- rate-limit and OAuth validation policies
- OpenAPI import
- Event Grid webhook validation
- Service Bus subscription filters
- Event Hubs capture
Event Hubs & Event Grid for Developers: Batching, Checkpointing, Capture, Kafka Endpoint, Input Schemas & Retry Policy
Sending events in batches with EventDataBatch, the event processor and blob checkpoint store for at-least-once processing across partitions, Event Hubs Capture to Blob or Data Lake in Avro, the Kafka-compatible endpoint on port 9093, Event Grid schemas (Event Grid, CloudEvents 1.0 and custom input schema) and subscription retry policy (maximum delivery attempts, event time-to-live) with dead-lettering
Objectives
- Send and process Event Hubs events efficiently with batching and checkpoints
- Archive streams with Capture and connect Kafka clients without code changes
- Pick an Event Grid schema and tune retry and dead-letter behavior
Key concepts
- EventDataBatch
- event processor
- checkpoint store
- UpdateCheckpointAsync
- Event Hubs Capture
- Avro
- Kafka endpoint port 9093
- CloudEvents schema
- maximum delivery attempts
- event time to live
- dead-letter destination
Service Bus Message Patterns: Defer, Duplicate Detection, Scheduled Messages, Auto-Forwarding & Claim-Check
Deferring messages and retrieving them by sequence number, duplicate detection with MessageId and a history time window set at creation, scheduled messages with ScheduledEnqueueTimeUtc and cancellation, auto-forwarding from a queue or subscription to another entity, sessions for ordered processing, dead-lettering and the claim-check pattern that stores large payloads in Blob storage
Objectives
- Choose the Service Bus feature for out-of-order, deduplicated, delayed or fan-in messaging
- Configure duplicate detection correctly at creation
- Handle large payloads with the claim-check pattern
Key concepts
- defer message
- SequenceNumber
- duplicate detection
- MessageId
- duplicate detection history
- ScheduledEnqueueTimeUtc
- auto-forwarding
- sessions
- dead-letter queue
- claim-check pattern
Geo-DR for Messaging & Network Protection: Event Hubs Geo-Replication, Service Bus Geo-DR, AVNM Security Admin Rules & DDoS Protection Tiers
Event Hubs geo-replication and geo-disaster recovery pairing, Service Bus geo-disaster recovery with an alias that replicates metadata only and requires manual failover, Azure Virtual Network Manager security admin rules that take precedence over NSG rules across subscriptions, and DDoS Network Protection versus DDoS IP Protection
Objectives
- Choose the right geo-DR mechanism for Event Hubs and Service Bus and state what it replicates
- Enforce organization-wide network rules with AVNM security admin rules
- Select the DDoS protection tier for a mix of virtual networks and public IPs
Key concepts
- Event Hubs geo-replication
- geo-disaster recovery alias
- metadata-only replication
- manual failover
- Azure Virtual Network Manager
- security admin rules
- DDoS Network Protection
- DDoS IP Protection
- DDoS rapid response
- cost protection
9 · Hybrid & Windows Server14 topics
AD DS, Group Policy & Hybrid Identity
AD DS domain controller deployment, sites, replication, forests, domains and trusts, FSMO roles, users, groups and OUs, service accounts (gMSA), Group Policy processing, Microsoft Entra Connect and Cloud Sync, password hash sync, pass-through authentication, federation, seamless SSO and Entra Domain Services
Objectives
- Deploy and troubleshoot domain controllers in single and multi-site environments
- Choose password hash sync, pass-through authentication or federation for hybrid sign-in
- Apply Group Policy with correct scope, inheritance and precedence
Key concepts
- domain controllers and replication
- sites and subnets
- forest and domain trusts
- FSMO roles
- Group Policy processing
- Entra Connect sync methods
Hybrid Windows Server Management
Windows Admin Center, PowerShell remoting, Azure Arc-enabled servers, Azure Automation and Update Manager, Azure Monitor agent, Defender for Servers, Azure Policy guest configuration, Azure Hybrid Benefit and Windows Server VMs on Azure
Objectives
- Onboard on-premises servers to Azure Arc and manage them with Azure services
- Patch and monitor hybrid servers at scale
- Configure remote management securely
Key concepts
- Windows Admin Center
- PowerShell remoting
- Azure Arc-enabled servers
- Update Manager
- guest configuration
- Azure Hybrid Benefit
Hyper-V & Windows Containers
Hyper-V host and guest configuration, generation 1 versus 2 VMs, virtual switches, checkpoints, live migration, Hyper-V Replica, nested virtualization, Windows containers, Docker on Windows Server, container networking and storage
Objectives
- Configure Hyper-V hosts, guests and virtual networking
- Move and protect VMs with live migration and Hyper-V Replica
- Run and network Windows containers
Key concepts
- generation 1 vs 2
- virtual switch types
- live migration
- Hyper-V Replica
- Windows containers and Docker
- container networking
Windows Server DNS, DHCP & IPAM
Windows Server DNS zones and records, forwarders and conditional forwarders, DNS policies, DHCP scopes, failover, and relays, IPAM, Azure DNS Private Resolver, Azure Extended Network, hybrid name resolution and connectivity (VPN, ExpressRoute, Azure Network Adapter)
Objectives
- Design hybrid DNS so on-premises and Azure resources resolve each other
- Configure DHCP scopes with high availability
- Plan IP address management across on-premises and Azure
Key concepts
- DNS zones and forwarders
- DHCP scopes and failover
- IPAM
- conditional forwarders
- DNS Private Resolver
- Azure Network Adapter
Windows Server Storage & File Services
Storage Spaces and Storage Spaces Direct, ReFS and NTFS, deduplication, iSCSI, SMB shares and permissions, DFS namespaces and replication, FSRM, Storage Replica, Storage Migration Service and Azure File Sync and Azure Files for hybrid files
Objectives
- Configure resilient Windows Server storage and file shares
- Extend file servers to the cloud with Azure File Sync
- Migrate file servers with Storage Migration Service
Key concepts
- Storage Spaces
- SMB shares and NTFS permissions
- DFS namespaces and replication
- data deduplication
- Storage Replica
- Azure File Sync and cloud tiering
Active Directory Groups, Delegation & Forest Operations
Active Directory group scopes (domain local, global, universal) and nesting rules within and across forest trusts, group strategy (AGDLP), delegation of control and built-in administrative groups, delegation groups in Microsoft Entra Domain Services (GPO and DNS administration), read-only domain controllers and the filtered attribute set, application directory partitions with ntdsutil, Backup Operators scope and permissions for site link changes
Objectives
- Choose a group scope and nesting design that works across domains and forests
- Delegate administrative tasks with least privilege instead of adding to built-in groups
- Configure RODC and directory partitions for branch and application needs
Key concepts
- group scopes and nesting rules
- AGDLP strategy
- delegation of control
- RODC filtered attribute set
- application directory partitions
- Entra Domain Services delegation groups
Windows Server: gMSA, Storage Spaces Direct, Hyper-V & Hybrid Extras
Group managed service accounts (KDS root key, creation, installation and credential specs for Windows containers), Storage Spaces Direct cluster quorum and witness, RDMA and Data Center Bridging validation on Switch Embedded Teaming, Hyper-V checkpoint types and nested virtualization, AKS on Azure Stack HCI, File Server Resource Manager file screens, DNSSEC trust anchors, Azure Network Adapter, Azure Automation Hybrid Runbook Worker and Serial Console prerequisites
Objectives
- Create and use a gMSA for services and Windows containers
- Design quorum and networking for a Storage Spaces Direct cluster
- Pick Hyper-V checkpoint and hybrid management features for a server scenario
Key concepts
- gMSA and KDS root key
- credential spec for containers
- S2D quorum and witness
- RDMA and DCB on SET
- Hyper-V checkpoints and nested virtualization
- FSRM file screens
Microsoft Entra Domain Services (Azure AD DS): Managed Domain, Password Policy, Delegated Administration & Least Privilege
Microsoft Entra Domain Services (formerly Azure AD Domain Services) as a managed domain: no domain controller or Domain Admin access, one-way sync from Microsoft Entra ID, password hash synchronization so cloud-only users must reset passwords to create NTLM and Kerberos hashes, the AAD DC Administrators group, custom OUs with delegated control, fine-grained password policies, built-in Group Policy objects (AADDC Users and AADDC Computers), secure LDAP, replica sets and joining Azure VMs to the managed domain
Objectives
- Explain what Microsoft Entra Domain Services manages and which AD DS operations it does not allow
- Apply a password policy and delegate administration with least privilege
- Join Azure VMs to the managed domain and troubleshoot sign-in for cloud-only users
Key concepts
- managed domain
- AAD DC Administrators
- password hash sync for cloud-only users
- fine-grained password policy
- custom OU delegation
- AADDC Users and AADDC Computers GPOs
- secure LDAP
- replica sets
AD DS Domain Controller Operations: Adprep, Offline Join, DSRM Authoritative Restore, DC Cloning, SYSVOL DFSR Migration, DC Locator & Global Catalog Caching
Schema and forest preparation with adprep or the promotion wizard, offline domain join with djoin, Directory Services Restore Mode with non-authoritative and authoritative restore using ntdsutil, cloning virtualized domain controllers (Cloneable Domain Controllers group, VM-GenerationID, DCCloneConfig.xml), migrating SYSVOL replication from FRS to DFSR with dfsrmig, re-registering DC locator records with nltest /dsregdc and Netlogon, placing the AD DS database, logs and SYSVOL on an Azure data disk with host caching set to None, and universal group membership caching at sites without a global catalog
Objectives
- Prepare a forest and promote or clone domain controllers safely
- Recover deleted objects with an authoritative restore and repair SYSVOL replication and DC locator records
- Place the AD DS database correctly on an Azure VM and reduce global catalog dependency at branch sites
Key concepts
- adprep /forestprep
- djoin offline domain join
- DSRM
- authoritative restore
- ntdsutil
- DC cloning
- VM-GenerationID
- dfsrmig
- nltest /dsregdc
- data disk host caching None
- universal group membership caching
AD DS Accounts, Groups & Policy: Built-in Groups, Nesting Rules, Protected Users, Lockouts, redircmp, Windows LAPS, UPN Suffixes & ADMX Central Store
Built-in administrative groups and scope (Enterprise Admins, Schema Admins, Domain Admins, Backup Operators, Account Operators), group scope nesting rules and AGDLP, the Protected Users group protections, account lockout troubleshooting with event 4740 on the PDC emulator, redirecting the default computer container with redircmp, Windows LAPS schema extension and permissions, alternative UPN suffixes for hybrid sign-in, and the Group Policy ADMX central store in SYSVOL
Objectives
- Apply the right group scope and nesting for a permission model and know which built-in groups are privileged
- Harden privileged accounts with Protected Users and Windows LAPS
- Troubleshoot lockouts and standardize Group Policy templates and computer placement
Key concepts
- Backup Operators
- Enterprise Admins vs Domain Admins
- group nesting rules
- AGDLP
- Protected Users
- event 4740
- redircmp
- Update-LapsADSchema
- alternative UPN suffix
- ADMX central store
Windows Server Remote & Constrained Administration: sconfig, PowerShell Second Hop, JEA, PowerShell Direct & Azure Serial Console
Server Core configuration with sconfig, the PowerShell remoting second-hop problem and its solutions (resource-based Kerberos constrained delegation, avoiding CredSSP), Just Enough Administration endpoints with session configuration and role capability files, PowerShell Direct from a Hyper-V host to a guest without networking, and the Azure Serial Console for Windows VMs (boot diagnostics, SAC and required roles)
Objectives
- Configure and manage Server Core with sconfig and remoting
- Constrain administrators to approved tasks with JEA and solve second-hop authentication
- Reach a VM that has lost networking using PowerShell Direct or the Azure Serial Console
Key concepts
- sconfig
- second-hop problem
- resource-based constrained delegation
- CredSSP risks
- Just Enough Administration
- role capability file
- PowerShell Direct
- Azure Serial Console
- boot diagnostics
Windows Server DNS Security & Remote Access: DNSSEC Trust Anchors, Aging & Scavenging, DNS Policies, NPS RADIUS & Always On VPN
DNSSEC zone signing and trust anchors on validating resolvers and clients (NRPT), DNS aging and scavenging with no-refresh and refresh intervals, DNS policies with zone scopes for split-brain, geo-location and time-of-day responses, Network Policy Server as a RADIUS server for VPN with network and connection request policies, and Always On VPN device and user tunnels deployed with ProfileXML
Objectives
- Validate DNSSEC and keep zones free of stale records
- Serve different answers by client subnet or location with DNS policies
- Authenticate VPN users with NPS and deploy Always On VPN profiles
Key concepts
- DNSSEC trust anchor
- NRPT
- aging and scavenging
- no-refresh and refresh interval
- DNS zone scopes
- query resolution policy
- NPS RADIUS
- network policy
- Always On VPN
- device tunnel and user tunnel
File Server Controls & Access: FSRM File Screens and Auto-Apply Quotas, Shadow Copies, SMB over QUIC & Azure Files Identity-Based Authentication
File Server Resource Manager active and passive file screens with file groups, auto apply quotas that cascade a template to existing and new subfolders, Shadow Copies of Shared Folders and previous versions, SMB over QUIC for access to file shares over the internet without a VPN, and Azure Files identity-based authentication with AD DS or Microsoft Entra (share-level Azure RBAC plus NTFS permissions)
Objectives
- Block file types and enforce folder quotas with FSRM
- Provide self-service file restore with shadow copies and remote access with SMB over QUIC
- Give domain users access to an Azure Files share using identity-based authentication
Key concepts
- FSRM file screen
- active vs passive screening
- auto apply quota
- Shadow Copies of Shared Folders
- SMB over QUIC
- Azure Files AD DS authentication
- Storage File Data SMB Share Contributor
- NTFS permissions on Azure Files
Disks & File Systems: GPT vs MBR, iSCSI Target Server, iSCSI MPIO, NTFS vs ReFS vs exFAT
Initializing disks as MBR or GPT (2 TB and four primary partition limits versus large disks and UEFI), the iSCSI Target Server role service with iSCSI virtual disks, targets and initiator access, Multipath I/O for iSCSI with multiple sessions and load balance policies, and choosing between NTFS, ReFS and exFAT
Objectives
- Choose MBR or GPT for a disk size and boot mode
- Present storage with iSCSI and make the connection resilient with MPIO
- Select NTFS, ReFS or exFAT for a workload
Key concepts
- MBR vs GPT
- 2 TB limit
- iSCSI Target Server
- iSCSI virtual disk
- initiator IQN
- Multipath I/O
- load balance policy
- NTFS
- ReFS
- exFAT
10 · AI Services & Machine Learning28 topics
AI Fundamentals & Responsible AI
AI workload types (machine learning, computer vision, NLP, generative AI, document intelligence), core machine learning concepts (regression, classification, clustering, training and inference), Azure AI services overview and the six responsible AI principles
Objectives
- Match an AI workload to the Azure service that supports it
- Explain core machine learning concepts and common model types
- Apply fairness, reliability, privacy, inclusiveness, transparency and accountability
Key concepts
- regression, classification, clustering
- training vs inference
- computer vision workloads
- NLP workloads
- generative AI workloads
- responsible AI principles
Microsoft Foundry: Plan, Deploy, Secure & Govern
Selecting Azure AI and Foundry services, creating resources and projects, model deployments and quotas, authentication with keys and Entra ID, network security, monitoring, cost control, content safety, and implementing AI responsibly
Objectives
- Choose the AI service and deployment type for a requirement
- Secure and monitor a Foundry resource
- Implement content filtering and responsible-AI safeguards
Key concepts
- Foundry resources and projects
- model deployments and quotas
- keys vs Entra authentication
- private endpoints for AI services
- Azure AI Content Safety
- diagnostics and cost
Generative AI, RAG & Model Optimization
Azure OpenAI models and deployments, tokens and parameters, prompt engineering, prompt flow, retrieval-augmented generation, grounding with your data, fine-tuning, evaluation, content filters, provisioned throughput, and operationalizing generative AI
Objectives
- Choose between prompt engineering, RAG and fine-tuning to improve model output
- Build a grounded chat solution and evaluate its quality
- Scale and operationalize a generative AI deployment with throttling and monitoring
Key concepts
- prompt engineering
- tokens and temperature
- RAG with Azure AI Search
- fine-tuning vs RAG
- evaluation and monitoring
- provisioned throughput
AI Agents & Orchestration
Agent concepts and use cases, Foundry Agent Service, tools and knowledge, Microsoft Agent Framework, multi-agent orchestration patterns, multiple users and autonomous capabilities, testing, optimizing and deploying agents
Objectives
- Decide whether a scenario needs an agent and which tools it requires
- Design a multi-agent workflow with orchestration and guardrails
- Test, evaluate and deploy an agent safely
Key concepts
- agent loop and tools
- Foundry Agent Service
- Microsoft Agent Framework
- multi-agent orchestration
- threads and state
- agent evaluation
Vision, Language & Speech Services
Azure AI Vision image analysis and OCR, custom vision models, video analysis, Azure AI Language (sentiment, entities, summarization, question answering, CLU), Translator, Speech to text and text to speech, and custom language models
Objectives
- Select the right vision or language service for a requirement
- Train and evaluate a custom classification or extraction model
- Build speech and translation features into an application
Key concepts
- image analysis and OCR
- custom vision models
- video indexing
- entity and sentiment analysis
- conversational language understanding
- speech and translation
Knowledge Mining & Information Extraction
Azure AI Search indexes, indexers, skillsets and enrichment, semantic ranking and vector search, hybrid queries, Azure Document Intelligence prebuilt and custom models, and Content Understanding for multimodal extraction
Objectives
- Design an AI Search index and enrichment pipeline
- Choose prebuilt versus custom Document Intelligence models
- Combine keyword, vector and semantic ranking for relevance
Key concepts
- indexes, indexers and skillsets
- semantic and vector search
- hybrid search
- Document Intelligence models
- Content Understanding
- knowledge store
Azure Machine Learning
Azure Machine Learning workspaces, compute targets, data assets and environments, automated ML, notebooks and jobs, hyperparameter sweeps, pipelines, MLflow tracking, model registry and managed online and batch endpoints
Objectives
- Set up a workspace, compute and assets for a training project
- Automate training, tuning and tracking with jobs, sweeps and MLflow
- Deploy and monitor a model to a managed endpoint
Key concepts
- workspace and compute
- data assets and environments
- AutoML
- sweep jobs
- pipelines and components
- online and batch endpoints
AI Model Components & Configurations
How AI models are built and configured: model families (language, multimodal, embedding, image, speech), large versus small language models, tokens and context windows, system and user prompts, inference parameters (temperature, top p, max tokens), embeddings, training data and inference, model catalog selection criteria and deployment options
Objectives
- Identify the components of an AI model deployment and what each configuration changes
- Tune inference parameters to trade creativity against determinism and cost
- Select a model type and size for a workload from the Foundry model catalog
Key concepts
- language, embedding and multimodal models
- tokens and context window
- temperature, top p and max tokens
- system prompt and user prompt
- small vs large language models
- model catalog and deployment options
Building Generative AI Apps & Agents in Foundry
Using the Foundry portal and playgrounds, deploying a model, calling it with the Foundry SDK and the chat completions or responses API, system prompts, grounding with your data, built-in tools such as file search and code interpreter, creating and testing a basic agent, evaluating output and applying content filters
Objectives
- Create a Foundry project, deploy a model and call it from application code
- Ground a chat app on your data and test it in the playground
- Build and test a basic agent with built-in tools
Key concepts
- Foundry projects and playgrounds
- deploy and call a model with the SDK
- chat completions and responses API
- grounding with your data
- basic agent with tools
- evaluate and filter output
Text and Speech Solutions in Foundry
Foundry Tools for language and speech: text analysis (sentiment, key phrases, entities, PII), summarization, translation, question answering, speech to text, text to speech with SSML, speech translation, real-time voice interaction, and calling these services from code with endpoints and credentials
Objectives
- Choose the language or speech capability that meets a text or audio requirement
- Call text and speech services from code using endpoint and credentials
- Combine speech and a generative model into a voice assistant
Key concepts
- sentiment, key phrases and entities
- PII detection and summarization
- text translation
- speech to text
- text to speech and SSML
- real-time voice and speech translation
Computer Vision & Image Generation in Foundry
Image analysis (captions, tags, object detection, people, OCR), multimodal models that reason over images, image generation and editing models with prompts, size and quality settings, video analysis, content safety for images, and responsible use of generated media
Objectives
- Pick between image analysis, a multimodal model and OCR for a vision requirement
- Write and tune a prompt to generate or edit an image with a Foundry model
- Apply safety filters and disclosure to generated images
Key concepts
- image analysis features
- OCR and read text
- multimodal image reasoning
- image generation prompts
- image editing and variations
- content safety for images
Information Extraction in Foundry
Extracting structured data from documents, images, audio and video with Azure Content Understanding and Document Intelligence: analyzers and field schemas, prebuilt versus custom extraction, confidence scores, multimodal inputs, and feeding extracted fields into downstream apps and search
Objectives
- Define an analyzer and field schema to extract structured output from content
- Choose prebuilt or custom extraction and interpret confidence scores
- Route extracted fields to a downstream app or index
Key concepts
- Content Understanding analyzers
- field schemas
- prebuilt vs custom extraction
- confidence scores
- multimodal extraction
- feeding extracted data downstream
ML Online Endpoints: Scoring Scripts, Probes & Responsible AI
Azure Machine Learning managed online endpoints versus Kubernetes endpoints, the scoring script init and run contract, loading the model in init, handling input skew, readiness and liveness probe timeout tuning, and responsible AI error analysis
Objectives
- Write a scoring script that loads the model once and scores requests
- Choose between managed and Kubernetes online endpoints
- Tune probes and analyze errors for responsible deployment
Key concepts
- scoring script init and run
- managed vs Kubernetes online endpoint
- probe timeout tuning
- input skew
- responsible AI error analysis
- model path in init
Bot Framework & Disconnected AI Containers
Azure Bot Service and Bot Framework conversation state persistence, channel configuration, and running Azure AI containers disconnected from the cloud with commitment tiers, including Content Safety containers
Objectives
- Persist bot conversation state in storage
- Connect a bot to channels
- Run AI containers in disconnected environments with commitment tiers
Key concepts
- conversation state persistence
- bot channels
- disconnected containers
- commitment tiers
- Content Safety container
- Bot Framework SDK
Azure ML Command Jobs: Inputs, Outputs, Snapshots & Spot Training
Submitting Azure Machine Learning v2 command jobs to a compute cluster with the SDK v2 or CLI v2 (SDK v1 and CLI v1 are legacy), job input modes (ro_mount, download, direct), outputs bound to datastores, the special outputs and logs folders, the code snapshot and .amlignore, the job timeout limit, interactive job services (SSH, JupyterLab, VS Code, TensorBoard) for debugging, user identity pass-through, and checkpointing to survive Spot node eviction
Objectives
- Submit a command job with the right inputs, outputs, environment and compute using SDK v2 or CLI v2
- Pick an input mode and bind outputs to a datastore path for large data
- Make a long training job resilient to timeouts and Spot eviction and debug it with interactive services
Key concepts
- command job submission
- input modes ro_mount download direct
- job outputs and datastores
- outputs and logs folders
- code snapshot and .amlignore
- job timeout limit
- interactive job services
- user identity pass-through
- Spot eviction checkpoints
- SDK v2 and CLI v2
Azure ML Workspace Security: Managed VNet, CMK, Compute & Quota
Azure Machine Learning workspace isolation with a managed virtual network (allow internet outbound versus allow only approved outbound, private endpoint, service tag and FQDN outbound rules), customer-managed keys for the workspace, compute clusters without public IP, AcrPull on a private Azure Container Registry for environments, OneLake datastores, compute instance file persistence, and VM family quota and workspace quota allocation
Objectives
- Choose the managed VNet isolation mode and outbound rules for a regulated workspace
- Secure the workspace with CMK, private ACR access and clusters with no public IP
- Plan quota and persistence so training capacity and user files are not lost
Key concepts
- managed VNet outbound modes
- customer-managed key workspace
- compute cluster no public IP
- AcrPull on private ACR
- OneLake datastore
- compute instance file persistence
- workspace quota allocation
- private endpoint outbound rules
Azure ML Endpoints: Authentication, Networking, Scaling & Batch
Securing and operating Azure Machine Learning endpoints: key, aml_token and Microsoft Entra token authentication and key regeneration, public_network_access and managed network isolation, endpoint identity with data-plane roles, max_concurrent_requests_per_instance and request timeouts, extra quota headroom for rolling updates, the online data collector, and batch endpoints with error_threshold, retry settings and pipeline component deployments
Objectives
- Select an authentication mode and rotate credentials for an endpoint
- Grant the endpoint identity least-privilege data-plane access and isolate it from the public internet
- Size concurrency and quota for online endpoints and configure fault-tolerant batch scoring
Key concepts
- endpoint authentication modes
- key regeneration
- public network access
- endpoint identity data-plane role
- max concurrent requests per instance
- quota headroom for rolling update
- data collector
- batch error_threshold
- pipeline batch deployment
MLflow Models, Pipeline Schedules & Parallel Jobs
Registering an MLflow model from a job output path (azureml://jobs/.../outputs/artifacts/paths/model), logging models with a signature so they deploy without a scoring script (no-code deployment), custom mlflow.pyfunc wrappers (PythonModel, load_context, predict), pipeline schedules with cron expressions and recurrence triggers, and the parallel job type with mini_batch_size and max_concurrency_per_instance
Objectives
- Register and package an MLflow model so it deploys with no scoring script
- Wrap custom preprocessing or a non-standard model with a pyfunc
- Schedule pipelines with cron and scale a step across nodes with a parallel job
Key concepts
- register MLflow model from job output
- model signature and no-code deployment
- mlflow.pyfunc PythonModel wrapper
- cron schedule syntax
- recurrence trigger
- parallel job
- mini_batch_size
Azure ML Data Access, Serverless Spark & AutoML Forecasting Validation
Loading datastore data in notebooks with mltable and identity-based access, attaching serverless Spark compute in Azure Machine Learning notebooks with user identity or managed identity and abfss paths, and validating AutoML forecasting with time-ordered rolling-origin cross-validation instead of random splits
Objectives
- Read datastore data with mltable and the right identity
- Run Spark data preparation on serverless compute from an Azure ML notebook
- Validate a forecasting model without leaking future data
Key concepts
- mltable and datastore URIs
- identity-based data access
- serverless Spark in notebooks
- abfss paths
- rolling origin cross-validation
- AutoML forecasting time column
Prompt Flow: Connections, Node Types & Evaluation Aggregation
Building LLM apps with prompt flow: connections (Azure OpenAI, custom connections with secret fields) managed as Microsoft Foundry project connections so keys stay out of flow files, node types (LLM, Prompt, Python, tools such as vector index lookup), the DAG of node inputs and outputs, and evaluation flows whose aggregation nodes compute metrics over all line-level results with log_metric
Objectives
- Keep secrets in connections rather than in flow definitions
- Select the node type for each step of an LLM flow
- Build an evaluation flow that aggregates line-level scores into run metrics
Key concepts
- prompt flow connections
- Foundry project connections
- LLM Prompt and Python nodes
- flow DAG inputs and outputs
- evaluation flow
- aggregation node and log_metric
- bulk test runs
Foundry Models: Catalog, Fine-Tuning Lifecycle, Embeddings & Batch
Shortlisting models with Foundry model catalog benchmarks (quality, cost, latency, throughput), migrating before a model version retires (version upgrade policy), diagnosing fine-tuning overfitting with training versus validation loss, the automatic deletion of idle fine-tuned deployments after 15 days of inactivity, reducing text-embedding-3 vector size with the dimensions parameter, security trimming at retrieval time in RAG, and the Azure OpenAI Global Batch deployment type
Objectives
- Compare candidate models with benchmarks before testing them on your own data
- Plan retirement migration and fine-tuned deployment lifecycle
- Tune embeddings, retrieval filters and batch inference for cost and security
Key concepts
- model catalog benchmarks
- model version retirement
- version upgrade policy
- fine-tuning overfitting
- validation loss
- idle fine-tuned deployment
- embedding dimensions parameter
- security trimming in RAG
- Global Batch deployment
Face Service: Limited Access, Liveness Detection & Recognition Models
Azure AI Face detection, verification, identification and similarity, the Limited Access policy that gates identification, verification and liveness behind an approved intake, retired facial-attribute inference, detection and recognition model versions (recognition_01 to recognition_04) that must match between enrolled and queried faces, and face liveness detection sessions where the backend creates a session, the client SDK captures, and the backend reads the result to block print and replay spoofing
Objectives
- Choose the Face operation and the access approval it needs
- Keep detection and recognition models consistent across enrollment and queries
- Add liveness detection to block spoofing in an onboarding flow
Key concepts
- Face Limited Access
- face verification vs identification
- recognition model versions
- detection model versions
- face liveness session
- anti-spoofing
- retired face attributes
- PersonGroup
Speech: Keyword Recognition, Pronunciation Assessment, Language Identification & Realtime Audio
Custom keyword models created in Speech Studio and used with the KeywordRecognizer for wake words, pronunciation assessment (reference text, Phoneme/Word/FullText granularity, accuracy, fluency, completeness and prosody scores, miscue detection), language identification with AutoDetectSourceLanguageConfig at start or continuous, text language detection, and the GPT realtime audio API over WebSocket or WebRTC for low-latency speech-in speech-out conversations with server voice activity detection
Objectives
- Build a wake-word experience and a pronunciation coach with the Speech SDK
- Detect the spoken or written language before transcription or translation
- Choose the realtime audio API for low-latency voice agents
Key concepts
- custom keyword model
- KeywordRecognizer
- PronunciationAssessmentConfig
- assessment granularity
- AutoDetectSourceLanguageConfig
- continuous language identification
- realtime audio API
- server VAD turn detection
AI Search: Security Trimming, Private Indexer Access, Facets, Suggesters & Replicas
Azure AI Search security trimming with a filterable group-ID field and a search.in filter, shared private links so indexers reach storage or databases over private endpoints, faceted navigation and OData filters (filterable and facetable attributes), suggesters for the Suggest and Autocomplete APIs, and replicas and partitions for query throughput, high availability and the 99.9 percent read SLA with two replicas and read-write SLA with three
Objectives
- Return only the documents each user is allowed to see
- Index private data sources without opening public network access
- Size replicas and partitions for availability and throughput
Key concepts
- security trimming
- search.in filter
- shared private link
- facets and filters
- suggester
- Autocomplete API
- replicas and partitions
- read SLA 2 replicas
Language & Translator Customization: Custom Translator, Multi-Label Classification, Custom QA Metadata, Health & Document Translation
Custom Translator (training a neural machine translation model on parallel documents and calling it with the category ID), custom text classification single-label versus multi-label, custom question answering with metadata filters, Text Analytics for health (medical entities, relations, assertion detection, UMLS linking), and Document Translation reading and writing blob containers with the managed identity of the Translator resource instead of SAS tokens
Objectives
- Adapt translation to domain terminology with Custom Translator
- Pick single-label or multi-label custom classification and filter QA answers by metadata
- Extract clinical entities and run batch translation without shared access signatures
Key concepts
- Custom Translator category
- parallel documents
- multi-label classification
- custom question answering metadata filter
- Text Analytics for health
- assertion detection
- Document Translation managed identity
- Storage Blob Data roles
Foundry Operations: Agent Tracing & Evaluators, Token Metering, APIM Semantic Caching, Model Router & Abuse Monitoring
OpenTelemetry tracing of Foundry agents and their run steps in Application Insights, agent evaluators (intent resolution, tool call accuracy, task adherence) alongside groundedness and relevance, token usage tracking with the usage object and the APIM llm-emit-token-metric and llm-token-limit policies, semantic caching with the APIM semantic cache lookup and store policies backed by Azure Managed Redis and an embeddings deployment, the model router deployment that selects an underlying model per prompt, and Azure OpenAI abuse monitoring retention and the approved modification process
Objectives
- Trace and evaluate an agent from the first prompt to each tool call
- Meter, limit and cache model traffic through API Management to control cost
- Explain the model router and how abuse monitoring differs from content filtering
Key concepts
- agent tracing
- run steps
- agent evaluators
- tool call accuracy
- llm-emit-token-metric
- llm-token-limit
- semantic cache lookup and store
- model router
- abuse monitoring
AI Services Operations: Key Rotation, Entra ID Auth, Long-Running Operations, Image URL Access & Disconnected Containers
Rotating the two keys of an Azure AI services resource and preferring Microsoft Entra ID with managed identity and disableLocalAuth, long-running operations that return 202 with an Operation-Location header polled until succeeded, Image Analysis calls by publicly reachable URL or binary body (SAS URL for private blobs), and disconnected containers that use a commitment-tier license (download license, mount license and output directories) including approved Content Safety containers
Objectives
- Rotate keys without downtime and move to keyless authentication
- Poll asynchronous analysis operations correctly
- Run AI containers in an air-gapped environment with a license
Key concepts
- two-key rotation
- disableLocalAuth
- Cognitive Services User role
- Operation-Location polling
- poller result
- image URL vs binary
- commitment tier license
- disconnected container
Bot Service: State Persistence, Channels & Web Chat Tokens
Bot Framework conversation, user and private conversation state with storage providers (MemoryStorage only for testing, Cosmos DB or Blob storage for production) and saving state at the end of each turn, Azure Bot resource channel configuration (Teams, Web Chat, Direct Line, Slack, Telegram), messaging endpoint and app identity type, exchanging a Direct Line secret for a short-lived token on the server so the browser Web Chat widget never holds the secret, and the move from the Bot Framework SDK to the Microsoft 365 Agents SDK
Objectives
- Persist bot state so conversations survive restarts and scale-out
- Publish a bot to channels with the right identity and endpoint
- Embed Web Chat securely with a server-issued token
Key concepts
- ConversationState and UserState
- CosmosDbPartitionedStorage
- MemoryStorage limits
- channel registration
- messaging endpoint
- Direct Line token generate
- Web Chat widget
- Microsoft 365 Agents SDK
Levels: Junior, Mid, Senior, and Expert
Explain it in your own words
Graded by AI · no account · 1 questionNo options to guess from: you write, the AI grades against the topic's rubric and tells you what level your answer reads at.
Already studying Microsoft Azure?
The assessment measures topic by topic, and your plan skips what you already know.
Open to read. An account is only needed to be measured.
Frequently asked questions
Where should I start studying Microsoft Azure?
Start with Cloud & Azure Fundamentals: Cloud Computing Concepts, Azure Architecture & Resource Hierarchy, and Azure Support Plans, SLAs & Service Lifecycle. The map orders topics by what they depend on, so each one prepares the next.
How long does a full Microsoft Azure assessment take?
A full assessment of this path takes about 45 minutes. Study time depends on where you start; a diagnostic shows which topics you can skip.
Do I need an account to use this page?
No. The map, objectives and key concepts are open. You only need an account to be measured, get your gap by topic and receive a plan.