AIP-C01: Generative AI Developer Professional Exam Study Guide

01 Top-Down Exam Strategy & Logic Gates

Order of Operations: Read the final sentence first to identify the core constraint, such as least operational overhead, most cost-effective, or minimize latency.
The Well-Architected Baseline: Security is often the default priority in enterprise design, but the exam should always follow the stated requirement. If cost, speed, experimentation, or simplicity is the actual constraint, choose the option that best satisfies it while still applying reasonable security controls.
The Ephemeral Compute Law: AWS Lambda is usually a poor fit for long-lived session state or large custom model weights; do not rely on Lambda memory or /tmp when the requirement calls for durable state, strict latency, or specialized execution.
50/50 Purge Filter: Default to native Bedrock or serverless options when the requirement is least operational overhead or lowest cost. Do not eliminate ECS/EKS/GPU cluster patterns outright when the requirement explicitly calls for strict latency, guaranteed throughput, pre-warmed inference, or specialized runtime control.

02 Official Domain Breakdown

Domain	Weight and focus
Domain 1: Foundation Model Integration, Data Management, and Compliance (31%)	Focuses on RAG pipelines, vector stores like Aurora pgvector and OpenSearch Serverless, chunking strategies, and custom model deployment.
Domain 2: Implementation and Integration (26%)	Focuses on application integration, orchestration, Bedrock Agents, and real-time streaming via API Gateway WebSockets.
Domain 3: AI Safety, Security, and Governance (20%)	Focuses on PII redaction, prompt injection defense, topic boundaries via Bedrock Guardrails, and AWS PrivateLink.
Domain 4: Operational Efficiency and Optimization (12%)	Focuses on cost optimization, latency reduction, Prompt Caching, Batch Inference, and Provisioned Throughput.
Domain 5: Testing, Validation, and Troubleshooting (11%)	Focuses on full-stack observability via CloudWatch, X-Ray, Model Invocation Logging, and RAG metrics like factual grounding.

03 End-to-End RAG Pipeline

Step 1: Ingestion & Query Transformation: The client application sends the raw natural language query to the backend; optional rewriting occurs for multi-turn queries.
Step 2: Vector Embedding Generation: The transformed text query is sent to an embedding model like Amazon Titan to convert the string into a high-dimensional dense vector.
Step 3: Vector Database Retrieval & Hybrid Search: The query vector is sent to the vector index, such as Amazon OpenSearch Serverless or Aurora pgvector. An Approximate Nearest Neighbor (ANN via HNSW) search identifies the top-k similar chunks. k-NN Tradeoff: Increasing k increases candidate recall but degrades search performance (higher latency/compute); decreasing k speeds up search at the cost of recall.
Step 4: Reranking & Context Filtering: Top candidate chunks pass through a Cross-Encoder or Reranker Model like Cohere to score true relevance.
Step 5: Prompt Augmentation: The system constructs a structured prompt payload using Bedrock Prompt Management to combine context chunks, system instructions, and the user query.
Step 6: Foundation Model Inference & Guardrails: The augmented prompt is passed to the Foundation Model. Amazon Bedrock Guardrails checks for prompt injections on ingress and verifies factual consistency on egress.
Step 7: Response Delivery: The generated text along with chunk source citations is streamed back to the client UI in real time via WebSockets or Server-Sent Events.

Inference flowFrom prompt initiation to final answer: user prompt enters the application > request validation and auth > prompt/context assembly > retrieval and reranking > model invocation > guardrails and safety checks > token streaming or final response > observability and logging.

04 Pipeline Validation & Defense-in-Depth

Input: Validate identity, size, schema, and allowed operations.
Application: Apply deterministic business rules and sanitize payloads.
Generation: Evaluate output against the configured safety and quality policy.
Operations: Monitor behavior over time for quality shifts and failures.

05 Vector Store Mechanics & Performance Tuning

Vector databases store dense embeddings for semantic search. Understanding how they index and scale is critical for troubleshooting retrieval latency:

HNSW vs. Flat (Brute Force): HNSW (Hierarchical Navigable Small World) builds multi-layer graphs for Approximate Nearest Neighbor (ANN) search with logarithmic time complexity: O(log N). Flat index performs exhaustive distance comparison across every vector in O(N) time. Always use HNSW at scale; Flat guarantees 100% recall for tiny datasets (<10k), but search latency explodes linearly as the index grows.
The k-NN Tradeoff (Recall vs. Latency): k specifies the number of nearest neighbors retrieved. Increasing k retrieves more candidate vectors (improving recall for downstream rerankers), but requires deeper graph traversal and larger candidate sorting, which increases query latency and degrades search performance. It never resolves slow search.
Segment Architecture & Refresh Interval (OpenSearch / Lucene): OpenSearch flushes vectors into immutable Lucene segments on every index refresh (default: 1s). Crucially, an HNSW graph is built per segment, and k-NN queries must search every active segment's graph before merging results. Continuous ingestion with frequent refreshes creates dozens of tiny segments, severely degrading search latency as the index grows. Fix: Raise index.refresh_interval (e.g., 30s–120s) so vectors accumulate into fewer, larger segments with unified HNSW graphs.
OpenSearch Serverless (AOSS) Boundaries: AOSS automatically provisions and scales OpenSearch Compute Units (OCUs) for ingestion and search. Shards and replicas are completely managed and abstracted by AWS; developers cannot configure shard counts or search replicas for Serverless collections.
Metadata Pre-filtering: Applying metadata filters before vector distance calculation prunes the candidate search space early, reducing search latency significantly more than adjusting k.

