Zbigniew Hołdys – Senior Software Engineer & Architect

// expertise

Core Competences

25+ years of professional R&D experience across the full software lifecycle: from kernel drivers and real-time systems, through middleware and SDK design, to cloud architecture, AI/ML pipelines and team leadership.

🐧

Linux / Unix Kernel

Deep kernel-level C/C++ development, BSP, drivers, LKMs, toolchains (ARM, PowerPC, MIPS). JTAG, Lauterbach, NEXUS, BDM hardware debugging.

⚡

C / C++ / Rust

25+ years of systems programming. Modern C++17/20/23, RAII, zero-cost abstractions, templates metaprogramming. Rust for memory-safe low-level code.

🐁

Embedded & Microcontrollers

Bare-metal and RTOS firmware for ARM Cortex-M, ESP32, STM32, AVR. FreeRTOS, Zephyr RTOS. Interrupt-driven, deterministic, memory-constrained systems.

🌐

Networking & Kernel Hacking

TCP/IP stack internals, eBPF/XDP, netfilter, raw sockets, OPC-UA, Modbus, industrial buses. Network performance tuning and protocol reverse engineering.

🔓

Security & Offensive Mindset

Vulnerability research, exploit mitigations, secure boot, firmware signing, privilege escalation analysis, threat modelling, cryptographic APIs.

📺

Broadcast & STB / HbbTV

Set-top box, HbbTV, RTOS platforms. GStreamer, DRM/EME/MSE, Netflix/YouTube certification lead. DVB-T/S/C, Wayland/Weston/OpenGL backends.

☁️

Cloud Architecture

Kubernetes, Helm, Docker, Podman, Ansible. Microservices, CI/CD pipelines (GitLab CI, Jenkins), observability (Prometheus, Grafana, Elastic Stack).

🤖

AI / ML & Data Science

Machine learning, linear programming, optimisation heuristics, VM placement algorithms, predictive maintenance, data analysis with Python/Pandas. TinyML on edge.

🏗️

Software Architecture

System design, UML, specifications, API/SDK development, IPC (RPC, COM, REST, gRPC, DBUS). Memory & performance profiling.

🎯

Project & Team Leadership

Certified Scrum Master (CSM). PMI/PMBOK certified. Product ownership, backlog management, risk analysis, cross-functional and multicultural team leadership.

🧪

Extreme Programming / TDD

XP practices: pair programming, TDD, continuous integration, refactoring. UnitTest, IntegrationTest, End2End pipelines, static analysis (clang-tidy).

🟦

TypeScript / JavaScript

Node.js backend services, TypeScript system design, full-stack tooling, WebDriver Selenium automation, build systems and runtime performance.

📡

Protocols & Databases

MongoDB, MariaDB, Prometheus, VictoriaMetrics, ClickHouse, RabbitMQ, Grafana, Kibana. MQTT, OPC-UA, Modbus, SCADA integration.

🌟

Industrial & Distributed Systems

Real-time control systems, SCADA, PLC integration (Rockwell, Siemens TIA Portal, CoDeSys). Distributed systems with time synchronization and high availability.

// tech stack · TKL layout

CC++C++20RustPythonTypeScriptJavaScriptNode.jsARM Cortex-MLinuxRTOSFreeRTOSZephyrYoctoBuildrootAndroid

ESP32STM32RP2040nRF52AVRRISC-VSPII2CUARTCANRS-485GPIOPWMJTAGSWD

LauterbachBDMNEXUSOpenOCDDockerKubernetesHelmPodmanAnsibleTerraformMongoDBMariaDBPrometheusVictoriaMetricsRabbitMQ

GrafanaKibanaElastic StackRedisPostgreSQLMQTTOPC-UAModbusgRPCWebSocketHbbTVDVBGStreamerDRMOpenGL

WaylandeBPFnetfilterTCP/IPTinyMLLoRaLoRaWANBLEWi-FiZigBeeNFCAWSGCPAzure

UMLTDDXPGitScrumCMakeGDBValgrind

clang-tidyML / AIPandas

GitLab CIJenkinsWireshark

ftrace

perfstraceltrace

Languages System/OS Embedded Cloud/DevOps Databases Protocols/Buses Tools/Debug Media/Graphics AI/Methods IoT/Radio

