AI-900 Cheat Sheet

AI-900 leans on recognizing a handful of recurring Azure AI workload categories from a business scenario: computer vision, natural language processing (NLP), document intelligence / knowledge mining, generative AI, and machine learning underneath them all. The official "Identify features of common AI workloads" objective, however, names exactly four: computer vision, natural language processing, document processing, and generative AI, and is essentially a classification drill: read the scenario, name the category. Machine learning is NOT under that objective; it sits in its own skill area. Categories overlap in practice (a chatbot blends NLP and generative AI), but each is tested individually.

Trap Listing knowledge mining or machine learning among the workloads under the single "common AI workloads" objective. The official outline names only four, and says "document processing," not "knowledge mining."

The fastest way to name a workload is the input→output test: tabular data in, a predicted score or class out = machine learning; image in, labels/boxes/extracted text out = computer vision; text or audio in, entities/sentiment/translation out = NLP; a form in, structured fields + a search index out = document intelligence; a prompt in, brand-new content out = generative AI. Most AI-900 scenario items are answerable on this signature alone.

Trap Calling a scenario that outputs structured fields from a form "computer vision" because an image went in. Image-in alone is vision, but field/key-value output is the document intelligence signature.

A machine learning workload trains a model on historical data to predict a numeric value (regression) or a category (classification) for new, unseen data; the output is a score or label, never new content. Predicting a house price from size and location is regression; flagging a transaction as fraudulent is classification. Numeric-looking labels (tier 1/2/3) are still classification, because the values are discrete classes, not a quantity on a continuous scale.

Trap Calling a tier-1/2/3 or category prediction "regression" because the labels look numeric. Discrete classes are classification; regression is only for a continuous value.

Machine learning underpins the other categories rather than competing with them: computer vision, NLP, and generative AI models are themselves ML models, typically deep neural networks trained on large datasets. That is why a bespoke prediction task with no off-the-shelf option points to Azure Machine Learning, while the prebuilt vision, language, and document services simply package already-trained ML models behind an API.

Trap Selecting Azure Machine Learning whenever "machine learning" is mentioned. A prebuilt vision or language service is still ML under the hood, so the prebuilt service is the answer unless the scenario demands training a custom model.

A computer vision workload extracts meaning from visual input: still images, video, or camera streams. Its core solution types are image classification (one label for the whole image), object detection (per-object labels with bounding-box coordinates, so it can locate and count), semantic segmentation (per-pixel masks for more precise location), facial detection and analysis, and OCR to read text. "Count the cars in a photo" and "read a license plate" are vision tasks.

Trap Choosing image classification when the scenario needs each item located or counted. A single whole-image label has no coordinates; locating multiple objects is object detection.

A natural language processing workload turns unstructured text or audio into structured insight: sentiment analysis, key phrase extraction, named entity recognition, language detection, translation, and speech-to-text transcription. "Flag negative reviews" and "transcribe a support call" are NLP scenarios. The output is structure about existing language (a sentiment, an entity, a transcript), not newly authored content.

Trap Tagging "write a reply to the customer" as NLP because it involves language. NLP returns structure about existing text; authoring new text from a prompt is generative AI.

For AI-900 workload classification, speech (speech-to-text, text-to-speech, speech translation) and translation belong to the NLP exam domain. The official outline lists "speech recognition and synthesis" and "translation" under NLP and names both Azure AI Language and Azure AI Speech as its services. So "transcribe a phone call" or "read this text aloud" is correctly an NLP/language workload.

Trap Classifying a speech-to-text or translation scenario as its own separate workload category. On AI-900 these roll up under the NLP / language domain rather than standing apart from it.

Knowledge mining ingests large volumes of mixed content and applies AI enrichment so it becomes searchable and explorable at scale, built on Azure AI Search. When a scenario emphasizes searching or exploring a whole body of documents, rather than pulling specific named fields from a form, the signal is knowledge mining, not document intelligence.

Trap Reaching for document intelligence when the goal is full-text search across a large corpus. Extracting named fields from one form is IDP; making the whole corpus searchable is knowledge mining.