OpenSearch degraded search as index grows → Raise refresh interval (fewer segments/HNSW graphs); eliminate shard/replica tuning on Serverless (managed by OCUs).

Expanded green / red matrixUse the full keyword-to-architecture matrix on page 8. Treat trigger phrases as clues to verify against the workload, service capabilities, and stated constraints, not as deterministic answer rules.

06 State Management & Integration

Stateless compute / Simple independent lookups

🟢 Target: AWS Lambda, Raw Bedrock InvokeModel API, and Stateless MCP servers.

🔴 Eliminate: Provisioning persistent EC2 instances or attempting to persist session context in Lambda memory.

Stateful workflows / Multi-turn memory

🟢 Target: Amazon Bedrock Agents, Amazon DynamoDB keyed by sessionId + TTL, and AWS Step Functions Task Tokens.

🔴 Eliminate: Storing state in Lambda /tmp memory, passing entire untrimmed raw chat history from the client, and synchronous sleep loops in Lambda.

Multi-agent orchestration / shared persistent state

🟢 Target: Amazon Bedrock AgentCore Memory for managed shared memory across orchestrator and worker agents in hierarchical task execution.

🔴 Eliminate: Treating S3, DynamoDB, or ElastiCache as the default solution when the requirement is managed, shared agent state with coordination semantics.

Continuous streaming inference / IoT and event streams

🟢 Target: Amazon Kinesis Data Streams feeding Lambda or other consumers that invoke Bedrock per batch for near-real-time processing of continuous sensor or event data.

🔴 Eliminate: Scheduled polling, S3 upload triggers, or manual review patterns when the requirement is continuous streaming inference with low latency and event-driven processing.

FM provider outage / Circuit breaker

🟢 Target: AWS Step Functions Circuit Breaker pattern to fail over between foundation models.

🔴 Eliminate: Route 53 Multi-Region failover and Bedrock Cross-Region Inference.

07 Prompting, RAG & Vector Storage

Hybrid search / duplicate results

🟢 Target: Combine keyword and vector retrieval, deduplicate by document ID or normalized content, and merge relevance scores before reranking.

🔴 Eliminate: Treating keyword and vector results as separate final answer sets or disabling keyword search entirely when the requirement is hybrid retrieval.

Embedding consistency / mixed model versions

🟢 Target: Keep a single embedding model and version per vector index; all vectors in the same space must be generated by compatible encoders.

🔴 Eliminate: Mixing embeddings from different models or model versions inside one index, because they live in different vector spaces and produce unreliable similarity results.

GraphRAG / Graph relationships + vector similarity

🟢 Target: Amazon Neptune Analytics when the requirement combines related documents or entities, graph structure, and vector similarity search.

🔴 Eliminate: Treating a standalone vector store as the GraphRAG answer when the question specifically requires graph relationships or graph traversal.

S3 prompt-template governanceWhen S3 Versioning is enabled, teams can retain and restore previous versions of stored template objects.

08 Safety, Security & Networking

Cross-Region Inference / compliance boundaries

🟢 Target: Same-region inference for regulated workloads, or use explicit regional controls and networking patterns when data residency is required.

🔴 Eliminate: Treating Cross-Region Inference as compliant by default. Data can traverse regions and be subject to different regulatory requirements.

09 Testing, Evaluation & Observability

Enterprise monitoring & full observability architecture

🟢 Target: The Four-Pillar Observability Stack consisting of CloudWatch metrics, AWS X-Ray tracing, Bedrock Model Invocation Logging, and Amazon Managed Grafana.

🔴 Eliminate: Isolated CloudWatch metrics alone and weekly/batch log polling cadences.

Multi-agent systems / cross-agent observability

🟢 Target: Monitor each agent's latency, token usage, tool calls, retries, and coordination flow, then correlate traces for end-to-end task success and bottlenecks.

🔴 Eliminate: Treating a single aggregate dashboard or just the busiest agent as sufficient for diagnosing orchestration failures, handoff problems, or quality regressions across the system.

Alerting / baseline-first monitoring

🟢 Target: Establish a representative baseline for normal GenAI behavior before setting thresholds, then alert on statistically significant deviations in latency, token usage, error rate, or quality.

🔴 Eliminate: Triggering alerts on every minor fluctuation, disabling monitoring during rollout, or setting static thresholds without a baseline.

Bedrock RAG Evaluation: Citation Metrics

🟢 Target: Citation Coverage for measuring recall and completeness of source backing, and Citation Precision for measuring citation accuracy.

🔴 Eliminate: Claims that coverage applies to text while precision applies to images, execution speed pipeline claims, and custom prompt requirements.

10 Cost Optimization

Predictable queries / Reduce time to first token

🟢 Target: Pre-compute responses for common, predictable queries and serve them from an application-level response cache before invoking the Bedrock foundation model. A cache hit avoids model inference, reducing time to first token, latency, and token charges.

🔴 Eliminate: Increasing temperature, adding more few-shot examples, or assuming the InvokeModel API is inherently faster than the Converse API.

Response caching stores completed answers. Prompt Caching stores reusable prompt prefixes and still invokes the model.

