AI Coding Assistants 1
▼
Understands basic GitHub Copilot usage for IoT development: leveraging suggestions for device communication protocol code, using Copilot Chat for embedded library API questions, accepting completions for sensor data processing functions. Follows team guidelines for reviewing AI-generated firmware and edge code.
Independently configures GitHub Copilot for IoT workflows: crafts prompts for embedded communication protocol code, uses Copilot Chat for hardware abstraction layer questions, evaluates suggestion quality for resource-constrained environments. Understands trade-offs between AI-assisted development speed and embedded code safety requirements.
Designs GitHub Copilot adoption strategies for IoT teams: optimizes prompt engineering for embedded and communication protocol code, implements safety validation for AI-generated firmware components, evaluates Copilot limitations for resource-constrained targets. Mentors team on responsible AI-assisted embedded development.
Defines GitHub Copilot strategy at team/product level. Establishes standards and best practices. Conducts reviews.
Algorithms & Data Structures 2
▼
Understands basic algorithms and their complexity in the context of resource-constrained IoT devices. Chooses O(n) vs O(n²) algorithms considering RAM as low as 64 KB.
Applies efficient algorithms for IoT: Kalman filter, moving average, CRC. Optimizes algorithms to work without heap allocation on microcontrollers.
Designs algorithms for edge computing in IoT: anomaly detection, signal processing, data compression. Optimizes computational complexity for real-time processing.
Defines algorithmic standards for IoT platform. Builds a library of optimized algorithms for embedded. Conducts algorithmic efficiency reviews.
Uses basic data structures on IoT devices: arrays, ring buffers, linked lists. Understands heap limitations on MCUs and prefers static allocation.
Applies specialized structures for IoT: priority queues for event-driven systems, hash tables for device registry, bloom filters for edge filtering.
Designs custom data structures for IoT platform: lock-free queues for ISR, persistent storage structures for NVRAM, compact serialization formats.
Defines data structure standards for IoT platform. Builds a library of optimized structures for different MCU architectures and constraint levels.
API Gateway & Service Communication 1
▼
Understands webhooks for IoT: device event notifications, alerts. Implements simple webhook endpoints for receiving IoT events.
Designs webhook system for IoT platform: device event subscriptions, retry with exponential backoff, signature verification. Ensures reliable delivery.
Designs scalable webhook infrastructure for IoT: event fanout via SNS/SQS, dead letter queues, webhook analytics. Handles 10K+ events/sec.
Defines webhook standards for IoT platform. Establishes event catalog and subscription management for internal and external consumers.
API Protocols 1
▼
Understands WebSocket for IoT dashboards: real-time device data display. Implements simple WebSocket connection for live telemetry.
Designs WebSocket API for IoT: rooms/channels for device groups, heartbeat, reconnection logic. Ensures scalability through Redis pub/sub.
Designs real-time communication architecture for IoT: WebSocket for dashboards, MQTT bridge for devices. Ensures delivery guarantees and authorization.
Defines real-time communication standards for IoT platform. Establishes guidelines for WebSocket API and SSE usage in IoT context.
Application Security 2
▼
Understands OWASP IoT Top 10: weak passwords, insecure interfaces, lack of updates. Checks basic security vulnerabilities in IoT APIs.
Applies OWASP IoT Top 10 for security review of IoT products. Conducts security testing: protocol fuzzing, firmware analysis. Configures SAST for IoT code.
Designs security controls for IoT platform based on OWASP. Implements secure development lifecycle for IoT. Conducts threat modeling of IoT systems.
Defines OWASP security standards for the IoT organization. Establishes security training and awareness program for IoT engineers.
Understands basic secure coding concepts. Follows security guidelines. Recognizes typical code vulnerabilities.
Applies secure coding practices in daily work. Conducts security code review. Uses scanning and analysis tools.
Designs secure coding practices for IoT and embedded systems — implements memory-safe coding patterns for firmware, secure boot chain verification, and encrypted OTA update mechanisms. Conducts threat modeling for device-cloud communication and mentors team on writing security-hardened code for resource-constrained environments.
Defines secure coding strategy for IoT development spanning firmware, edge, and cloud components. Establishes security policies for embedded code review, secure boot implementation, and device provisioning security requirements. Coordinates IoT security incident response and trains teams on safety-critical secure coding practices.
Clean Code & Refactoring 1
▼
Follows coding standards for embedded IoT code. Uses clang-format and basic linting rules. Writes comments for hardware-specific code.
Applies static analysis (cppcheck, PC-lint) for IoT firmware. Configures MISRA C rules. Writes self-documenting embedded code with unit tests.
Designs code quality framework for IoT platform: static analysis, code coverage, complexity metrics. Implements quality gates in CI pipeline for firmware.
Defines code quality standards for the IoT team. Establishes coding guidelines, review checklists, and training. Coordinates tech debt reduction for firmware.
Code Review 1
▼
Understands basic code review for IoT code: reviewing firmware changes, checking sensor data handling logic, validating communication protocol implementations. Follows team review guidelines for embedded code quality.
Independently conducts code reviews for IoT code: evaluates firmware logic correctness, reviews sensor data processing efficiency, checks protocol implementation compliance. Provides constructive feedback on embedded code quality and resource usage patterns.
Designs code review processes for IoT systems: firmware code review standards, protocol compliance review checklists, resource usage review gates. Mentors team on reviewing embedded code for reliability and power efficiency.
Defines code review strategy for IoT team: firmware code review standards, protocol compliance review governance, embedded reliability review practices. Establishes review culture for IoT code quality across firmware and cloud components.
Concurrency & Parallelism 1
▼
Understands basic multithreading for IoT systems: concurrent task management on edge devices, basic synchronization for sensor data collection, understanding thread safety in device communication handlers. Follows team conventions for concurrent firmware and edge processing patterns.
Applies synchronization in IoT firmware: semaphores, event groups, message queues. Prevents deadlocks and race conditions. Profiles task stack usage.
Designs multitasking IoT firmware architecture: task decomposition, ISR-safe communication, priority scheme. Ensures deterministic timing for real-time tasks.
Defines multithreading best practices for IoT firmware. Establishes task architecture templates and concurrency guidelines for the team.
Distributed Tracing 1
▼
Understands basics of OpenTelemetry for IoT system observability. Follows team guidelines for instrumenting edge services and cloud processing pipelines with OTel SDK. Reads distributed traces to debug device-to-cloud communication latency and data ingestion issues.
Configures OpenTelemetry for IoT service observability — instruments edge gateways and cloud processing services with custom spans, creates dashboards for device-to-cloud latency and data pipeline throughput. Participates in IoT incident on-call and analyzes telemetry data for device connectivity and data ingestion failures.
Designs observability strategy for IoT ecosystems with OpenTelemetry — implements distributed tracing across edge devices, gateways, and cloud services. Defines SLI/SLO for device connectivity and data pipeline reliability. Conducts post-mortems for IoT platform incidents and architects telemetry collection for resource-constrained edge environments.
Defines product observability strategy for IoT platforms with OpenTelemetry. Establishes SLO-based approach for device connectivity and data pipeline reliability. Coordinates IoT incident management across edge and cloud teams. Optimizes MTTD/MTTR for IoT-specific failure modes.
Embedded Programming 2
▼
Writes simple C programs for ESP32/STM32 microcontrollers. Understands register operations, pointers, and basic memory management in embedded context.
Develops peripheral drivers and interrupt handlers in C for IoT devices. Uses DMA, timers, and watchdog. Optimizes RAM usage down to 64 KB.
Designs embedded firmware architecture in C for IoT gateways and edge devices. Implements OTA updates, secure boot, and fault-tolerant mechanisms. Optimizes power consumption for battery-powered devices.
Defines embedded C development standards for an IoT team of 10+ engineers. Establishes coding guidelines, HAL abstractions, and reusable libraries for the device lineup.
Writes MicroPython scripts for ESP32/ESP8266. Reads sensor data, controls GPIO, and sends data over WiFi. Uses REPL for rapid prototyping.
Develops production-ready IoT devices in MicroPython. Manages power consumption (deep sleep), uses asyncio for multitasking. Implements OTA script updates.
Designs MicroPython frameworks for rapid IoT device deployment. Writes C modules for performance-critical sections. Organizes fleet management for device fleet.
Defines strategy for MicroPython vs C/C++ usage across different IoT projects. Builds a library of reusable MicroPython modules for the team.
Git & Workflows 1
▼
Understands basic Git advanced features for IoT development: branching for firmware version management, cherry-pick for porting fixes across device-specific branches, submodules for shared embedded libraries. Follows team conventions for versioning firmware alongside cloud service code.
Independently uses Git advanced features for IoT projects: manages firmware branches per device family with submodules for shared HAL code, resolves conflicts in board configuration files, implements hooks for build system validation. Understands trade-offs between monorepo and multi-repo for firmware+cloud codebases.
Designs Git workflows for IoT teams: implements branching strategies for multi-device firmware management, optimizes submodule and LFS usage for hardware-specific codebases, automates firmware version tracking through Git tags and CI. Mentors team on managing embedded and cloud code in coordinated release cycles.
Defines Git Advanced strategy at team/product level. Establishes standards and best practices. Conducts reviews.
Hardware Interfaces 1
▼
Configures BLE advertising and scanning on ESP32 for IoT devices. Understands GATT profiles, characteristics, and services. Uses nRF Connect for BLE debugging.
Develops custom BLE GATT services for IoT devices. Optimizes connection interval and MTU for balancing power consumption and throughput. Implements BLE mesh.
Designs BLE architecture for IoT products with LoRaWAN, Zigbee, Thread support. Ensures compatibility with mobile applications. Implements BLE 5.x long range and coded PHY.
Defines wireless strategy for IoT products: BLE vs Zigbee vs Thread vs LoRaWAN. Establishes wireless security and testing standards for the team.
Integration Testing 1
▼
Understands basics of integration testing for IoT device-to-cloud communication. Writes simple tests verifying MQTT/CoAP message delivery and sensor data ingestion pipelines. Follows team testing guidelines for firmware-gateway integration validation.
Independently develops integration tests. Applies test design techniques. Integrates tests into CI/CD. Covers edge cases.
Designs integration testing strategy for IoT ecosystems spanning edge devices, gateways, and cloud platforms. Implements automated testing across firmware, protocol, and data pipeline layers with hardware-in-the-loop simulation. Optimizes test pyramid balancing device-level tests with fleet-scale integration validation. Mentors team on testing OTA update flows and device provisioning chains.
Defines integration testing strategy for IoT product lines spanning heterogeneous devices and cloud services. Establishes quality standards for device-cloud integration points including OTA update verification and telemetry pipeline validation. Implements shift-left testing culture with early validation of device protocol specifications and firmware-hardware compatibility.
IoT Platforms 2
▼
Understands edge computing concept for IoT: processing data on device instead of sending to cloud. Runs simple filters and aggregators on ESP32/Raspberry Pi.
Deploys edge computing on IoT gateways: AWS Greengrass, Azure IoT Edge. Implements local data processing and filtering. Synchronizes edge-cloud state.
Designs edge computing architecture for IoT: multi-tier (device → gateway → cloud). Implements ML inference on edge (TensorFlow Lite, ONNX). Enables OTA edge model updates.
Defines edge computing strategy: what to process on edge vs cloud. Establishes deployment and update standards for edge applications across the IoT device fleet.
Connects IoT devices to MQTT broker (Mosquitto). Publishes sensor data to topics and subscribes to commands. Understands QoS 0/1/2 and retained messages.
Designs MQTT topic hierarchy for IoT projects. Uses MQTT 5.0 features: shared subscriptions, message expiry. Configures TLS and client certificates for security.
Designs scalable MQTT infrastructure for IoT platform: EMQX/VerneMQ clustering, bridging, routing rules. Implements CoAP for constrained devices.
Defines messaging standards for IoT platform. Selects protocols (MQTT/AMQP/CoAP) for different scenarios. Establishes topic naming conventions and governance.
Memory Management 1
▼
Understands RAM/Flash limitations on IoT MCUs (64-256 KB RAM). Uses static allocation instead of malloc. Monitors heap and stack usage.
Optimizes IoT firmware memory layout: linker scripts, memory pools, stack sizing. Profiles memory usage through compiler reports and runtime monitoring.
Designs memory management strategy for IoT platform: memory budgets, fragmentation prevention, NVRAM management. Optimizes for multi-tenant edge.
Defines memory management standards for IoT products. Establishes memory budget templates and monitoring tools for the team.
Metrics & Monitoring 1
▼
Understands basic Prometheus & Grafana for IoT monitoring: reading device fleet dashboards, understanding telemetry metrics for device health tracking, navigating Grafana panels for connectivity and data ingestion rates. Follows team conventions for IoT infrastructure monitoring.
Configures Prometheus and Grafana for IoT fleet monitoring: implements custom metrics for device telemetry and connectivity, creates dashboards for fleet health and data ingestion rates, sets up alerts for device offline patterns and data loss. Analyzes device incidents using telemetry metric correlation.
Designs observability strategy for IoT platforms with Prometheus & Grafana: implements fleet-wide monitoring with device telemetry aggregation, defines SLI/SLO for device connectivity and data delivery, conducts post-mortems for fleet-wide incidents. Mentors team on IoT-specific monitoring patterns.
Defines observability strategy for IoT products with Prometheus & Grafana: establishes SLO-based approach for device fleet reliability, coordinates IoT incident management, optimizes MTTD/MTTR for device connectivity and data processing incidents.
Network Protocols 2
▼
Understands DNS role in IoT: cloud service name resolution, mDNS for local discovery. Configures DNS client on IoT devices.
Configures DNS strategies for IoT: DNS-over-TLS for security, failover DNS, caching on IoT gateway. Diagnoses DNS issues in IoT networks.
Designs DNS infrastructure for IoT platform: private DNS zones, DNS-based device routing, geo-DNS for multi-region IoT. Ensures DNS security (DNSSEC).
Defines DNS strategy for IoT infrastructure. Establishes naming conventions and DNS management for large-scale IoT deployments.
Understands differences between HTTP/1.1, HTTP/2, HTTP/3 for IoT. Uses HTTP/2 for REST API interaction between IoT gateway and cloud services.
Applies HTTP/2 server push and multiplexing for IoT gateways. Optimizes HTTP communication for constrained networks. Configures gRPC over HTTP/2 for device management.
Designs HTTP strategy for IoT platform: HTTP/2 for gateways, HTTP/3 QUIC for mobile networks. Evaluates protocol overhead vs reliability trade-offs.
Defines HTTP standards for IoT platform. Establishes guidelines for choosing HTTP/2 vs gRPC vs MQTT for various IoT scenarios.
Networking 1
▼
Understands basic networking concepts for IoT: IP addressing, DHCP, NAT, DNS. Configures WiFi and Ethernet on IoT devices. Uses ping and traceroute.
Designs network infrastructure for IoT: VLAN segmentation for IoT devices, firewall rule configuration, port forwarding. Diagnoses network issues with tcpdump.
Designs network architecture for IoT deployments: network segmentation, zero-trust networking, VPN for remote IoT. Ensures QoS for critical IoT traffic.
Defines network architecture standards for IoT deployments. Establishes network security baseline and monitoring strategy for the IoT device fleet.