Hire
Backend Rust Developers in France

Developed microservice architectures in Rust, focusing on high-throughput and low-latency applications. Engineered RESTful APIs with a robust security model.

• Integrated Java services with legacy systems
• Enhanced backend performance using multithreading
• Designed inter-service communication protocols

Architected scalable microservices using Go and Kubernetes, focusing on high-availability systems. Designed RESTful APIs for enterprise-level applications with robust CI/CD pipelines.

• Implemented distributed caching with PostgreSQL
• Integrated Docker for containerized deployments
• Developed automated testing frameworks for backend services

Develops asynchronous concurrent Rust services on Tokio for algorithmic digital-asset trading across more than 140 centralized and decentralized exchanges. Built exchange connectivity for roughly 20 venues using FIX, REST, and WebSocket protocols, with latency-sensitive order and market-data paths below 100 milliseconds.

• Founded an audited on-chain protocol
• Supported more than 12,000 blockchain identities
• Implemented NATS-based service messaging
• Built EVM integrations using The Graph and Multicall

Engineered high-performance asynchronous systems using Rust and Tokio, optimizing parsing and serialization with Serde. Specialized in FFI for cross-language integration.

• Built asynchronous systems with Rust and Tokio
• Optimized parsing and serialization with Serde
• Specialized in FFI for cross-language integration

Led development of distributed systems using Rust and Go, emphasizing consistency and availability. Architected scalable microservices with TypeScript for cloud environments.

• Implemented serverless functions with Python
• Developed frontend frameworks with JavaScript
• Optimized database performance

Architected and led the development of a distributed data platform capable of handling petabyte-scale datasets. Designed and implemented streaming data solutions to support real-time analytics for critical business operations.

• Optimized data processing pipelines to reduce latency by 40%
• Led a team in developing a fault-tolerant distributed system
• Integrated machine learning workflows into existing data platforms

Developed backend services in Rust for high-performance financial transaction processing. Contributed to the design of a low-latency messaging system in C++. Implemented RESTful APIs for data-driven applications.

• Improved Python scripts for data transformation tasks
• Integrated Java-based authentication services
• Optimized Go routines for concurrency management
• Refactored legacy C code for performance gains

Builds Rust-based embedded Linux software for EV charging systems, including OCPP 2.0.1 implementations, ISO 15118 integration, MQTT APIs, and interoperability testing between charging stations and backend services. Has developed cloud-connected software for large sensor fleets and low-power IoT deployments spanning hardware integration and scalable backend services.

• Prototyped PCBs for AC charging station hardware
• Implemented LoRaWAN and Zigbee device communication
• Integrated Modbus sensors into energy systems
• Maintained CI/CD pipelines for embedded software

Designed asynchronous service-evolution workflows for telecom products using state-machine orchestration across automated and human-driven steps. Builds Rust and Python backend services deployed with Kubernetes, Terraform, and observability stacks spanning Prometheus, Grafana, OpenTelemetry, and Elasticsearch.

• RabbitMQ workflow messaging
• TCP/IP, DNS, DHCP, and VLAN operations
• GCP and Azure infrastructure automation
• Network inventory and firewall automation

Built a web-scale clean-content extraction service in Rust and an indexer for thousands of technical and manufacturing documents. Current systems combine Haskell, TypeScript, and Effect-based workflows for RAG agents, document comparison, product recommendations, and PLM traceability.

• Kubernetes crawler deployment
• RAG recommendation pipelines
• Functional Scala production systems
• React technical-document interfaces

Develops Rust-based partner integrations for fintech and e-commerce platforms using gRPC and Protobuf, covering API design through AWS deployment and production operations. Works on payment, budgeting, and supplier-connectivity workflows requiring idempotent retries, observability, and reliable transaction processing.

• Kafka-backed distributed data pipelines
• Neo4j relationship-data modeling
• Kubernetes deployment automation
• Canary releases through Jenkins

Created an open-source distributed key-value and object store implementing Raft replication, two-phase commit, linearizable reads, and replica placement. The system combines Tokio-based services with write-ahead logging, RocksDB storage, S3-compatible APIs, REST, and gRPC.

• 400-plus GitHub stars on distributed storage project
• 173 automated tests for storage and replication
• Append-only segments with checksums and Bloom filters
• JWT, RBAC, and AES-256-GCM modules

Led backend development for scalable applications using Rust and Python. Designed efficient algorithms for data processing. Implemented CI/CD pipelines using Docker and Agile methodologies.

• Led scalable backend development
• Designed efficient data processing algorithms
• Implemented CI/CD with Docker

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