168  IoT Architecture Quiz and Game

168.1 Learning Objectives

By the end of this chapter, you will be able to:

• Demonstrate comprehension: Answer questions about IoT reference model layers and data flow
• Apply layer knowledge: Correctly categorize IoT components by architectural layer
• Analyze scenarios: Identify which layers are involved in specific IoT operations
• Synthesize understanding: Complete multi-level challenges testing comprehensive architecture knowledge

168.2 Introduction

This chapter provides interactive assessments to test and reinforce your understanding of IoT reference models. Complete the quiz first to identify knowledge gaps, then use the game to practice component categorization.

TipFor Beginners: How to Use This Chapter

1. Take the quiz first - Answer all questions without looking at notes
2. Review explanations - Read the detailed feedback for each question
3. Play the game - Reinforce learning through interactive practice
4. Retry if needed - Both activities can be repeated for mastery

168.3 Interactive Quiz: Test Your Understanding

Test your knowledge of IoT reference models with this interactive auto-grading quiz.

viewof q1 = Inputs.radio([
  "Level 1 - Physical devices measure temperature",
  "Level 3 - Edge gateway performs threshold checking",
  "Level 5 - Cloud database stores the event",
  "Level 7 - Humans receive the alert"
], {
  label: "1. A smart factory temperature sensor detects overheating (>150F) and triggers an immediate shutdown. Which layer performs the time-critical decision?",
  value: null
})

viewof q2 = Inputs.radio([
  "All sensors send directly to cloud (no layers 3-5)",
  "Raw sensor data flows through all 7 layers sequentially",
  "Layer 3 filters, Layer 4 stores, Layer 5 provides unified API",
  "Only Layer 1 and Layer 6 are needed"
], {
  label: "2. A building automation system has 500 sensors from 3 vendors (Zigbee, BACnet, Wi-Fi). How should Layers 3-5 handle this heterogeneity?",
  value: null
})

viewof q3 = Inputs.radio([
  "Layer 1: sensor -> Layer 2: Wi-Fi -> Layer 6: dashboard",
  "Layer 1: sensor -> Layer 3: edge -> Layer 4: database -> Layer 5: API -> Layer 6: app",
  "Layer 1: sensor -> Layer 7: cloud -> Layer 6: app",
  "Layers don't matter for simple systems"
], {
  label: "3. A smart home thermostat reads temperature and displays on an app. What's the minimal complete data flow through reference model layers?",
  value: null
})

viewof q4 = Inputs.radio([
  "IoT-A - Focus on virtual entities and digital twins",
  "Cisco 7-level - Most granular, best for learning layers",
  "ITU-T - Telecom-focused, good for network operators",
  "All models are equivalent, choice doesn't matter"
], {
  label: "4. An electric utility needs to create digital twins of transformers and substations. Which reference model best supports this requirement?",
  value: null
})

viewof q5 = Inputs.radio([
  "Bandwidth cost: $5K-50K/month, compliance failure, brittle integrations",
  "No problems - layers 3-5 are optional optimizations",
  "Slight performance degradation, easily resolved",
  "Only affects systems with >10,000 sensors"
], {
  label: "5. Your IoT system has Layer 1 (sensors) and Layer 6 (dashboard) but skips Layers 3-5. What happens when you scale to 1000 sensors?",
  value: null
})

viewof checkBtn = Inputs.button("Check Answers")

