Alexey Sudachen (Senior SSE)

Alexey Sudachen

Senior Systems Software Engineer
Location: Remote, Chile (CLT, UTC-4) | Email: alexey@sudachen.name
GitHub: github.com/sudachen | LinkedIn: linkedin.com/in/sudachen
Download PDF Version

OVERVIEW

Senior Systems Software Engineer with 10+ years of experience building data planes and infrastructure for distributed, compute-intensive systems. Bringing hands-on expertise in asynchronous (Tokio) and low-level (FFI/Syscalls) Rust, P2P networking, and kernel abstractions (eBPF/XDP, C/C++), I bridge the gap between high-level architecture and physical hardware limits. I take full ownership of system design, performance benchmarking, and production reliability.

CORE EXPERTISE

Systems Architecture & Memory: Async & Unsafe Rust (Tokio, FFI, Syscalls), Go (Cgo), C/C++, Zero-Allocation Pipelines, OS Internals.
Networking & Data Planes: High-Throughput Ingestion, Custom Packet Filtering (eBPF/XDP concepts), TCP/IP L3 Tunneling, P2P Protocols.
AI Infrastructure & Data Systems: Embeddable SLM Inference Engines, Native CPython Extensions (PyO3/C-API), WASM Compute Isolation.
Engineering Ownership & Reliability: Performance Benchmarking Harnesses, Fuzzing & Regression Testing, Continuous Integration Infrastructure.

SELECTED OPEN SOURCE and SYSTEMS R&D

slm_inference_rs (github.com/sudachen/slm_inference_rs): Lightweight, embeddable Rust inference framework for Small Language Models (GGUF format) with C/C++ backend bindings and zero-allocation weight mapping.
xdp_rs (github.com/sudachen/xdp_rs): High-performance Rust abstractions and bindings for Linux eBPF/XDP (eXtended Data Path) kernel packet processing.

EXPERIENCE

Senior Systems Engineer ║ Remote — current

Full-time remote IC role focusing on core network infrastructure, cloud-managed WireGuard VPN architectures, and edge DPI traffic filtering.

Custom L3 Tunneling: Engineered a custom TCP/IP L3 tunneling extension in Golang for an existing remote access platform, enabling secure network overlays and seamless protocol encapsulation.
Cloud-Managed VPN Architecture: Architected a high-throughput, cloud-managed VPN infrastructure based on the WireGuard protocol utilizing Rust for core control/data logic and Kubernetes (K8s) for scalable control-plane orchestration.
Edge DPI & Analytics: Implemented a lightweight DPI-based (Deep Packet Inspection) traffic filtering engine in Rust for resource-constrained OpenWrt routers, integrated with cloud-based analytics and management pipelines (Python/Bash).

Senior Software Engineer / Founding Engineer ║ Analog One (Remote) — 2022–2025

Architected and led the core engineering of a high-throughput, fault-tolerant distributed data ingestion engine in Rust.

Architectural Ownership: Owned the technical roadmap and architecture from initial prototype to mainnet production, establishing core data models, network interfaces, and state-consistency guarantees.
High-Throughput Ingestion Engine: Engineered a high-concurrency event processing system in Rust, scaling system throughput across decentralized nodes using Tokio async, sharding, and WASM-sandboxed execution for read-only blockchain actions.
Systems Reliability & Testing Harness: Architected an automated testing and performance-benchmarking harness in Rust, isolating concurrency race conditions, and preventing performance regressions prior to production releases.
Production Deployment: Built deterministic CI/CD pipelines and deployment workflows (Docker/AWS).

Senior Systems Engineer (P2P/Consensus) ║ Spacemesh.io (Remote) — 2020–2022

Core developer within the consensus engineering team for a Layer-1 blockchain (go-spacemesh), specializing in P2P propagation, deterministic math, and Go/Rust VM boundaries.

Fast Consensus & Eligibility Engine: Owned the implementation of core modules within the fast Hare consensus protocol, including dynamic participant election, role assignment, and vote aggregation per epoch.
Deterministic Fixed-Point Math: Developed a high-performance, deterministic fixed-point math library in Go to guarantee hardware-independent reward and consensus weight calculations across heterogeneous node architectures.
P2P Message Propagation: Optimized P2P networking layers (libp2p) for rapid transaction and consensus message propagation, reducing block propagation delays under high node concurrency.
Go/Rust VM Integration: Managed Cgo/FFI execution boundaries between the Go node and the Rust-based Virtual Machine (SVM/Wasmer), minimizing memory allocation overhead and call latency during smart-contract execution.
Distributed Liveness & Infrastructure: Resolved critical timing and synchronization issues within the Proof-of-Elapsed-Time (PoET) service to prevent network-wide epoch liveness stalls; maintained deterministic integration testing pipelines.

ML Systems Engineer / Data Scientist II ║ Vacasa (Hybrid) — 2018–2020

Bridged Machine Learning workflows with low-level systems engineering, building automated ETL data pipelines and optimizing Python model inference via native C++/Rust extensions.

High-Performance ML Extensions: Built predictive models (Python, SQL) and accelerated critical execution paths by writing native C++/Rust extension modules to eliminate Python interpreter bottlenecks during real-time inference.
Data Pipeline Infrastructure: Architected and automated high-volume ETL ingestion pipelines (Airflow, Terraform, Docker), ensuring data consistency and low-latency access for downstream ML model execution.

R&D Engineer / C++ Developer ║ Kaspersky Lab / DLP Research (Remote) — 2012–2018

Engineered pre-OS security solutions and driver architecture using EDK II / TianoCore within the UEFI environment.

Bare-Metal Network Drivers (PCI/MAC): Ported Linux network device drivers to the UEFI environment (EDK II), interacting directly with PCI configuration space, MMIO registers, MAC/PHY layers, and DMA ring buffers for pre-boot network access.
USB SmartCard & Token Drivers: Developed custom UEFI DXE drivers implementing USB CCID protocol parsing and APDU packet handling within the pre-boot DXE environment.
Pre-OS Process Isolation: Created a proprietary Windows DLL abstraction loader operating directly inside the UEFI memory space, enabling secure pre-boot execution before OS kernel initialization.
Encrypted Storage Interception: Implemented low-level interception mechanisms for encrypted GPT disk operations during the pre-boot phase.

EARLY HIGHLIGHTS and FOUNDING R&D

MoleBox (Founder & Lead Developer): Architected a commercial Windows executable packer and runtime virtual file system (C/C++, Assembly, Win32 Internals). Enabled transparent file encryption and DLL virtualization without application modifications.
SpriteCraft Engine (Founder and Developer): Built a 2D/3D graphics engine from scratch in C++, featuring custom memory allocators, asset pipelines, and low-level rendering optimizations.
High-Throughput Telecom Engines: Designed and built a high-availability SMSC/USSD messaging gateway for a Tier-1 telecom provider, managing high-volume concurrent SS7/SMPP protocol traffic under strict uptime guarantees.
Real-Time Media & Streaming: Built a 0-to-1 MVP video streaming platform (RTSP/RTP) and developed a high-concurrency VoIP media-switching engine for low-latency voice routing.
Embedded & Driver Development: Engineered a custom kernel-mode display driver for handheld devices (WinCE/ARM), implementing hardware-level framebuffer scaling and memory-optimized graphics algorithms without 3D acceleration.