Scenario practice questions

Building a conversational chatbot: Azure Machine Learning

Why it fails: Incorrect — Azure Machine Learning is for building and training models, not specifically for chatbots.

Analyzing images for content moderation: Azure Bot Service

Why it fails: Incorrect — Azure Bot Service is for chatbots, not image analysis.

Classifying text by sentiment: Azure Cognitive Search

Why it fails: Incorrect — Cognitive Search is for indexing and search, not sentiment analysis.

Reduce the probability threshold to increase recall.

Why it fails: Lowering the probability threshold shifts the decision boundary, changing precision-recall balance without teaching the model the new lighting distribution, so accuracy on shifted images stays poor. It is tempting because threshold tuning is a quick, no-retraining lever for recall, and would be correct if the goal were to catch more defects at the cost of false positives.

Use Azure AutoML to automatically find the best algorithm.

Why it fails: AutoML searches algorithm and hyperparameter combinations, but the failure is caused by a domain shift in lighting, which no algorithm swap addresses without representative images. It is tempting because AutoML is the standard route to squeezing accuracy from a dataset, and would be correct if the model were underfitting rather than facing distribution shift.

Add more images from the original lighting conditions to the training set.

Why it fails: Adding more images from the original lighting conditions reinforces the distribution the model already handles, so it cannot learn the new lighting variation causing the drop. It is tempting because enlarging the training set is the usual remedy for weak accuracy, and would be correct if the shortfall stemmed from too few examples overall rather than changed conditions.

Image format support (JPEG, PNG)

Why it fails: Both services support common formats.

Need for real-time inference latency

Why it fails: Both services offer low latency; it's not a distinguishing factor.

Create custom classification rules for sensitive data types.

Why it fails: Custom classification rules define your own regex or dictionary patterns, yet the scenario requires automatic detection of built-in sensitive types, which system classifications already cover. It is tempting because custom rules are the correct choice when standard classifiers miss organisation-specific data formats.

Apply sensitivity labels to the classified data.

Why it fails: Sensitivity labels are applied after classification to govern usage, not to scan and classify Blob Storage content. It is tempting because labels do tag sensitive assets, but that is the correct action once scanning has already identified the data, not part of configuring the scan itself.

Azure AI Vision's image analysis

Why it fails: Image analysis returns captions, tags and object detections, not field-level key/value pairs, so handwritten form data stays unstructured. It is tempting because it processes scanned images, but it suits general visual labelling; Document Intelligence's custom form model is built for extracting labelled fields from forms.

Azure AI Speech to text

Why it fails: Speech to text transcribes audio into text, and scanned form images contain no audio stream, so no handwriting is read. It is tempting because it converts unstructured input into text, but it is correct when the source is recorded or live speech, not images of forms.

Azure Bot Service

Why it fails: Azure Bot Service builds conversational interfaces, offering no OCR or field-extraction capability, so scanned handwriting cannot become structured data. It is tempting as a document-facing front end, but it is correct when users must chat with a bot, not when forms require automated data extraction.

Azure AI Translator

Why it fails: Transcription and sentiment detection require speech-to-text and language sentiment analysis; Translator only converts text between languages, so it adds no transcription or sentiment capability. It is tempting because it processes call audio output, but it would be the right choice only for translating already-transcribed text into another language.

Azure AI Speech (text-to-speech)

Why it fails: Text-to-speech converts text into synthesised audio, the reverse of transcription, so it cannot process call recordings. It suits voice assistants and accessibility narration. The stem needs speech-to-text recognition, which Azure AI Speech also provides as a separate capability.

Azure AI Language (conversational language understanding)

Why it fails: Conversational language understanding extracts intents and entities from utterances for bots and command routing; it does not classify sentiment. Sentiment analysis is a separate Azure AI Language feature. The stem's sentiment detection requires that feature, not intent recognition.

Azure AI Custom Vision

Why it fails: Custom Vision is for image classification, not text extraction.

Azure AI Vision OCR

Why it fails: OCR is optimized for printed text, not handwriting.

Azure AI Language

Why it fails: Language service analyzes text, not images.

Abstractive summarization

Why it fails: Abstractive summarization generates new condensed prose, whereas the scenario requires sentiment scores, key phrases and entity extraction. It is tempting because summarising reviews sounds related to analysing them, and it would be correct if the requirement were producing a short narrative digest of each review rather than structured outputs.

Language detection

Why it fails: Language detection identifies the text's language, not sentiment, key phrases or entities, so it adds nothing to the three required capabilities. It is tempting because multilingual reviews often need language identification first, and it would be correct if the pipeline had to route non-English text to the appropriate sentiment model.

