Zephyr RTOS Bootcamp
Take Your Zephyr Projects from Demo to Production
A 4-day hands-on bootcamp to help you ship faster, more reliable firmware.
Reserve Your SpotYou’ve Started with Zephyr. Now What?
🚧 Stuck on Simple Demos
You’ve followed tutorials and built basic examples, but real production systems feel out of reach.
🤯 Complexity Overload
Device trees, overlays, CI/CD integration, and power management create more confusion than clarity.
⚠️ No Clear Roadmap
You’re not sure how to architect scalable, testable, maintainable systems that ship to production.
You’re not alone. Most embedded developers struggle to move beyond simple examples into scalable, testable, maintainable systems. The complexity of modern workflows, device trees, overlays, CI/CD integration, and power management often creates more confusion than clarity. That’s exactly why we created this bootcamp.
The Solution: Hands-On Production Experience
In this four-day immersive workshop, you’ll go hands-on to design and build a real production system using Zephyr RTOS. With 50% of the time dedicated to hands-on labs, you’ll gain practical experience you can apply immediately.
Led by industry experts Jacob Beningo and Mohammed Billoo, this workshop provides a proven roadmap to master Zephyr RTOS—from low-level board bring-up to modern, professional workflows. You’ll leave with practical experience, professional confidence, and the toolkit you need to build and ship production-grade firmware.
See What You’ll LearnYour Guides
Jacob Beningo
Embedded Systems Consultant
Jacob is an embedded systems consultant who has helped hundreds of companies modernize their firmware development. He specializes in RTOS design, DevOps workflows, and architecting systems that scale.
Mohammed Billoo
Zephyr & Embedded Linux Expert
Mohammed is a Zephyr and Embedded Linux/Yocto expert who helps teams develop robust software and firmware solutions for their products. He also trains them to ensure they follow best practices to navigate complex system design, testing, and hardware-software integration.
Together, they bring decades of real-world experience to help you go from “just tinkering” to building professional firmware.
What You’ll Master
Day 1: Development Environment & Build System
Module 1: Development Environment Setup 1 hour
- Installing Zephyr SDKs and toolchains
- Working with IDEs (VS Code, Zephyr Workbench) and CLI
- Git strategies for Zephyr-based projects
- Repository structure and west manifest files
- Overview of Zephyr documentation and resources
Lab 1: Environment Setup & First Build 1 hour
- Install and verify toolchain
- Clone a Zephyr project using west
- Build and flash a sample application
- Verify debugger connectivity
Module 2: Building and Configuration with west + CMake 1.5 hours
- Mastering west for build, dependency, and project management
- CMake fundamentals for Zephyr projects
- Navigating Kconfig and Zephyr’s modular architecture
- Creating and managing overlays and board definitions
- Containerizing your build system (Docker)
- Build variants and configuration management
Lab 2: Project Configuration & Build Management 1.5 hours
- Create a new Zephyr application from scratch
- Configure project using Kconfig menuconfig
- Create custom board configuration files
- Set up a containerized build environment
- Build for multiple board targets
Module 3: RTOS Fundamentals – Threads & Scheduling 1.5 hours
- Zephyr kernel architecture overview
- Creating and managing threads (static and dynamic)
- Thread priorities and scheduling policies
- Thread states and lifecycle
- Stack sizing and memory considerations
- Timing services (k_sleep, k_busy_wait, timers)
- Workqueues and deferred processing
- Introduction to application tracing for thread observation
Day 2: RTOS Fundamentals & Synchronization
Lab 3: Multi-Threaded Application Design 1.5 hours
- Create a multi-threaded application with different priorities
- Experiment with scheduling policies and preemption
- Implement timers for periodic tasks
- Use workqueues for deferred processing
- Profile stack usage and optimize sizing
- Observe thread states and context switches using tracing
Module 4: RTOS Synchronization & Communication 2 hours
- Semaphores (counting and binary)
- Mutexes and priority inheritance
- Message queues and FIFOs
- Event flags and polling
- Memory pools and memory slabs
- Heap management and dynamic allocation
- Common concurrency pitfalls and solutions
Lab 4: Inter-Thread Communication Patterns 2 hours
- Implement producer-consumer using queues
- Protect shared resources with mutexes
- Synchronize threads using semaphores
- Implement event-driven state machine with event flags
- Create and manage memory pools
- Debug a priority inversion scenario
Module 5: Device Tree & Custom Boards 1.5 hours
- Device tree fundamentals (DTS/DTSI syntax)
- Node structure, properties, and bindings
- Creating overlays for peripherals (GPIO, USART, SPI, I2C, SD card)
- Using device tree overlays for flexible configurations
- Multi-board support strategies
- Debugging hardware configs and device tree bindings
- Zephyr device tree macros and APIs
Day 3: Hardware Integration & Drivers
Lab 5: Custom Board Overlay Development 1.5 hours
- Examine existing board DTS files
- Create a custom overlay for GPIO configuration
- Add UART and SPI peripheral definitions
- Create a reusable overlay for multi-board support
- Debug device tree issues using build output
- Access configured devices from application code
Module 6: Interrupts & Low-Level Programming 1 hour
- Interrupt architecture in Zephyr
- Interrupt resources in device tree (IRQ numbers, priorities)
- Connecting ISRs using IRQ_CONNECT() and IRQ_DIRECT_CONNECT()
- Writing and optimizing interrupt service routines
- Real-time constraints and interrupt priorities
- Interrupt-safe APIs and deferred processing
- Direct ISR vs. interrupt threads
Lab 6: Interrupt Service Routine Implementation 1 hour
- Configure GPIO interrupts via device tree
- Implement ISR with deferred work processing
- Measure interrupt latency
- Implement interrupt-driven UART communication
- Handle interrupt priorities and nesting
Module 7: Custom Drivers & HAL 1.5 hours
- Zephyr driver model architecture
- Working with Zephyr’s HAL for peripheral access
- Driver APIs and device structures
- Writing custom Zephyr drivers (sensor driver example)
- Device initialization levels and priorities
- Power management integration in drivers
- Testing drivers with sample applications
Lab 7: Custom Driver Development 1.5 hours
- Examine existing driver implementations
- Write a custom sensor driver using the driver model
- Implement device tree bindings for the driver
- Add Kconfig options for driver configuration
- Test driver with application code
- Add power management callbacks
Day 4: Debugging, Testing & Production Readiness
Module 8: Debugging & Testing 1.5 hours
- Logging subsystem configuration and best practices
- Shell integration for runtime diagnostics
- Advanced application tracing for performance monitoring
- Capturing core dumps and crash analysis
- Using GDB and Segger Ozone for debugging
- Writing unit tests with Ztest framework
- Running and automating tests with Twister
Lab 8: Debugging & Test Automation 1.5 hours
- Configure logging with multiple backends
- Add shell commands for runtime configuration
- Capture and analyze a core dump
- Debug a running application with GDB/Ozone
- Write unit tests using Ztest
- Run tests locally with Twister
Module 9: CI/CD & Production Readiness 1 hour
- CI/CD integration strategies for Zephyr
- Build automation with GitHub Actions/GitLab CI
- Running Twister in CI pipelines
- Code quality tools (static analysis, formatting)
- Power management fundamentals
- Release management and versioning
- Production deployment considerations
Lab 9: CI/CD Pipeline & Production Configuration 2 hours
- Set up a GitHub Actions (or GitLab CI) workflow for Zephyr
- Configure automated builds for multiple board targets
- Integrate Twister for automated test execution
- Add static analysis and code formatting checks
- Configure power management policies in Kconfig
- Implement version numbering in the build
- Review production checklist and best practices
What You’ll Walk Away With
✅ Production-Ready Skills
Build firmware that’s scalable, testable, and maintainable
🛠️ Complete Toolkit
Master the tools and workflows professionals use every day
💪 Professional Confidence
Ship production firmware with certainty, not guesswork
📚 Reference Materials
Code examples and documentation to reference long after the bootcamp
Who Should Attend
This course is designed for embedded developers with a basic understanding of RTOS concepts and some exposure to Zephyr, such as those who’ve completed the Nordic Zephyr Academy or similar training.
Ideal for developers who have:
- Completed the Nordic Zephyr Academy or similar training
- Built basic Zephyr demos or examples
- Experience with embedded C/C++ development
- A desire to build production-grade firmware
Frequently Asked Questions
Is this course online or in-person?
The course is currently offered in-person for public training and at company facilities upon request.
What should I bring?
You’ll need a laptop with development tools installed. Detailed setup instructions will be provided to registered attendees before the bootcamp.
Will I receive a certificate?
Yes! All attendees who complete the bootcamp will receive a certificate of completion.
Is there a refund policy?
Yes, we offer a full refund up to 14 days before the event. Contact us for details.
Will the materials be available after the bootcamp?
Absolutely! You’ll have ongoing access to all code examples, slides, and reference materials.
Ready to Level Up Your Zephyr Skills?
Limited spots available for each session
2026 Sessions
Early Bird Pricing — Limited Time
Questions? Email us at [email protected]