Repeated system prompt + similar FAQ queries / Two-layer caching

🟢 Target: Combine Bedrock Prompt Caching for repeated system-prompt prefixes with semantic caching for similar FAQ queries. Prompt caching reduces repeated input-token charges; semantic-cache hits return stored responses without invoking the model.

🔴 Eliminate: Treating prompt caching and semantic caching as interchangeable: one reuses prompt context, while the other reuses completed answers for semantically similar requests.

Most cost-effective / Reduce token billing spend

🟢 Target: Prompt Caching for static prompt prefixes > 1,024 tokens, Batch Inference for offline processing, Model Right-Sizing, and S3 Vectors.

🔴 Eliminate: Idle dedicated instances like SageMaker multi-GPU endpoints, Flagship over-provisioning, and full raw document injection.

01 Generative AI Basics

Generative AI creates new content such as text, images, audio, code, and synthetic data from learned patterns. A foundation model is a large, general-purpose model trained on broad data and adapted to many downstream tasks.

RememberModel output is probabilistic. A fluent response is not automatically factual, current, or safe.

Common model tasks

Summarization: compress information while preserving key meaning.
Classification: assign labels, sentiment, intent, or topic.
Extraction: return structured fields from unstructured text.
Question answering: generate an answer from learned knowledge or supplied context.
Transformation: translate, rewrite, format, or generate code.

02 Foundation Model Workflow

Stage	Purpose
Pre-training	Learn general language or multimodal patterns from large, diverse datasets.
Adaptation	Specialize behavior with prompting, fine-tuning, or preference optimization.
Inference	Use the model to produce a response for a particular request and context.
Evaluation	Measure quality, safety, latency, cost, robustness, and business fit.

Parameters are learned numerical values. More parameters can increase capability, but does not guarantee better results for every task.

03 Prompt Engineering

A strong prompt gives the model a clear task, relevant context, constraints, and an output format. Put instructions where they are easy to distinguish from untrusted input.

Task + Context + Constraints + Examples + Output format

Zero-shot: request a task without examples.
Few-shot: show representative input and output examples.
Chain-of-thought: for internal reasoning needs, request a concise answer or rationale appropriate to the use case rather than exposing sensitive reasoning.
Iterate with evaluation data; change one prompt variable at a time.

04 Amazon Bedrock

Amazon Bedrock is a fully managed service for building generative AI applications with foundation models from multiple providers through a unified API. It supports model choice, experimentation, customization, agents, guardrails, and knowledge bases.

Capability	Use it when you need to...
Model inference	Generate or transform content using a selected foundation model.
Knowledge Bases	Ground responses in enterprise data with retrieval-augmented generation.
Agents	Plan multi-step tasks and call APIs or action groups.
Guardrails	Apply configurable content filters and denied topics.
Model customization	Adapt a supported model to a domain with labeled or continued-pretraining data.

Exam cueBedrock is the application platform. SageMaker is the broader ML platform for building, training, tuning, and deploying custom models with more control.

05 RAG vs. Fine-Tuning

Approach	Best fit	Tradeoff
RAG	Current, private, or frequently changing facts.	Requires retrieval quality and a maintained index.
Fine-tuning	Consistent style, format, behavior, or domain patterns.	Needs curated data and retraining when behavior must change.
Prompting	Fast, low-risk behavior changes and prototypes.	Less durable and can be sensitive to wording.

RAG retrieves relevant chunks, adds them to the prompt, and asks the model to answer from that context. Chunking, metadata filters, embeddings, and reranking affect retrieval quality.

Structured data ruleFor tables, CSVs, JSON, and other structured sources, use format-aware chunking that preserves schema boundaries and row/column relationships. Generic semantic chunking can keep the raw text but still destroy meaning by splitting tables across boundaries.

Preserve existing systemsWhen the requirement says to keep the existing codebase, architecture, or platform unchanged, prefer an adapter, compatibility layer, or minimal integration point over rewriting, replacing, or replatforming the current system. The goal is to add capability without breaking the consuming application.

Reduce vector search scopeWhen a RAG system has a very large document set, narrowing the search space with metadata filters or hierarchical indexes before similarity search often reduces latency much more than simply adjusting the number of retrieved chunks. Search a smaller relevant subset first; only then run vector similarity on that candidate set.

06 Quick Recall

Define the business task.
Choose a model by quality, cost, and latency.
Protect sensitive data.
Ground factual answers.
Evaluate representative prompts.
Monitor production drift.
Apply least privilege.
Log safely and audit access.

07 Responsible AI

Responsible AI means designing, deploying, and operating AI systems with fairness, explainability, privacy, security, safety, and accountability in mind. Responsibility spans the full lifecycle, not only the model.

Risk	Practical control
Bias	Use representative data, subgroup metrics, human review, and documented limitations.
Hallucination	Use RAG, citations, constrained outputs, confidence handling, and evaluation sets.
Prompt injection	Separate instructions from retrieved content; validate tool calls and authorize actions.
Privacy	Minimize data, redact sensitive values, control retention, and restrict access.
Misuse	Use abuse monitoring, rate limits, content filters, and incident response.

08 Security Fundamentals