CC++C++20RustPythonTypeScriptJavaScriptNode.jsARM Cortex-MLinuxRTOSFreeRTOSZephyrYoctoBuildrootAndroideBPFnetfilterESP32STM32RP2040nRF52AVRRISC-VSPII2CUARTCANRS-485GPIOPWMJTAGSWDDockerKubernetesHelmPodmanAnsibleTerraformMongoDBMariaDBRedisPostgreSQLPrometheusVictoriaMetricsRabbitMQMQTTOPC-UAModbusgRPCWebSocketTCP/IPGrafanaKibanaElastic StackAWSGCPAzureGitLab CIJenkinsWiresharkclang-tidyGDBValgrindCMakeperfstraceLauterbachHbbTVDVBGStreamerDRMOpenGLWaylandTinyMLML / AIPandasLoRaLoRaWANBLEWi-FiZigBeeNFCUMLTDDXPScrumGit

// embedded_systems

Embedded Systems & Microcontroller Engineering

Firmware developer and embedded systems engineer specialising in microcontroller programming, real-time control, IoT devices, and hardware-software integration. Experienced in bare-metal ARM, RTOS-based firmware, industrial protocols, connected edge devices, and advanced debugging.

🧠 Firmware & Microcontrollers

Bare-metal firmware for ARM Cortex-M, ESP32, STM32, AVR microcontrollers
Real-time programming with FreeRTOS and Zephyr RTOS
Interrupt-driven architectures and deterministic timing
Memory-constrained system design and optimisation
Custom bootloaders, linker scripts, startup code
Secure boot and firmware signing pipelines

⚡ Hardware Interfaces & Protocols

Peripheral integration: SPI, I2C, UART, CAN, RS-485
Sensor integration: IMU, environmental sensors, ADC/DAC systems
GPIO control, PWM generation, hardware timers and interrupts
Industrial buses: OPC-UA, Modbus, proprietary real-time protocols
Hardware debugging: logic analyzers, oscilloscopes, JTAG/SWD

📡 IoT & Connectivity

Wi-Fi / BLE IoT device development using ESP32
MQTT-based telemetry and device communication
Secure device provisioning and OTA firmware updates
Edge devices communicating with cloud platforms (AWS, GCP, Azure)
LoRa / LoRaWAN long-range low-power communication
Time-synchronised distributed sensor systems

🧩 Embedded Linux & SBC Platforms

Development on Raspberry Pi and Linux-based SBCs
Custom Linux images with Yocto and Buildroot
Device drivers, kernel modules, low-level hardware access
Hardware interfacing via GPIO / SPI / I2C under Linux
Building edge-computing gateways and data collectors
Real-time industrial control on embedded Linux + PLC platforms

🛠 Hardware Prototyping & Debugging

Rapid prototyping with Arduino / ESP32 / STM32 platforms
PCB prototyping and electronics integration
Power management for embedded and battery-powered devices
Sensor networks and distributed device systems
Firmware CI pipelines: build, flash and automated hardware-in-loop tests
Reverse engineering hardware protocols and building custom debugging tools

🌐 Real-Time & Industrial Systems

Designed custom embedded control systems integrating sensors, RT firmware, and network connectivity
Real-time distributed systems with deterministic latency constraints
Industrial PLC integration (Rockwell Studio5000, Siemens TIA Portal, CoDeSys)
SCADA integration and field device communication
High-availability runtime environments for safety-critical applications

// edge_and_advanced_embedded

TinyML / Edge AI Embedded Computer Vision OpenCV on ARM Ultra-low-power IoT OTA Infrastructure Secure Boot Firmware Signing LoRa / LoRaWAN Time-sync Distributed Systems Hardware-Software Co-design Reverse Engineering Protocols Custom Debug Tooling Embedded Gateways Predictive Maintenance Hardware-in-the-loop CI BLE Mesh MQTT + TLS Industrial OPC-UA

ebpf_hooks.c C · eBPF/XDP

/* eBPF XDP packet filter — O(1) drop */
#include <linux/bpf.h>
#include <bpf/bpf_helpers.h>

SEC("xdp")
int xdp_firewall(struct xdp_md *ctx) {
  void *data = (void*)(long)ctx->data;
  void *data_end = (void*)(long)ctx->data_end;
  struct ethhdr *eth = data;
  if (eth + 1 > data_end) return XDP_DROP;
  struct iphdr *ip = (void*)(eth+1);
  if (ip->saddr == htonl(BLOCKLIST_IP)) return XDP_DROP;
  return XDP_PASS;
}
char _license[] SEC("license") = "GPL";

