Golioth has now trained current and future IoT engineers from across the globe more than 10 times. We have learned a lot about how to get people up and going with Zephyr, the popular Real Time Operating System and ecosystem. Our next training will happen November 29th, 2023. This will be our last training session of the year. The price continues to be…free!

What does training look like?

Our training on October 25th was another iteration of our ongoing series to show people how to get started with Zephyr. It broadly has two sections:

  • In the first hour we help you get your dev board (nRF9160-DK or nRF7002-DK) loaded up with a pre-built binary and connecting to the network. This lets us know that you understand the workflow and you can see early success at building an IoT project. You’ll load binaries directly to the board (no compiling required), input security credentials from the Golioth Console, watch the device connect, and then interact with readings on the Cloud.
  • In the second two hours, we take things back to basics and show you how Zephyr works from the ground up…with examples! As with any good project, we start from hello_world and blink examples, and build you all the way back up to things like using the connectivity on-board and then building a more complex IoT application in Zephyr. This includes plying more difficult topics like the Devicetree, as well as learning some RTOS topics like threads. Along the way we demo full featured applications like our Thingy91 demo and reference designs.

Sign up for November 29th training now!

You have one final chance to get in on the fun in 2023. We’ll have additional training sessions (with some fun new content) in 2024. Feel free to bring others from your company and work together on the sessions! We have had groups of trainees that were able to work together and even discuss how the Zephyr concepts will apply to their development inside their company.

Zephyr is the fastest growing real-time operating system. If you’re not already using it, you should be! Now’s your chance, Golioth’s next training and the next session is just two weeks away. Join our free Zephyr training on October 25th at 9am Pacific time to get yourself up to speed.

What Will I Learn?

This three hour training happens on real hardware—sign up now so yours arrives in time for training. By the end of the session, you will have compiled, run, and worked with the output from a Zephyr app numerous times. Along the way you’ll gain understanding of the major building blocks of Zephyr (CMake, Kconfig, Devicetree, etc). We delve into mapping hardware, working with threads, and troubleshooting build issues.

This training session is held live on a video chat platform. You move around as an 8-bit avatar, automatically opening chats when you get near people. This makes it pretty easy to ask questions from other people at your table. And when you get stuck, you can pair up with instructors to get help.

Golioth Uses Zephyr

Golioth is your instant IoT cloud. Chances are, we support the microcontrollers you want to use. This is thanks to Zephyr’s approach to building for a wide range of hardware while at the same time providing a fully-featured networking stack perfect for connected devices. The Golioth Zephyr SDK is a module that you add to any Zephyr project to enable device management, data transfer to/from the device, and over-the-air (OTA) firmware updates a simple matter of making a function call.

We’ll demo the Golioth platform and give you a chance to try it out at the beginning of the training. If you can’t wait until then, our free Dev Tier allows up to 50 connected devices, so give Golioth a spin today.

A group of engineers sitting in a circle, learning together

Come and learn Zephyr RTOS with Golioth! This free training will get you up to speed on the basics of the fastest growing Real-Time Operating System. We host these remotely, so you can take part from the comfort of your home or office (or perhaps your home office). Sign up now to join in on September 27th from 9am to noon, Pacific time!

Hands on with the basics of Zephyr

Closeup image of two Nordic development boards

There is no cost to take part in the training, but we do ask that you order your own hardware. Our code examples work on either the nRF7002dk (WiFi) or the nRF9160dk (Cellular) development boards. We start with a pre-compiled binary that shows your device connecting to Golioth as a basic IoT device. From there, we go back to first principles:

  • Learning about the build system
  • Modifying existing Zephyr programs
  • Testing simple Zephyr outputs

By the end of the day you will have a taste of how to add sensors and work with threads, and how to run those examples on your target hardware.

Remote, yet it’s still kind of like being in-person

Training is held in a virtual classroom that looks like it’s straight out of the Legend of Zelda. You have a character to walk around with the arrow keys and when you get close to other people, a video chat opens up. This makes it very easy to pick your study group, ask question, or listen in as others are getting help. Golioth staff are on-hand to present the training and answer questions along the way. It’s the next best thing to being in the same room together and we can’t wait to see you there. Sign up below and we’ll send you all the into you need to get ready for training.

(Please note: This form will automatically switch over to the following month once registration for September is closed)

On September 28th, 2023 at noon EDT / 9 am PDT, we’re hosting a webinar with Keenan Johnson of the Ribbit network! You have seen Keenan featured in our Case Study about Ribbit where we detail how they are using Golioth to power their fleet of environmental monitors. We’ve been giving away Ribbit kits to new newsletter signups, so be sure to sign up and enter the sweepstakes if you haven’t already.

