Curriculum Structure

Understanding the 4-week FHEVM Bootcamp curriculum architecture, data model, and content organization

Overview

The FHEVM Bootcamp curriculum is a comprehensive 4-week program designed to onboard developers into confidential computing with Fully Homomorphic Encryption (FHE) at scale. The curriculum follows a structured progression from foundational concepts to advanced real-world applications.

4 Weeks

Structured learning path covering FHE fundamentals to production deployment

TypeScript-First

Entire curriculum defined in TypeScript for type safety and IDE support

Multi-Modal

Text, code, video, interactive components, quizzes, and hands-on homework

Instructor-Ready

Built-in instructor notes, pacing guides, and facilitation tips

Curriculum Data Model

The curriculum is defined in src/data/curriculum.ts using a strongly-typed TypeScript structure. This ensures consistency and enables powerful IDE features.

Core Types

src/data/curriculum.ts

export interface Curriculum {
  title: string;
  description: string;
  targetAudience: string[];
  prerequisites: string[];
  weeks: Week[];
}

export interface Week {
  id: string;              // e.g. 'week-1'
  number: number;          // 1-4
  title: string;
  subtitle: string;
  objectives: string[];    // Learning outcomes for the week
  lessons: Lesson[];
  homework: Homework;
  milestone: string;       // What students should accomplish
  estimatedHours: number;
}

Lesson Structure

Each lesson contains multiple sections with different content types:

src/data/curriculum.ts

export interface Lesson {
  id: string;
  title: string;
  description: string;
  estimatedMinutes: number;
  icon: string;                // Lucide icon name
  sections: Section[];
  quiz?: Quiz;
  instructorNotes: string[];
  codeTemplate?: CodeTemplate;
  objectives: string[];        // Specific learning objectives
}

Week-by-Week Structure

The bootcamp follows a progressive learning path:

1. Week 1: Foundations of Confidential Computing

   • Focus: Understand FHE, set up tooling, grasp FHEVM architecture
   • Lessons: 3 lessons covering FHE fundamentals, environment setup, and deep dive
   • Estimated Hours: 8 hours
   • Milestone: Working dev environment with wallet connected to Sepolia
2. Week 2: FHEVM Smart Contract Development

   • Focus: Write, test, and deploy confidential smart contracts
   • Lessons: Hands-on contract development and testing
   • Estimated Hours: 10 hours
   • Milestone: Deployed and tested EncryptedCounter contract on Sepolia
3. Week 3: Building Confidential dApps

   • Focus: Frontend integration, decryption flows, and UX patterns
   • Lessons: Full-stack dApp development with FHEVM
   • Estimated Hours: 12 hours
   • Milestone: Working confidential voting dApp
4. Week 4: Production & Advanced Patterns

   • Focus: Gas optimization, security, testing, and deployment
   • Lessons: Production-ready patterns and best practices
   • Estimated Hours: 12 hours
   • Milestone: Production-grade confidential application deployed

Section Types

The curriculum supports diverse content types through the Section interface:

src/data/curriculum.ts

export interface Section {
  id: string;
  title: string;
  type: 'text' | 'code' | 'interactive' | 'video' | 'diagram' | 'quiz';
  content: string[];       // Paragraphs of text
  code?: CodeSnippet;
  tips?: string[];
  keyPoints?: string[];
  videoId?: string;        // YouTube video ID
  diagramCode?: string;    // Mermaid diagram syntax
  componentId?: string;    // Reference to interactive component
}

Content Type Examples

Text Sections

Standard explanatory content with support for markdown-style formatting:

• Multiple paragraphs in content array
• Optional keyPoints for callouts
• Optional tips for practical advice

Code Sections

Syntax-highlighted code with context:

code: {
  language: 'solidity',
  code: '// SPDX-License-Identifier: MIT\npragma solidity ^0.8.24;...',
  filename: 'EncryptedCounter.sol',
  description: 'A contract with encrypted state'
}

