Build, Create & Learn: A Maker’s Journey

Ep.11 - S2|E4: Redesigning My Maker Journey: HakFabrik and My Homelab Experiments

In this new episode of Build, Create & Learn – A Maker’s Journey, I take a step back to rethink how I share my work — and return to a more honest, conversational format that feels closer to the way I actually build, experiment, and learn.
 
Over the past weeks, I’ve been working on a new hardware-hacking project called HakFabrik, exploring whether real demand exists for a dedicated IoT security training device. From shaping the first concept and building the landing page to setting up a simple signup flow, this episode captures the early stages of validating an idea before writing a single line of firmware.
 
Alongside that, I’ve been expanding my home lab with a dedicated malware and reverse-engineering environment, isolated through VLANs and Proxmox — a place to safely experiment, analyze code, and dive deeper into cybersecurity without risking my main systems.
 
And after nearly twenty years on macOS, I’m finally jumping into the world of Linux as my daily driver, preparing my new laptop for everything from hacking tools to future firmware development for HakFabrik.
 
This episode marks a small shift in Season 2 — away from rigid scripting and back toward documenting the real moments, discoveries, and missteps that make up a maker’s journey.
Thanks for listening, and for following along as this adventure continues to evolve.

Ep.10 - S2|E3: From Makers to Hackers – Lessons from Maker Faire Salzburg

In this new episode of Build, Create & Learn – A Maker’s Journey, I take a short break from the deep technical dives into Embedded Linux to explore something more fundamental — curiosity.
 
During my visit to Maker Faire Salzburg, I met passionate creators, young experimenters, and communities that reminded me why I started making in the first place. It was a vivid reminder that curiosity is the common thread connecting every builder, designer, and engineer — and, interestingly, every hacker too.
 
In this episode, I reflect on what unites makers and hackers, why breaking things is part of learning, and how curiosity shapes our approach to both creativity and security. From soldering tables to cybersecurity labs, it’s all driven by the same desire: to understand how things work.
 
This episode marks a small turning point in Season 2 — a bridge between the embedded Linux journey so far and the next chapter of my exploration into ethical hacking and cybersecurity with my upcoming project.
 
Thanks for listening, and don’t forget to check out the companion article at https://herndlbauer.com/blog/a-makers-journey-podcast-episode-10/ — where I share some reflections on curiosity, and more behind-the-scenes notes from this journey.

Ep.09 - S2|E2: Writing, Debugging & Cross-Compiling My First Linux Character Driver

In this new episode of Build, Create & Learn – A Maker’s Journey, I take the next step into the world of Embedded Linux: writing, debugging, and cross-compiling my very first character driver.
 
After my initial “Hello Kernel” experiment, I wanted to go deeper — to understand how real drivers work, how they register with the kernel, and how data travels between user space and kernel space. Along the way, I learned the hard way how to debug without crashing the system, and how to cross-compile a kernel module from my Ubuntu machine to a Raspberry Pi.
 
This episode is about more than just code — it’s about exploring the invisible layers that make Linux so powerful, and why knowing what happens beneath the surface gives every maker a new kind of confidence.
 
Thanks for listening, and don’t forget to check out the companion article at https://herndlbauer.com/blog/a-makers-journey-podcast-episode-9/ — it includes the full source code and more details from my journey into the kernel.

Ep.08 - S2|E1: My Journey into Embedded Linux & Kernel Development

In this season premiere of Build, Create & Learn – A Maker’s Journey, I begin a brand-new adventure: diving into Embedded Linux and Kernel Driver Development.
 
After years of working with microcontrollers and maker projects, I wanted to understand what really happens under the hood — how Linux talks to hardware, what lives inside the kernel, and why that matters for anyone building modern embedded systems.
 
I share how I set up a dedicated Linux environment, wrote my first “Hello Kernel” module, and what I learned along the way about the invisible bridge between user space and kernel space. It’s the start of a deeper exploration into the layers that make our devices tick — from bootloaders to drivers and everything in between.
 
Thanks for tuning in to this new season. Here’s to more building, creating, and learning — this time, inside the Linux kernel!

Ep.07 - S1|E7: Season Finale: Lessons from the Drone Telemetry Project

