I design and build embedded and distributed systems — board bring-up, real-time firmware, embedded Linux, device networking and accelerated inference at the edge — and validate them on real hardware.
Subject · engineerKochi · India9.9312° N 76.2673° E Channel open
Systems · Engineer
Role
Software Design Engineer
Focus
Embedded systems
Base
Kochi · India
Platform
Linux
Code
GitHub
Writing
dev.to
// Think in systems. Build in layers.Scroll ↓
01Selected work
Systems I have built.
Embedded, Linux, networking and edge-AI systems — described at the level of architecture and approach.
Selected engineering work is presented at a high level. Proprietary implementation details, source code, internal architecture and company-specific information are intentionally omitted. Work shown reflects engineering experience, not independently owned products.
S-01
Thermal sensor
Local processing
Zone logic
MQTT
Monitoring
Embedded thermal monitoring system
Embedded · IoT · Edge sensing
Developed embedded software for a thermal sensing and occupancy-monitoring system, integrating sensing, local processing, connectivity, persistent configuration and remote monitoring.
Technologies
C/C++
ESP32-class MCU
Thermal sensing
MQTT
Wi-Fi
BLE
OTA
S-02
Node A
Node B
Node C
Node D
Application
Multi-node communication
Networking · Distributed systems
Worked on communication architectures for systems involving multiple network nodes, telemetry transport and distributed device coordination.
Concepts
IP networking
Multi-node communication
Routing
Telemetry
Distributed architecture
Fault handling
S-03
Hardware
RTOS / HAL
Config · Network · OTA
Device services
Application
Embedded device platform
Embedded · Firmware · IoT
Built embedded software infrastructure covering device configuration, provisioning, persistent storage, connectivity, monitoring and firmware updates.
Layers
Provisioning
Persistent config
Connectivity
Monitoring
OTA update
RTOS / HAL
S-04
Docs
Embed
Index
Retrieval
Ollama · Qwen
Emacs
// Nothing leaves the machine
Local AI over engineering documentation
Local LLM · Retrieval · Developer tooling
A local retrieval-augmented setup that makes a personal software and design documentation base queryable from the development environment — Qwen models served by Ollama on the host, reached through gptel inside Emacs, with retrieval over the notes supplying the context for each answer.
Components
Ollama
Qwen / Qwen Coder
Local inference
gptel in Emacs
RAG over docs
Embeddings + vector index
S-05
Boot ROM
SPL / U-Boot
Kernel + DTB
Rootfs
// ROM to userspace on a new board
SoM bring-up on custom hardware
Embedded Linux · Yocto · Board bring-up
Brought up an NXP i.MX8-class system-on-module on a custom carrier board — bootloader and kernel configuration, device-tree work to describe the board's peripherals, and a Yocto-based BSP producing the image, from boot ROM through to a running userspace.
Scope
i.MX8-class SoM
Yocto / OpenEmbedded
BSP layers + recipes
U-Boot
Linux kernel
Device tree
S-06
Org source
C4 blocks + prose
Org export
HTML · Reveal.js
// One source · two published forms
Architecture documentation system
Org-mode · PlantUML · C4 · Documentation tooling
A documentation system where architecture diagrams live in the same Org files as the prose explaining them — C4-PlantUML sources rendered on export, a custom stylesheet for HTML and Reveal.js for presentations. One source, two published outputs, and diagrams that cannot drift from the text.
Pipeline
Org-mode
PlantUML
C4-PlantUML
Automated export
Custom CSS
Reveal.js
S-07
Video in
Pre-process
DPU
Detections
Application
// Inference in the programmable logic
DPU-accelerated person detection
FPGA SoC · AI acceleration · Computer vision
Person detection on the deep-learning processing unit of a Xilinx UltraScale+ platform — the video path into the accelerator, deploying the detection model onto it, and optimising that model for embedded inference.
Scope
Xilinx UltraScale+
DPU accelerator
Hardware-accelerated inference
Person detection
Model deployment
S-08
Camera sensor
CSI-2
CSI receiver
V4L2
Vision
MIPI CSI-2 camera integration
Linux · V4L2 · Camera bring-up
Brought up camera sensors over MIPI CSI-2 on embedded SoCs — a V4L2 driver for the sensor, I²C register configuration, device-tree description of the CSI link, and end-to-end debugging of the video pipeline feeding vision processing.
Path
MIPI CSI-2
V4L2 driver
Sensor bring-up
I²C configuration
Device tree
Video pipeline debug
S-09
Cortex-A9 PS
FreeRTOS tasks · ISRs
AXI
Prog. logic
// Fabric interrupts return to the tasks
Zynq-7000 real-time firmware
Zynq-7000 · FreeRTOS · HW/SW integration
Real-time firmware on a Xilinx Zynq-7000, with FreeRTOS on the Cortex-A9 processing system driving peripherals in the programmable logic — task and interrupt architecture, synchronisation, and bring-up either side of that boundary.
Scope
Zynq-7000 SoC
ARM Cortex-A9
FreeRTOS
Programmable logic
Interrupt handling
Task synchronisation
S-10
PIC32 MCU
Drivers / ISRs
FreeRTOS kernel
Queues · timers
Tasks
PIC32 real-time firmware
PIC32 · FreeRTOS · Embedded firmware
Embedded firmware on a Microchip PIC32 under FreeRTOS — a real-time task architecture with inter-task communication and synchronisation, interrupt handling, peripheral integration and hardware bring-up.
Two views I return to constantly: how data flows through a system, and how a system stacks from silicon to the person using it.
Data flowsensor → user
Sensorsacquisition
Edge processingfilter · fuse · decide
Communicationtransport · protocol
Distributed servicesstate · coordination
Control / visualisationoperator surface
System layersbidirectional
L6UserThe operator surface: what a person needs to see, decide and override.
L5ApplicationMission logic, coordination and the services that hold shared state.
L4NetworkTransports, routing and what happens when delivery fails or a node disappears.
L3OSEmbedded Linux or an RTOS — scheduling, drivers and the boundary to user space.
L2FirmwareBring-up, interrupts, timing and the code closest to the silicon.
L1HardwareSensors, SoCs and carrier boards — where every design is finally proven.
How I build
01Problem
02Requirements
03Architecture
04Prototype
05Implement
06Integrate
07Test
08Validate
> Architecture before implementation.
> Prototype early.
> Validate on real systems.
> Understand the entire stack.
03Tooling
Systems stack.
Grouped by engineering domain rather than scored — each group notes where it connects.
Software
C
C++
Python
Bash
→ every layer below
Embedded
ESP32
Sensors
UART
SPI
I2C
MQTT
OTA
BLE
→ device · edge sensing
Robotics
ROS 2
SLAM
Sensor fusion
→ perception · control
Networking
TCP/IP
UDP
Mesh
Ad-hoc routing
Telemetry
→ multi-node systems
Linux
Arch Linux
GCC
GDB
Git
tmux
zsh
Emacs
→ development environment
Engineering
KiCad
PlantUML
C4
Architecture
Git / Gerrit
→ design · review · docs
arun@workstation Ready
OS
Arch Linux
WM
i3
Term
tmux + zsh
Editor
Emacs / Spacemacs
Build
GCC / CMake
Debug
GDB
VCS
Git / Gerrit
Design
KiCad / PlantUML
A keyboard-driven Linux environment — tiling windows, persistent terminal sessions, one editor for code and notes. The point isn't minimalism; it's removing the distance between a thought and a running test.
Open source · github/arun-jyothishStandby
—
Public repos
—
Stars
—
Languages
Repositories and languages load live from the public GitHub API — nothing is shown until they arrive.
I build systems where software meets hardware — from the first boot of a new board to the services and interfaces that sit on top of it.
Most of my work sits on boundaries — between firmware and the operating system, between a device and the network it reports to, between a control algorithm and the machine it actually moves. Those boundaries are where designs are proven or quietly fail, so that is where I spend attention.
I work in a Linux environment end to end, read specifications before writing code, and prefer to validate on the real system rather than only in simulation.
Architecture
Embedded software
Hardware/software integration
Networking
Distributed systems
Robotics
Edge intelligence
Linux
Experience
Software Design Engineer
Employer details available on request · work described generically
—System and software architecture for embedded and distributed products
—Embedded firmware development and hardware bring-up
—Network and telemetry communication between devices and services
—Integration, debugging and validation on real hardware
—Code review and version control workflows (Git / Gerrit)
Engineering log
[ Systems ]Understanding multi-node routingHow packets actually find their way between peers, and what breaks first when a node disappears.Draft
[ Embedded ]Building reliable device provisioningIdentity, persistent configuration and first-boot flows that survive the field.Draft
[ Linux ]Engineering a keyboard-driven development environmentWhy the terminal, the editor and the build system should feel like one tool.Draft
[ Networking ]Designing IP-based device communicationChoosing transports, framing telemetry and deciding what to do when delivery fails.Draft