E-Commerce Backend Engineer

Ruby You

R **********@*****.*** Ó 610-***-**** ruby-y-4457b41a2

Summary

Java Backend Engineer with 6+ years architecting high-performance distributed systems serving 100K+ concurrent users in banking, e-commerce, and insurance domains. Led the modernization of monolithic applications into Spring Cloud microservices, achieving 40% latency reduction and 3x throughput improvement. Expert in designing event-driven architectures using Kafka and CQRS patterns, implementing OAuth 2.0/JWT security frameworks, and optimizing Java applications through advanced concurrency patterns. Proven technical leader who established engineering best practices, mentored 5+ developers, and drove cross-functional initiatives between product, QA, and DevOps teams.

• Architected microservices for a retail e-commerce platform using Spring Cloud (Eureka, Gateway, Feign), reducing response latency by 40% and improving modularity across product, order, and user services.

• Developed an event-driven architecture using Kafka for real-time order updates, behavior logging, and recommendation triggers, enabling asynchronous processing across 5+ services.

• Implemented secure login and checkout authorization using Spring Security, JWT, and role-based access control (RBAC), supporting both customers and administrators in a B2B SaaS platform.

• Optimized backend performance with Java concurrency (CompletableFuture, async service calls), reducing response time by 50% in high-load order and payment scenarios.

• Refactored a monolithic insurance policy system into Spring Boot-based microservices, improving deployment flexibility and reducing release time from bi-weekly to daily.

• Built a fraud-detection pipeline for a banking system using Kafka and CQRS, allowing near-real-time monitoring of trans- action events and alert generation with under 200ms latency.

• Used Redis (cache-aside strategy) to store hot product inventory and promotion data, reducing DB pressure by 70% during flash sales in the e-commerce module.

• Designed and maintained a multi-tenant B2B permission system, enabling separate role policies across organizations using JWT and custom claims-based authentication.

• Deployed services on Docker and Kubernetes, configuring auto-scaling to handle up to 10x traffic spikes during marketing campaigns while maintaining stability under 200ms latency.

• Developed RESTful and GraphQL APIs for cross-team integration, following Richardson Maturity Model Level 3 with versioning strategies to support external vendor access.

• Designed and implemented full-stack dashboards using React.js, displaying real-time metrics via Kafka Streams, helping business teams monitor order fulfillment in real-time.

• Integrated observability stack with Prometheus, Grafana, and ELK to visualize service metrics and errors, achieving average MTTR under 15 minutes.

• Migrated legacy banking data access layers to Spring Data JPA + Hibernate, supporting read/write splitting and sharding strategies for better performance with growing datasets.

• Introduced CI/CD pipelines with Jenkins and GitHub Actions, improving test automation and reducing manual deploy- ment time by 90%.

• Mentored a team of 5+ junior engineers, established code review standards, led architecture discussions, and improved cross-functional collaboration with QA, product, and DevOps teams. Technical Skills

• Programming Languages: Java 8/11/17, JavaScript ES6+, TypeScript 4.x, Python 3.x, SQL

• Backend Frameworks: Spring Boot 2.x/3.x, Spring Cloud (Eureka, Gateway, Config), Spring Security 5.x, Hibernate 5.x/6.x

• Frontend Technologies: React 18, Angular 17, Redux Toolkit, RxJS 7, HTML5, CSS3, Bootstrap 5, Tailwind CSS

• Microservices & Messaging: Apache Kafka 3.x, RabbitMQ 3.x, Spring Cloud Stream, REST/GraphQL APIs

• Databases: MySQL 8.x, PostgreSQL 15, MongoDB 5.x, Redis 7.x, Oracle 11g/19c, Cassandra 4.x

• Cloud & Container: AWS (EC2, RDS, S3, EKS), Docker, Kubernetes, Helm, Terraform

• DevOps & CI/CD: Jenkins 2.x, GitHub Actions, Maven 3.x, Gradle 7.x, GitOps

• Testing & Quality: JUnit 5, Mockito 4.x, Testcontainers, JMeter, Postman, SonarQube