results = {
  checkBtn;

  const correct = {
    q1: "Level 3 - Edge gateway performs threshold checking",
    q2: "Layer 3 filters, Layer 4 stores, Layer 5 provides unified API",
    q3: "Layer 1: sensor -> Layer 3: edge -> Layer 4: database -> Layer 5: API -> Layer 6: app",
    q4: "IoT-A - Focus on virtual entities and digital twins",
    q5: "Bandwidth cost: $5K-50K/month, compliance failure, brittle integrations"
  };

  const answers = {q1, q2, q3, q4, q5};
  let score = 0;
  let feedback = [];

  Object.keys(correct).forEach(q => {
    if (answers[q] === correct[q]) {
      score++;
      feedback.push(`Correct! Question ${q.substring(1)}:`);
    } else {
      feedback.push(`Incorrect. Question ${q.substring(1)}:`);
    }
  });

  const explanations = {
    q1: "LEVEL 3 (Edge Computing) performs time-critical threshold checking. The temperature sensor (L1) sends readings through network (L2) to edge gateway (L3), which detects >150F and immediately sends shutdown command - all within 50ms locally. If this went to cloud (L4-L6), the 200-500ms round-trip would allow equipment damage. Edge computing is specifically designed for real-time local decisions that cannot tolerate cloud latency. Only after shutdown does the event get logged to cloud (L4-L7) for analysis and human notification.",
    q2: "LAYER 3 filters (aggregates 500 sensors to 50 zones), LAYER 4 stores in appropriate databases (time-series for trends, SQL for events), LAYER 5 provides unified REST API that abstracts vendor differences. Without L3: 500 sensors x 1 reading/sec = overwhelming cloud traffic. Without L4: no historical data for analytics/compliance. Without L5: dashboard must know Zigbee packet format, BACnet format, MQTT topics - adding a 4th vendor requires rewriting dashboard code. L5's abstraction means adding vendors only requires writing one adapter class, not changing every application.",
    q3: "Minimal COMPLETE flow requires L1 to L2 to L3 to L4 to L5 to L6. L2 (Connectivity) transmits data via Wi-Fi/Zigbee. L3 (Edge) may do local filtering. L4 (Data Accumulation) stores readings for history. L5 (Data Abstraction) provides API for app to query. L6 (Application) displays dashboard. Skipping L3-L5 works for demos but fails in production: no historical data (L4), direct sensor queries overwhelm devices, adding sensors breaks apps (no L5 abstraction). L7 (Collaboration) only needed when humans must coordinate actions.",
    q4: "IoT-A REFERENCE MODEL excels at digital twins through its Virtual Entity Layer, which explicitly maps physical devices (transformers) to software representations with synchronized state. The service organization layer then orchestrates complex operations across multiple digital twins. Cisco 7-level is best for learning layer functions but lacks explicit digital twin abstraction. ITU-T is telecom-focused. The EU smart grid case study showed IoT-A enabled 42% reduction in transformer failures through predictive digital twin simulations.",
    q5: "Missing L3/L4/L5 causes CATASTROPHIC scaling problems: (1) No L3: 1000 sensors x 1 msg/sec x cellular = $5K-10K/month bandwidth costs, plus 200-500ms latency makes real-time control impossible. (2) No L4: No historical data = compliance failure (FDA/GDPR require years of retention), no analytics ('what was temp last Tuesday?'). (3) No L5: Every sensor type requires custom dashboard code - adding LoRaWAN to Zigbee system = 4-6 weeks of manual integration. These layers aren't optional optimizations - they're what makes IoT scalable beyond 50-sensor pilot projects to production deployments."
  };

  return {score, total: 5, feedback, explanations, answers, correct};
}

md`### Results: ${results.score}/${results.total} Correct

${results.feedback.map((f, i) => `
${f}

**Explanation:** ${results.explanations[Object.keys(results.explanations)[i]]}

`).join('\n---\n\n')}`

---

168.4 Architecture Layer Builder Game

NoteHow to Play

Build a complete IoT architecture by placing components in the correct layer! Each component belongs to one of four layers: Device/Perception, Network/Gateway, Processing/Cloud, or Application. Place all components correctly to complete each level.

Controls:

• Click on a component in the “Available Components” area
• Click on a layer to place it there
• Green feedback = correct placement, Red = incorrect
• Complete all 3 levels with increasing difficulty!

viewof gameState = {
  const initialState = {
    currentLevel: 1,
    score: 0,
    totalPlaced: 0,
    selectedComponent: null,
    placedComponents: {
      device: [],
      network: [],
      cloud: [],
      application: []
    },
    feedback: null,
    levelComplete: false,
    gameComplete: false
  };

  return Inputs.input(initialState);
}

