AI-200 Study Guide
A curated learning path for the AI-200 exam: the best documentation, videos, blog posts and tutorials for every exam objective.A curated learning path for the AI-200 exam: the best documentation, videos, blog posts and tutorials for every exam objective, in the order worth studying them.
Microsoft Certified: Azure AI Cloud Developer Associate
Exam at a Glance
AI-200 measures whether you can do the day-to-day work of a back-end developer building AI-powered solutions on Azure: hosting services in containers, backing them with vector-capable data stores, wiring them together with messaging and functions, and keeping them secure and observable.
| AI-200 | Developing AI Cloud Solutions on Azure |
|---|---|
| Level | Intermediate (associate role-based exam) |
| Exam length | 120 minutes |
| Questions | Typically 40 to 60; the number and format mix can vary |
| Passing score | 700 out of 1000 |
| Question formats | Multiple choice, multiple select, drag and drop, build list, hot area, case studies, possibly labs |
| Microsoft Learn access | Available within the exam; browsing is restricted and the timer continues |
| Skills measured version | October 7, 2026 |
| Renewal | Certification expires annually; renew with a free online assessment on Microsoft Learn |
What the Exam Covers
The exam has four domains, and the data services domain is the heaviest at 30-35%. It also has the least overlap with general Azure development experience: vector indexes, embedding storage and Redis modules come with hard boundaries, so give it the most time.
Develop containerized solutions on Azure — 20-25%
Building and versioning images in Azure Container Registry with ACR Tasks, then choosing where they run: App Service with environment variables and secrets, Azure Container Apps with revisions and KEDA event-driven scaling, or Azure Kubernetes Service with manifest files. Troubleshooting questions work through AKS and Container Apps logs, events and end-to-end connectivity.
Develop AI solutions by using Azure data management services — 30-35%
Three stores, each with its own choices. Azure Cosmos DB for NoSQL: indexing policies and consistency levels for RU optimization, embeddings and vector similarity search, and change feed processors. Azure Database for PostgreSQL: schema and data types, pgvector indexing strategies, sizing for vector workloads, and RAG with metadata filters. Azure Managed Redis: caching, expiration and invalidation, and vector indexing for similarity search.
Connect to and consume Azure services — 20-25%
Back-end messaging and serverless APIs: Azure Service Bus messages, topics, subscriptions and dead-letter handling, Azure Event Grid filters, custom events and retries, and Azure Functions triggers and bindings, plus configuring and deploying function apps.
Secure, monitor, troubleshoot Azure solutions — 20-25%
Secrets in Azure Key Vault, including rotation and retrieval, configuration in Azure App Configuration, distributed tracing with the OpenTelemetry SDKs, and KQL queries that analyze logs and metrics.
The full bullet list is in Microsoft's study guide, linked in Step 1 below.
How This Maps to CertiAce Practice Modules
The CertiAce question bank is organized by the same nine learning paths Microsoft uses for the AI-200 course, so you can drill each area in isolation:
| CertiAce practice module | What you will drill there |
|---|---|
| Implement container application hosting on Azure | Container Registry, ACR Tasks, image tagging, containers on App Service |
| Deploy and manage apps on Azure Container Apps | Environments, revisions, secrets, health probes, HTTP and KEDA scale rules |
| Deploy and monitor applications on Azure Kubernetes Service | Manifests, Services, ConfigMaps and Secrets, kubectl triage and connectivity |
| Develop AI solutions with Azure Cosmos DB for NoSQL | SDK queries, indexing and consistency, vector index types and limits, change feed processors |
| Develop AI solutions with Azure Database for PostgreSQL | pgvector index choices, distance operators, RAG with metadata filters, pooling and sizing |
| Enhance AI solutions with Azure Managed Redis | Tiers and modules, caching and expiration, pub/sub and streams, vector indexes |
| Integrate backend services for AI solutions | Service Bus settlement and dead-lettering, Event Grid filters and retries, Functions triggers |
| Manage application secrets and configuration for AI solutions | Key Vault retrieval and rotation, App Configuration labels, feature flags and Key Vault references |
| Observe and troubleshoot apps on Azure | OpenTelemetry into Application Insights, KQL over requests, dependencies and traces |
Where AI-200 Fits

