I absolutely love the degree of control you can get at the microcontroller level. One of my proudest projects had IRQ handlers written in assembly where I counted instruction cycles in order to guarantee worst-case latencies and well-defined impact to realtime activities in the main loop. There were also some lower-priority tasks going on that were cooperatively multitasked.
Some time later I wrote a JavaScript library that mimicked some of those cooperative multitasking concepts to queue background image downloads and other generic "ITasks" in a manner that maximally utilized available connections (which were extremely limited by servers back then) and allowed on-the-fly reordering. The frontend used it to always ensure whatever image the user was most interested in (i.e. tiny previews, and large version of the result presently hovered over or that we anticipate will be hovered next) came up as close to instantaneous as we could get, and the rest of the large images lazy-loaded in an intelligent order. The result was an experience that felt so much faster than how most other websites operated back then (and ironically even now as bloat has really slowed a lot of sites down), and users loved it.
So the concepts you learn at one end of the spectrum can definitely benefit you at the other.
I have much less fun now that so much of the web has moved to React and other cookie cutter frameworks where the level of control comes at a higher cost (in terms of learning curve, understanding all the layers of abstraction, and space for developer creativity).
In other words, just get in there and start playing with a personal project or two, and trust your instincts and all the experience that honed them!
My point is, whoever has actually done the transition, their experience may not really help you a lot. They might have a cousin who actually refers them to the company; They might have worked 10 years of embedded projects as a hobby; They might be lucky because 5 years ago there were a huge opening somewhere. I heard of a metaphor about elevators -- Several people ride an elevator to floor 100, and a reporter asked them how they get there -- one of them said he did 1,000 push-ups, another said he read 2 books, and a third said he bumped his head against the elevator's walls.
Those experience might be very well relevant, or not. But above all, copying others' experience, in THIS market, probably doesn't work. Now that you are 6 years senior than me regarding SWE experience, I think you already know what to do -- just do it.
If your question is instead how you make a career transition to embedded/firmware work, that's much trickier. The obvious concern is AI's impact on the job market, but I'm chiming in to observe that this isn't the biggest problem with a web->embedded transition. Good jobs doing embedded stuff, at least for people who don't already have a pedigree doing that work, has for as long as I can remember been a bottleneck for people wanting to do this stuff. There's simply a lot more high-level work to be done than low-level work.
I can see bright spots potentially ahead; I'm not a big Jevon's Paradox person but one kind of clearly Jevon-y area is hardware, because we've zorched one of the biggest impediments to getting new projects off the ground. But it hasn't happened yet, and might not.
For fun - just do it. There are no barriers. Esp32, audio synthesizer gadget, cameras. Everything is cheap and available.
For the money? Expect lower pay, lower standards, worse hours and shit conditions
Neither of them write a single line of code anymore.
Just be realistic about the post AI world, don't fool yourself
But embedded is something else entirely that I'd argue is fundamentally incompatible with the perspective of a web dev. In embedded, you need to be aware at every moment of exactly what the CPU is doing and how many resources are being used. You generally don't have multiple CPUs or even threads. Multitasking means hardware interrupts instead of cooperative threads. You also likely need to be aware of assembly because sometimes you have to write a really hot function in raw assembly to get the required performance.
Embedded is all about resource optimization, and we dev is about throwing more and more resources at the problem. It will probably be a difficult transition to make because it's a fundamentally different way of looking at and thinking about programming.
I would recommend you find a problem, then buy the cheapest microcontroller you can find and spend a few weeks learning how to optimize your code to make maximal use of the hardware while still solving the problem in acceptable time. A big part of getting my current job was talking in my interview about how I solved a novel problem by using an obscure CPU feature in assembly that resulted in 30x fewer instructions than optimized C.
Find a problem, solve the hell out of it, and speak confidently about your solution.
One benefit that web dev does bring you is thinking about concurrency. Your CPU can only do one thing at a time, but microcontrollers have peripherals that run in parallel, and the embedded system usually consists of multiple chips talking to each other and doing independent work. Managing this concurrency efficiently with a single CPU thread is a large chunk of embedded engineering. Instead of IPC, you do things like set up a DMA pipe between SPI and RAM, trigger an interrupt on I2C bytes, use harhardware timers to simulate threads. You'd be shocked at just how much concurrent work can happen with only a single non-pipelined in-order CPU thread.
If you want to break into a new field, the advice is always the same: do the work in your own time, build a portfolio, show you know the job, and speak confidently about the hard problems you learn to solve.
Embedded development has never had a lower bar to entry. There are cheap development boards, free tools, and modestly priced test equipment. Doing embedded development is entirely up to you.
Getting someone to pay for your time doing it is just the generic problem of getting someone to pay for your time doing something you would prefer to do. It depends on other people and your social capital
Who you know, how good a hang you are [1], the economics of the field, your opportunity cost and compensation requirements, etc. are what matter most. Luck aside there’s no free lunch. The place to start is your building your network. That’s hard.
[1] technical skill might or might not be a determining factor within a workplace culture.
Transitioning your skills is possible. But embedded is a different world and a different mindset. You a lot less RAM and a smaller CPU. You may have hard deadlines - the right answer can be wrong if it's too late. You may have multiple threads that have to share data and not corrupt it, no matter what order events occur in.
In the worst case, you may not have logging available at all, and you may not have a debugger. (I think the worst I ever had to do was attach a logic analyzer to the address bus, triggered by a specific address, and then use it to look at past memory addresses in order to figure out what path of execution had got me to the point of the crash.)
So, yeah. It's a different world. Learnable, but different.
Getting someone to believe you can do it enough that they're willing to pay you: I don't have great advice there. I spent almost my whole career in embedded. It seems to me that it's easier to get from there into, say, desktop programming, than it is to go the other way. Your best bet might be to emphasize your native development background, and count on there being a shortage of embedded people.
Now, if you’re just over, focused on technologies and want to use a technology for the sake of using that technology, probably won’t be as easy.
Saying you want to transition to C, C++, or Rust is like a handyman saying they want to to get better with electrical tools vs plumbing tools or circular saws vs reciprocating saws. They focus on the problem than try to pick the right tool for the job.
Focus on what you want to solve, and then apply the tooling. Solve the same Problems you’ve already been solving, with your new tooling and weigh the pros and cons of both. The obvious choices will come out based on the problem at hand. The jump from web apps to firmware may be a big jump. But if you focus on a problem that interests you, and it appears those techs may be a better tooling for your task. Maybe solve it in your traditional languages first, then re apply the new stack. Or contribute to tools you’re already using, written in those stacks.
Get comfortable with breadboards, scruffy command-line interfaces, and hex dumps. You'll need to stare at a block of raw memory, and determine the data structure, therein.
I started with embedded. It's a lot of fun, but you'll spend a hell of a lot of time, preparing the stage. You will be responsible for all the low-level stuff that a modern host OS does.
I'd actually suggest starting with pure Machine Code, first. It will make ASM look easy, and help you to really understand the processes in the chips.
Also: IRQ is The Way. It's a whole new way of looking at threading. There are absolutely no safety nets.
That said, it's been 35 years, since I did that low level work. I suspect the tools have come a long way, since.
The #1 thing to remember about firmware, is it's often a big deal to patch. It can be done, but it should not be done often.
Get in the habit of triple-checking everything. Mistakes can be rather difficult to fix.
You’re also going to have to get comfortable with some level of electronics, because it’s very rare someone wants embedded development done that doesn’t interact with the outside world in some way, and that’s going to require knowing how to drive some IO.
By the way, this course was hands down the most hardcore thing I ever did. At one point I had to count high pulses for a number of c for loop ticks to read a temperature, in the process of writing the driver by hand (no AI yet), ending up with too high readings, and I couldn't debug it since it's actual pulses of electrons in the wire, once you signal it to start you can't stop it. In the end it was an off by one error, but not the usual kind, I shifted left 1 bit too much. I got stuck like 2 hours in the library trying to figure out what went wrong (I always suspect it's the hw fault, naturally), so that aha moment was really fun!
There is something special about creating something physically. I wish you make it soon and have fun!
As someone who frequently hopped around across different domains, the key is demonstrating that you understand their problems and can provide value. Also, being curious helps.
Also, today with AI am not sure how much native development is going to matter. A handful of best practices in an already set up project plus an AI agent is gonna spit out very workable code. Right now the problem space is very much about reasoning about the larger system, de bugging stuff, thinking about how pieces work together, going in the lab and connecting debuggers so that they agent can do stuff to the hardware, etc.
I'd like to transition closer to my roots with a job doing primarily c, c++ or rust. The natural place seems to be in embedded development or firmware work. How feasible is the transition this late in the game? Any advice?