You Can Pass This Exam For Free
Choose Your Study Path
Limited Azure or cloud development experience. You need to build foundational knowledge in Azure services, containers, and databases before tackling AI-specific patterns.
Week 1Set up an Azure free account. Learn Azure fundamentals: resource groups, subscriptions, regions, Azure CLI, and the Azure portal. Complete the AZ-900 learning path if you have not already
Week 2Study containerization basics: Docker images, Dockerfiles, container registries. Learn Azure Container Registry (ACR) -- building, storing, versioning, and managing container images
Week 3Deep dive into Azure Container Apps: environment configuration, revision management, KEDA event-driven scaling. Compare Container Apps vs AKS vs App Service for container hosting
Week 4Learn Azure Kubernetes Service (AKS): manifest files, deployments, services, ConfigMaps, Secrets, persistent storage, and monitoring with Container Insights
Week 5Study Azure Cosmos DB for NoSQL: SDK connections, queries, indexing policies, consistency levels, Request Units (RUs), change feed processor, and vector similarity search with embeddings
Week 6Learn Azure Database for PostgreSQL: schemas, indexing, pgvector extension, vector similarity search (L2, cosine, inner product), HNSW vs IVFFlat indexes, and RAG patterns with metadata filters
Week 7Study Azure Managed Redis (caching, expiration, invalidation, vector indexing), Azure Service Bus (queues, topics, subscriptions, dead-letter queues), and Azure Event Grid (filters, custom events, retries)
Week 8Learn Azure Functions (triggers, bindings, deployment), Azure Key Vault (secret rotation, retrieval), Azure App Configuration, and OpenTelemetry distributed tracing with KQL
Week 9Take practice exams across all domains. Review explanations carefully. Focus on the data management domain which is the heaviest at 28%
Week 10Final review: focus on service comparisons (Cosmos DB vs PostgreSQL, Container Apps vs AKS), vector search patterns, and common exam traps
Exam Overview
Format
40-60 questions, 120 minutes. Multiple choice, multiple select, drag-and-drop, case studies, and interactive lab scenarios.
Scoring
Scaled score 100-1000. Passing: 700. No penalty for wrong answers -- always answer every question.
Domains & Weights
- Develop Containerized Solutions on Azure23%
- Develop AI Solutions by Using Azure Data Management Services28%
- Connect to and Consume Azure Services24%
- Secure, Monitor, and Troubleshoot Azure Solutions25%
Registration
$165 USD. Available at Pearson VUE testing centers or online proctored from home. Exam fee is $165 USD. Currently in beta with GA expected July 2026.
Topic Priority Table
Not all topics are tested equally. Focus your study time on Tier 1 first, then Tier 2. Tier 3 topics rarely appear — just recognize what they do.
Domain 123% of exam
Develop Containerized Solutions on Azure
This domain covers building and deploying containerized AI workloads on Azure using ACR, Container Apps, AKS, and App Service. You must understand container image lifecycle management, KEDA-based autoscaling, Kubernetes manifest deployments, and monitoring containerized applications. This is one of the areas with the most net-new content compared to AZ-204.
Key Topics
Azure Container RegistryAzure Container AppsAzure Kubernetes ServiceAzure App ServiceKEDAContainer Insights
Must-Know Concepts
- ACR fundamentals: building images with ACR Tasks, storing and versioning images, managing repositories, and configuring access with managed identities
- Container Apps deployment: environment configuration, revision management (single vs multi-revision mode), environment variables, and secret management
- KEDA scaling in Container Apps: configuring HTTP, TCP, CPU, memory, and custom event-driven scaling rules with min/max replicas
- AKS deployment with manifest files: Deployments, Services, ConfigMaps, Secrets, and understanding YAML manifest structure
- AKS persistent storage: choosing between Azure Disk (single-node, block storage) and Azure Files (multi-node, shared file storage) based on workload needs
- Container monitoring: using Container Insights with KQL queries to inspect logs, events, and end-to-end connectivity for both AKS and Container Apps
- App Service container hosting: deploying custom containers with environment variables and Key Vault secret references
- Revision management in Container Apps: understanding that scaling rule changes, image updates, and config changes create new revisions
- Container networking: understanding ingress configuration, port mapping, and service discovery in Container Apps and AKS
Common Exam Traps
Container Apps revisions are IMMUTABLE -- any scaling rule or config change creates a new revision. You cannot modify an existing revision
KEDA scales to zero by default for non-HTTP triggers in Container Apps. HTTP triggers maintain at least one replica unless explicitly configured otherwise
AKS ConfigMaps are for non-sensitive configuration data. Use Kubernetes Secrets (or better, Key Vault integration) for sensitive data like passwords
Azure Disk supports ReadWriteOnce (single pod). Azure Files supports ReadWriteMany (multiple pods). Choosing wrong causes mount failures in AKS
ACR Tasks can automate image builds on code commit or base image update -- do not confuse with manual docker build and push workflows
Domain 228% of exam
Develop AI Solutions by Using Azure Data Management Services
The heaviest domain at 28% -- expect roughly 14 questions covering Cosmos DB NoSQL with vector search, PostgreSQL with pgvector for RAG patterns, and Azure Managed Redis for caching and vector indexing. You must understand how to store embeddings, execute vector similarity searches, implement RAG patterns, and optimize query performance across all three data services.
Key Topics
Azure Cosmos DB for NoSQLAzure Database for PostgreSQLpgvectorAzure Managed RedisVector SearchRAG Patterns
Must-Know Concepts
- Cosmos DB SDK operations: connecting, running queries, and performing CRUD operations using the NoSQL API with partition key design
- Cosmos DB performance optimization: indexing policies (include/exclude paths), consistency levels (strong, bounded staleness, session, consistent prefix, eventual), and RU consumption analysis
- Cosmos DB vector search: storing embeddings as arrays, configuring vector indexing policies, and executing vector similarity search for semantic retrieval
- Cosmos DB change feed processor: detecting new or updated items, processing changes with delegates, managing leases, and building event-driven data pipelines
- PostgreSQL schema design: choosing appropriate data types, designing tables for vector workloads, and implementing effective indexing strategies
- pgvector distance operators: L2 distance (<->), cosine distance (<=>), and inner product (<#>) -- know when to use each
- pgvector index types: HNSW (faster queries, more memory, slower builds) vs IVFFlat (faster builds, needs reindexing, lower memory)
- RAG pattern implementation with PostgreSQL: storing embeddings, executing semantic retrieval queries, and applying metadata filters for hybrid search
- PostgreSQL connection optimization: using connection pooling (pgBouncer), configuring compute/memory/storage for vector workloads, and minimizing latency
- Azure Managed Redis: implementing caching operations (cache-aside pattern), expiration and invalidation strategies, and vector indexing for similarity search
- Vector similarity search concepts: embeddings, cosine similarity, semantic retrieval, and how vector search enables RAG pipelines
Common Exam Traps
Cosmos DB consistency levels affect BOTH performance and cost. Strong consistency gives the latest data but costs more RUs. Eventual consistency is cheapest but may return stale data
pgvector HNSW indexes do NOT need reindexing after data changes, but IVFFlat indexes DO. This is a critical distinction for production workloads
Cosmos DB partition keys cannot be changed after container creation. Choosing a bad partition key leads to hot partitions and wasted RUs
Azure Managed Redis vector search requires the Enterprise tier -- Standard and Basic tiers do not support vector indexing
Connection pooling is essential for PostgreSQL vector workloads. Without it, 50+ concurrent requests cause connection pool exhaustion
RU consumption in Cosmos DB is affected by query complexity, data size, indexing, and consistency level. Cross-partition queries consume significantly more RUs than single-partition queries
Domain 324% of exam
Connect to and Consume Azure Services
This domain covers building event-driven and message-based AI solutions using Azure Service Bus, Event Grid, and Azure Functions. You must understand messaging patterns, dead-letter queue handling, event filtering, serverless API development with triggers and bindings, and how these services wire AI workloads together in production pipelines.
Key Topics
Azure Service BusAzure Event GridAzure FunctionsTriggersBindingsDead-Letter Queues
Must-Know Concepts
- Service Bus queues: FIFO message processing, dead-letter queue (DLQ) handling for failed messages, message sessions for ordered processing, and PeekLock vs ReceiveAndDelete modes
- Service Bus topics and subscriptions: publish-subscribe messaging, subscription filters (SQL, correlation), and message routing to multiple subscribers
- Dead-letter queue handling: understanding why messages end up in DLQ (max delivery count exceeded, TTL expired, filter evaluation exceptions), and how to process DLQ messages with Functions
- Event Grid event subscriptions: configuring filters (event type, subject prefix/suffix, advanced filters), retry policies (exponential backoff, max retries), and dead-lettering
- Event Grid custom events: publishing custom events to Event Grid topics, defining event schemas, and subscribing to custom event types
- Azure Functions triggers: HTTP triggers for APIs, Service Bus triggers for queue/topic processing, Event Grid triggers for event handling, and Timer triggers for scheduled tasks
- Azure Functions bindings: input bindings (read data from services), output bindings (write data to services), and how bindings simplify service integration without explicit SDK code
- Function app deployment: configuring function apps, managing application settings, and deploying to Azure
- Message vs event distinction: messages are commands that must be processed (Service Bus); events are notifications of state changes (Event Grid)
Common Exam Traps
Service Bus PeekLock mode locks the message during processing and completes or abandons it based on function outcome. ReceiveAndDelete removes the message immediately -- if processing fails, the message is LOST
Event Grid retries failed deliveries with exponential backoff by default. If all retries fail and dead-lettering is configured, the event goes to a storage blob container, NOT a Service Bus DLQ
Azure Functions Service Bus triggers use PeekLock by default. If your function throws an exception, the message is abandoned (not deleted) and retried up to MaxDeliveryCount
Dead-letter queue messages must be explicitly processed -- they do not re-enter the main queue automatically. You need a separate function or process to handle DLQ messages
Event Grid subject filters are case-sensitive. A filter for /subjects/AI will not match /subjects/ai
Domain 425% of exam
Secure, Monitor, and Troubleshoot Azure Solutions
This domain covers securing AI solutions with Key Vault and App Configuration, implementing distributed tracing with OpenTelemetry, and writing KQL queries to analyze logs and metrics. You must understand secret management, configuration patterns, vendor-neutral observability instrumentation, and how to troubleshoot production Azure solutions using Azure Monitor.
Key Topics
Azure Key VaultAzure App ConfigurationOpenTelemetryAzure MonitorKQLManaged Identities
Must-Know Concepts
- Key Vault secret management: creating, storing, retrieving, and rotating secrets programmatically. Understanding soft-delete and purge protection
- Key Vault access control: using Azure RBAC or access policies, and integrating with managed identities for credential-free access from Azure resources
- Secret rotation: implementing automatic rotation with Key Vault rotation policies and event-driven rotation using Event Grid notifications
- App Configuration usage: storing and retrieving application settings, using labels for environment-specific configuration, and referencing Key Vault secrets
- OpenTelemetry distributed tracing: creating custom spans with ActivitySource, propagating trace context across service boundaries, and correlating requests in distributed systems
- OpenTelemetry metrics: creating custom metrics with Meter instruments (Counter, Histogram, Gauge), and exporting metrics to Azure Monitor
- KQL query fundamentals: basic operators (where, project, summarize, extend, order by), time-based filtering, aggregation functions, and joining tables
- Azure Monitor integration: sending OpenTelemetry telemetry to Azure Monitor, querying logs in Log Analytics workspaces, and creating alerts based on KQL queries
- Managed identity best practices: using system-assigned or user-assigned identities to access Key Vault, Cosmos DB, and other services without storing credentials
Common Exam Traps
OpenTelemetry ActivitySource creates SPANS (units of work in a trace), not traditional Application Insights requests/dependencies. The terminology has changed
Key Vault soft-delete is enabled by default and CANNOT be disabled on new vaults. Deleted secrets are recoverable for 7-90 days depending on retention policy
App Configuration is NOT a replacement for Key Vault. App Configuration stores settings; Key Vault stores secrets. Use Key Vault references in App Configuration for sensitive values
KQL is case-sensitive for string comparisons by default. Use =~ for case-insensitive comparisons. This catches many exam candidates
OpenTelemetry replaces the Application Insights SDK on the AI-200 exam. Questions will reference ActivitySource and Meter, not TelemetryClient
Managed identities eliminate the need for connection strings in code, but the identity must still be granted appropriate RBAC roles on the target resource
Azure Services You Must Not Confuse
These pairs appear on nearly every exam. Learn the difference and you'll avoid the most common traps.
Top Mistakes to Avoid
Confusing Azure Container Apps (serverless, KEDA-based scaling, no Kubernetes knowledge needed) with AKS (full Kubernetes cluster requiring manifest files and node management)
Mixing up Cosmos DB consistency levels -- strong consistency is NOT the default; session consistency is the default and most commonly used level
Thinking pgvector HNSW and IVFFlat indexes are interchangeable -- HNSW is better for query speed but uses more memory; IVFFlat needs periodic reindexing after data changes
Using Azure Key Vault for non-sensitive application settings instead of Azure App Configuration -- Key Vault is for secrets, App Configuration is for settings
Confusing Service Bus messages (commands to process, pulled by receivers) with Event Grid events (state change notifications, pushed to subscribers)
Forgetting that Container Apps revision changes are immutable -- modifying a scaling rule or environment variable creates a new revision, not an update to the existing one
Assuming Application Insights SDK is still tested -- AI-200 uses OpenTelemetry (ActivitySource, Meter) as the observability standard, not TelemetryClient
Not understanding that Cosmos DB RU costs vary by query type -- cross-partition queries cost significantly more RUs than single-partition queries with the partition key
Confusing Azure Disk (ReadWriteOnce, single pod) with Azure Files (ReadWriteMany, multiple pods) when selecting AKS persistent storage
Storing credentials in code or environment variables instead of using managed identities for credential-free access to Azure services
Exam-Ready Checklist
Can explain all 4 exam domains and their relative weights (23%, 28%, 24%, 25%)
Know when to choose Container Apps vs AKS vs App Service for container hosting based on workload requirements
Understand KEDA scaling rules in Container Apps: HTTP, TCP, CPU, memory, and event-driven scalers
Can deploy to AKS using manifest files with Deployments, Services, ConfigMaps, and Secrets
Understand Cosmos DB indexing policies, consistency levels, RU optimization, and partition key design
Can implement vector similarity search with both Cosmos DB (embeddings, vector indexing) and PostgreSQL pgvector (HNSW, IVFFlat, distance operators)
Know Azure Managed Redis caching patterns, expiration strategies, and Enterprise tier vector indexing
Understand Service Bus queues, topics/subscriptions, and dead-letter queue processing patterns
Can configure Event Grid subscriptions with filters, custom events, and retry policies
Know Azure Functions trigger types (HTTP, Service Bus, Event Grid, Timer) and input/output bindings
Can implement OpenTelemetry distributed tracing with ActivitySource and metrics with Meter instruments
Know how to write KQL queries with where, project, summarize, extend, and bin() for time-based analysis
Understand Key Vault secret management including rotation, managed identity access, and App Configuration references
Can distinguish between HNSW (fast queries, slow builds, more memory) and IVFFlat (fast builds, needs reindexing, less memory) indexes
Scored 70%+ on at least two full mock exams (700/1000 passing score)
Recommended Resources
Free & Official Resources
Paid Courses & Practice Exams
These are recommended if you prefer a structured learning path. They can save time but are not required to pass.