| Certification | What it validates | When to take it |
|---|---|---|
| AZ-900: Azure Fundamentals | Cloud concepts, core Azure services, management and governance | Optional first step if you are new to Azure |
| AI-901: Azure AI Fundamentals | AI concepts and the Azure AI landscape, with basic Python | Optional first step if you are new to AI workloads |
| AI-200: Azure AI Cloud Developer Associate (this exam) | Building, integrating, securing and monitoring the back end of AI solutions on Azure | You are here |
| AI-103: Azure AI Apps and Agents Developer Associate | The model and agent side: building AI apps and agents with Microsoft Foundry | A natural companion if you also build the AI layer |
AI-200 has no official prerequisites: the certification page lists none, so neither AZ-900 nor AI-901 is required. If you are new to Azure, starting with AZ-900 is strongly recommended; if you are new to AI workloads, AI-901 adds the vocabulary around models and embeddings that AI-200 assumes. If you already ship back-end services on Azure in Python, go straight to AI-200.
Before You Start
The exam assumes you write code for Azure, not just read about it: every official learning path lists Python as its primary language. Anything unfamiliar in this table is where to start:
| Area | You should be comfortable with |
|---|---|
| Python and Azure SDKs | Reading and writing Python; calling Azure services through the Python SDKs and REST; managed identity instead of connection strings |
| Containers | Building and tagging images; what a registry does; App Service versus Container Apps versus AKS; basic kubectl |
| Vector data and AI patterns | What embeddings are and why dimensions matter; exact versus approximate nearest-neighbor search; the retrieval-augmented generation (RAG) pattern |
| Messaging and eventing | Queues versus topics versus events; at-least-once delivery; why dead-letter queues exist |
| Monitoring | What distributed tracing is; reading a basic log query |
Commonly Confused Pairs
These pairs tend to show up together as the two plausible answers to one question:
| Looks similar | The difference that decides the answer |
|---|---|
| Stable tag or unique tag | A stable tag such as 1.0 keeps moving to newer images as the image is patched, so it suits base images. Deploy with a unique tag, such as a build ID or the image digest, so a restart or scale-out never pulls a newer image than the other replicas run. |
| HTTP scale rule or custom scale rule | An HTTP rule scales a container app on concurrent HTTP requests. Scaling a background worker on queue length, such as an Azure Service Bus queue, needs a custom rule built on a KEDA scaler. An app without ingress, a custom rule or a minimum replica count scales to zero and has no way to start again. |
| Session or Strong consistency | Session guarantees read-your-writes within one client session, using a session token, and reads from a single replica. Strong guarantees that every read returns the latest committed write, its reads cost twice the request units of Session, and it can't be used on an account with multiple write regions. |
| IVFFlat or HNSW | IVFFlat builds faster and uses less memory, but it clusters the existing rows into lists, so load the data before you create it. HNSW takes more time and memory to build and gives a better speed and recall trade-off, and with no training step it can be created on an empty table. |
| PeekLock or ReceiveAndDelete | ReceiveAndDelete consumes a message as soon as Service Bus sends it to the receiver, so a message the receiver fails to process can't be delivered again. PeekLock locks the message until the receiver completes it, and an abandoned message or an expired lock makes it available for redelivery. |
| App Configuration or Key Vault | Keep the secret in Key Vault and add a Key Vault reference in App Configuration, which stores only the secret's URI. App Configuration never reads the vault, so the app needs its own access to Key Vault, for example through its managed identity. |
Step-by-Step Study Plan

