Troubleshooting practice questions

Increase the confidence threshold parameter in the analyzeDocument request body to 0.99.

Why it fails: The confidence threshold only filters which extracted fields the response returns; raising it to 0.99 suppresses low-confidence results rather than improving the model's accuracy. It is tempting as a quick quality gate, which suits downstream validation logic, not raising the underlying extraction confidence of a custom template model.

Convert all training PDFs to grayscale and reduce their resolution to 72 DPI to speed up processing.

Why it fails: Grayscale conversion and 72 DPI reduction strip colour and detail the custom template model relies on to match field layouts, degrading extraction confidence further. It is tempting because smaller files process faster, which suits latency or throughput optimisation, not accuracy on poorly extracted fields.

Switch the model type from custom template to a prebuilt business card model.

Why it fails: A prebuilt business card model extracts a fixed schema of contact fields and cannot target the custom fields the template model was trained on, so those fields lose extraction entirely. It is tempting because prebuilt models need no training, which suits standard documents such as business cards, not bespoke field extraction.

Listen for incoming webhook notifications on an Azure Event Grid subscription attached to the text analytics resource.

Why it fails: Azure AI Language LROs expose status through the Operation-Location polling URL; no Event Grid subscription is created for the /analyze job. It is tempting because Event Grid delivers push notifications for resource events, but it is correct only where an event source publishes to a subscribed topic.

Query the Azure Monitor metrics API for job completion status.

Why it fails: Azure Monitor exposes resource metrics and diagnostic logs, not the per-job operation status or result payload of an LRO. It is tempting because Azure Monitor tracks service health and latency, but it is correct only for monitoring resource-level telemetry, not for retrieving a specific job's output.

Repeatedly send synchronous POST requests to the same document endpoint until a 200 OK is returned.

Why it fails: The /analyze endpoint returns an Operation-Location header; status and results are retrieved by polling that operation URL with GET, not by resubmitting documents. It is tempting because polling is the right pattern, but re-POSTing re-runs the job and returns 202 Accepted, never the completed summary payload.

Double the model temperature to 2.0 to accelerate reasoning speed.

Why it fails: Temperature accepts values from 0 to 2, so 2.0 is valid but increases output randomness and token generation length, worsening timeouts rather than accelerating reasoning. It is tempting because temperature is the familiar knob for tuning model behaviour, and lowering it would be correct when diagnosing verbose or unstable agent responses.

Delete all vector indices to force local memory processing.

Why it fails: Deleting vector indices removes the retrieval grounding agents depend on, so tool calls fail or return nothing and timeouts persist. It is tempting because local memory processing sounds like it bypasses network round trips, and rebuilding an index would be correct when embeddings are stale or dimensionally mismatched.

Run the Azure Advisor cost recommendation analyzer to optimize resource pricing tiers.

Why it fails: Cost optimisation reports analyse spending against usage, offering no visibility into network path, firewall rules or DNS resolution. It is tempting because Azure Advisor surfaces resource recommendations, and would be correct for reducing waste, but connectivity faults require Network Watcher, IP flow verify and connection troubleshoot instead.

Use the Azure Resource Manager template visualizer to inspect regional resource dependencies.

Why it fails: Template visualiser renders ARM deployment topology and dependencies, not live packet flow or firewall rule evaluation. It is tempting because it clarifies resource relationships, and would be correct when auditing deployment structure, but intermittent connectivity demands runtime diagnostics such as connection monitor and NSG flow logs.

Delete all project iteration history to reset model weights to random initialization.

Why it fails: Deleting iterations removes trained snapshots and their performance metrics; it does not reset weights to random initialisation, and it destroys the evidence needed to compare models. It is tempting as a clean-slate remedy, but retraining with additional labelled images is the actual mechanism for improving a poorly performing detector.

Manually edit model neural network weights via the REST API.

Why it fails: Custom Vision exposes training, prediction and iteration endpoints; no REST API permits editing neural network weights, which are learned internally during training. It is tempting because the REST API does allow programmatic control of projects, and it would be correct for automating training, publishing or exporting an iteration as a model.

Deploy all development, test, and production AI resources into a single shared resource group to simplify administration.

Why it fails: A single shared resource group removes the scope boundary for cost allocation, RBAC and policy, so per-environment budgets and governance cannot be enforced. It is tempting because consolidating resources appears to reduce administrative overhead, but the correct approach separates environments into distinct resource groups with scoped budgets and tags.

Disable diagnostic logging across all AI resources to reduce Azure storage and log ingestion costs.

