Seven steps to grow your embedded Linux skills

Do you already have a job in embedded Linux but wish to be given more challenging goals? Or are you in IT, already using Linux on your own laptop, and dreaming about landing an embedded Linux job, possibly starting as your own boss? Follow my advice in a patient and consistent way, and you will achieve your goals in less than 12 months.

0. Stop reading if…

The first question is: “Is this topic really for you?”. So, ask yourself a few questions first:

Do I like software and hardware?
Do you have a preference for the Linux command line interface?
When something breaks or doesn’t work as expected, instead of being annoyed or discouraged, are you rather excited about the opportunity to challenge your existing beliefs or to uncover a bug that maybe nobody found before?
Are you interested in low-level details, and not only in the big picture?
Do you have at least one or two hours per day (on a weekly average) to dedicate to this effort?

If you answered “no” to some of the above questions, think twice before reading on…

1. Find your first own project

You need something concrete to get started and make progress with every day. If you start right away studying big projects like Linux or Yocto, it will be hard to know where to start.

If you indeed like hardware and software, it won’t be too hard for you to find a cool project you’ll be excited about. Here are just a few random directions you could be interested in exploring:

IoT gateway idea, to protect your local network from vulnerable IoT devices.

Some home automation project, like keeping track of the inside and outside temperature to figure out when to open or close the windows (or start pumping air from the outside) to minimize heating or air conditioning costs. You could even use the weather forecast to anticipate drops or increases in outside air temperature in the next hours, that could make air conditioning or heating unnecessary.
Implement a weather station, based on designs shared on the Internet.
Implement your own wildlife camera, triggered by a motion detection sensor.
Use a small embedded board as a gateway to run all your connected devices in one or multiple isolated subnets. You would do this to protect your local network from exploits in proprietary devices which connect to the Internet all the time and are very rarely updated against known vulnerabilities. Some of these devices can also be given just the bandwidth they are supposed to need. This way, even if they are compromised, they won’t be usable as botnets.
By the way, if you are interested in cybersecurity, you could try to break into one of such devices and look for unfixed vulnerabilities. You’ll need to develop low-level skills to achieve such goals.
Implement a box to play your own media. Embedded boards such as Raspberry Pi can drive multiple screens in high definition.
Implement your own cloud, hosting your data by yourself instead of relying on private-data hungry tech giants. That’s very easy with projects like NextCloud or YunoHost.

2. Find suitable hardware

The next step is to look for hardware to implement your project. My advice would be to tap on some of the most popular hardware resources on the Internet, backed by a big community of contributors and users:

NanoPi R3S – Low-cost dual gigabit Ethernet router
(source: CNX Software)

Raspberry Pi: very popular ARM-based boards, with either powerful options like Raspberry Pi 5, or tiny ones like Raspberry Pi Zero 2. In both cases, they can be powered with a USB power supply. All sorts of hardware add-ons (camera, sensors, SSD, to name just a few) have been developed for such boards.
Beagleboard.org: boards like the BeagleBone, BeaglePlay or PocketBeagle 2 are also very popular solutions, and have the advantage of being open-source hardware and supported by a very active community. If you ultimately want to give a commercial life to your project, it will be easier to develop a custom board from the original one.
Of course, many other Linux supported hardware platforms exist, of all kinds of features and shapes. The best way to find them is probably through the CNX Software website, which relentlessly reviews all the new devices being announced.

3. Find tools to build your root filesystem

While there is some learning value in starting from scratch, you will ultimately need some reproducible way of building and maintaining your root filesystem with the base system and its applications. Here are the most popular solutions.

Debian GNU/Linux

With Debian GNU/Linux, you have a ready-made root filesystem, supporting all embedded platforms such as ARM, ARM64 and RISC-V. It will be easy to add more components by installing packages, or by compiling your own applications directly on the board. You will also enjoy timely security updates to the standard packages.

This solution is also the smoothest one for somebody with Linux desktop or server experience. You should already be in familiar territory, and you will be able to make your first prototypes with this distribution.

However, this solution has shortcomings too. Your filesystem will be bigger than with the other solutions (hundreds instead of tens of MB), and being very generic, will include dependencies to support features you won’t actually use in your embedded system. This also increases the attack surface, in particular if you installed a compiler to build your own applications!

