AWS AIP-C01 Study Plan: Bedrock, RAG, and Guardrails in 30, 60, and 90 Days

AWS AIP-C01 30-, 60-, and 90-day study plan for Bedrock, RAG, guardrails, review loops, and final-week priorities.

Use this study plan when you want a structured route through AWS Certified Generative AI Developer - Professional (AIP-C01). This is not a prompt-vocabulary exam. AIP-C01 tests whether you can build, integrate, secure, evaluate, operate, and troubleshoot production GenAI applications on AWS.

AWS’s current exam guide frames AIP-C01 around foundation model integration, data management, compliance, implementation, integration, safety, governance, optimization, testing, validation, and troubleshooting. The strongest answers usually protect the data boundary, ground the answer, constrain tool use, evaluate behavior, monitor cost and quality, and keep rollback or human review available where the scenario requires it.

Current exam facts

I verified these current AWS exam facts on May 16, 2026.

Item Value
Exam AWS Certified Generative AI Developer - Professional
Exam code AIP-C01
Category Professional
Questions 75 total
Scoring 65 scored + 10 unscored (unscored items are not identified)
Question types Multiple choice, multiple response, ordering, and matching
Time 180 minutes
Passing score 750, scaled 100-1000
Cost 300 USD
Target candidate 2+ years building production-grade applications and 1 year implementing GenAI solutions

AWS’s certification overview lists the exam as 75 questions over 180 minutes. The AIP-C01 exam guide also lists ordering and matching item types, so practice sequence and pairing logic explicitly instead of preparing only for ordinary single-answer questions.

Weight-driven study allocation

Domain Weight How to allocate study time
Foundation Model Integration, Data Management, and Compliance 31% Spend the most time on model fit, RAG, embeddings, vector stores, prompt design, data retention, and compliance-aware grounding.
Implementation and Integration 26% Drill agents, tool integrations, deployment strategies, enterprise integration, FM API contracts, workflows, and application development tools.
AI Safety, Security, and Governance 20% Practice guardrails, prompt-injection defense, IAM, KMS, private access, privacy controls, audit evidence, responsible AI, and approval flows.
Operational Efficiency and Optimization 12% Learn token cost, model tiering, caching, batching, provisioned throughput, latency, retrieval speed, monitoring, and rollback decisions.
Testing, Validation, and Troubleshooting 11% Drill evaluation datasets, regression tests, hallucination diagnosis, retrieval failures, tool failures, runtime evidence, and release readiness.

The first two domains are 57% of scored content, but safety and testing are not optional. In real AIP-C01 scenarios, the best answer usually crosses domains: RAG plus privacy, agents plus tool permissions, streaming plus latency, or evaluation plus rollback.

Pick the right timeline

Starting point Typical study time Best-fit timeline
You build AWS applications and have shipped GenAI features 55-80 hours 30-60 days
You know AWS well but are newer to RAG, agents, and evaluation 85-120 hours 60 days
You know AI concepts but not AWS production architecture 100-140 hours 60-90 days
You are new to both AWS architecture and production GenAI 140+ hours 90 days before scheduling

Choose the longer route if you still confuse Bedrock model invocation, Knowledge Bases, Agents, Guardrails, vector stores, IAM/KMS boundaries, evaluation, monitoring, and workflow orchestration as one generic “AI app” bucket.

The AIP-C01 study loop

Use one production GenAI loop every week.

    flowchart LR
	  U["Use case"] --> D["Data boundary"]
	  D --> M["Model and pattern"]
	  M --> I["Integration path"]
	  I --> C["Controls"]
	  C --> E["Evaluation"]
	  E --> O["Operate and optimize"]
	  O --> R["Miss rule"]
Step What to ask
Use case Is the problem generation, summarization, search, classification, extraction, conversation, workflow automation, or tool action?
Data boundary What source data, PII, retention, isolation, vector store, metadata, audit, or compliance boundary matters?
Model and pattern Should the app use direct prompting, RAG, Knowledge Bases, agents, customization, smaller models, or multimodal processing?
Integration path What API, workflow, event, tool, business system, fallback, retry, streaming, or deployment path is required?
Controls Which guardrail, IAM, KMS, network, content filter, prompt-injection defense, approval, or logging control belongs where?
Evaluation What dataset, metric, regression test, quality threshold, safety test, or human review proves readiness?
Operate and optimize What reduces cost, latency, drift, failures, or safety incidents without weakening quality or governance?

