Ruchira Madhushan Rajapaksha

Led technical architecture and engineering excellence for enterprise-scale financial platform serving millions of users across multiple markets. Architected and delivered high-performance distributed systems using Java 21, Spring Boot microservices, and event-driven architecture with Kafka, processing 1M+ daily transactions with sub-100ms latency. Drove system modernization initiatives, established comprehensive testing standards, and mentored engineering teams on distributed systems design and clean code practices. Collaborated with product managers and cross-functional teams in Agile environment to define, design, and deliver critical financial workflows while ensuring 99.9% system uptime and operational excellence.

• Processed 1,000,000+ daily transactions (12K requests per second) with 20ms latency and maintained 99.9% uptime by building large-scale data streaming and processing systems using Java 21, Spring Boot, and event-driven architecture (Kafka, CloudEvents), supporting multi-domain financial workflows at enterprise scale.
• Built and operated real-time data processing pipeline using Kafka and event streaming reducing data processing latency from 48 hours to near-instantaneous (4 hours), implementing reactive systems with Project Reactor for high- throughput event handling supporting thousands of concurrent operations.
• Improved query performance by 40% and boosted system throughput for high-volume transactional workloads by architecting distributed Redis caching solutions with efficient indexing and cache invalidation strategies, enabling scalable and consistent data operations across microservices.
• Reduced codebase issues by 30% and elevated engineering standards across 15+ microservices by leading technical architecture and solution design sessions, establishing comprehensive testing standards (BDD), and fostering engineering excellence through mentoring and knowledge sharing.
• Reduced cross-department coordination time by 92% (48 hours to 4 hours) and improved operational responsiveness by 50% by designing and delivering a real-time notification system, empowering non-technical teams to respond to workflow updates without engineering intervention.

Designed and developed scalable backend microservices for enterprise financial platform using Java 17, Spring Boot, and Spring Cloud ecosystem. Specialized in building RESTful APIs, implementing reactive programming patterns with Project Reactor, and integrating message-driven architectures using Kafka. Led security initiatives implementing ABAC authorization framework and dynamic configuration management across 40+ microservice instances. Mentored junior developers on microservices architecture, comprehensive testing strategies and Spring Boot best practices while actively participating in code reviews and Agile/Scrum ceremonies.

• Optimized high-performance systems achieving 60% faster processing times and 20% infrastructure cost reduction by identifying performance bottlenecks and migrating file upload/download operations to reactive AWS SDK with Project Reactor, improving user experience for 1,000 plus daily active users handling 50,000+ files monthly.
• Secured 30 plus services in a zero-trust architecture and reduced unauthorized access attempts by 95% by designing and implementing standalone Attribute-Based Access Control (ABAC) policy engine using Cedar SDK, collaborating with Platform teams to integrate authorization enforcement at API gateway layer.
• Achieved 99% microservices uptime and eliminated 100% of configuration-related outages by architecting Spring Cloud Config Server with Spring Cloud Bus for dynamic configuration management, enabling real-time updates across 40+ service instances without downtime.
• Improved system reliability and reduced production incidents by 35% by designing scalable REST APIs using OpenAPI specifications, implementing comprehensive testing strategies, and containerizing applications with Docker.
• Accelerated project delivery by 40% and elevated team technical capabilities by mentoring 4 engineers on microservices architecture, reactive programming patterns, and testing best practices, while fostering cross-functional collaboration through code reviews and pair programming.

Engineered high-throughput backend services for multi-brand food ordering SaaS platform processing 500K+ daily orders across multiple markets. Designed and implemented distributed caching architectures using Redis and MongoDB, built event-driven microservices with Kafka for real-time order processing, and developed RESTful APIs using Spring Boot and Java. Containerise services with Docker, deploy to AWS ECS/EKS, and establish observability standards using OpenTelemetry and Grafana. Built CI/CD pipelines using CircleCI and Gradle for automated testing and deployment workflows.

• Processed 500,000+ daily food orders with 35% faster API response times by engineering distributed Redis write-behind caching solution that reduced MongoDB database load by 40%, supporting high-throughput operations and concurrent request handling across multiple brands at scale.
• Cut Mean Time to Detect (MTTD) by 80% (from 45 minutes to 9 minutes) and Mean Time to Resolve (MTTR) by 75% by implementing distributed tracing using OpenTelemetry for gRPC applications, collaborating with Platform teams to establish robust observability standards and improve production incident response.
• Accelerated feature development cycles by 30% and reduced technical debt by 25% by proactively proposing and leading refactoring initiatives to decompose monolithic codebase into domain-driven microservices, implementing clean architecture patterns and containerizing services with Docker for deployment to AWS ECS/EKS.

Developed high-performance trading applications and backend services for financial services platform handling real-time market data streaming and low-latency order execution. Built microservices using Java and Akka framework for concurrent request processing and actor-based systems. Designed RESTful APIs and integrated with relational databases using JDBC and JPA for data persistence. Participated in code reviews, and collaborated with frontend teams building React interfaces. Worked in Agile/Scrum environment resolving critical performance bottlenecks, optimizing memory consumption, and improving system reliability for trading operations.

• Improved real-time data processing throughput by 45% and reduced latency by 30% by designing high-performance trading applications using Akka's actor-based model, supporting low-latency order execution and market data streaming for financial services platforms.
• Enhanced platform reliability and user experience by 80% by resolving critical performance bottlenecks in financial systems, reducing memory consumption by 60% and eliminating user-facing system slowdowns and crashes.
• Mentored junior engineers on microservices patterns and testing best practices, improving team efficiency through peer reviews and pair programming.

An event-driven architecture utilizing CloudEvents and Reactive Kafka while supporting multi-protocol architecture supporting JSON, Protocol Buffers and Spring Integration

This project implements a fully reactive real-time request processing application with Spring WebFlux and Reactive gRPC.

This is a cloud-native solution for an application that handles a high volume of writes, using write-behind caching with Redis and using the underlying main database as Couchbase. This can be customised for any No-Sql Database.

This project demonstrates the usage of Amazon S3 Transfer Manager in the AWS SDK for Java 2.x. This implementation is for two use cases; Asynchronous Parallel File Transfers with S3 Transfer Manager and Streaming data to Amazon S3 Asynchronously. asynchronous and parallel file transfers and data streaming.