AI-200 — Microsoft Azure AI Cloud Developer Associate Cheat Sheet

Focus less on memorizing product names and more on answering: Which Azure AI service fits the requirement, how is it secured, how is it deployed, and how do you evaluate and troubleshoot it?

The goal is not to replace hands-on Azure work. The goal is to help you quickly recognize the major design choices, implementation patterns, traps, and troubleshooting signals that commonly appear in Azure AI developer scenarios.

1. Scan the decision tables first. AI developer exams often test whether you choose the right Azure AI service and integration pattern.
2. Review the traps. Many misses come from confusing similar services, authentication methods, indexing concepts, or generative AI terms.
3. Practice immediately after each section. Use topic drills to confirm that you can apply the idea under exam-style wording.
4. Read explanations even for correct answers. Detailed explanations help you notice distractors, missing requirements, and better service choices.
5. Finish with mixed mock exams. The real challenge is switching contexts quickly across AI Search, Azure OpenAI, Language, Vision, Speech, Document Intelligence, security, and deployment scenarios.

Service selection quick table

Azure OpenAI SDK Pattern

Use Microsoft Entra ID or managed identity where possible for production workloads. API keys are common in simple examples but should be protected.

from azure.identity import DefaultAzureCredential, get_bearer_token_provider
from openai import AzureOpenAI

token_provider = get_bearer_token_provider(
    DefaultAzureCredential(),
    "https://cognitiveservices.azure.com/.default"
)

client = AzureOpenAI(
    azure_endpoint="https://<resource-name>.openai.azure.com/",
    azure_ad_token_provider=token_provider,
    api_version="<api-version>"
)

response = client.chat.completions.create(
    model="<deployment-name>",
    messages=[
        {"role": "system", "content": "Answer using the provided policy excerpt only."},
        {"role": "user", "content": "What is the refund window?"}
    ],
    temperature=0.2
)

print(response.choices[0].message.content)

High-yield detail: in Azure OpenAI calls, model="<deployment-name>" commonly refers to the Azure deployment name, not just the base model family.

Model Choice Decision Points

RAG Design Matrix

Minimal Search Index Fields for RAG

Vector/Hybrid Search SDK Shape

from azure.search.documents import SearchClient
from azure.search.documents.models import VectorizedQuery
from azure.identity import DefaultAzureCredential

search_client = SearchClient(
    endpoint="https://<search-service>.search.windows.net",
    index_name="<index-name>",
    credential=DefaultAzureCredential()
)

vector_query = VectorizedQuery(
    vector=query_embedding,
    k_nearest_neighbors=5,
    fields="contentVector"
)

results = search_client.search(
    search_text="refund policy for annual subscriptions",
    vector_queries=[vector_query],
    filter="documentType eq 'policy'",
    select=["title", "content", "sourceUri", "pageNumber"],
    top=5
)

Use this pattern to remember the separation between query embedding, vector retrieval, metadata filtering, and prompt construction.

Knowledge Mining vs RAG

Azure AI Speech and Translator

Azure AI Vision and Document Intelligence

Azure AI Language review

Language service decision rules

• Use prebuilt capabilities when the requirement matches standard NLP tasks.
• Use custom classification or extraction when labels/entities are domain-specific.
• Use Azure OpenAI when the requirement is open-ended generation, reasoning over context, or flexible summarization.
• Use AI Search + Azure OpenAI when answers must be grounded in a large private corpus.
• For production extraction, plan for evaluation data, confidence thresholds, review queues, and error handling.

Prebuilt vs custom decision

Document extraction workflow

1. Receive document from an approved source.
2. Validate file type, size, and quality.
3. Select prebuilt, custom, or layout model.
4. Extract fields, tables, and confidence values.
5. Validate required fields and business rules.
6. Send low-confidence or high-risk cases to review.
7. Store extracted data with source traceability.
8. Monitor accuracy by document type and version.

Document Intelligence traps

• Do not choose generic OCR when the requirement asks for named fields from forms.
• Do not assume one custom model works for unrelated document layouts.
• Do not ignore confidence scores.
• Do not train on ideal samples only; include realistic variation.
• Do not skip downstream validation just because extraction succeeded.

Speech review

Speech traps