// Component definitions for all levels
componentDatabase = ({
  // Level 1: Basic components (6 components)
  level1: [
    { id: "temp-sensor", name: "Temperature Sensor", layer: "device", icon: "T", description: "Measures ambient temperature" },
    { id: "wifi-module", name: "Wi-Fi Module", layer: "network", icon: "W", description: "Wireless connectivity" },
    { id: "time-series-db", name: "Time-Series DB", layer: "cloud", icon: "DB", description: "Stores sensor data over time" },
    { id: "dashboard", name: "Dashboard", layer: "application", icon: "D", description: "Visualizes data for users" },
    { id: "mcu", name: "Microcontroller (MCU)", layer: "device", icon: "M", description: "Processes sensor data locally" },
    { id: "mqtt-broker", name: "MQTT Broker", layer: "network", icon: "Q", description: "Message queue for IoT" }
  ],
  // Level 2: Intermediate components (10 components)
  level2: [
    { id: "accelerometer", name: "Accelerometer", layer: "device", icon: "A", description: "Measures motion/vibration" },
    { id: "actuator", name: "Actuator/Motor", layer: "device", icon: "G", description: "Physical output device" },
    { id: "battery", name: "Battery Module", layer: "device", icon: "B", description: "Power source for devices" },
    { id: "lora-gateway", name: "LoRa Gateway", layer: "network", icon: "L", description: "Long-range wireless gateway" },
    { id: "edge-gateway", name: "Edge Gateway", layer: "network", icon: "E", description: "Local processing hub" },
    { id: "stream-processor", name: "Stream Processor", layer: "cloud", icon: "S", description: "Real-time data processing" },
    { id: "ml-engine", name: "ML Engine", layer: "cloud", icon: "ML", description: "Machine learning inference" },
    { id: "mobile-app", name: "Mobile App", layer: "application", icon: "P", description: "User mobile interface" },
    { id: "alert-service", name: "Alert Service", layer: "application", icon: "!", description: "Notification system" },
    { id: "analytics-tool", name: "Analytics Tool", layer: "application", icon: "C", description: "Data analysis interface" }
  ],
  // Level 3: Advanced components (12 components)
  level3: [
    { id: "pressure-sensor", name: "Pressure Sensor", layer: "device", icon: "P", description: "Measures pressure/force" },
    { id: "humidity-sensor", name: "Humidity Sensor", layer: "device", icon: "H", description: "Measures moisture levels" },
    { id: "gps-module", name: "GPS Module", layer: "device", icon: "G", description: "Location tracking" },
    { id: "zigbee-coordinator", name: "Zigbee Coordinator", layer: "network", icon: "Z", description: "Mesh network hub" },
    { id: "protocol-translator", name: "Protocol Translator", layer: "network", icon: "T", description: "Converts between protocols" },
    { id: "vpn-gateway", name: "VPN Gateway", layer: "network", icon: "V", description: "Secure network tunnel" },
    { id: "api-gateway", name: "API Gateway", layer: "cloud", icon: "A", description: "REST API endpoint" },
    { id: "data-lake", name: "Data Lake", layer: "cloud", icon: "L", description: "Raw data storage" },
    { id: "event-hub", name: "Event Hub", layer: "cloud", icon: "E", description: "Event ingestion service" },
    { id: "web-portal", name: "Web Portal", layer: "application", icon: "W", description: "Browser-based interface" },
    { id: "automation-engine", name: "Automation Engine", layer: "application", icon: "R", description: "Rule-based automation" },
    { id: "reporting-service", name: "Reporting Service", layer: "application", icon: "R", description: "Generate reports" }
  ]
})

// Get components for current level
currentLevelComponents = {
  const level = gameState.currentLevel;
  if (level === 1) return componentDatabase.level1;
  if (level === 2) return componentDatabase.level2;
  return componentDatabase.level3;
}

// Layer definitions with colors
layerDefinitions = [
  { id: "device", name: "Layer 1: Device/Perception", color: "#16A085", description: "Physical sensors, actuators, MCUs, power" },
  { id: "network", name: "Layer 2: Network/Gateway", color: "#27AE60", description: "Connectivity, protocols, gateways, brokers" },
  { id: "cloud", name: "Layer 3: Processing/Cloud", color: "#2980B9", description: "Storage, processing, ML, APIs" },
  { id: "application", name: "Layer 4: Application", color: "#8E44AD", description: "Dashboards, apps, alerts, analytics" }
]

// Check if component placement is correct
checkPlacement = (componentId, targetLayer) => {
  const component = currentLevelComponents.find(c => c.id === componentId);
  return component && component.layer === targetLayer;
}

// Calculate available (unplaced) components
availableComponents = {
  const placed = [
    ...gameState.placedComponents.device,
    ...gameState.placedComponents.network,
    ...gameState.placedComponents.cloud,
    ...gameState.placedComponents.application
  ];
  return currentLevelComponents.filter(c => !placed.includes(c.id));
}