Identity: use IAM roles, least privilege, short-lived credentials, and resource policies.
Data protection: encrypt in transit and at rest; use AWS KMS for key management where appropriate.
Network controls: use VPC connectivity, private endpoints, security groups, and egress controls for sensitive workloads.
Observability: capture useful audit events with CloudTrail and application metrics, while avoiding secrets and unnecessary prompt retention.
Supply chain: validate datasets, dependencies, model artifacts, and retrieved documents.

Least privilege checkCan this identity read every document, call every tool, or change every resource? If not, scope it to the smallest required action and resource.

Bedrock Converse IAMInvoking a foundation model through the Converse API requires bedrock:InvokeModel; there is no separate bedrock:ConverseModel action.

Auditability defaultFor compliance and governance, keep enough evidence to reconstruct what happened: tool calls, request parameters, responses, timestamps, identities, and policy decisions. If the design hides or deletes interaction details, it usually fails the audit requirement.

Auditability ruleIf a question is about compliance, governance, policy enforcement, or regulator review, choose the option that preserves evidence of what the agent did. The right design keeps request data, response data, timestamps, tool calls, identities, and decisions; avoid choices that hide, delete, or erase interaction details.

Centralized governance ruleWhen the requirement is enterprise-wide policy enforcement, use one shared access layer or control plane to centralize IAM, quotas, usage tracking, and model access controls. Avoid per-team duplicates, scattered admin rights, or isolated model access paths that make governance inconsistent.

Managed service reduces ops burdenFor operational questions, favor the managed service when the requirement is to reduce patching, scaling, capacity management, and availability work. Bedrock and similar managed services shift infrastructure operations to AWS, which is why the “lower operational burden” answer is usually the correct common-sense choice.

09 Data Preparation

Quality data improves both retrieval and customization. Remove duplicates, resolve encoding problems, preserve useful structure, and document provenance.

Collect data with a permitted business purpose.
Clean, normalize, deduplicate, and redact.
Split into representative training, validation, and test sets.
Inspect labels and balance important classes.
Track versions, sources, owners, and quality metrics.

10 Evaluation & Metrics

Evaluate the whole system, not just the base model. Include task quality, safety, latency, cost, and user outcomes.

Dimension	Questions to ask
Quality	Is the answer correct, relevant, complete, and well formatted?
Grounding	Does it use the supplied evidence and avoid unsupported claims?
Safety	Does it refuse harmful requests and protect sensitive content?
Intent detection	Does the agent correctly understand what the user wants before selecting tools or actions?
Helpfulness / task success	Does the response address the user's need and solve the stated problem?
Performance	Are latency, throughput, availability, and token usage acceptable?
Business value	Does it reduce effort, improve outcomes, or meet the service goal?

Agent intent accuracyHigh accuracy leads to appropriate tool calls and actions; low accuracy causes irrelevant tool use, poor task completion, and a worse user experience.

Choose the metric from the questionIf the question asks whether the customer’s problem was solved, use helpfulness or task-success evaluation. Token count and latency are operational metrics unless the stem explicitly makes cost or response time the goal.

Customer-service defaultFor customer-facing GenAI, “did the agent solve the user problem?” is usually a helpfulness or task-success question, not a fluency, latency, or token-count question. Fluency measures grammar, latency measures speed, and token count measures cost—unless the requirement explicitly says the goal is speed or cost.

Systematic model comparisonWhen the goal is to determine which foundation model performs best on a task, look for repeatable evaluation using task-relevant quality metrics. Bedrock Model Evaluation supports systematic comparisons with built-in or custom metrics. CloudWatch latency and token metrics are operational measures; prompt A/B tests compare prompt configurations, while the Playground is for interactive exploration.

Production observability ruleWhen the goal is to monitor prompt performance in production, choose the option that records prompt and response behavior so teams can analyze template effectiveness, failure patterns, and quality trends. Generating templates, encrypting prompt text, or rewriting underperforming prompts are not the same as observing or diagnosing production behavior.

Total cost = input tokens + output tokens + retrieval + tool calls + operations

11 Production Pattern

Request -> Validate -> Retrieve -> Generate -> Guard -> Observe

Validate identity, input size, content type, and allowed operation.
Retrieve only authorized, relevant context.
Generate with a stable prompt and bounded parameters.
Apply output checks, citations, schema validation, and human escalation.
Monitor quality, safety signals, cost, latency, errors, and drift.

12 Service Map

AWS service	Think of it as...
Amazon Bedrock	Managed access to foundation models and GenAI application features.
Amazon SageMaker AI	Build, train, tune, deploy, and govern ML models with deep control.
Amazon OpenSearch Service	Search and vector retrieval for knowledge applications.
Amazon S3	Durable storage for source documents, datasets, and artifacts.
AWS IAM / KMS	Identity permissions and encryption key management.
Amazon CloudWatch	Operational metrics, logs, dashboards, and alarms.

13 Exam Checklist

Managed or custom model?
What data is sensitive?
Who can invoke the model?
What happens on failure?
How is quality measured?
How is cost controlled?

Final promptChoose the simplest managed AWS capability that satisfies the requirement, then add only the controls needed for the data, risk, scale, and latency.

Routing logic ruleModel cascading only works when the routing classifier reliably distinguishes simple queries from complex ones. If the classifier cannot separate them, it falls back to the larger model and the cost-saving routing logic is broken.

14 Choose the Abstraction