But really we want to get into the nitty-gritty details of environmental monitoring: what are the challenges for putting devices into the field and how does someone address those challenges with a connection to the internet?

This session will cover things like:

  • Protecting a project from the elements while also still measuring those elements
  • Creating resource efficient communications back to the internet to prolong device life
  • Gathering relevant fleet health data to ensure long deployments
  • Working with community partners to deploy sensor networks asynchronously
  • Visualizing data in a useful way for all stakeholders
  • Utilizing automation to reduce engineering overhead for a large sensor network
  • Empowering citizen science to improve environmental monitoring

The presentation will last approximately 40 minutes, followed by a Q&A session with attendees that can ask questions directly to Keenan. Sign up for the webinar below!


Golioth makes it easy to work with the incoming data from your IoT fleet. How easy? Very Easy! But you don’t need to take our word for it… you can try it for yourself right now using our self-guided Golioth REST API training module.

The Golioth REST API is incredibly full-featured, unlocking all aspects of accessing data and controlling your IoT fleet from the cloud. This was no afterthought, everything that can be done from the Golioth web console is based on the API. Whether you want to perform some simple queries, deploy a new firmware update, or spin up you own custom app for device management, we’re ready for it!

This training is self-guided and available for everyone.

Getting to Know the Golioth REST API

Golioth REST API Docs

If you browse the REST API in the Golioth Docs you’ll see there is a lot to take in. We added a REST API training module to help you get familiar with the basics. You will learn how to:

  • Get a list of devices and status information from your fleet
  • Query your sensor data
  • Issue Remote Procedure Calls (RPCs) to control your devices
  • View all of the REST API calls made by the Golioth Web Console as an example for more complex operations

This is the newest section of Golioth training. It builds on the Intro to Golioth module, which runs a pre-compiled binary on your choice of the nRF9260 DK or nRF7002 DK boards to send temperature sensor data to the cloud a few times a minute. Having a device sending live data means you will see device status and sensor data entries returned by your REST API queries.

Internet, Meet Things

Connecting your devices to the internet is only one piece of the IoT puzzle. How will you collect and store the data from your devices? How will timestamps be associated with that data? What does it take to send command and control information to your fleet? Golioth has already solved these problems, and we packaged that solution into a REST API from the start.

Get your IoT deployment up and running in days, not months. With our Dev Tier, your first 50 devices are free, so take the plunge and sign up now. Our self-guided training will jump-start the skills you need and we’re always available to answer questions and share advice in the Golioth forum.

Come learn Zephyr with Golioth on July 12th, 2023! You will need to order your own hardware, but there is no cost to attend the live training. Sign up now so that you know you have a seat and can order a dev board with plenty of time.

Golioth’s Zephyr Training in a Nutshell

Golioth is an instant IoT Cloud for microcontroller-level devices. We are hardware agnostic, and we use Zephyr, the fastest growing RTOS, because it supports a wide range of hardware from different vendors. We have a number of customers who ask where to find Zephyr training, so we developed our own boot camp to get you started.

Nordic nRF7002-DK board

Nordic’s new nRF7002 Development Kit

This three-hour training uses your choice of the Nordic nRF7002 DK (WiFi) or nRF9160 DK (Cellular). We begin by installing the Nordic tools on your local machine for loading new firmware on the boards. Everything else happens in a browser-based container. You’ll use VS Code and the Zephyr build environment, but it’s already set up for you to start working quickly.

Two sections are presented. We first load a pre-compiled binary on the board and test out the Golioth platform features. This ensures you are able to successfully program the board, and exposes you to the Zephyr networking stack, serial shell (used to assign credentials which are loaded into non-volatile storage), and logging system. The second portion of the training provides an overview of how the Zephyr development environment works before getting hands-on with Devicetree, Kconfig, pin mapping, timers, threads, and general RTOS knowledge.

You will come away with an understanding of how a Zephyr application is formatted, how the build system works, and what to expect when your application is running on your board.

Take a Peek, then Join Us Live!

Our training is no secret, the self-guiding documentation and the sample code are both available to peruse right now. However, you’ll find the interaction with other attendees and with the Golioth staff running the training fills in a lot of knowledge that’s not so easy to print on a webpage.

Sign up

Join us Live on July 12th! Note that we also changed our signup policy: if you meet the criteria, you will be automatically enrolled into training (see form for more details). We are limited to 60 trainees, but we plan to also hold a training in August. We hope to see you there!

Fill out the signup form at https://forms.gle/3yk5WrWJ3Dunds9CA

