Claude Certified Architect – Foundations (CCAR-F) — Complete Study Guide

The Claude Certified Architect – Foundations exam was Anthropic's first proctored certification, and it now anchors the architect track of a four-exam ladder of live Pearson VUE certifications: Claude Certified Associate – Foundations (CCAO-F), Claude Certified Developer – Foundations (CCDV-F), CCAR-F itself, and Claude Certified Architect – Professional (CCAR-P). Where Anthropic Academy's free courses certify that you completed the coursework, CCAR-F certifies — under a proctor, on a clock, against a scaled passing score — that you can architect with this stack.

That distinction matters. Anthropic's free completion certificates are excellent skills evidence, but they are unproctored and carry limited standalone weight in résumé screening. CCAR-F is the missing formal layer: a scenario-based, 60-question, 120-minute exam delivered through Pearson VUE, scored 100–1,000 with a 720 passing bar, and backed by a Credly badge. For architects, senior engineers, and consultants who bring Claude to market, it is the most direct way to put a proctored frontier-lab architect credential on your profile.

It is also unambiguously a 301-level exam for seasoned professionals. Anthropic recommends at least six months of hands-on experience with the Claude API and Claude Code before attempting it, plus completion of the 200-level Academy courses and real project work with the Agent SDK and MCP. The questions are scenario-based — "given this workload, which architecture / configuration / prompt strategy is correct" — not definition recall. If you have not shipped something on this stack, no amount of reading substitutes for the muscle memory the scenarios assume.

One naming note before anything else, because it confuses nearly everyone researching this credential: the official Pearson VUE exam code is CCAR-F, but third-party sites, community forums, and study-material vendors near-universally call it "CCA-F". These are the same single exam — CCA-F is a community abbreviation, not a separate credential. If you see "CCA-F practice tests" or "CCA-F vs CCAR-F" comparisons online, there is exactly one exam behind both names.

Who is this guide for? Three audiences:

• Partner-network architects and consultants whose employers bring Claude to market and who need the formal credential for customer-facing credibility (and whose organizations may have qualified for free Early Access seats at launch).
• Senior engineers already building on Claudedaily Claude Code users, Agent SDK builders, MCP server authors — who want proctored validation of skills they already have.
• Experienced AI engineers from other ecosystems (OpenAI, cloud-native ML) who are deep on LLM engineering generally but need to close Claude-specific gaps: CLAUDE.md conventions, hooks, adaptive thinking, prompt caching mechanics, MCP primitives.

How to Use This Guide

This guide is organized in eight parts:

• Part 1 — Exam Logistics & Registration covers the registration path (Partner Network → Skilljar → Pearson VUE), fee history, the retake policy, renewal, and the CCAR-F vs "CCA-F" naming situation.
• Parts 2–6 — The Five Exam Domains, one part per domain in blueprint order, each covering what the exam guide says the domain tests and the real technical concepts an architect needs to have internalized: agent loops and orchestration patterns (Part 2), Claude Code configuration (Part 3), prompt engineering and structured output (Part 4), tool design and MCP (Part 5), and context management and reliability engineering (Part 6).
• Part 7 — The Certification Roadmap maps the wider program: the four live Pearson VUE exams (CCAO-F, CCDV-F, CCAR-F, CCAR-P), how they ladder, and what is still announced-only.
• Part 8 — Study Plan & Portfolio Evidence gives a 4–6 week preparation schedule and the projects to build so your preparation doubles as demonstrable work, followed by the Exam-Day Checklist and Official Resources.

If you are already a heavy Claude Code + API user, skim Parts 2–6 for gaps rather than reading linearly — the domain weightings in each part's opening tell you where to spend marginal study time. If you are coming from another LLM ecosystem, read every domain part carefully; the exam's scenarios assume Claude-specific defaults and vocabulary throughout.

Part 1: Exam Logistics & Registration

The Registration Path

Registration runs through three systems, in order:

