Exam overview & is this realistic in 22 days?

Short answer: yes — it's achievable, because you've already cleared AI-901, you understand RAG and the concepts, and the exam rewards breadth of Azure AI knowledge more than deep coding. The one thing you must fix: you cannot lean on AI to write code in the exam, but you also won't be asked to. AI-103 is a knowledge exam (mostly multiple choice, drag-and-drop, code-completion and scenario sets) — it tests whether you know which service, model, setting or code pattern fits a scenario, not whether you can build it from scratch.

Official skills measured & weights

Logistics that actually matter

• Register with a personal Microsoft account (MSA), not a work/school account. If you register with an organisational account and later leave the org, your exam records are lost and unrecoverable.
• Most questions are on Generally Available (GA) features. Widely-used preview features can appear too. Don't ignore preview — but don't over-invest.
• English is updated first; localised versions follow ~8 weeks later.
• There is an official exam sandbox you can practise in before test day — do this once so the UI is not a surprise.
• Credentials expire annually; renew with a free online assessment (no paid resit).

Why 22 days is enough (and the risk that isn't)

The 22-day study plan (11 Oct → 1 Nov)

Today is Sunday 11 October. The exam is Sunday 1 November. That is three weekends and 21 study days — day 22 is the exam itself. Your budget is 2 hours every weekday and 2.5–3 hours at the weekend, about 40 focused hours: enough for an associate exam when a good part of it is revision of material you already know. The plan below is the version that targets 80%+ on the weighted self-check.

Week 1 — Foundations & the two heavy domains (Sun 11 – Sat 17 Oct)

Week 2 — Agents, evaluation, and the three light domains (Sun 18 – Sat 24 Oct)

Week 3 — Text, speech, and full revision (Sun 25 – Sat 31 Oct)

How to use this guide

• Nav on the left jumps between sections. Your browser back button works too.
• Search box hides everything that doesn't match — great for "where was that term?".
• Checkboxes at the bottom of each section track studied progress (saved in this browser). The bar top-left fills up. The checkboxes are the plan — clear them all before the exam.
• Cloud sync (top bar) sends those ticks and your last self-check score to your own Cloudflare endpoint so your laptop and phone share them: press Generate code on one device, then type the same code on the others. The code is the only key — keep it private.
• Print / PDF produces a clean white printable version — save it as your offline revision copy.
• Practice questions are multiple-choice: read the stem, decide your answer, then click to reveal the options with the correct answer in green and the distractors in red, plus the reasoning.
• Scored self-check is the exam-weighted version — 25 scenario questions you answer and score like the real thing, with a projected score and a per-domain breakdown. Aim for 80%+ twice in a row before you book.

Official Microsoft Learn prep

Everything below is Microsoft's own material for AI-103: the four entry points, then the self-paced learning paths that line up with each exam domain. Use it alongside this guide — read a domain here, then do its matching modules on Learn.

Self-paced learning paths, mapped to the exam domains

These paths are not tagged "AI-103" on Learn, but their objectives line up with the domains below. Durations are the official ones (verified Oct 2026).

Community field notes r/AzureCertification

Candidates who have already sat AI-103 post detailed write-ups on Reddit. This section condenses the consistent signals — what the exam looks like on the day, where it goes deeper than the outline implies, and the third-party material people actually used. It is community experience, not official Microsoft guidance: the outline in Official MS Learn prep stays the source of truth, and everything here is the field intelligence layered on top.

Domain 1 · Plan and manage an Azure AI solution 25–30%

This is the "architect + operator" domain: pick the right service and model, set the project up, secure it, watch it, and keep it responsible. Four objective clusters.

1.1 The platform vocabulary (learn this cold)

Microsoft has renamed and reshuffled its AI stack. The exam expects the current names.

1.2 Choosing the right model for the task

Model families in the Foundry catalog, and when to pick each:

1.3 Choosing Foundry services for each job

1.4 Retrieval & indexing methods

• Keyword (full-text) — BM25-style. Exact terms, cheap, weak on paraphrase.
• Vector — nearest-neighbour on embeddings. Strong on meaning, needs an embedding model.
• Hybrid — keyword + vector together, fused (RRF). Usually the best default for RAG.
• Semantic ranker — a re-ranking layer on top of results using a language model; improves relevance ordering. (Enabled on a search index — a layer, not a separate index.)
• Agentic retrieval — the search service itself decomposes a query, runs multiple sub-queries, and returns grounded results for an agent.

1.5 Setting up AI solutions in Foundry

• Design the infrastructure: a Foundry resource (hub of model + tools) → one or more projects → model deployments and connections (to AI Search, storage, Document Intelligence, etc.).
• Connections are how a project reaches other Azure resources without hard-coding keys — you add a connection and reference it by name.
• Deployment options (see the next table) decide capacity, cost model and data residency.
• CI/CD: treat Foundry projects as infrastructure-as-code. Provision with Bicep/Terraform/ARM, deploy agents and evaluators through pipelines, keep prompts/instructions versioned. Agents get versions (create_version), so you can promote a tested version.
• Memory, tool & knowledge integration services (pick per agent, don't hand-roll): memory = conversation history plus a longer-term store; tools = custom functions/APIs and MCP servers; knowledge = Azure AI Search indexes, knowledge stores, and Content Understanding over documents/audio/video.

1.6 Manage, monitor and secure

Quotas, scaling, rate limits, cost

• TPM/RPM = tokens-per-minute / requests-per-minute quotas per deployment. Hitting them returns HTTP 429 → retry with backoff or raise quota / use PTU.
• Scaling: raise TPM on a deployment, add deployments, or move to provisioned throughput.
• Cost control: right-size the model (mini vs frontier), use Batch for bulk, monitor token usage, set budgets/alerts.

Monitoring

• Azure Monitor for metrics/logs; Application Insights for app-level telemetry.
• Watch model performance & drift, safety events, and grounding quality (is the answer actually supported by retrieved context?).
• Watch data ingestion quality, search index health and relevance for RAG pipelines.
• Foundry tracing is OpenTelemetry-based — token analytics, latency breakdowns, safety signals.

Security — the high-value list

1.7 Responsible AI across gen & agentic systems

• Safety filters / content moderation — Azure AI Content Safety screens for hate, violence, sexual, self-harm, each with a severity level (Safe / Low / Medium / High). You choose thresholds per category. Applies to input and output.
• Guardrails — rules that constrain what a model/agent may do (allowed topics, blocked content, required disclosures).
• Prompt Shields — defend against direct prompt injection (user jailbreak) and indirect prompt injection (malicious instructions hidden in retrieved documents or in text embedded in images). Related technique: spotlighting (marking untrusted input so the model treats it as data, not instructions).
• Groundedness detection — flags outputs not supported by source material (fabrication/hallucination).
• Evaluators — quality (groundedness, relevance, coherence, fluency, similarity) and risk/safety evaluators. Run safety evaluations and red-team scans against an app or agent. Explanation tooling surfaces why a model produced an output (which evidence/features drove it) — the third leg of responsible-AI instrumentation alongside evaluators and safety evaluations.
• Auditing — trace logging, provenance metadata (e.g. Content Credentials/C2PA for generated media), approval workflows.
• Governing agent behaviour — oversight modes (human-in-the-loop vs autonomous), constraints, and tool-access controls (which tools an agent may call).

Domain 2 · Implement generative AI and agentic solutions 30–35%

The biggest domain. Two halves: build generative apps (deploy, RAG, workflows, evaluate, connect) and build agents (roles, tools, memory, orchestration, safeguards).

2.1 Deploy and consume models

• Deploy a model from the catalog into your project, then call it by its deployment name.
• Consume it through the Foundry SDK: get an OpenAI-compatible client from the project and call it.
• Connect an application to a project via the project endpoint: https://<resource>.services.ai.azure.com/api/projects/<project>.

pip install "azure-ai-projects>=2.3.0" azure-identity
az login

import os
from azure.ai.projects import AIProjectClient
from azure.identity import DefaultAzureCredential

with (
    DefaultAzureCredential() as credential,
    AIProjectClient(endpoint=os.environ["FOUNDRY_PROJECT_ENDPOINT"],
                    credential=credential) as project_client,
):
    with project_client.get_openai_client() as openai_client:
        response = openai_client.responses.create(
            model=os.environ["FOUNDRY_MODEL_NAME"],   # a DEPLOYMENT name
            input="What is the size of France in square miles?",
        )
        print(response.output_text)

2.2 RAG — retrieval-augmented generation

The core pattern of the whole exam. Learn the flow, not the code:

2.3 The Responses API (Agents v2) — the current runtime

Foundry's agent runtime is the Responses API, built on four ideas:

from azure.ai.projects.models import PromptAgentDefinition

agent = project.agents.create_version(
    agent_name="helpdesk-agent",
    definition=PromptAgentDefinition(
        model="gpt-5-mini",
        instructions="You are a helpful assistant that answers general questions",
    ),
)

openai = project.get_openai_client(agent_name="helpdesk-agent")
conversation = openai.conversations.create()
r1 = openai.responses.create(conversation=conversation.id,
                             input="What is the size of France?")
r2 = openai.responses.create(conversation=conversation.id,
                             input="And its capital city?")   # remembers turn 1

2.4 Design workflows & reasoning pipelines

• Tool-augmented flows — the model decides to call a function/API, gets the result, continues.
• Multistep reasoning — chain prompts (decompose → solve → verify) for tasks a single call does poorly.
• Self-critique / reflection — the model reviews and revises its own output; a common quality booster.
• Hybrid LLM + rules — combine the model with deterministic business logic where correctness is mandatory.
• Foundry provides workflows to wire these steps (and connectors) together visually or in code.

2.5 Evaluate models and apps

Run evaluations in Foundry against datasets, compare model/prompt variants, and gate deployments on the results (ties back to CI/CD in Domain 1).

2.6 Build agents

• Define roles, goals, conversation-tracking and tool schemas — the agent's instructions set its role/goal; the conversation carries memory; tools are declared with schemas so the model knows how to call them.
• Integrate retrieval, function-calling and conversation memory — retrieval (AI Search), functions (your code/APIs), memory (conversation history, plus longer-term stores).
• Tools an agent can use: Azure AI Search (knowledge), APIs / custom functions (actions), knowledge stores, and Content Understanding (reading documents/audio/video).
• Hosted agents — run your own containerised agent code with Foundry providing managed hosting and scaling.

2.7 Orchestrated multi-agent solutions

• Connected agents — a primary agent delegates subtasks to specialist agents.
• Multi-agent workflows — several agents arranged in a pipeline/sequence with a coordinator.
• Autonomous / semi-autonomous workflows — agents that act with limited supervision, bounded by safeguards, approval flows (human-in-the-loop for risky actions), and tool-access controls.
• Use multi-agent when a single agent's instructions/tools become too broad or conflicting — split by specialism.

2.8 Monitor & evaluate deployed agents

• OpenTelemetry tracing into Application Insights: each agent step, tool call, token count and latency.
• Track agent behaviour over time — quality, safety signals, and drift — with continuous evaluation, and feed failures back into prompts/tools. This feedback loop is error analysis: inspect failed runs (which step or tool call went wrong) and fix the instruction, tool, or retrieval.

2.9 Optimize & operationalize generative AI

The official outline groups a third cluster here — the things you do after it works:

• Tune generation behaviour — prompt engineering plus model parameters (temperature, top_p, max_tokens, stop sequences). Low temperature for determinism; right-size max tokens for cost/latency.
• Improve quality without retraining — model reflection / self-critique, chain-of-thought, and iterative prompt refinement (see 2.4).
• Observability — tracing (OpenTelemetry), token analytics, safety signals and latency breakdowns to find cost/latency hotspots and quality drift.
• Orchestrate — combine multiple models, multiple flows, and hybrid LLM + rules engines where correctness must be deterministic.

Domain 3 · Implement computer vision solutions 10–15%

Generation and editing of images/video, multimodal understanding, and the responsible-AI angle specific to visual content.

3.1 Image generation & editing

• Generation from text prompts (and reference media) using gpt-image-1 (replaces the retired DALL·E 3).
• Editing — prompt-driven modification, inpainting (regenerate only a masked region), and mask-based edits. Think "keep the background, change one object".
• Generation can be conditioned on a reference image (style/composition guidance).

3.2 Video generation & editing

• Text-to-video and video editing using Sora.
• Platform-level generation/editing controls (duration, aspect, edit vs generate).
• Video segment analysis for understanding, not just generation.
• Azure AI Video Indexer — the classic service for deep video understanding (transcripts, speakers, topics, scenes) when you need indexed video rather than generated video.

3.3 Multimodal understanding

• Visual context analysis — reason about an image with a multimodal model.
• Captions — concise or detailed descriptions of an image.
• Visual question answering (VQA) — answer questions grounded in image evidence.
• Alt-text & extended image descriptions — both a short alt-text and a longer extended description, aligned to accessibility guidelines.

3.4 Azure Content Understanding for vision

• Analyzers process images, video (and documents/audio). Base ones: prebuilt-image, prebuilt-video.
• Outputs visual characteristics and video segments.
• Single-task vs pro-mode pipelines: single-task = one focused extraction; pro-mode = a richer multi-stage pipeline for harder content.
• Object / component / region identification — locate and label things in an image.

3.5 Responsible AI for multimodal content

• Classify unsafe visual content (e.g. with Azure AI Content Safety image analysis).
• Indirect prompt injection via text embedded in images — malicious instructions hidden inside a picture. A high-yield vision-specific risk!
• Visual policy enforcement — watermarks, prohibited symbols, brand usage, inappropriate content.
• Provenance — Content Credentials / C2PA metadata marking AI-generated media.

Domain 4 · Implement text analysis solutions 10–15%

Text (entities, topics, summaries, sentiment, translation) and speech. Remember: speech is not its own domain — it lives here, so don't double-count it.

4.1 Extraction with prompting vs Foundry Tools

4.2 Detection

• Sentiment & opinion mining — positive/negative/neutral, per sentence or per aspect.
• Tone and safety issues detection.
• PII / sensitive content — detect (and optionally redact) personal data.
• Key phrase & topic extraction, language detection, summarisation (extractive and abstractive).

4.3 Translation

• Azure Translator — dedicated translation service, many languages, document translation.
• LLM-powered translation flows — when you need translation plus reasoning/tone in one step, or unusual language/domain handling.

4.4 Speech (inside this domain)

Domain 5 · Implement information extraction solutions 10–15%

The ingestion/retrieval half of RAG: get documents, images, audio and video into a searchable form, then ground an app or agent in it.

5.1 Ingest & index multimodal content

• Ingest documents, images, audio and video — not just text.
• Two ingestion styles: pull (an indexer reaches out to a data source) vs push (you send data into the index).
• Split into chunks, embed, and store in an index with usable metadata.

5.2 Configure search for grounding

5.3 Enrichment (skillsets)

• Built-in skills — OCR, language detection, entity/key-phrase extraction, translation, image captioning/analysis.
• Custom skills — your own code (e.g. an Azure Function) or a model call, chained in a skillset during indexing.
• The RAG ingestion flow can include OCR so scanned pages become searchable text.
• Connect retrieval pipelines to workflows and agent tools — an agent uses an index/hits as a knowledge tool.

5.4 Document Intelligence vs Content Understanding

5.5 Content Understanding analyzers — the anatomy

An analyzer is a JSON configuration saying what content, what to extract, what output shape, and which models.

{
  "analyzerId": "myCustomInvoiceAnalyzer",
  "description": "Extracts vendor info, line items and totals",
  "baseAnalyzerId": "prebuilt-document",
  "config": { "enableOcr": true },
  "fieldSchema": { "fields": { "vendorName": { "type": "string" } } },
  "models": {
    "completion": "gpt-5.2",              // extraction/segmentation/reasoning
    "embedding": "text-embedding-3-large" // for knowledge-base use
  }
}

• baseAnalyzerId — inherits a base analyzer; override what you need. Custom analyzers build on one of the four base types.
• fieldSchema — the fields you want (a custom schema).
• models.completion / models.embedding — use catalog model names, not deployment names; the service maps them to your resource's deployments.
• Description matters — CU uses it as context during extraction, so a precise description improves accuracy.
• API versions: GA is 2025-11-01; preview features use 2026-06-01-preview. Agentic mode (reason/validate over evidence) is a preview capability.
• Output can be structured JSON fields or markdown — markdown output is what feeds RAG.

Cheat sheet — the high-yield facts

If you read nothing else on the morning of the exam, read this page.

Names that must be exact

• Platform: Microsoft Foundry (not "Azure AI Foundry" except for legacy contrast). Prebuilt services: Foundry Tools (old: Azure AI Services / Cognitive Services).
• Container of work: Foundry project; SDK: azure-ai-projects; endpoint https://<resource>.services.ai.azure.com/api/projects/<project>.
• Agent runtime: Responses API — agents, conversations, items, responses, agent versions (create_version). Legacy Assistants API (threads/messages/runs/assistants) is retired — use Foundry Agents.
• Keyless inference role: Foundry User (formerly Azure AI User); classic Azure OpenAI uses Cognitive Services OpenAI User.
• Auth: Entra ID only, DefaultAzureCredential, Python 3.10+, azure-ai-projects>=2.3.0.

Model choice in one line

Reasoning/quality → frontier/reasoning model · Volume+simple → mini/small (Phi) · Images → multimodal · Search → embeddings + chat · Picture/video out → gpt-image-1 / Sora.

Deployment choice in one line

Default → Global Standard · Residency → Data Zone/Regional · Predictable high load → PTU · Bulk offline → Batch · No deployment → instant/direct model.

Search choice in one line

Exact terms → keyword · Meaning → vector · Best default → hybrid · Better ranking on existing index → semantic ranker · Query decomposition for agents → agentic retrieval.

Documents in one line

Structured + known fields / labelled → Document Intelligence · Unstructured / no labels / needs reasoning / RAG-ready → Content Understanding.

Responsible AI one-liners

• Harm categories: hate, violence, sexual, self-harm with severity levels.
• Prompt injection: direct (user) vs indirect (hidden in retrieved docs or embedded text in images) → guarded by Prompt Shields; technique spotlighting.
• Hallucination check → groundedness evaluator / groundedness detection.
• Quality evaluators: groundedness, relevance, coherence, fluency, similarity.
• Provenance of generated media → Content Credentials / C2PA.
• Tracing → OpenTelemetry → Application Insights.

Speech vocabulary

STT · TTS · custom speech · Realtime API · speech translation · batch transcription · neural voice.

Exam traps — the confusable pairs

These are the specific places AI-103 questions try to trick you. Read twice.

Practice questions

Multiple-choice, in the style of AI-103 (scenario + best answer). Read the stem, decide your answer, then click to reveal — the correct option is green, the distractors are red, with the reasoning underneath.

Scored self-check (exam-weighted)

Twenty-five scenario questions, weighted the way the exam is: Domain 2 carries the most, then Domain 1, then D3–D5. Answer them all without looking back, then press Score it. You get a projected score, a per-domain breakdown, and the domain to study next — the same feedback loop the AI Skills Navigator assessment gives you, inside the guide.

Glossary — quick definitions