Select Two (Multi-Select) Questions

Store API keys in Azure Key Vault but use them directly in application code.

Why it fails: Embedding keys directly in application code exposes them in source control and logs; managed identity or Key Vault references should supply credentials at runtime. It tempts because Key Vault storage alone sounds secure, but direct code usage defeats the vault's protection.

Place all AI services in a DMZ subnet with public IP addresses.

Why it fails: Public IP addresses in a DMZ expose Azure OpenAI and Azure AI Search endpoints to the internet, contradicting private endpoint and network isolation requirements. It tempts as a classic perimeter pattern, yet these services should sit in private subnets reached via private endpoints.

A fine-tuned custom model.

Why it fails: Fine-tuning is not required for a RAG approach.

An Azure OpenAI embeddings model deployment.

Why it fails: Embeddings are used internally but not a separate requirement.

The skill can only accept one input and produce one output

Why it fails: Custom skills accept multiple inputs and emit multiple outputs, so this restriction is false. Single-input, single-output designs suit trivial transformations, but external extraction skills typically map several enriched fields and return structured results, which the scenario's API-based extraction requires.

The skill must be written in Python

Why it fails: Custom skills run as Azure Functions, which support C#, Java, JavaScript, Python and PowerShell, so Python is not mandatory. Python suits teams already using it for ML processing, but the scenario's external API extraction can be implemented in any supported runtime.

A Power Automate flow to trigger the copilot

Why it fails: Power Automate is not required for Q&A; it's for automation.

An Azure OpenAI Service deployment

Why it fails: Copilot Studio uses its own generative AI, not Azure OpenAI directly.

Extract text from scanned receipts.

Why it fails: Custom Vision trains image classification and object detection models; extracting text from scanned receipts is Optical Character Recognition, handled by Azure AI Vision or Document Intelligence. OCR is tempting because both are vision services, but Custom Vision classifies and localises objects in images rather than reading printed characters.

Identify specific individuals in a crowd using facial recognition.

Why it fails: Custom Vision performs image classification and object detection, not facial recognition; identifying individuals is Azure AI Face. Face is tempting because both analyse images, but Custom Vision labels whole images or draws bounding boxes around object classes, while Face matches human faces to identities.

Expose endpoints publicly to simplify client access.

Why it fails: Public endpoints let anyone reach the service, so authentication and throttling become the only barriers; private endpoints or network restrictions are required instead. It is tempting because it removes VPN and firewall configuration work, and it would be correct for genuinely public-facing APIs, but not for securing Azure AI services handling sensitive data.

Disable diagnostic logging to reduce data exposure.

Why it fails: Diagnostic logging records who called which model and when, which is essential for detecting misuse and meeting audit obligations; disabling it removes that evidence. It is tempting because less stored telemetry means less data at risk, and it would be correct where logging itself captures prohibited personal data, but not as a general security practice.

Share API keys among multiple applications for simplicity.

Why it fails: Sharing keys across applications destroys per-client attribution and means one compromise or rotation forces every consumer to be rekeyed simultaneously, widening blast radius. It is tempting because it reduces secret-management overhead, and it would be correct only where a single trusted workload consumes the resource, not for isolating multiple applications.

The need for optical character recognition (OCR) of product serial numbers.

Why it fails: OCR may be separate, not core to quality inspection.

Multilingual support for labeling.

Why it fails: Labels are internal, not a critical factor.

Azure AI Translator

Why it fails: Azure AI Translator performs text translation between languages; it consumes already-extracted text and returns translated output, with no OCR capability. It is tempting because it processes documents, which would be correct when localising extracted content rather than reading text from images or PDFs.

Azure AI Search

Why it fails: Azure AI Search indexes and queries content, relying on skillsets or external enrichment to obtain text; it does not itself perform optical character recognition on images or PDFs. It is tempting because it handles documents, which would be correct for retrieval over already-extracted text.

Azure AI Language

Why it fails: Azure AI Language provides NLP over existing text, such as entity recognition and sentiment analysis; it cannot read pixels or PDF page images. It is tempting because it analyses documents, which would be correct for extracting meaning from text already obtained by OCR.

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.

index_name

Why it fails: Not a chat completions parameter.

embedding_model

Why it fails: Not a chat completions parameter.

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.

Assign a managed identity to the model deployment.

Why it fails: A managed identity lets the deployment authenticate to other Azure resources without stored credentials; it neither confines inbound access to a virtual network nor records API calls for auditing. It is tempting because managed identities are genuinely required when the model must securely access Key Vault or Storage.