Golioth just wrapped another Zephyr training session that was open to the public. This was a group of 30 trainees, all remote. There continue to be challenges with remote training, but we are always refining how we train engineers and will detail some of the learnings below. We appreciate everyone who took part in the training and are energized to do another one. In fact, you can sign up for our July session at the end of this post!

Why does Golioth focus on training?

Golioth’s main business is creating the web infrastructure that IoT devices connect to and enhance IoT offerings. The devices have a seamless connection experience by using our various device SDKs. Supporting customers that use Zephyr means we have a large amount of hardware that we can support “out of the box”. Our Zephyr SDK helps us advance our goal to support the maximum number of hardware platforms. We also have a Golioth Firmware SDK that extends that goal by supporting additional ecosystems like ESP-IDF and ModusToolbox™. We have plans for other ecosystems in the future.

Golioth focuses on Zephyr training because we think it gives customers a great opportunity to build hardware that is tightly coupled to Cloud services that Golioth provides.

Zephyr is unique because it is both an ecosystem and a Real Time Operating System (RTOS). This is in contrast to something like FreeRTOS, which is an RTOS (obviously), but then vendors like Espressif or Infineon (and a range of others) maintain a vendor specific ecosystem on top of the core RTOS. The net result is that Zephyr has many vendors contributing, but ultimately the core members of the open source Zephyr project drive the direction of the ecosystem and the RTOS. I believe this is what is driving a lot of the popularity of Zephyr. As the popularity continues to increase, we see more people looking to learn about how to use Zephyr in their projects.

There is a steep learning curve when getting started with Zephyr. This, of course, depends on your experience. To hardware and firmware engineers who are used to bare metal programming, it might be difficult to learn about an RTOS for the first time. Understanding how KConfig, Devicetree, and the west build systems can work for your project is another layer to unfold. Device vendor specific implementations of Zephyr APIs and interacting with real hardware takes the problem off of the code editor and into the real world. And throughout the entire process, understanding error messages and building troubleshooting capabilities is a necessary skill-building exercise.

This is why we want to help train people around Zephyr. We know the power of the platform and we want to unblock developers from getting their device talking to the internet using the Golioth Zephyr SDK.

Things we learned

In preparation for our June training, we revamped multiple aspects of our Zephyr program. We also learned more about what works, and what doesn’t

New training site

Training.golioth.io is where we maintain all of our training documentation. Our training programs are focused around written material, instead of being dependent on presentations from the trainers. This unlocks users to move ahead during the training or go back and review a section that is difficult for them to understand.

We also broke up the training into some new sections. We have a new REST API training section, that is separate from our Zephyr training. We will hopefully have other types of training on there in the future. We broke out the “Intro to Golioth” into its own section, because this is the same regardless of which training you’ll be going through.

Having well written documentation continues to be a positive aspect to our training, though we found additional areas we can clarify.

A focus on binaries

In the Intro to Golioth section, we encourage users to download and flash a binary onto their hardware. This matches a recent experiment we did with pre-compiled binaries on the Thingy91, since we think this is the fastest way to try out the capabilities of Golioth. We want trainees to also be able to explore the Golioth Console, which is made easier by a binary that can be put onto the supported hardware during the training. An added benefit is that this tests that users are capable of programming their hardware with a known-working application, which means they’re ready for subsequent training sections.

Previously we had users compiling a program immediately after starting the training. The binary seems to be a better solution to accelerate users’ progress.

Switching to Nordic hardware

Another change for this training is focusing on development hardware from our partner Nordic Semiconductor. We wrote about our excitement around the nRF7002-DK for training, since it provides an affordable board with a built-in programmer. We also enabled a second piece of hardware, the nRF9160-DK. That board is cellular based, which gave users more flexibility to take the training in places where they didn’t have access to the Wi-Fi credentials; it also happens to be one of our best supported boards. Finally, this showcases how Golioth, Zephyr, and Nordic Semiconductor hardware enable cross platform solutions (even different connectivity types), with almost the same underlying code.

Another reason we were excited to switch to Nordic-based hardware is the cross platform support of the nRF Connect for Desktop tool suite. This gives a graphical programmer and reliable serial terminal, which we integrated into our training. Supporting engineers across the range of computing hardware (laptops, desktops) is a surprising challenge. Even though Windows, Mac, and Linux based options are the norm, there is a huge variability between different types of machines. This is also why we continue to be excited about Kasm.

Kasm Environments