A generative AI workload takes a natural-language prompt and produces new, original content (text, code, summaries, or images) instead of a fixed label or score. "Draft a marketing email," "summarize this report," and "generate an image from a description" are generative scenarios. The defining contrast: the other categories analyze or predict on existing input, while generative AI synthesizes something new.

Trap Labeling "summarize this report" as NLP because it processes text. Condensing existing text into new prose is a generative AI task; NLP returns structure like entities or sentiment, not authored output.

AI-900 pairs each workload with its primary Azure service: custom ML → Azure Machine Learning; computer vision → Azure AI Vision; NLP → Azure AI Language (plus Azure AI Speech for audio); document intelligence → Azure AI Document Intelligence; knowledge mining → Azure AI Search; generative AI → Azure OpenAI. This one-workload-to-one-service mapping answers most service-selection items. (Docs may now title these "in Foundry Tools," but the established names remain exam-current.)

Trap Picking Azure AI Vision for a read-the-fields-from-a-form scenario because both involve images. Text-only OCR is Vision, but extracting structured fields maps to Azure AI Document Intelligence.

AI-900 tests build-vs-consume: Azure Machine Learning is the answer only when you must train your own model for a bespoke prediction with no off-the-shelf option. The vision, language, and document services are prebuilt: already-trained models behind a simple API, no data-science skill required. Stems saying "least development effort" or "without data science expertise" steer you to a prebuilt Azure AI service, not Azure Machine Learning.

Trap Picking Azure Machine Learning for a "least effort / no data scientists" scenario. That phrasing points to a prebuilt Azure AI service; AML means you train the model yourself.

Computer vision and document intelligence both read text via OCR and are paired as distractors. The discriminator is the goal: if you just need the raw text out of an image (a photo, a sign, a poster) that is computer vision (Read OCR); if you need specific structured fields such as the total, invoice number, or line items from a form, that is document intelligence, which uses OCR as its foundation but adds field/table/key-value extraction.

Trap Choosing document intelligence just because the input is text in an image. Pulling raw text from a sign or poster is Vision Read OCR; document intelligence is only when you need named fields from a form.

NLP and generative AI both operate on text, making them common distractors. NLP analyzes existing text and returns structure: sentiment, entities, key phrases; generative AI produces new text from a prompt. "Determine if a review is positive" is NLP (sentiment analysis); "write a reply to the review" is generative AI.

Trap Calling "write a reply to the review" NLP because a review went in. Analyzing the review's sentiment is NLP, but composing a new reply is generative AI.

A channel is the connection between Azure AI Bot Service and a communication app such as Microsoft Teams, web chat, Slack, Facebook, Telegram, or SMS (via Twilio). Because the Bot Framework is channel-agnostic, you build one bot and deploy it to many channels without rewriting code per channel. Bot Service is the build/deploy framework: it delegates language understanding to Azure AI Language, it is not itself an NLP service.

Trap Treating Azure AI Bot Service as the service that does the NLP. It hosts and connects the bot but delegates intent/entity understanding and FAQ answers to Azure AI Language.

The Bot Connector Service is the Azure Bot Service component that relays messages and events between a bot and its channels, translating the Bot Framework activity schema to and from each channel's native format. This normalization is what lets the bot stay channel-agnostic: the bot speaks one schema while the connector adapts it per channel.

Trap Assuming the Bot Connector Service interprets the user's intent. It only relays and translates messages between the bot and its channels; understanding the language is delegated to Azure AI Language.

In Azure AI Search, an indexer is the crawler that connects to a data source, performs document cracking to extract text and images, and populates the index. A skillset is the collection of AI-enrichment skills (OCR, entity recognition, key-phrase extraction, translation) the indexer runs over that content. A knowledge store optionally saves the enriched output as tables or objects in Azure Storage for use outside search, for example analysis in Power BI.

Trap Confusing the knowledge store with the search index. The index is what search queries hit, while the knowledge store persists enriched output to Azure Storage for use outside search.

A knowledge-mining solution on Azure AI Search runs in three phases: ingest content from data sources via the indexer (document cracking), enrich it with AI skills to extract information and patterns, and explore the indexed result through search queries, apps, or visualizations. The enriched output always lands in a search index, and optionally in a knowledge store for downstream use.

