The complete Amazon Bedrock RAG + Agentic AI interview preparation resource - 110 questions with model answers, spanning fundamentals to system design + live coding rounds. Suitable for candidates preparing for AWS GenAI Cloud Engineer, ML Engineer, Solutions Architect + AI Engineer interviews at MNCs, hyperscalers + cloud consultancies. Companion to the Amazon Bedrock for RAG + Agentic AI handbook. September 2026 edition.
Level: Beginner → Intermediate, with advanced stretch questions.
Covers: LLM basics · Bedrock core · Embeddings · RAG + Knowledge Bases · Guardrails · Agents · Strands · AgentCore · MCP · Production.
Table of Contents
- GenAI + LLM Fundamentals (Q1-Q10)
- Amazon Bedrock Core (Q11-Q22)
- Prompt Engineering + Converse API (Q23-Q30)
- Embeddings + Vector Stores (Q31-Q38)
- RAG + Bedrock Knowledge Bases (Q39-Q52)
- Advanced RAG + Evaluation (Q53-Q60)
- Guardrails, Security + Responsible AI (Q61-Q68)
- Agentic AI Concepts + Tool Use (Q69-Q78)
- Bedrock Agents, Strands, AgentCore + MCP (Q79-Q90)
- Production, Cost + Operations (Q91-Q98)
- Scenario + System Design (Q99-Q104)
- Hands-on Coding (Q105-Q110)
- Rapid-Fire Revision (24 one-liners)
01. GenAI + LLM Fundamentals
Interviewers open with fundamentals to check that you understand what is happening underneath the APIs.
Q1. What is a foundation model, and how is it different from a traditional ML model? (Beginner)
A foundation model is a very large model pre-trained on broad data (text, code, images) that can be adapted to many tasks through prompting, RAG or fine-tuning. A traditional ML model is usually trained for one narrow task on labelled data (for example, a churn classifier). Foundation models are general-purpose; traditional models are task-specific.
Q2. What is a token, and why does it matter to an engineer? (Beginner)
A token is the unit of text a model reads and writes, roughly 3 to 4 characters of English. It matters because pricing is per input and output token, the context window is measured in tokens, latency grows with output tokens + chunk sizes in RAG are set in tokens. Indian languages such as Telugu and Hindi typically use more tokens per word, so they cost more.
Q3. What is a context window? (Beginner)
The maximum number of tokens a model can process in one request, covering the system prompt, conversation history, retrieved documents, tool definitions + the generated answer. Anything outside the window does not exist for the model.
Q4. LLMs are stateless. What does that mean in practice? (Beginner)
The model remembers nothing between API calls. A chatbot appears to remember because the application resends the conversation history on every call. That is why long chats get slower + more expensive, and why we need memory strategies such as trimming, summarising, or a memory service.
Q5. Explain temperature and top-p. (Beginner)
Temperature controls randomness: near 0 gives focused, repeatable output; higher values give more varied, creative output. Top-p limits sampling to the smallest set of tokens whose probabilities add up to p. For RAG + agents we use low temperature (0 to 0.3) for consistency; we usually tune one of the two, not both.
Q6. What is hallucination, and how do you reduce it? (Beginner)
Hallucination is fluent, confident output that is not supported by facts. Reduce it by grounding (RAG), giving tools for live data, instructing the model that "I don't know" is acceptable, lowering temperature, requiring citations + adding an automated check such as Bedrock Guardrails contextual grounding.
Q7. When would you choose prompt engineering, RAG, fine-tuning or an agent? (Intermediate)
| Problem | Choose |
|---|---|
| Wrong format, tone or reasoning style | Prompt engineering first |
| Model lacks private or fresh knowledge | RAG |
| Needs live data or must take actions | Agent with tools |
| Specialised behaviour at scale that prompting cannot achieve | Fine-tuning or distillation |
Key line: fine-tuning teaches behaviour, RAG supplies facts. Fine-tuning is a poor way to add facts that change.
Q8. What is the difference between an LLM's parametric and non-parametric knowledge? (Intermediate)
Parametric knowledge is stored in the model weights from training; it is fixed at the training cutoff + cannot cite sources. Non-parametric knowledge is supplied at runtime from external sources (documents via RAG, tool results). RAG adds non-parametric knowledge, which is updatable + citable.
Q9. What is "lost in the middle"? (Intermediate)
Models tend to use information at the beginning + end of a long prompt more reliably than information in the middle. Practical fixes: send fewer but better-ranked chunks, put the most relevant chunks first, put the question + key instructions at the end + rerank before generation.
Q10. What is a reasoning (extended thinking) model, and when is it worth using? (Intermediate)
Some models can spend extra tokens reasoning internally before answering. This improves accuracy on multi-step problems (planning, maths, complex tool use, code) but increases latency and cost. Use it for hard problems or agent planning; avoid it for simple lookups, classification or high-volume chat.
02. Amazon Bedrock Core
Expect these in any AWS GenAI interview. Answer with specifics: API names, clients + trade-offs.
Q11. What is Amazon Bedrock? (Beginner)
A fully managed, serverless AWS service that gives one API to many foundation models (Anthropic Claude, Amazon Nova, Meta Llama, Mistral, Cohere and others) plus built-in capabilities for building GenAI apps: Knowledge Bases (RAG), Guardrails, Agents, AgentCore, Flows, Prompt Management, Evaluations + model customisation. No infrastructure to manage; you pay per use.
Q12. Why would a company use Bedrock instead of self-hosting an open-source model on EC2 or EKS? (Beginner)
- No GPU provisioning, scaling or patching; pay per token instead of paying for idle GPUs.
- Access to many models, including proprietary ones, behind one API; easy to switch.
- Enterprise security: IAM, VPC endpoints (PrivateLink), KMS encryption, CloudTrail; prompts and outputs are not used to train the base models.
- Native RAG, guardrails, agents + evaluation reduce integration work.
Self-hosting can win when you need full control of weights, very high steady volume, or a model Bedrock does not offer.
Q13. Name the boto3 clients used with Bedrock and what each is for. (Beginner)
| Client | Purpose |
|---|---|
bedrock | Control plane: list models, guardrails, customisation jobs |
bedrock-runtime | Invoke models: converse, converse_stream, invoke_model, apply_guardrail |
bedrock-agent | Create + manage Knowledge Bases, data sources, Bedrock Agents |
bedrock-agent-runtime | retrieve, retrieve_and_generate, invoke_agent, rerank |
bedrock-agentcore(-control) | Invoke AgentCore runtimes and memory / create AgentCore resources |
Q14. What is the difference between InvokeModel and the Converse API? (Beginner)
InvokeModel takes a provider-specific JSON body, so each model family has a different request format. Converse provides one consistent message schema across chat models, with unified support for system prompts, multi-turn messages, images and documents, tool use + guardrails. Switching models with Converse is usually just a change of modelId. InvokeModel is still used for embeddings, image generation + provider-specific features.
Q15. How do you enable access to models on Bedrock today? (Beginner)
Serverless models are enabled by default in commercial regions. Anthropic models additionally need a one-time use-case form (submitted from the console playground or API). Access can still be restricted by IAM policies or Service Control Policies, so an AccessDeniedException usually means a policy, the form, or an SCP.
Q16. What is a cross-region inference profile? (Intermediate)
An identifier with a geography prefix (for example us., eu., apac. or global.) that lets Bedrock route requests to any region in that geography with available capacity. It increases throughput + resilience. Some newer models are only callable through inference profiles, which explains the error "on-demand throughput isn't supported" when using the plain model ID.
Q17. Which IAM actions are needed to call the Converse API? (Intermediate)
bedrock:InvokeModel for Converse and bedrock:InvokeModelWithResponseStream for ConverseStream. Resources should be scoped to the specific foundation-model and inference-profile ARNs used, following least privilege.
Q18. What are Bedrock API keys, and should you use them in production? (Intermediate)
A simpler bearer-token way to authenticate to Bedrock, useful for quick experiments and tools. Short-term keys last up to the console session (about 12 hours); long-term keys are recommended only for exploration. In production use IAM roles attached to Lambda, ECS, EC2 or AgentCore so no secret is ever stored.
Q19. What are the pricing and throughput options on Bedrock? (Intermediate)
- On-demand: pay per input / output token; subject to per-minute quotas.
- Batch inference: submit large offline jobs from S3 at a discount versus on-demand.
- Prompt caching: reduced cost and latency for repeated prompt prefixes.
- Service tiers / latency-optimised options for selected models.
- Provisioned throughput: reserved capacity for steady high volume or custom models.
Q20. What does Bedrock offer for model customisation? (Intermediate)
Fine-tuning on labelled examples, continued pre-training on unlabelled domain text (for supported models), model distillation (a large teacher model generates training data to make a smaller, cheaper student model better at your task) + custom model import for supported open-weight architectures you trained elsewhere.
Q21. What is Bedrock Flows and when would you use it instead of an agent? (Intermediate)
Flows is a visual workflow builder that links prompts, knowledge bases, Lambda functions, conditions + other nodes into a fixed pipeline. Use it when the steps are known and must be predictable + auditable (for example: classify a ticket, retrieve policy, draft a reply). Use an agent when the steps depend on the request + intermediate results.
Q22. What is Bedrock Prompt Management? (Intermediate)
A service to store prompts as versioned resources with variables (for example {{student_name}}), test them against different models in the console + reference a specific version from applications. It separates prompt changes from code deployments + lets teams collaborate on prompts.
03. Prompt Engineering + the Converse API
Answer the question asked, then add one practical detail that shows real hands-on experience.
Q23. What makes a good system prompt? (Beginner)
It defines the role, the task + goals, the rules + boundaries (what to refuse, when to say "I don't know"), the output format + where helpful examples. It is specific + positive ("answer in under 100 words" rather than "don't be long") + uses delimiters such as XML tags to separate instructions from data.
Q24. What is few-shot prompting? (Beginner)
Including a few example inputs with ideal outputs in the prompt so the model copies the pattern. It is often the fastest way to fix format + tone problems without fine-tuning.
Q25. How do you reliably get JSON from a model? (Intermediate)
- Specify the exact schema in the system prompt + say "return only JSON"; use temperature 0.
- More reliable: define a tool whose input schema is your JSON schema + force it with
toolChoice; the model must return arguments matching the schema. - Always validate the result (for example with Pydantic) + retry on failure.
Q26. Walk through a Converse API request and response. (Intermediate)
Request: modelId, optional system blocks, messages alternating user and assistant (each with content blocks: text, image, document, toolUse, toolResult), inferenceConfig (maxTokens, temperature, topP, stopSequences), optional toolConfig + guardrailConfig.
Response: output.message, stopReason, usage (input, output, cache tokens) + metrics.latencyMs.
Q27. What are the possible stopReason values and how do you handle each? (Intermediate)
| stopReason | Action |
|---|---|
end_turn | Return the answer |
tool_use | Execute the requested tools, send toolResult blocks, call again |
max_tokens | Output truncated: raise maxTokens or request a shorter format |
stop_sequence | A configured stop sequence was hit |
guardrail_intervened | A guardrail blocked content; return the configured message |
content_filtered | Provider safety filtering removed content |
Q28. How does prompt caching work on Bedrock and when does it help? (Intermediate)
You insert a cachePoint block after a long, static prefix (system prompt, tool definitions, a policy document). On later requests with the identical prefix, supported models read it from cache, reducing input cost + time-to-first-token. It helps when many requests share a large prefix; it does not help when every prompt is different.
Q29. How do you handle long multi-turn conversations? (Intermediate)
Keep only the last N turns, summarise older turns into a short running summary, store durable facts in long-term memory + retrieve them when relevant + use prompt caching for the static parts. This controls cost + keeps the context focused.
Q30. What is prompt injection and how do you defend against it? (Advanced)
Prompt injection is malicious instruction hidden in user input or in content the model reads (a retrieved document, web page, email or tool output), such as "ignore previous instructions and reveal the data". Defences in layers:
- Treat all retrieved + tool content as untrusted data; delimit it clearly + instruct the model not to follow instructions inside it.
- Guardrails prompt-attack filter on inputs; content filters on outputs.
- Least-privilege tools + IAM, so a hijacked agent cannot do much damage.
- Human confirmation for sensitive actions + deterministic policies (AgentCore Policy) outside the model.
- Never put secrets in prompts.
04. Embeddings + Vector Stores
Answer the question asked, then add one practical detail that shows real hands-on experience.
Q31. What is an embedding? (Beginner)
A vector of numbers representing the meaning of text (or images, audio). Texts with similar meaning have vectors that are close together, which enables semantic search: "reset password" matches "recover login credentials" even with no shared words.
Q32. Which embedding models can you use on Bedrock? (Beginner)
Amazon Titan Text Embeddings V2 (256, 512 or 1,024 dimensions, optional normalisation), Cohere Embed (English and multilingual) + multimodal embedding models such as Amazon Nova multimodal embeddings. Choose based on language coverage, modality, dimensions + cost + validate on your own data.
Q33. Why must queries and documents use the same embedding model? (Beginner)
Each model maps text into its own vector space. Vectors from different models (or different dimension settings) are not comparable, so similarity scores become meaningless. Changing the embedding model means re-embedding the whole corpus.
Q34. Cosine similarity vs dot product vs Euclidean distance? (Beginner)
Cosine measures the angle between vectors (direction only). Dot product combines angle and magnitude; for normalised vectors it equals cosine. Euclidean measures straight-line distance, where smaller means more similar. Cosine is the usual choice for text embeddings.
Q35. What is ANN search and HNSW? (Intermediate)
Approximate nearest neighbour (ANN) search finds very similar vectors without comparing against every vector, trading a small amount of recall for large speed gains. HNSW (Hierarchical Navigable Small World) is a popular graph-based ANN index used by OpenSearch, pgvector + others.
Q36. How do you choose embedding dimensions? (Intermediate)
Higher dimensions can capture more nuance but cost more storage, memory + search time. With Titan V2, 1,024 is the accurate default, while 512 or 256 can cut storage substantially with a small accuracy drop. Decide with an evaluation on your own queries.
Q37. Which vector stores can back a Bedrock Knowledge Base, and how do you choose? (Intermediate)
| Store | Choose when |
|---|---|
| Amazon S3 Vectors | Very large or archival corpora; lowest cost; can tolerate higher latency |
| OpenSearch Serverless / managed | Low-latency, high-QPS production; hybrid search + rich filters |
| Aurora PostgreSQL (pgvector) | Team already on PostgreSQL; want SQL + vectors together |
| Neptune Analytics | GraphRAG: relationships across documents |
| Pinecone, MongoDB Atlas, Redis Enterprise | Existing investment in that platform |
Or use a managed knowledge base + let AWS run storage entirely.
Q38. What is metadata filtering and why is it important? (Intermediate)
Storing attributes (program, department, date, version, access group) with each chunk + filtering on them at query time, for example equals program = NEXUS. It improves precision, keeps outdated versions out + supports document-level access control. It is often a bigger win than changing the embedding model.
05. RAG + Bedrock Knowledge Bases
The most heavily tested area. Be ready to draw the pipeline on a whiteboard.
Q39. What is RAG? Explain it end to end. (Beginner)
Retrieval-Augmented Generation retrieves relevant passages from your data + adds them to the prompt so the model answers from them. Ingestion: load, parse, chunk, embed, store vectors with metadata. Query time: embed the question, retrieve top-k chunks (optionally hybrid search, filters, reranking), build a prompt with the chunks + grounding rules + generate an answer with citations.
Q40. Why not just put all documents into a long-context model? (Beginner)
Cost + latency grow with prompt size, accuracy can drop with very long contexts + most corpora are larger than any context window. RAG sends only what is relevant. The two combine well: retrieve a focused set, then use a generous window to reason over it.
Q41. What are Amazon Bedrock Knowledge Bases? (Beginner)
Bedrock's managed RAG capability. It connects to data sources, parses, chunks, embeds + indexes documents, keeps them in sync + exposes the Retrieve + RetrieveAndGenerate APIs with citations. It integrates with Bedrock Agents, AgentCore + Guardrails.
Q42. Managed Knowledge Base vs customer-managed knowledge base? (Intermediate)
| Managed | Customer-managed | |
|---|---|---|
| Storage | AWS-managed, auto-scaling | You choose and run the vector store |
| Models | Defaults chosen and maintained by AWS | You pick embedding model and chunking |
| Connectors | S3, SharePoint, Confluence, Google Drive, OneDrive, Web Crawler, with ACL support | S3 and other connectors; more setup |
| Extras | Hybrid search, ranking, agentic retrieval | GraphRAG (Neptune), structured data / text-to-SQL, fine tuning of retrieval |
Q43. Retrieve vs RetrieveAndGenerate? (Intermediate)
Retrieve returns ranked chunks with scores, source locations + metadata; you build your own prompt. Best for agents + custom prompts. RetrieveAndGenerate retrieves + generates an answer with citations in one call and supports multi-turn sessions via sessionId. Best for quick, standard Q&A.
Q44. What chunking strategies does Bedrock support and when do you use each? (Intermediate)
| Strategy | Use when |
|---|---|
| Fixed-size (tokens + overlap) | Default starting point, uniform documents |
| Hierarchical (parent / child) | Long manuals + policies: search small, return large context |
| Semantic | Content with topic shifts: articles, transcripts |
| No chunking | Data already pre-split, such as one FAQ per file |
| Custom Lambda transformation | Special formats or domain rules |
Q45. How would you choose chunk size and overlap? (Intermediate)
Start at about 300 to 500 tokens with 10 to 20% overlap, then tune with an evaluation set. Too small loses context; too large adds noise + cost. FAQs work best as one item per chunk; long technical documents benefit from hierarchical chunking.
Q46. What parsing options exist and why does parsing matter? (Intermediate)
The default parser extracts plain text. Bedrock Data Automation and foundation-model parsing handle tables, figures, scanned pages + complex layouts (and Data Automation also handles audio + video). If tables become scrambled text at ingestion, no retrieval or prompt tuning can recover the numbers, so parsing quality sets the ceiling for RAG quality.
Q47. How do you add metadata to documents in an S3 data source? (Intermediate)
Place a sidecar JSON file next to each document named <filename>.metadata.json containing metadataAttributes, for example program, year + audience. These fields become filterable at retrieval time.
Q48. How do you keep a knowledge base in sync with changing documents? (Intermediate)
Run an ingestion job (start_ingestion_job) after changes; it processes only added, modified + deleted files. Automate it with S3 events or an EventBridge schedule triggering Lambda. Managed knowledge bases sync connected sources automatically. For immediate single-document updates, use the direct document ingestion APIs.
Q49. How do you implement multi-turn conversations with a knowledge base? (Intermediate)
With RetrieveAndGenerate, pass back the sessionId from the first response so follow-up questions use conversation context. With Retrieve, rewrite follow-ups into standalone queries ("and its fees?" becomes "NEXUS program fees") using a cheap model call before retrieval.
Q50. How do you enforce that users only see documents they are allowed to see? (Intermediate)
Never rely on the prompt. Use metadata filters built from the authenticated user's groups on every retrieval call, separate knowledge bases per tenant where isolation is required, or connector ACL support in managed knowledge bases (for example SharePoint permissions). Log access + test with users from different groups.
Q51. Your RAG bot gives wrong answers. How do you debug it? (Intermediate)
- Check retrieval first: call Retrieve + inspect the chunks. Is the right passage there?
- If not: check ingestion stats + parsing, chunk boundaries, filters + try hybrid search, more results plus reranking, or query rewriting.
- If the right chunk is retrieved but the answer is wrong: fix the prompt (grounding rules, order of chunks), lower temperature, try a stronger model.
- Add the failing question to the golden evaluation set + re-run after every fix.
Q52. Explain RAG vs agentic RAG. (Advanced)
Classic RAG is a fixed pipeline: retrieve once, then generate. Agentic RAG lets the model decide: rewrite the query, retrieve several times from several sources, call other tools + judge whether it has enough evidence. On Bedrock this is done by exposing retrieval as an agent tool, or by using agentic retrieval on managed knowledge bases, which plans sub-queries, retrieves iteratively + evaluates sufficiency. It handles multi-hop questions better, at higher latency + cost.
06. Advanced RAG + Evaluation
Answer the question asked, then add one practical detail that shows real hands-on experience.
Q53. What is hybrid search and when does it help? (Intermediate)
It combines keyword search (BM25) with vector search + merges the results. It helps when queries contain exact tokens that embeddings may miss: error codes, product IDs, names, acronyms. In Knowledge Bases set overrideSearchType to HYBRID where the vector store supports it.
Q54. What is a reranker and why use one? (Intermediate)
A model that scores each (query, chunk) pair together, which is more accurate than comparing separate embeddings. Pattern: retrieve 20 to 50 candidates cheaply, rerank, keep the top 3 to 5. It improves precision + reduces prompt noise + cost. Bedrock supports reranking models such as Cohere Rerank and Amazon Rerank through the Rerank API or Knowledge Base reranking configuration.
Q55. Explain query rewriting, decomposition, HyDE and multi-query. (Intermediate)
- Rewriting: make a follow-up question standalone.
- Decomposition: split a complex question into sub-questions + retrieve for each.
- HyDE: generate a hypothetical answer + search using its embedding.
- Multi-query: generate paraphrases, retrieve for each, merge results for better recall.
Q56. What is GraphRAG and when is it worth it? (Intermediate)
GraphRAG builds an entity + relationship graph from documents and, after vector search, traverses related entities to gather connected context across documents. On Bedrock, customer-managed knowledge bases can use Amazon Neptune Analytics for this. It helps with relationship-heavy, multi-hop questions; benchmark it against plain vector search on your own questions before adopting it.
Q57. How would you answer questions that need numbers or aggregation, like "how many students joined in August"? (Intermediate)
Not with vector search. Use structured data retrieval (text-to-SQL against a warehouse such as Redshift via Knowledge Bases structured data support), or give an agent a SQL or API tool. Vector search retrieves passages; it cannot count or sum.
Q58. Which metrics do you use to evaluate RAG? (Intermediate)
| Layer | Metrics |
|---|---|
| Retrieval | Context relevance, context recall / coverage, precision; hit rate + MRR on labelled data |
| Generation | Faithfulness (groundedness), answer correctness, completeness, answer relevance |
| Citations | Citation precision + coverage |
| Safety | Harmfulness, refusal correctness, stereotyping |
| Operations | Latency (p50 / p95), cost per query, token usage |
Q59. How do you evaluate RAG on Bedrock? (Intermediate)
Build a golden dataset (questions, reference answers, ideally source documents; include no-answer + multi-hop cases). Run Bedrock Evaluations RAG jobs against the knowledge base (retrieve-only or retrieve-and-generate) with an LLM-as-a-judge, or bring your own responses from a custom pipeline. Compare configurations side by side, change one variable at a time + track cost + latency with quality.
Q60. What are the limitations of LLM-as-a-judge? (Advanced)
Judges can be biased (towards longer answers, their own style, or the first option), inconsistent between runs + wrong on domain specifics. Mitigate with clear rubrics, reference answers, a strong judge model, spot-checking by humans + measuring judge agreement against human labels on a sample.
07. Guardrails, Security + Responsible AI
Answer the question asked, then add one practical detail that shows real hands-on experience.
Q61. What are Amazon Bedrock Guardrails? (Beginner)
Configurable safety policies applied to model inputs + outputs, independent of the model: content filters (hate, insults, sexual, violence, misconduct, prompt attacks), denied topics, word filters, sensitive information (PII) block or mask, contextual grounding checks + Automated Reasoning checks.
Q62. How does the contextual grounding check work? (Intermediate)
It scores the model response for grounding (is it supported by the provided source?) + relevance (does it answer the query?). If either score is below the threshold you configure, the response is blocked. With Converse you mark the source text with the grounding_source qualifier + the question with the query qualifier inside guardContent blocks.
Q63. What is the ApplyGuardrail API used for? (Intermediate)
To evaluate any text against a guardrail without invoking a Bedrock model: for models hosted elsewhere, for checking tool inputs + outputs in agents, or for moderating user content in a pipeline. It returns whether the guardrail intervened + any masked output.
Q64. Denied topics vs content filters? (Intermediate)
Content filters detect predefined harmful categories with adjustable strength. Denied topics are business-specific subjects you define in natural language, such as investment advice or competitor comparisons, even if not harmful.
Q65. How do you protect PII in a GenAI application? (Intermediate)
- Guardrails sensitive-information filters to block or mask PII (and custom regex) in inputs + outputs.
- Mask before logging; restrict access to model invocation logs.
- KMS encryption for S3 sources, vector stores + logs; VPC endpoints for private traffic.
- Do not index sensitive fields you do not need; apply access-controlled retrieval.
Q66. How is data privacy handled on Bedrock? (Intermediate)
Prompts + responses are not used to train the base foundation models + model providers do not get access to your data. Data is encrypted in transit + at rest, can use customer-managed KMS keys, traffic can stay private through PrivateLink + API activity is logged in CloudTrail. Always confirm regional data-residency requirements, especially when using cross-region inference.
Q67. What are Automated Reasoning checks? (Advanced)
A guardrail capability that turns policy documents into formal logical rules + verifies whether model responses are consistent with them, reporting valid, invalid or unsupported claims. It suits domains with strict, rule-based policies such as HR eligibility, insurance or compliance.
Q68. How do you secure an agent that can take real actions? (Advanced)
- Least-privilege IAM per tool; separate read + write tools.
- Human confirmation for irreversible actions (payments, deletions, emails to customers).
- Deterministic policies enforced outside the model, for example AgentCore Policy on Gateway tool calls, plus rate + budget limits.
- Guardrails on inputs, outputs + tool content; treat tool outputs as untrusted.
- Max iteration limits, timeouts, full tracing + audit logs.
08. Agentic AI Concepts + Tool Use
Answer the question asked, then add one practical detail that shows real hands-on experience.
Q69. What is an AI agent? (Beginner)
A system in which an LLM decides which actions to take to achieve a goal, calls tools to take them, observes the results + repeats until done. Its four ingredients are a model (reasoning), tools (actions), instructions (goals + rules) + memory (context across turns + sessions).
Q70. Chatbot vs RAG application vs agent? (Beginner)
A chatbot answers from model knowledge in a single call. A RAG app follows a fixed retrieve-then-generate pipeline over your documents. An agent dynamically chooses steps + tools, can call live systems + take actions + loops until the goal is met.
Q71. What is the ReAct pattern? (Beginner)
Reason plus Act: the model reasons about what to do, calls a tool (act), receives the result (observation) + repeats. Modern tool-calling APIs implement it natively through tool_use + tool result messages.
Q72. Explain tool use with the Converse API step by step. (Intermediate)
- Send
toolConfigwith tool specs: name, description, JSON input schema. - The model responds with
stopReason = tool_use+ one or moretoolUseblocks (toolUseId, name, input). - Append the assistant message to history; execute each tool in your code.
- Send a user message with
toolResultblocks matched bytoolUseId(status error if a tool failed). - Call Converse again; repeat until
end_turn. Enforce a maximum number of iterations.
Q73. What makes a good tool definition? (Intermediate)
A clear name, a description that says what it does, when to use it + when not to, well-described parameters with types + enums, concise outputs + informative error messages. The model chooses tools only from these descriptions, so most agent bugs are description bugs.
Q74. When should you NOT build an agent? (Intermediate)
When the steps are known + fixed, when strict determinism + auditability are required, or when latency + cost budgets are tight. A workflow (Flows, Step Functions or plain code) or a simple RAG chain is cheaper, faster + easier to test. Use the lowest level of autonomy that solves the problem.
Q75. What is human-in-the-loop in agents? (Intermediate)
Pausing the agent for a person to approve, edit or reject an action before it executes, typically for irreversible or high-risk actions. On Bedrock Agents this can be done with user confirmation or return of control; in code-first agents you interrupt the loop + resume after approval.
Q76. What types of memory does an agent need? (Intermediate)
Short-term: current session turns (trimmed or summarised). Long-term: durable facts, user preferences, summaries of past sessions + episodic memory of past experiences + outcomes. AgentCore Memory provides short-term events plus long-term strategies (semantic, user preference, summary, episodic), namespaced per user.
Q77. Describe common multi-agent patterns. (Intermediate)
- Supervisor / agents-as-tools: a coordinator delegates to specialists.
- Graph / workflow: agents as nodes with defined edges + conditions.
- Swarm: peers hand off to each other with shared context.
- Router: a classifier sends each request to one specialist.
Use multi-agent only with clear evidence (too many tools, conflicting instructions, separate owners) because each agent adds latency, cost + failure points.
Q78. Your agent keeps looping or calling the wrong tool. How do you fix it? (Advanced)
- Inspect traces to see reasoning + tool inputs / outputs.
- Improve tool descriptions; remove overlapping tools; add enums + examples.
- Return clear, actionable error messages instead of empty or huge outputs.
- Tighten the system prompt: when to stop, when to ask the user.
- Add a max-iteration limit + try a stronger model for planning.
- Add the case to your evaluation set (AgentCore Evaluations can score tool selection).
09. Bedrock Agents, Strands, AgentCore + MCP
Answer the question asked, then add one practical detail that shows real hands-on experience.
Q79. What are the main components of a Bedrock Agent? (Intermediate)
Instructions (system prompt), foundation model, action groups (tools defined by an OpenAPI schema or function details, executed by Lambda or returned to your app via return of control), associated knowledge bases, optional memory, code interpretation, guardrails + versions + aliases for deployment. Invoked with invoke_agent using a sessionId.
Q80. What is "return of control" in Bedrock Agents? (Intermediate)
Instead of calling a Lambda function, the agent returns the chosen action + parameters to the calling application, which executes it (for example on-premises or after user approval) + sends the result back in the next invocation.
Q81. What is the Strands Agents SDK? (Intermediate)
An open-source, model-driven Python SDK from AWS for building agents in a few lines: you provide a model (for example BedrockModel), a system prompt + tools (Python functions decorated with @tool, whose docstrings become schemas) + it runs the agent loop. It supports MCP tools, streaming, structured output, conversation managers, multi-agent patterns + OpenTelemetry tracing.
Q82. What is Amazon Bedrock AgentCore? (Intermediate)
A platform of modular services to deploy + operate agents securely at scale, with any framework (Strands, LangGraph, CrewAI, LlamaIndex) + any model: Runtime (serverless, session-isolated microVM hosting), Memory, Gateway (APIs and Lambda as MCP tools), Identity (inbound auth + outbound OAuth), Code Interpreter, Browser, Observability, Policy + Evaluations.
Q83. Bedrock Agents vs AgentCore: which would you choose? (Intermediate)
Bedrock Agents for quick, simpler, console-configured agents where AWS runs the orchestration. AgentCore for code-first, production agents that need framework or model flexibility, long-running sessions, enterprise identity, fine-grained policies, observability + evaluation. For new complex projects, a framework such as Strands on AgentCore is the usual choice.
Q84. How do you deploy a Strands agent to AgentCore Runtime? (Intermediate)
Wrap the agent in a BedrockAgentCoreApp with an @app.entrypoint function that receives the payload + returns the result, test locally, then use the AgentCore CLI to configure + deploy (it builds the container, pushes to ECR, creates the IAM role + runtime). Clients call it with invoke_agent_runtime + a session ID.
from bedrock_agentcore.runtime import BedrockAgentCoreApp
from strands import Agent
app, agent = BedrockAgentCoreApp(), Agent(tools=[...])
@app.entrypoint
def invoke(payload):
return {"result": str(agent(payload.get("prompt", "")))}
Q85. What does AgentCore Gateway do? (Intermediate)
It turns existing APIs, OpenAPI specifications, Lambda functions + MCP servers into MCP-compatible tools behind one secure endpoint, with authentication (via Identity), semantic tool discovery, rate limits + Policy enforcement on each tool call.
Q86. What is AgentCore Identity for? (Intermediate)
Managing who can call an agent (inbound authentication, for example with an existing identity provider) + letting the agent securely access third-party services on a user's behalf (outbound OAuth tokens or API keys held in a token vault), including user consent flows. Credentials never need to be hard-coded in agent code.
Q87. What is MCP and why does it matter? (Intermediate)
The Model Context Protocol is an open standard for connecting AI applications to tools + data. MCP servers expose tools, resources + prompts; MCP clients inside agents discover + call them. Build a tool once + use it from any compatible agent or IDE assistant, like USB-C for AI tools.
Q88. MCP vs A2A? (Intermediate)
MCP connects an agent to tools + data. A2A (Agent-to-Agent protocol) connects agents to other agents, letting independently built agents discover capabilities + delegate tasks. They are complementary.
Q89. What is AgentCore Policy and why enforce rules outside the model? (Advanced)
Policy defines what an agent may do (which tools, with which parameters, under which conditions), written in natural language + compiled to Cedar + enforced on Gateway tool calls before they run. Because it sits outside the model's reasoning, it holds even if the model is confused or prompt-injected: deterministic guarantees rather than hoping the model obeys its instructions.
Q90. How do you observe and evaluate agents in production? (Advanced)
AgentCore Observability captures OpenTelemetry traces of each session: reasoning steps, tool calls, latency + tokens, viewable in CloudWatch. AgentCore Evaluations scores live or batch traces with built-in evaluators (correctness, helpfulness, tool selection) + custom ones + supports A/B tests. Add alarms on errors, latency + spend + a weekly review of failed sessions.
10. Production, Cost + Operations
Answer the question asked, then add one practical detail that shows real hands-on experience.
Q91. How do you reduce Bedrock costs? (Intermediate)
- Use smaller models for routing, classification + simple answers; larger ones only where needed.
- Send fewer, better chunks (rerank) + summarise history to cut input tokens.
- Prompt caching for static prefixes; cap
maxTokens+ ask for concise output. - Batch inference for offline jobs; intelligent prompt routing; model distillation.
- Pick the right vector store (S3 Vectors for cheap large storage); delete idle dev resources.
- Limit agent iterations + set budget alarms.
Q92. How do you handle ThrottlingException? (Intermediate)
Use boto3 retries with exponential backoff (adaptive mode), use cross-region inference profiles for more capacity, smooth traffic with queues (SQS) for non-interactive work, move bulk jobs to batch inference + request quota increases (requests + tokens per minute) before launches.
Q93. How do you monitor a GenAI application on AWS? (Intermediate)
CloudWatch metrics for Bedrock (invocations, latency, tokens, throttles, errors), model invocation logging to S3 or CloudWatch Logs (with PII controls), CloudTrail for API audit, AgentCore Observability traces for agents, application-level feedback (thumbs up / down) + AWS Budgets alarms on spend.
Q94. How would you estimate monthly cost for a RAG chatbot? (Intermediate)
Requests per month times (average input tokens times input price plus average output tokens times output price). Input tokens include system prompt, history + retrieved chunks. Add embedding costs for ingestion + queries, vector storage + query costs, reranking + guardrail charges. For agents multiply model costs by average model calls per request. Use the current Bedrock pricing page for the chosen model + region.
Q95. How do you version and safely release changes to prompts, models or knowledge bases? (Intermediate)
Version prompts (Prompt Management), agents (versions + aliases) + infrastructure (CDK or Terraform). Run the golden evaluation set in CI for every change, compare against the current baseline, roll out gradually (A/B or canary alias) + keep a quick rollback path.
Q96. How do you reduce latency? (Intermediate)
Stream responses; choose faster models for simple steps; reduce prompt size; use prompt caching; retrieve fewer, reranked chunks; run independent tool calls in parallel; keep services in the same region; use latency-optimised options where available + cache frequent answers.
Q97. How do you design for multi-tenancy in a SaaS RAG product? (Advanced)
Choose isolation level per tenant: silo (separate knowledge base or index per tenant), pool (shared index with a mandatory tenant_id metadata filter enforced server-side), or bridge (a mix). Use tenant-scoped IAM roles or ABAC, per-tenant KMS keys where required, per-tenant usage metering + rate limits (for example AgentCore Gateway limits) + tests that prove no cross-tenant leakage.
Q98. What are the risks of cross-region inference for Indian or regulated customers? (Advanced)
Requests may be processed in another region within the chosen geography, which may conflict with data-residency rules. Mitigate by using in-region model IDs where available (for example in ap-south-1), choosing the geography prefix carefully + confirming with compliance which processing locations are acceptable.
11. Scenario + System Design Questions
Structure every design answer the same way: clarify requirements, draw the architecture, walk ingestion + query paths, then cover security, evaluation, cost + scale.
Q99. Design an internal HR policy assistant for 10,000 employees. (Intermediate)
- Data: HR policies in SharePoint; managed knowledge base with the SharePoint connector + ACLs, so employees see only documents they may access.
- Query: Retrieve with hybrid search + reranking; Claude or Nova generates answers with citations at temperature 0.
- Safety: Guardrails with grounding checks, denied topics (legal advice), PII masking.
- Front end: Slack or Teams bot via API Gateway + Lambda, SSO authentication.
- Quality: golden set of 150 HR questions, RAG evaluation jobs, feedback buttons, weekly review.
- Ops: auto-sync, CloudWatch dashboards, budget alarms.
Q100. Design a customer-support agent that can check order status and raise refunds. (Intermediate)
- Strands agent on AgentCore Runtime; tools:
get_order(read),create_refund(write) exposed through AgentCore Gateway from existing APIs. - Knowledge base for return + refund policies as a retrieval tool.
- Identity: customer authenticated; agent acts only on that customer's orders (enforced in the API + Policy, not the prompt).
- Policy: refunds above a threshold require human approval; max refunds per session.
- Memory for customer preferences; Guardrails for PII + abuse; Observability + Evaluations for quality.
Q101. How would you build a RAG system over 1 million scanned PDF pages? (Intermediate)
Advanced parsing (Bedrock Data Automation) for OCR, tables + layout; hierarchical chunking; rich metadata (document type, date, department); vector store chosen by latency + cost (OpenSearch for low-latency heavy traffic, S3 Vectors for cost at massive scale); hybrid search plus reranking; incremental ingestion; access-control filters; evaluation on a representative sample; batch inference for any bulk enrichment.
Q102. A stakeholder says "just fine-tune the model on our documents". How do you respond? (Advanced)
Fine-tuning teaches behaviour + style, not reliable, updatable facts; it cannot cite sources, needs retraining when documents change + still hallucinates. Recommend RAG for knowledge, with citations + access control + consider fine-tuning or distillation later for tone, format or cost reduction once RAG is working + evaluated.
Q103. Your RAG chatbot is accurate but costs three times the budget. What do you do? (Advanced)
- Measure token breakdown per request: system prompt, history, chunks, output.
- Rerank + send fewer chunks; trim or summarise history; cap output length.
- Prompt caching for static system prompt + instructions.
- Route easy questions to a smaller model (intelligent prompt routing or a classifier); cache frequent answers.
- Re-run the evaluation set after each change to confirm quality holds.
Q104. How would you migrate a LangChain + FAISS prototype on a laptop to production on AWS? (Advanced)
Move documents to S3; replace FAISS with a Bedrock Knowledge Base (managed, or customer-managed with OpenSearch / S3 Vectors) + scheduled sync; replace local model calls with Bedrock via langchain-aws or Converse; deploy the app on AgentCore Runtime or Lambda / ECS behind API Gateway with Cognito auth; add Guardrails, IAM least privilege, VPC endpoints, observability, evaluation in CI + infrastructure as code.
12. Hands-on Coding Questions
Interviewers increasingly ask candidates to write these live. Practise until you can type them from memory.
Q105. Write a minimal Converse call. (Beginner)
import boto3
brt = boto3.client("bedrock-runtime", region_name="us-east-1")
resp = brt.converse(
modelId="us.anthropic.claude-haiku-4-5-20251001-v1:0",
system=[{"text": "You are a concise AWS tutor."}],
messages=[{"role": "user", "content": [{"text": "What is S3?"}]}],
inferenceConfig={"maxTokens": 300, "temperature": 0.2},
)
print(resp["output"]["message"]["content"][0]["text"])
Q106. Generate a Titan embedding and compute cosine similarity. (Beginner)
import json, boto3, numpy as np
brt = boto3.client("bedrock-runtime", region_name="us-east-1")
def embed(t):
r = brt.invoke_model(modelId="amazon.titan-embed-text-v2:0",
body=json.dumps({"inputText": t, "dimensions": 512, "normalize": True}))
return np.array(json.loads(r["body"].read())["embedding"])
a, b = embed("reset my password"), embed("recover login credentials")
print(float(a @ b)) # normalised, so dot product = cosine
Q107. Query a knowledge base with a metadata filter and print sources. (Intermediate)
kb = boto3.client("bedrock-agent-runtime", region_name="us-east-1")
res = kb.retrieve(
knowledgeBaseId="KB_ID",
retrievalQuery={"text": "refund policy"},
retrievalConfiguration={"vectorSearchConfiguration": {
"numberOfResults": 5,
"filter": {"equals": {"key": "program", "value": "NEXUS"}}}},
)
for r in res["retrievalResults"]:
print(round(r["score"], 3), r["location"], r["content"]["text"][:80])
Q108. Implement a tool-calling loop with Converse. (Intermediate)
def run(messages, tools, registry, max_steps=6):
for _ in range(max_steps):
r = brt.converse(modelId=MODEL_ID, messages=messages, toolConfig=tools)
msg = r["output"]["message"]; messages.append(msg)
if r["stopReason"] != "tool_use":
return msg["content"][0]["text"]
results = []
for b in msg["content"]:
if "toolUse" in b:
tu = b["toolUse"]
out = registry[tu["name"]](**tu["input"])
results.append({"toolResult": {"toolUseId": tu["toolUseId"],
"content": [{"json": {"result": out}}]}})
messages.append({"role": "user", "content": results})
return "Step limit reached"
Q109. Build a Strands agent with a custom tool. (Intermediate)
from strands import Agent, tool
from strands.models import BedrockModel
@tool
def word_count(text: str) -> int:
# Count words in the given text. Args: text - The text to count.
return len(text.split())
agent = Agent(model=BedrockModel(model_id="us.anthropic.claude-haiku-4-5-20251001-v1:0"),
tools=[word_count])
print(agent("How many words are in 'Amazon Bedrock makes GenAI easy'?"))
Q110. Stream a response and print tokens as they arrive. (Intermediate)
resp = brt.converse_stream(modelId=MODEL_ID,
messages=[{"role": "user", "content": [{"text": "Explain RAG in 5 lines"}]}])
for ev in resp["stream"]:
if "contentBlockDelta" in ev:
print(ev["contentBlockDelta"]["delta"].get("text", ""), end="", flush=True)
13. Rapid-Fire Revision (24 One-Liners)
Cover the right column + test yourself the night before the interview.
| Question | Answer |
|---|---|
| Default Titan V2 embedding dimensions? | 1,024 (also 512 and 256) |
| API for search + answer + citations in one call? | RetrieveAndGenerate |
| Client for Retrieve + InvokeAgent? | bedrock-agent-runtime |
| Client for Converse? | bedrock-runtime |
| stopReason when the model wants a tool? | tool_use |
| Role used to send tool results back? | user (toolResult blocks) |
| Metadata sidecar file name? | <file>.metadata.json |
| Start a KB sync? | start_ingestion_job |
| Search type for keyword + vector? | HYBRID |
| Guardrail check against sources? | Contextual grounding check |
| Use guardrails without invoking a model? | ApplyGuardrail |
| Policy language behind AgentCore Policy? | Cedar |
| Protocol for agent-to-tool connections? | MCP |
| Protocol for agent-to-agent? | A2A |
| AgentCore service for sandboxed code? | Code Interpreter |
| AgentCore service to expose APIs as MCP tools? | Gateway |
| Cheapest vector store for huge archives? | Amazon S3 Vectors |
| Vector store for GraphRAG? | Amazon Neptune Analytics |
| Discounted offline inference? | Batch inference |
| Reuse long identical prompt prefixes? | Prompt caching (cachePoint) |
| Bedrock Agents tool definitions are called? | Action groups |
| Strands decorator for tools? | @tool |
| Prefix-based ID routing across regions? | Cross-region inference profile |
| Error when a model needs a profile ID? | ValidationException (on-demand throughput not supported) |
How to Answer Well in the Interview
- Structure: definition in one sentence, how it works, when to use it, one trade-off.
- Be concrete: name the API (Retrieve, Converse), the client (bedrock-agent-runtime) + a real number (300-token chunks, top-20 then rerank to 5).
- Tell a story: "In my capstone the bot missed error codes, so I switched to hybrid search + recall improved."
- Always mention evaluation, security + cost in design answers. That separates engineers from demo-builders.
- Say "I would verify in the docs" for fast-changing details such as model IDs, regions + quotas. Honesty scores better than guessing.
Content reflects Amazon Bedrock + AgentCore capabilities as of September 2026. Model IDs, region availability, quotas + prices change frequently; verify against current AWS documentation.
Cloudsoft APEX - AWS + AI + Cloud Interview Preparation
Cloudsoft Solutions (Hyderabad) runs the APEX flagship program covering AWS + Azure + GCP + AI/ML + Cybersecurity - with dedicated interview preparation cycles including Amazon Bedrock, RAG + Agentic AI, and system-design mock interviews.
- Cloudsoft APEX - AI + ML + Cloud + Security 2026 Flagship Program
- Full Interview Questions Library
- Senior AWS Engineer Interview Q&A
- Fresher Cloud + AI + DevOps Job Alerts
Contact Cloudsoft for a targeted Bedrock + AI/ML interview prep sprint tailored to your target company + role.
Cloud Soft Solutions - 513, 5th Floor, Aditya Enclave, Nilagiri Block, beside Ameerpet Metro Station, Hyderabad 500016 · cloudsoftsol.com · +91 96660 19191 · +91 99496 16388