Kasm is a streaming container platform that we have standardized on in our training. This allows us to create an entire desktop computing environment that gets streamed to a user’s browser. The best part is that as soon as the user logs in, they have access to all of the toolchains, IDEs, downloaded firmware projects, and any helper tools needed on the virtual remote machine. As the user goes through training and compiles binaries for themselves, they can download the binary to their host machine. That binary can then be programmed using the nRF Connect for Desktop programmer tool. The net result is that our users are ready to compile Zephyr programs within minutes of starting the training. See below for a look “inside” our training.

Where our training still falls short is a direct connection from the Kasm remote environment to the users’ development boards. This is a tough nut to crack.

You might be thinking, “Why not have the user install tools locally? Or have them install tools before they show up to training?”. Past training experiments where we asked users to install the Zephyr tooling onto their host machine took a significant amount of time, and sometimes didn’t work at all because users show up with a wide range of laptops to a training. Don’t believe us? At our in-person training at Supercon 2022, we had a user show up with a Valve Steamdeck handheld Linux gaming computer (his laptop had broken the night before). He was able to successfully use our Kasm container to compile and program the hardware!

For now, we will continue to experiment with connections to pre-configured containers, as we think this unified development experience is the best case scenario for training users.

Sign up for the next one

We continue to refine our capabilities on these training sessions and decided to hold another one on July 12th! We also changed our signup policy: if you meet the criteria, you will be automatically enrolled into training (see form for more details). We hope to see you there!

Fill out the signup form at https://forms.gle/3yk5WrWJ3Dunds9CA

Many Thanks

Though I had the opportunity to help administer this training, the majority of credit goes to my co-worker Mike Szczys. He wrote, tested, and built all of the firmware images and training materials and the training would not be possible without him.

Thanks also go to Golioth team members like Chris W, Dan, Dylan, Marko, and Sam for being on the training and walking users through Golioth.

Golioth continues to run training for hardware and firmware developers looking to learn more about Zephyr and connecting their devices to the cloud; our last public training had 30 engineers trying out Zephyr and Golioth on accessible IoT hardware.

Our next training will take place on June 7th, 2023 at noon EST / 9 am PST / 6 pm CEST. There are limited slots to take part in this training and we will give priority to a select group described below.

What’s new in our training

We will continue to run training using Kasm, a virtual environment for building Golioth and Zephyr projects. Using Kasm in conjunction with Gather.town was a successful combination for our past virtual trainings. We want to ensure we can easily answer questions from different groups and accommodate as many individuals as possible.

One big change for this training is we are switching to Nordic Semiconductor hardware for the training. We previously chose to use the Adafruit Magtag, which features the Espressif ESP32-S2 onboard. However, we are excited to try out new partner hardware. It will also be interesting to have an included debugger on this hardware, which we hope to target in future versions of the training. Users who decide to continue following Golioth examples will be well prepared by using the boards listed below:

  • nRF9160-DK
    • This is the primary board that we recommend for this upcoming training. It is also one of our Continuously Verified Boards, which means you will be able to use this board to try out any feature of the Golioth platform. Golioth works great on cellular devices, and is well supported on the nRF9160. Being cellular, it means you could take part in the training from just about anywhere.
  • nRF7002-DK
    • We had written about our excitement for this platform, but with sourcing issues occurring right now, it doesn’t line up well with this upcoming training. We think this will be our main board going forward. The cost for this board is much less than the nRF9160-DK and it doesn’t require a cellular SIM in order to operate, just a Wi-Fi connection.

The key thing for this training is you can use either of these platforms and achieve the same output. We may add additional hardware in the future to become even more resilient against sourcing issues.

Want a guaranteed slot?

Golioth offers free training, but we love learning more about users and customers up front. We are offering preferential placement for users who have a business use case and are willing to talk through it with Golioth team members. Fill out the form below and indicate you’d like to be considered for this option. This isn’t a requirement, just a way to get a guaranteed spot on training.

Golioth hosts a lot of training on Zephyr RTOS. It’s the fastest growing RTOS and Zephyr is great for Golioth because it delivers a ton of cross-platform support, includes a built in networking stack, and it’s an open source project guided by the Linux Foundation. The only problem we’ve had is finding target hardware to use during training. Until now! The nRF7002 Development Kit from Nordic is what we are targeting for upcoming training. Let’s look at why that is.

Golioth’s hardware needs for Zephyr Training

Nordic nRF7002-DK board

Nordic’s new nRF7002 Development Kit

