How to become an Embedded Software Engineer?

When I started out with a goal to become an embedded developer, I had no clue where to even begin as embedded systems cover a wide variety of fields including electronics, software engineering, microcontroller programming, PCB design, networking, chip design, etc., Due to a big knowledge base needed, entering this particular engineering field can seem daunting. 

If you are reading this article, then you are probably looking for directions and some sort of a plan to develop the skills needed to get into this field of making embedded systems. By the end of this article hopefully, you will know where to start, how to plan and how to proceed in order to become an embedded software engineer.

I have also provided you with a rough estimate of the time you need to spend on each skill along with some recommended courses so that you can plan your own learning schedules. 

So let’s begin!

Branches of Embedded Software Development

The reason behind the fact that the knowledge base needed to develop embedded systems is vast is that there are lots of branches to embedded software engineering. They include 

  1. Embedded bare-metal software development
  2. Embedded Linux Software development
  3. Embedded RTOS software development and 
  4. Embedded Networking software development
Embedded software classification
Embedded software classification

A single person is not expected to be an expert in all these branches. But some basic knowledge about these branches is important as it will help us to know our place in the broad spectrum of embedded engineering.

Each of these different embedded software needs its own specific skill set to become an expert in. Big companies often hire engineers who are experts in one given skill set, while small companies need engineers who are the jack of all the above-mentioned trades!

Although each branch needs a unique set of skills, some skills are common to all. They include the following

  • Good mastery of C and C++ programming
  • Basics of Electronics
  • Basic knowledge about Microcontrollers
  • Debugging skills using oscilloscope and logic analyzers
  • Version management software like Git
  • Basics of Operating Systems

Let’s take a brief look at each of these branches so that you get a basic idea of what they are and then let’s proceed to see the skills needed and plans to develop those skills to become a software developer in each of the above branches.

Embedded Bare-metal software a.k.a. Embedded Software

This is the simplest type of embedded system which does its job without an operating system. All other types branched out of this one. Even though the entire software running on these systems look simple, they are actually the hardest to design. Since there is no operating system present here, everything needed by the application from drivers to schedulers must be designed and developed by the software engineering team.

It’s called bare metal because of the fact that the software we write runs directly on the chip by manipulating its registers like the control and status registers. 

Also since the entire code is written for the specific application, the resulting system will the much more responsive and efficient compared to the other types of embedded software as there are very few layers separating the application code from the actual hardware.

There are 2 special sub-branches that come from bare-metal software development

They include

  • Embedded Hardware Abstraction Layer software development
  • Embedded Application software development

Hardware Abstraction Layer vs Application development

The Hardware Abstraction Layer sub-branch includes writing code directly on top of the hardware and making a base layer on top of which other software can be written. This includes writing values to data and control registers and reading data from status registers of the hardware and communicating with the layer above as needed. The interface between this firmware layer and application layer is usually done through an API of functions.

Let’s take a simple example of a GPIO driver to see the difference between firmware and application software in action.  (you can read more about microcontroller peripherals here)

The GPIO peripheral has the following options 

  1. Can set an individual pin as input or output
  2. Can read the value present if that pin is configured as input
  3. Can write values to it if the value is configured as an output
  4. Can select some alternate options on the pin, for example, configure it as a UART RX pin or a PWM pin.

Out of the box, the GPIO peripheral’s interface to the user will only have a control register and a status register.

STM32 Datasheet

The above pic is from the datasheet of STM32 microcontroller that you can find in this link

Here if you need to set the mode as output, you need to write 0x01 to the appropriate place.

For example, to make pin 2 as output, and output the value 01 on it we need to write to the appropriate bits like

Now that we have made pin 2 as output, next we need to set the value to 1. To do that we need to write to the output data register like this

To make it easy for your teammate who is going to write some fancy led code, you need to provide a Hardware abstraction layer and give him an API 

void set_pin_as_output(int pin_number)
   port_mode_register |= (0x01 << pin_number);
void set_pin(int pin_number)
   output_data_register |= (1 << pin_number);
void reset_pin(int pin_number)
   output_data_register |= (0 << pin_number);

The code above is the actual code that’s talking to the hardware. 

So that the application programmer can use it and write some fancy code like this