Treat these estimates as planning guidance and adjust them to your starting knowledge and weekly study hours:
| Your starting point | Suggested prep time |
|---|---|
| Daily Azure developer, comfortable with Python and containers | 3 to 5 weeks, most of it on the data services domain |
| New to Azure app development | 6 to 10 weeks |
Step 1: Read the Official Study Guide
Skim the full skills-measured list once, and mark every bullet you could not explain to a colleague. The October 7, 2026 update raised the data services domain to 30-35% without changing any bullets. Re-skim the list if it changes again before your exam.
Step 2: Schedule Your Exam
Choose a realistic target date after reviewing the skills list and your available study time, then work backwards from it with the prep-time table above.
Certification and Exam Details Page
Step 3: Work Through the Official Learning Path
Complete the nine AI-200 learning paths on Microsoft Learn in course order: containers first, then the three data services, then integration, secrets and observability. Spend the most time on the data services paths, and flag anything that needs hands-on practice for Step 5.
Official Learning Path Course Page
Step 4: Use a Supplementary Video Resource
No dedicated AI-200 video course exists yet. Until one appears, Microsoft Reactor's free Python + AI series is the best substitute for the highest-weight domain: six on-demand sessions on large language models, vector embeddings, retrieval-augmented generation, function calling and quality, all in Python. It teaches the concepts, not the Azure stores themselves; get those, and the other three domains, from the learning path and the labs.
Python + AI on Microsoft Reactor
Step 5: Get Hands-On Practice
AI-200 questions describe operational situations, so build the back ends yourself. Microsoft's official exercises for the AI-200 course are 26 free labs that cover every domain. Make sure you personally touch:
- Building an image with ACR Tasks, deploying it to Container Apps, App Service and AKS, and adding a KEDA scale rule
- Storing embeddings and running a vector similarity query in all three data stores
- Processing a Service Bus queue, handling dead-lettered messages, and publishing Event Grid events
- Retrieving a secret from Key Vault and settings from App Configuration with a managed identity
- Instrumenting an app with the OpenTelemetry SDK and following one request through KQL
Step 6: Benchmark Your Knowledge
Use CertiAce to benchmark your readiness module by module. The practice modules map to the exam domains as shown above, so use the module mapping and the topics behind your missed questions to identify the skills-measured areas to revisit. Microsoft also offers a free official practice assessment for AI-200 on AI Skills Navigator (sign in to launch it). It is a useful extra check, but it tends to be somewhat easier than the real exam. CertiAce questions are written to sit closer to the real exam's difficulty. If a module stays weak, read the explanations on the questions you missed, then retry that module.
Official Practice Assessment on AI Skills Navigator
Step 7: Take the Exam
The day before, review only your weak topics and revisit the hard boundaries: vector index dimension limits, vector policies fixed at container creation, Redis modules chosen at creation, and which scale rules can reach zero. In the exam, watch for wording that implies constraints such as least privilege, cost, or scale to zero.
- Microsoft Learn is available during the exam in a split screen. Use it to check details you genuinely need: the timer keeps running, and the exam is deliberately too long to look up every answer. Browsing is limited to Microsoft Learn itself (no Q&A, practice assessments, or profile), and personal notes and other websites are unavailable.
- You can take unscheduled breaks, but the clock keeps running and you cannot return to questions you already saw.
- Case studies lock when you leave them: finish each one before moving on, because you cannot revisit its questions afterwards.
- Labs may appear: AI-200's 120-minute allotment is the one Microsoft uses for role-based exams that may contain labs. The introduction screen tells you whether yours does; if it does, budget extra time for them.
- Try the exam sandbox beforehand so the question formats and interface hold no surprises: Exam Sandbox
Additional Learning Resources
| Resource | Type | Why it is useful |
|---|---|---|
| Exercises for Azure developers: Develop AI Cloud Solutions on Microsoft Azure | Hands-on labs | The 26 free official exercises behind the AI-200 course, covering every domain |
| Python + AI | Microsoft Reactor series | Six on-demand sessions on LLMs, embeddings, vector search and RAG in Python |
| Integrated Vector Store - Azure Cosmos DB | Docs | The three vector index types, their dimension limits, the fixed container vector policy and when to pick flat, quantizedFlat or diskANN |
| Optimize performance when using pgvector in Azure Database for PostgreSQL | Docs | IVFFlat versus HNSW, index build parameters and query tuning |
| DiskANN on Azure Database for PostgreSQL – Now Generally Available | Blog | When DiskANN beats the classic pgvector index types |
| Azure Managed Redis Documentation | Docs | Tiers, the modules-at-creation rule, clustering policies and vector search |
| Vector search concepts | Docs | FLAT versus HNSW and the FT.CREATE and KNN query syntax Azure Managed Redis exposes |
| Compare Messaging Services - Azure Service Bus | Docs | Settles Service Bus versus Event Grid versus Event Hubs questions |
| Scaling Deployments, StatefulSets & Custom Resources | Docs | KEDA scaler and activation concepts (Container Apps exposes them almost verbatim) |
| Azure Functions University | GitHub repo | Free lesson-based Functions curriculum with Python triggers and bindings |
| Must Learn KQL | GitHub repo | The free 20-part KQL series that Microsoft's own KQL learning page recommends |
| Kusto Detective Agency | Hands-on | Microsoft's gamified KQL challenges that build real query fluency |
| rag-postgres-openai-python | GitHub repo | End-to-end RAG on PostgreSQL with pgvector on Container Apps: three exam domains in one repo |
Realistic AI-200 exam-style questions with instant feedback and detailed explanations.
Practice AI-200 now