Question wording	Likely direction
Train, tune, host, or deeply control a custom model	SageMaker AI
Custom model with large payloads (>6 MB) or long runtimes (>60s) on-demand	SageMaker Asynchronous Inference
Event-driven stateless code or preprocessing	AWS Lambda
Durable multi-step orchestration, retries, task tokens	Step Functions
API front door, authentication, schema validation	API Gateway
Trace latency and cross-service failures	AWS X-Ray
Private service access and data isolation	PrivateLink / VPC endpoints

15 Retrieval Choice

Signal	Choice
Vector search at scale; infrequent queries	S3 Vectors
Graph relationships + vector similarity	Neptune Analytics / GraphRAG
Vector embeddings + ANN + graph index	HNSW (logarithmic scaling: `O(log N)`)
Degraded vector search as index grows	Raise `index.refresh_interval` (reduces segment/graph count)
OpenSearch Serverless collection scaling	Managed OCUs (cannot configure shard count or replicas)

16 Agentic Application Patterns

ReAct: reasoning, acting through a tool, observing the result, and repeating as needed.
Bedrock Agents: managed agent behavior with action groups and knowledge sources.
Step Functions: explicit workflow orchestration, retries, task tokens, and circuit breakers.
DynamoDB sessionId + TTL: durable bounded conversation state.
WebSockets or streaming responses: lower perceived time to first token.

Do not confuseReAct is a general reasoning-and-action pattern. Step Functions and Bedrock Agents are AWS implementation choices that may orchestrate agentic behavior.

17 Performance & Cost Signals

Signal	Target
Repeated long prompt prefixes	Prompt Caching; reduces repeated input-token charges.
Repeated predictable completed queries	Application response cache; avoids model invocation.
Offline high-volume processing	Batch Inference.
Guaranteed capacity or throughput	Provisioned Throughput.
Reduce cost without a quality requirement	Model right-sizing; avoid flagship over-provisioning.

18 Input, Retrieval, Output

Stage	Primary concern
Input	Identity, schema, size, prompt injection, PII.
Retrieval	Authorization, chunking, embeddings, relevance, grounding.
Generation	Model fit, prompt, latency, token cost, temperature.
Output	Guardrails, citations, schema, human escalation.
Operations	CloudWatch, X-Ray, invocation logs, drift, alarms.

19 One-Line Exam Heuristics

Graph relationships + vectors → GraphRAG / Neptune Analytics.

Embedding similarity + ANN → vector index / HNSW.

OpenSearch degraded search as index grows → Raise refresh interval (fewer segments/HNSW graphs); eliminate shard/replica tuning on Serverless (managed by OCUs).

k in k-NN → Higher k increases recall but degrades search latency/performance; lower k improves query speed.

Repeated prompt prefix → Prompt Caching.

Repeated finished answer → response cache.

Multi-step stateful process → Agents or Step Functions.

Custom model endpoint → SageMaker + ECR + S3.

System-prompt role definition → consistent persona, expertise, tone, and domain focus.

Temperature → output randomness, not IAM permissions, model architecture, or programming-language access.

20 Final Pass

Read the final sentence and identify the constraint.
Classify the workload: model, retrieval, state, security, cost, or operations.
Choose the managed service that directly owns that capability.
Eliminate answers that add infrastructure, violate state boundaries, or solve a different problem.
Check freshness, access, quality, latency, and cost before committing.

Answer disciplineDo not select the most familiar AWS service. Select the service whose primary purpose matches the strongest requirement keyword.

21 Core GenAI Services

Service	What it does
Amazon Bedrock	Fully managed service to access foundation models (FMs) from Amazon, Anthropic, Meta, Cohere, and others via API. Provides `InvokeModel`, `Converse`, streaming, and batch inference — no infrastructure to manage.
Bedrock Agents	Orchestrate multi-step, stateful tasks by combining FM reasoning with action groups (Lambda functions) and Knowledge Bases. Agents plan, invoke tools, and return results autonomously. Enable `enableTrace: true` for step-by-step diagnostics.
Bedrock Data Automation	Extract structured output (text, key-value pairs, tables) from documents, images, and media using FM-powered pipelines for downstream processing.
Bedrock Guardrails	Configurable content filters applied to FM inputs and outputs: denied topics, sensitive-information redaction (PII/regex), prompt-attack detection, contextual grounding checks, and word filters. Works with Bedrock, SageMaker, and custom models.
Bedrock Knowledge Bases	Managed RAG pipeline: ingest documents from S3, automatically chunk, embed, and index them into a vector store, then retrieve relevant context at query time to ground FM responses in private data.
Bedrock Model Evaluation	Run automated or human evaluations against FMs using built-in or custom metrics on your datasets. Compare model quality (accuracy, toxicity, robustness) before production deployment.
Bedrock Prompt Management	Centrally author, version, and manage prompt templates with dynamic variables. Create prompt variants per model/use case and deploy via prompt ARNs — decouples prompt engineering from application code.

22 Model Training & Hosting

Service	What it does
Amazon ECR	Managed container registry for storing Docker images used by SageMaker training jobs and inference endpoints — the standard path for custom model containers.
Amazon SageMaker AI	Build, train, and deploy custom ML/FM models at scale. Supports notebook development, distributed training, and multiple inference modes: Real-Time, Async (payloads up to 1 GB, scale-to-zero), Serverless, and Batch Transform.
Bedrock Custom Models	Fine-tune or continue pre-training supported Bedrock FMs on your labeled data without managing infrastructure. Produces a custom model invocable through the same Bedrock APIs.