In Conversational Language Understanding, an intent represents the task or action a user wants to perform (e.g., BookFlight), while entities are the words in the utterance that supply the details needed to fulfill that intent (the destination, date, or product). The model predicts one overall intent per utterance and extracts its entities. An utterance is the user's short natural-language input that the model is trained on.

Trap Mixing up intent and entity. The intent is the single overall action the user wants, while entities are the detail words within the utterance that fill in that action.

Map the task to the feature: named entity recognition identifies entries in text and categorizes them into predefined types (people, organizations, locations); key phrase extraction returns the main concepts/topics as a list; sentiment analysis returns positive/negative/neutral with confidence; and PII detection identifies (and can redact) sensitive data such as SSNs and phone numbers. These are all Azure AI Language features, not the legacy brand names that appear in distractors.

Trap Selecting a retired brand like LUIS or QnA Maker for these tasks. On exam-current AI-900, the single answer for NLP text features is Azure AI Language.

Azure AI Document Intelligence (formerly Form Recognizer) provides prebuilt models for common documents: invoice, receipt, ID, and layout, where layout extracts text, tables, selection marks, and structure, plus custom models for unique business forms, all returned as structured JSON. Choose a custom template model when your forms share a consistent, static visual layout, and a custom neural model for mixed-type or varied documents.

Trap Building a custom model for a standard invoice or receipt. Document Intelligence already ships prebuilt models for those; custom models are for unique business forms with no prebuilt match.

In Azure AI Vision Image Analysis, tagging returns content tags (objects, living beings, scenery, actions, even indoor/outdoor) each with a confidence score but no location. Object detection goes further, adding bounding-box coordinates for each detected object. A caption returns a single natural-language sentence describing the whole image. So "what is in this image" can be tagging, but "where is each object" requires object detection.

Trap Expecting image tagging to tell you where each object is. Tags carry confidence scores but no coordinates; bounding boxes come from object detection.

Azure AI Vision's Read OCR engine uses optical character recognition to extract both printed and handwritten text from images and documents, including mixed-language and mixed-mode (print + handwritten) pages. It returns pages, text lines, and words with their location and a confidence score. "Read the text," "handwritten," or "OCR" fingerprints Azure AI Vision rather than Document Intelligence.

Trap Assuming Read OCR only handles printed text and reaching for another service for handwriting. The Read engine extracts both printed and handwritten text, including mixed print-plus-handwritten pages.

Azure AI Face detection (the Detect API) locates each face and returns its rectangle coordinates without identifying anyone. It is required as the first step in every other scenario. Recognition goes further: verification is one-to-one ("do these two faces belong to the same person?", e.g. selfie vs. ID photo, with a confidence score), identification is one-to-many against a person group, and the Group operation clusters unknown faces by similarity. Face recognition is Limited Access, gated by Responsible-AI eligibility.

Trap Assuming face detection tells you who a person is. Detection only returns the face's location; matching it to an identity is verification or identification.

Supervised learning trains on past observations that include both feature values and the correct answers (labels), then predicts the label for new cases; unsupervised learning trains on feature values only, with no labels, and finds structure in the observations themselves. The mechanical test: if every training row already carries the right answer, it's supervised (regression, classification); if there's no answer column, it's unsupervised (clustering).

Trap Calling a task unsupervised because it discovers patterns, when the training data already supplies known labels and the work is really supervised.

Regression is supervised learning whose predicted label is a numeric value, learned from past observations that pair features with a known number. The exam tell is a stem asking 'how much / how many / what value / what amount': forecasting a quantity, price, count, rate, or score is regression, not classification.

Trap Reaching for classification when the question asks to forecast a continuous amount like sales or price.

Microsoft's AI-900 regression examples recur verbatim: number of ice creams sold on a day from temperature, rainfall, and windspeed; a property's selling price from its size, bedrooms, and location metrics; and a car's fuel efficiency (miles-per-gallon) from engine size and dimensions. Each predicts an amount (a count, a price, a rate) which is the regression signature.

A number that names a category is still a class, so predicting whether a customer is in tier 1, 2, or 3 is classification, not regression: the values are discrete classes, not a continuous quantity. Regression applies only when the output is a value on a continuous scale; a fixed set of categories means classification even when the labels happen to be numbers.

Trap Picking regression because the label values are numbers (tier 1/2/3), when they're really discrete classes.

Classification is supervised learning whose label represents a categorization, or class, rather than a number; like regression it needs labeled training data, but the answer is a category. The exam tell is a stem asking 'which category / which class / true or false': contrast regression, which answers 'how much.'

Trap Choosing regression for a 'which category' stem because the training data is labeled, when a categorical answer means classification.

Binary classification predicts one of two mutually exclusive outcomes: a true/false or positive/negative result for a single class. Microsoft's examples: whether a patient is at risk for diabetes from clinical metrics; whether a bank customer will default on a loan from income and credit history; whether a mailing-list customer will respond positively to an offer. The shape is always two options: yes/no, will/won't, is/isn't.

Trap Choosing multiclass classification for a yes/no question that only ever has two possible outcomes.

Multiclass classification extends binary classification to predict one label out of multiple possible classes, and in most scenarios those labels are mutually exclusive: the model picks exactly one. Microsoft's examples: the species of a penguin (Adelie, Gentoo, or Chinstrap) from physical measurements, and the genre of a movie (comedy, horror, romance, adventure, or science fiction) from cast, director, and budget. A penguin can't be both Gentoo and Adelie, so standard multiclass returns a single class.

Trap Treating a several-classes-but-exactly-one scenario as multilabel, when mutually exclusive classes make it standard multiclass.

Multilabel classification trains models in which more than one valid label can apply to a single observation, for example a movie tagged as both science fiction and comedy. If a stem says an item can carry more than one category at once, it's multilabel; if each item gets exactly one of several categories, it's standard multiclass.

Trap Calling a multiple-tags-per-item scenario multiclass, when overlapping labels make it multilabel.

Clustering is the most common form of unsupervised learning: it identifies similarities between observations from their features and groups them into discrete clusters, with no previously known label to learn from. Microsoft's examples: grouping similar flowers by size, number of leaves, and number of petals, and segmenting similar customers by demographics and purchasing behavior.

Both clustering and classification assign observations to discrete groups, so AI-900 leans on the difference: classification is supervised (you already know the classes and learn the mapping to those labels) while clustering is unsupervised, with no predefined label, grouping purely by feature similarity. A scenario that supplies known class labels is classification; one with no labels where you discover natural groupings is clustering.

Trap Calling an unlabeled grouping task classification because both methods sort items into groups.

Clustering is often run first to discover what classes exist: Microsoft's pipeline segments customers into clusters, analyzes and labels those segments (such as 'high value – low volume'), then uses that newly labeled data to train a classification model that predicts which segment a new customer belongs to. The pattern is cluster to discover, label, then classify to assign.

Trap Assuming the clustering model itself assigns each new customer to a segment, when a separate classification model trained on the labeled segments does that.

Deep learning is an advanced form of machine learning that emulates how the human brain learns by building an artificial neural network. Each neuron is a function operating on an input value (x) and a weight (w), wrapped in an activation function that decides whether to pass its output to the next layer; stacking multiple layers forms a deeply nested function: that depth is why it's called deep learning, and the models are deep neural networks (DNNs).

A deep neural network isn't a separate problem type: like other techniques it fits training data to a function predicting a label (y) from features (x), so DNNs perform regression and classification and underpin specialized computer-vision and natural-language models. Training feeds features forward to produce predictions, uses a loss function to measure error against the known y, then adjusts weights (typically gradient descent backpropagated through the layers) over many epochs until loss is minimized; the trained model is just the final weight values.

Trap Treating deep learning as its own kind of ML problem distinct from regression and classification, rather than another way to perform them.