1. 1Join the Claude Partner Network (claude.com/partners). The exam is available to employees of Claude Partner Network member organizations. Membership is free for any organization bringing Claude to market — consultancies, ISVs, system integrators, resellers. If your company builds or sells Claude-based solutions and isn't a member yet, this is a straightforward application, and it unlocks the Partner Academy.
2. 2Register on Anthropic Partner Academy (anthropic-partners.skilljar.com). This is a separate Skilljar instance from the public anthropic.skilljar.com — partner-gated, with the certification page, exam registration, and checkout ($125 at the current Skilljar checkout). The public Academy's prep courses remain open to everyone, partner or not, so you can do the majority of your preparation before your organization's membership is even processed.
3. 3Schedule with Pearson VUE (pearsonvue.com/us/en/anthropic.html). After registering through the Partner Academy, you schedule your actual sitting on Pearson VUE — test center or online proctored — under exam code CCAR-F. Standard Pearson VUE rules apply: government ID, clean desk for online proctoring, arrive/check in early.

Fee History and the Early Access Window

The exam launched on March 12, 2026 on Skilljar with ProctorFree online proctoring at $99, with free Early Access vouchers for the first 5,000 partner-company employees and an "Early Adopter" Credly badge variant for candidates who certified during the launch window. Around June 30, 2026, delivery migrated to Pearson VUE and the fee moved to the current $125. If you encounter blog posts citing $99 or ProctorFree, they are describing the launch-window arrangement, not the current one.

Retakes, Validity, and Renewal

The retake policy is stricter than most cloud certifications, so plan your first attempt seriously:

The 12-month validity looks short next to AWS's three years, but the renewal is free and unproctored — a deliberate design for an ecosystem where the underlying platform (models, Claude Code features, MCP spec) changes substantially every year. Treat the annual renewal as a forcing function to stay current, not as a burden.

CCAR-F vs "CCA-F": One Exam, Two Names

Worth restating as its own section because it distorts search results: CCAR-F is the official Pearson VUE code; "CCA-F" is what almost everyone calls it informally. There is no separate "CCA" credential, no "CCA-F exam" distinct from CCAR-F, and no difference in content, fee, or badge. When evaluating third-party study resources, treat the two names as synonyms — and treat any resource that claims they are different credentials as a signal of low quality.

Part 2: Domain 1 — Agentic Architecture & Orchestration (27%)

This is the heaviest domain by weight and the one that most rewards genuine build experience. Per the exam guide, it covers selecting and designing agentic architectures: when to use a single API call versus a workflow versus an autonomous agent, how the tool-use loop works, orchestrator/subagent patterns, and building on the Claude Agent SDK. Expect scenario questions that describe a workload and ask which architecture is appropriate — and the trap answers will be over-engineered.

The Simplicity Ladder

Anthropic's own architectural guidance — repeated across its docs and the "Building Effective Agents" lineage — is to use the simplest tier that meets the need:

• Single LLM callclassification, summarization, extraction, Q&A. One request, one response.
• Workflowmulti-step pipelines where your code controls the sequence: prompt chaining (output of one call feeds the next), routing (a classifier call dispatches to specialized prompts), parallelization (fan out independent subtasks, aggregate), and evaluator–optimizer loops (one call generates, another critiques, iterate).
• Agentthe model decides its own trajectory: it plans, calls tools, observes results, and continues until done. Reach for this only when the task is genuinely open-ended and hard to decompose in advance.

Before choosing the agent tier, an architect checks four criteria: task complexity (multi-step and hard to fully specify?), value (does the outcome justify the cost and latency?), model viability (is Claude actually capable at this task type?), and cost of error (can mistakes be caught — tests, review, rollback?). A "no" on any of these argues for a simpler tier.

The Agent Loop

Every Claude agent, from a ten-line script to Claude Code itself, is the same loop: send the conversation plus tool definitions → Claude responds, possibly with tool_use blocks and stop_reason: "tool_use" → your harness executes the tools → results go back as tool_result blocks in a single user message → repeat until stop_reason: "end_turn". Know this cycle cold, including the details architects get tested on in practice:

