# Claude Certification Tracks Structure: Complete Guide to the JSON Schema

> Explore the Claude certification tracks structure using the JSON schema. Understand credential metadata, exam specs, weighted domains, and automated study plans for AI engineering.

- Repository: [Rohit Ghumare/ai-engineering-from-scratch](https://github.com/rohitg00/ai-engineering-from-scratch)
- Tags: architecture
- Published: 2026-09-04

---

**The Claude certification tracks in the `ai-engineering-from-scratch` repository use a standardized JSON schema in `certifications/claude/tracks/` that defines credential metadata, exam specifications, weighted domains, lesson mappings, and automated study plans.**

The `rohitg00/ai-engineering-from-scratch` repository implements a data-driven curriculum engine for Claude certifications through structured track definitions. Each JSON file in `certifications/claude/tracks/` serves as the authoritative source of truth for a specific credential, enabling automated tooling to resolve lesson paths, calculate domain coverage, and generate personalized learning schedules.

## JSON Schema Overview

Every track file follows an identical schema structure that separates public identity, exam logistics, competency domains, and curriculum layout.

### Metadata and Public Identity

The root object defines the credential's public-facing attributes. Key fields include `id`, `slug`, `examCode`, `credential`, `shortName`, `level`, and `accent`. These properties determine the badge appearance, exam registration identifiers, and how the track appears in directory listings.

For example, the Foundations Developer track in [`certifications/claude/tracks/ccdv-f.json`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/certifications/claude/tracks/ccdv-f.json) specifies:

- **Level**: Foundational
- **Accent**: blue
- **Credential**: Claude Certified Developer – Foundations

### Exam Specifications

The nested `exam` object records logistical details required for test scheduling. This includes the number of items, time limit, fee, passing score (scale), validity period, delivery mode, and a direct link to the official exam guide version. Having these details machine-readable allows automated systems to surface registration deadlines and pricing without manual updates.

### Domain Competency Model

Each track defines one or more **domains** representing high-level competency areas. Every domain object contains:

- `id`: Unique identifier for the domain
- `name`: Human-readable domain title
- `weight`: Percentage of exam emphasis (drives study prioritization)
- `objectives`: Concrete learning outcomes measured on the exam

Domain weightings directly influence lesson mapping and study plan generation, ensuring curriculum time aligns with exam importance.

## Curriculum Structure

Beyond metadata, the schema orchestrates the actual learning content through linked lessons, optional deep-dives, and assessment banks.

### Lesson Mapping and Roles

The `lessons` array enumerates every lesson belonging to the track. Each lesson entry specifies:

- `path`: Relative directory path (e.g., `certifications/claude/lessons/01-claude-product-and-model-landscape`)
- `domains`: Which competency domains the lesson supports
- `role`: Classification as `orientation`, `core`, `review`, or `capstone`
- `required`: Boolean indicating mandatory vs. optional completion

This structure enables the curriculum engine to filter lessons by role or domain, supporting both comprehensive and exam-focused study modes.

### Deep Dives and Assessments

Optional **deep-dives** provide advanced coverage for learners needing deeper expertise. Each entry contains a `path`, human-readable `label`, and explanatory `reason`. The `assessments` array links to diagnostic and mock exam JSON files (stored in `certifications/claude/assessments/`) used for practice testing and readiness evaluation.

### Study Plan Recommendations

Pre-crafted **study-plan** objects in the `studyPlans` array provide recommended pacing. Each plan specifies `durationDays`, `hoursPerWeek`, and milestone lists, allowing automated tools to generate calendar schedules from the structured data.

## Available Claude Certification Tracks

The repository currently maintains four distinct credentials, each following the identical schema:

| Track File | Credential | Level | Accent |
|---|---|---|---|
| [`certifications/claude/tracks/ccdv-f.json`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/certifications/claude/tracks/ccdv-f.json) | Claude Certified Developer – Foundations | Foundational | blue |
| [`certifications/claude/tracks/ccar-p.json`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/certifications/claude/tracks/ccar-p.json) | Claude Certified Architect – Professional | Professional | green |
| [`certifications/claude/tracks/ccar-f.json`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/certifications/claude/tracks/ccar-f.json) | Claude Certified Architect – Foundations | Foundational architecture | violet |
| [`certifications/claude/tracks/ccao-f.json`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/certifications/claude/tracks/ccao-f.json) | Claude Certified Associate – Foundations | Foundational | orange |

## Programmatic Access to Track Definitions

Because the tracks use standard JSON, you can interact with them using any programming language. Here are practical examples for consuming the schema.

### Loading a Track in Python

The following function loads any track by its slug using only the standard library:

```python
import json
from pathlib import Path

def load_track(slug: str) -> dict:
    """Load a Claude certification track JSON by its slug."""
    base = Path(__file__).parent.parent / "certifications" / "claude" / "tracks"
    file = base / f"{slug}.json"
    with file.open(encoding="utf-8") as f:
        return json.load(f)

# Example: load the Foundations Developer track

dev_track = load_track("ccdv-f")
print(dev_track["credential"])
print([lesson["path"] for lesson in dev_track["lessons"][:3]])  # first three lessons

```

### Extracting Lesson Paths with jq

For shell scripting or quick inspection, use `jq` to extract all lesson paths:

```bash
jq -r '.lessons[].path' certifications/claude/tracks/ccar-f.json

```

### Generating Study Plan Summaries

You can programmatically generate human-readable study guides from the structured data:

```python
def summarize_plan(track: dict) -> str:
    lines = [f"Study plan for {track['credential']}:"]
    for plan in track.get("studyPlans", []):
        lines.append(f"- {plan['label']}: {plan['durationDays']} days, {plan['hoursPerWeek']} h/wk")
    return "\n".join(lines)

print(summarize_plan(dev_track))

```

## Summary

- **Claude certification tracks** are defined as JSON files in `certifications/claude/tracks/` following a unified schema.
- Each track contains **metadata** (identity, badge info), **exam specifications** (timing, cost, passing scores), and **domain weightings** that drive curriculum priorities.
- The **lessons array** maps content to domains with specific roles: `orientation`, `core`, `review`, or `capstone`.
- **Deep dives** and **assessments** provide optional enrichment and practice testing capabilities.
- Four active tracks exist: Foundations Developer (`ccdv-f`), Professional Architect (`ccar-p`), Foundations Architect (`ccar-f`), and Foundations Associate (`ccao-f`).
- The schema enables **data-driven tooling** for automatic study plan generation, domain coverage analysis, and lesson path resolution.

## Frequently Asked Questions

### What file format stores the Claude certification track definitions?

All track definitions use **JSON files** stored in `certifications/claude/tracks/`. Each credential has a dedicated file (e.g., [`ccdv-f.json`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/ccdv-f.json) for the Foundations Developer track) containing the complete schema for metadata, domains, lessons, and study plans.

### How are exam domains weighted in the track files?

Each domain object contains a **weight field** representing the percentage of exam emphasis. These weights are integers that sum to 100 across all domains, allowing algorithms to calculate study time allocation and lesson priority based on exam importance.

### What lesson roles are available in the curriculum?

The schema defines four distinct lesson roles: **orientation** (introductory context), **core** (essential competency material), **review** (refresher content), and **capstone** (integrative final projects). Each lesson's `role` field determines its position in recommended learning paths.

### How can I generate a study plan from a track JSON file?

Parse the `studyPlans` array from any track file. Each object contains `durationDays`, `hoursPerWeek`, and milestone labels. You can extract these values using Python's `json` module, `jq` in bash, or any JSON parser to build calendar integrations or printable schedules.