A convolutional neural network (CNN) is a deep-learning architecture for images: filters in convolutional layers extract numeric feature maps from image pixels, pooling layers downsize those maps to emphasize key visual features, and the flattened features feed a fully connected network that predicts a label. Filter weights start random and are tuned over training epochs against known labels, making CNNs the standard architecture for image classification.

Trap Reaching for a Transformer (or RNN) as the go-to architecture for image classification, when CNNs are the standard choice for images.

The Transformer architecture underpins large language models with two blocks: an encoder that builds embeddings by applying attention (weighing how each token is influenced by the tokens around it) and a decoder that uses those embeddings to predict the next most probable token, generating output one token at a time. It doesn't look anything up; it repeatedly predicts the next token, like super-powerful predictive text.

Trap Assuming a language model retrieves stored answers, when a Transformer generates text by repeatedly predicting the next most probable token.

Every vision solution type takes the same input (an image) so the reliable way to choose one is to match the requested output. Classification emits a single whole-image label, object detection emits labels plus bounding boxes, semantic segmentation emits a per-pixel mask, OCR emits text, and facial detection emits face locations. Read the stem for the output shape it wants and the service falls out.

Image classification predicts a single text label for an image's main subject, a produce item on a checkout scale classified as "apple". It says what the image is about but reports no coordinates, no count, and no per-object location, so it cannot tell you where an item is or how many are present.

Trap Reaching for image classification when the scenario needs to locate or count multiple items on the checkout: classification only labels the whole frame.

Object detection examines multiple regions of an image to find individual objects and their locations, returning for each object a class label plus the coordinates of a rectangular bounding box. Because every object is reported separately, detection can also count how many items are present, the capability classification lacks.

Trap Expecting image classification to count multiple items when only object detection reports each object separately and can tally them.

Classification gives one whole-image label and cannot say where or how many; object detection localizes and counts each object with a bounding box. A stem asking to identify each item placed on a checkout and where each one sits is object detection, not classification.

Trap Choosing image classification for a "scan and identify each item plus its location" scenario: only detection returns per-object boxes.

Semantic segmentation is a more sophisticated form of object detection in which the model classifies individual pixels by the object they belong to, producing a per-pixel mask instead of a rectangle. The mask traces an object's true outline, giving a much more precise location than a bounding box: its exact shape, area, and boundary.

Trap Settling for object detection when the stem needs an object's true outline or exact shape, since a bounding box only approximates location while a pixel mask traces it.

A bounding box is a rectangle that necessarily includes some background around the object, whereas a segmentation mask classifies the object pixel-for-pixel. Semantic segmentation is therefore the most precise localization among the vision types and the right answer when a scenario needs an object's exact area, outline, or boundary.

Trap Picking object detection when the stem demands an object's exact outline or pixel-level area: a rectangular box can't deliver that, only a mask can.

The three object-oriented types form a ladder of increasing locational precision: classification gives no location, object detection gives a coarse rectangle, and semantic segmentation gives an exact per-pixel mask. Compact rule: classification = what; detection = what + where (boxed) + how many; segmentation = what + where (pixel-perfect).

Optical character recognition (also called text recognition or text extraction) pulls printed or handwritten text from images like posters, street signs, and product labels and from documents like articles, reports, forms, and invoices, turning it into searchable, machine-readable text. The Read engine returns the text as pages, lines, and words, each with its location and a confidence score.

OCR is the outlier among the vision types: its result is the recognized characters (with location as secondary metadata), not an object class label or a bounding box around a non-text object. When the goal verb is read, extract, or digitize the text (a receipt, license plate, or street sign) the task is OCR.

Trap Calling object detection when the stem says "read the text on the sign": detection finds objects, OCR returns the actual characters.

Facial detection finds where human faces are in an image and returns the rectangle coordinates of each detected face; it is required as a first step in all other face scenarios. The AI-900 blueprint pairs detection with facial analysis as one solution type, where detection answers "is there a face, and where?"

Trap Jumping to facial analysis when the stem only needs to find where the faces are, since detection alone returns the face regions and analysis adds attributes you weren't asked for.

Facial analysis goes beyond detection by inferring attributes of a detected face, such as head pose or the presence of glasses, answering "what can be described about it?" These are general predictions, not classifications, and they still do not identify who the person is.