probe.rs Rust · Tokio

// Async port scan — zero unsafe, zero leaks
use tokio::net::TcpStream;
use std::time::Duration;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
  let tasks: Vec<_> = (1..1024).map(|port|
    tokio::spawn(async move {
      let addr = format!("10.0.0.1:{port}");
      tokio::time::timeout(
        Duration::from_millis(200),
        TcpStream::connect(&addr),
      ).await
    })).collect();
  futures::future::join_all(tasks).await;
  Ok(())
}

⊕

socket.cpp C++ · RAII

// RAII TCP socket — no leaks, ever
class TcpSocket {
  int fd_;
public:
  explicit TcpSocket(int domain = AF_INET)
    : fd_(::socket(domain, SOCK_STREAM, 0)) {
    if (fd_ < 0) throw std::system_error(
      errno, std::system_category(), "socket()");
  }
  ~TcpSocket() { if (fd_ >= 0) ::close(fd_); }
  TcpSocket(const TcpSocket&) = delete;
  TcpSocket& operator=(const TcpSocket&) = delete;
  [[nodiscard]] int fd() const noexcept { return fd_; }
  void connect(std::string_view host, uint16_t port);
};

█

kernel_module.c C · LKM

/* Loadable Kernel Module — netfilter hook */
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/netfilter.h>

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Zbigniew Holdys");

static int __init mod_init(void) {
  printk(KERN_INFO "[zh] module loaded\n");
  nf_register_net_hook(&init_net, &nfho);
  return 0;
}
static void __exit mod_exit(void) {
  nf_unregister_net_hook(&init_net, &nfho);
}
module_init(mod_init); module_exit(mod_exit);

∂

i2c_sensor.c C · Embedded/I2C

/* TMP102 temperature sensor via STM32 HAL */
#include "stm32f4xx_hal.h"
#define TMP102_ADDR 0x90U
#define TMP102_TEMP 0x00U

float TMP102_Read(I2C_HandleTypeDef *hi2c) {
  uint8_t buf[2] = { TMP102_TEMP };
  HAL_I2C_Master_Transmit(hi2c, TMP102_ADDR, buf, 1, 10);
  HAL_I2C_Master_Receive (hi2c, TMP102_ADDR, buf, 2, 10);
  int16_t raw = (buf[0] << 4) | (buf[1] >> 4);
  if (raw & 0x800) raw |= 0xF000; /* sign extend */
  return raw * 0.0625f;
}

crtp.cpp C++ · Templates

// CRTP — static polymorphism, zero runtime overhead
template<typename Derived>
struct Protocol {
  void send(std::span<const uint8_t> data) {
    static_cast<Derived*>(this)->send_impl(data);
  }
};

struct CANBus : Protocol<CANBus> {
  void send_impl(std::span<const uint8_t> d) {
    can_write(d.data(), d.size());
  }
};

struct SPIBus : Protocol<SPIBus> {
  void send_impl(std::span<const uint8_t> d) {
    HAL_SPI_Transmit(&hspi1, d.data(), d.size(), 10);
  }
};

∆

arm_cortex.c C · ARM Cortex-M

/* STM32 SysTick ISR — 1 ms heartbeat */
#include "stm32f4xx.h"

volatile uint32_t tick_ms = 0;

void SysTick_Handler(void) {
  ++tick_ms;
  if (tick_ms % 1000 == 0)
    LED_Toggle(LED_HEARTBEAT);
}

void delay_ms(uint32_t ms) {
  uint32_t t0 = tick_ms;
  while ((tick_ms - t0) < ms)
    __WFI(); /* sleep till next IRQ */
}

watchdog.rs Rust · no_std

// Rust no_std — IWDG watchdog on Cortex-M
#![no_std] #![no_main]

use cortex_m_rt::entry;
use stm32f4xx_hal::watchdog::IndependentWatchdog;
use stm32f4xx_hal::pac;

#[entry]
fn main() -> ! {
  let p = pac::Peripherals::take().unwrap();
  let mut wdg = IndependentWatchdog::new(p.IWDG);
  wdg.start(500u32.millis());
  loop {
    wdg.feed(); // reset timer or reboot
    do_work();
  }
}