It’s hard to know how many deployed embedded systems use such a solution, but based on previous customer requests and projects, it probably represents between 5 and 15% of the total share. This being said, this remains a relevant solution for making prototypes.

Buildroot

Buildroot logo

Unlike Debian which will build a generic yet extensible root filesystem, Buildroot is probably the best solution to build a dedicated root filesystem with a fixed set of features.

Buildroot is very easy to learn. All you have to do is download the sources, run make menuconfig to select the components and features you want to include, and then make to generate a ready-made image to flash the root filesystem. Buildroot was kept intentionally simple by its developers, and it doesn’t support advanced features like updating the system through packages, for example, that would make its engine much more difficult to maintain.

As a consequence, every time you want to update something, you will have to rebuild your filesystem from scratch, whether it’s to update the system or applications, or to apply security and bug-fix updates provided by the Buildroot project. That’s probably all right anyway, as your system will be smaller (a few tens of MB at most), as the system will only include the components and features you actually need.

It’s also hard to estimate the market share for Buildroot. According to my own experience in this area, it’s probably between 25 and 45% of the embedded products that are built and maintained with Buildroot.

Yocto

Yocto Project logo

The third and apparently most popular solution is the Yocto Project, which historically is the second project of the Linux Foundation, after Linux of course. Like Buildroot, it allows to build a custom root filesystem for your system, but unlike Buildroot, it has more advanced features allowing to generate and maintain a real distribution, which can be updated by packages too (if you wish). That’s because BitBake, the build engine, is much smarter, allowing for many more possibilities and customizations. This way, unlike Buildroot, BitBake never rebuilds the same outputs twice (as long as the inputs are strictly equivalent), and can build multiple versions of the same component.

Yocto, being more open to customization, differs from Buildroot in the sense that the core system, BitBake plus Openembedded-Core, can be supplemented by a great number of third-party layers offering support for specific hardware, for specific components or for specific features like security and virtualization.

My rough estimate is that Yocto is used in between 45 and 70% of the embedded systems. Its 4 year Long Term Support, the size of its community, of its ecosystem and its endless customization capabilities make it a great choice for developing and maintaining embedded Linux systems. However, it may not be the best choice when you are a beginner, as the learning curve is steeper than with Buildroot. But if you eventually master this tool, this will be a great advantage in your search for an interesting embedded Linux jobs, proving how advanced your experience is.

Choosing a solution – Summary

In a nutshell for this section:

You can start with Debian to build your first prototype. The transition from regular Linux will be smoother.
Then, move to Buildroot when you are ready to build a system with a fixed set of features
Then, switch to Yocto if there are things you cannot do with Buildroot, or when you feel ready to tackle more complexity.

4. Learn by doing

Once you have made your choices, it’s time to get your hands dirty. Start aiming at what you’re trying to achieve, one goal at a time.

Here are some of the first steps you can make:

Get access to a serial console, access the bootloader and see the Linux kernel boot.
Recompile your kernel with a modified configuration, or with a modified version. That’s easier than you can think!
Recompile the root filesystem.
Customize the root filesystem and add your own applications.

You’ll succeed if you are patient and start small, one little step at a time. You’ll build your skills and self confidence at each achievement. Small steps also let you truly understand what you’re doing.

5. Accelerate your learning

The Internet offers countless resources to embedded Linux students and developers, and perhaps too many. So, which are good ones to start with?

Many practical labs in Root Commit's training courses — Root Commit’s Yocto course materials with a majority of time spent on practical labs. Learn by doing!

At Root Commit, we offer embedded Linux, Kernel and Yocto training courses to accelerate your learning in a fun and interactive way. Even if you don’t join one of our sessions, you can also do some self training with our open Yocto lectures and practical labs, available under a free documentation license. You can also check out Bootlin’s free training materials. I’m also one of the original authors and main contributors.

And then, you can attend technical conferences:

The Embedded Linux Conference is a bi-yearly conference organized by the Linux Foundation. It’s great if you can attend it and meet other users and key project maintainers. However, if you can’t afford or make it, all videos and slides from previous sessions are available for free on YouTube.
FOSDEM is a great event too in Brussels, free of cost, with multiple sessions related to embedded, mobile, kernel and other low-level topics. Videos from past sessions are also available for free.
Many other conferences are available, of course, as tracked on LWN.net’s event calendar. In particular, don’t miss the ones in your own area or country. You’ll be surprised to meet like-minded people there too, and such people are also easier to interact with.