Video Sections

Embedded YouTube videos with responsive iframe:

type: 'video',
videoId: '1FtbyHZwNX4',  // YouTube video ID

Diagram Sections

Mermaid diagrams rendered client-side:

type: 'diagram',
diagramCode: `flowchart LR
  A["Client"] -->|"Encrypt"| B["Contract"]
  B -->|"Compute"| C["Result"]`

Interactive Sections

Custom React components for hands-on learning:

type: 'interactive',
componentId: 'fhe-basics-contracts',  // Maps to ContractExplorer

Accessing Curriculum Data

The curriculum is exported from src/data/curriculum.ts and consumed throughout the application:

src/state/bootcampStore.ts

import { curriculum, getTotalLessons, getAllLessonIds } from '@/data/curriculum';

// Access weeks
curriculum.weeks.forEach((week) => {
  console.log(week.title, week.lessons.length);
});

// Helper functions
const totalLessons = getTotalLessons();  // Count all lessons
const allIds = getAllLessonIds();        // Get all week/lesson ID pairs

Helper Functions

The curriculum module provides utility functions for navigation:

src/data/curriculum.ts

// Get specific week by ID
export function getWeekById(weekId: string, curriculum: Curriculum): Week | undefined

// Get specific lesson by ID
export function getLessonById(weekId: string, lessonId: string, curriculum: Curriculum): Lesson | undefined

// Get next lesson in sequence
export function getNextLesson(weekId: string, lessonId: string, curriculum: Curriculum)

// Get previous lesson
export function getPrevLesson(weekId: string, lessonId: string, curriculum: Curriculum)

Target Audience

The curriculum is designed for:

Target Audiences

curriculum.targetAudience = [
  'Web3 developers with basic Ethereum and Solidity knowledge',
  'Smart contract developers looking to add privacy-preserving capabilities',
  'Technical educators and community leaders planning to run FHEVM workshops',
]

Curriculum Flexibility

The TypeScript-based curriculum structure makes it easy to:

• Add new weeks or lessons by following the type structure
• Reorder content by changing array positions
• Internationalize by connecting to translation keys
• Customize for different audiences or pacing

Real Example: Week 1, Lesson 1

Here’s how “Welcome to FHEVM” is structured:

src/data/curriculum.ts

{
  id: 'welcome-to-fhevm',
  title: 'Welcome to FHEVM',
  description: 'Introduction to FHE, the Zama Protocol, and real-world use cases',
  estimatedMinutes: 30,
  icon: 'Home',
  objectives: [
    'Define Fully Homomorphic Encryption in your own words',
    'Explain how FHEVM brings FHE to Ethereum',
    'Identify 3+ real-world use cases for confidential computing',
  ],
  sections: [
    {
      id: 'week1-video',
      title: 'Video: Introduction to Confidential Smart Contracts',
      type: 'video',
      videoId: '1FtbyHZwNX4',
      content: ['Watch this Zama tutorial...']
    },
    {
      id: 'what-is-fhe',
      title: 'What is Fully Homomorphic Encryption?',
      type: 'text',
      content: ['FHE allows computation on encrypted data...'],
      keyPoints: [
        'Compute on encrypted data without decryption',
        'Results remain encrypted until explicitly revealed'
      ]
    }
  ],
  quiz: { /* Quiz definition */ },
  instructorNotes: [
    'Start with the "why": show a token transfer on Etherscan',
    'The HTTPS analogy is your best friend'
  ]
}

The curriculum structure balances rigidity (enforced types, required fields) with flexibility (optional quizzes, varied section types, customizable content).

Next Steps

Lessons

Deep dive into lesson structure, sections, and learning objectives

Quizzes

Explore the quiz system, question types, and scoring

Homework

Learn about homework assignments and grading rubrics

Progress Tracking

Understand how progress is persisted and tracked