≡

netlink.c C · Linux Netlink

/* Netlink — subscribe to kernel route events */
#include <linux/netlink.h>
#include <linux/rtnetlink.h>

int fd = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
struct sockaddr_nl sa = {
  .nl_family = AF_NETLINK,
  .nl_groups = RTMGRP_IPV4_ROUTE,
};
bind(fd, (struct sockaddr*)&sa, sizeof(sa));

char buf[8192];
ssize_t n = recv(fd, buf, sizeof(buf), 0);
struct nlmsghdr *nh = (struct nlmsghdr*)buf;
for (; NLMSG_OK(nh, n); nh = NLMSG_NEXT(nh, n))
  process_route(nh);

asyncio.py Python · asyncio

# Concurrent sensor polling — asyncio + aiohttp
import asyncio, aiohttp

async def fetch(session, url):
  async with session.get(url) as r:
    return await r.json()

async def pipeline(endpoints):
  async with aiohttp.ClientSession() as s:
    tasks = [fetch(s, u) for u in endpoints]
    results = await asyncio.gather(*tasks)
  return [normalize(r) for r in results
          if r.get("status") == "ok"]

nodes = [f"http://node-{i}/data" for i in range(16)]
data = asyncio.run(pipeline(nodes))

∇

optimizer.ts TypeScript · ML

// Gradient descent — typed, generic
type CostFn = (x: Float64Array) => number;

function gd(
  f: CostFn, x0: Float64Array,
  lr = 0.01, iters = 1000
): Float64Array {
  let x = x0.slice(); const h = 1e-5;
  for (let i = 0; i < iters; i++) {
    x.forEach((_, j) => {
      const fwd = x[j]; x[j] += h;
      const grad = (f(x) - f(x0)) / h;
      x[j] = fwd - lr * grad;
    });
  }
  return x;
}

⊗

lockfree.cpp C++ · Lock-Free

// SPSC lock-free ring — cache-line aligned
template<typename T, size_t N>
class SpscQueue {
  alignas(64) T buf_[N];
  alignas(64) std::atomic<size_t> head_{0};
  alignas(64) std::atomic<size_t> tail_{0};
public:
  bool push(T v) {
    auto h = head_.load(std::memory_order_relaxed);
    auto nh = (h + 1) % N;
    if (nh == tail_.load(std::memory_order_acquire)) return false;
    buf_[h] = std::move(v);
    head_.store(nh, std::memory_order_release);
    return true;
  }
};

// career

Work Experience

From the very first Linux mobile phones and Siemens embedded systems, through SmartTV platforms and YouView/Netflix certification, to industrial IoT at Vestas and cloud architecture at SAP.

2015 – Present

Liga Niezwykłych Umysłów / T-LEM.COM ● Active

Co-Founder · Technical Director / CTO · Self-employed · Wrocław

Co-created the innovative LEM platform used by tens of thousands of students and teachers across Poland (edu-dagon.t-lem.com).
Technical Director / CTO: overall system architecture, technology roadmap, engineering team leadership.
Full-stack platform architecture: backend microservices, real-time collaboration engine, sandboxed code execution environments.
Platform supports individual and group programming education, tailored to student interests and predispositions.
Product: integrated IDE, automated assessment, gamification, video lessons, AI-assisted feedback.

2018 – 2020

YouView TV Limited

Senior Software Developer · Contractor · London, UK

IP Player & Media developer: Netflix, YouTube, Amazon Player, BBC Player.
YouTube 2019 / Netflix 2019 certification lead developer.
GStreamer audio/video plugin developer (DashDemux, PlayBin, Video Decoders & Filters); hardware decoding vendors (Broadcom, Humax, Intel).
Porting Layers and Video backends based on Wayland/Weston/Westeros/OpenGL.
EME/MSE, CDM, DRM, WebCrypto, Secure Video Path — BCM Nexus porting layers.
Implementing AV features: review buffers, trickplay, VOD, timeshift and linear playback.

2016 – 2018

LGI / consult.red (contractor)

Technical Team Leader · Senior Software Developer · Scrum Master · Wrocław