void main()
   int pin_no = 0;
   while (1)
       if (read_pin(pin_no) == 0) {
       else {
       if (pin_no >= 16) {
           pin_no = 0;

Where he turns on each individual GPIO one by one and then turn them off in the same order. 

This is the application software that is written on top of the firmware. I hope you got the idea about the difference between the 2 types of embedded bare-metal software. Next, let’s take a look at the skills needed to develop both kinds of software. 

What are the skills needed to develop Embedded Bare-metal software?

Developing Embedded Bare-metal Software requires a good understanding of 

  • microcontroller and its peripherals
  • Ability to read data sheets and working with registers and manipulating bit-level data.
  • assembly programming (used rarely but an understanding of how it works is very important.)
  • System architecture
  • Software engineering principles (as there is no Operating System to guide us to design around it, we must adhere to good software engineering principles of code modularity and data abstraction) and 
  • Processor architecture

Next, let’s have a brief look at embedded Linux software.

Embedded Linux Software

Linux is famous among embedded engineers as it is an open-source operating system with a customizable kernel. This means anyone can make their own operating system to suit their particular needs by keeping just the necessary parts thus keeping the size small yet support their device’s functionality. Then on top of the kernel, they can make their own application code to make an embedded device! 

Some famous examples of porting Linux to embedded devices include Raspberry Pi, Beagle Bone, and Jetson devices.

This reduces the development time and costs so much compared to building your own embedded operating system. 

What are the specific skills needed to develop Embedded Linux software?

Developing embedded Linux software needs knowledge about the following

  • Linux kernel development
  • Linux driver development
  • Linux application development
  • File systems
  • Operating System concepts like Scheduling, Queues, power management, and memory management. a dedicated community for embedded Linux recommends getting these books to learn more about the development of embedded Linux.

  • Embedded Linux System Design and Development by P. Raghavan, Amol Lad and Sriram Neelakandan, Auerbach Publication (link to Amazon)
  • Embedded Linux Primer, a practical, real-world approach by Christopher Hallinan, Prentice Hall PTR (link to Amazon)

Embedded RTOS Software

What are real-time systems? Real-time systems act predictable (or deterministic) to events. Their main characteristic is the fact that they will react to events within the specified time constraints. 

Let’s take a simple example of a computer keyboard to understand what real-time systems are. When you are typing something, you expect the letter to appear on the screen as soon as you type it. If the word comes in even with a 2-second delay then it is going to be a bad experience using your device for the end-user. So the time constraint here is a few milliseconds, which cannot be perceived by normal human senses so that the end-user will feel like the letter you just pressed magically appeared on the screen. 

They are of 2 types of hard and soft real-time systems

Hard real-time systems are those that have a hard deadline, in other words, a late answer is a wrong answer. 

For example, imagine an embedded device installed on a mars rover whose purpose is collision avoidance. In this case, if the rover is heading for an obstacle and the embedded system does not react in a timely manner and pull the brakes then it can result in damage to the rover which can, in turn, result in the catastrophic failure of the mission. 

Soft real-time systems have a deadline that is not as firm as hard real-time systems. Here a late answer is an inaccurate answer but still useful. 

The keyboard example we talked about in the beginning is a good example as even if the letters are delayed by a few more milliseconds it is still acceptable performance to the end-user. 

Before we can learn about RTOS let’s take a moment to cover one more idea, that is multitasking.

What is multitasking? Operating Systems, in general, are used to support multitasking. Multitasking means running more than one thread on a single processor.

For example, consider a device with the following features:

  • It senses the temperature in your room
  • It updates the readings over wifi to your smartphone. 
  • It has an LED indicator that blinks once every 2 seconds if the temperature is above 20 degrees and blinks every second if the temperature is below 20 degrees

It has a single processor that needs to do all three tasks at the same time, in other words, it needs to do some multitasking. 

To give us the illusion that all three processes are running at the same time, operating systems use a scheduler to let the 3 processes to share the processor time. So sensor reading is taken in the first 5 milliseconds, in the next 10 milliseconds it is sent to your smartphone and in the next 5 milliseconds, the LED status is updated. This is done over and over again to make the end-user think that all 3 processes are running in parallel. 

We use this multitasking feature every day whenever we use our smartphone to listen to music and use it to do some other activity at the same time. (Like I am doing right now, as I am listening to music while I am writing this article!)  These processes are called threads in the PC world and Tasks in RTOS world but they refer to the same idea. 

What is RTOS? RTOS stands for Real-Time Operating System. This type of operating system is specially designed for use in real-time systems. The main characteristic of this system is to execute code within the specified deadline. 

What differentiates RTOS from other traditional operating systems is the implementation of Schedulers. Here the algorithm used for scheduling allows the end programmer to prioritize tasks, set a minimum time limit to respond to an event, and such control. 

A famous example of this kind of system is freeRTOS. You can check out this article to learn the fundamentals of freeRTOS. 

What are the specific skills needed to develop Embedded RTOS software? A good understanding of RTOS principles like 

  • Task Management
  • Heap memory management
  • Queue Management
  • Software timer management
  • Interrupt Management and 
  • Resource management

I would suggest this free ebook from if you want to learn more about RTOS development. It basically explains the API used with FreeRTOS along with some examples on how to use the API and the concepts needed to start developing using their Operating System.

Embedded Networking software

A major part of any embedded software is not generating data, it is rather to transfer data from one module to another, in other words, to make 2 modules talk to each other

Networking is given a special category in embedded software because they involve a specific skill set that’s needed to develop and manage custom network stacks. Some examples of network stacks include Ethernet stack, wifi stack, and Bluetooth stack.

A good understanding of these stacks, in terms of how they work and a good understanding of network security, is important to develop devices that are robust, safe and secure

Examples of such devices can include smartwatches that connect to our devices via Bluetooth or wifi, Bluetooth headphones and speakers and other wearable techs. 

What are the skills needed to develop Embedded Networking software? Developing embedded software on the network stacks need knowledge about the following. 

  • Basic Networking principles
  • Network security principles
  • Ethernet stack
  • Wifi stack
  • Bluetooth stack
  • Zigbee and Zwave protocols for home automation
  • ANT+ protocols for the health industry
  • Networking devices like switches, routers, IDS, IPS, and firewalls

If you don’t have a college course on networking, I would suggest you go for industrial certifications like CompTIA Network+ as a way to get your basics strong in networking.

You can read more about networking certifications in this link

Now that we have covered the branches of embedded software engineering, let’s have a look at how to actually develop the skills needed.

Plan to develop Basics skills

As we saw above, no matter which branch you decide to go on, you need some basic skills which include the following

  • Good mastery of C and C++ programming
  • Basics of Electronics
  • Basics of Operating Systems
  • Basic knowledge about Microcontrollers
  • Debugging skills using oscilloscope and logic analyzers
  • Version management software like Git

These 6 skills are the ones that employers look for when they hire junior developers and the rest can easily be learned on the job.

To learn the skills needed, you need to take some courses either at an educational institution or online. Both approaches have their pros and cons, you can read more about them at this article here

So here is my proposed plan to develop the basic skills. 

Step 1: Take up a C programming course,  Estimated time to finish 40 hours.

Coding is a very easy skill to pick up, especially C is very easy to learn as the overall flow of the code matches with human thinking. So I would propose you to start with this one. 

You can do this either at your university if they have one or you can do it online.

Course recommendation: C programming for beginners by (link to Youtube)

Book recommendation for beginners: Let us C  (link to Amazon)

Book recommendation for intermediates: C Programming Language by Kernighan and Ritchie (link to Amazon)

Step 2: Take a course on the Basics of Electronics, estimated time to complete: 100hours

This involves a lot of science. From the perspective of embedded software developers, it’s still a good idea to learn the basics as you will be closely working with the hardware. Spend some time learning the basics of electronics as this will help you both on the interview and on the job, say when you are discussing something with hardware teams and when you are stuck debugging some sort of bug and you can figure out if it’s the hardware that’s causing the bug. 

But you don’t need to learn too deep. Just understand the basics thoroughly. 

  • You can start with learning what is current, voltage, resistance, capacitance, inductance, 
  • then proceed onto the electronics concepts and learn how a diode and a transistor work. 
  • Then you can move onto learning about the electronic components typically used in embedded systems like oscillators, rectifiers, ADCs and DAC and 
  • learn how PCBs are made 

These are the bare minimum you need to know as a software developer

It will be time-consuming, and the concepts will be difficult to grasp in the first go, that’s the reason you need to choose your study materials properly.

Course recommendation: Basics of Electronics (link to youtube)

So now you got the basics of programming and electronics covered, next let’s move onto learning about how operating systems work

Step 3: Take a course on Operating Systems:  Estimated time to finish 40 hours.

We have all used operating systems like Windows 10, Mac OS, iOS and Android. Embedded operating systems are just minimalist version of the above. If it’s your first time learning about operating systems, then no need to be scared as operating systems work in a very similar fashion to a factory manager, all it does is organise the work going on in the background and give us the ability to do multi-tasking. The concepts are fairly simple to grasp as with other things in computer science, it’s just some logic taken from our day-to-day lives so it’s not that hard. 

Again choose some good study materials, so that you don’t waste time and learn the concepts needed easily.

Course recommendation: Introduction to operating systems (link to Udacity)

Step 4: Take a course on Microcontrollers: Estimated time to finish 60 hours.

This one is a must, no matter what type of embedded system you are developing as at the end of the day, whatever software you write will be run by the microcontrollers. So take some course on it and learn the basics. Again no need to learn in-depth, as you will probably never be able to learn everything there is to know, so just learn the basics and as you work on some projects, you can always do the research to figure out if some concept feels hazy to you.

You can check out these articles to learn more about the basics of microcontrollers

Step 5: Learn Git, estimated time: 15 hours

Git is a tool that will be in all good software engineer’s toolkit. It helps us immensely during the software development process and it will not take much time to learn. You can easily learn it in 2 days time and then proceed to start using it in your projects. I bet you will feel the difference in your code organization and productivity levels with Git!

Course recommendation: Git tutorial by Thenewboston (link to youtube)

Step 6: Learn to use Oscilloscopes and Logic Analysers, estimated time: 15 hours

This is another skill which does not need much time to master but will help you immensely during your projects, especially in the early phases. So spend some time and learn these too!

I could not find a simple course to teach these skills as it is usually taught in labs with some other course. At some point perhaps I will make a course on my own to teach everything you need to know about using these instruments, till then I suggest you stick to googling and youtube videos for this one. 

So if you are efficient, you can probably complete all the above course on the basics of embedded systems in 270 hours, which is not bad as if you do it part-time at 20 hours a week, you can do it in 14 weeks time!

So now that you have covered the basics, let’s move onto the plan to develop the special skills needed for your chosen branch of embedded systems.

Plan to develop skills for Bare-metal embedded software Engineering

As we saw above these are the skills needed to develop bare-metal embedded software

  • microcontroller peripherals programming and ability to read data sheets 
  • Assembly language programming
  • System architecture and Software engineering principles 

Microcontroller peripheral programming, estimated time 80hours

Now that you know the concepts of how a microcontroller works and how to program in C, the next step is you should start learning about how to program microcontrollers. This is the fun part, as you will start learning the actual job you are going to do!

Recommended courses: Mastering Microcontroller with Peripheral Driver Development(link to Udemy)

As you start programming microcontrollers, you will find yourself going again and again to the manufacturer’s datasheets to get the needed information. This is a skill developed through practice and I have written another article on how to get started doing this, you can check it out here

Assembly language programming, estimated time 40 hours

This one is rarely used in your day to day job, but nonetheless it is a very important skill as it is used in critical parts of your code to improve the performance. No need to learn this one at a very deep level either as a basic understanding is enough since every microcontroller will have its own instruction set and if you have the basics, you can always do what is needed to be done.

Recommended course 

Assembly language Programming (link to youtube)

System Architecture and Software Engineering Principles: 80 hours

When you are building small systems, usually everything will fall into place and you don’t need some special design pattern and keep code modular. But as the complexity levels of your system increases, you will feel the need to adhere to the best practices in order to make the software maintainable and it will help you immensely when you are trying to add a feature 1year down the road. 

So I suggest that you spend some time on this, as employers these days don’t just look for people who can write working software, but also it should be maintainable in the long run too. 

Recommended course

Embedded Software and Hardware Architecture (link to Coursera)

So add another 200 hours after learning the basics then you can are looking at a total of 24 weeks learning 20 hours a week, so all you need is 6months to get into Bare-metal embedded software development!

Now that we have covered the skills needed for Bare-metal Embedded Software development, let’s get to embedded Linux software development.

Plan to develop skills for Embedded Linux Software Engineering

As we saw above these are the skills needed to develop Embedded Linux Software

  • Linux kernel development
  • Linux driver development
  • Linux application development

File systems and operating system concepts we saw above will be included in the application development part. 

Linux kernel development,  estimated time 80 hours

Linux kernel is nothing but a bunch of modules tied together to make the core of an operating system. In order to develop embedded systems on top of it, you need to be able to learn the basics of the Linux kernel, so that you can compile one on your own to suit the needs of your embedded system. 

Recommended course

Linux Kernel Programming (link to Youtube)

Linux driver development , estimated time 60 hours

Once you are done learning about the kernel, the next step is to learn to communicate with it from your drivers, there are some do’s, donts and best practices here that you need to learn in order to communicate with the kernel. The operating system concepts that you have already learned when you went through the basics plan is going to be a big help here. Once you learn the basics, you will be able to develop your own drivers for the custom hardware, that are usually found on embedded systems.

Recommended books

Linux Driver Development for Embedded Processors (link to Amazon)

Linux Device Drivers Development: Develop customized drivers for embedded Linux (link to Amazon)

Linux application development, estimated time 60 hours

Once you have your kernel and required drivers ready, the next step is to write up your application. This will feel very easy and here the software engineering skills that you have learned will guide you to program the logic needed for your application.

Recommended Book

Linux Application Development (link to Amazon)

Alright so in total you are going to need

Basics 270 hours + Linux 200 hours = 470 hours or 24 weeks of 20 hours a week, which comes to about 6 months time to learn!

Plan to develop skills for Embedded RTOS Software Engineering

As we saw above these are the skills needed to develop Embedded RTOS Software

  • Task Management
  • Heap memory management
  • Queue Management
  • Software timer management
  • Interrupt Management and 
  • Resource management

Estimated time 100 hours

I am not going to go into the details of each part here as any RTOS includes all the above parts. A good course on embedded RTOS development is going to teach you everything you need to know in around 50hours time, and you can practice using the next 50 hours to make your own projects based on your chosen RTOS. You can read more about RTOS in this article.

Recommended course

Mastering RTOS: Hands-on FreeRTOS and STM32Fx with Debugging (link to Udemy)

Plan to develop skills for Embedded Networking Software Engineering

As we saw above these are the skills needed to develop Embedded Networking Software

  • Basic Networking principles
  • Network security principles
  • Ethernet stack
  • Wifi stack
  • Bluetooth stack
  • Zigbee and Zwave protocols for home automation
  • ANT+ protocols for the health industry
  • Networking devices like switches, routers, IDS, IPS, and firewalls

These skills can be grouped into 3 basic categories

  1. Basic networking principles
  2. Networking stacks and 
  3. Network security

Basic Networking skills, estimated time 100 hours

This one is going to take some time to learn if you are starting from scratch, I suggest instead of going for a course, go ahead and do certification on networking. You can select a certification based on your needs. I suggest you take a look at this article here where I explained how to choose a networking certification.

If you are not into getting a certification, then you can just go through these 2 courses on CompTIA Network+ certification with going through the actual certification process.

Course recommendations

CompTIA Network+ The Total Course (link to Udemy)

CompTIA Network+ by Professor Messer (link to Youtube)

Networking stacks, estimated time 100 hours

This one is another one of those skills where basics are enough. Just learn the Ethernet stack and learn to write code on top of it using TCP, UDP communications, transferring files through FTP and SFTP, installing and using HTTP and HTTPS web servers like Apache. 

Once you have a strong grasp of these concepts, then if your project needs say another stack like WiFi or Bluetooth or ZigBee or any other protocol, you will be quickly be able to adapt your skills as all these protocols have the same basic logic behind them, but their implementations will differ to suit particular needs.

Recommended books

Networking and Internetworking with Microcontrollers (link to amazon)

Linux TCP/IP Stack: Networking For Embedded Systems (link to Amazon)

Alright so in total you are going to need

Basics 270 hours + networking 200 hours = 470 hours or 24 weeks of 20 hours a week, which comes to about 6 months time to learn!


No matter which branch you take, it is a good idea to keep your practice projects on GitHub as this will make it easier for you to share your code with the potential employers. Having these practice projects will help a very good deal if you are trying to find your very first job as an embedded developer without any related work experience! 

Alright, hope you got an idea of where to begin and how to proceed in your plan to become an embedded engineer. 

All the very best to you!

Hope this article provided some value to you! 

You can email us or contact us through this link if you have any questions or suggestions.

If you liked the post, feel free to share this post with your friends and colleagues!

Related Articles

4 Types of Embedded Software Explained!

200 Embedded and IoT Software Engineering Interview Questions – Part 1

Embedded Engineers Salaries In Europe

Photo of author
Balaji Gunasekaran
Balaji Gunasekaran is a Senior Software Engineer with a Master of Science degree in Mechatronics and a bachelor’s degree in Electrical and Electronics Engineering. He loves to write about tech and has written more than 300 articles. He has also published the book “Cracking the Embedded Software Engineering Interview”. You can follow him on LinkedIn

Comments are closed.