# How Claude Certification Tracks Are Structured Using tracks/*.json

> Discover how Claude certification tracks are structured using tracks/*.json files in rohitg00/ai-engineering-from-scratch. Learn about exam metadata, lesson paths, and study schedules.

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

---

**Claude certification tracks in the rohitg00/ai-engineering-from-scratch repository are defined by JSON manifest files located in `certifications/claude/tracks/` that encode exam metadata, weighted knowledge domains, sequential lesson paths, and personalized study schedules in a machine-readable schema.**

The rohitg00/ai-engineering-from-scratch repository implements a data-driven approach to curriculum management through structured JSON manifests. Instead of hard-coding certification logic, the system uses discrete track definition files to render study roadmaps, generate exam items, and drive the learner interface dynamically. Understanding the schema behind these `tracks/*.json` files is essential for developers extending the platform or integrating Claude certification data into custom tooling.

## Anatomy of a Track Manifest File

Each JSON file in `certifications/claude/tracks/` (such as [`ccar-f.json`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/ccar-f.json)) follows a uniform schema containing nine top-level sections that completely define a certification track.

### Track Identification and Metadata

The manifest begins with core identifiers: `id` (unique internal identifier like `"claude-ccar-f"`), `slug` (URL-friendly name), `examCode` (official designation such as `"CCAR-F"`), and `credential` (human-readable title like `"Claude Certified Architect – Foundations"`). The `summary` field provides a one-sentence description of the track's focus area, such as making production tradeoffs across Claude Code, the Agent SDK, API, and MCP.

### Knowledge Domains and Weighting

The `domains` array lists core knowledge areas with assigned weights that determine exam composition. For example, `"agentic-architecture-orchestration"` might carry a weight of 27, indicating its proportional representation in the certification exam. This weighting system enables automated exam item generation based on domain importance.

### Curriculum Structure via Lessons

The `lessons` array defines the ordered curriculum through objects containing:
- **path**: Directory location (e.g., `"certifications/claude/lessons/00-certification-strategy"`)
- **domains**: Array of knowledge domains covered
- **role**: Classification as orientation, core, review, or capstone
- **required**: Boolean indicating mandatory completion

### Supplementary Content and Assessments

Optional `deepDives` reference advanced lessons from the main curriculum, such as `"phases/14-agent-engineering/28-orchestration-patterns"`, while the `assessments` array configures diagnostic and mock exams with paths to JSON exam definitions like [`certifications/claude/assessments/ccar-f/diagnostic.json`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/certifications/claude/assessments/ccar-f/diagnostic.json).

### Study Schedule Configuration

The `studyPlans` array offers structured preparation timelines, specifying `durationDays`, `hoursPerWeek`, and descriptive labels like `"28-day scenario plan"` to help learners pace their preparation.

## Consuming Track Data Programmatically

The self-contained JSON structure enables downstream tools to ingest certification data without hard-coded logic.

### Python – Load Track Metadata and Filter Core Lessons

```python
import json
from pathlib import Path

track_path = Path("certifications/claude/tracks/ccar-f.json").read_text()
track = json.loads(track_path)

print(f"Track: {track['credential']} ({track['examCode']})")
print("\nCore Lessons:")
for lesson in track["lessons"]:
    if lesson["role"] == "core":
        print(f"- {lesson['path']}")

```

### JavaScript – Extract Study Plans

```javascript
import { readFileSync } from "fs";

const track = JSON.parse(
  readFileSync("certifications/claude/tracks/ccar-f.json", "utf-8")
);

console.log(`Study plans for ${track.credential}:`);
track.studyPlans.forEach(sp => {
  console.log(`• ${sp.label}: ${sp.durationDays} days, ${sp.hoursPerWeek}h/week`);
});

```

### Bash – Quick Overview with jq

```bash
jq '.credential, .domains[].name, .lessons[].path' certifications/claude/tracks/ccar-f.json

```

## Multi-Track Schema Consistency

All tracks adhere to the identical schema, differing only in field values. The repository includes:
- **ccar-f.json**: Foundations track manifest
- **ccar-p.json**: Professional track manifest  
- **ccdv-f.json**: Developer-focused track manifest
- **ccao-f.json**: Architecture-oriented track manifest

This uniformity allows the certification engine to process any track generically, while global metadata in [`certifications/claude/program.json`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/certifications/claude/program.json) (containing badge URLs and overall descriptions) and prerequisite mappings in [`certifications/claude/prerequisites.json`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/certifications/claude/prerequisites.json) provide program-wide context.

## Summary

- Claude certification tracks use JSON manifest files in `certifications/claude/tracks/` to define complete certification metadata including exam codes, credentials, and summaries
- Each manifest includes weighted `domains`, sequenced `lessons` with pedagogical roles (orientation/core/review/capstone), optional `deepDives`, `assessments`, and `studyPlans`
- The uniform schema across all tracks ([`ccar-f.json`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/ccar-f.json), [`ccar-p.json`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/ccar-p.json), etc.) enables the certification engine to programmatically render study roadmaps and generate weighted exam items
- Machine-readable structure supports integration with CLI tools, CI validation scripts, and custom learning management systems without modifying source code

## Frequently Asked Questions

### What is the exact file path for Claude certification track definitions?

Track manifests are located in `certifications/claude/tracks/` within the rohitg00/ai-engineering-from-scratch repository, with individual files named according to their exam codes (e.g., [`certifications/claude/tracks/ccar-f.json`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/certifications/claude/tracks/ccar-f.json) for the Architect Foundations exam).

### How are lesson dependencies and ordering controlled in the track manifests?

The `lessons` array in each JSON file defines explicit sequencing through array order, with each lesson object specifying its `path`, covered `domains`, pedagogical `role` (orientation/core/review/capstone), and whether it is `required` for certification completion.

### Can third-party tools consume these track manifests to build custom study planners?

Yes, the JSON schema is self-contained and documented through the existing track files, allowing external Python, JavaScript, or Bash scripts to parse domains, study plans, and lesson paths without modifying the source repository.

### Where are the actual exam questions stored if tracks only reference assessments?

While track manifests in `tracks/*.json` reference assessments via the `assessments` array (pointing to files like [`certifications/claude/assessments/ccar-f/diagnostic.json`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/certifications/claude/assessments/ccar-f/diagnostic.json)), the specific exam item pools are stored separately in the referenced assessment JSON files, not in the track manifests themselves.