Why it fails: Disabling diagnostic logging removes the telemetry needed to attribute AI service consumption and detect anomalous spend, undermining governance rather than improving it. It is tempting because log ingestion and retention do generate storage charges, but cost management relies on that data, so the correct action is configuring retention and sampling instead.

Use the Free (F0) pricing tier for all production workloads to eliminate infrastructure costs.

Why it fails: The F0 tier caps monthly transactions and excludes production SLAs, so it cannot carry live workloads. It is tempting because F0 genuinely removes subscription charges, and it suits evaluation, prototyping or low-volume development where throttling and no uptime guarantee are acceptable.

Use the Read API instead

Why it fails: The Read API returns recognised text and bounding boxes but does not reconstruct table structure, so it cannot resolve cells being merged or columns misread. It is tempting because Read is the standard call for plain text extraction, and it would be the right choice for documents containing no tabular layout.

Disable the layout model

Why it fails: Disabling the layout model removes the component that detects and reconstructs table structure, worsening the misinterpretation rather than fixing it. It is tempting because switching off a misbehaving feature feels like a quick remedy, and it would be correct when layout analysis actively harms non-tabular documents.

Change the resource region

Why it fails: Changing the resource region relocates the Azure AI Document Intelligence resource; it does not alter how tables are parsed, so misread cells persist. It is tempting because region selection affects latency and data residency, and it would be the right action when compliance or performance requires a different deployment location.

The model weights have become corrupted and require redeployment.

Why it fails: Corrupted model weights cause consistent failures or degraded output, not intermittent 429 responses tied to request-rate spikes. Redeployment is the right choice when a deployment returns persistent errors or malformed completions regardless of traffic volume.

The Azure subscription has run out of monthly financial budget.

Why it fails: Budget exhaustion suspends the subscription or disables the resource, yielding authorisation or deployment errors rather than intermittent 429s that clear as traffic subsides. Budget alerts are the right choice for cost governance, not for diagnosing per-deployment rate limiting.

The Private Endpoint DNS resolution has failed.

Why it fails: Private Endpoint DNS failure blocks name resolution entirely, producing connection errors rather than HTTP 429, and it would not correlate with request-rate spikes. Private Endpoint DNS is the right choice to diagnose when requests fail to reach the deployment at all.

Restart the client web browser session

Why it fails: Restarting the browser session clears client state but cannot reveal why the agent's tool invocation fails server-side. Browser restarts suit stale cached UI or authentication cookie issues; diagnosing tool invocation requires inspecting agent traces, tool schemas and API request logs in Azure AI Foundry.

Increase the Azure DNS TTL value for domain resolution

Why it fails: DNS TTL governs how long resolvers cache records; it has no bearing on whether an agent invokes a tool. Raising it would only delay propagation of DNS changes. TTL tuning belongs to scenarios involving DNS failover or record migration, not tool-call debugging in Azure AI Foundry.

Publish administrative API keys publicly in GitHub repositories for easy developer access.

Why it fails: Publishing admin keys in a public repository exposes full control of the search service, enabling unauthorised index manipulation and data exfiltration; production access must use role-based keys or Microsoft Entra ID. Storing keys in a secret manager is tempting for developer convenience, but public exposure violates every secure-deployment baseline.

Use the Free pricing tier for high-throughput production workloads.

Why it fails: The Free tier caps indexes, storage and query throughput, so it cannot sustain production workloads; production requires Standard tier or higher with replicas and partitions for scale. It is tempting because Free avoids cost during prototyping, and it would be the correct choice for a short-lived development or evaluation environment.

Verify that the client application has been assigned the Storage Blob Data Contributor role.

Why it fails: Storage Blob Data Contributor governs Blob Storage data-plane access, not Azure AI Language connectivity through a Private Endpoint. It is tempting because role assignments commonly cause authorisation failures, and this role would be correct when an application must read or write blobs in a storage account.

Ensure that the Azure OpenAI model weights have been retrained.

Why it fails: Retraining Azure OpenAI model weights has no bearing on Private Endpoint connectivity; the failure is network-path related, not model quality. It is tempting because retraining addresses accuracy degradation in deployed models, which would be the right action when predictions drift — not when clients cannot reach the resource at all.

Check that public network access is set to enabled and unrestricted.

Why it fails: Enabling unrestricted public access contradicts the Private Endpoint design, which routes traffic privately; the fix lies in private DNS resolution and subnet configuration. It tempts because public access restores connectivity when private DNS zones are misconfigured, but that bypasses the intended private-only posture.

