# What Do Claude Certification Track JSON Manifests Contain? A Complete Schema Guide

> Explore Claude certification track JSON manifests. Understand exam logistics, domain weightings, lesson mappings, and study plans with this complete schema guide.

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

---

**The track JSON manifests in `certifications/claude/tracks/` contain complete certification definitions—including exam logistics, domain weightings, lesson mappings, and study plans—in a standardized schema shared across all Claude certification tracks.**

The `rohitg00/ai-engineering-from-scratch` repository structures its Claude certification curriculum through machine-readable JSON manifests. Each file in `certifications/claude/tracks/` (such as [`ccdv-f.json`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/ccdv-f.json) or [`ccar-p.json`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/ccar-p.json)) acts as a single source of truth for automated curriculum generation, badge rendering, and exam preparation tooling.

## Track Manifest Schema Structure

Every track manifest follows a consistent top-level schema. Below are the key components found in files like [`certifications/claude/tracks/ccdv-f.json`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/certifications/claude/tracks/ccdv-f.json).

### Core Identification and Metadata

The manifest begins with identifiers and display properties:

- **`id`**: Unique internal identifier (e.g., `"claude-ccdv-f"`)
- **`slug`**: URL-friendly name used for file naming (e.g., `"ccdv-f"`)
- **`examCode`**: Official exam abbreviation (e.g., `"CCDV-F"`)
- **`credential`**: Full certification title (e.g., `"Claude Certified Developer - Foundations"`)
- **`shortName`**: Concise UI label for badges (e.g., `"Developer Foundations"`)
- **`level`**: Certification tier classification (e.g., `"Foundational technical"`)
- **`accent`**: UI color theme for visual distinction (e.g., `"blue"`)
- **`badge`**: Object containing `imageUrl`, `width`, and `height` for credential badges

### Audience and Prerequisites

The manifest defines target learners and entry requirements:

- **`summary`**: One-sentence description of the track's scope
- **`audience`**: Target professional roles (e.g., `"Software engineers, AI engineers..."`)
- **`recommendedExperience`**: Array of prerequisite experience strings (e.g., `"One to five years of software development"`)

### Exam Configuration

The **`exam`** object contains logistical details:

```json
{
  "items": 53,
  "timeLimitMinutes": 120,
  "fee": 150,
  "scoringScale": "200-800",
  "validityMonths": 24,
  "deliveryMode": "Online proctored",
  "guideVersion": "1.0"
}

```

### Domain Weightings and Learning Objectives

The **`domains`** array maps exam content distribution. Each domain object includes:

- **`id`**: Machine-readable domain identifier (e.g., `"agents-workflows"`)
- **`name`**: Human-readable domain title (e.g., `"Agents and Workflows"`)
- **`weight`**: Percentage of total exam coverage (e.g., `14.7`)
- **`objectives`**: Array of skill descriptions assessed in that domain

### Lesson Sequencing and Structure

The **`lessons`** array establishes the ordered curriculum. Each lesson entry specifies:

- **`path`**: Repository path to lesson content (e.g., `"certifications/claude/lessons/00-certification-strategy"`)
- **`domains`**: Array of domain IDs covered by this lesson
- **`role`**: Lesson type (`"orientation"`, `"core"`, or `"capstone"`)
- **`required`**: Boolean indicating mandatory completion status

### Supplemental Deep Dives

The optional **`deepDives`** array references advanced lessons from the main curriculum for extended study. Each entry contains:

- **`path`**: Repository path to the deep-dive content (e.g., `"phases/14-agent-engineering/01-the-agent-loop"`)
- **`label`**: Human-readable title (e.g., `"The Agent Loop"`)
- **`reason`**: Brief explanation of relevance (e.g., `"Build the loop before using an SDK"`)

### Assessment References

The **`assessments`** array links to diagnostic and mock exam resources:

- **`id`**: Assessment identifier (e.g., `"claude-ccdv-f-diagnostic"`)
- **`path`**: Relative path to the assessment JSON (e.g., `"certifications/claude/assessments/ccdv-f/diagnostic.json"`)
- **`kind`**: Type classification (`"diagnostic"` or `"mock"`)
- **`title`**: Display name for the assessment
- **`timeLimitMinutes`**: Duration constraint for the assessment

### Study Plan Schedules

The **`studyPlans`** array offers structured learning schedules. Each plan includes:

- **`id`**: Plan identifier (e.g., `"ccdv-f-21-day"`)
- **`label`**: Human-readable schedule name (e.g., `"21-day intensive plan"`)
- **`durationDays`**: Total timeline for completion
- **`hoursPerWeek`**: Recommended study commitment
- **`milestones`**: Ordered array of weekly or daily study goals

## Programmatically Loading Track Manifests

