Practice Exams:

Microsoft SC-500: Securing AI Workloads End to End

Microsoft Security

An AI workload crosses identity, data, execution, model, agent-tool and platform boundaries. Security engineers must constrain every transition and verify that a malicious instruction cannot become a privileged action even when the model behaves unpredictably. Model responses and tool calls can cross different trust levels, particularly when retrieved text instructs an agent to perform an action. The architecture must separate evidence from authority, constrain access to each downstream service and test whether lower-trust inputs can trigger prohibited effects.

On this page
  1. Map AI application and tool flows
  2. Apply security baselines across AI resources
  3. Use separate identities for deployment, runtime and delegation
  4. Preserve classification and provenance through retrieval
  5. Make tools narrowly typed and independently authorized
  6. Separate prompt, tool and memory trust
  7. Constrain networking and secrets without breaking observability
  8. Use security telemetry to identify unusual agent behavior
  9. Prepare an AI-specific containment and rollback matrix

Draw the application, model and tool flow before selecting controls

Begin with the user request, web or API front end, model invocation, retrieval source, vector or search index, memory, downstream tool and final business effect. Each component can have a different identity and data owner, and untrusted information may enter through a prompt, document, tool result or another agent. The threat model should mark where text from a lower-trust source could influence a higher-trust action. Hosting a model privately or enabling content filtering does not establish that the API receiving its output enforces the correct authorization.

Trace a synthetic invoice assistant that reads contract terms and proposes payment records. List which component performs retrieval, which principal can see finance data and which service actually approves the transaction. The model may suggest a value, but trusted application code should validate the account, amount, user authority and business policy. Add one malicious retrieved note telling the model to use a different account and verify that the payment tool rejects it. This separates language understanding from authority to change real systems.

Apply Azure resource baselines to the complete AI estate

AI projects still use subscriptions, resource groups, identities, storage, databases, networking and deployment pipelines. Apply appropriate Azure Policy guardrails, role scope, protected logs and Defender for Cloud coverage to these resources before tuning model behavior. Prototype workloads often accumulate public endpoints, forgotten keys and excessively privileged identities as teams rush to demonstrate capabilities. Separate experimental and production environments so a useful proof of concept does not silently inherit production data access or become an unowned long-term service.

Deploy a small nonproduction AI service using an approved infrastructure template rather than ad hoc portal configuration. Attempt to create an unapproved public storage account or broad privileged role and confirm that policy or review catches it. Record the expected owners and recovery path. If a model deployment requires a service exception, document its scope and expiry. Platform guardrails reduce repeated configuration problems, but they should not be mistaken for controls over prompt injection or unauthorized tool execution.

Use separate identities for deployment, runtime and delegation

The identity that deploys a model or changes its guardrails should not automatically be the identity that invokes inference or retrieves data. Managed identities and federation can reduce reusable secrets where supported, but downstream resource roles must still be narrow. An agent may also act under a specific agent identity or a delegated user context; which subject acquires the token determines which policy and audit rules apply. Entra agent controls can have preview and licensing limits, so do not generalize one tenant’s available options to all deployments.

Give the runtime identity permission to query one approved search index and call one inference endpoint, while retaining model-administration privilege on a separate deployment principal. Test that runtime cannot create deployments, alter safety controls or read unrelated storage. For a delegated tool, verify that the signed-in user is authorized for the particular requested business action, not merely that the agent service has an all-powerful backend credential. Log the actor and effective principal at each hop so incident responders can reconstruct authority.

Preserve classification and provenance through retrieval

A retrieval-augmented application may duplicate information into chunks, embeddings, vector indexes, caches and logs. The original SharePoint or database permissions may not automatically propagate to every derived store. Preserve source identity, tenant and document ACL metadata where required, and enforce authorization in the retrieval path. A user who could not directly open a confidential document should not get its content through an overbroad vector query. Data classification and retention must also account for copied prompts, traces, evaluation sets and agent memory.

Create two synthetic employee profiles with different document permissions and index a mixture of approved and restricted content. Ask both users a similar question and verify that retrieval filters respect their source entitlements. Examine logs and caches for accidental sensitive copies. Rebuild the index after revoking one permission to ensure stale access cannot persist unnoticed. A private search endpoint is useful for network exposure, but it cannot substitute for tenant and user authorization in the retrieval service.

Make tools narrowly typed and independently authorized

A tool turns model-produced text into an external side effect: it can send email, change a customer record, initiate a cloud deployment or call a payment API. Every high-consequence tool should define valid inputs, allowed operations, identity scope, request size, confirmation needs and idempotency behavior. The orchestration layer must treat model output as untrusted until deterministic code verifies it. A strong system prompt is a useful instruction but not a security boundary when the underlying service accepts unauthorized tool calls.

