Hire
Fintech Rust Developers in France

Specialized in building asynchronous Rust services with Tokio for backend scalability. Developed event-driven architectures in Python and Kotlin for microservices.

• Integrated C++ libraries for high-speed computation
• Implemented TypeScript interfaces for frontend-backend communication
• Enhanced database interactions with Rust

Architected global e-commerce applications using Next.js, React, Svelte, and TypeScript, with cloud deployments on GCP and Kubernetes. Led cross-stack observability and resilience work using Datadog and OpenTelemetry, while applying microservices and domain-driven design to large-scale Java payment systems.

• Visa and Mastercard payment processing
• Kafka and Redis platform integration
• Core Web Vitals optimization
• CKAD-certified Kubernetes operations

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

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

Architected scalable data processing systems with Scala and FS2 for large-scale analytics. Developed RESTful APIs using Http4s, ensuring high throughput and low latency.

• Led migration to cloud infrastructure using Kubernetes
• Enhanced data serialization with Circe for JSON processing
• Designed event-driven architectures using Kafka

Architected distributed systems with Rust and C++ for high-frequency trading platforms. Spearheaded performance optimization projects reducing latency by over 50% in critical systems. Developed low-latency communication protocols for financial data exchange.

• Enhanced multi-threading capabilities in systems software
• Implemented custom memory management techniques
• Led refactoring of legacy C++ codebases to Rust

Developed decentralized applications on the Solana blockchain, using Rust and Anchor for smart contract development. Designed scalable backend services for financial platforms.

• Implemented TypeScript-based UI for blockchain interactions
• Optimized SQL queries for high-volume data processing
• Integrated Java-based middleware for cross-chain compatibility

Developed back-end services with C++ and Python for high-availability systems. Contributed to Qt-based interfaces for desktop applications.

• Enhanced Rust libraries for better concurrency support
• Integrated JavaScript for responsive UI components
• Optimized C code for embedded systems

Developed high-throughput financial transaction systems using Java and Rust. Specialized in building scalable backend services for real-time data processing. Integrated cross-platform mobile applications with Swift and Rust for enhanced performance.

• Optimized SQL queries for complex data retrieval in large databases
• Implemented C/C++ modules for high-performance computing tasks
• Designed Python-based automation scripts for testing environments

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

Develops Web3 applications and infrastructure across Rust, Solidity, TypeScript, and EVM tooling. Optimized an Ethereum event aggregation database by 60%, deployed load-balanced Ethereum nodes, and built trading interfaces with portfolio analysis.

• Uniswap v4 Rust hook development
• Foundry and Alloy toolchains
• Kafka-based event processing
• Digital twins for autonomous shuttles

Developed a Bevy-based game engine in Rust with mlua integration for executing Luau scripts. Built web interfaces with React and TypeScript while applying C-based systems programming and Docker-based development workflows.

• Luau scripting runtime integration
• Rust ownership-oriented systems design
• React and TypeScript application development
• C-based algorithm implementation

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

Develops Rust systems spanning embedded control software for marine vessels and drones, backend services, and WebAssembly applications. Co-created a real-time collaborative audio workstation using Rust, WASM, and CRDTs, combining low-latency state synchronization with cross-platform interfaces.

• ESP32 and NVIDIA Jetson embedded targets
• CAN, Modbus, and NMEA protocol integration
• Flight-controller software for autonomous drones
• Substrate and Ink! smart-contract development