Minimum production baseline

You do not need a large lab, but you should be able to explain these paths without guessing:

Path What you should know
Direct FM call Model fit, prompt template, system instruction, response format, token cost, latency, retry, fallback, and logging
RAG path Source data, chunking, embeddings, vector store, metadata filters, retrieval scoring, grounding, citations, and data freshness
Agent path Tool choice, permissions, state, memory, MCP/tool integration, approval, error handling, and audit trail
Safety path Input filtering, output filtering, guardrails, prompt-injection defense, PII handling, unsafe-output handling, and human escalation
Security path IAM, resource policy, KMS, private access, secrets, tenant isolation, logging, retention, and audit evidence
Evaluation path Golden set, automated evaluation, human review, regression test, release gate, rollback signal, and drift monitoring
Optimization path Model tiering, prompt compression, caching, batching, streaming, provisioned throughput, quotas, and version comparison

30-day intensive plan

Use this route only if you already have strong AWS application experience and basic GenAI implementation exposure.

Week Focus What to produce
1 Foundation model integration, RAG, and data boundaries A decision table for direct FM call vs RAG vs Knowledge Bases vs agent vs customization, plus a retrieval failure checklist.
2 Implementation and integration A workflow map covering Bedrock invocation, agents, tool calls, FM APIs, streaming, retries, enterprise systems, Step Functions, EventBridge, and deployment controls.
3 Safety, security, governance, and privacy A control matrix for prompt injection, PII, unsafe output, overprivileged tools, missing audit evidence, privacy leakage, and human approval.
4 Operations, optimization, testing, and mixed review An evaluation and runbook pack covering latency, token cost, cache fit, monitoring, quality regression, safety regression, rollback, and troubleshooting order.

30-day rule

Every study day should create one artifact.

Artifact Why it matters
Architecture sketch Forces you to place Bedrock, app code, data sources, vector store, IAM, KMS, logs, guardrails, and evals correctly.
Decision table Converts “use AI” into concrete choices: direct call, RAG, agent, customization, or deterministic workflow.
Control matrix Keeps safety, privacy, IAM, KMS, network, logging, approval, and governance controls distinct.
Evaluation checklist Prevents treating a good demo as production readiness.
Troubleshooting tree Separates prompt, retrieval, model, tool, guardrail, permission, latency, and runtime failures.
Miss log Turns plausible distractors into durable rules.

60-day balanced plan

This is the best default route for most candidates.

Weeks Focus What to do
1-2 Foundation model integration, data, and compliance Study model fit, Bedrock basics, direct prompting, RAG, embeddings, vector stores, Knowledge Bases, chunking, prompt templates, data retention, and compliance boundaries.
3 Implementation and integration Drill agents, tools, MCP/tool boundaries, deployment strategies, enterprise integrations, streaming, function calling, structured output, Step Functions, EventBridge, AppConfig, and CI/CD.
4 Safety, security, and governance Practice guardrails, prompt injection, harmful output, PII, private data, masking, IAM, KMS, VPC/private access, audit logs, governance evidence, and responsible AI.
5 Operations and optimization plus testing and troubleshooting Study token cost, model tiering, caching, batching, provisioned throughput, latency, monitoring, evaluation datasets, regression testing, and troubleshooting.
6-7 Mixed production scenarios Run mixed sets and group misses by failure layer: data, retrieval, prompt, model, tool, guardrail, permission, deployment, evaluation, cost, or latency.
8 Final repair and scheduling decision Reread weak lessons, review the cheat sheet, answer sample questions, and schedule only if misses are narrow.

90-day part-time plan

Use this route if you are building production GenAI depth while studying.

Phase Weeks Outcome
GenAI architecture foundation 1-3 You can choose direct prompting, RAG, Knowledge Bases, agents, customization, and deterministic orchestration by requirement.
Data and integration 4-6 You can place source data, embeddings, vector stores, APIs, business systems, workflows, deployment paths, and fallback behavior correctly.
Safety and governance 7-8 You can control prompt injection, PII, unsafe output, tool permissions, audit evidence, privacy, and responsible AI requirements.
Operations and evaluation 9-10 You can tune cost/latency and prove quality, safety, retrieval, and release readiness with measurable evidence.
Exam execution 11-12 You can answer mixed, ordering, and matching items under time pressure and explain every repeated miss.

What to drill by domain