Configure CORS to allow only the VNet's domain.

Why it fails: CORS governs which browser origins may call the endpoint; it does not restrict network-level access to a virtual network, nor does it log API calls. It is tempting because CORS is legitimately configured when web apps on other domains must invoke an API from client-side JavaScript.

Enable public network access from selected IP addresses.

Why it fails: Allowing selected public IP addresses still exposes the model endpoint over the internet, so access is not restricted to the virtual network as the scenario demands. It is tempting because this setting is genuinely used when clients outside Azure must reach the service over public endpoints.

Use the free tier for production workloads

Why it fails: The free tier caps index storage, index count and document volume, and carries no production SLA, so it cannot support large-scale indexing workloads. It is tempting because it costs nothing for evaluation and development. Production optimisation requires a billable tier whose partitions and replicas can be scaled.

Increase the replica count for better indexing throughput

Why it fails: Replicas increase query throughput and concurrent search capacity, not indexing throughput, which scales with partitions. Adding replicas is tempting because it is the standard scaling lever, but it targets read performance. For large-volume indexing, partition count is the relevant dimension.

Disable scoring profiles to speed up indexing

Why it fails: Scoring profiles affect query-time ranking, not indexing throughput, so disabling them leaves the indexing bottleneck untouched. They are tempting because they add per-document computation, but that cost is incurred during search, and profiles are the correct tool when result ordering must reflect business rules.

Increase the temperature parameter to encourage diversity

Why it fails: Higher temperature may increase errors and security risks.

Rely on the model's built-in safety features

Why it fails: Built-in safety is not sufficient; additional measures are needed.

Fine-tune the model with a dataset of secure code examples

Why it fails: Fine-tuning is costly and may not guarantee security for all prompts.

The temperature parameter is set too high.

Why it fails: Temperature controls randomness of generated text, not whether the model emits valid function-call arguments or the runtime executes them. It tempts because high values cause erratic output, but function execution failures usually trace to schema definitions, tool registration or prompt instructions, which temperature does not govern.

The model version is outdated.

Why it fails: Model version does not govern function-calling execution; the schema, tool definitions and response handling do. An outdated model may still invoke functions correctly. Upgrading is relevant when a newer model adds capabilities such as parallel tool calls, not when calls fail to execute.

Azure AI Custom Vision

Why it fails: Custom Vision classifies images by visual patterns, not by extracting structured text fields such as line items or totals from invoices. It is tempting because it can process document images, but it lacks the OCR and prebuilt model capabilities required to parse key-value pairs and tables from varied invoice formats and languages. For this scenario, Azure AI Document Intelligence (Form Recognizer) would be the correct choice, as it provides prebuilt invoice models for field extraction.

Azure AI Content Safety

Why it fails: Content Safety is for moderation, not extraction.

Azure AI Metrics Advisor

Why it fails: Azure AI Metrics Advisor performs anomaly detection on time-series metrics and alerts on deviations; it has no image-processing pipeline for extracting text. It would be correct for monitoring business or telemetry data streams, not for reading documents.

Azure AI Language

Why it fails: Azure AI Language handles text analytics such as entity recognition, sentiment and question answering; it consumes text, not images, so it cannot extract characters from scanned documents. It would be correct for analysing text already produced by an OCR service.

Azure AI Personalizer

Why it fails: Azure AI Personalizer is a reinforcement-learning service that ranks content to personalise user experiences; it processes interaction and reward data, not document images. It would be correct for choosing which product or article to surface to a user.

Use Azure AI Document Intelligence to extract text from PDFs before indexing

Why it fails: If PDFs are already text-based, extraction is not required; Cognitive Search can handle PDFs directly.

Deploy Azure AI Content Safety to filter responses

Why it fails: Content Safety is not a required step for answering from PDFs.

Fine-tune the GPT model on the PDF content

Why it fails: Fine-tuning is not required for retrieval-augmented generation; it is an alternative approach.

Azure RBAC roles for the service

Why it fails: Azure RBAC roles govern authorisation — which principal may perform which action — and generate control-plane role assignment events, not a record of every data-plane API call. RBAC is tempting because it is a core security control, but audit compliance needs diagnostic logging and Azure Monitor.

Managed identity for the service

Why it fails: Managed identity supplies an automatically rotated credential for the resource to authenticate to Azure services; it grants no record of who called which API. It is tempting because it removes secrets from code, but auditing requires diagnostic logging and activity logging, which managed identity does not produce.

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.