• •
  The API is stateless — you resend the full history every iteration.
• •
  Parallel tool calls: one assistant turn can contain multiple tool_use blocks; execute them concurrently and return all results in one user message.
• •
  Tool failures go back as a tool_result with is_error: true — never dropped — so the model can adapt.
• •
  Server-side tools can pause a long loop with stop_reason: "pause_turn"; the correct handling is to resend and let the server resume, not to inject a "continue" message.

Orchestrators and Subagents

The signature pattern of this domain is orchestrator–worker: a lead agent decomposes work and delegates to subagents, each running with its own context window, its own (usually narrower) tool set, and often a cheaper model. The architectural reasons to decompose:

• Context isolationa research subagent can burn 100K tokens reading files and return a two-paragraph conclusion; the orchestrator's context stays clean.
• Parallelismindependent workstreams (search multiple sources, review multiple files) run concurrently.
• Least privilegea code-review subagent gets read-only tools; only the orchestrator holds write access.
• Cost tieringroutine sub-tasks run on Haiku or Sonnet while the orchestrator stays on the frontier model.

Equally important is when not to decompose: sequential, dependent steps gain nothing from subagents except handoff overhead, and subagents do not share conversation history — the orchestrator must pass complete task context in the delegation message (or via the filesystem). Under-specified delegation is the classic multi-agent failure mode.

The Claude Agent SDK

The Claude Agent SDK (Python and TypeScript) packages the production agent loop that powers Claude Code — the harness handles tool execution, permission gating, context management, and subagent spawning, and you configure it with system prompts, custom tools, hooks, and MCP servers. For the exam, understand what you get from the SDK versus hand-rolling the loop on the raw API: the SDK gives you Claude Code's tool suite (file operations, bash, search), session management, fine-grained permission control, and hooks, while the raw API loop gives you maximum flexibility with maximum responsibility. An architect should be able to justify either choice for a given scenario — SDK for agent products that resemble "an autonomous worker in an environment," raw API tool use for tightly scoped custom workflows embedded in an application.

Part 3: Domain 2 — Claude Code Configuration & Workflows (20%)

Per the exam guide, this domain covers configuring, extending, and operating Claude Code in professional settings: project memory, settings and permissions, hooks, slash commands, subagents, and headless/CI usage. This is the domain where daily Claude Code users have a huge advantage — and where "I've used it but never configured it for a team" shows.

CLAUDE.md — Project Memory

CLAUDE.md is the project memory file Claude Code loads into context at session start. Know the hierarchy and what belongs at each level:

• Project CLAUDE.md (repo root, checked in) — build/test commands, architecture notes, code conventions, repository etiquette shared by the whole team.
• User-level ~/.claude/CLAUDE.mdpersonal preferences applied across all your projects.
• Directory-scoped CLAUDE.md files deeper in the tree — loaded when Claude works in that area, for module-specific guidance.
• CLAUDE.local.md / importspersonal, non-committed overlays.

The architect-level judgment: CLAUDE.md is prompt budget, spent on every session. Keep it curated and imperative ("run npm test before committing", "use the repository pattern in src/data/") rather than encyclopedic. A bloated memory file degrades behavior and costs tokens on every request.

Settings and Permissions

Configuration lives in layered settings.json files — user (~/.claude/settings.json), project (.claude/settings.json, checked in), and local project (.claude/settings.local.json, git-ignored) — with enterprise managed policy settings able to override all of them. The permission model is the exam-relevant core: allow / ask / deny rules per tool, with matchers that scope rules tightly — e.g. allow Bash(npm test:*) without allowing all of Bash, allow Read broadly but deny read access to .env and secrets paths, deny WebFetch entirely in a locked-down environment. Understand precedence (deny beats allow; more specific managed policies beat user preferences) and the operating modes (default, plan mode for read-only analysis, auto-accept for edits, and --dangerously-skip-permissions for isolated containers only).

Hooks — Deterministic Guardrails

