Senior Backend / Platform Engineer
Go-first · Rust-enabled · Distributed Systems · Embedded Linux · 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 strongest profile is Go backend engineering for distributed, integration-heavy, and hardware-adjacent systems.
Rust is a strong secondary language for systems and platform work, while Python is used for tooling, automation, and ML-adjacent workflows.

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
• Distributed services where API behavior, integration boundaries, and failure handling must remain predictable over time
• Embedded Linux platforms built on custom Buildroot-based operating systems, including package integration, rootfs composition, firmware image assembly, and reproducible delivery pipelines
• Infrastructure where reproducibility, auditability, and operational clarity are first-class requirements
• Systems where observability is designed before the first incident
• 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 and protocol-heavy integrations
• Event-driven architectures
• API design, compatibility, and service evolution
• 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

• Develop and maintain Go/Rust-based backend services for distributed industrial systems with strong requirements for reliability and predictable behavior.
• Design and evolve microservice-based backend architectures using REST APIs and explicit inter-service contracts.
• Build reliable communication flows between system components under real operational constraints.
• Integrate backend services with embedded devices and microcontrollers.
• Configure and support CI/CD pipelines for build, validation, and delivery automation.
• Write unit and integration tests to improve regression safety and operational confidence.
• Prepare technical documentation and API specifications.
• Collaborate with hardware and systems engineers on architectural decisions.
• Work 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.
• Build 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.
• Integrate firmware-level validation through Buildroot and QEMU, and design CI/CD flows for end-to-end command verification on both virtual and hardware targets.
• Focus 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.}