You can consume these manifests programmatically to build custom study tools or curriculum navigators.

### Python Implementation

```python
import json
from pathlib import Path

def load_track(slug: str) -> dict:
    """Read a track JSON file and return its dictionary."""
    track_path = Path("certifications/claude/tracks") / f"{slug}.json"
    with track_path.open(encoding="utf-8") as f:
        return json.load(f)

track = load_track("ccdv-f")
print(track["credential"])  # Output: Claude Certified Developer - Foundations

print("Exam weight:", sum(d["weight"] for d in track["domains"]))

```

### TypeScript Implementation

```typescript
import { readFileSync } from "fs";
import path from "path";

interface Domain {
  id: string;
  name: string;
  weight: number;
  objectives: string[];
}

interface Track {
  id: string;
  slug: string;
  credential: string;
  domains: Domain[];
  lessons: { path: string; domains: string[]; role: string; required: boolean }[];
}

function loadTrack(slug: string): Track {
  const file = readFileSync(
    path.join("certifications/claude/tracks", `${slug}.json`),
    "utf-8"
  );
  return JSON.parse(file) as Track;
}

const track = loadTrack("ccdv-f");
console.log(`Track: ${track.credential}`);
console.log(`Total domain weight: ${track.domains.reduce((s, d) => s + d.weight, 0)}`);

```

### Bash and jq for CLI Inspection

```bash
#!/usr/bin/env bash
slug=$1   # e.g., ccdv-f

jq -r '
  .studyPlans[] |
  "- \(.label): \(.durationDays) days, \(.hoursPerWeek) h/week\n  Milestones:\n  " + (.milestones|join("\n  "))
' "certifications/claude/tracks/${slug}.json"

```

## Available Certification Track Files

The repository currently maintains these track manifests in `certifications/claude/tracks/`:

- **[`ccdv-f.json`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/ccdv-f.json)**: Claude Certified Developer - Foundations (entry-level technical certification)
- **[`ccar-p.json`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/ccar-p.json)**: Claude Certified Architect - Professional (advanced architecture patterns)
- **[`ccar-f.json`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/ccar-f.json)**: Claude Certified Architect - Foundations (introductory architecture concepts)
- **[`ccao-f.json`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/ccao-f.json)**: Claude Certified AI Orchestrator - Foundations (workflow orchestration focus)

Each file adheres to the identical schema structure, differing only in concrete values representing their specific credential requirements.

## Summary

- **Track JSON manifests** in `certifications/claude/tracks/` serve as the authoritative schema for Claude certification definitions in the `rohitg00/ai-engineering-from-scratch` repository.
- Each manifest contains **fourteen top-level keys** ranging from basic metadata (`id`, `slug`) to complex structures (`domains`, `lessons`, `studyPlans`).
- The **`domains`** array specifies exam weight percentages and learning objectives, while the **`lessons`** array defines curriculum sequencing with role classifications.
- **Assessment references** and **study plans** provide diagnostic tools and structured learning timelines for candidates.
- All four track files ([`ccdv-f.json`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/ccdv-f.json), [`ccar-p.json`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/ccar-p.json), [`ccar-f.json`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/ccar-f.json), [`ccao-f.json`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/ccao-f.json)) share a uniform schema enabling automated tooling for badge generation, navigation menus, and exam weight calculations.

## Frequently Asked Questions

### How do I find the domain weight distribution for a specific certification?

Load the track JSON manifest and inspect the `domains` array. Each domain object includes a `weight` field representing the percentage of exam questions allocated to that domain. For example, in [`ccdv-f.json`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/ccdv-f.json), you can calculate the total weight coverage by summing `domain.weight` values across all domains to verify they total 100%.

### What is the difference between `lessons` and `deepDives` in the manifest?

The `lessons` array contains required and optional curriculum content specific to the certification track, including orientation, core, and capstone modules. The `deepDives` array references supplemental lessons from the broader curriculum (typically from `phases/`) that provide advanced context but are not required for certification completion.

### Can I use these JSON files to generate a custom study schedule?

Yes. The `studyPlans` array provides suggested schedules with `durationDays`, `hoursPerWeek`, and specific `milestones`. You can parse these programmatically (using Python, TypeScript, or jq) to generate calendar integrations, progress trackers, or personalized study applications based on the official curriculum structure.

### Where are the actual exam questions stored?

The track manifests do not contain exam questions. They reference assessment metadata through the `assessments` array, which points to separate JSON files in `certifications/claude/assessments/` (e.g., [`ccdv-f/diagnostic.json`](https://github.com/rohitg00/ai-engineering-from-scratch/blob/main/ccdv-f/diagnostic.json)). These assessment files contain the actual question banks and scoring logic for diagnostic and mock exams.