Hire
Systems Rust Developers in Berlin

Architected a high-performance distributed database system, enhancing concurrency and fault-tolerance using Rust and Erlang. Designed a novel consensus protocol to ensure data consistency across distributed nodes.

• Led migration from monolithic to microservices architecture
• Implemented custom query optimizer in Haskell
• Developed a multi-threaded storage engine in C

Built and maintained web platforms using Ruby on Rails, JavaScript, React, Node.js, and Linux-based infrastructure. Applied event-store patterns, domain-driven design, test-driven development, and continuous delivery across full-stack applications and service integrations.

• Elixir service development
• MQTT messaging systems
• Hotwire application interfaces
• Nginx and Apache operations

Built scalable backend systems using Rust and Golang for cloud-native applications. Automated CI/CD pipelines with GitHub Actions and Docker. Developed low-level system utilities for container orchestration.

• Built scalable backend systems with Rust and Golang
• Automated CI/CD with GitHub Actions
• Developed system utilities for container orchestration

Managed teams in building data analytics platforms using Rust and Apache Arrow, enabling efficient processing of large datasets. Spearheaded the migration of on-premise systems to Kubernetes-based cloud infrastructure.

• Designed Golang services for scalable microservice architecture
• Automated deployment pipelines with Python scripts
• Collaborated on DataFusion enhancements for query optimization

Optimized FIX trading infrastructure from approximately 30 to 250 trades per second through concurrency and performance-focused backend changes. Built event-driven settlement workflows that aggregate transactions by instrument and support reliable financial operations.

• Kafka-to-FIX latency measured at 100ms p50 and 200ms p95
• Instrument-level fault isolation for settlement processing
• Database inbox/outbox optimization for event delivery
• SFTP report ingestion with deduplication and validation

Designed and migrated a carrier-integration platform serving millions of daily requests with availability above 99.99% and no customer-facing migration downtime. Implemented Rust/Axum accounting integration plus event-driven workflow services for shipment placement, invoicing, retention, and financial synchronization.

• Attribute-based authorization with CASL
• BullMQ event-processing workflows
• Kubernetes and Terraform platform operations
• GCP and AWS cloud migrations

Built cross-chain settlement infrastructure for real customer funds, processing more than $500 million in cumulative volume and approximately $50 million weekly. Designed failure-recoverable transaction state machines in Rust and Move, covering partial commits, releases across systems, and idempotent retries.

• Integrated settlement workflows with internal REST APIs
• Evaluated Wormhole, Polymer, and CCIP integration tradeoffs
• Led external security audit through remediation and sign-off
• Authored protocol specifications and integration documentation

Engineered concurrent systems using Rust's Tokio and Futures for asynchronous programming. Developed backend services with Go and Dart for scalable applications.

• Optimized network protocols with Rust
• Integrated Bash scripts for system automation
• Designed microservices architecture

Architected distributed systems using .NET and C#, enabling high availability and fault tolerance. Led the development of a multi-tenant SaaS platform, scaling user capacity by 300%.

• Integrated MS SQL Server for transactional processing
• Optimized network protocols for latency reduction
• Refactored legacy codebases for modern architectures

Architected a peer-to-peer networking framework supporting millions of concurrent users. Developed cross-platform applications leveraging Rust's memory safety and concurrency features.

• Optimized network protocols for low-latency communication
• Developed custom peer-to-peer file sharing protocols
• Implemented robust error recovery mechanisms in distributed systems

Engineered high-performance systems in Rust, focusing on concurrency and multithreading. Contributed to large-scale distributed systems with a focus on fault tolerance and resilience.

• Designed low-latency messaging systems using C++
• Developed cross-platform applications with C#
• Integrated Go-based microservices into existing infrastructure

Engineered Web3 solutions using Rust and Solidity for decentralized finance platforms. Developed cross-platform applications with Next.js and Swift.

• Built Web3 solutions with Rust
• Focused on decentralized finance
• Developed cross-platform apps with Swift

Pioneered research and development in WebAssembly with Rust. Engineered cross-platform solutions using C and C++.

• Developed scalable backend services with TypeScript
• Contributed to Python-based R&D projects
• Optimized WASM modules for performance

Built routing infrastructure for real-time multimodal trip search, integrating a routing engine with external mobility APIs. Developed a concurrent Go pipeline that enriches OpenStreetMap geodata before indexing it into Elasticsearch for large-scale place search.

• Event-driven service architectures
• Kubernetes-based CI/CD operations
• Prometheus alerting and vulnerability management
• Geospatial autocomplete optimization