Senior Backend / Platform / MLOps Engineer
Distributed Systems · Go · Rust · Embedded Linux · Infrastructure · Reliability

Remote · rewanderer@proton.me

I build backend, platform, and embedded Linux systems where failures are expensive, behavior must be deterministic, and every decision must be explainable.

My focus is on long-lived, infrastructure-heavy and device-adjacent systems operating under strict constraints: security, auditability, offline environments, firmware delivery, hardware integration, and real-world protocol complexity.

I work best on systems that must remain correct, observable, reproducible, and operable years after the original authors have left.

• Backend systems with explicit state machines and well-defined failure semantics
• Infrastructure where reproducibility and auditability are first-class requirements
• Embedded Linux platforms built on custom Buildroot-based operating systems, including package integration, rootfs composition, firmware image assembly, and reproducible delivery pipelines
• Systems where observability is designed before the first incident
• Tooling that reduces operational and cognitive load over time
• Network and system software where command behavior must be provable against real runtime state, firmware, and hardware targets

• Correctness over cleverness
• Determinism over hidden state
• Operational clarity over theoretical elegance
• Explainability over magic
• Reproducibility over one-off fixes
• Long-term maintainability over short-term wins

• Go, Rust, Python
• REST, gRPC, WebSockets
• SOAP / WS-*, ONVIF, RTSP
• Distributed systems & protocol-heavy integrations
• Event-driven architectures
• Deterministic and audit-ready backend design
• Clean Architecture, pragmatic DDD
• Backend systems running on constrained, embedded, and hardware-adjacent environments

• Custom Buildroot-based operating systems
• Package integration and root filesystem composition
• Firmware image assembly and release preparation
• Hardware-software integration on constrained devices
• Reproducible firmware delivery pipelines
• Validation on target hardware and virtual environments

• PostgreSQL, MySQL, SQLite
• Redis
• Kafka, RabbitMQ
• Consistency models and failure semantics

• Linux (production operations)
• Docker, Docker Compose
• Kubernetes
• Helm, Kustomize
• CI/CD (GitHub Actions, GitLab CI, Jenkins, Zuul)
• Hermetic and reproducible builds
• Air-gapped and offline deployments

• Prometheus, Grafana
• OpenTelemetry
• Metrics, tracing, structured logs
• Incident-driven debugging
• Production diagnosis under real hardware and infrastructure constraints

• TLS / DTLS
• Secure transport design
• Authentication & authorization
• OIDC / JWT
• Policy enforcement
• Real-world network protocol integration

• ML infrastructure and data-processing systems
• Production-oriented model integration
• Experiment automation and evaluation workflows
• Inference-oriented backend design
• Applied ML systems under infrastructure constraints

Oct 2025 – Present

• Developed and maintained Go/Rust-based backend services for distributed industrial systems.
• Designed and implemented microservice-based backend architectures using REST APIs and explicit inter-service contracts.
• Built reliable communication flows between system components under real operational constraints.
• Integrated backend services with embedded devices and microcontrollers.
• Configured and supported CI/CD pipelines for build, validation, and delivery automation.
• Wrote unit and integration tests to improve system reliability and regression safety.
• Prepared technical documentation and API specifications.
• Collaborated with hardware and system engineers on architectural decisions.
• Worked on a Rust-based Network Operating System with a typed control plane, explicit command modeling, and runtime ownership across Linux and daemon-backed execution domains.
• Built command-conformance and release-truth pipelines that verify CLI behavior, runtime effect, live readback, and replay/persistence instead of relying on parser-only support claims.
• Integrated firmware-level validation through Buildroot and QEMU, and designed CI/CD flows for end-to-end command verification on both virtual and hardware targets.
• Focused on turning CLI-visible functionality into real, evidence-backed platform behavior with deterministic failure reporting and production-oriented release gating.

Oct 2023 – Oct 2025

• Designed and implemented backend services in Go for protocol- and infrastructure-heavy systems.
• Built systems with strict requirements for correctness, reliability, and fault tolerance.
• Implemented protocol-level integrations (ONVIF, RTSP, secure transport), handling real-world edge cases.
• Developed backend services and platform components for devices running on custom Buildroot-based embedded Linux systems.
• Participated in OS image preparation, package integration, root filesystem composition, and firmware build pipelines for target hardware.
• Integrated backend services with hardware devices, embedded platforms, and external systems, operating under real-world I/O, latency, and failure constraints.
• Owned systems end-to-end: architecture, implementation, deployment, and operational support.
• Improved observability and debuggability through metrics, structured logging, and tracing.

Aug 2024 – Jun 2025

