Hire
Data 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

Architected full-stack applications with Rust and Scala, focusing on high throughput and low latency systems. Enhanced front-end performance with React.

• Integrated Java services for backend processing
• Developed Python scripts for data analysis
• Optimized server-side rendering in JavaScript

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

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

Architected scalable microservices in Rust and Go for financial platforms. Led development of a high-throughput SQL database engine.

• Designed TypeScript frontend for a complex data visualization tool
• Integrated Rust-based modules into existing C and JavaScript systems
• Optimized C codebases for increased concurrency and throughput

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

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

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

Developed scalable web applications using modern frontend frameworks, focusing on performance and user experience. Built RESTful APIs for seamless integration with client-side applications, handling high volumes of concurrent requests. Optimized complex SQL queries for efficient data retrieval in large databases.

• Implemented server-side rendering for improved page load speed
• Utilized WebSocket for real-time client-server communication
• Created custom React hooks for reusable component logic
• Designed responsive UI components with CSS-in-JS solutions

Developed backend services using Python and Rust with a focus on database management. Implemented both SQL and NoSQL solutions for diverse data requirements.

• Implemented SQL and NoSQL solutions
• Developed Python backend services
• Focused on database management

Developed microservices for data processing pipelines using Rust and GoLang. Implemented performant SQL database queries to optimize backend operations in a cloud environment.

• Built cross-platform CLI tools with Python
• Integrated Typst and LaTEX for document automation
• Optimized RESTful API endpoints for scalability

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 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