AWS just released a new certification: Certified Generative AI Developer – Professional. If you work with GenAI on AWS or plan to, this exam outline doubles as a surprisingly useful roadmap for what you need to learn, regardless of whether you ever sit for the test.
The blueprint maps what separates proof-of-concept GenAI from production-grade systems. It covers the operational, security, and cost management practices that determine whether your GenAI system survives contact with real users and real budgets. The certification itself matters less than having a structured view of what production actually requires.
What makes this certification different from other AWS exams?
Most AWS certifications test breadth. This one tests depth in a narrow domain: building GenAI systems that handle real money, real compliance requirements, and real operational risk.
The target candidate has two years building production apps on AWS and one year hands-on with GenAI. If you have less experience, the exam blueprint still works as a learning path. If you have more, it works as a checklist of things your team should standardize.
The beta exam includes 85 questions with a 205-minute time limit. The standard version will have 65 scored questions plus 10 unscored evaluation questions. You won’t know which questions are unscored. Passing requires 750 out of 1000 points. New question formats include ordering tasks in sequence and matching concepts to implementations. Multiple response questions require selecting all correct options to receive credit.
The first 5,000 participants who pass receive an Early Adopter badge. The exam costs $150 and is available through Pearson VUE testing centers or online proctored testing.
Here’s what actually gets tested, organized by how you’ll use it.
Foundation models and data preparation
Foundation models are pre-trained transformer models that AWS makes available through Bedrock. Think of them as extremely capable pattern matchers that learned from massive amounts of text, code, images, or audio during training.
AWS supports several model families through Bedrock:
- Claude from Anthropic for conversations and reasoning
- Jurassic-2 from AI21Labs for multilingual text generation
- Stable Diffusion from stability.ai for image generation
- Llama from Meta for general LLM tasks
- Amazon Titan for embeddings, summarization, and search
You need to know when to use which model family and how to swap providers without rewriting application code. The exam tests your ability to design flexible architectures where the model becomes a configuration choice, not a hard dependency.
Getting data ready for models
Foundation models expect structured input. Raw documents lose context when converted to plain text. Headings, tables, lists, and formatting carry information that models need.
Amazon Textract extracts structure from documents. Amazon Comprehend identifies entities and topics. Bedrock Data Automation handles multimodal inputs including documents, images, video, and audio.
For video processing, Bedrock Data Automation generates chapter summaries, full transcripts, and scene-level breakdowns. For audio, it produces transcripts with speaker labels and topic segmentation.
Amazon Transcribe converts speech to text with custom vocabulary support for domain-specific terms. It also detects toxic language patterns in voice conversations, which matters for customer service recordings or moderation workflows.
The exam expects you to chain these preprocessing steps before data reaches a foundation model. A Lambda function running Comprehend for entity extraction, feeding cleaned results to Bedrock, with CloudWatch tracking the pipeline.
How do you connect models to external data?
Foundation models know what they learned during training. That knowledge has a cutoff date and doesn’t include your company’s internal documents, product specs, or customer data.
Retrieval Augmented Generation (RAG)
RAG treats foundation models like students taking an open-book exam. Before answering a question, the system queries a database for relevant context and includes that context in the prompt.
The workflow:
- User asks a question
- System converts question to a vector (embedding)
- Vector database returns most similar stored content
- System builds a prompt including the question plus retrieved context
- Foundation model generates response based on both
RAG is faster and cheaper than fine-tuning for incorporating new information. Updating knowledge means updating the database, not retraining the model. It also reduces hallucinations because the model works from provided context instead of relying solely on training data.
Knowledge Bases and vector stores
Bedrock Knowledge Bases automate RAG pipelines. You point them at S3 buckets, web crawlers, Confluence, Salesforce, or SharePoint. The service handles chunking documents, generating embeddings, and storing vectors.
Vector stores translate text into high-dimensional numerical representations that capture meaning. Similar concepts cluster near each other in this vector space. Searching becomes finding the nearest vectors to a query vector.
Vector database options for Bedrock Knowledge Bases include:
- OpenSearch Serverless / OpenSearch Service (managed clusters)
- Aurora (PostgreSQL with pgvector)
- Neptune Analytics
- MongoDB
- Pinecone
- Redis Enterprise Cloud
For development and prototyping, Bedrock can provision an OpenSearch Serverless instance automatically.
Chunking strategies
Chunking splits documents into smaller pieces before converting them to vectors. Chunk size affects retrieval quality. Too large and you lose precision. Too small and you lose context.
Bedrock offers two chunking approaches:
Hierarchical chunking creates small child chunks for precise matching, then replaces them with larger parent chunks when building the final prompt. This preserves context while maintaining search accuracy.
Semantic chunking uses a foundation model to identify natural content boundaries based on topic shifts and meaning changes, instead of splitting at fixed character counts.
Metadata stored alongside chunks improves retrieval. Document IDs, creation dates, topics, and access control flags help the system rank and filter results.
When should you fine-tune a model?
Fine-tuning adapts a foundation model to specific use cases by training it on additional data. This costs more upfront than RAG but produces better results for narrow domains where the model needs to learn new patterns, not just reference new facts.
Bedrock supports fine-tuning for Titan, Cohere, and Meta models. For text models, provide training pairs of prompts and expected completions. For image models, provide S3 paths to images with text descriptions.
Fine-tuned models behave like any other foundation model in Bedrock. Same API, same invocation patterns. The difference lives in the model weights, not your application code.
To secure sensitive training data, use VPC endpoints and PrivateLink. This keeps data inside your network perimeter during the fine-tuning process.
How do you write effective prompts?
Prompts combine several components:
- Instructions that define the model’s role and behavior
- Context that provides background information
- Input data that contains the specific question or task
- Output indicators that specify the desired format
Prompt techniques
Few-shot prompting includes examples of desired input-output pairs before asking the model to handle a new input. Show the model three examples of how to format a JSON response, then ask it to format new data the same way.
Chain of Thought (CoT) prompting forces the model to show its reasoning by including “think step by step” or similar instructions. This improves accuracy on complex tasks where the final answer depends on intermediate reasoning.
Bedrock Prompt Management stores and versions reusable prompt templates with variables. A customer service template accepts variables for customer name, order ID, and issue description. The template structure stays constant while variables change per request.
Bedrock Flows chains multiple prompts with conditional logic. Route to one prompt if the user asks about pricing, another if they ask about features, a third if they ask about technical support. The flow handles orchestration while each prompt specializes in one domain.
How do you control what models generate?
Bedrock Guardrails filter inputs and outputs based on content policies. Configure them to block profanity, filter by topic, remove personally identifiable information, or detect harmful content categories.
Contextual grounding checks measure how closely a response aligns with retrieved reference documents. This catches hallucinations where the model generates plausible but incorrect information.
Token-level redaction requires custom logic beyond standard guardrails. Use Amazon Comprehend for named entity recognition, build a Lambda function that identifies sensitive tokens, redact them before sending to the model or in the response.
How do you build AI agents that use tools?
Bedrock Agents extend foundation models with tools, planning, and memory. Instead of generating text responses, agents can call APIs, query databases, run calculations, or interact with external systems.
The planning module breaks complex requests into subtasks. A user asks to “send an expense report to finance.” The agent plans: extract expense data from attachments, validate totals, format the report, identify the finance distribution list, send the email.
Action groups define available tools using OpenAPI schemas stored in S3. The schema describes function signatures, input parameters, types, and expected outputs. The agent uses this schema to understand when to invoke each tool and how to pass parameters.
Multi-agent workflows split tasks across specialized agents. An orchestrator delegates subtasks to worker agents with different capabilities. One agent handles data retrieval, another performs calculations, a third formats results. A synthesizer combines their outputs into a final response.
Agent memory
Short-term memory stores the current conversation context. Sessions track individual user interactions. Events record specific exchanges within a session.
Long-term memory extracts insights, preferences, and patterns from conversations over time. Memory records store user preferences. Memory strategies define how and when to persist information.
AgentCore Memory provides serverless storage for both memory types with automatic scaling.
What is Amazon Q and when should you use it?
Amazon Q Business creates company-specific AI assistants that answer questions and automate tasks based on internal knowledge. Data connectors crawl S3, SharePoint, Slack, Salesforce, and other sources. IAM Identity Center controls access so users only see responses based on documents they’re authorized to read.
Plugins extend Q Business with actions. Native integrations for Jira and ServiceNow let Q create tickets, update statuses, and fetch information from these systems.
Amazon Q Apps lets non-technical users build and share GenAI applications using natural language. Describe what you want the app to do, Q generates it, you refine and share with your team.
Amazon Q Developer helps developers with code generation, command suggestions, security scans, and documentation lookups. IDE extensions for VSCode, Visual Studio, and JetBrains provide real-time assistance.
How do you control GenAI costs?
Foundation models charge per token for both input and output. The Bedrock CountTokens API estimates token count before you invoke a model, letting you calculate costs in advance.
CloudWatch tracks InputTokenCount and OutputTokenCount metrics per invocation. Use these to identify expensive queries or inefficient prompts.
Reducing token usage
Context pruning limits the number of chunks retrieved in RAG queries. Filter by metadata to exclude irrelevant documents. Summarize old conversation history instead of including full text.
Response size controls set maximum token limits on model outputs. Include explicit instructions like “respond in 50 words or less” to prevent runaway generation.
Prompt caching stores static prompt prefixes so only the dynamic content needs processing on subsequent requests. System prompts, instructions, and common context get cached. User questions and data change per request. Bedrock prompt caching bills cache reads and writes separately with their own token rates, which can reduce cost for repeated prefixes.
Model selection and routing
Smaller models cost less than larger models. For simple tasks where RAG provides most of the intelligence or the query follows a template, a smaller model often produces equivalent results.
Bedrock’s intelligent prompt routing can analyze incoming requests and direct complex queries to capable models while routing simple queries to cheaper options. When configured, routing happens based on query characteristics without manual intervention.
Use Bedrock Evaluations to measure model performance against cost. Test whether a smaller model produces acceptable results for your use case before committing to expensive inference at scale.
How do you deploy and serve custom models?
SageMaker AI handles custom model deployments when Bedrock doesn’t support your requirements. Models up to 500GB can be deployed to SageMaker endpoints, but container health checks and download timeouts need adjustment for large models.
Instance type selection matters. Use GPU instances like ml.p4d.24xlarge for large models. Use CPU-optimized instances like ml.c5.9xlarge for smaller models or inference tasks like named entity recognition that don’t benefit from GPU acceleration.
For on-demand invocations, Lambda can call Bedrock or SageMaker endpoints directly. For consistent high-throughput workloads, use Bedrock provisioned throughput or dedicated SageMaker endpoints.
How do you monitor GenAI systems in production?
CloudWatch Logs collect application logs, foundation model invocations, and agent traces. Organize logs into log groups by service or component. Encrypt logs using KMS keys for compliance.
Bedrock Model Invocation Logs capture full request and response payloads for every model call. This creates an audit trail and helps diagnose quality issues or unexpected model behavior.
X-Ray traces requests across service boundaries. Use it to identify bottlenecks in RAG pipelines or agent workflows where latency spikes occur.
Bedrock Agent Tracing shows reasoning paths, knowledge base queries, action group invocations, and errors. Trace types include preprocessing, orchestration, postprocessing, and guardrail application.
Track custom metrics for GenAI-specific concerns: token usage patterns, hallucination rates detected by grounding checks, prompt effectiveness scores, response quality ratings from users.
How do you test and evaluate model quality?
Human evaluation remains essential for GenAI systems. Models produce non-deterministic outputs. Automated tests catch some problems but humans assess creativity, helpfulness, and tone.
Bedrock Evaluation Jobs measure RAG system performance using test datasets. Key metrics include correctness, completeness, helpfulness, logical coherence, and faithfulness to retrieved documents.
ROUGE metrics measure word and phrase overlap between generated text and reference text. These work well for summarization and translation tasks where the expected output has a known structure.
LLM-as-a-judge techniques use one foundation model to evaluate another model’s outputs. The judge model receives a scoring rubric, the generated response, and optionally reference responses or context. It assigns quality scores based on the rubric.
Create prompt datasets with optional reference responses and reference contexts (ground truth). Run evaluations comparing different models, different prompt templates, or different RAG configurations. Use results to inform architecture decisions.
How do you secure GenAI applications?
IAM policies control access to Bedrock and SageMaker AI resources. Follow least privilege principles. Grant specific model invocation permissions to specific roles.
VPC endpoints and PrivateLink keep traffic inside AWS networks. Use these when handling sensitive data or training custom models with proprietary information.
Amazon Macie discovers and classifies sensitive data in S3. Amazon Comprehend detects PII in text. Use these services to scan data before including it in prompts or training sets.
AWS Glue Data Catalog tracks data lineage, showing where data originated and how it transformed through pipelines. CloudTrail logs all API calls for audit and compliance.
SageMaker Model Monitor detects data drift in deployed models. It alerts when input distributions shift or model quality degrades over time. SageMaker Clarify identifies bias across demographic groups and explains which features contribute most to predictions.
How do you prepare and move data for GenAI workloads?
AWS Glue runs ETL jobs to transform data before it reaches foundation models. Use Glue to add structure dividers, clean text, merge related documents, or extract metadata.
Amazon AppFlow moves data between SaaS applications and AWS services. Build pipelines that pull data from Salesforce or Zendesk, transform it, and load it into S3 for ingestion into knowledge bases.
AWS Transfer Family provides SFTP, FTPS, and FTP servers that write directly to S3 or EFS. External systems can push data into AWS using standard file transfer protocols.
How do you automate GenAI infrastructure?
AWS CDK defines infrastructure as code using TypeScript, Python, or Java. CDK compiles to CloudFormation templates. This lets you deploy infrastructure and application code together, treating the entire stack as versioned artifacts.
CodePipeline, CodeBuild, and CodeDeploy automate testing and deployment for GenAI components. Include security scans in the pipeline. Test prompt variations against evaluation datasets. Deploy with canary strategies that expose changes to a small percentage of traffic first.
API Gateway provides the front door for GenAI services. It handles authentication, rate limiting, request validation, and transformation. Place it between external clients and Lambda functions that invoke foundation models.
What does the exam test beyond technical skills?
Five domains make up the scored content:
Foundation Model Integration, Data Management, and Compliance accounts for 31% of questions. This covers selecting and configuring models, building RAG systems, prompt engineering, and data validation pipelines.
Implementation and Integration accounts for 26%. This covers agents, tool integrations, model deployment, API patterns, and application development.
AI Safety, Security, and Governance accounts for 20%. This covers input and output safety controls, data privacy, compliance frameworks, and responsible AI principles.
Operational Efficiency and Optimization accounts for 12%. This covers cost optimization, performance tuning, monitoring systems, and resource management.
Testing, Validation, and Troubleshooting accounts for 11%. This covers evaluation frameworks, quality assurance, and diagnosing production issues.
The percentages tell you where to focus preparation time. Spend roughly a third of your study on data and model integration, a quarter on implementation patterns, a fifth on safety and governance.
How should you prepare for the exam?
Build something. The exam tests practical knowledge, the kind you get from debugging a RAG pipeline at 2 AM when retrieval returns irrelevant chunks or from explaining to a compliance officer why your fine-tuning job needs access to customer data.
Set up a Knowledge Base in Bedrock. Point it at a few PDFs. Try different chunking strategies. Measure retrieval quality. You’ll learn more in two hours of hands-on work than reading documentation for a day.
Create an agent with action groups. Give it a tool that calls an external API. Watch what happens when the API returns an error or unexpected data format. You’ll understand why OpenAPI schemas matter and why input validation belongs in Lambda functions.
Deploy a model to SageMaker. Not through the console, through CDK or CloudFormation. Deploy a second version. Implement canary routing between them. Now you understand deployment strategies in a way that exam questions will feel obvious.
The study guide lists technologies in scope. Don’t memorize the list. Use the technologies to solve a problem you care about. The exam asks “how would you solve this?” not “what service does this?” Hands-on work teaches you to think in architectures, not service names.
Read the AWS Well-Architected Generative AI Lens. It describes patterns and principles for building GenAI systems across the full lifecycle: scoping, model selection, customization, integration, deployment, continuous improvement. The exam draws heavily from these patterns.
Should you actually get AWS GenAI certified?
For job applications, AWS certifications signal that you invested time learning their ecosystem. Some organizations require them. Most don’t.
For consulting or contract work, certifications help when clients evaluate vendors. Two proposals with similar scope and price, one team has certifications, one doesn’t. The certifications become a tiebreaker.
For your own learning, the exam creates a structured forcing function. You can learn the same material without taking the test, but few people do. The exam fee and scheduling deadline create accountability.
I recommend taking it if you work with GenAI on AWS professionally and want external validation of your knowledge. I recommend studying the exam topics whether you take it or not. The blueprint maps to real production work closely enough that studying for the exam makes you better at the job.
AWS certifications are valid for three years. For Professional certifications, recertification typically requires passing the latest version of the exam. This matches the pace of change in GenAI where three-year-old knowledge becomes outdated anyway.
What should you do after passing the certification?
The certification doesn’t make you an expert. It confirms you know enough to be dangerous. Real expertise comes from building systems that survive production, handling edge cases the exam doesn’t cover, and making tradeoffs between cost, latency, and quality that documentation doesn’t quantify.
Use the certification as a checkpoint, not a destination. It tells you what you know. More importantly, it shows you what you don’t know yet. The topics you struggled with during practice exams point to areas needing more hands-on work.
Build a project that combines the pieces. RAG with multiple knowledge bases, agent workflows with external tools, custom fine-tuned models for domain-specific tasks, monitoring and cost tracking across the stack. Connect it to a real use case. Deploy it properly. Document your tradeoffs.
That project teaches more than the certification. The certification just gives you a reason to build it.