The AIP-C01 Exam at a Glance

The AWS Certified Generative AI Developer - Professional exam (exam code AIP-C01) is a professional-level certification for people who build generative AI applications on AWS, not for people who merely describe them. That distinction matters more than anything else in this chapter. It is not the AI Practitioner exam with harder wording: it assumes you have written code against Amazon Bedrock, wired an agent to a Lambda function, argued with a vector store about chunk sizes, and been paged when a retrieval-augmented answer cited the wrong document.

The format

• 75 questions in 180 minutes — an average of 2 minutes 24 seconds per question.
• Two question types: multiple choice (one correct answer, three distractors) and multiple response (two or more correct answers out of five or more options).
• Scored on a scaled range of 100-1000, with 750 as the passing score.
• AWS includes a number of unscored pretest items that are not identified in the exam. You cannot tell which ones they are, so treat every question as if it counts.

The domains and their weightings

Domain	Weighting	Roughly what it covers
1. Foundation Model Integration, Data, and Compliance	31%	Model selection, prompt design, RAG and knowledge bases, embeddings and chunking, data residency, customisation
2. Implementation and Integration	26%	Agents, action groups, tool use, orchestration, Step Functions, Lambda, event-driven patterns, APIs
3. AI Safety, Security, and Governance	20%	Guardrails, IAM, encryption, network isolation, logging, auditability, responsible AI
4. Operational Efficiency	12%	Cost, latency, throughput, caching, batching, monitoring, scaling
5. Testing, Validation, and Troubleshooting	11%	Evaluation, hallucination diagnosis, regression testing, debugging traces

Weightings are approximate targets for the question pool, not a promise. If roughly 65 items are scored, domain 1 is around twenty questions and domain 5 is around seven. Two implications follow. First, domains 1 and 2 together are more than half the exam, so if your revision time is limited, spend it on model integration, data pipelines and agent implementation. Second, you cannot ignore the small domains: scoring is compensatory, meaning there is one overall scaled score and no per-domain pass mark, but eighteen questions across domains 4 and 5 is more than enough to move you from 760 to 740.

What the scaled score is not

750 out of 1000 is not 75%. The scale is a statistical transformation that keeps the difficulty bar constant across different versions of the exam, so a harder question set is worth more per item. Do not try to reverse-engineer "how many can I get wrong". Aim to be comfortably above the line rather than optimising for the minimum.

The failure mode to avoid

The commonest way to fail a professional AWS exam is not ignorance, it is pace. Scenario stems on this exam run to eight or ten lines, and a slow, thorough first pass on the first thirty questions leaves you rushing the last twenty-five. Budget two minutes for a typical question, flag anything that needs more, and finish the paper before you go back. An answered-and-flagged question is worth more than a perfectly reasoned blank.

# The API shape the exam expects you to read fluently: Bedrock Converse
# with a tool definition and a guardrail attached at invocation time.
import boto3

bedrock = boto3.client("bedrock-runtime", region_name="eu-west-1")

response = bedrock.converse(
    # An inference profile ID (the "eu." prefix) rather than a bare model ID:
    # this routes across Regions in the geography for throughput and resilience.
    modelId="eu.amazon.nova-pro-v1:0",
    system=[{"text": "You are a claims triage assistant. Be concise."}],
    messages=[
        {"role": "user", "content": [{"text": "Is claim CLM-4471 still open?"}]}
    ],
    toolConfig={
        "tools": [
            {
                "toolSpec": {
                    "name": "get_claim_status",
                    "description": "Look up the current workflow status of a claim.",
                    "inputSchema": {
                        "json": {
                            "type": "object",
                            "properties": {
                                "claim_id": {
                                    "type": "string",
                                    "description": "Claim reference, e.g. CLM-4471",
                                }
                            },
                            "required": ["claim_id"],
                        }
                    },
                }
            }
        ]
    },
    inferenceConfig={"maxTokens": 512, "temperature": 0.2},
    guardrailConfig={
        "guardrailIdentifier": "abc123guard",
        "guardrailVersion": "3",
    },
)

print(response["stopReason"])  # "tool_use" when the model wants the tool run
print(response["usage"])       # inputTokens / outputTokens, per request