Hire
Data Systems Scala Developers in France

Designed backend systems using Akka HTTP and Play Framework for high-load applications. Developed GraphQL interfaces to streamline data access across distributed services.

• Implemented service mesh architecture for microservices
• Enhanced data serialization techniques for better efficiency
• Led backend modernization efforts with Scala and Java

Developed quantitative trading algorithms with a focus on low-latency execution and risk management. Built containerized microservices for financial data analysis using Rust and Python, optimizing for performance and scalability. Managed deployment and orchestration of applications on AWS using Kubernetes.

• Automated CI/CD pipelines with GitLab for seamless deployments
• Integrated real-time data feeds with complex event processing engines
• Optimized performance-critical components using Rust for speed and efficiency
• Leveraged AWS services for scalable cloud-based computation

Designed and implemented a real-time data ingestion pipeline using Apache Pulsar for a healthcare analytics platform. Leveraged ZIO in Scala for building highly concurrent, fault-tolerant backend services. Developed a serverless architecture on S3 for scalable storage solutions.

• Built a reactive web application using Elm and JavaScript
• Integrated third-party APIs for enhanced data processing capabilities
• Optimized data serialization formats to reduce network latency

Led the development of RESTful services using Scala and Http4s, focusing on high concurrency. Implemented reactive systems with FS2 to handle streaming data efficiently. Developed APIs with Circe for JSON handling in distributed environments.

• Integrated Cats for functional programming enhancements
• Designed scalable microservices architecture with Go
• Implemented custom serialization with Circe

Led the design and implementation of a distributed data platform handling petabyte-scale datasets. Specialized in optimizing real-time data processing pipelines, enhancing throughput and reducing latency. Pioneered the integration of Rust into existing Scala-based systems to improve performance and safety.

• Architected a scalable ETL framework using Python and Scala
• Implemented custom SQL query optimizations for faster analytics
• Developed cross-language data serialization protocols with Rust and Typescript

Engineered a distributed data processing platform optimizing real-time analytics for financial services. Developed microservices architecture for scalable e-commerce applications, integrating complex API systems. Led the migration of monolithic systems to cloud-based solutions, enhancing performance and reliability.

• Implemented machine learning pipelines for predictive maintenance in manufacturing.
• Designed high-throughput messaging systems using Apache Kafka and RabbitMQ.
• Optimized ETL processes for large-scale genomic data analysis.
• Architected containerized deployment strategies with Kubernetes and Docker.

Builds AI agents and retrieval-augmented systems for technical documents, including ISO standards, assembly drawings, industrial specifications, and PLM records such as bills of materials and manufacturing orders. Designed large-scale indexing across thousands of customer documents, document comparison workflows, and a web-scale search crawler.

• Rust clean-content extraction service matching industry-standard quality
• Kubernetes deployment for high-throughput crawling infrastructure
• Effect.ts and React implementation of typed frontend workflows
• Production Scala development across distributed backend systems

Developed and optimized consensus protocols for blockchain networks, ensuring fault tolerance and high throughput. Designed and implemented distributed storage systems, focusing on low-latency data retrieval. Spearheaded the development of a scalable peer-to-peer networking library in Rust, enhancing cross-platform compatibility.

• Implemented BFT consensus using Prolog for formal verification
• Optimized network serialization with custom protocol buffers
• Built a high-performance virtual machine for smart contracts
• Designed a microservices architecture for decentralized applications

Designed and maintained robust distributed systems with a focus on functional programming paradigms and system integration. Specialized in ensuring maintainability and scalability of relational database systems.

• Pioneered functional programming practices in legacy systems
• Integrated disparate systems for unified data processing
• Optimized relational databases for high concurrency workloads

Designed and implemented a petabyte-scale data processing platform using distributed systems technologies. Spearheaded the development of a real-time streaming analytics solution for IoT data ingestion.

• Architected a multi-tenant data platform
• Led a team in building a batch processing system
• Implemented a fault-tolerant message queue

Specializes in building scalable backend services with Scala and Kafka. Developed fault-tolerant systems using Play Framework and http4s.

• Integrated Cats Effect for functional programming paradigms
• Optimized message processing with Kafka Streams
• Designed microservices architecture for high availability

Built real-time data processing pipelines using Akka and Kafka, integrating with Protocol Buffers for efficient data serialization. Developed backend systems supporting high-frequency trading platforms.

• Implemented event-driven architectures with Scala and Akka
• Enhanced system reliability with robust error-handling in C#
• Optimized cross-platform integration with Java and Scala

Designed generic service-evolution workflows for telecom network products, using state-machine orchestration across automated and human-driven steps. Builds asynchronous backend services and network-integrated automation with Rust and Python, supported by Kubernetes-based production infrastructure.

• RabbitMQ-based reliable message processing
• Elasticsearch indexing and search workflows
• PostgreSQL schema and query optimization
• TCP/IP, DNS, DHCP, and VPN automation

Co-founded a startup focusing on distributed systems and microservices with Scala. Designed APIs for scalable data-driven applications. Integrated complex SQL queries for data-intensive backend processes.

• Co-founded startup in distributed systems
• Designed scalable APIs
• Integrated complex SQL queries