Best Practices & Checklist

This final lesson consolidates everything into an actionable deployment checklist, covers the often-overlooked topics of power consumption and thermal management, provides a hardware selection guide, and answers the most common questions engineers ask when deploying AI on edge devices in production.

Edge AI Deployment Checklist

Use this checklist before shipping edge AI to production. Each item maps to a lesson in this course:

Model (Lessons 1-2)

• Model optimized for target hardware — quantized to INT8, pruned if needed, size under hardware RAM limit
• Accuracy validated post-optimization — tested on held-out data, accuracy within 2% of cloud model
• Fallback models prepared — primary + fallback + minimal models packaged and tested
• Input preprocessing matches training — same resize, normalize, color space as training pipeline
• Output post-processing tested — dequantization, NMS (for detection), label mapping verified

Runtime (Lesson 3)

• Correct runtime selected for hardware — TFLite for ARM/Coral, TensorRT for Jetson, CoreML for Apple
• Benchmarked under sustained load — p95 latency measured over 1 hour, not just cold-start
• Memory profiled — peak RAM usage during inference measured and under device limit
• Thread count optimized — tested 1, 2, 4 threads; more is not always faster
• Hardware accelerator delegate enabled — EdgeTPU, NNAPI, GPU delegate configured and tested

Connectivity (Lessons 4-5)

• Offline operation tested — device runs 7+ days without network, no data loss, no crashes
• OTA update pipeline tested — download-with-resume, integrity check, validation, atomic swap, rollback
• Data sync tested with poor connectivity — 50% packet loss, 500ms latency, intermittent drops
• Queue overflow handled — eviction policy for when local storage fills up
• Conflict resolution defined — strategy for each data type (append, LWW, server-wins, merge)

Fleet (Lesson 6)

• Device health monitoring active — CPU temp, RAM, disk, battery, inference metrics reported
• Alerts configured — offline detection, thermal warning, disk full, error spike
• Staged rollout plan ready — 1% canary, 10% early, 50% gradual, 100% full
• Rollback tested — auto-rollback on metric threshold, manual rollback, emergency fleet-wide rollback
• A/B testing framework ready — deterministic device assignment, metric collection, significance testing

Power Consumption Optimization

For battery-powered devices, power management is as important as model accuracy. Every milliwatt matters:

class PowerManager:
    """
    Manages power consumption on battery-powered edge devices.
    Goal: maximize battery life while maintaining AI functionality.
    """
    def __init__(self, battery_capacity_wh: float):
        self.battery_capacity_wh = battery_capacity_wh
        self.mode = "balanced"

    def get_power_profile(self, battery_percent: float) -> dict:
        """Adjust power profile based on remaining battery."""
        if battery_percent > 50:
            return {
                "mode": "performance",
                "inference_fps": 30,
                "cpu_governor": "performance",
                "wifi_interval_sec": 60,
                "display": "on",
                "camera_resolution": (1920, 1080),
            }
        elif battery_percent > 20:
            return {
                "mode": "balanced",
                "inference_fps": 10,
                "cpu_governor": "ondemand",
                "wifi_interval_sec": 300,
                "display": "dim",
                "camera_resolution": (1280, 720),
            }
        elif battery_percent > 5:
            return {
                "mode": "power_saver",
                "inference_fps": 2,
                "cpu_governor": "powersave",
                "wifi_interval_sec": 3600,
                "display": "off",
                "camera_resolution": (640, 480),
            }
        else:
            return {
                "mode": "critical",
                "inference_fps": 0,          # Stop inference
                "cpu_governor": "powersave",
                "wifi_interval_sec": 0,      # WiFi off
                "display": "off",
                "camera_resolution": None,   # Camera off
                "action": "hibernate",
            }

    def estimate_battery_life(self, power_watts: float) -> float:
        """Estimate remaining hours of operation."""
        if power_watts <= 0:
            return float('inf')
        return self.battery_capacity_wh / power_watts

    def apply_duty_cycling(self, motion_detected: bool,
                            inference_fn, frame) -> dict:
        """
        Only run inference when motion is detected.
        Saves 70-95% power in low-activity environments.
        """
        if motion_detected:
            result = inference_fn(frame)
            self.last_inference_time = time.time()
            return result
        else:
            # Return cached result or "no activity"
            return {"label": "no_motion", "confidence": 1.0, "power_saved": True}

Thermal Management

Edge devices in enclosures, outdoors, or running sustained inference overheat without proper thermal management:

class ThermalManager:
    """
    Monitor and manage device temperature to prevent throttling and damage.
    CPUs throttle at 80-85C. Components fail at 100C+.
    """
    THRESHOLDS = {
        "optimal": 55,      # Normal operating range
        "warm": 65,         # Start reducing workload
        "hot": 75,          # Significant throttling
        "critical": 85,     # Emergency shutdown path
    }

    def __init__(self):
        self.thermal_history = []

    def get_thermal_action(self, cpu_temp: float, gpu_temp: float = None) -> dict:
        max_temp = max(cpu_temp, gpu_temp or 0)
        self.thermal_history.append((time.time(), max_temp))

        if max_temp < self.THRESHOLDS["optimal"]:
            return {
                "action": "none",
                "inference_fps": 30,
                "fan_speed": 0,        # Fan off
                "cpu_throttle": False,
            }
        elif max_temp < self.THRESHOLDS["warm"]:
            return {
                "action": "fan_on",
                "inference_fps": 30,
                "fan_speed": 50,       # 50% fan
                "cpu_throttle": False,
            }
        elif max_temp < self.THRESHOLDS["hot"]:
            return {
                "action": "throttle",
                "inference_fps": 10,   # Reduce workload
                "fan_speed": 100,      # Full fan
                "cpu_throttle": True,
                "alert": f"Device warm: {max_temp}C",
            }
        elif max_temp < self.THRESHOLDS["critical"]:
            return {
                "action": "emergency_throttle",
                "inference_fps": 2,    # Minimal inference
                "fan_speed": 100,
                "cpu_throttle": True,
                "switch_model": "minimal",  # Use lightest model
                "alert": f"CRITICAL: Device at {max_temp}C",
            }
        else:
            return {
                "action": "shutdown",
                "inference_fps": 0,
                "alert": f"EMERGENCY: {max_temp}C - shutting down to prevent damage",
            }

# Hardware thermal design tips:
# 1. ALWAYS add a heatsink to Jetson/RPi (even passive = 10-15C cooler)
# 2. Use a fan for sustained workloads (active cooling = 20-25C cooler)
# 3. Outdoor enclosures: IP67 rating, ventilation slots, sun shield
# 4. Mount away from heat sources (motors, power supplies)
# 5. Use thermal paste between SoC and heatsink (comes pre-applied on most)
# 6. Test in worst-case ambient temperature (summer afternoon, direct sun)

Frequently Asked Questions

Course Summary

You now have everything you need to design, optimize, deploy, and manage AI on edge devices: