Hire Freelance
Backend Scala Developers

Designed a seller shipment-management system that migrated more than 1,000 marketplace sellers onto a commerce platform. Owns Scala services built with Lagom and Akka, from initial architecture through Kubernetes production stabilization on AWS.

• Go-based logistics services for order fulfillment
• GCP deployments using Google Kubernetes Engine
• High-availability APIs for marketplace operations
• Event-driven backend architecture

Designed and implemented large-scale microservices architectures using Scala for financial transaction systems, ensuring high availability and fault tolerance. Developed real-time data processing pipelines for a cloud-based analytics platform, optimizing for low latency and high throughput. Contributed to the development of reactive systems, enhancing system responsiveness and scalability in distributed environments.

• Led migration of legacy Java systems to Kotlin microservices
• Implemented event-driven architecture for a retail analytics platform
• Optimized cloud resource allocation, reducing operational costs by 30%
• Developed secure API gateways for fintech applications

Architected cloud-native applications on GCP, leveraging Kubernetes for efficient container orchestration and scaling. Designed and deployed a multi-tenant logging system using Elasticsearch, enhancing query performance and storage efficiency. Automated CI/CD pipelines with ArgoCD, reducing deployment times and improving reliability across distributed systems.

• Configured Grafana for real-time monitoring of cloud infrastructure.
• Enhanced security protocols for distributed systems in cloud environments.
• Developed custom Scala libraries for data processing and transformation.

Decomposed a high-traffic monolith into five standalone services using purely functional Scala, improving deployment frequency while maintaining resilience and test coverage. Delivers backend systems through production operations, including releases, on-call ownership, and postmortem-driven reliability work.

• Reduced incident recovery time from 1.4 hours to 15 minutes
• HTTP APIs built with http4s, Tapir, Circe, and protobuf
• Database access using doobie across PostgreSQL and Cassandra
• Kafka-based event-driven integrations with Redis caching

Developed scalable microservices for real-time financial transaction processing, leveraging event-driven architecture to ensure low-latency data handling. Designed and implemented distributed systems for high-availability cloud environments, focusing on fault tolerance and resilience.

• Architected RESTful APIs for cross-platform data integration
• Optimized distributed system performance for 100,000+ concurrent users
• Implemented message-driven microservices using Kafka and Akka
• Designed scalable data pipelines for real-time analytics

Designed and implemented a distributed ledger system for financial transactions, optimizing consensus protocols for latency and throughput. Spearheaded the development of a real-time event processing pipeline, handling billions of messages per day with sub-second latency. Architected a microservices platform for a large-scale e-commerce application, focusing on scalability and fault tolerance.

• Developed a custom RPC framework in Rust for microservices
• Optimized JVM performance for high-frequency trading applications
• Implemented a distributed caching system, reducing data retrieval time by 70%
• Led migration of monolithic architecture to microservices, improving deployment speed

Architected a large-scale multiplayer game engine supporting millions of concurrent users, leveraging deep expertise in Linux kernel optimizations and C++. Pioneered the development of a cloud-native platform, enhancing scalability and reliability for distributed systems. Spearheaded the integration of Rust in performance-critical components, reducing latency and increasing throughput.

• Designed real-time physics engine for AAA games
• Implemented secure, low-latency networking protocols
• Optimized cloud cost with efficient resource allocation

Built and maintained an electronic repo trading system in Scala using a proprietary trading framework, including integrations with an additional trading platform and regional desk. Improved trade-change detection, production performance, and operational reliability through targeted tuning, defect remediation, and automated unit testing.

• Developed backend model-engineering services with cats-effect and http4s
• Integrated Oracle Advanced Queuing and Tanzu GemFire
• Built data platforms using Apache Flink, Kafka, and Elasticsearch
• Researched verified monadic programming and formal software methods

Builds distributed backend systems for payments and high-volume event streaming, including Kafka and ClickHouse pipelines processing billions of records. Has led product delivery, data-platform migrations, and engineering standards across production services.

• Personalized recommendation and ad-tech services for multi-device video playback
• Event-sourced CQRS services with gRPC and Protobuf contracts
• Prometheus, Grafana, and Jaeger observability across Kubernetes workloads
• Rust components for performance-sensitive backend processing

Developed distributed data processing systems leveraging Scala and Java, optimizing performance for real-time financial analytics. Integrated complex SQL queries into backend services to support dynamic reporting features in a high-traffic e-commerce platform. Implemented RESTful APIs using TypeScript to enhance interoperability across microservices.

• Optimized database interactions for a 1TB daily transaction system.
• Built event-driven architecture using Kafka for asynchronous processing.
• Automated deployment pipelines with Bash for continuous integration.
• Enhanced frontend-backend communication with WebSocket protocols.

Developed backend systems with Rust and Go for high-performance computing. Expert in implementing cross-platform solutions with C++ and Python.

• Built high-performance systems with Rust
• Developed cross-platform solutions
• Optimized C++ and Python applications

Engineered backend systems using Scala with a focus on functional programming. Built fault-tolerant services with ZIO for distributed systems. Developed GraphQL APIs using Caliban for seamless client-server interactions.

• Utilized Cats library for functional programming patterns
• Optimized SQL queries for high-volume transaction systems
• Developed Python utilities for backend service monitoring

Built backend platforms for experimentation and feature-flag management, including real-time audience targeting, eligibility decisioning, and production APIs. Operated the surrounding AWS and Kubernetes infrastructure with Terraform, deployment automation, and observability tooling.

• Apache Spark data-processing pipelines
• GraphQL API design with Smithy models
• Kafka event-streaming integrations
• PostgreSQL and DynamoDB persistence

Builds high-throughput, low-latency distributed services for real-time bond trading, firehose-scale ingestion, regulated payments, and commerce. Has modernized legacy Java and Kotlin platforms into functional Scala microservices while operating Kafka- and Kinesis-driven systems on Kubernetes across AWS and GCP.

• Akka/Pekko Cluster and Persistence
• Back-pressure tuning in streaming pipelines
• Zero-downtime Akka-to-Pekko migration
• PostgreSQL production systems