A 30-day countdown to the CCA Foundations exam feels like plenty of time — until week two arrives and you realise you've re-read the same domain twice and never opened a practice question. The candidates who pass on their first attempt almost never out-study everyone else; they simply follow a schedule that maps study hours to the exam's actual domain weights, in the actual order those domains appear on the syllabus, with practice questions built in from day one rather than bolted on at the end.
This is that schedule. It's built around the five real CCA Foundations domains and their official weightings — not a generic "study everything equally" template — and it front-loads the heaviest domain first, because that's where the most marks live and where most candidates underinvest.
Know What You're Studying For First
Before opening a single resource, lock in the shape of the exam. Every allocation in this 30-day plan is derived directly from these numbers:
| Detail | Value |
|---|---|
| Total questions | 60, scenario-based |
| Time limit | 120 minutes |
| Passing score | 720 / 1,000 (scaled, not a raw percentage) |
| Registration fee | $125 (USD) |
| Free registration option | First 5,000 partner-company employees (early access) |
| Format | Proctored, closed-book, multiple choice (one correct answer) |
And here is the domain breakdown this entire schedule is organised around — five domains, weighted by how much of your final score each one controls:
| Domain | Exam Weight | Days Allocated |
|---|---|---|
| 1. Agentic Architecture & Orchestration | 27% | 8 days |
| 2. Claude Code Configuration & Workflows | 20% | 6 days |
| 3. Prompt Engineering & Structured Output | 20% | 6 days |
| 4. Tool Design & MCP | 18% | 5 days |
| 5. Context Management & Reliability | 15% | 4 days |
That's 29 days of domain-mapped study plus one day held in reserve for rest and final review — 30 in total. Notice that the day allocation roughly mirrors the exam-weight percentages. That's deliberate: spending equal time on a 27% domain and a 15% domain is a guaranteed way to under-prepare for the section that decides most of your score.
Week 1 (Days 1–7): Agentic Architecture & Orchestration
Domain 1 carries 27% of your final score — more than one in four marks — so it opens the schedule and gets the largest share of days. Everything else on the exam assumes you already think clearly about agent loops, orchestration, and failure handling, so building that foundation first makes every later domain easier to learn.
- Days 1–3 — The agent loop and architecture choice: Study the observe–think–act–respond cycle, when a single agent is sufficient versus when an orchestrator/subagent split is the right call, and parallel vs. sequential subagent execution. Work through 15–20 scenario questions on architecture selection, reviewing every explanation in full — including on questions you got right.
- Days 4–5 — Reliability and escalation patterns: Focus on the patterns the exam returns to again and again: minimal-footprint design, human-in-the-loop interrupts, clarifying ambiguity before a long autonomous run, and recovery strategies when a subagent fails mid-task. These are the "two answers both look right" questions — the domain where judgment, not recall, decides your score.
- Days 6–7 — Practice and consolidation: Run 30–40 Domain 1 practice questions back to back, in exam-like conditions (no notes, no pausing). Then read our deep dive on Agentic Architecture & Orchestration, which walks through a full worked scenario — a support-ticket triage system with an escalation threshold — of exactly the kind the exam favours.
Week 2 (Days 8–14): Claude Code Configuration, Then Into Prompt Engineering
Domain 2 (Claude Code Configuration & Workflows, 20%) comes next. Candidates routinely underrate this domain because it feels like "settings," but the questions test whether you understand how CLAUDE.md files, settings hierarchies, and permission allowlists actually interact at runtime — not whether you can recite where a file lives.
- Days 8–9 — The configuration hierarchy: Study the inheritance chain between global and project-level settings, when to use
settings.jsonversussettings.local.json, Bash and file-tool permission allowlists, and how MCP servers are connected and scoped inside Claude Code. Our guide to writing an effective CLAUDE.md file is a useful companion here. - Days 10–11 — Practice and the worked scenario: Work through 25–30 Domain 2 questions, then read our Domain 2 deep dive, which walks through configuring Claude Code for a six-person team — exactly the kind of "where does this setting belong" scenario the exam likes to test.
- Days 12–14 — Begin Prompt Engineering & Structured Output (20%): Start the next domain early rather than waiting for week three. Cover the PRECISE framework (Persona, Role, Explicit instructions, Context, Instructions, Steps, Examples), few-shot example selection and ordering, and chain-of-thought usage. Run 20 practice questions focused on diagnosing why a prompt underperforms — that's the skill this domain actually tests, not prompt-writing in the abstract.
Week 3 (Days 15–21): Finish Prompt Engineering, Then Tool Design & MCP
This week closes out Domain 3 and opens Domain 4 (Tool Design & MCP, 18%) — together they make up 38% of the exam, more than a third of your score.
- Days 15–17 — Structured output and injection defence: Study schema-enforced JSON output versus prompt-only formatting instructions, Constitutional AI principles, and prompt injection prevention in production systems. Then read our Domain 3 deep dive, built around a worked scenario comparing prompt-based and schema-enforced approaches to a resume-extraction pipeline. Run 20–25 practice questions and pay close attention to any you get wrong — Domain 3 questions often hinge on a single overlooked constraint.
- Days 18–21 — Tool Design & MCP: Cover MCP server architecture (the resources, tools, and prompts primitives), JSON Schema for tool input definitions, stdio vs. SSE transport trade-offs, and authentication patterns for production MCP deployments. Read our Domain 4 deep dive, which walks through a calendar-agent scenario weighing one consolidated
manage_eventtool against four narrower tools — precisely the granularity trade-off the exam tests. Close the week with 30 practice questions, focusing especially on "what's wrong with this tool schema" formats.
Week 4 (Days 22–30): Context Management, Full Practice, and Final Review
The final stretch covers the lightest domain by weight — but the one most likely to cost you easy marks if you skip it — and then shifts entirely to full-length practice and targeted revision.
- Days 22–25 — Context Management & Reliability (15%): Study the CALM framework, prompt caching with
cache_controlbreakpoints, conversation compaction and summarisation strategies, and token budgeting across long multi-turn conversations. Read our Domain 5 deep dive, which works through a long-running contract-review agent that has to manage context across dozens of turns — the exact failure mode this domain tests for. Run 20 practice questions; this domain is consistently the easiest to pick up quickly once the CALM framework clicks. - Days 26–28 — Full timed simulations: Take a complete 60-question timed exam simulation under real conditions — no pausing, no references, the full 120 minutes. Review your domain-by-domain score breakdown in detail, then take a second simulation two days later. The gap between your two scores, and which domains moved, tells you exactly where your remaining hours should go.
- Days 29–30 — Targeted revision and rest: Spend day 29 exclusively on your one or two lowest-scoring domains from the simulations — 20–30 focused questions, explanations reviewed in full. Take day 30 mostly off. Skim your own notes if you want, but don't cram new material the day before the exam; at this stage, a clear head outperforms one more hour of reading.
Daily Habits Worth Keeping for All 30 Days
- Practice questions every single day, even on "concept" days. Ten questions after a study session does more for retention than an extra thirty minutes of reading. The exam tests decision-making under scenario pressure — you build that skill by doing it repeatedly, not by understanding it in the abstract.
- Review every explanation, including the ones you got right. Getting the right answer for the wrong reason is the most dangerous form of progress, because it feels like mastery and isn't. The explanation is where the actual learning happens.
- Keep a running list of your "almost picked it" wrong answers. These are the options that looked defensible but weren't. Re-reading that list in the final week is far more valuable than re-reading domain notes, because it directly targets the instinct the exam is designed to surface.
- Protect one rest day per week. A 30-day plan that runs you into the ground by day 20 produces worse exam-day performance than a slightly lighter plan you can actually sustain. Build recovery in rather than discovering you need it.
Adjusting This Plan to Your Situation
This schedule assumes a working knowledge of Claude's APIs and roughly one to two hours of study per day. If your starting point is different, adjust the front end of the plan rather than the back end — the final week of full simulations and targeted review should stay intact regardless of how much runway you have.
Don't have exactly 30 days? Our free CCA Study Plan Generator takes your actual weeks until exam, your weekly study capacity, and up to two weak domains, then builds a day-by-day schedule weighted the same way as this one — instantly, with no signup.
If you're not sure where you currently stand, take our free 10-question readiness diagnostic before you commit to a 30-day calendar. It scores you across all five domains in a few minutes and estimates how close you are to the 720/1,000 passing standard right now — which tells you whether 30 days is generous, about right, or optimistic for your starting point, and which domain deserves the extra days if you need to rebalance the schedule above.
- Less than 30 days available? Compress by domain weight, not evenly. Keep the full allocation for Domain 1 (Agentic Architecture & Orchestration) and Domains 2–3, and compress Domains 4 and 5 into shared days — they're lighter-weighted and faster to pick up.
- More than 30 days available? Don't stretch the concept-study days — stretch the practice. Add a third full timed simulation in the final week, spaced a few days apart, and use the extra runway to close out your weakest domain entirely rather than just improving it.
- Already deep in Claude's ecosystem? Skip straight to the practice-heavy days in each domain and use the freed-up time to add an extra simulation or two. Familiarity with the tools doesn't always translate into exam-style decision-making — verify it with questions rather than assuming it.
The Mistake That Undoes a Good Schedule
The single most common reason a well-built 30-day plan fails isn't lack of time — it's spending most of it reading and saving practice questions for "when I'm ready." You are never quite ready by that measure, because reading creates a feeling of familiarity that scenario-based questions don't reward. The exam isn't testing whether you've encountered a concept; it's testing whether you can apply it correctly under the specific pressure of a realistic, ambiguous scenario with a 120-minute clock running.
Flip the ratio instead: treat reading as the warm-up and practice questions — with full explanation review — as the main event. Candidates who follow that ordering consistently outperform candidates who spend twice as many hours studying the "right" way but back-load all their practice into the final week.
Ready to put this schedule into action? Start by finding your baseline with the free 10-question readiness diagnostic, then build decision-making speed with the 400-question practice bank spanning all five domains. When day 26 arrives, the full 60-question timed simulation gives you the domain-by-domain score breakdown this entire plan is built to act on.