Hire
Data Systems Rust Developers

Engineered high-performance data processing pipelines using Scala and Rust, focusing on real-time analytics. Designed and maintained distributed systems for large-scale data ingestion and processing.

• Built microservices architecture using Go and Java
• Integrated TypeScript for front-end data visualization
• Optimized C++ algorithms for data compression

Designed MLS group-state features and bidirectional streaming transport for secure messaging, including ordered delivery, heartbeats, reconnects, external invites, and per-field permissions. Reduced 100-device group-invite storage from 8 MB to 200 KB and reduced full-group database loading from 13 reads to one.

• Migrated core product infrastructure into Rust
• Built FFI boundaries for untrusted drivers
• Enabled PostgreSQL through asynchronous database traits
• Shipped four protocol improvement proposals

Designed a Kafka-fed Rust caching service for a sanctions platform whose nightly database workload reached approximately 21 billion requests. The architecture reduced that traffic to fewer than four million requests while supporting migration from legacy sanctions workflows into a PostgreSQL-backed platform.

• Built real-time backend services with Python and Node.js
• Developed React interfaces for sanctions operations
• Modernized end-of-life application workflows
• Eliminated recurring manual database updates

Builds high-throughput, low-latency distributed systems for real-time trading, regulated payments, and firehose-scale data ingestion using functional Scala and concurrent streaming architectures. Has modernized legacy JVM platforms into independently deployable services and operated production workloads across public-cloud Kubernetes environments.

• Akka-to-Pekko zero-downtime migration
• Kafka and Kinesis event pipelines
• Cats-Effect, FS2, and ZIO
• PostgreSQL service backends

Designs distributed event-streaming and data-platform systems for payments and personalized media, including Kafka and ClickHouse pipelines processing billions of records. Production work spans Scala, Java, Kotlin, and Rust services with migrations across messaging, storage, and service architectures.

• Implemented event-sourced and CQRS service architectures
• Used Kafka, gRPC, and Protobuf for interservice transport
• Deployed workloads through Kubernetes and Argo CD
• Instrumented systems with Prometheus, Grafana, and Jaeger

Built data pipelines using SQL and Snowflake for large-scale data analysis. Developed containerized applications with Docker and Podman, enhancing deployment efficiency.

• Integrated R for statistical data analysis
• Optimized Python scripts for data transformation
• Developed scalable data solutions for enterprise needs

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 distributed financial-data and logistics systems using Go, Python, PostgreSQL, Redis, Kafka, and ClickHouse. Built trading and investment product workflows, modernized legacy services, and delivered infrastructure with Kubernetes, AWS, OpenTelemetry, Prometheus, and Jaeger.

• Real-time financial data aggregation
• RabbitMQ workflow automation
• STUN/TURN networking services
• Grafana and ELK operational dashboards

Developed quantitative trading systems using Rust and C++, focusing on high-frequency trading algorithms. Implemented smart contracts for decentralized finance applications.

• Built high-frequency trading algorithms
• Developed DeFi smart contracts
• Specialized in quantitative finance systems

Engineered quantitative trading algorithms using Python and Rust, optimizing execution on cloud platforms. Automated deployment pipelines with Kubernetes for seamless CI/CD.

• Integrated AWS for cloud-based computation
• Utilized Docker for containerized environments
• Implemented robust CI/CD with GitLab

Designed and owned low-latency execution, market-data, simulation, and quantitative research infrastructure for multi-asset trading. Applied Rust and C++20 performance engineering across NUMA-aware optimization, lock-free queues, CPU affinity, IRQ tuning, binary feeds, FIX, and lossless gigabit packet capture.

• CEX, DEX, and DeFi trading systems
• MiFID II and PCI DSS exchange architecture
• perf, VTune, and flame-graph profiling
• Memory-cache and scheduler optimization

Developed backend services with Rust and Actix-Web for high-performance web applications. Utilized Tokio for building asynchronous systems.

• Optimized SQL databases for data integrity
• Implemented Python scripts for data manipulation
• Enhanced TypeScript for frontend solutions

Built a Rust complex-event-processing engine that composes reusable processing blocks into Kafka-consuming and Kafka-producing deployments. The system uses Tokio tasks, NATS stage transport, embedded Python execution, and dependency-aware input routing to reproduce production-grade stream-processing architecture.

• Implemented bidirectional PyO3 type marshalling across the FFI boundary
• Managed Python GIL boundaries for in-process block execution
• Developed Linux filesystem drivers and embedded firmware
• Built distributed event-driven backends in Scala, Java, and Go

Designs and operates real-time data infrastructure for national-scale payment processing, humanitarian systems, and business intelligence platforms. Builds Kafka-driven pipelines, Rust and Python microservices, and low-latency storage layers using ScyllaDB, Redis, PostgreSQL, Parquet, and Kubernetes.

• Implemented streaming transformations with PySpark
• Used Tokio for asynchronous Rust services
• Built gRPC APIs for distributed backends
• Operated observability through Grafana and Prometheus