6. Interact with your peers

One of the great things with embedded Linux is that you’re not alone. You will find many people online sharing the same interests, and facing similar issues. In each project, there are also a few people who stand out and take some time to help others.

Getting help

You’ll be surprised how helpful the community can be when you know how to ask for help. The key point to understand is that people have no obligation to dedicate their precious time to helping you; they will just do this in their own interest, which usually aligns with the interests of the project they contribute to.

Therefore, you are much more likely to get help if:

You have done your “homework” first. You explain what steps you’ve gone through so far to look to pinpoint the issue and look for a solution. This shows how committed you are to contribute to finding a solution that will benefit every user of the project. Contributors are then more likely to support you, because they know it’s likely to lead to a useful outcome.
You ask for help in a public way, through a public forum or mailing list. It’s rare to find somebody ready to devote time to writing explanations that only you will profit from. Forums and mailing list archives can build up a very helpful archive over time. So, when I get private requests for help, I most of the time ask the person to ask the question again on a public place, where I will often be too.
You have built a reputation as a reliable contributor. If contributors know that in the past, you followed up on questions you asked, and this led to somewhere, and that you helped other users too, they are more likely to help you than if they didn’t trust you yet. So, be reliable and patient.

Connect with others

Having connections with people in real life is very helpful and keeps you motivated too.

Yocto BoF meeting in 2023 — Yocto user and contributor meeting in 2023

Therefore, try to go to conferences in your area, country or region, whatever is accessible without spilling too much extra CO2 in the atmosphere. Don’t hesitate to ask questions to speakers and chat with people who attended the same sessions as you did.

Also try to take the opportunity of such events to meet people you interacted with only online so far. A good way to achieve this is to post on social media (typically Mastodon and LinkedIn) about the event you are going to. Not only does this help the event itself, but you can also signal your interest in meeting other people with shared interests.

You will be amazed how much you can learn (and share!) when interacting with such people in real life. I will always remember how excited as I was when I went to my first conference. It was like spending time in a parallel world where the Linux desktop and Free Software had succeeded and where everyone was ready to share the best of their knowledge.

7. Contribute

Michael Opdenacker's contributions to Poky, July 2025 — Yocto Project’s cgit interface showing contributions from a specific person.

At this stage, you should be ready to contribute to the projects you are using. Many people stop before this one, but this is key for further growth.

Here are a few things you can do:

Help others on mailing lists and forums
Share what you learn, through blog posts, social media for quick updates, and even conference presentations. All conferences welcome new speakers. Otherwise, they always have the same people on their schedule. You don’t have to be an expert, just to have experience to share that could benefits others, like the beginner you were a few months ago.
Investigate the issues you face and propose fixes.
Implement or at least propose improvements that come to your mind.
Make sure all your contributions are public. In particular, you can add links to your code contributions to your resume. Most git web interfaces allow to list all commits from a specific author.

The more you do all this, the more you should enjoy it. If you don’t, that may be because you didn’t catch the vibe of the projects you got into. You may try with different ones then.

Doing all this should make you visible beyond the walls of your current school or employer. Your public contributions will prove your skills and ability to collaborate with others, in particular with the open source community which is known for its high quality standards. You can now apply to embedded Linux jobs, and your profile will stand out, compared to other candidates with perhaps longer experience, but less verifiable skills. And anyway, if you are stuck with a problem, you know how and who to ask.

Quick summary

Here’s a programmer’s reply to the original question: “How to grow your embedded Linux skills?”

Doesn’t this remind you of Root Commit’s recycling wheel?

Pick a fun personal project
Choose hardware matching your requirements
Choose a solution to build your root filesystem
Learn by doing, one atomic step at a time
Accelerate your learning by reading, watching videos, attending conferences and/or taking courses
Connect with other people using the same open-source projects
Contribute to the projects that you use: share what you learn, support other users through public resources, make code or documentation contributions.
This will give visibility to your skills, leading to more interesting job or business opportunities, ultimately providing funding for going back to 1.

All this requires discipline and independent work at the start, but this is a very profitable investment in your own visibility. Having public contributions that recruiters, project leaders or customers can also verify on the Internet is quite rare and therefore highly valuable.

Image credits

Post Views: 1,267