• Monitoring & Observability: Prometheus, Grafana, ELK Stack, Jaeger, Spring Boot Actuator

• Development Tools: IntelliJ IDEA, VS Code, Git, Docker Desktop

• Application Servers: Apache Tomcat 9.x/10.x, Spring Boot embedded servers

• Methodologies: Agile/Scrum, TDD, DDD, Microservices patterns, SOLID principles Free People (Urban Outfitters Inc.) Philadelphia, PA Java Backend Developer 01/2024 – Present

Project: Fashion E-commerce Order Management System Description: Led order service development in microservices architecture for fashion retail platform, processing millions of daily transactions. Worked in a 12-engineer team to modernize the e-commerce platform supporting online and retail channels. Responsibilities:

• Built distributed transaction management using Saga pattern with Kafka as event coordinator, implementing compen- sating transactions for payment failures and inventory rollback, achieving 99.9% data consistency across order, payment, and inventory services

• Optimized order query performance through multi-level caching strategy with Redis, implementing cache warming for hot products and preventing cache avalanche during flash sales, reducing API response time by 80%

• Developed event-driven architecture using Kafka for order lifecycle management, designing idempotent consumers and implementing dead letter queues for failed message handling, processing 100K+ events per minute

• Architected order service to handle complete order lifecycle from creation to fulfillment, supporting multiple order types (regular, pre-order, flash sale) and scaling to 10x traffic during peak sales events

• Implemented resilience patterns including circuit breakers for payment gateway failures and bulkhead isolation for third- party services, maintaining 99.99% availability during critical business periods

• Led performance optimization initiatives through JVM tuning, database query optimization, and connection pool man- agement, supporting 50K concurrent users during promotional events

• Designed scalable data model for order management with proper indexing strategy and partitioning approach, ensuring data integrity while maintaining sub-second query performance for millions of orders

• Established comprehensive monitoring and alerting using Prometheus and Grafana, tracking both technical metrics (latency, error rate) and business KPIs (conversion rate, order value)

• Mentored team members on distributed systems concepts and conducted code reviews to ensure code quality and knowledge sharing

• Collaborated with cross-functional teams including product, QA, and DevOps to deliver features on schedule while maintaining system stability

Environment: Java 11, Spring Boot, Spring Cloud, Apache Kafka, Redis, MySQL, AWS, Docker, Kubernetes, Microservices, RESTful APIs

Wawa Philadelphia, PA

Backend Engineer 05/2022 - 12/2023

Project: Real-time Inventory Management & Fulfillment System Description: Built a distributed backend system managing real-time inventory visibility and intelligent order fulfillment across 700+ convenience stores, processing 3M+ daily transactions. Led critical initiatives to modernize legacy inventory systems, reducing food waste by 40% and improving order accuracy to 99.5%. Responsibility:

• Developed distributed microservices using Spring Boot to replace monolithic inventory system that couldn’t scale beyond 8K QPS, designing 4 core services for order processing, inventory tracking, fulfillment routing, and store replenishment using domain-driven design principles, ultimately scaling to 60K QPS to support peak breakfast and lunch rushes across all locations.

• Integrated Apache Kafka event streaming to eliminate 5-minute inventory lag that caused daily food waste worth $50K+, implementing real-time event-driven architecture for inventory updates, made-to-order food tracking, and automatic re- plenishment triggers across 700+ locations, reducing inventory sync to under 3 seconds and preventing $2M+ monthly food waste.

• Designed multi-tier caching strategy using Redis to solve database bottleneck causing 600ms+ query latency during peak hours, caching high-velocity items like coffee and hoagies with 2-minute TTL and store inventory snapshots with 10-minute TTL using write-through pattern, which reduced P95 latency by 70% to 180ms and handled morning rush without scaling RDS.

• Implemented JWT-based authentication and RBAC using Spring Security for 20K+ store associates across multiple shifts, designing hierarchical roles for associates, managers, and district managers with 25+ permissions controlling inventory adjustments, waste reporting, and ordering capabilities, achieving zero security breaches while reducing training time by 50%.