Increase the Azure OpenAI model temperature parameter to 1.5

Why it fails: Temperature controls sampling randomness in generation, not retrieval; raising it to 1.5 makes answers less grounded and cannot improve which chunks are returned. It is tempting because temperature tuning genuinely helps creative or diverse generation, but irrelevant retrieval is fixed by chunking, embeddings, and search configuration.

Configure Azure Key Vault access policies for the search service

Why it fails: Key Vault access policies govern secret storage permissions; they do not affect indexing, embeddings, or ranking, so retrieval relevance is untouched. It is tempting because Key Vault genuinely secures the search service's API keys and connection strings, which is a security concern rather than a retrieval-quality one.

Increase the timeout threshold in the HTTP client configuration.

Why it fails: Raising the HTTP timeout only lets the client wait longer for the same cross-region round trips; it cannot reduce the West US to Southeast Asia network distance causing the latency. Timeout tuning suits slow-processing operations, not geographically misplaced resources, where recreating the Azure AI Vision resource in West US removes the delay.

Enable Azure ExpressRoute between West US and Southeast Asia.

Why it fails: ExpressRoute provides dedicated private connectivity between your on-premises network and Azure, not accelerated routing between two Azure regions; the West US to Southeast Asia distance remains. ExpressRoute suits hybrid connectivity or bypassing public internet paths, whereas this scenario needs the Azure AI Vision resource recreated in West US.

Switch from REST API to gRPC protocol.

Why it fails: gRPC changes serialisation and transport framing, not the physical distance between West US and Southeast Asia, so inter-region round-trip latency persists. gRPC suits high-throughput streaming or compact binary payloads; here the fix is recreating the Azure AI Vision resource in West US alongside the application.

Increase the probability threshold in the prediction API call.

Why it fails: Raising the probability threshold suppresses some false positives at prediction time but leaves the model's learned features unchanged, so the underlying background-variety gap persists. Threshold tuning is the correct lever when a trained model is sound and you simply need to trade recall for precision on live calls.

Remove all tagged bounding boxes and retrain as a multi-class classification model.

Why it fails: Converting to multi-class classification discards bounding-box localisation entirely, so the model can no longer detect object position, which object detection requires. Classification is the right choice when each image contains a single dominant subject and you only need a label, not coordinates.

Apply aggressive data augmentation to duplicate existing positive images.

Why it fails: Duplicating positive images amplifies the same backgrounds the model already overfits to, reinforcing the false-positive pattern rather than teaching background diversity. Augmentation suits enlarging a small positive dataset, but the stem's deficiency lies in negative images, which this leaves untouched.

The local workstation IP address is not whitelisted in Azure DevOps.

Why it fails: Whitelisting a workstation IP in Azure DevOps governs pipeline agent access, not ARM provisioning. Azure Resource Manager authenticates the deployment principal and validates quota, region availability and policy; the control plane never checks your local IP. This option is tempting because firewall allow-listing genuinely blocks access when agents or storage accounts restrict source addresses.

The client web browser cache is corrupted.

Why it fails: A corrupted browser cache affects client-side rendering, not server-side ARM template deployment to Azure. It is tempting because cache issues commonly cause portal display errors, and it would be correct where the Azure portal interface misbehaves for a user rather than a template provisioning failure.

The local git repository has uncommitted changes.

Why it fails: Uncommitted local git changes affect source control state, not the ARM template's provisioning of an Azure OpenAI account. It is tempting because deployment pipelines often build from repositories, and it would be correct where a CI/CD release fails due to unpushed or uncommitted code rather than template validation.

Lower the confidence score threshold to 0.01.

Why it fails: The confidence threshold governs inference-time labelling, not training dynamics, so it cannot raise training loss or validation accuracy. It is tempting because lowering it increases recall, which suits scenarios needing broader coverage of borderline predictions rather than correcting underfitting.

Reduce the training dataset size by 90%.

Why it fails: Cutting the dataset by 90% removes the examples the model needs to learn the task, worsening underfitting. It is tempting because reducing data helps when overfitting is present, which is the opposite diagnosis to high training loss with low validation accuracy.

Switch the resource pricing tier from Standard to Free.

Why it fails: The pricing tier governs quota, throughput and cost, not the model's capacity to fit training data, so underfitting persists. It is tempting because tier changes resolve throttling or capacity errors, which suits scenarios where training jobs fail or queue rather than converge poorly.