Store connection strings in Azure Key Vault and reference them in the agent's configuration

Why it fails: Storing connection strings in Key Vault contradicts the managed identity requirement, since managed identities remove the need for stored secrets entirely. It is tempting because Key Vault is the standard secret-management service, and it would be correct for agents authenticating with credentials rather than an assigned managed identity.

Create a service principal in Microsoft Entra ID and assign RBAC roles to the agent's resource

Why it fails: A service principal with a client secret is a separate identity requiring credential management, whereas managed identities are created and assigned directly to the Azure resource. It is tempting because service principals with RBAC roles are the usual pattern for application authentication, but the stem explicitly mandates managed identities.

Configure the agent to use an API key for each external service

Why it fails: API keys are static shared secrets, so they cannot satisfy the stem's managed-identity requirement for passwordless authentication to Azure resources. They are tempting because they suit third-party services outside Microsoft Entra ID, where no service principal or federated credential exists.

Ensure the model achieves at least 95% accuracy on a cross-validation split.

Why it fails: Accuracy alone can be misleading, especially with imbalanced classes; precision and recall are more important.

Use the training set to compute accuracy and ensure it is above 90%.

Why it fails: Performance on the training set is inflated and does not reflect generalization.

Compare the model's performance to a baseline model that always predicts the most common class.

Why it fails: While comparing to a baseline is useful, it is not a required action before promotion; the question asks for actions to ensure performance requirements.

Configure Azure AI Language with custom question answering.

Why it fails: Custom question answering builds a curated question-and-answer pair index from uploaded documents; it does not natively index a live SharePoint knowledge base for generative answers. It is tempting because it answers from documents, but Copilot Studio's SharePoint knowledge source retrieves content directly from the specified site.

Create an Azure Bot Service with a QnA Maker knowledge base.

Why it fails: QnA Maker is retired and cannot be created in Azure; Azure Bot Service hosts bots but provides no SharePoint knowledge grounding. It is tempting as the historical pattern for FAQ bots, yet Copilot Studio's built-in SharePoint knowledge source is the current supported mechanism for this scenario.

Use Azure OpenAI Service with data integration (Bring Your Own Data).

Why it fails: Azure OpenAI with Bring Your Own Data connects to Azure AI Search indexes, not SharePoint document libraries directly, so the internal knowledge base would need separate ingestion and indexing first. It is tempting for generative grounding, but Copilot Studio's native SharePoint knowledge source meets the requirement without that pipeline.

Azure AI Document Intelligence with a custom model

Why it fails: A custom Document Intelligence model must be trained on your own labelled samples and is built for extracting fields from specific form layouts, not general handwriting transcription. It is tempting because Document Intelligence reads handwriting, but the pre-built read model, not a custom model, covers English and Spanish notes.

Azure AI Language with custom entity recognition

Why it fails: Azure AI Language with custom entity recognition extracts named entities from existing text; it does not convert images of handwriting into text. It is tempting because it is a pre-built, multilingual Azure AI service, but it consumes text input, so it cannot perform the optical recognition step the scenario requires.

Custom Vision with a custom handwriting recognition model

Why it fails: Custom Vision performs image classification and object detection; it cannot transcribe handwriting into text at all. It is tempting because it is a pre-built Azure AI vision service and the word custom suggests tailoring to handwriting, but training it yields labels or bounding boxes, not recognised characters.

Video Analyzer S1 tier.

Why it fails: Video Analyzer S1 processes video streams, not still-image analysis, so it cannot serve Computer Vision requests at all. It tempts because it is a vision-family tier, but it is correct only for video indexing and spatial analysis workloads.

Free F0 tier.

Why it fails: F0 caps calls at 20 per minute and 5,000 per month, throttling the high request volume the app requires. It tempts as a no-cost entry tier, but it is correct only for evaluation, demos or very low-volume prototyping.

Custom Vision S0 tier.

Why it fails: Custom Vision S0 trains and hosts bespoke image classification models; it does not expose the general Computer Vision analyse-image endpoint the app calls. It tempts as an image AI tier, but fits only custom model training and prediction.

The model is not being batch-processed for inference.

Why it fails: Batch processing affects throughput and request grouping, not per-image detection accuracy; inference mode does not change how many people the model detects in a frame. It is tempting because batching is a genuine latency and cost optimisation, and would be correct when tuning endpoint throughput rather than diagnosing detection accuracy.

The model is overfitting to the training data.

