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

Builds backend platforms around PHP 8+, Symfony, Laravel, and NestJS, using domain-driven, hexagonal, and event-driven architectures for REST APIs and microservices. Has implemented distributed integrations across AWS messaging services, Kubernetes deployments, relational and document databases, and regulated authentication flows.

• Designed OpenAPI contracts for service integrations
• Implemented OAuth2, OIDC, JWT, and Keycloak security
• Applied TDD with PHPUnit, Jest, and SonarQube
• Built event workflows with AWS SNS and SQS

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

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

Architected scalable microservices for high-traffic platforms, leveraging Rust and Java for backend stability and performance.

• Designed reactive frontends with React.js
• Optimized MongoDB queries for large datasets
• Migrated legacy systems to modern microservices architecture

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

Architected embedded systems with a focus on Linux-based platforms using Yocto. Developed real-time applications in Rust for resource-constrained environments.

• Created custom Linux kernel modules
• Implemented C++ solutions for hardware interfacing
• Automated build processes with Bash scripting

Led the development of container orchestration tools for cloud-native applications, enhancing deployment efficiency and scalability. Developed a real-time monitoring system for IoT devices using edge computing techniques.

• Implemented custom Kubernetes operators for automated scaling
• Designed a distributed logging system for large-scale clusters
• Developed cross-platform applications with C++ and Rust

Architected scalable solutions with Rust and Postgres for enterprise applications. Developed graph-based data models using Neo4j.

• Built RESTful services with Flask
• Enhanced Java applications for backend efficiency
• Integrated Python scripts for data processing