Hire Contract
Rust Developers

Designed a stable ABI for cross-language Rust interoperability, including an intermediate representation, generated type conversions, validity checks, opaque types, generics, custom DSTs, and runtime tagged dispatch. Added WebAssembly smart-contract execution to Hyperledger Iroha and corrected consensus, fault-handling, and peer-synchronization defects.

• Unsafe Rust and memory-layout engineering
• Procedural macro and code-generation tooling
• cbindgen associated-type resolution
• Concurrent Java ETL and stream replication

Architected Rust event-driven services on AWS EKS processing more than one million concurrent interaction events across multiple production deployments. Built exactly-once pipelines across Kinesis, Lambda, DynamoDB, PostgreSQL, and Redis, with sub-second delivery and automated infrastructure managed through Terraform, Helm, and ArgoCD.

• LGTM observability stack
• Backpressure-aware event processing
• AI recommendation infrastructure
• GitOps deployment automation

Builds Rust and Bun microservices for real-time, AI-driven threat detection and security intelligence. Has designed Kubernetes infrastructure on AWS and worked across e-commerce fulfillment optimization, cloud platforms, multidimensional databases, and headless commerce.

• API architecture and developer advocacy
• E-commerce date-delivery optimization
• Data migration and platform modernization
• Security and regulatory compliance engineering

Builds Rust backend services, compilers, domain-specific languages, and embedded-systems software. Created a Rust implementation of a custom programming language, shipped PostgreSQL-backed production APIs, and maintains open-source packages across crates.io and npm.

• Designed REST and WebSocket interfaces
• Optimized PostgreSQL queries and schemas
• Built reproducible environments with NixOS
• Won an IEEE hardware-demo award for side-channel tooling

Develops Rust systems spanning embedded control software for marine vessels and drones, backend services, and WebAssembly applications. Co-created a real-time collaborative audio workstation using Rust, WASM, and CRDTs, combining low-latency state synchronization with cross-platform interfaces.

• ESP32 and NVIDIA Jetson embedded targets
• CAN, Modbus, and NMEA protocol integration
• Flight-controller software for autonomous drones
• Substrate and Ink! smart-contract development

Works across Rust, WebAssembly, Python, TypeScript, Java, and Apache Spark. The available profile indicates a systems and data-engineering focus, but does not provide specific infrastructure scale, protocol domains, or project outcomes.

• WebAssembly runtime development
• Apache Spark data processing
• Python automation tooling
• TypeScript application development

Works on Rust asynchronous systems and modular applications while applying long-term maintainability practices to complex enterprise codebases. Current research projects combine C++, CUDA, LibTorch, and tch-rs for GPU-accelerated machine-learning and numerical workloads.

• CUDA and GPU resource integration
• IPC and process-level resource management
• CMake, Cargo, Docker, and GitHub Actions
• Incremental refactoring of large Java systems

Designed and implemented distributed systems for high-availability services using Rust and Python. Led teams in developing blockchain-based applications with a focus on smart contract security.

• Optimized SQL databases for performance and scalability
• Authored technical documentation for complex system architectures
• Contributed to open-source distributed ledger projects

Built GPU-resident simulation infrastructure for physically based animation, open-ended multi-agent environments, and reinforcement-learning workloads. Implemented pipeline-parallel decentralized LLM inference that streams intermediate activations across machines, plus WASI-based RPC interfaces between processes and nodes.

• CUDA miner reaching 150 proofs per second
• Correctness-gated autoresearch profiling harness
• llama.cpp, tinygrad, and Candle integration
• Embedding-based decentralized recommendation indexers

Engineered a decentralized finance protocol on Ethereum, focusing on security and gas optimization. Developed smart contract frameworks for Solana, enabling efficient cross-chain transactions. Contributed to the core development of a blockchain consensus mechanism, enhancing throughput and latency.

• Created a custom Rust-based library for cryptographic operations
• Integrated TypeScript tooling for blockchain application interfaces
• Designed a Solidity-based tokenomics model for a new crypto asset
• Built a cross-platform wallet application with advanced security features

Designed and delivered a mediation-based privileged-access management architecture that isolates authorized database, web, SSH, Telnet, and RDP access while retrieving credentials from rotating vaults. Builds production Rust security tooling with Tokio-based asynchronous services, containerized releases, automated testing, and algorithmic components.

• Session recording for privileged access
• Multi-toolchain CI and coverage automation
• Serde-based systems data handling
• Clap-powered command-line utilities

Designs and operates distributed services and data infrastructure in Go and Rust, including modernization of legacy advertising platforms into AWS and Kubernetes microservices. Recent systems work also covers event processing, workflow engines, and integrating agentic LLM capabilities into production applications.

• Built analytics pipelines with Apache Arrow Flight and Parquet
• Implemented messaging flows using NATS and RabbitMQ
• Used AWS Kinesis, Firehose, Glue, and Athena
• Developed local-model workflows with vLLM and LangGraph

Developed robust backend services using Rust for cloud-native applications. Integrated Nix-based deployment pipelines, ensuring reproducible builds and environments. Contributed to open-source projects focused on improving developer tooling in Rust.

• Created a TypeScript-to-Rust FFI for seamless integration
• Automated CI/CD workflows with GitHub Actions
• Enhanced API performance with custom caching strategies

Engineered distributed systems in Go and Rust for payment processing, Web3 infrastructure, smart contracts, and cross-chain services, including ecosystems exceeding 200 microservices. Maintained tier-one transaction workloads on Kubernetes with operational practices centered on failure behavior, deployment safety, and observability.

• Open-source Go multi-agent orchestrator
• Cross-chain backend integration
• Prometheus and Grafana platform monitoring
• Docker-based production deployments