WebKit-based browser development on 4 different STB platforms, including standalone browser application.
EME/MSE, CDM, DRM, WebCrypto layer integrator — Playready & Widevine DRM; Secure Video Path (Intel, BroadCom-Nexus).
YT2017 passed certification under heavy conformance test conditions.
GStreamer plugin developer: DashDemux, PlayBin, Video Decoders & Filters; Wayland/Weston/OpenGL video backends.
OTT Application development (native API, OIPF, BBC, STB services API).
IP Player team leader, product specification & documentation.

2014 – 2015

SOFTITI (contractor)

Product Manager · Program Manager · Wrocław

DigitalTV, SmartTV, TV/STB, Video Broadcast consultant. Security and quality advisor in STB branch.
Project management with Scrum, Kanban, Lean6Sigma methodology.
Direct contact with SW customers, HW vendors, STB architects, UI designers.
Backlog management, project planning, risk analysis, budget planning, team capacity management.
International partners: Sweden, Greece, Germany, USA, India, China.

2012 – 2014

Nokia Networks

Line Manager · Product Owner · Development Project Leader · Wrocław

Backlog management, project planning, risk analysis. Feature development & maintenance team leader.
Team capacity management, definition of done. C/C++ Senior Software Programmer.
API and documentation reviewer. Recruitment support; knowledge transfer / training.
Creating internal department standards. R&D and Tools & Improvements meetings.
Reducing memory footprints, algorithm optimisation, code profiling, hardware debugging.

2006 – 2012

Opera Software International AS

Project Manager · Senior Software Architect · Wrocław

Programming leader: Linux C/C++, Linux SDK, Linux & TV deliveries departments.
Linux platform architect, SDK designer; worked with dozens of hardware vendors (ARM, MIPS, PowerPC, Intel, Nvidia, Broadcom, Qualcomm).
Memory footprint reduction, algorithm optimisation, code & hardware profiling (Lauterbach, JTAG).
HbbTV / Web standards, API & documentation, developer libraries and tooling.
International collaboration: India, China, Korea, Japan, Germany, UK, USA.

2005 – 2006

BenQ Poland

Software Architect · Project Leader · Wrocław

Responsible for PC Simulator architectural design for mobile devices.
Led a team of 5 developers in the PC Simulator project.
Documenting architecture, system design and creating department standards.

2004 – 2005

Siemens Poland

Software Developer · Wrocław

C/C++ embedded Linux development in Mobile Phone department. Originated new division for first Linux-based phones for Siemens.
Leading PC Simulator team; developer tools for SW/HW debugging.
BREW emulator environment for Mobile Phone Development, reducing development costs across several projects.
Deep GSM / GPRS / UMTS telecommunication standard knowledge.

2002 – 2004

Technical University of Opole

UNIX Programmer · System Administrator · Opole

Administration of the network and informatics infrastructure of Opole University.
Preparing C/C++ lab tools and solutions for students: network security, threading, database access.
Maintaining main Internet access servers and service infrastructure.

// education & achievements

Education & Notable Achievements

MSc in Computer Science, two national Informatics Contest finals, and a lifelong passion for open-source, music and sports.

🎓 Education

1999 – 2004 · Technical University of Opole

Graduate of the Computer Science Department.
Master of Science & Engineer degree in programming of informatics systems.
Founder of the Opole Linux Users Group (OpLUG).
Active member of the Informatics Scientific Circle INFORMAT.
Member of the Movement for Free Software.

🏆 Certifications & Achievements

Recognitions & Professional Certifications

Certified Scrum Master (CSM).
PMI / PMBOK Project Management certification.
Certifications: Planning & Organization, Team Communication, Group Coaching, Situational Leadership.
Double finalist of the National Informatics Contest.
Title of "Opole High-Flier of 1999" appointed by the Lord Mayor of Opole City.

🎯 Hobbies & Interests

Beyond the terminal

Music Acoustics Sport Mathematics Physics Open Source Linux OpLUG Free Software Movement Competitive Programming

🔧 Hardware & Toolchain Experience

Architectures & Vendors

ARM, MIPS, PowerPC, Intel, Nvidia, Broadcom, Qualcomm.
Cross-compilation toolchains, distributed build systems.
Hardware debugging: Lauterbach, JTAG, BDM, NEXUS.
OS exposure: Linux (Android, Yocto, Buildroot), OSE RTOS, Qualcomm BREW, Windows CE.
Industrial PLCs: Rockwell Studio5000, Siemens TIA Portal, CoDeSys.

Zbigniew
Hołdys

Core Competences