Trap Assuming facial analysis can tell you who the person is when it only predicts attributes like head pose or glasses and never matches an identity.

Facial detection and analysis are distinct from face recognition, which matches a detected face to a known identity: verification is one-to-one ("do these two faces belong to the same person?") and identification is one-to-many (who, out of many, is this?). A stem that says detect a face and where is detection; one that says confirm this is employee Jane or match a watchlist is recognition, which is Limited Access and responsible-AI gated.

Trap Answering facial recognition for a "find and locate the face" stem: locating a face is detection; recognition only kicks in when you must name or verify who it is.

The vision solution types analyze an existing image; producing a brand-new image from a text prompt is a generative AI task and belongs to the generative-AI domain. Any stem about generating or creating an original image is never one of these analysis solution types.

Trap Mapping "create an image of…" to object detection or image classification: generation is generative AI, not a vision-analysis workload.

The Caption feature generates a single one-sentence description of the whole image (useful for alt text). Dense Captions generates separate one-sentence descriptions for up to 10 different regions of the image, each returned with bounding box coordinates, when you need region-level detail.

Trap Expecting Caption to return per-region descriptions: only Dense Captions does that (and caps at 10 regions); Caption gives a single whole-image sentence.

Image tagging assigns descriptive content tags (objects, living beings, scenery, actions, and setting terms like indoor or outdoor) each with a confidence score but no bounding boxes. Unlike object detection it can include contextual concepts that can't be localized, which is the distinction between tagging and detection.

Trap Treating image tagging as object detection because both name what's in the image: tagging gives no coordinates and adds non-localizable context tags.

Generative AI is the AI category that produces new, original content (natural-language text, code, images, or audio) in response to an input, rather than returning a fixed prediction. The exam filter: brand-new content (summarize, draft, rewrite, answer conversationally, generate an image) is generative AI; a number, a class label, or a bounding box is predictive AI.

Trap Treating image classification or object detection as generative because it involves images. Those emit a label or box, not new content, so they are predictive AI.

Text-based generative AI runs on large language models (LLMs) and their more compact relations, small language models (SLMs). These models encapsulate the linguistic and semantic relationships between the words and phrases in a vocabulary, letting them reason over natural-language input and generate relevant responses.

Trap Assuming only large language models can generate text and SLMs cannot. Small language models are compact relations of LLMs that also generate text-based content.

LLMs are built on the transformer architecture, which has two blocks: an encoder that creates embeddings by applying a technique called attention, and a decoder that uses those embeddings to determine the next most probable token in a sequence. Recognizing transformer as the architecture behind LLMs, and attention as the technique inside the encoder, is a discrete AI-900 fact.

Trap Naming a neural-network type like CNN or RNN as the LLM architecture. The AI-900 answer is the transformer.