23 Vector & Data Stores

Service	What it does
Amazon DynamoDB	Serverless key-value/document database. Common for session state (keyed by `sessionId`), conversation history, and metadata lookups in GenAI applications — not for vector search.
Amazon Neptune Analytics	Graph analytics engine for relationship-rich data. Combines graph traversals with vector similarity for GraphRAG — finding related entities/documents via structural connections.
Amazon OpenSearch Service / Serverless	Distributed search and analytics engine with native k-NN vector search (HNSW). Serverless auto-scales via OCUs. Primary choice for hybrid keyword + semantic retrieval in RAG.
Amazon S3	Object storage for documents, datasets, model artifacts, logs, and evaluation results. Source for Knowledge Base ingestion, SageMaker training data, and Model Invocation Log storage.
Aurora PostgreSQL (pgvector)	Relational database with the `pgvector` extension for vector similarity search alongside SQL transactions — ideal when relational and vector queries coexist.

24 Orchestration & Compute

Service	What it does
Amazon API Gateway	Managed API front door. WebSocket API enables real-time token streaming from Bedrock. REST API buffers full responses (no streaming). Provides request validation, throttling, and auth integration.
Amazon EventBridge	Serverless event bus that routes events from AWS services, SaaS, and custom apps to targets via rules. Useful for event-driven GenAI workflows triggered by state changes.
Amazon Kinesis Data Streams	Real-time streaming data ingestion at scale. Feeds Lambda or other consumers for near-real-time GenAI processing of high-throughput event data (e.g., clickstreams, IoT).
Amazon SNS	Pub/sub messaging service for fan-out notifications. Pushes messages to multiple subscribers (Lambda, SQS, email, HTTP) — common for alerting on model evaluation results or pipeline completions.
Amazon SQS	Fully managed message queue for decoupling and buffering. Provides durable, at-least-once delivery with dead-letter queues — use between S3 events and Lambda for backpressure-safe ingestion pipelines.
AWS Lambda	Serverless compute that runs code in response to events (API calls, S3 uploads, SQS messages). Executes Bedrock API calls, preprocessing, and action-group logic for Agents. 15-min max timeout.
AWS Step Functions	Visual workflow orchestrator for multi-step, long-running processes. Coordinates Lambda, Bedrock, and SageMaker calls with retries, error handling, branching, parallel execution, and circuit-breaker patterns.

25 Observability & Security

Service	What it does
Amazon CloudWatch	Metrics, alarms, and dashboards for all AWS services. Track Bedrock invocation counts, latency (TTFT), `ThrottlingException` rates, and token usage. Set alarms on anomalies.
Amazon CloudWatch Logs	Centralized log storage and querying. One of the two supported destinations for Bedrock Model Invocation Logging — captures request/response bodies and metadata for debugging and auditing.
AWS CloudTrail	Records control-plane API calls (e.g., `CreateKnowledgeBase`, `StartIngestionJob`). Provides governance and audit trail — does not capture data-plane inference payloads or document processing failures.
AWS IAM	Identity and access management for all AWS resources. Controls who/what can invoke Bedrock models, access Knowledge Bases, read S3 data, or execute Lambda functions via fine-grained policies.
AWS KMS	Managed encryption key service. Encrypts data at rest in S3 buckets, DynamoDB tables, OpenSearch indexes, and SageMaker volumes — essential for data protection compliance.
AWS PrivateLink	Private connectivity from your VPC to supported AWS services via interface VPC endpoints — keeps traffic off the public internet. Pair with endpoint policies and security groups.
AWS X-Ray	Distributed tracing across Lambda, API Gateway, and downstream services. Visualizes end-to-end request flow, identifies latency bottlenecks in GenAI pipelines.
Bedrock Model Invocation Logging	Logs full inference request/response payloads (prompts, completions, images, metadata) to Amazon S3 and/or CloudWatch Logs — the only two supported destinations. Essential for root-cause diagnostics, compliance, and quality analysis.

26 Codified Automation vs. Magic

Use this litmus test when an answer promises hands-off behavior: name the documented capability, the required configuration, and the boundary of what it automates.

🟢 Green flag: Supported capability + configuration + boundary of automation.

🔴 Red flag: Service infers business policy or guarantees outcomes without a defined feature.

27 Scenario Triggers: Green Flags vs. Red Flags

Map the constraint to a capability, then check fit, configuration, and tradeoffs. A red flag is a mismatch for the stated scenario, not a universal ban on a service.