In this season finale of Build, Create & Learn – A Maker’s Journey, I look back on my FPV drone telemetry project and what it taught me. From frustrating SD card issues and wiring mishaps to the breakthrough of logging my first GPS data, this season has been a mix of struggles, pivots, and small wins.
I also share behind-the-scenes insights about starting this podcast, balancing projects with a full-time job, and why documenting the journey helped me stay consistent. Finally, I tease what might be coming in Season 2 — new projects, new formats, and fresh challenges.
Thanks for joining me on this first season. Here’s to more building, creating, and learning ahead!

Ep.06 - S1|E6: From Breadboard to Field Test - Debugging, Enclosures & First Data

This week on Build, Create & Learn – A Maker’s Journey, I took a big step forward: moving my drone telemetry logger off the breadboard and into a real enclosure.
It wasn’t smooth sailing. Desoldering headers damaged some pads, wiring bugs kept piling up, and I spent hours chasing errors from the SD card, BME280, and GPS module. But after rerouting pins and rewriting code, I finally got the system logging properly again.
The real payoff? A short car test drive that produced my first dataset — GPS coordinates, speed, and altitude — all saved to the SD card. I visualized the track in JupyterLabs with Folium and GPX Studio, and it was incredibly satisfying to see the results line up with reality.
What you’ll hear in this episode:
Why moving from breadboard to wires is never as easy as it looks
The lessons I learned from desoldering headers and torn pads
Debugging SD card, BME280, and GPS issues one by one
Designing and 3D printing my first enclosure box
Logging real data on a short test drive (instead of a flight)
Visualizing GPS tracks and speed data in Jupyter
Next steps: battery indicators, antennas, and the first drone flight
This episode is about more than just wiring and code — it’s about perseverance, learning from mistakes, and celebrating the moment when raw numbers turn into meaningful data.
🎧 Listen now and let’s keep building, creating, and learning — together!

Ep.05 - S1|E5: From Zero to Flight-Ready - Drone Telemetry with CircuitPython

This week on Build, Create & Learn – A Maker’s Journey, I finally put the Adafruit Feather RP2040 and CircuitPython to the test — and the results were a huge step forward for my drone telemetry project.
 
After weeks of SD card frustration on STM32, I’m relieved to say: the new setup just works. From a simple blinky app to logging environmental data and GPS coordinates straight to a microSD card, I now have the first version of a working telemetry logger. And with my mechanical engineering hat back on, I’ve also started sketching and 3D printing ideas for the enclosure that will carry it into a real drone flight.
 
What you’ll hear in this episode:
Setting up the Adafruit Feather RP2040 with CircuitPython
Running the first “blinky” and rainbow LED examples
Reading environmental data with the BME280 sensor
Finally getting reliable SD card logging with sdcardio
Adding GPS data to the logger with Adafruit’s GPS library
Why I chose not to solder everything down yet — a maker’s choice
Starting the design process for a flight-ready enclosure
It’s the most complete version of the telemetry system so far, and it feels amazing to see the pieces finally coming together.
 
Companion blog article: https://herndlbauer.com/blog/a-makers-journey-podcast-episode-5/
 
🎧 Listen now and let’s keep building, creating, and learning – together!

Ep.04 - S1|E4: When the SD Card Won… and Why I’m Switching to CircuitPython for My Drone Telemetry

This week on Build, Create & Learn – A Maker’s Journey, I hit a wall with my STM32 drone telemetry project. My GPS parser worked beautifully, but the SD card shield? Not so much. After days of debugging SPI conflicts, wiring quirks, and endless C/C++ frustration, I had to face a tough question: keep grinding, or pivot to a tool that actually fits my maker workflow?
 
In this episode, I share the full story of why I’m switching from STM32 and C to CircuitPython on the RP2040 for my drone telemetry logger. We’ll talk about NMEA strings (RMC & GGA), testing external GPS antennas, and the lessons I learned from failing at SD card logging. More importantly, I’ll reflect on the maker’s mindset: knowing when to push through and when to change tools so you can keep learning, building, and actually finish projects.
 
What you’ll hear in this episode:
How I parsed GPS NMEA data (RMC & GGA) and added a motion filter
Why my STM32 + SD card shield setup refused to cooperate
The moment I realized C wasn’t helping me move forward
Why CircuitPython + RP2040 is the better fit for my telemetry project
My next steps: reconnecting sensors, logging to SD, and moving toward a flight-ready prototype
Listen now and let's keep building, creating, and learning – together!