An LLM generates completions by repeatedly predicting the most probable next token (Microsoft frames it as a super-powerful version of a phone's predictive text) rather than retrieving a stored answer. This probabilistic next-token mechanism explains both the model's fluency and why its output is not guaranteed to be factually correct.

Trap Assuming an LLM stores and looks up facts like a database. It predicts tokens, which is why it can sound confident yet be wrong.

LLMs break their vocabulary into tokens (words, but also sub-words such as the un in unbelievable and unlikely, punctuation, and other common character sequences), each assigned a unique integer identifier. Modern LLM vocabularies hold hundreds of thousands of tokens, and token count, not word count, is the unit by which usage is measured.

Trap Equating one token with one word when estimating usage. A token can be a sub-word, punctuation, or character sequence, so token count and word count differ.

A prompt is simply the input you give to an LLM to get a response (a question, a command, or a comment), and the model responds to a prompt with a completion. Keep the pair crisply apart: the prompt is what goes in, the completion is what comes out.

Trap Swapping the terms and calling the model's output the prompt. The input is the prompt, the generated output is the completion.

Prompts come in two kinds. A system prompt is set by the application to define the model's behavior, tone, and any constraints it must adhere to (e.g. "You're a helpful assistant that responds in a cheerful, friendly manner"). A user prompt elicits a response to a specific question or instruction and is typically what a person types; the model answers the user prompt while obeying the system prompt.

Trap Assuming the user (not the application) sets the system prompt. The application defines the system prompt to constrain the model.

A copilot is an AI-powered assistant that embeds the prompt-to-completion loop inside everyday tools. Microsoft 365 Copilot, for example, brings generative AI into apps like Word, Excel, Outlook, and Teams. Recognize a copilot as the user-facing packaging of an LLM, not a distinct kind of model.

Trap Treating a copilot as a distinct type of model rather than an application that surfaces an underlying LLM inside everyday tools.

To keep a multi-turn conversation consistent and relevant, generative AI apps keep track of the conversation history and include summarized versions of it in subsequent prompts. That supplies ongoing context so the model interprets each new question in relation to what was said before.

Trap Assuming the model itself remembers earlier turns. The application supplies continuity by re-feeding summarized history into each new prompt.

Because a completion is generated from the prompt, a better prompt materially changes the result. Microsoft's prompt-engineering guidance: be clear and specific, add context (topic, audience, format), use examples of the desired style, and ask for structure such as bullet points, tables, or numbered lists. Better results often come from a better prompt, not a bigger model.

Trap Reaching for a larger model to improve a weak result when clearer, more specific prompting is the cheaper and often more effective lever.

An LLM only knows its training data, so it can't answer about private documents or recent facts on its own. Retrieval augmented generation (RAG) retrieves relevant information (documents, emails, policy pages) and uses it to augment the prompt, so the response is grounded in the supplied data. RAG is the exam-correct answer whenever a stem needs internal, organization-specific, or up-to-date information.

Trap Reaching for fine-tuning when the need is current or organization-specific facts. That re-trains style/behavior, whereas RAG injects the actual data at prompt time.

Because generation is probabilistic, an LLM can produce confident but factually wrong or invented answers, commonly called hallucinations. This is an inherent property of generative models, not a defect cured by more training; the mitigations are grounding (RAG) to supply real data plus responsible-AI guardrails such as content filters and human review.

Trap Assuming more training data eliminates hallucinations. They stem from probabilistic generation, so the fix is grounding and guardrails, not retraining.

Because it creates content, generative AI intensifies responsible-AI concerns. Microsoft frames a lifecycle of mapping (identifying) potential harms, measuring potential harms, mitigating potential harms, and managing (operating) a responsible solution. The exam shorthand is map, measure, mitigate, manage.

Responsible generative-AI harm mitigation is a layered approach, not a single switch. Microsoft applies it across four layers: the Model itself, a Safety System with content filters and prompt shields, the System message and grounding that steer and constrain the model (including RAG), and the User experience (application UI input/output validation and transparent documentation).

Trap Believing content filters alone make a solution safe. The safety system is only one of four layers, alongside model choice, system message/grounding, and UX.

A foundation model (the basis of an LLM) gains broad, general-purpose language capability by being pretrained on enormous volumes of largely unlabeled text from many sources such as books and websites. That broad pretraining lets one model be adapted to many downstream tasks through prompting or fine-tuning, without retraining from scratch for each task.

Trap Assuming a foundation model is trained from scratch on labeled data for one specific task. It is pretrained broadly on largely unlabeled text and then adapted to many tasks.

A multimodal generative AI model accepts and reasons over multiple input types (such as text and images) in the same prompt, and returns a natural-language response. This is what lets a user upload a photo and ask questions about its contents; the Azure OpenAI example is GPT-4o, which integrates text and images in a single model.

Trap Picking a text-only model and bolting on a separate image classifier when one multimodal model like GPT-4o reasons over text and images together in a single prompt.

Microsoft's six Responsible AI principles map to distinct concerns: fairness = minimize bias so the model doesn't produce discriminatory outputs; reliability and safety = account for probabilistic models being fallible; privacy and security = keep training data and models from exposing personal information; inclusiveness = don't exclude users (e.g. captions for hearing-impaired users); transparency = make users aware they're interacting with AI and explain its limitations; accountability = people and organizations stay responsible, with governance and human sign-off.