Constraint / trigger	🟢 Green flags: fit the stated need	🔴 Red flags: mismatch or unsupported claim
Automated evaluation / prompt regressions	CI/CD runs prompt variants against a golden dataset and gates release on configured quality thresholds; Step Functions can orchestrate multi-step validation. Bedrock prompt optimization is explicitly invoked for a selected target model.	Assuming deployment silently rewrites prompts or blocks poor responses without an evaluation gate or configured Guardrails. Prompt optimization is not continuous, evaluation-driven auto-tuning by default.
Minimize operational overhead / private or changing facts	Use managed Bedrock models, Knowledge Bases, Agents, or Prompt Management when their supported features fit. A provider model invoked through Bedrock is still managed Bedrock inference; compare model cost and capability separately. RAG supplies changing/private facts; fine-tuning targets learned task behavior.	Adding custom containers, EC2 GPU clusters, EKS, or hosted endpoints without a control, model, throughput, or latency requirement that justifies them; fine-tuning solely to load changing facts.
Real-time web editor / streaming / low TTFT (least overhead)	API Gateway WebSocket API linked to AWS Lambda + Bedrock Streaming API (`InvokeModelWithResponseStream` or `ConverseStream`); use Bedrock Prompt Management to centrally maintain and version style-guide/system prompts with dynamic variables.	Custom containers on ECS/ALB (unnecessary operational overhead); asynchronous queues or state machines (SQS → Step Functions → DynamoDB) for interactive typing/editing; API Gateway REST API (buffers complete responses up to 10 MB and cannot stream tokens); HTTP short/long polling; direct browser gRPC without transcoding.
Event-driven ingestion / resilient S3 updates	For burst buffering, backpressure, and durable retry handling, route S3 create/delete notifications to SQS and use a Lambda SQS event source mapping to call `IngestKnowledgeBaseDocuments` or `DeleteKnowledgeBaseDocuments`. Configure a redrive policy and make processing idempotent.	Using a periodic schedule when changes must be reflected promptly; using direct S3-to-Lambda when the requirement specifically calls for a durable, customer-controlled backlog. Direct invocation is still viable for lower-latency, simpler flows and supports asynchronous retries/failure destinations.
Relational SQL / transactions / vector retrieval	Aurora PostgreSQL with pgvector when relational transactions and vector queries belong together; OpenSearch for vector/hybrid search; S3 Vectors for supported large-scale vector workloads; DocumentDB when document and vector-search semantics fit.	DynamoDB GSIs as a substitute for approximate-nearest-neighbor vector search; DocumentDB when relational SQL/ACID behavior is required; Redshift as an OLTP transaction store. Redshift may fit analytical vector workloads.
Prompt injection / safety / schema	Configure and apply Bedrock Guardrails for supported prompt-attack filters, denied topics, sensitive-information filtering, and contextual grounding. Use API Gateway request validation for request structure/schema; keep secrets out of prompts and use application controls for confidentiality.	Relying on a base model to enforce policy; treating request validation as semantic safety; using Comprehend sentiment/entity analysis or regex as the sole jailbreak defense; assuming Guardrails guarantee every response is safe.
Multiple models / prompt portability	Use Bedrock Converse for its consistent interface across supported message models; keep Prompt Management variants, variables, and versions for model/workflow-specific behavior.	Assuming identical prompt text yields equivalent behavior across models, or that XML/Markdown tags are interpreted uniformly; building a custom prompt-translation model or compiler without a requirement that justifies it.
Root-cause diagnostics / detailed analysis	Set `enableTrace: true` on Bedrock Agents `InvokeAgent` calls and inspect returned trace parts; use Guardrails trace data on supported inference paths; enable Model Invocation Logging to S3 or CloudWatch Logs for request/response bodies and metadata, subject to privacy controls.	Using aggregate invocation-count alarms alone to explain one request's behavior; treating an input/output content-source field as a full trace. Offline Model Evaluation helps compare quality; it does not replace request-level production tracing.
Private networking / data isolation	Use AWS PrivateLink interface VPC endpoints for supported private service access, with endpoint policies, security groups, and IAM as required by the boundary.	Using public endpoints or internet routing when private-only access is required; relying on an S3 bucket policy alone to secure network transit; treating multi-Region deployment as network isolation.
Bounded agent loops / stopping conditions	For custom loops, enforce max steps/timeouts and verify an explicit goal state in orchestration code; use managed-agent controls only as documented and configured.	Assuming an agent will always detect a runaway loop or stop exactly at a business-defined goal without an applicable limit or completion check.
Document preparation / LLM ingestion	Configure Knowledge Bases parsing/chunking, or build explicit preprocessing with Glue/Lambda. Use Bedrock Data Automation for supported extraction and structured outputs.	Assuming S3 passively cleans, semantically chunks, or reformats documents to fit any model context window.
Troubleshoot KB ingestion / failed documents	Configure Knowledge Base logging with Amazon CloudWatch Logs as destination; query via CloudWatch Logs Insights for document-level failure statuses (`RESOURCE_IGNORED`, `EMBEDDING_FAILED`, `INDEXING_FAILED`).	Using CloudTrail (only audits control-plane API calls like `StartIngestionJob`, blind to file processing failures); using Model Invocation Logging (monitors runtime inference payloads, not ingestion jobs); using Application Signals (APM latency/SLO tracking, not ingestion errors).
Analyze photos/video / summarize trends	Select a Bedrock model whose current model card supports the required media inputs. The model interprets media; Step Functions can coordinate multi-step calls/retries; store structured results in S3 and visualize them in QuickSight.	Assuming every multimodal model accepts video; treating Step Functions or QuickSight as the media analyzer; using an image-generation model for visual understanding or training custom labels when open-ended semantic extraction is the need.
Large payload (> 6 MB, e.g. 50 MB) / long processing (> 60s, e.g. 15 min) / on-demand GPU	Deploy a SageMaker Asynchronous Inference endpoint using accelerated computing (GPU) instances; handles large payloads up to 1 GB via S3, processing timeouts up to 1 hour, on-demand requests (`InvokeEndpointAsync`), and scales to 0 instances when idle.	Real-Time Inference (hard limits: 6 MB payload max, 60s timeout max); Serverless Inference (4 MB payload max, 60s timeout, CPU only / no GPU instance types); Batch Transform (offline batch job that provisions and tears down clusters, not an on-demand interactive endpoint).
Migrating On-Demand Bedrock → Provisioned Throughput / observability continuity	Establish parallel monitoring for both invocation modes during the transition period. Maintain simultaneous telemetry for on-demand model IDs and provisioned model ARNs to compare p95/p99 latency (TTFT), token throughput, and `InvocationUtilization`; use canary/weighted routing for gradual traffic cutover. Decommission on-demand metrics only after a documented stability period.	Decommissioning on-demand metrics immediately upon provisioning (destroys baseline comparison); dropping performance dashboards to track only cost metrics (cost and performance are complementary, never zero-sum); relying on service-quota dashboards instead of invocation-level CloudWatch telemetry; assuming provisioned throughput eliminates the need for `ThrottlingException` (429) alarms.