Test an agent with a read-only catalog tool and a separate write-capable order tool. Present malicious retrieved text that tells the model to send a large order to an attacker-controlled address. Regardless of the generated response, the order API should check the real user entitlement, approved supplier and transaction thresholds before committing anything. Log denials and provide safe feedback. Human approval should show the complete destination and consequence, not a vague confirm button that hides the altered request.

Defend prompts, third-party tools and memory as separate trust zones

Prompt injection can arrive through a user request, retrieved web page, email, document, tool result or a collaborating agent. Microsoft Foundry Prompt Shields and supported guardrails can help detect certain attacks but must be paired with least-privilege tools, validation and secure output handling. Tool responses should be treated as data even when they look like authoritative instructions. Persistent memory is another attack surface because malicious content can survive the original session and influence later work. External MCP servers or plugins introduce dependencies whose provenance and permissions need review.

Construct tests using an untrusted document that attempts instruction override, a tool result containing executable-looking output and a memory item that references stale authority. Verify that none can cause an unauthorized write or secret disclosure. Limit tool-call recursion, execution time and cost to reduce abuse through runaway loops. Review external tool implementations and dependency versions before granting access to regulated data. No single content filter eliminates the need for explicit application enforcement.

Constrain networking and secrets without breaking observability

Private endpoints can reduce public exposure for supported model, storage, search and database services, but they require coherent DNS, routing and firewall configuration. Network segmentation should limit which runtime components can call sensitive tools or reach external services. Still, the application needs service-level authentication for every protected resource. Secrets that cannot be eliminated should live in a controlled vault with narrow data-plane roles, rotation and recovery, not embedded in prompt files, pipeline variables or unchecked agent tools.

For a contained AI workload, verify the allowed private path from app to model and search, then attempt the same connection from an unauthorized network source. Separately test an incorrect identity over an allowed private path. Record DNS and authorization results so a failed request is not misdiagnosed as generic model failure. Keep enough logs to investigate failures, but avoid logging full sensitive prompts and retrieved documents by default when smaller event records would answer the operational question.

Use security telemetry to identify unusual agent behavior

An AI system should expose identities, model and tool calls, retrieval and data-access decisions, policy denials, unusual execution loops and infrastructure changes. Preserve correlation identifiers across services so an investigator can trace from human request through agent action and backend operation. Defender for Cloud may add AI posture and threat signals in supported configurations; application-level logs still explain what the agent actually attempted. All observability stores need access control and retention because they may themselves contain sensitive business or personal information.

Simulate a denied tool call and verify the evidence includes caller, agent or runtime identity, target tool, authorization outcome and request trace without storing unnecessary secret values. Then disable one data source to see whether alerting reveals loss of expected telemetry rather than interpreting silence as safety. Rehearse how an investigator distinguishes a prompt-injection attempt from a legitimate user instruction. This makes monitoring actionable even when the model’s generated wording varies between runs.

Prepare an AI-specific containment and rollback matrix

An AI incident may require disabling a tool, revoking a managed identity, removing a poisoned retrieval source, blocking a network path, rolling back model or prompt configuration or stopping the orchestrator. Containment should be scoped to the compromised boundary: shutting down every model endpoint may cause unnecessary business disruption, while disabling only a user session may leave an autonomous agent active. Recover from controlled artifacts, preserve relevant evidence and retest data permissions and tool approvals before restoring service.

Run a tabletop involving a poisoned document that caused repeated unauthorized write requests. Identify who can quarantine the document, restrict the agent tool, revoke affected credentials and determine whether real business records changed. Define rollback steps and test that the same payload no longer succeeds after the fix. The mature AI security design is not the promise that a model never makes a bad choice; it is proof that one bad choice does not obtain broader authority than the business explicitly allowed.

Related Guides and Official Objectives

Related Posts

• SC-200 Certification: Boost Your Cybersecurity Career

• Stepping Into Cybersecurity Leadership — The SC-100 Journey Begins

• Mastering SC-300: Microsoft Identity and Access Administrator

• Microsoft SC-200: KQL for Security Analysts: Ask Better Questions

• Microsoft SC-100: From Business Risk to Cybersecurity Architecture

• Microsoft SC-500: Defender for Servers Design Choices

• Microsoft SC-500: Entitlement Management in Entra ID

• Microsoft SC-500: Passkeys in Microsoft Entra ID

• Microsoft SC-500: Private Link Security Patterns

• Microsoft SC-500: Protecting Copilot Data with Purview