Hire Contract
Data Systems Rust Developers in Netherlands

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

Architected distributed systems with a focus on scalability and high availability. Applied domain-driven design principles to streamline AI/ML application development.

• Led system analysis for enterprise-level applications
• Implemented event-driven architectures with Rust
• Optimized machine learning pipelines for performance

Designed Rust execution and storage infrastructure for distributed ledgers, including a payment engine benchmarked at multi-million transactions per second and replay protection using per-account nonces and intent deduplication. Built full-node storage integration, chain reorganization handling, and zero-knowledge-compatible data-availability verification, raising production throughput to 5,000 TPS.

• Consensus fork selection and state finalization
• Celestia data publishing integration
• Prover and verifier storage coordination
• Production observability infrastructure

Architected a high-availability distributed database system using Rust, focusing on fault tolerance and scalability. Developed a real-time analytics platform in Scala for processing petabyte-scale datasets. Spearheaded the design of a microservices framework in Go, enhancing modularity and deployment speed.

• Designed custom load balancing solutions for distributed systems
• Implemented security protocols in Rust for data protection
• Developed a high-performance networking library

Constructed distributed systems with a focus on high concurrency and low latency. Developed infrastructure automation scripts, enhancing deployment efficiency and reliability.

• Optimized database queries for large-scale data operations
• Implemented multi-threading in C++ for performance gains
• Created a CI/CD pipeline using Go and Python

Engineered backend systems using Scala and Rust, focusing on high-availability and real-time data processing. Developed scalable microservices with TypeScript and Spring Boot for enterprise solutions.

• Implemented Kotlin for reactive programming
• Optimized Java applications for distributed systems
• Developed REST APIs for seamless integration

Architected distributed systems leveraging Kafka and ClickHouse for real-time data processing. Developed scalable backend solutions in Rust and Scala.

• Architected real-time distributed systems
• Leveraged Kafka and ClickHouse
• Developed backend in Rust and Scala

Provided consulting on high-performance computing with Rust and C++. Developed custom compilers and interpreters for domain-specific languages.

• Explored functional programming with Scheme and Racket
• Optimized algorithms for computational efficiency
• Developed mathematical models in Haskell

Built Java and PHP REST services for identity authentication, combining frontend and backend components in scalable web systems. Developed data pipelines and repaired memory leaks across more than 100 files in investigation case-management software.

• Optimized over 50% of critical application code
• Backend systems for police and insurance-fraud investigations
• Open-source software contributions
• Cross-platform development across Linux, Windows, and Apple

Managed distributed systems projects leveraging Rust and Kubernetes on AWS. Implemented CI/CD pipelines for seamless deployment and continuous integration. Optimized key-value data stores for high availability and performance.

• Managed distributed systems with Kubernetes
• Implemented CI/CD pipelines
• Optimized key-value data stores

Designed high-performance backend systems using Perl, catering to large-scale data processing needs. Implemented FastCGI-based solutions for optimizing server-side performance in legacy systems.

• Designed high-performance backend systems
• Implemented FastCGI solutions
• Optimized server-side performance

Expert in developing high-performance web applications using Perl and Catalyst, with extensive experience in Apache and FastCGI environments. Specializes in building robust database interfaces with DBI.

• Migrated legacy systems to modern Perl frameworks
• Designed caching mechanisms to reduce server load
• Developed a custom ORM using Moose

Engineered backend systems using Rust and Go, emphasizing performance and concurrency. Developed low-level networking protocols in C and Assembly.

• Utilized Python for scripting and automation tasks
• Contributed to open-source projects in the Rust ecosystem
• Implemented microservices architecture for scalable applications

Refactored embedded GNSS software from Python to Rust around a hardware-abstraction microservice and ZeroMQ broker. Built a single-threaded Tokio data path for Bluetooth, Radino, and CAN interfaces, using exclusive handle ownership and latest-wins channels to control latency and staleness.

• Yocto-based embedded OS deployment automation
• Trait-based correction-feed and output-sink contracts
• ZMQ Pub/Sub and Push/Pull abstractions
• Independent GNSS read and correction-write tasks