Decision rule: verify capability + configuration + workload fit. Treat “automatically,” “natively,” and “for every model” as claims to check, not automatic disqualifiers.

28 The Intuitive Elimination Framework

Engineering judgment gets you to the final two; AWS feature knowledge selects the winner. Common sense is a powerful filter, not a substitute for knowing documented service capabilities, limits, and configuration boundaries. (No internet or AI tools are available during the exam — trust the mental model you built.)

Core Principle The exam tests what NOT to do as much as what to do. Eliminate designs that a senior engineer would reject in production: dropping observability, removing rollback paths during a migration, skipping validation, or adding unjustified infrastructure. Then prove that the surviving option is a real AWS capability that satisfies every stated requirement.

The 4-Pass Decision Protocol

Pass 1 — Constraint Anchor: Read the LAST sentence first. Identify the binding driver: least operational overhead / lowest cost / strict latency / zero downtime.
Pass 2 — Requirement Coverage: Mark every non-negotiable, including qualifiers such as continuously, in production, without disruption, or across accounts.
Pass 3 — Red-Flag Purge: Reject anti-patterns, unsupported magic, unjustified infrastructure, and options that solve only part of the scenario. Keep plausible options provisional; do not lock out a candidate merely because wording is strong.
Pass 4 — Proof of Fit: Name the exact AWS feature, configuration, input/event source, and tradeoff that make the answer work. If you cannot explain the mechanism in one sentence, it is not proven.

Requirement Matrix

For each surviving option, silently score every mandatory requirement: ✓ directly met / ~ partly met or needs unstated work / ✗ conflicts. Select an answer only when all mandatory requirements are ✓. A technically valid design loses if it omits a qualifier or requires an unstated component.

Distractor Signatures

Premature teardown: Removing legacy metrics, logs, or rollback paths during migration. Preserve parallel coverage until the replacement proves stable.
False dichotomy: Replacing granular application telemetry with only quotas or summaries. Observability layers are usually complementary.
Fictional magic wand: A service “automatically” infers policy, rewrites prompts, or tunes behavior without documented configuration, rules, thresholds, or evaluation data.
Scope creep: Adding EKS, containers, GPUs, or bespoke orchestration without a stated control, throughput, latency, or runtime requirement that justifies it.
Partial solution: Solving cost but not latency, security but not auditability, or monitoring but not document-level troubleshooting.

29 Single-Select vs. Multi-Select Strategy

4-Choice Questions (Single-Select)

One option must satisfy the full requirement end-to-end. If two answers remain plausible, compare them against the Requirement Matrix and perform the Proof-of-Fit check. The winner is the one whose documented primary purpose matches the binding constraint with the fewest unstated dependencies.

5-Choice Questions (Pick Two)

The Independent-Truth Rule Test each choice independently. Select two only when each adds a required, non-duplicative control or capability and neither conflicts with the scenario. Correct answers often address different layers, but they can operate at the same layer when they provide defense in depth or different evidence/control functions.

Complementary Pattern	Example
Ingress + Egress	Input validation + Output guardrails
Provisioning + Telemetry	Infrastructure config + Monitoring verification
Security in depth	KMS encryption + IAM least privilege
Observability in depth	CloudWatch metrics + X-Ray traces
Caching layers	Prompt prefix cache + Semantic response cache

Named-Feature Rule

When a question asks which Bedrock, AgentCore, SageMaker, Guardrails, or CloudWatch feature provides a behavior, expect a named managed capability. Do not substitute a reasonable DIY architecture unless the managed feature cannot meet the requirement. Learn lifecycle distinctions: online vs. on-demand evaluation; knowledge-base ingestion logs vs. model invocation logs vs. CloudTrail; Prompt Management vs. prompt caching vs. response caching.

30 Absolute-Language Verification

Words such as always, never, immediately, solely, and automatically are prompts to verify a service boundary — not instant disqualifiers.

Eliminate the option when the claim conflicts with the requirements or documented behavior.
Keep it when a stated security, compliance, reliability, or availability requirement justifies the strong language and AWS supports the capability.
Without configuration is suspect unless the service explicitly performs that behavior by default.
Automatically detects / infers / decides requires a documented classifier, evaluator, threshold, rule, or managed feature.

Final rule: Common sense eliminates bad architecture; AWS service knowledge chooses the supported one. Preserve baselines during migrations, use canary or parallel telemetry when appropriate, and verify capability + configuration + workload fit before committing.