• Speech-to-text produces transcripts; it does not automatically summarize or classify unless combined with another service.
• Background noise and microphone quality affect recognition.
• Real-time scenarios prioritize latency; batch scenarios can prioritize completeness.
• Text-to-speech voice selection affects user experience but not text correctness.
• Translation, transcription, and conversational understanding are separate tasks.

Tool Calling Control Points

RBAC and Access Boundaries

Network Isolation Checklist

Responsible AI and Safety Controls

Authentication and authorization

Key security reminders

• Prefer Microsoft Entra ID and managed identities over static keys when supported.
• If keys are used, store them securely and rotate them.
• Keep secrets out of code, prompts, config files, and logs.
• Apply least privilege to data stores, search indexes, AI services, and monitoring systems.
• Treat prompts and model outputs as data that may contain sensitive information.
• Implement tenant isolation and document-level access checks for multi-user RAG apps.
• Validate all model-suggested actions before execution.

Hosting Service Selection

Evaluation Metrics by Scenario

Optimization Levers

RAG decision path

    flowchart TD
	    A[User asks a question] --> B{Need private or current knowledge?}
	    B -- No --> C[Prompt model with instructions]
	    B -- Yes --> D[Retrieve relevant content]
	    D --> E[Use Azure AI Search or another retrieval layer]
	    E --> F[Add retrieved passages to prompt]
	    F --> G[Generate grounded answer]
	    G --> H{Need citations or auditability?}
	    H -- Yes --> I[Return sources and confidence cues]
	    H -- No --> J[Return concise answer]

RAG implementation checklist

Prompt design review

Strong prompts usually include:

• Role or task: “You are an assistant that answers from provided policy excerpts.”
• Boundaries: “If the answer is not in the provided context, say you do not know.”
• Output format: JSON, table, bullet list, short paragraph, or classification label.
• Grounding rules: Use only retrieved content when required.
• Safety rules: Avoid restricted content, unsafe advice, or sensitive data exposure.
• Examples: Few-shot examples for formatting or classification consistency.

Weak prompts often:

• Ask for broad expertise without source boundaries.
• Mix several tasks without ordering them.
• Fail to specify output format.
• Trust the model to infer compliance, privacy, or security rules.
• Include user-controlled content in a way that enables prompt injection.

Generative AI traps

Search pattern comparison

AI Search implementation traps

• Mark fields correctly for searchable, filterable, sortable, facetable, and retrievable behavior.
• Do not expect to filter on a field that was not configured for filtering.
• Do not expose documents from unauthorized tenants; implement security trimming.
• Do not assume indexers support every source or transformation requirement.
• Use skillsets when enrichment is needed during indexing.
• Validate chunking and retrieval quality with realistic user questions.
• Monitor index freshness if source documents change frequently.
• Use metadata such as source URI, title, document type, timestamp, tenant, department, and permissions.

Conversational design rules

• Use the model for natural language understanding and generation, not for unchecked business authority.
• Store durable state in application storage where required.
• Validate user identity before retrieving private data.
• Apply security trimming before retrieved content reaches the prompt.
• Use structured tool/function calls for actions such as ticket creation, lookup, or transaction submission.
• Log enough context to troubleshoot without exposing sensitive information unnecessarily.

API and SDK reminders

• Know whether the scenario is asking for management-plane work, such as provisioning resources, or data-plane work, such as calling a model or analyzing a document.
• Handle transient failures with retries and backoff.
• Use regional endpoints and deployment names correctly.
• Do not expose service keys in client-side code.
• Validate request size, supported file formats, and rate/throughput limits in design scenarios.
• Use structured outputs when downstream systems need reliable parsing.
• Log correlation IDs and request metadata for troubleshooting.

Troubleshooting signals

Architecture mistakes

• Putting service keys in browser or mobile client code.
• Forgetting managed identity and least privilege.
• Building RAG without document-level authorization.
• Treating embeddings as a database replacement.
• Ignoring index field attributes needed for filters and facets.
• Sending too much irrelevant context to the model.
• Skipping human review for high-impact automated decisions.

Exam-reading mistakes

• Missing qualifiers like prebuilt, custom, real-time, batch, private data, least privilege, low latency, or structured output.
• Answering for the most advanced technology instead of the simplest service that satisfies the requirement.
• Confusing safety, security, and correctness.
• Ignoring whether the task is ingestion, retrieval, generation, deployment, or monitoring.
• Overlooking that the app, not the model, must enforce identity, authorization, and business rules.