Hire
Backend Scala Developers in France

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

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

Engineered microservices architecture on AWS, utilizing Kubernetes for container orchestration and Seneca for microservices communication. Spearheaded the development of scalable backend systems using JavaScript and Angular.

• Designed cloud-native solutions for high availability
• Implemented CI/CD with Kubernetes and AWS
• Automated infrastructure provisioning with Terraform

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

Architected scalable enterprise systems with a focus on clean architecture principles and domain-driven design. Led the development of search solutions utilizing ElasticSearch for high-performance querying across large datasets. Designed end-to-end solutions integrating multiple systems within heterogeneous environments.

• Developed JVM-based microservices for modular application architecture
• Implemented CI/CD pipelines for automated deployment processes
• Designed RESTful APIs for cross-platform system integrations

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 a distributed event-driven architecture supporting millions of transactions per second. Specialized in building scalable microservices and real-time data processing systems. Extensive experience in optimizing JVM performance for high-throughput applications.

• Architected event-driven systems for high concurrency
• Optimized JVM for low-latency applications
• Built scalable microservices handling millions of users

Developed a distributed event-driven microservices architecture for a high-traffic e-commerce platform using Scala and functional programming paradigms. Designed and optimized complex data pipelines for real-time analytics in the retail sector, leveraging Scala's concurrency features. Built a custom ETL framework for processing large datasets in a cloud-based environment, integrating seamlessly with Redshift and Postgres.

• Implemented a custom authentication module using Scala and Java.
• Optimized query performance for multi-terabyte Redshift databases.
• Built real-time dashboards using Angular for live data visualization.
• Designed a fault-tolerant messaging system for financial transactions.

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

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

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

Developed a distributed event-driven microservices platform for financial transactions processing. Designed a high-performance, fault-tolerant data pipeline handling over 10 million events per day. Implemented a real-time analytics dashboard using Scala and Go for monitoring system metrics and user activity.

• Optimized SQL queries for sub-second response times
• Built RESTful APIs in Scala for e-commerce platforms
• Integrated third-party authentication services using OAuth2
• Implemented CI/CD pipelines with Bash and Python scripting

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