security

Enterprise RAG breaks on isolation, not on retrieval quality. The signal is enforcing tenant and document-level permissions server-side, at retrieval time, so the model can never surface data a user is not allowed to see. Here is the design that survives a security review.

Code-execution agents are powerful and risky: arbitrary model-generated code runs on your infrastructure. The signal is genuine isolation (containers/VMs), resource limits, and network/filesystem restrictions, not 'trust the model.' Here is the answer.

Writing the regexes takes ten minutes. The half of the question that separates candidates is the evaluation: a detector that blocks 'ignore the noise in the data' has shipped a bug to every analyst using your product. Here is the layered detector and the harness that proves it works.

Moving a cloud-API POC into a bank or defense network kills your model provider, your judge API, and your vendor dashboards in one stroke. Learn the signed-bundle supply chain, local evaluation loop, and zero-egress observability that make an air-gapped LLM stack actually operable.

Every AI product that runs generated code (notebooks, agents, code interpreters) ends up building this, and the interview turns on two numbers: how strong your isolation is and how fast a session starts. The answer is microVMs plus snapshot restore, and knowing why the VM boot is not the slow part.

A classic ML-security question that trips up people who only know clean-data accuracy. What lands is grasping why models are brittle, the realistic threat model, and the fact that no single defense holds. Here is the honest answer.

LLM endpoints are unusually exposed: every call can spend real money and consume scarce GPU capacity, so abuse is a security and a financial problem at once. What lands is layered controls on tokens and cost, not just request count. Here is the defense.

Most ML security centers on inference-time attacks; this one targets the training pipeline, where a poisoned dataset or a tampered dependency can hide a backdoor that clean-data evaluation never catches. What lands is naming the attack classes and recognizing that defense means provenance, not a single model fix.

Two attacks aimed at a deployed model's confidentiality: copying its functionality through the API, and deducing who was in its training data. What lands is naming the precise mechanism each exploits and recognizing that every defense trades against utility.

Attackers coax models into spilling the hidden system prompt, exposing IP, business logic, or worse, embedded secrets. The signal is treating the prompt as non-secret and defending in layers, rather than betting on 'never reveal your instructions.'

With direct injection the user attacks the prompt. With indirect injection the payload sits inside a page, doc, or email the model reads. The signal is recognizing that retrieved and tool data is untrusted and can hijack the model. Here is the answer.

An enterprise RAG that retrieves across everyone's documents is a breach in waiting. The fix belongs in the retrieval layer, not the prompt. Here is the design that survives a security review.

LLM apps bleed secrets in three quiet places: the prompt, the logs, and the next training set. Each demands a different control. Here is how to close all three.

Large models memorize and can be coaxed into emitting training examples verbatim, a genuine privacy and copyright liability. The defenses reach across data, training, and output. Here is the layered answer.

An attacker doesn't have to breach your LLM to hurt you, only make it do expensive work. A few crafted prompts can pin your GPUs and run up the bill. The defense is not a bigger rate limit.

AI features create cross-tenant leak paths that classic SaaS isolation never had to reckon with: shared embeddings, shared caches, and fine-tunes that memorize. One leak ends an enterprise contract. Here is the isolation model.

When an agent holds private data, reads untrusted text, and can talk to the outside, injected instructions can steal data. This 'lethal trifecta' is the defining agent vulnerability. The fix is architectural, not a better prompt.

Before naming defenses, a security engineer maps the attack surface systematically. LLM apps present a wider, stranger surface than classic software. Here is how to threat-model one end to end.

Security and compliance teams are gatekeepers, not adversaries. Interviewers look for you to bring them in early, satisfy real requirements, and turn a blocker into an ally. Here is the approach.