• Designed and implemented backend services for research and applied systems.
• Built an end-to-end audio processing and classification system, from data ingestion to execution and evaluation.
• Developed backend components and processing logic for embedded and hardware-adjacent environments.
• Built ML infrastructure and data-processing systems for training, experimentation, and evaluation.
• Integrated software with hardware devices, embedded platforms, and external systems, handling real-world constraints.
• Developed research prototypes and automated laboratory workflows.
• Prepared datasets and built automation tooling for data collection, preprocessing, and validation.

• Building a Network Operating System (NOS) in Rust with a Cisco-like CLI, typed control plane, and explicit runtime ownership across Linux and daemon-backed domains.
• Designing and implementing an evidence-driven command conformance system: parser/help parity, runtime effect validation, live readback, replay/persistence checks, and release-truth generation.
• Working on end-to-end firmware validation through Buildroot + QEMU, with live execution scenarios and production-oriented CI/CD gates for both virtual and hardware targets.
• Extending the system from CLI surface parity to real functional parity of commands on firmware and target hardware, with honest support reporting and artifact-backed verification.
• Focus: NOS architecture, Rust system software, command modeling, firmware validation, reproducible CI/CD, embedded Linux runtime correctness.

• Built backend services in Go for a NAS device running on a custom Buildroot-based operating system on a Russian processor.
• Participated in development and maintenance of the device OS image: Buildroot configuration, package integration, root filesystem composition, and firmware build orchestration.
• Owned CI/CD end-to-end: from OS and firmware builds to automated functional validation on target hardware.
• Set up and maintained delivery and verification pipelines using Jenkins, GitLab CI, Zuul, and Grafana.
• Focus: reproducible firmware delivery, embedded Linux platform engineering, package integration, and hardware-level validation.

• Implemented backend and system logic for an access control solution running on a Russian processor.
• Worked with Go, Buildroot, and ONVIF, integrating the system with security and video-surveillance infrastructure.
• Participated in development of a custom Buildroot-based OS for the device, including package assembly, system image preparation, and integration of platform-specific components.
• Built and debugged software running directly on embedded hardware under strict reliability constraints.
• Focus: protocol interoperability, embedded Linux platform integration, custom firmware builds, and hardware-software integration.

• Developed backend services in Go for a Smart PDU used for remote power control and telemetry.
• Designed and implemented internal and external communication via gRPC.
• Participated in building a custom Buildroot-based operating system for the device, including package integration, image assembly, and preparation of reproducible firmware artifacts.
• Built logic for command execution, device state reporting, and reliable control flows.
• Focus: deterministic device management, embedded Linux firmware assembly, remote operations, and service-to-device communication.

• Built an end-to-end audio processing pipeline using Go, Python, PyTorch, FFT, and DSP.
• Implemented sound filtering, feature extraction, and classification logic for real-world audio streams.
• Worked on preprocessing, evaluation, and integration of ML and signal-processing components.
• Focus: applied ML, real-time signal processing, production-oriented experimentation.

• Worked on an enterprise-grade computer vision platform for image detection and classification from camera streams.
• Built or integrated a stack around Rust, Python, PyTorch, ONNX, ONNX Runtime, and GPU-oriented inference.
• Focused on production inference architecture, deployment simplicity, and runtime efficiency.
• Focus: CV infrastructure, model serving, performance-sensitive backend design.

MIREA — Russian Technological University (Moscow)
MSc, Information Security of Telecommunication Systems — 2025

• Studied secure ML pipelines, adversarial robustness of neural networks, and model vulnerability assessment.
• Designed and deployed ML workflows including data versioning, model training, monitoring, and automated deployment.
• Applied DevOps practices in large-scale secure infrastructure, implementing centralized logging and monitoring (ELK stack), identity and access management (Keycloak), RBAC policies, OAuth2/OpenID Connect authentication flows, and secure configuration of distributed services.
• Built applied projects involving backend services, ML systems, and production-oriented model integration.

MIREA — Russian Technological University (Moscow)
BSc, Software Engineering — 2023

• Studied machine learning fundamentals, neural networks, data analysis, optimization methods, multi-agent systems, and evolutionary programming.
• Completed academic projects involving neural network models, data processing pipelines, and decision support systems.
• Developed backend-oriented projects in system programming and applied software engineering.
• Worked with Verilog, implementing and integrating simple computational models into hardware modules.
• Completed structured coursework in computer networking based on Cisco and Huawei curricula, covering routing & switching, network protocols, and enterprise infrastructure design.

_{I build systems that remain correct, observable, and operable years after the original authors have left.}