// Check if level is complete
isLevelComplete = availableComponents.length === 0 &&
  (gameState.placedComponents.device.length +
   gameState.placedComponents.network.length +
   gameState.placedComponents.cloud.length +
   gameState.placedComponents.application.length) === currentLevelComponents.length

// Game UI
html`
<div style="font-family: system-ui, -apple-system, sans-serif; max-width: 900px; margin: 0 auto;">

  <!-- Header with Score and Level -->
  <div style="display: flex; justify-content: space-between; align-items: center; padding: 15px; background: linear-gradient(135deg, #2C3E50, #34495E); color: white; border-radius: 10px; margin-bottom: 20px;">
    <div>
      <span style="font-size: 1.4em; font-weight: bold;">Level ${gameState.currentLevel} of 3</span>
      <span style="margin-left: 15px; opacity: 0.9;">
        ${gameState.currentLevel === 1 ? "Basic Components" : gameState.currentLevel === 2 ? "Intermediate" : "Advanced"}
      </span>
    </div>
    <div style="text-align: right;">
      <div style="font-size: 1.2em;">Score: <strong>${gameState.score}</strong></div>
      <div style="font-size: 0.9em; opacity: 0.8;">
        ${availableComponents.length} components remaining
      </div>
    </div>
  </div>

  <!-- Feedback Message -->
  ${gameState.feedback ? html`
    <div style="padding: 12px 20px; margin-bottom: 15px; border-radius: 8px; text-align: center; font-weight: 500;
      background: ${gameState.feedback.correct ? '#d4edda' : '#f8d7da'};
      color: ${gameState.feedback.correct ? '#155724' : '#721c24'};
      border: 1px solid ${gameState.feedback.correct ? '#c3e6cb' : '#f5c6cb'};">
      ${gameState.feedback.correct ? 'Correct! ' : 'Not quite. '}${gameState.feedback.message}
    </div>
  ` : ''}

  <!-- Level Complete Message -->
  ${isLevelComplete ? html`
    <div style="padding: 20px; margin-bottom: 20px; background: linear-gradient(135deg, #27ae60, #2ecc71); color: white; border-radius: 10px; text-align: center;">
      <div style="font-size: 1.5em; margin-bottom: 10px;">Level ${gameState.currentLevel} Complete!</div>
      <div style="margin-bottom: 15px;">You correctly placed all ${currentLevelComponents.length} components!</div>
      ${gameState.currentLevel < 3 ? html`
        <button onclick=${() => {
          gameState.currentLevel = gameState.currentLevel + 1;
          gameState.placedComponents = { device: [], network: [], cloud: [], application: [] };
          gameState.feedback = null;
          gameState.selectedComponent = null;
        }} style="padding: 12px 30px; font-size: 1.1em; background: white; color: #27ae60; border: none; border-radius: 25px; cursor: pointer; font-weight: bold;">
          Next Level
        </button>
      ` : html`
        <div style="font-size: 1.3em; margin-top: 10px;">Congratulations! You've mastered IoT Architecture Layers!</div>
        <div style="margin-top: 10px;">Final Score: <strong>${gameState.score}</strong> points</div>
      `}
    </div>
  ` : ''}

  <!-- Available Components Section -->
  <div style="background: #f8f9fa; padding: 20px; border-radius: 10px; margin-bottom: 20px; border: 2px solid #dee2e6;">
    <h4 style="margin: 0 0 15px 0; color: #2C3E50;">
      Available Components
      <span style="font-weight: normal; font-size: 0.9em; color: #666;">
        (Click to select, then click a layer to place)
      </span>
    </h4>
    <div style="display: flex; flex-wrap: wrap; gap: 10px; min-height: 60px;">
      ${availableComponents.length === 0 ? html`
        <div style="color: #666; font-style: italic; padding: 20px;">
          All components placed! ${isLevelComplete ? "Level complete!" : ""}
        </div>
      ` : availableComponents.map(comp => html`
        <div
          onclick=${() => {
            gameState.selectedComponent = gameState.selectedComponent === comp.id ? null : comp.id;
            gameState.feedback = null;
          }}
          style="
            padding: 10px 15px;
            background: ${gameState.selectedComponent === comp.id ? '#3498db' : 'white'};
            color: ${gameState.selectedComponent === comp.id ? 'white' : '#2C3E50'};
            border: 2px solid ${gameState.selectedComponent === comp.id ? '#2980b9' : '#bdc3c7'};
            border-radius: 8px;
            cursor: pointer;
            transition: all 0.2s;
            display: flex;
            align-items: center;
            gap: 8px;
            font-size: 0.95em;
          "
          title="${comp.description}"
        >
          <span style="font-size: 1.3em; font-weight: bold;">[${comp.icon}]</span>
          <span>${comp.name}</span>
        </div>
      `)}
    </div>
    ${gameState.selectedComponent ? html`
      <div style="margin-top: 15px; padding: 10px; background: #e8f4fd; border-radius: 6px; border-left: 4px solid #3498db;">
        <strong>Selected:</strong> ${currentLevelComponents.find(c => c.id === gameState.selectedComponent)?.name}
        - <em>${currentLevelComponents.find(c => c.id === gameState.selectedComponent)?.description}</em>
      </div>
    ` : ''}
  </div>

  <!-- Architecture Layers -->
  <div style="display: flex; flex-direction: column; gap: 15px;">
    ${layerDefinitions.map(layer => {
      const placedInLayer = gameState.placedComponents[layer.id] || [];
      const componentsInLayer = currentLevelComponents.filter(c => placedInLayer.includes(c.id));

      return html`
        <div
          onclick=${() => {
            if (gameState.selectedComponent) {
              const isCorrect = checkPlacement(gameState.selectedComponent, layer.id);
              if (isCorrect) {
                gameState.placedComponents[layer.id] = [...placedInLayer, gameState.selectedComponent];
                gameState.score = gameState.score + 10;
                gameState.feedback = {
                  correct: true,
                  message: `${currentLevelComponents.find(c => c.id === gameState.selectedComponent)?.name} belongs in ${layer.name}`
                };
              } else {
                gameState.score = Math.max(0, gameState.score - 5);
                gameState.feedback = {
                  correct: false,
                  message: `${currentLevelComponents.find(c => c.id === gameState.selectedComponent)?.name} doesn't belong in ${layer.name}. Try another layer!`
                };
              }
              if (isCorrect) {
                gameState.selectedComponent = null;
              }
            }
          }}
          style="
            padding: 20px;
            background: linear-gradient(135deg, ${layer.color}15, ${layer.color}08);
            border: 3px solid ${layer.color};
            border-radius: 12px;
            cursor: ${gameState.selectedComponent ? 'pointer' : 'default'};
            transition: all 0.2s;
            ${gameState.selectedComponent ? `box-shadow: 0 0 0 3px ${layer.color}40;` : ''}
          "
        >
          <div style="display: flex; justify-content: space-between; align-items: center; margin-bottom: 12px;">
            <h4 style="margin: 0; color: ${layer.color}; font-size: 1.1em;">
              ${layer.name}
            </h4>
            <span style="font-size: 0.85em; color: #666; background: white; padding: 4px 10px; border-radius: 15px;">
              ${componentsInLayer.length} placed
            </span>
          </div>
          <div style="font-size: 0.9em; color: #666; margin-bottom: 12px; font-style: italic;">
            ${layer.description}
          </div>
          <div style="display: flex; flex-wrap: wrap; gap: 8px; min-height: 45px; padding: 10px; background: white; border-radius: 8px; border: 1px dashed #ccc;">
            ${componentsInLayer.length === 0 ? html`
              <span style="color: #aaa; font-size: 0.9em;">
                ${gameState.selectedComponent ? 'Click here to place component' : 'Drop components here...'}
              </span>
            ` : componentsInLayer.map(comp => html`
              <div style="
                padding: 6px 12px;
                background: ${layer.color};
                color: white;
                border-radius: 6px;
                font-size: 0.9em;
                display: flex;
                align-items: center;
                gap: 6px;
              ">
                <span>[${comp.icon}]</span>
                <span>${comp.name}</span>
              </div>
            `)}
          </div>
        </div>
      `;
    })}
  </div>

  <!-- Reset Button -->
  <div style="text-align: center; margin-top: 25px;">
    <button onclick=${() => {
      gameState.currentLevel = 1;
      gameState.score = 0;
      gameState.placedComponents = { device: [], network: [], cloud: [], application: [] };
      gameState.feedback = null;
      gameState.selectedComponent = null;
    }} style="padding: 10px 25px; background: #95a5a6; color: white; border: none; border-radius: 6px; cursor: pointer; font-size: 1em;">
      Reset Game
    </button>
  </div>
</div>
`