• Created Spring Cloud Gateway filters to centralize security and monitoring across services, implementing store-based rate limiting at 500 requests per minute, JWT validation with Redis cache, structured logging for PCI compliance, and intelligent routing based on store regions, successfully blocking 50K+ unauthorized requests daily and achieving PCI DSS compliance certification.

• Applied Circuit Breaker pattern using Resilience4j after experiencing cascading failures from single store outages, configuring 35% failure threshold over 15 requests with fallback to cached inventory data and queued orders, maintaining 90% functionality during supplier API outages and preventing $3M+ in potential lost sales.

• Optimized parallel inventory aggregation using CompletableFuture with ForkJoinPool tuned to 25 threads to replace serial queries that took 2s+, batching store queries by region to respect connection limits and reducing multi-store inventory lookup from 1.2s to 650ms, enabling real-time inventory transfers between nearby stores.

• Built real-time food waste prediction system processing 500K+ daily transactions through machine learning pipeline that analyzes sales patterns, weather data, and local events to predict demand, reducing food waste by 45% and saving $6M+ annually across all stores while improving freshness scores.

• Developed smart replenishment algorithm considering sales velocity, shelf life, and delivery schedules, implementing time- series forecasting for 5000+ SKUs with automatic reorder points that reduced out-of-stock incidents by 60% and improved customer satisfaction scores by 25%.

• Containerized services with Docker and deployed on AWS EC2 with Auto Scaling Groups triggered by transaction volume metrics, implementing blue-green deployments via GitHub Actions with automated rollback on business metric degradation, achieving 99.9% uptime while reducing deployment time from 3 hours to 20 minutes.

• Established comprehensive monitoring using Spring Boot Actuator and custom Micrometer metrics tracking waste percentage, order accuracy, and fulfillment time, building Grafana dashboards with intelligent alerts for inventory discrepancies and abnormal waste patterns that reduced shrinkage by 30%, saving $4M+ annually.

• Led critical production incident response when payment integration failure caused order backlog during morning rush, im- plementing async order queuing with Kafka for offline order capture and batch processing, successfully processing 10K+ queued orders and preventing $500K revenue loss.

• Standardized API documentation using Swagger/OpenAPI 3.0 across all services, establishing governance for 50+ internal endpoints used by mobile apps, POS systems, and analytics platforms, reducing integration time for new features from 3 weeks to 5 days.

• Collaborated with store operations teams through field visits and feedback sessions with 100+ associates to understand real- world challenges, delivering features that improved associate efficiency by 35% and reduced average order preparation time by 45 seconds.

Environment: Java 11, Spring Boot 2.7, Spring Cloud Gateway, Apache Kafka 3.x, Redis 6.x, MySQL 8.0, Spring Security, JWT, Resilience4j, Docker, AWS (EC2, RDS, ElastiCache, CloudWatch), GitHub Actions, Maven, Swagger 3.0, Micrometer, Grafana, CompletableFuture, Machine Learning, Agile

Philadelphia Insurance Companies Philadelphia, PA

Java Backend Developer 06/2020 - 04/2022

Project: Digital Claims Processing Platform

Description: Delivered a cloud-native claims management platform processing 50K+ monthly claims worth $200M+, replacing legacy mainframe systems. Led backend development initiatives that reduced claim processing time from 5 days to 24 hours while improving fraud detection accuracy by 35%.

Responsibility:

• Developed microservices architecture using Spring Boot to modernize monolithic claims system that took 30+ minutes for bulk operations, designing services for claim intake, validation, adjudication, and payment processing using Hibernate ORM with Spring Data JPA and Oracle 19c, achieving sub-second response times for 95% of operations.

• Built GraphQL API layer to consolidate 20+ legacy REST endpoints into unified schema, implementing DataLoader pattern to solve N+1 query problems and subscription support for real-time claim status updates, reducing mobile app API calls by 60% and improving user experience for 10K+ adjusters.