Hooks are shell commands the harness executes at lifecycle events — PreToolUse, PostToolUse, UserPromptSubmit, SessionStart, Stop, and others. The architectural distinction the exam cares about: instructions in CLAUDE.md are suggestions the model usually follows; hooks are code the harness always runs. Anything that must happen every time — run the formatter after each edit, block any Bash command touching production credentials, validate a commit message format — belongs in a hook, not in prose. A PreToolUse hook can inspect the pending tool call and block it with feedback (non-zero exit / structured JSON decision), which makes hooks the enforcement layer for policies that prompts can only request.

Slash Commands, Subagents, and Skills

• Custom slash commands are Markdown prompt templates in .claude/commands/ (project) or ~/.claude/commands/ (user), invoked as /name, with $ARGUMENTS interpolation and frontmatter for allowed tools. They turn "the prompt that works" into a shared, versioned team asset.
• Subagents in Claude Code are Markdown definitions (.claude/agents/) with their own system prompt, tool allowlist, and optional model override — the practical implementation of Domain 1's orchestration theory. Claude delegates to them automatically based on their descriptions or on request.
• Skills package instructions plus optional scripts/resources that Claude loads on demand when a task matches — progressive disclosure that keeps the default context lean.

Headless Mode and CI

Claude Code runs non-interactively with claude -p "<prompt>" — headless mode — with --output-format json (or stream-json) for programmatic consumption, --allowedTools to scope permissions for the run, and --max-turns to bound the loop. This is how Claude Code becomes a CI citizen: automated issue triage, PR review bots, scheduled maintenance tasks, and the GitHub Actions integration. For team scale-out, know that sessions can be resumed (--resume), and that permission prompts don't exist in headless mode — you pre-authorize exactly what the run needs, which is why tight --allowedTools scoping is the security answer in CI scenarios.

Part 4: Domain 3 — Prompt Engineering & Structured Output (20%)

Per the exam guide, this domain covers engineering prompts for production systems: system prompt design, Claude's XML conventions, few-shot strategy, structured outputs, tool-use prompting, and extended/adaptive thinking. The bar is architect-level: not "write a nice prompt" but "design a prompt system that behaves predictably at scale."

System Prompts and Claude's Prompting Conventions

The system prompt sets role, constraints, and output contract; user turns carry the task and data. Claude responds strongly to a small set of documented techniques the exam expects you to know as defaults:

• Be explicit and specific. Claude 4-generation models follow instructions more literally than older models — vague prompts get literal interpretations, and aggressive scaffolding written for older models ("CRITICAL: you MUST…") over-triggers. Modern prompt hygiene is calm, precise instruction.
• XML tags for structure. Claude is specifically trained to respect XML-style delimiters — <instructions>, <context>, <examples>, <document> — to separate instructions from data. This is also the standard defense-in-depth move against prompt injection from retrieved content: fence untrusted data in tags and instruct the model that content inside them is data, not instructions.
• Few-shot examples for format-sensitive tasks: 3–5 well-chosen examples wrapped in <example> tags outperform paragraphs of format description, and diverse examples beat redundant ones.
• Ordering matters for long contextput large documents near the top and the query/instructions after them; ask for quote extraction before analysis to ground answers in document content.
• Motivate, don't just commandexplaining why a constraint exists ("respond in under 100 words because this feeds an SMS gateway") measurably improves adherence.

Structured Outputs — the Modern Answer

For machine-readable output, the current API answer is structured outputs: output_config.format with a JSON Schema guarantees the response parses and validates. Two related mechanisms, one decision:

• JSON output format (output_config: {format: {type: "json_schema", schema: …}}) constrains the response body — use for extraction, classification payloads, and any response your code parses.
• Strict tool use (strict: true on a tool definition, with additionalProperties: false and required in the schema) guarantees tool call inputs validate exactly against the schema — use for production tool interfaces.

