Overview
Domain 1 is the architectural core of the AWS Certified Generative AI Developer - Professional exam, and it has six task statements. You analyze requirements and design GenAI solutions, select and configure foundation models (FMs), and build data validation and processing pipelines that feed them. Two task statements cover retrieval-augmented generation in depth: designing vector stores and designing the retrieval mechanisms that sit on top of them, from chunking and embeddings to hybrid search, reranking and query expansion. The last task covers prompt engineering and prompt governance with Amazon Bedrock Prompt Management and Prompt Flows.
AIP-C01 is now generally available. The beta ran through March 31, 2026, and the current published format is 75 questions in 180 minutes with a scaled passing score of 750. At 31%, this domain alone is close to a third of the scored items, so it deserves the largest share of your preparation.
How it's tested
Domain 1 questions are long scenarios that state a business goal, data sources and constraints such as latency, cost, Region or compliance. You then choose the architecture, model, vector store, chunking strategy or prompt control that meets every stated constraint, not just the headline requirement.
-
Customize or augment
A model lacks company knowledge or style, and you decide between retrieval augmentation, prompt changes and fine-tuning, weighing freshness, cost and effort.
-
Pick the vector store
Existing data platforms and scale are described, and you choose Bedrock Knowledge Bases, OpenSearch Service, Aurora pgvector or another store.
-
Fix retrieval quality
Answers miss relevant facts, and you identify the chunking, embedding, metadata, hybrid search or reranking change that addresses the root cause.
A support assistant must answer from product manuals that change weekly, and the team wants minimal custom code. Fine-tuning would bake in content that goes stale within days and needs retraining for every revision. An Amazon Bedrock knowledge base over the S3 manual bucket with scheduled ingestion keeps answers current and cites sources. The weekly change rate is the clue that points to retrieval instead of customization.
Task statements 6
Official task statements from the Amazon Web Services outline, in outline order.
1.1 Analyze requirements and design GenAI solutionsArchitecture design, proof of concept and standardized components.
- What it means
- This task covers turning business needs and technical constraints into a GenAI architecture: choosing FMs, integration patterns and deployment strategies, validating feasibility with a proof of concept on Amazon Bedrock, and standardizing components using the AWS Well-Architected Framework and its Generative AI Lens.
- What to understand
- A proof of concept on Bedrock lets a team measure quality, latency and cost before committing to a full build. Standardized components such as shared prompt templates, gateway patterns and reference architectures keep many teams consistent. The Well-Architected Generative AI Lens applies the six pillars to GenAI workloads, so expect it as the answer when a question asks for a structured design review.
- How it shows up
- A requirement list is given, and you choose the design approach or review framework that meets it with the least risk.
- Common confusion
- Treating a proof of concept as production; it validates feasibility and value, then needs hardening before rollout.
1.2 Select and configure FMsModel selection, provider switching, resilience and customization lifecycle.
- What it means
- This task covers assessing FMs with benchmarks and capability analysis, building architectures that switch models without code changes (Lambda, API Gateway, AWS AppConfig), designing resilience with circuit breakers and Bedrock cross-Region inference, and managing customized models with SageMaker AI, LoRA adapters and SageMaker Model Registry.
- What to understand
- Externalizing the model ID in AppConfig or a gateway lets teams swap providers without redeploying code. Cross-Region inference profiles route requests to other Regions when capacity is short or a model is not offered locally. Fine-tuned models need versioning, automated deployment, rollback and retirement plans, just like application code. Parameter-efficient techniques such as LoRA reduce the cost of customization.
- How it shows up
- A model choice, outage risk or model update process is described, and you select the configuration or lifecycle control that fits.
- Common confusion
- Hard-coding a model ID; the exam favors configuration-driven model selection that changes without a code release.
1.3 Implement data validation and processing pipelines for FM consumptionData quality checks, multimodal processing and input formatting.
- What it means
- This task covers validating data quality before it reaches an FM (AWS Glue Data Quality, SageMaker Data Wrangler, Lambda, CloudWatch metrics), processing text, image, audio and tabular data, formatting requests to each model's schema, and improving input quality with entity extraction and normalization.
- What to understand
- Bad input produces bad output, so pipelines check completeness and format first. Audio usually goes through Amazon Transcribe before an LLM sees it, and multimodal Bedrock models accept images directly. Each model family expects its own request body, and the Converse API standardizes chat-style messages. Amazon Comprehend can extract entities that enrich or clean the prompt.
- How it shows up
- A data source with quality or format problems is described, and you choose the validation or transformation step.
- Common confusion
- Sending raw transcripts or unvalidated records straight to the model instead of cleaning and structuring them first.
1.4 Design and implement vector store solutionsVector database architecture, metadata, scale, connectors and freshness.
- What it means
- This task covers designing vector stores for FM augmentation with Bedrock Knowledge Bases, OpenSearch Service with the Neural plugin, Amazon RDS with S3 document repositories and DynamoDB for metadata, building metadata frameworks, scaling with sharding and multi-index designs, connecting to wikis and document systems, and keeping content current.
- What to understand
- Metadata such as timestamps, authors and domain tags enables filtering that pure similarity search cannot do. Large corpora call for sharding and separate indexes per domain. Data source connectors bring in content from S3, Confluence, SharePoint and similar systems. Incremental sync and change detection keep vectors aligned with source documents without full re-ingestion.
- How it shows up
- A corpus size, source system or freshness requirement is described, and you pick the store design or maintenance approach.
- Common confusion
- Assuming one large index is always best; separate indexes or metadata filters often improve precision for distinct domains.
1.5 Design retrieval mechanisms for FM augmentationChunking, embeddings, vector search, hybrid search, query handling and access.
- What it means
- This task covers the retrieval layer of RAG: chunking documents (fixed-size, hierarchical, semantic), choosing embedding models such as Amazon Titan by dimension and domain fit, deploying vector search in OpenSearch Service, Aurora pgvector or Bedrock Knowledge Bases, hybrid search with reranker models, query expansion and decomposition, and exposing retrieval through function calling or MCP.
- What to understand
- Chunk size trades context completeness against precision. Hierarchical chunking returns a larger parent chunk when a small child matches. Higher embedding dimensions capture more nuance but cost more storage and latency. Hybrid search combines keyword and vector scores, which helps with product codes and exact terms. Rerankers reorder candidates so the best passages reach the prompt.
- How it shows up
- Retrieval results are poor or slow, and you choose the chunking, embedding, search or query technique that fixes it.
- Common confusion
- Changing the FM when the real problem is retrieval; poor context in means poor answers out, whatever the model.
1.6 Implement prompt engineering strategies and governance for FM interactionsInstruction frameworks, conversation context, prompt governance and complex prompt flows.
- What it means
- This task covers controlling FM behavior with system roles and templates in Bedrock Prompt Management, enforcing guidelines with Bedrock Guardrails, keeping conversation history in DynamoDB, governing prompts with versioned, parameterized templates and approval workflows, testing prompts for regression, refining them with chain-of-thought and output specifications, and chaining prompts with Prompt Flows.
- What to understand
- Prompt Management stores versioned templates with variables so teams reuse approved prompts. CloudTrail records who changed or used them. Regression tests catch quality drops when a prompt or model version changes. Prompt Flows (now Amazon Bedrock Flows) link prompts, conditions and Lambda steps into a sequence. Conversation memory is application state you store, not something the model keeps.
- How it shows up
- Inconsistent or ungoverned prompts are described, and you choose the management, testing or chaining feature that fixes it.
- Common confusion
- Expecting the FM to remember earlier turns on its own; the application must store and resend conversation history.
High-yield concepts
The terms, rules and formulas this domain turns into questions most often.
-
Retrieval-augmented generation (RAG)
Retrieving relevant documents at request time and adding them to the prompt.
- Remember
- Best for changing or proprietary knowledge.
- Tested as
- The default answer when facts must stay current.
- Trap
- Choosing fine-tuning to add frequently changing facts.
-
Amazon Bedrock Knowledge Bases
Managed RAG: ingestion, chunking, embeddings, vector storage and retrieval.
- Remember
- Supports several vector stores and source connectors.
- Tested as
- Least-custom-code retrieval questions.
- Trap
- Building a custom pipeline when the managed one meets requirements.
-
Cross-Region inference
Inference profiles that route Bedrock requests across Regions for capacity and availability.
- Remember
- Helps when a model has limited Regional availability.
- Tested as
- Resilience and capacity scenarios.
- Trap
- Ignoring data residency rules when routing across Regions.
-
AWS AppConfig for model selection
Externalized configuration that switches model IDs or parameters at runtime.
- Remember
- Changes take effect without redeploying code.
- Tested as
- Provider-switching questions.
- Trap
- Hard-coding model IDs in Lambda functions.
-
LoRA and adapters
Parameter-efficient fine-tuning that trains small adapter weights instead of the full model.
- Remember
- Cheaper and faster than full fine-tuning.
- Tested as
- Customization lifecycle questions.
- Trap
- Assuming any customization requires full retraining.
-
Hierarchical chunking
Small child chunks for matching, larger parent chunks returned for context.
- Remember
- Balances precision with context completeness.
- Tested as
- Chunking strategy questions.
- Trap
- Using tiny fixed chunks that strip needed context.
-
Embedding dimensionality
The vector length an embedding model produces.
- Remember
- Higher dimensions add nuance but raise storage and latency.
- Tested as
- Embedding selection questions.
- Trap
- Assuming larger vectors are always better.
-
Hybrid search and reranking
Combining keyword and vector scores, then reordering results with a reranker model.
- Remember
- Helps exact terms such as part numbers and IDs.
- Tested as
- Retrieval relevance questions.
- Trap
- Relying on pure semantic search for codes and names.
-
Metadata filtering
Restricting retrieval by attributes such as date, department or document type.
- Remember
- Improves precision and supports access scoping.
- Tested as
- Vector store design questions.
- Trap
- Expecting similarity alone to separate domains.
-
Aurora PostgreSQL with pgvector
Vector search inside a relational database the team already runs.
- Remember
- Good fit when data and skills are already in PostgreSQL.
- Tested as
- Vector store selection questions.
- Trap
- Adding a new search cluster when Aurora already holds the data.
-
Bedrock Prompt Management
Versioned, parameterized prompt templates with variants.
- Remember
- Supports reuse, comparison and governance.
- Tested as
- Prompt governance questions.
- Trap
- Storing prompts as untracked strings in code.
-
Bedrock Flows (Prompt Flows)
Visual chains of prompts, conditions and functions.
- Remember
- Handles sequential prompt chains and branching.
- Tested as
- Complex prompt system questions.
- Trap
- Writing custom orchestration for a simple prompt chain.
Side by side
Concepts candidates mix up, compared on the point that decides the answer.
RAG vs. fine-tuning vs. prompt engineering
| Concept | Meaning | Key difference | Common trap |
|---|---|---|---|
| Prompt engineering | Change instructions, examples and format | Fastest and cheapest, no new knowledge | Expecting it to add proprietary facts |
| RAG | Retrieve documents into the prompt at runtime | Current knowledge with citations | Ignoring chunking and retrieval quality |
| Fine-tuning (including LoRA) | Adjust model weights on labeled examples | Changes style, tone or task behavior | Using it for facts that change weekly |
Vector store options on AWS
| Concept | Meaning | Key difference | Common trap |
|---|---|---|---|
| Bedrock Knowledge Bases | Managed end-to-end RAG | Least operational effort | Overbuilding a custom pipeline |
| OpenSearch Service | Search engine with k-NN and hybrid search | Scale, sharding and keyword plus vector | Choosing it for a tiny corpus |
| Aurora PostgreSQL pgvector | Vectors in a relational database | Reuses existing SQL data and skills | Missing it when data already lives in Aurora |
| DynamoDB with a vector store | Key-value metadata alongside embeddings | Fast metadata lookups | Treating DynamoDB alone as a similarity search engine |
Chunking strategies
| Concept | Meaning | Key difference | Common trap |
|---|---|---|---|
| Fixed-size | Equal token chunks with overlap | Simple and predictable | Splitting tables and sections mid-thought |
| Hierarchical | Child chunks for match, parent for context | Precision plus context | Ignoring it for long structured documents |
| Semantic | Breaks at meaning boundaries | Coherent chunks, more processing | Assuming it is free to compute |
Exam traps
Each trap is an answer that looks right. Learn the clue that should change your mind.
-
Fine-tune for fresh facts
- What candidates pick
- Fine-tune a model on the latest policy documents.
- Why it looks right
- Fine-tuning sounds like deep customization.
- Why it's wrong
- Weights freeze knowledge at training time, so frequently updated content needs retrieval at request time instead.
Clue to watch for Content changes often or answers must cite sources.
-
Swap the model to fix RAG
- What candidates pick
- Move to a larger FM when answers miss facts.
- Why it looks right
- Bigger models seem smarter.
- Why it's wrong
- If the right passages are never retrieved, any model will answer without them; fix chunking, embeddings or search first.
Clue to watch for Retrieved passages are irrelevant or missing.
-
Pure vector search for codes
- What candidates pick
- Rely only on semantic similarity for part numbers and SKUs.
- Why it looks right
- Vector search is the modern default.
- Why it's wrong
- Embeddings blur exact tokens such as identifiers, so hybrid keyword plus vector search returns them more reliably.
Clue to watch for Queries contain exact product codes, names or IDs.
-
Code change to switch providers
- What candidates pick
- Redeploy the Lambda function with a new model ID.
- Why it looks right
- It is the direct fix.
- Why it's wrong
- The guide favors AppConfig or a gateway layer so model choice changes at runtime without a release.
Clue to watch for Requirement says switch models without code modifications.
-
Model remembers the chat
- What candidates pick
- Assume the FM retains earlier turns automatically.
- Why it looks right
- Chat interfaces appear stateful.
- Why it's wrong
- FM invocations are stateless; the application stores history, for example in DynamoDB, and resends relevant turns.
Clue to watch for Multi-turn assistant losing context between requests.
-
Ignore Regional availability
- What candidates pick
- Deploy only in the home Region where the model is not offered.
- Why it looks right
- Keeping everything in one Region feels simpler.
- Why it's wrong
- Cross-Region inference profiles exist for models with limited Regional availability and for burst capacity.
Clue to watch for The model is unavailable or throttled in the primary Region.
Answer framework
Use these steps to work through a Domain 1 design scenario on AIP-C01.
- Underline every constraint in the scenario, including freshness of data, latency, cost, Region, compliance and how much custom code the team accepts.
- Decide how knowledge reaches the model: prompt changes for behavior, RAG for current or private facts, fine-tuning or LoRA for style and task specialization.
- If RAG is involved, pick the vector store that matches existing data platforms and scale, then choose chunking and embedding settings for the document type.
- Plan resilience and flexibility by externalizing model choice, using cross-Region inference where availability is limited, and adding fallbacks for outages.
- Close with governance: versioned prompt templates, regression tests, CloudTrail auditing and guardrails, choosing the managed Bedrock feature before custom code.
Practice question
Want more like this? The AIP-C01 practice test has questions for every domain.
Checklist
0 of 14
Tick each one you can do without notes. Your ticks stay in this browser.
Study strategy
Give this domain the most hours, since it holds nearly a third of the scored items. Start by building a small RAG application end to end: put documents in S3, create an Amazon Bedrock knowledge base, try two chunking strategies and compare answers. Then repeat the retrieval with OpenSearch Service and Aurora pgvector so the trade-offs between stores become concrete rather than memorized.
Next, practice model selection. Call several Bedrock models through the Converse API, store the model ID in AppConfig and switch it without redeploying. Read about cross-Region inference profiles and fine-tuning lifecycle with SageMaker Model Registry.
Finish with prompts: create versioned templates in Prompt Management, chain them in Bedrock Flows and write a simple regression test. Review the Well-Architected Generative AI Lens once. For each practice question you miss, record whether the root cause was data, retrieval, model choice or prompt, because that pattern tells you where to study next. Expect long scenarios, so practice reading constraints before options.
FAQ
How much of AIP-C01 is Domain 1?
Foundation Model Integration, Data Management, and Compliance is 31% of the scored content, the largest domain, with six task statements.
Is AIP-C01 still in beta?
No. The beta ran through March 31, 2026. The AWS certification page now lists 75 questions in 180 minutes, with 65 scored and a passing score of 750.
When should I choose RAG over fine-tuning?
Choose RAG when knowledge changes often, must be cited or is private. Choose fine-tuning or LoRA when you need to change style, format or task behavior that prompts cannot achieve.
Which vector stores should I know?
Amazon Bedrock Knowledge Bases with its managed options, OpenSearch Service with k-NN and hybrid search, Aurora PostgreSQL with pgvector, and DynamoDB for metadata alongside embeddings.
What does hierarchical chunking solve?
It matches on small child chunks for precision but returns the larger parent section, so the model receives enough surrounding context to answer.
How do I switch models without a code change?
Store the model ID and parameters in AWS AppConfig or route through an API Gateway layer, so a configuration update changes the model at runtime.
Does this domain cover prompt governance?
Yes. Task 1.6 includes versioned templates and approvals in Bedrock Prompt Management, CloudTrail usage tracking and prompt regression testing.
Other Artificial Intelligence & Machine Learning certifications
Where the same subject shows up in other exams. Cards marked "Same subject" open the matching domain.
Test your Domain 1 knowledge
You have covered FM selection, data pipelines, vector stores, retrieval design and prompt governance. Test whether you can pick the right design under professional-level scenario pressure.
Keep going
- Training Training Built on your Weak areas
- Practice test Questions by domain, with explanations
- Mock exam Full length, timed like the real exam
- Readiness test Find your weakest domain in minutes
- Cheat sheet Key terms and formulas on one page
- Ask the AIP-C01 AI tutor Get any concept explained your way