• Designed RESTful APIs following Richardson Maturity Model Level 3 with HATEOAS, exposing claims data to partner insurance networks and third-party TPAs, implementing API versioning and rate limiting that supported 50+ enterprise integrations processing $50M+ monthly transactions.

• Implemented JWT-based security with Spring Security and OAuth 2.0 for service-to-service authentication, designing token refresh mechanism with 15-minute expiry and secure token storage in Redis, preventing unauthorized access attempts while maintaining stateless architecture across 15 microservices.

• Applied multi-level caching strategy using Redis with different TTLs for claim data (5 minutes), policy information (1 hour), and reference data (24 hours), implementing cache warming for frequently accessed claims and cache invalidation on updates, reducing database load by 75% and average response time from 500ms to 50ms.

• Optimized Oracle query performance by analyzing execution plans and creating composite indexes on claim number + status

+ date columns, implementing database partitioning by claim year and read replicas for reporting queries, reducing claim search time from 8 seconds to under 200ms.

• Built fraud detection integration using Apache Kafka to stream claims data to ML models, implementing event sourcing for complete audit trail and idempotent processing to handle duplicate submissions, flagging 2000+ suspicious claims monthly and saving $5M+ in fraudulent payouts.

• Implemented document processing pipeline handling 100K+ monthly uploads of claim photos and documents, using AWS S3 for storage with lifecycle policies, async processing with Spring @Async for OCR integration, and virus scanning, reducing document processing time from 10 minutes to 30 seconds.

• Deployed services to AWS EC2 using Docker containers with multi-stage builds reducing image size by 60%, configured Auto Scaling Groups based on CPU and memory metrics, and implemented health checks with Spring Boot Actuator, achieving 99.95% uptime during peak enrollment periods.

• Established blue-green deployment strategy using AWS ALB target groups, implementing canary releases with 10% traffic initially and automated rollback on error rate spikes, reducing deployment risks and achieving zero-downtime deployments for 50+ production releases.

• Created comprehensive monitoring using CloudWatch custom metrics tracking business KPIs like claims processed per hour and average processing time, building dashboards for operations team and setting up SNS alerts for SLA violations, reducing incident response time from 30 to 5 minutes.

• Automated CI/CD pipeline using Jenkins for build orchestration and GitHub Actions for PR validation, implementing SonarQube quality gates requiring 80% code coverage and A-rating security score, Liquibase for database migrations, and automated regression tests, reducing release cycle from 2 weeks to 3 days.

• Led performance optimization initiative during open enrollment surge, profiling with JProfiler to identify memory leaks in file processing, tuning JVM heap settings and garbage collection, and implementing connection pooling with HikariCP, handling 3x normal load without additional infrastructure.

• Collaborated with actuarial teams to implement complex claim calculation rules, building rules engine using Spring Expression Language (SpEL) for dynamic formula evaluation, enabling business users to modify calculation logic without code changes, reducing rule update time from 1 week to 1 hour.

• Integrated with legacy COBOL systems using IBM MQ for claim data synchronization, implementing message transfor- mation layer and error handling with dead letter queues, ensuring data consistency across old and new systems during 18-month migration period.

Environment: Java 11, Spring Boot 2.5, Spring Security, Spring Data JPA, Hibernate 5.x, Oracle 19c, GraphQL Java, Redis 6.x, Apache Kafka 2.8, JWT, OAuth 2.0, AWS (EC2, S3, ALB, CloudWatch, SNS), Docker, Jenkins, GitHub Actions, SonarQube, Liquibase, JProfiler, HikariCP, IBM MQ, Agile

CompuData Philadelphia, PA(Remote)

Java Developer 06/2018 - 05/2020

Project: Cloud-Based Enterprise Resource Planning (ERP) Platform Description: Contributed to the development of a multi-tenant cloud ERP platform serving 200+ SMB clients across manufactur- ing, distribution, and professional services sectors. Led backend initiatives that improved system performance by 50% and reduced operational costs by 30% through cloud migration and microservices architecture. Responsibility:

• Developed modular ERP services using Spring Boot to replace legacy Sage ERP monolith, designing microservices for inventory management, financial reporting, payroll processing, and procurement workflows that enabled 15+ implementation teams to work independently, reducing deployment time from 3 months to 3 weeks per client.

• Designed RESTful APIs following OpenAPI 3.0 specification for seamless integration with Sage Intacct, QuickBooks, and client-specific systems, implementing API gateway with rate limiting and usage analytics that supported 100+ integrations processing 5M+ daily transactions across diverse industries.

• Implemented Apache Cassandra as primary datastore for time-series financial data and audit logs, designing wide-column schemas with composite partition keys (client id + year + month) optimized for multi-tenant architecture, achieving 99.99% data durability while reducing storage costs by 40% through strategic TTL policies.

• Tuned Cassandra performance for multi-region deployment, configuring consistency levels (LOCAL QUORUM for writes, ONE for reads), implementing rack-aware replication across 3 data centers, and optimizing compaction strategies that reduced query latency from 200ms to 30ms for financial reporting queries.

• Built event-driven architecture using Apache Kafka for real-time data synchronization between ERP modules, implementing event sourcing for complete audit trail required by SOX compliance, processing 50K+ events per second with exactly-once semantics that eliminated data discrepancies across modules.

• Integrated RabbitMQ for asynchronous workflow orchestration including month-end closing processes, tax calculations, and report generation, implementing priority queues and dead letter exchanges that reduced batch processing time from 6 hours to 40 minutes for payroll calculations.

• Designed intelligent caching layer using Redis with multi-tier strategy: session data (15-min TTL), frequently accessed master data (1-hour TTL), and pre-computed financial reports (24-hour TTL), reducing database load by 65% during month-end reporting peaks.

• Deployed containerized microservices on AWS EC2 using Docker and ECS, implementing auto-scaling based on CPU and memory metrics that handled 3x traffic during tax season without manual intervention, while reducing infrastructure costs by 35% through right-sizing.

• Ensured ACID compliance without traditional RDBMS by implementing distributed sagas for financial transactions, idempo- tency keys for duplicate prevention, and compensating transactions for rollback scenarios, maintaining 100% accuracy for 10M+ monthly transactions.

• Created real-time monitoring dashboards using Prometheus and Grafana tracking business metrics (invoice processing time, payroll accuracy) and technical KPIs (API latency, database performance), enabling proactive issue resolution and 99.9% SLA achievement.

• Achieved 90% test coverage through comprehensive testing strategy using JUnit 5 for unit tests, Testcontainers for inte- gration testing with embedded Cassandra/Kafka, and contract testing with Pact, reducing production bugs by 75%.

• Collaborated with React.js frontend teams to deliver responsive dashboards for financial analytics, implementing GraphQL API layer that reduced data over-fetching by 60% and improved dashboard load times from 5 seconds to under 1 second.

• Led cross-regional collaboration with teams across US, Europe, and Asia-Pacific, conducting architecture reviews in 3 time zones and mentoring 4 offshore developers, successfully delivering multi-currency and multi-language support for global clients.

• Optimized batch processing performance by refactoring legacy payroll calculations using parallel streams and Completable- Future, leveraging all 16 cores on EC2 instances and reducing processing time for 10K+ employee payroll from 6 hours to 40 minutes.

• Built Node.js utility services for data migration and ETL processes, creating scripts that automated the import of legacy data from 50+ client systems, reducing implementation time by 60% and improving data accuracy to 99.9%. Environment: Java 11, Spring Boot 2.4, Apache Cassandra 3.11, Apache Kafka 2.6, RabbitMQ 3.8, Redis 6.0, AWS (EC2, ECS, RDS, S3), Docker, Jenkins, Prometheus, Grafana, JUnit 5, Mockito, Testcontainers, React.js, Node.js, GraphQL, Agile Education

University of Pennsylvania

Master of Computer and Information Science

Penn State University

Bachelor of Science in Computer Science

Contact this candidate