TipGame Learning Objectives

After completing all three levels of the Architecture Layer Builder Game, you should be able to:

1. Identify Device Layer Components: Recognize that sensors (temperature, pressure, humidity), actuators, MCUs, batteries, and GPS modules belong at the perception/device layer where physical-world interaction occurs.

2. Classify Network Layer Components: Understand that Wi-Fi modules, LoRa gateways, MQTT brokers, Zigbee coordinators, protocol translators, and VPN gateways handle connectivity and data transmission between devices and cloud.

3. Recognize Cloud/Processing Layer Components: Know that time-series databases, stream processors, ML engines, API gateways, data lakes, and event hubs provide storage, processing, and data transformation in the cloud tier.

4. Categorize Application Layer Components: Identify that dashboards, mobile apps, alert services, analytics tools, web portals, automation engines, and reporting services serve end-users and business logic.

Key Insight: The same data flows through all four layers, gaining value at each step:

• Device: Raw sensor readings (25.3C)
• Network: Formatted and transmitted (JSON over MQTT)
• Cloud: Stored, processed, analyzed (trend detection)
• Application: Presented to users (“Temperature rising - check HVAC”)

---

168.5 Knowledge Check: Data Flow Patterns

NoteSouthbound Control Flow

{
  const container = document.getElementById('kc-arch-12');
  if (container && typeof InlineKnowledgeCheck !== 'undefined') {
    container.innerHTML = '';
    container.appendChild(InlineKnowledgeCheck.create({
      question: "In an IoT smart home system, a user taps 'turn on lights' in their mobile app. Trace the data flow: which layers are involved in the SOUTHBOUND (control) direction, and in what order?",
      options: [
        {text: "L1 (sensor) -> L2 (network) -> L6 (app) -> L7 (user)", correct: false, feedback: "This describes NORTHBOUND (sensing) data flow. Southbound control flows in the opposite direction - from user decision to actuator action."},
        {text: "L7 (user) -> L6 (app) -> L5 (API) -> L3 (edge) -> L2 (network) -> L1 (actuator)", correct: true, feedback: "Correct! Southbound control flow: User decides (L7) -> App sends command (L6) -> API validates/translates (L5) -> Edge gateway routes command (L3) -> Network delivers (L2) -> Light actuator activates (L1). Note that L4 (storage) logs the event but isn't in the critical control path."},
        {text: "L6 (app) -> L4 (database) -> L1 (actuator)", correct: false, feedback: "This skips critical layers. L5 abstraction is needed to translate app requests to device commands. L2 connectivity is needed to actually deliver the command. L3 may validate the command locally."},
        {text: "L7 (user) -> L1 (actuator) directly via local network", correct: false, feedback: "Direct L7->L1 bypasses all architectural layers. In practice, commands flow through apps (L6), APIs (L5), and network infrastructure (L2-L3) for security, validation, and routing."}
      ],
      difficulty: "medium",
      topic: "data-flow-patterns"
    }));
  }
}

168.6 Summary

This chapter provided two interactive assessments to reinforce your IoT architecture knowledge:

Interactive Quiz (5 Questions):

• Tested understanding of layer responsibilities
• Covered edge vs cloud processing decisions
• Explored reference model selection criteria
• Examined scaling consequences of skipping layers

Architecture Layer Builder Game (3 Levels):

• Level 1: Basic components (sensors, databases, dashboards)
• Level 2: Intermediate (gateways, ML engines, mobile apps)
• Level 3: Advanced (protocol translators, data lakes, automation)

Key Takeaways:

1. Layer 3 (Edge) handles time-critical decisions that cannot tolerate cloud latency
2. Layer 5 (Abstraction) enables vendor-agnostic applications
3. Skipping layers creates technical debt that compounds at scale
4. Component placement follows clear patterns: physical things at L1, connectivity at L2, storage/processing at L3-4, user interfaces at L6

168.7 What’s Next

Put your knowledge into practice:

• Hands-On Lab - Build a working multi-layer IoT demo with ESP32
• Interview Preparation - Review scenario-based questions