Domain Drill questions until you can answer…
FM integration, data, and compliance What model/application pattern fits the use case, data boundary, retrieval requirement, and compliance constraint?
Implementation and integration Where do agents, tools, APIs, workflows, deployment targets, fallback, retries, streaming, and enterprise systems fit?
Safety, security, and governance Which control belongs at input, retrieval, model invocation, tool call, output, logging, human approval, or audit review?
Operations and optimization What reduces cost or latency without harming quality, safety, governance, or observability?
Testing and troubleshooting How do you isolate prompt, retrieval, model, tool, guardrail, permission, deployment, runtime, or evaluation failure?

High-yield GenAI comparisons

Decision Choose by asking…
Direct FM call vs RAG Does the answer need current/private facts, citations, or source grounding?
RAG vs customization Is the gap missing knowledge/context or model behavior/style that retrieval cannot solve?
Agent vs workflow Does the system need tool-using autonomy and state, or deterministic orchestration with explicit steps?
Guardrail vs prompt instruction Is the requirement enforceable safety policy or just behavior guidance?
IAM vs KMS vs vector-store permission Is the failure caller authorization, decrypt/key access, or data-store access?
Prompt fix vs retrieval fix Is the output wrong because the instruction is weak or because the retrieved context is missing/stale/noisy?
Bigger model vs smaller model with better retrieval Is the bottleneck reasoning capacity or context quality/cost/latency?
Monitoring vs evaluation Do you need runtime telemetry, or a quality/safety judgment against expected behavior?
Human approval vs automated action Does the tool call carry business, safety, financial, privacy, or compliance risk?

Ordering and matching practice

AIP-C01 can include ordering and matching items. Practice these explicitly.

Format Practice habit
Ordering Write the production sequence before looking at choices: define use case, identify data boundary, choose pattern, wire integration, add controls, evaluate, deploy, monitor, optimize.
Matching Match each failure to the right layer: prompt, retrieval, vector store, model, tool, guardrail, IAM, KMS, network, logging, evaluation, or deployment.

For ordering and matching, partial familiarity is not enough. You need the exact sequence or exact pairing.

Final-week checklist

Use the final week for decision speed, not new topic sprawl.

Day Work
7 days out Review all five domain weights and reread the cheat sheet.
6 days out Drill RAG, vector stores, chunking, embeddings, metadata filters, data boundaries, and compliance scenarios.
5 days out Drill agents, tool use, workflow orchestration, enterprise integration, streaming, retries, fallback, and approval controls.
4 days out Drill safety, security, IAM, KMS, guardrails, prompt injection, PII handling, privacy, and audit evidence.
3 days out Drill cost, latency, model tiering, caching, batching, provisioned throughput, monitoring, evaluation, rollback, and troubleshooting.
2 days out Run a mixed timed block and classify every miss by failure layer.
1 day out Review only weak rules, ordering/matching traps, official facts, and high-yield comparisons.

Readiness signals

You are close to ready when:

  • You can explain why each wrong answer violates a data, integration, safety, evaluation, cost, or operational constraint.
  • You can separate RAG failures from prompt failures, model-fit failures, tool failures, guardrail failures, permission failures, and runtime failures.
  • You can choose controls for PII, prompt injection, unsafe outputs, overprivileged agents, missing audit evidence, and hallucination risk.
  • You can evaluate a GenAI app using measurable criteria instead of subjective “quality” language.
  • You can answer ordering and matching items without treating them like ordinary multiple-choice questions.
  • You can keep a steady pace across 75 questions in 180 minutes.

If you only have 48 hours

This is not ideal for a professional-level exam, but if you are already near-ready:

  1. Read the cheat sheet twice: once before practice and once after reviewing misses.
  2. Drill one mixed timed block and classify every miss by domain and failure layer.
  3. Spend one focused block on RAG/data boundaries and one on agents/safety/security/governance.
  4. Review operations and testing traps: cost, latency, monitoring, evaluation, rollback, ordering, matching, and troubleshooting order.
  5. Recheck the current official AWS page and exam guide before scheduling or buying an attempt.

Booking signal

Schedule only when your misses are narrow and explainable. If you still choose answers by familiar AI vocabulary instead of use case, data boundary, architecture pattern, safety control, evaluation evidence, or operational constraint, keep studying. AIP-C01 rewards production GenAI judgment under professional-level time pressure.

Revised on Monday, June 15, 2026