Know the history well enough to spot outdated patterns in scenarios: the older technique of prefilling the assistant turn (starting the assistant message with { to force JSON) is no longer supported on current models — last-assistant-turn prefill returns an error on the Claude 4.6+ generation — and structured outputs are its replacement. Also know the practical constraints: schemas must set additionalProperties: false, unsupported constraint keywords exist (numeric ranges, string lengths), and structured outputs are incompatible with citations.

Tool-Use Prompting

Tool definitions are prompts. The exam-grade rules: descriptive names (get_customer_invoices, not tool_3); detailed descriptions that say when to call the tool, not just what it does (current models reach for tools more conservatively, and trigger-condition descriptions measurably lift correct-call rates); enum for closed value sets; and tool_choice for control — auto (default), any (must use some tool), {"type": "tool", "name": …} (forced call, the classic classification pattern), and none.

Extended and Adaptive Thinking

Claude's reasoning controls are a favorite scenario ingredient because they changed recently and distinguish current practitioners from stale ones. The current model generations use adaptive thinking — thinking: {type: "adaptive"} — where Claude decides when and how deeply to reason, with the effort parameter (output_config.effort: low / medium / high, plus higher tiers on frontier models) as the depth-versus-cost dial. The older fixed budget_tokens extended-thinking configuration is deprecated-to-removed on current models. Architect-level facts: thinking output is billed; interleaved thinking between tool calls comes automatically with adaptive thinking; effort is the first lever for both "responses are too shallow" (raise it) and "latency/cost too high on routine tasks" (lower it) before you reach for prompt surgery.

Part 5: Domain 4 — Tool Design & MCP Integration (18%)

Per the exam guide, this domain covers designing tool interfaces Claude can use reliably and building/integrating Model Context Protocol servers: schema design, tool surface architecture, MCP's primitives, transports, and the security model. It is the most "protocol-flavored" domain, and the one where hands-on MCP building pays off most directly.

Designing the Tool Surface

Beyond individual schema quality (Part 4's territory), architects design the set of tools an agent holds:

• Right-sized tool count. Every tool definition costs context and adds decision burden. Consolidate overlapping tools; a focused set outperforms an exhaustive one. For genuinely large tool libraries, deferred loading with tool search — discovering and loading only relevant schemas per request — is the scaling pattern.
• Bash-versus-dedicated-tool judgment. A bash tool gives an agent enormous breadth but gives your harness only an opaque command string. Promote an action to a dedicated tool when you need to gate it (confirmation before send_email), validate it (an edit tool can reject stale writes), render it, or parallelize it safely. Start broad, promote when you need the hook.
• Design for the loop. Tools should return what the model needs to decide the next step — meaningful errors (in tool_result with is_error: true) beat silent failures; concise, filtered results beat raw dumps that flood the context window.

MCP: The Open Standard

Model Context Protocol — created by Anthropic, now adopted across the industry — is the ecosystem version of tool use: instead of every application defining private tools, an MCP server exposes capabilities once, and any MCP client (Claude Code, Claude Desktop, the Agent SDK, and a long list of third-party hosts) can consume them. The architecture is client–host–server over JSON-RPC: the host application runs MCP clients, each maintaining a connection to one server.

Know the three server primitives and their intended control model — this is the most exam-testable fact cluster in the domain:

Servers can also request sampling — asking the client's model to run a completion on the server's behalf — which inverts the usual direction and is gated by the client for exactly that reason.

Transports

Two transports matter architecturally:

• stdiothe client launches the server as a local subprocess and speaks JSON-RPC over stdin/stdout. Right for local integrations: filesystem access, local dev tools, anything that should inherit the user's machine context. No network exposure, credentials stay local.
• Streamable HTTPthe server is a remote HTTP endpoint (with optional server-sent-event streaming). Right for shared, multi-tenant, or SaaS-hosted servers. This is where authentication enters: the MCP spec standardizes on OAuth 2.1 for remote server authorization. (Older materials describe a separate "HTTP+SSE" transport; Streamable HTTP is its successor in the current spec.)

The local-versus-remote decision — subprocess trust and machine access versus centralized deployment, shared credentials, and network-level auth — is a natural scenario axis.

MCP Security Judgment

An architect defends the MCP boundary: servers run with real credentials against real systems, and tool descriptions/results are third-party content entering the model's context. Core judgments: install servers from trusted sources only (a malicious server can inject instructions through tool descriptions); scope server credentials to least privilege (read-only tokens for read use cases); treat data returned by MCP tools as untrusted input (fence it, per Part 4); and gate destructive tools behind human confirmation in the client. In Claude Code specifically, know that MCP servers are configured at project or user scope (.mcp.json for team-shared project servers) and that their tools flow through the same permission system as built-in tools.

Part 6: Domain 5 — Context Management & Reliability (15%)

Per the exam guide, this domain covers operating Claude solutions in production: context window management, prompt caching, compaction and context editing, rate limits and retries, and evaluation. It is the smallest domain by weight but the most "day-two operations" flavored — and prompt caching questions in particular reward precise mechanical knowledge.

Context Windows and Long-Running Sessions

Current Claude models offer very large context windows (200K tokens standard, with 1M-class windows on current frontier models), but an architect treats context as a managed budget, not free space: quality and latency degrade as context bloats, and agentic sessions accumulate tool results relentlessly. The management toolkit, in escalating order:

• Don't put it in contextretrieve on demand (RAG, agentic file reading, tool search, skills) rather than front-loading.
• Context editingclear stale tool results and old thinking blocks from the transcript; pruning, not summarizing.
• Compactionwhen a conversation approaches the window, summarize earlier history into a compact block and continue; this is what Claude Code's auto-compact does, and the API offers it server-side.
• Memorypersist durable state (decisions, learnings, preferences) outside the conversation — files the agent reads/writes — so sessions can be short and state survives them.

Know the compaction-versus-editing distinction crisply: editing removes stale content; compaction summarizes history. They compose — and both differ from memory, which is cross-session persistence.

Prompt Caching — the Mechanics

Prompt caching is the highest-ROI cost lever in Claude production systems, and its rules are precise enough to test well:

• It is a prefix match. The rendered prompt orders tools → system → messages; a cache_control: {"type": "ephemeral"} breakpoint caches everything up to it. Any byte change anywhere in the prefix invalidates everything after that point.
• Economics: cache reads cost ~10% of base input price; cache writes carry a ~25% premium (5-minute TTL; a 1-hour TTL costs more to write). Cached spans keep paying off across the calls of an agent loop — which is why agents are caching's best customers.
• Design consequence: stable content first (frozen system prompt, deterministic tool list), volatile content (timestamps, per-request IDs, the user's question) after the last breakpoint. The classic silent invalidators: a datetime.now() interpolated into the system prompt, unsorted JSON serialization, per-user tool sets, and switching models or editing the tool list mid-session (both invalidate the whole cache).
• Verification: the response usage block reports cache_read_input_tokens and cache_creation_input_tokens — zero reads across repeated identical calls means an invalidator is hiding somewhere.

Rate Limits, Retries, and Cost Architecture

The Claude API enforces per-organization limits along requests-per-minute and input/output tokens-per-minute dimensions, by usage tier. Architect-grade handling:

• 429s carry a retry-after header — honor it; the official SDKs already retry 429s and 5xx-class errors (including 529 overloaded) with exponential backoff and jitter, so the first answer is configuring SDK retries, not hand-rolling them.
• Distinguish retryable from non-retryable429/500/529 retry; 400 (malformed request) and 401/403 (auth) never fix themselves — surface them.
• The Message Batches API processes asynchronous workloads at 50% of standard price with results within 24 hours — the correct answer for any scenario with large non-interactive volume (nightly enrichment, bulk classification).
• Model tieringHaiku for high-volume simple tasks, Sonnet as the workhorse, Opus-class for frontier reasoning — plus caching plus batching is the standard three-lever cost architecture.
• Streaming is the reliability answer for long outputs (avoids HTTP timeouts on large max_tokens) as well as the UX answer for responsiveness.

Evaluation — Engineering, Not Vibes

Production prompt changes need regression protection. The exam-relevant practice: build an eval set of representative cases (including edge cases and past failures) before tuning; grade with the cheapest sufficient method — code-based checks for verifiable outputs (exact match, schema validation, execution tests), LLM-as-judge with an explicit rubric for open-ended quality, human review reserved for calibration; and gate prompt/model changes on eval results the way code changes gate on tests. Model upgrades are prompt changes too: re-run evals when the model version bumps.

Part 7: The Certification Roadmap — What's Live and What's Announced

Anthropic's certification program has grown quickly: what began with a single flagship exam is now a four-exam ladder of live, proctored Pearson VUE certifications, with a Seller credential still announced-only. As of July 2026, the honest status board looks like this:

The ladder now maps cleanly to roles: CCAO-F is the broad-audience entry credential (foundational fluency across the Claude ecosystem, less depth), CCDV-F is implementation-heavy for hands-on builders, CCAR-F — this guide's subject — is the architecture-heavy foundations exam, and CCAR-P sits above it as the professional-tier architect credential for those who pass Foundations and want the advanced tier.

What this means strategically: CCAR-F is no longer the only proctored Anthropic credential, but it remains the flagship of the architect track — and the free annual renewal means certifying now costs you nothing as the program keeps expanding. If your role is developer-flavored rather than architect-flavored, CCDV-F is now the more direct fit; if you want the architecture credential, the natural progression is CCAR-F today and CCAR-P once you have it. The five CCAR-F domains — Agent SDK, Claude Code, the API, and MCP in depth — overlap heavily with CCDV-F preparation either way.

Part 8: Study Plan & Portfolio Evidence

A 4–6 Week Study Plan

This plan assumes you meet the experience recommendation (≥6 months hands-on with the Claude API and Claude Code). If you don't, spend 4–8 weeks building first — the exam's scenario style punishes purely theoretical preparation. Budget 6–10 hours per week.

Portfolio Evidence — Make the Prep Pay Twice

Everything in the study plan doubles as portfolio material. Assemble it deliberately:

When you pass, present the credential precisely: "Claude Certified Architect – Foundations (CCAR-F), Anthropic — Credly-verified" on LinkedIn's licenses & certifications section, with the Credly badge URL as the credential link, and the portfolio repos one click away. A proctored architect credential from the lab that builds the models, an annual free renewal keeping it current, and public work demonstrating every domain — that is a complete, credible story.

Exam-Day Checklist

• Logistics first. Government ID ready; for online proctoring, a clean desk, a stable connection, and early check-in; for a test center, arrive early. Confirm your Partner Academy registration and Pearson VUE booking the week before.
• Pace: two minutes per question. 60 scenario questions in 120 minutes is comfortable only if you never stall on a long stem.
• Read the question line first, then mine the scenario stem for the discriminating detail — the stems are long by design.
• Eliminate over-engineering. Answers that violate the simplicity ladder (a multi-agent system where a prompt chain suffices) are classic distractors.
• Eliminate stale mechanics. Prefill-for-JSON, fixed thinking budgets on current models, and other deprecated patterns are disproportionately the wrong answers.
• Flag and move on rather than stalling; the review screen exists for a reason.
• Answer everything. There is no penalty for wrong answers, and the scaled 100–1,000 scoring means you do not need 72% raw to hit the 720 bar.
• No cramming in the final 48 hours. Scenario judgment comes from consolidation, not last-minute reading.

Official Resources

• Anthropic Partner Academy — CCAR-F certification page:anthropic-partners.skilljar.com/claude-certified-architect-foundations-certification — registration, current exam guide, fees, and policies.
• Anthropic Academy:anthropic.com/learn — the free prep courses (Claude API, Claude Code, MCP) recommended before this 301-level exam.
• Pearson VUE — Anthropic certification page:home.pearsonvue.com/anthropic — scheduling, test-center search, and online-proctoring requirements.
• Claude documentation:docs.anthropic.com — the primary technical source for every domain in the blueprint.