Why it fails: Overfitting would degrade generalisation across all conditions, not selectively during peak occupancy; retraining with more data would typically worsen or not fix a systematic underestimation tied to crowd density. It is tempting because overfitting is a common cause of poor model accuracy, and would be correct if validation loss diverged from training loss.

The Computer Vision API version is outdated.

Why it fails: An outdated API version would affect all requests uniformly, not specifically peak-hour counts, and version drift does not explain density-dependent underestimation. It is tempting because version mismatches do cause unexpected behaviour, and would be correct if a newer API version introduced the detection capability the model requires.

Key Phrase Extraction and Conversational Language Understanding

Why it fails: Key Phrase Extraction surfaces salient terms; it cannot identify a language, so routing to a language-specific intent model never happens. It would suit mining topics from documents, whereas the stem requires Language Detection before Conversational Language Understanding.

Translator and Conversational Language Understanding

Why it fails: Translator converts text between languages; it does not return the detected source language for routing decisions. It would be correct when translating utterances into a single pivot language, but the stem needs Language Detection feeding Conversational Language Understanding.

Language Detection and Custom Text Classification

Why it fails: Custom Text Classification assigns documents to user-defined classes; it does not resolve intents from utterances. It would fit tagging support tickets by topic, whereas the stem requires Language Detection followed by Conversational Language Understanding for intent routing.

QnA Maker

Why it fails: QnA Maker builds a question-and-answer knowledge base matched to user queries; it performs no entity extraction and cannot learn custom entities from labelled examples. Custom named entity recognition is the service for that task, whereas QnA Maker suits FAQ-style conversational answers.

Pre-built Entity Extraction

Why it fails: Pre-built entity extraction returns only fixed categories such as person, location and organisation, so it cannot learn custom product names or order numbers from labelled examples. Custom named entity recognition is the service that trains on your labelled data; pre-built suits generic extraction with no training.

Text Analytics for health

Why it fails: Text Analytics for health extracts medical entities such as medications, diagnoses and dosages from clinical text, not product names or order numbers. Custom named entity recognition trains on your labelled examples to extract bespoke entities; the health model suits clinical documents only.

Azure Blob Storage

Why it fails: Blob Storage holds files but exposes no indexed, queryable document structure for generative answers. It suits storing raw documents for pipelines that parse them first. Copilot Studio's knowledge sources ingest indexed content directly, so unstructured blobs alone won't ground responses.

Azure SQL Database

Why it fails: Azure SQL Database stores structured rows, not the unstructured technical documents generative answers require. It is the right source for tabular lookups via connectors. Copilot Studio knowledge retrieval needs indexed document content, which a relational schema does not provide.

Microsoft Lists

Why it fails: Microsoft Lists holds structured list items, not the document corpus the copilot must search. It fits tracking records or simple tabular data. Grounding answers on technical documents requires an indexed knowledge source that Copilot Studio can query semantically.

Language Detection

Why it fails: Language detection returns the detected language and confidence score for input text, not sentiment, key phrases or entities. It is the correct call when routing multilingual documents to the appropriate language-specific model before analysis, which this single-language review scenario does not require.

PII Detection

Why it fails: PII detection identifies and redacts personal data such as names, addresses and phone numbers; it returns entity categories for privacy, not sentiment scores, key phrases or product entities. It would be the right operation when the requirement is to mask personal information before storage or sharing.

Conversational Language Understanding

Why it fails: Conversational Language Understanding extracts intents and entities from existing text, so it cannot convert call audio into a transcript. It is tempting because call analysis often follows transcription, but CLU is the correct choice for classifying intent once text already exists.

Azure AI Translator

Why it fails: Azure AI Translator converts text between languages; it accepts text input and cannot process call audio into a transcript. It is tempting because transcribed calls are often translated afterwards, but Translator is the correct choice when the source material is already text.

Azure AI Text-to-Speech

Why it fails: Azure AI Text-to-Speech synthesises spoken audio from written text, the reverse direction of transcription. It is tempting because both involve speech, but Text-to-Speech is the correct choice when you need to generate voice output from a script.

Custom models always have faster response times.

Why it fails: Latency depends on deployment, model size and endpoint load, not on whether the model is pre-built or custom; custom training adds no guaranteed speed advantage. It tempts because custom models can be tuned for domain accuracy, which is a genuine selection factor — but response time is not inherent to customisation.

Pre-built models cannot be used in containers.

Why it fails: Pre-built Azure AI Language models can be deployed in containers for on-premises or disconnected use, so this claim is false. It tempts because container deployment is a real consideration when data residency or connectivity rules apply, but it does not distinguish pre-built from custom sentiment analysis.