We have a few base requirements when choosing hardware for training:

  • In-Tree Zephyr support
  • WiFi – although we support Cellular, WiFi, Ethernet, and Thread, we find WiFi is ubiquitous and usually the most straight-forward to get connected during training.
  • USB-based firmware update we don’t want to require a separate programmer
  • User Interface – there should be some way for the user to interact with the hardware
  • Integrated sensor – Golioth makes it easy to stream sensor data to the cloud, it’s nice to show this happening live during training
  • All-in-one – we don’t want the added complexity of the user having to wire up modules.
  • Inexpensive – there’s a chance people will never use this device again after the training. So it should be inexpensive, and generate as little waste as possible.
  • Available – see also: chip shortage

Released earlier this year, the Nordic nRF7002-DK ticks almost all of these boxes. It includes the nRF7002 which is a WiFi connectivity IC, along with the nRF5340 that runs the applications. It uses the Segger on-board programmer via the USB port. It includes two user buttons and two LEDs for user interaction. There is no integrated sensor but we’re working around that.

It is inexpensive at an MSRP of $59, however production is still ramping up since the product launch. As a result, there are some stock shortages right now which we hope will improve soon. This board is a great way to try out Golioth, Nordic, and Zephyr all at the same time. All around, we think it’s likely that anyone learning to use Zephyr will find this board useful far beyond the Golioth session, helping to reduce the chance of training hardware becoming e-waste.

An early glimpse at the code

If you happen to already have an nRF7002-DK on your bench, you can give our training repository an early look. We’d love to have your feedback!

nRF7002dk simulating temperature sensor readings

Temperature values streaming to Golioth

At the time of writing, only one module has been published. It’s a “kitchen sink” demo that shows off all of the Golioth services.

I mentioned we are working around the lack of a built-in sensor, this is done with an algorithm that simulates temperature sensor data. That’s being recorded on the cloud using the LightDB Stream service which adds timestamps to each data set received.

The user-interface includes a blinking LED for output. Pressing the buttons on the board selects which of the two LEDs is currently blinking, and reports that LED number to the Golioth LightDB State service. The blinking speed can be updated remotely using our Settings service. And of course our Remote Logging service is enable on this demo so you can access the logging output as the application runs.

If you want to try this out, just follow the README and keep a few things in mind:

  1. Use `west init` to set up your workspace, and do not directly clone. That way, when you call `west update` it will pull in all dependencies (including the nRF Connect SDK and Golioth Zephyr SDK)
  2. These boards will require WiFi credentials to connect to your network, and device credentials to connect to Golioth. Both are entered via serial terminal after flashing firmware, and will be persistent (in the Zephyr settings partition) over power cycle and future firmware upgrades

Wait, what about the Zephyr training?

This post is a sneak peek. We are still actively developing this new training module and will add more subdirectories to this repository over time. I recommend starring the repo so you are notified.

The most immediate plans are to implement modules that show how to blink an LED using timers and threads, and how to react to button input. We’ll show how to define your own LEDs and buttons using Devicetree overlays and how to add sensors and enable the in-tree drivers. Of course we’d love your feedback on what else to include, please let us know!

You’re invited to Golioth’s free Zephyr training

Get up to speed with Zephyr and Golioth, sign up for our free training which is held virtually. You’ll be the first notified when our next session is scheduled.

How do you ensure you achieve the lowest possible power with your Cellular IoT Devices? We held a webinar on January 18th, 2023 where we tackled this question, alongside our friend Jared Wolff of CircuitDojo. In this video, we review how to measure and optimize your hardware, firmware, and software. The main focus of this video is the nRF9160 from Nordic Semiconductor, which runs NCS / Zephyr. Jared shared many of the tips and tricks he has learned while building the CircuitDojo Feather nRF9160.

A three pronged approach

There are three key areas to focus on when trying to optimize your design for low power.

  • Hardware – Jared talked about the importance of part choice, especially on the switching regulator. The nRF9160 has a low quiescient current if everything is configured properly.
  • Firmware – In order to take advantage of the low current draw of the part in question, we need to understand and enable features within the nRF9160. This would be true of any part we chose to use, the configuration is crucial. Understanding how the cellular modem is communicating with the tower is another important step, since each time you ping the tower it takes energy to check in.
  • Software – In this case, we mean Cloud software, such as the capabilities that Golioth provides to its users. The Golioth platform enables efficiencies like CoAP communication and CBOR encoding, lowering the size (and power draw) of each packet you decide to send to the Cloud. Things like the Golioth Setting service allows you to enable and disable different modes on your device to achieve fine-grained control of devices in your fleet.

Take your design (and battery life) further

Golioth is focused on building better cellular IoT deployments. We enable engineers to build customizable and reliable device fleets that monitor and impact the world around them. If you need any help optimizing your fleet, let us know on our forum or drop us a note.