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

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 or 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.

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:

{
  "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

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

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

#!/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: Claude Certified Developer - Foundations (entry-level technical certification)
• ccar-p.json: Claude Certified Architect - Professional (advanced architecture patterns)
• ccar-f.json: Claude Certified Architect - Foundations (introductory architecture concepts)
• 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, ccar-p.json, ccar-f.json, 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, 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). These assessment files contain the actual question banks and scoring logic for diagnostic and mock exams.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}