The whole GenAI track, sorted into the five scored domains. Each domain leads with the cheat sheet that anchors it, then the decisions to work through, the flash cards to drill, and the labs to build with your own hands. The domains overlap in real systems, so a few posts could sit under two headings; they are filed under the one they teach best.
How to use this
Read each domain heading and its scope line first, then run down the list. The order within each domain is deliberate: every list starts at the deciding-level idea and works toward its refinements, so the post above you is always the one the post below leans on. Top to bottom is the intended path. A line you can explain out loud, tick. A line that makes you hesitate is the next hour of revision. The flash cards are the fastest way to close a gap; the labs are the slowest and the ones that actually stick.
The five scored domains and their weight:
| Domain | Weight |
|---|---|
| 1. Foundation Model Integration, Data Management, and Compliance | 31% |
| 2. Implementation and Integration | 26% |
| 3. AI Safety, Security, and Governance | 20% |
| 4. Operational Efficiency and Optimization | 12% |
| 5. Testing, Validation, and Troubleshooting | 11% |
Before the first lab, do the one-time, once-per-account setup: run preflight.sh (it ships in every lab zip) to confirm your account is ready, then deploy the lab reaper once. The reaper is a standing backstop that auto-deletes any lab you forget to tear down after 24 hours, so a forgotten stack becomes a deleted stack instead of a running bill.
All in, the track is about 58 h 12 min of reading and roughly 11 h 30 min of hands-on lab work (lab times are active time; long-running jobs run on their own clock).
Weight is where the marks are, not where the difficulty is. Domain 1 is a third of the score on its own; give it a third of the time.
Domain 1 — Foundation Model Integration, Data Management, and Compliance (31%)
About 23 h 25 min of reading and 5 h 30 min of hands-on lab time.
Picking the right foundation model, feeding it the right data, and grounding it in your own documents. The biggest domain by a wide margin, and the one where retrieval lives.
Anchor cheat sheets: Model Selection and Inference · RAG and Vector Stores · Model Customization · 33 min
Pick the model and the surface
About 4 h 45 min of reading.
- Decide whether GenAI is even the right tool for a problem, or whether a cheaper, deterministic approach wins.
- Choose a Bedrock model by matching capability, context window, latency, and cost to the workload, not by brand.
- Pick an inference surface (on-demand, provisioned throughput, batch) from the traffic shape.
-
Say when a purpose-built AI service or a managed app like Amazon Quick beats building on a foundation model, and when an open-weight model or SageMaker JumpStart is the better host.
- ☐ Deciding Whether to Use GenAI at All · 31 min
- ☐ Choosing a Model From the Bedrock Catalogue · 38 min
- ☐ Choosing an Inference Option for a GenAI Workload · 29 min
- ☐ Picking a Bedrock Model for High-Volume RAG · 28 min
- ☐ Choosing a Model for Code Generation · 27 min
- ☐ Open-Weight or Proprietary: Choosing How You Host a Model · 30 min
- ☐ SageMaker JumpStart or Bedrock for the Same Model · 23 min
- ☐ When a Purpose-Built AI Service Beats a Foundation Model · 29 min
- ☐ Buy or Build: Amazon Quick Versus a Custom RAG App · 28 min
- ☐ Choosing Between Kiro, Amazon Quick, and Bedrock · 22 min
Multimodal
About 2 h 11 min of reading.
- Pick the right Bedrock model for generating and for understanding images, audio, and video.
- Build cross-modal search with multimodal embeddings (a text query over images, and the reverse).
-
Wire a voice pipeline end to end: Transcribe in, Bedrock to reason, Polly out.
- ☐ Generating and Understanding Images, Audio, and Video on Bedrock · 41 min
- ☐ Searching Images and Text With Multimodal Embeddings · 28 min
- ☐ Building a Voice Assistant: Transcribe, Bedrock, and Polly · 36 min
- ☐ How to Build a Multi-Modal Bedrock Assistant for Insurance Claims · 26 min
Retrieval, embeddings, and knowledge bases
About 10 h 38 min of reading.
- Design a retrieval pipeline end to end: embedding model, distance metric matched to that model, vector store, index type, chunking, and top-K.
- Choose a vector store (OpenSearch, Aurora pgvector, S3 Vectors, a Bedrock Knowledge Base) from scale, latency, and cost, and name each one’s cost or latency floor.
- Know that Amazon Kendra is in maintenance mode and closed to new customers, and that a Bedrock managed knowledge base is the replacement.
- Enforce document-level ACLs with
userContexton retrieval, know it is optional and so fails open, and know Web Crawler is the connector it does not cover. - Use metadata filtering for freshness and multi-tenant access, and keep a knowledge base fresh without re-embedding everything.
- Reach for hybrid search and reranking when dense retrieval misses exact tokens, and parent-document retrieval when small chunks lose their context.
-
Route to text-to-SQL or structured extraction when the answer lives in a table rather than in prose.
- ☐ Picking a Vector Store for Bedrock RAG · 24 min
- ☐ Which AWS Store Can Do Vector Search · 26 min
- ☐ Choosing a Vector Index: HNSW, IVF, and the Trade-Offs · 33 min
- ☐ Picking an Embedding Model for Retrieval · 23 min
- ☐ Choosing an Embedding Model for a Multilingual Corpus · 28 min
- ☐ Choosing an Embedding Dimension and Its Storage Cost · 27 min
- ☐ Choosing a Distance Metric for Embeddings · 26 min
- ☐ Dense, Sparse, or Hybrid Retrieval · 27 min
- ☐ Hybrid Search and Reranking for Bedrock RAG · 24 min
- ☐ Parent-Document Retrieval: Small Chunks, Big Context · 29 min
- ☐ How Many Chunks to Retrieve: Tuning Top-K · 29 min
- ☐ Metadata Filtering for Multi-Tenant Retrieval · 29 min
- ☐ Choosing a Chunking Strategy for Bedrock Knowledge Bases · 27 min
- ☐ Chunking Code, Tables, and Mixed Content · 29 min
- ☐ When a Document Won’t Fit the Context Window · 22 min
- ☐ Getting Documents Into a Bedrock Knowledge Base · 29 min
- ☐ Keeping a Knowledge Base Fresh Without Re-Embedding Everything · 32 min
- ☐ Building RAG When the Source Documents Change Daily · 25 min
- ☐ How to Build a Citations-Required RAG Over 50K Internal Documents · 29 min
- ☐ Grounding on Fresh Data: Tools or RAG · 29 min
- ☐ Agentic RAG: When Retrieval Needs to Reason · 30 min
- ☐ Extracting Structured Data From Documents at Scale · 31 min
- ☐ Retrieval Over Structured Data With Text-to-SQL · 30 min
Customise the model
About 2 h 34 min of reading.
- Choose between fine-tuning, continued pre-training, and distillation for a stated goal.
- Say when customisation beats retrieval and when it does not, and when the two belong together.
- Prepare and size a fine-tuning dataset, and read a training-versus-validation loss curve to spot overfitting or an under-trained run.
-
Import custom weights into Bedrock and know what serving them then requires (provisioned throughput).
- ☐ Fine-Tuning, Continued Pre-Training, or Distillation · 31 min
- ☐ Combining RAG and Fine-Tuning for a Legal Contract Assistant · 33 min
- ☐ Preparing a Dataset for Fine-Tuning · 30 min
- ☐ Tuning Fine-Tuning: Epochs, Learning Rate, and Batch Size · 35 min
- ☐ Importing Custom Weights into Bedrock · 25 min
Data management and compliance
About 28 min of reading.
-
Pick the right AWS tool to profile, validate, and govern the data feeding a GenAI system, and say what each one catches.
-
☐ Picking the Right Tool to Check and Govern GenAI Data · 28 min
Drill the flash cards
About 24 min of reading.
- ☐ Hierarchical Chunking in One Line · 3 min
- ☐ Freshness and Access Are Metadata · 3 min
- ☐ What a Reranker Actually Fixes · 3 min
- ☐ Why Hybrid Search Finds ERR-4021 · 3 min
- ☐ The Silent Distance-Metric Bug · 3 min
- ☐ When Aurora pgvector Wins · 3 min
- ☐ OpenSearch Serverless’s Hidden Floor · 3 min
- ☐ S3 Vectors and the Latency Budget · 3 min
Build it
About 1 h 24 min of reading and 5 h 30 min of hands-on lab time.
Ready when you can pick a model and inference option for a stated workload, design a retrieval pipeline end to end (embedding model, distance metric, vector store, chunking, top-K, metadata), and say when fine-tuning beats retrieval and when it does not.
- ☐ Lab 05: Build RAG From Scratch · 8 min read + ~1 h hands-on
- ☐ Lab 11: Stand Up a Bedrock Knowledge Base · 18 min read + ~1 h hands-on
- ☐ Lab 07: Build a Data-Quality Gate · 8 min read + ~45 min hands-on
- ☐ Lab 08: Answer a Metric Question With Text-to-SQL · 9 min read + ~1 h hands-on
- ☐ Lab 12: Fine-Tune a Model and Read the Loss Curves · 20 min read + ~1 h hands-on
- ☐ Lab 13: Generate the Weekly Box Art · 21 min read + ~45 min hands-on
Domain 2 — Implementation and Integration (26%)
About 10 h 39 min of reading and 3 h of hands-on lab time.
Turning a model into an application: prompts, tools, agents, memory, and how responses reach the caller.
Anchor cheat sheets: Prompt Engineering · Agents and Orchestration · 20 min
Prompts and sampling
About 2 h 55 min of reading.
- Apply the prompt techniques that actually change output quality (structure, few-shot, role, and where step-by-step reasoning helps).
- Write a production system prompt, and treat prompts as versioned, rollback-able assets through Bedrock Prompt Management.
-
Set temperature, top-P, and top-K deliberately for the task, from deterministic extraction to open-ended generation.
- ☐ Prompt Engineering Techniques That Move the Needle · 31 min
- ☐ Writing a System Prompt for a Production Assistant · 31 min
- ☐ Managing Prompts With Bedrock Prompt Management · 28 min
- ☐ How to Manage Prompts Across Thirty Services on Bedrock · 27 min
- ☐ Versioning and Rolling Back Prompts and Models · 31 min
- ☐ Tuning How a Model Samples: Temperature, Top-P, and Top-K · 27 min
Tools, agents, and orchestration
About 3 h 23 min of reading.
- Wire function calling and a Bedrock Agent action group, and design tool schemas that are safe to expose to a model.
- Choose between a Bedrock Agent, Step Functions, and a Bedrock Flow for a given job, trading autonomy against determinism.
-
Say what AgentCore adds for running agents in production, and how to coordinate more than one agent.
- ☐ How to Wire Function Calling Through Bedrock · 22 min
- ☐ How to Wire an LLM to Side-Effecting Actions with Bedrock Agents · 23 min
- ☐ Designing Safe Tool Schemas for an Agent Action Group · 34 min
- ☐ Orchestrating Multiple Bedrock Agents · 32 min
- ☐ Running Agents in Production With Bedrock AgentCore · 31 min
- ☐ When to Orchestrate With Step Functions Instead of an Agent · 31 min
- ☐ Building Deterministic Pipelines With Bedrock Flows · 30 min
Memory and conversation state
About 1 h 33 min of reading.
- Design short-term and long-term memory for a chat assistant, and say what each is for.
- Choose where conversation state lives from the access pattern and retention need.
-
Keep a long conversation inside the context window by summarising older turns.
- ☐ Designing Short-Term and Long-Term Memory for a Bedrock Chat Assistant · 28 min
- ☐ Choosing Where to Store Conversation State · 34 min
- ☐ Summarising Long Conversations to Fit the Context Window · 31 min
Delivery and interaction
About 1 h 36 min of reading.
- Choose sync, async, or streaming delivery from the latency budget and the payload shape.
- Build an event-driven pipeline that processes documents asynchronously.
-
Handle an ambiguous question by asking for clarification instead of guessing.
- ☐ Delivering Responses: Sync, Async, or Streaming · 27 min
- ☐ Event-Driven GenAI: Processing Documents Asynchronously · 34 min
- ☐ Handling Ambiguous Questions With Clarification · 35 min
Drill the flash cards
About 9 min of reading.
- ☐ Letting an LLM Take Actions · 3 min
- ☐ Turning Down the Randomness · 3 min
- ☐ Prompts Are Versioned Assets · 3 min
Build it
About 43 min of reading and 3 h of hands-on lab time.
Ready when you can wire a tool an agent can call safely, choose between an agent, Step Functions, and a Flow for a given job, and pick where conversation state lives.
- ☐ Lab 01: Invoke a Foundation Model From Lambda · 13 min read + ~30 min hands-on
- ☐ Lab 06: Wire a Tool the Model Can Call · 9 min read + ~1 h hands-on
- ☐ Lab 03: Get Structured JSON Out With Tool Use · 11 min read + ~45 min hands-on
- ☐ Lab 04: Give a Bedrock Chatbot a Memory · 10 min read + ~45 min hands-on
Domain 3 — AI Safety, Security, and Governance (20%)
About 9 h of reading and 30 min of hands-on lab time.
Keeping the app safe to run: guardrails, injection and exfiltration defence, identity and encryption, responsible-AI evidence, and the audit trail.
Anchor cheat sheet: Security and Responsible AI · 15 min
Guardrails and moderation
About 1 h 30 min of reading.
- Configure a Bedrock Guardrail for PII, denied topics, and contextual grounding.
- Choose a guardrail strategy (managed, custom, or both) for a stated requirement.
-
Pick the right moderation service for the content type: Rekognition for images, Comprehend for text, Guardrails at the model boundary.
- ☐ Configuring Bedrock Guardrails for PII, Topics, and Grounding · 29 min
- ☐ Choosing a Guardrail Strategy: Managed, Custom, or Both · 31 min
- ☐ Content Moderation With Rekognition, Comprehend, and Guardrails · 30 min
Attacks and data protection
About 2 h 32 min of reading.
- Defend against both direct prompt injection and the indirect kind that arrives through retrieved documents.
- Prevent data exfiltration through the model, and keep PII out of prompts and logs.
-
Red-team a Bedrock app to find these weaknesses before an attacker does.
- ☐ Defending a Bedrock App Against Prompt Injection · 30 min
- ☐ Defending Against Indirect Prompt Injection in RAG · 33 min
- ☐ Preventing Data Exfiltration Through an LLM · 35 min
- ☐ Red-Teaming a Bedrock Application · 30 min
- ☐ Keeping PII Out of LLM Prompts and Logs · 24 min
Identity, network, and encryption
About 1 h 02 min of reading.
- Secure a Bedrock app with least-privilege IAM and PrivateLink, so nothing reaches the model over the public internet.
-
Encrypt every data surface end to end with KMS, using customer-managed keys where the requirement calls for them.
- ☐ Securing a Bedrock App: IAM, PrivateLink, and Keys · 30 min
- ☐ Encrypting a Bedrock App End to End With KMS · 32 min
Responsible AI and governance
About 3 h 06 min of reading.
- Say which service produces which evidence: Clarify for bias, model cards for explainability, Audit Manager and invocation logging for the audit trail.
- Make a Bedrock app audit-ready, and govern model access across many teams.
-
Prove where AI content came from, and design where a human belongs in the pipeline and how the bot escalates to one.
- ☐ Checking a Bedrock Feature for Bias and Explainability · 24 min
- ☐ Making a Bedrock App Audit-Ready · 25 min
- ☐ Governing Model Access Across Many Teams · 35 min
- ☐ Proving Where AI Content Came From · 39 min
- ☐ Where Humans Belong in a GenAI Pipeline · 28 min
- ☐ Designing a Bot-to-Human Escalation Path · 35 min
Drill the flash cards
About 24 min of reading.
- ☐ Keeping PII Out of Prompts and Logs · 3 min
- ☐ What Guardrails Enforce · 2 min
- ☐ The Eight Responsible-AI Dimensions · 4 min
- ☐ Measuring Bias With Clarify · 3 min
- ☐ LLM Explainability Is Traceability · 3 min
- ☐ The Prompt-and-Completion Record · 3 min
- ☐ Who Changed It vs What It Said · 3 min
- ☐ Turning Logs Into an Audit · 3 min
Build it
About 11 min of reading and 30 min of hands-on lab time.
Ready when you can name where access control belongs (retrieval and tools, not the prompt), attach a versioned guardrail, encrypt every data surface with KMS, and say which service produces bias or audit evidence.
- ☐ Lab 02: Put a Guardrail in Front of a Bedrock Model · 11 min read + ~30 min hands-on
Domain 4 — Operational Efficiency and Optimization (12%)
About 9 h 51 min of reading.
Running it affordably and reliably: cost levers, caching, throughput, latency, resilience, and observability.
Anchor cheat sheet: Evaluation, Cost, and Operations · 13 min
Cost and caching
About 4 h 44 min of reading.
- Reach for the right cost lever for a given spend shape: caching, batching, request routing, model choice, or provisioned throughput.
- Tell prompt caching from response caching, and cache responses without serving stale answers.
- Attribute and cap spend with tagging, budgets, and quotas.
-
Route between a cheap and a capable model instead of paying top-tier rates for every request.
- ☐ How to Cut a Bedrock Bill Without Hurting Quality · 25 min
- ☐ Cutting Cost per Query in a RAG System · 37 min
- ☐ Cutting Ingestion Cost by Caching and Batching Embeddings · 37 min
- ☐ Cost Attribution and Tagging for GenAI Workloads · 33 min
- ☐ Cost Guardrails: Budgets, Quotas, and Model Choice · 35 min
- ☐ Budgeting Tokens for a Long-Document Workload · 33 min
- ☐ Routing Requests Between a Cheap and a Capable Model · 31 min
- ☐ Prompt Caching Versus Response Caching on Bedrock · 31 min
- ☐ Caching LLM Responses Without Stale Answers · 22 min
Throughput, latency, and resilience
About 3 h 41 min of reading.
- Choose provisioned throughput versus on-demand, and right-size the model units for a custom model.
- Cut end-to-end latency, and first-token latency with streaming, without hurting quality.
-
Build resilience: cross-region inference profiles, multi-region failover, graceful throttling, and a plan for a model deprecation.
- ☐ How to Match Bedrock Pricing to Workload Rhythm · 26 min
- ☐ Right-Sizing Provisioned Throughput for a Custom Model · 26 min
- ☐ Reducing End-to-End Latency in a GenAI App · 32 min
- ☐ Streaming Responses to Cut First-Token Latency · 23 min
- ☐ Multi-Region Resilience for a GenAI Service · 30 min
- ☐ Spreading Bedrock Load with Cross-Region Inference Profiles · 27 min
- ☐ Handling Throttling and Rate Limits Gracefully · 27 min
- ☐ Surviving a Model Deprecation on Bedrock · 30 min
Observability
About 1 h 04 min of reading.
- Say what to watch in CloudWatch for a production Bedrock app, and which metrics warn you first.
-
Trace an agent’s decisions to see why it did what it did, not just what it returned.
- ☐ Monitoring a Production Bedrock App · 31 min
- ☐ Tracing an Agent’s Decisions in Production · 33 min
Drill the flash cards
About 9 min of reading.
Ready when you can reach for the right cost lever for a given spend shape (caching, batching, routing, provisioned throughput), keep latency down without hurting quality, and say what to watch in CloudWatch and an agent trace.
- ☐ Cutting the Bill Without Losing Quality · 3 min
- ☐ Provisioned Throughput vs On-Demand · 3 min
- ☐ Seeing Into a Production Bedrock App · 3 min
Domain 5 — Testing, Validation, and Troubleshooting (11%)
About 5 h 45 min of reading and 2 h 30 min of hands-on lab time.
Proving it works and finding out why it does not: evaluation, judging, hallucination measurement, A/B testing, and reproducibility.
Anchor cheat sheet: Evaluation, Cost, and Operations (the evaluation half) · 13 min
Evaluate and troubleshoot
About 4 h 27 min of reading.
- Build a golden dataset, and score retrieval and generation separately rather than as one number.
- Design an LLM-as-a-judge rubric you can trust, and tell faithfulness from correctness.
- Measure hallucination, and trace a wrong answer back to the stage that caused it (retrieval or generation).
-
A/B test prompts and models in production, and make a given output reproducible.
- ☐ Evaluating LLM Output With Bedrock Eval Jobs · 22 min
- ☐ Evaluating a RAG Pipeline End to End · 26 min
- ☐ Building a Golden Dataset for LLM Evaluation · 28 min
- ☐ LLM-as-a-Judge: Designing a Rubric You Can Trust · 29 min
- ☐ Measuring Hallucination in a RAG System · 32 min
- ☐ Why Your RAG Returns the Wrong Chunk · 36 min
- ☐ A/B Testing Prompts and Models in Production · 32 min
- ☐ Building a Feedback Loop From Users to Model Improvement · 32 min
- ☐ Making an LLM Output Reproducible · 30 min
Drill the flash cards
About 9 min of reading.
- ☐ Evaluating Both Halves of RAG · 3 min
- ☐ Faithful but Wrong · 3 min
- ☐ LLM-as-a-Judge, and the Catch · 3 min
Build it
About 56 min of reading and 2 h 30 min of hands-on lab time.
Ready when you can build a golden set, score retrieval and generation separately, tell faithfulness from correctness, and trace a wrong answer back to the stage that caused it.
- ☐ Lab 09: Evaluate the Pipeline · 10 min read + ~1 h hands-on
Tie it together
Two things pull all five domains into one picture. Read the first, do the second.
- ☐ Taking a GenAI Feature From Proof of Concept to Production maps the gap between a demo and a shipped feature across evaluation, safety, security, reliability, cost, observability, governance, and operations. It is the whole checklist in prose. · 39 min
- ☐ Lab 10: The Capstone builds one feature end to end and exercises every domain at once. If you can finish it without notes, you are ready. · 7 min read + ~1 h 30 min hands-on
Good luck. 🍀