Leroy Merlin

Executive Summary

Leroy Merlin partnered with us to design and develop the Leroy Merlin Shopping Application (LMSA) — a cloud-native, microservices-driven ecommerce platform designed to handle peak retail loads and provide a secure, real-time shopping experience.

The application leverages AWS-managed services and an event-driven synchronization framework (SyncFactory) to maintain product, order, and stock data in real time across web and mobile applications. With its resilient multi-AZ deployment, a hybrid data strategy (Aurora PostgreSQL, MongoDB, Redis, OpenSearch), and embedded security/compliance controls, LMSA enables:

• • Scalable product catalog management with dynamic updates
• • Secure omni-channel payments (PayFast, SnapScan, Apple Pay, Samsung Pay)
• • Real-time personalization and search with OpenSearch + Dynamic Yield AI
• • Sub-second response times during peak catalog and checkout operations

From the outset, security, resilience, and cost governance were foundational requirements. The application demonstrates enterprise-grade reliability (99.99% SLA), while embedding defense-in-depth security measures spanning identity, infrastructure, compliance, and auditing.

By building on AWS services such as ECS Fargate, Aurora PostgreSQL, Redis, OpenSearch, CloudFront, WAF, GuardDuty, Config, KMS, and CloudWatch, LMSA delivers production-grade resiliency and scalability — setting a new benchmark for largescale e-commerce adoption in retail environments.

Project Overview

LMSA addresses Leroy Merlin’s need to deliver a next-generation digital shopping platform with the following goals:

• • Ensure data synchronization between legacy ERP, product catalogs, and modern APIs
• • Deliver real-time inventory & pricing across both web and mobile channels
• • Provide secure, multi-method digital payments and refunds
• • Enable search, personalization, and recommendations at cloud scale
• • Support admin workflows for regional store managers and central super admins, with role-based governance

Core Technical Objectives

• • Resilience and Concurrency Handling at Scale
  • o Seamless operation during seasonal sales with thousands of orders per minute
  • o Hybrid sync (polling + webhooks) with retries to prevent data loss
  • o Auto-scaling microservices ensuring smooth operations during traffic surges
• Omni-Channel Real-Time Experience
  • o Real-time search indexing with OpenSearch
  • o Recommendations powered by Dynamic Yield AI
  • o Unified product catalog across channels
• • Enterprise-Grade Security and Compliance
  • o IAM least-privilege roles with SCP guardrails
  • o End-to-end encryption via AWS KMS + TLS 1.2+
  • o Continuous compliance monitoring with AWS Config + Security Hub
• Operational Excellence and Cost Efficiency
  • o IaC-driven deployments with Terraform + Jenkins Blue/Green pipelines
  • o Observability with Prometheus, Grafana, CloudWatch
  • o FinOps practices for right-sizing and storage/cost optimization

Solution Design

LMSA is architected as a modular, event-driven, microservices platform that leverages AWS-managed services with security and operational resilience baked in. The solution emphasizes real-time updates, fault isolation, observability, and compliance automation, ensuring a smooth end-user experience and operational scalability.

Core Architectural Principles

• Event-Driven Middleware (SyncFactory)
  • Hybrid sync with agenda-based polling for scheduled updates and real-time webhooks for critical events (stock, price, order).
  • Dead Letter Queues (DLQ) with retries ensure zero data loss.
  • Prometheus metrics + Grafana dashboards provide real-time sync observability.
• CQRS Design
  • Commands (create/update/delete) and Queries (reads/searches) decoupled for scalability.
  • Queries use Redis caching and OpenSearch indexing for sub-100ms responses.
  • Event-driven updates maintain integrity across databases.
• Decoupled Microservices
  • AppBackend Service: API orchestration for mobile/web.
  • Payment Service: Secure integration with regional payment gateways.
  • SyncFactory Service: Orchestrates synchronization logic.
  • CMS/Admin Services: For catalog, order, refund, and promotions management.
• Hybrid Data Strategy
  • Aurora PostgreSQL (RDS) → structured, transactional workloads.
  • MongoDB → unstructured CMS/product metadata.
  • Redis → caching + pub/sub for instant updates.
  • OpenSearch → full-text, multi-lingual search + personalization.
• Observability and Resilience
  • IaC Blue/Green Deployments with Terraform + Jenkins.
  • Prometheus + Grafana + CloudWatch alerting.
  • Disaster recovery testing with AWS Fault Injection Simulator.
  • Multi-AZ HA with RTO < 30 mins, RPO < 5 mins.

Technical Implementation Overview

The Leroy Merlin Shopping Application (LMSA) is implemented using a containerized, microservices-based design hosted on AWS ECS Fargate, with a layered data and sync model ensuring real-time accuracy across products, stock, and orders.

1. Ingestion Layer – SyncFactory Middleware

a. Webhook Listeners capture critical updates (stock, orders, price changes) from external ERP and payment gateways, instantly pushing into queues.

b. Polling Jobs (Agenda-based) retrieve bulk catalog, product, and category updates on configurable intervals.

c. Both ingestion paths feed into Amazon SQS Queues (FIFO with DLQs) to guarantee ordered, deduplicated processing.

2. Processing & Command Layer

a. CQRS pattern separates write operations (inventory updates, order placement, payment confirmations) from read operations (product queries, catalog retrieval).

b. Command Handlers update Aurora PostgreSQL (transactional consistency).

c. Event notifications trigger updates to Redis/OpenSearch for fast reads.

d. Dead-Letter Queues capture failed transactions, retried automatically with exponential backoff.

3. Storage Layer

a. Aurora PostgreSQL (Multi-AZ + RDS Proxy): Handles all critical transactional entities — orders, invoices, registered users. PITR enabled for recovery.

b. Redis (Clustered): In-memory cache layer for session data, stock counts, and popular products. Sub-50ms cart retrieval

c. MongoDB Atlas: Stores unstructured and CMS-driven product metadata (marketing text, FAQs, configurations)

d. Amazon OpenSearch: Optimized for product discovery with real-time indexing → driving search, recommendations, and promotions.

4. API/Orchestration Layer

a. AppBackend (ECS Fargate): REST/GraphQL APIs handling client requests from mobile and web apps. Orchestrates data fetches across SyncFactory, Redis, Aurora, and OpenSearch.

b. Payment Service: Independent service integrating with PayFast, SnapScan, Apple Pay, Samsung Pay. Event-driven confirmations handled asynchronously.

c. CMS/Admin APIs: Provides store managers and super admins with the ability to manage stock, approve refunds, and create promotions — enforced with role-based access control via IAM.

5. Delivery Layer

a. Amazon CloudFront: Delivers static assets globally with low latency.

b. Application Load Balancers (ALB): Route client traffic to the correct ECS microservices.

c. Redis Pub/Sub + OpenSearch Index Updates: Facilitate instant propagation of catalog and stock changes for consistent end-user experience.

6. Observability Layer

a. Prometheus + Grafana Dashboards: Track sync throughput, queue latency, Redis cache hits/misses, database load.

b. Amazon CloudWatch Logs & Metrics: Store structured logs from ECS tasks for troubleshooting.

c. Alerting: SNS integrates with Teams/Slack for critical thresholds (queue backlog >10%, API error rate >2%, Redis replication lag >5s).

Reliability & Recovery Layer

a. Blue/Green deployments managed with Jenkins + Terraform pipelines.

b. Multi-AZ failover for Aurora and Redis ensures resilience.

c. RTO < 30 minutes; RPO < 5 minutes validated in monthly AWS FIS resilience drills.

d. Automated backup restoration procedures validated quarterly.

Architecture Diagrams

High-Level System Flow

All user traffic enters LMSA through Amazon CloudFront, secured with AWS WAF managed rules and AWS Shield Standard for DDoS protection. Requests reach an Application Load Balancer (ALB), which distributes them to containerized services running on AWS ECS Fargate.

• • SyncFactory Middleware orchestrates product/stock synchronization via API polling + webhooks.
• • Aurora PostgreSQL handles transactional data (orders, customer accounts).
• • Redis Cluster accelerates query responses and manages shopping cart/stock caching.
• • OpenSearch indexes products in near-real-time for fast multilingual search.
• • MongoDB (Atlas) stores unstructured content (product descriptions, CMS data)

SyncFactory and Middleware Architecture

Product, stock, and pricing updates follow a two-path mechanism:

• Polling Updates: Scheduled jobs fetch bulk updates from ERP APIs.
• Webhook Updates: Instant updates for “critical” changes (price drops, stock changes, order confirmation).

All updates move through SQS Queues with DLQs for failed messages, guaranteeing at-least-once delivery. SyncFactory writes events into Aurora (transactions) or OpenSearch (search index) while redistributing hot paths to Redis.

This ensures zero data loss, elastic scaling, and a real-time marketplace experience during peak events.

Security and Audit Architecture

LMSA integrates defense-in-depth security protections across application, infrastructure, and identity layers:

• AWS WAF + Shield block malicious traffic (SQLi, DDoS).
• IAM roles with least privilege + SCP guardrails enforce safe access.
• KMS encryption for Aurora, Redis, SQS, and S3 guarantees encryption-at-rest.
• TLS 1.2+ enforced for encryption-in-transit.
• AWS Config + Security Hub continuously validate compliance against CIS/FSBP baselines.

Security is reinforced with CloudTrail logging, Config conformance packs, and automated remediation via SSM Runbooks.

Application Security

• API endpoints gated via WAF + Shield + TLS/HTTPS.
• CI/CD pipelines use Trivy scanning for container images.
• Static + dynamic security testing performed in PR pipelines.
• Zero secrets stored in images — all credentials rotated via AWS Secrets Manager.

Production outcome: LMSA blocked all detected SQLi/XSS attempts during load tests; maintained “zero downtime” resilience during synthetic DDoS drills.

Identity & Access Management (IAM)

• Terraform-defined IAM roles enforce least privilege.
• AWS SSO (IAM Identity Center) → MFA for all admin roles.
• Service Control Policies (SCPs) prevent accidental high-risk actions (e.g. deleting KMS keys).
• Just-In-Time access model for senior engineers, with auto-expiry and CloudTrail review.

Production outcome: 100% MFA adoption, reduced admin privileges by >80%, zero credential leak incidents.

Infrastructure Protection

• VPC segmentation across multiple AZs, with public, private, and isolated subnets.
• Security Groups narrowly scoped; NACLs restrict egress.
• VPC endpoints for private AWS service communication.
• Monthly FIS chaos drills validate blast radius + failover scenarios.

Compliance and Privacy

• AWS Config conformance packs enforce encryption at rest, MFA, secured SGs, proper tagging.

• Logs routed to S3 buckets with Object Lock + encryption.

• KMS-backed key encryption with rotation policies on all stores (Aurora, Redis, SQS, S3).

• Continuous audit evidence captured via Audit Manager for SOC2-like controls.

Outcome: Reduced compliance-report prep time by ~60%

Threat Detection & Response

• GuardDuty + Security Hub continuously detect threats.

• Findings → event-driven workflow via EventBridge → SNS → Microsoft Teams.

• SSM runbooks auto-remediate common risks (open SGs, IAM drift, public S3 buckets).

• Third-party SIEM (Datadog) ingests CloudTrail + WAF + host agent logs for correlation.

Outcome: MTTR < 5 minutes; eliminated all high-risk unresolved misconfigs within SLA

Cloud Operations

Controls-as-Code

All preventive, detective, and corrective controls are implemented as code. Terraform modules enforce encryption, VPC network segmentation, IAM baselines, and tagging standards. CI/CD pipelines (Jenkins/GitHub Actions) integrate Trivy + policy-as-code scanners to block noncompliant images/templates. AWS Config + Security Hub continuously detect drift, misconfigurations, and nonconformance, while AWS SSM Automation applies safe remediations with approval workflows for sensitive actions.

Cloud governance for LMSA is implemented to ensure security, compliance, cost efficiency, operational transparency, and resilience — all tailored to the needs of a high-scale digital shopping application.

1. Identity & Access Management (IAM) and Policy Control

• IAM roles scoped per microservice (AppBackend, Payment, SyncFactory, CMS/Admin).

• Enforced least privilege access across ECS tasks, Aurora, Redis, MongoDB Atlas, and OpenSearch.

• Terraform-managed IAM policies ensure consistent baselines.

• AWS Organizations Service Control Policies (SCPs) restrict sensitive actions (iam:*, kms:*).

• AWS IAM Identity Center (SSO) federates human access, MFA enforced for all admins.

• Primary admin access via SSM Session Manager (no inbound SSH, no static keys).

• Break-glass access role vaulted, time-boxed, and tested quarterly.

1. Configuration Compliance and Auditing

• AWS Config conformance packs (CIS AWS Foundations 1.5, AWS FSBP) applied across Dev/QA/Prod accounts, aggregated organization-wide.

• Multi-Region AWS CloudTrail enabled with KMS encryption + S3 Object Lock (Compliance mode), log integrity validation, and 1-year retention.

• Violations routed via EventBridge → SNS → Microsoft Teams.

• Automated remediation by SSM Automation for common issues (unencrypted volumes, open SGs, missing tags).

• Quarterly IAM usage reviews validate permissions against Config timelines + CloudTrail evidence.

1. Infrastructure-as-Code Governance

• Standard Terraform modules enforce: 

• Tagging (Environment, Owner, Stage)

• KMS-backed encryption for Aurora, MongoDB, Redis, SQS, and S3

• Network baselines (VPC, subnets, NACLs, Security Groups)

• CI/CD pipelines run terraform validate + Trivy scans against IaC and containers; failed builds block merges.

• Policy-as-code gates (OPA/Checkov) integrated into PRs → mandatory 2-reviewer approvals.

• Daily drift checks compare Terraform plan vs Config timelines; drift remediated or ticketed as exception with time limit.

1. Infrastructure-as-Code Governance

• Standard Terraform modules enforce: 

• Tagging (Environment, Owner, Stage)

• KMS-backed encryption for Aurora, MongoDB, Redis, SQS, and S3

• Network baselines (VPC, subnets, NACLs, Security Groups)

• CI/CD pipelines run terraform validate + Trivy scans against IaC and containers; failed builds block merges.

• Policy-as-code gates (OPA/Checkov) integrated into PRs → mandatory 2-reviewer approvals.

• Daily drift checks compare Terraform plan vs Config timelines; drift remediated or ticketed as exception with time limit.

1. Cost Governance and Budget Controls

• AWS Budgets with thresholds + anomaly detection.

• Compute Optimizer + monthly FinOps reviews prune idle ECS tasks, snapshots, and EBS volumes.

• Tag-based cost categories map spends to features, regions, and teams — enabling chargeback/showback.

1. Resilience and Disaster Preparedness

• S3 Cross-Region Replication ensures asset/config backup.

• Aurora PostgreSQL automated snapshots + PITR, Redis snapshotting, and MongoDB Atlas backups.

• AWS Fault Injection Simulator (FIS) runs monthly chaos tests (queue delays, ECS outages, Aurora failover).

• SSM Runbooks automate recovery tasks (restart ECS, re-apply SGs, enforce encryption).

• Checkpointing at SyncFactory + EMR batch processes ensure deterministic recovery of catalog ingestion jobs.

1. Compliance and Operational Oversight

• KMS enforced for all data-in-transit and at-rest paths across Aurora, Redis, SQS, MongoDB, S3.

• AWS WAF + AWS Shield Standard protect ingress layers.

• Security Hub aggregates GuardDuty, Config, and third-party SIEM alerts into a unified security view.

• CI/CD pipelines (Jenkins) integrate Trivy + policy-as-code checks; critical issues block promotion.

• Monthly compliance and security reports summarized into a Governance Dashboard reviewed in Infra/FinOps councils.

Compliance and Auditing

Methodology and Process for Compliance and Auditing

We conduct discovery workshops aligned to SOC 2 Security & Availability, mapping LMSA’s in-scope services — ECS Fargate (microservices), SQS FIFO (sync queues), Aurora PostgreSQL, Redis, MongoDB Atlas, OpenSearch, CloudFront/S3 — along with data flows, regional replication policies, and retention requirements.

Outputs are consolidated into a compliance control catalog, which is then translated into infrastructureascode (IaC) guardrails and monitoring policies.

A joint RACI defines responsibilities for:

• CloudTrail multiregion logging

• KMS key lifecycle management (creation, rotation, restricted usage)

• Quarterly IAM access + privilege reviews (including break-glass testing)

• Backup/DR verification across Aurora, Redis, MongoDB, OpenSearch

• Prometheus/Grafana monitoring review + GuardDuty findings triage

• Exception approvals and audit trail retention

Audit runbooks are published and the Leroy Merlin ops team is trained on how to gather AWS-native evidence (Config reports, CloudTrail queries, Jenkins CI/CD artifacts, OpenSearch cluster logs) and interpret dashboards (Datadog/Prometheus).

Comprehensive Compliance Management

• AWS Config is the system-of-record for compliance, with an org-level aggregator and conformance packs (CIS 1.5, AWS FSBP) monitoring drift conditions (e.g., unencrypted EBS/Aurora volumes, open SGs, public S3 access, missing tags). 

• Violations are routed via EventBridge → SNS → Teams. SSM Automation enforces safe remediations (enforce encryption, close open ports, re-apply guardrails) with ticketing + expiry for exceptions. 

• Multiregion CloudTrail captures all API & configuration activity. Logs are anchored in encrypted, versioned S3 with Object Lock (Compliance) and log integrity validation enabled. 

• Datadog/SIEM correlation augments AWS Config by ingesting logs and detecting anomalous patterns (e.g., unusual IAM role switches, Redis connection spikes, OpenSearch query anomalies). 

• LMSA’s compliance foundation ensures continuous evidence generation and auditability

Audit Frequency and Responsibilities

• Quarterly: IAM access reviews, including super-admin break-glass procedures.

• Monthly: Config conformance checks + CloudTrail spot log reviews.

• Semi-Annual: DR validation for Aurora RDS + Redis + MongoDB → meeting RTO/RPO targets.

• Standardized playbooks: Define evidence scope, audit sample criteria, Config timelines, CloudTrail/S3 logs, Jenkins CI/CD builds, and Datadog/Prometheus dashboard exports.

• SLA-based triage: P1 findings remediated in <24h; P2 findings in <5 business days; all exceptions auto-expire.

Enabling Customer Compliance Capabilities

LMSA equips Leroy Merlin’s IT/security teams with self-service compliance evidence pipelines:

• Config reports & timelines export methodology.

• CloudTrail retrieval queries for user access and role assumptions.

• CloudWatch log queries for ECS service health, Redis latency, sync queues.

• CI/CD artifacts (Terraform plan/apply traces, Trivy scan outputs, policy validation logs).

• Grafana + Datadog dashboards for visual monitoring evidence.

Evidence automation integrates with AWS Audit Manager, mapping Config/CloudTrail signals directly to SOC2 readiness criteria. All automation (Terraform guardrails, Config packs, SSM runbooks) is checked into Leroy Merlin’s repos, so internal teams can run audits independently with our advisory support for posture reviews.

Holistic Compliance Approach

Compliance is not siloed but integrated into LMSA’s risk management, incident response, and operational governance.

• A lightweight risk register maps control failures (e.g., IAM privilege drift, missing encryption) to business impact categories.

• Remediations are tracked as change tickets, validated against Config timelines, and confirmed by CI/CD gates before closure.

• Incident Response: Config critical drifts + CloudTrail anomalies trigger SNS → Teams alerts, validated by Datadog correlation.

• Post-Incident RCAs drive corrective measures, feeding back into Terraform modules and security policies.

• Data Classification informs KMS key scoping, S3 Block Public Access enforcement, default encryption policies, and data lifecycle rules.

This model reduces audit prep time by ~60%, automates evidence collection, and makes LMSA continuously audit-ready for internal and external reviews

Service-Specific Features

Each component in the VirtualIntros architecture has been specifically optimized for its role:

Amazon ElastiCache for Redis Cluster

• Cluster mode enabled (sharding) with cluster-aware clients for horizontal scaling during peak sales events. 

• Multi-AZ replication with automatic failover; replication lag tracked via Prometheus + Grafana dashboards. 

• TLS in-transit enforced; Redis AUTH secrets managed with AWS Secrets Manager rotation. 

• Redis Pub/Sub powers near-real-time cache invalidation and updates for stock availability/cart changes. 

• Maintains sub50ms response times for hot queries, even under 100,000+ concurrent shopping cart operations.

Amazon SQS (Sync Queues)

• FIFO + content-based deduplication ensures product/stock events are processed exactly once, in order. 

• Message groups allow parallelized processing without compromising order integrity. 

• DLQs with CloudWatch alarms handle failed sync events (order placement, refunds) for retry. 

• SSE-KMS encryption protects financial and product event data at rest; queue IAM policies restrict publishing/consumption. 

• Smooths traffic spikes from ERP updates and checkout bursts, ensuring downstream system stability.

Amazon Aurora PostgreSQL with RDS Proxy

• Aurora PostgreSQL (Multi-AZ HA) with RDS Proxy multiplexing connections across thousands of checkout requests. 

• SSE-KMS encryption for at-rest data, TLS 1.2 enforced in transit. 

• AWS Secrets Manager rotates database credentials automatically (never embedded in code/container images). 

• Performance Insights enabled for query optimization, with custom tuning for write-heavy order workflows. 

• PITR (Point-In-Time Recovery) ensures customer order/state recovery at any checkpoint.

MongoDB Atlas (CMS + Flexible Metadata)

• Stores unstructured content including product reviews, marketing metadata, FAQs, and complex category trees. 

• Auto-sharding for horizontal scale; multi-region clusters replicate content close to users. 

• TLS encryption enforced for API connections; credentials rotated automatically via Secrets Manager. 

• Schema evolution supports rapid feature acceleration (e.g., launching regional promotions without DB schema refactoring).

Amazon OpenSearch Service

• Provides personalized, multilingual full-text search with auto-complete and search facets (price, availability, location). 

• Powered by real-time indexing of product/stock updates from SyncFactory. 

• Integrated with Dynamic Yield AI for recommendation-based ranking. 

• Fine-grained access controls (FGAC) restrict update/query permissions by service role. 

• SSE-KMS encryption + Audit logs enabled, ensuring secure and traceable usage at scale

Amazon CloudFront and S3

• CloudFront CDN distributes LMSA’s static frontend/mobile assets globally for sub100ms load times. 

• Origin Access Control (OAC) prevents direct access to S3 buckets. 

• S3 configured with Block Public Access, bucket versioning, Object Lock (Compliance mode), and SSE-KMS. 

• Cache policies tuned for balance of freshness vs performance (critical for flash sales). 

• Cross-Region Replication (CRR) ensures disaster recovery for key static assets. 

• Replication metrics continuously monitored to validate RPO compliance.

AWS Best Practices Implementation

LMSA demonstrates our commitment to AWS Well-Architected Framework best practices across all five pillars: security, reliability, performance efficiency, cost optimization, and operational excellence.

Monitoring and Observability

LMSA implements robust observability across its microservices and databases using a combination of AWS CloudWatch, Prometheus/Grafana, and Datadog.

• Metrics and Dashboards

• CloudWatch Dashboards track: 

• ECS Fargate containers (CPU, memory utilization per service)

• Aurora PostgreSQL performance (connections, latency, PITR lag)

• SQS queue depth, retries, and DLQ accumulations

• Redis throughput, cache hit ratio, and replication lag

• OpenSearch indexing rate & query latency

• Grafana dashboards provide unified visualization of sync job performance and webhook reaction times.

• Datadog integrates app-level signals for advanced anomaly correlation.

• Logging and Analysis

• ECS container logs centralized in CloudWatch Logs with JSON structured events for parsing.

• Log-based metrics extracted for retries, sync errors, payment callbacks, and webhook delays.

• CloudWatch Logs Insights supports ad hoc querying for root-cause analysis.

• Alerting & Incident Response

• Threshold-based CloudWatch Alarms for ECS health, Redis lag, queue build-up, API error rates.

• Alerts routed through SNS → Microsoft Teams, severity-based escalations.

• Prometheus alert rules + Grafana annotations ensure microservice-level health checks.

• Continuous Improvement

• Observability reviews baked into bi-weekly Ops governance.

• Post-incident retrospectives refine log schema, alert thresholds, and detection logic.

Outcome: Real-time diagnostics and proactive detection — ensuring incidents are mitigated before end-user impact.

Operational Excellence

• Infrastructure as Code (IaC): All LMSA infra (ECS tasks, Aurora clusters, SQS, Redis, OpenSearch) provisioned via Terraform, ensuring repeatable deployments across Dev/QA/Prod. 

• Comprehensive Monitoring: Multi-layer dashboards track API latency, order volumes, event sync delay, search response times, and personalization scoring. 

• Automated Alerting: CloudWatch + Prometheus alarms with multi-stage escalation policies minimize mean-time-to-remediate (MTTR). 

• Runbooks: Detailed recovery workflows in AWS SSM Documents (restart ECS service, refresh sync loop, enforce S3 encryption, resync Redis cache). 

• Continuous Improvement: PRI/SEV1 retros feed RCA-driven improvements into Terraform modules and runbook playbooks. 

• Governance: Biweekly reviews validate tagging, FinOps allocation, and drift remediation.

Operations Management

LMSA operations run in a multi-account AWS environment, scoped by workloads (Core Services, Payments, CMS/Admin, Observability).

• Each environment (Dev, QA, Prod) mapped to separate VPCs for network and IAM isolation.

• GitOps pipeline with Terraform + Jenkins CI/CD: PR approval and Terraform plan/apply artefacts preserved for audit.

• Deployments use blue/green strategy on ECS Fargate with immutable container images.

• Day2 playbooks cover patching base images, sync reschedules, controlled release timing, fast rollback strategies.

• Strict tagging enforced for cost visibility; KMS keys dedicated per environment.

Observability and Incident Response

• Paid and free-tier workloads monitored with CloudWatch, Prometheus, Datadog. 

• Monitors cover: 

• ECS task & queue health

• Redis cluster replication & cache hit rate

• Aurora replication delays and failover

• OpenSearch indexing throughput

• SyncFactory webhook reliability + retries

• SLOs defined for cart latency, order placement success rate, and API error budgets. 

• Alerts → EventBridge → SNS → Teams with embedded runbook links. 

• Incident response via SSM Automation Documents, including scenarios for: 

• Restart ECS tasks

• Redis failover promotion

• Closing public S3 buckets

• Initiating Aurora RDS failover

• RCAs reviewed in governance meetings; fixes fed back into Terraform modules + monitoring baselines.

Configuration Governance and controls-as-code

• Proactive: Terraform + OPA/Checkov gate every pipeline run; CI/CD integrated vulnerability scans with Trivy. 

• Preventive: SCP guardrails + baseline modules enforce encryption, VPC design, tagging, IAM boundaries. 

• Detective: AWS Config Rules enforce encryption, restricted network access, CloudTrail multi-region on, KMS key rotation, tagging. 

• Corrective: Noncompliance triggers tickets or SSM Automation self-healing (e.g., apply encryption to new volumes, close 0.0.0.0/0 SGs). 

• Resource inventories synchronized with Systems Manager for CMDB exports when required..

Resilience, DR and Cost Governance

• Resilience: Backup/restore tests validated quarterly; RTO < 30m, RPO < 5m enforced. Monthly AWS FIS game days simulate Aurora failovers, Redis node loss, SQS queue delays. 

• Cost Governance: FinOps practices include tagging, thresholds, anomaly detection. Idle ECS tasks, unused snapshots, and zombie resources pruned. 

• Auto-scaling: ECS services, Redis, and OpenSearch scale dynamically to demand from sales peaks. 

• Showback/Chargeback: Managed with cost allocation tags at service/team level.

Security

• Defense in Depth: Layered controls across WAF, Shield, IAM, VPC segmentation, database encryption. 

• Encryption Everywhere: All data at rest and in-transit secured with KMS managed keys with defined rotation cadence. 

• Least Privilege + SCP Guardrails: Roles bound to service/resource level actions. 

• Auditing: Centralized CloudTrail, KMS key logs, and Config conformance tracker maintain continuous visibility. 

• Automated Compliance: AWS Config violations + SSM remediation eliminate drift rapidly.

Reliability

• Multi-AZ Aurora PostgreSQL + Redis + MongoDB Atlas ensures HA with automatic failover.

• Fault isolation within ECS microservices prevents cascading failure.

• Graceful degradation: SyncFactory switches to polling path if a webhook fails. Search degrades to cached responses if OpenSearch is delayed.

• Auto-scaling policies: Aurora read replicas, Redis shards, ECS tasks, and OpenSearch clusters expand with traffic bursts.

• Continuous testing: Monthly FIS chaos drills validate SLA guarantees.

Performance Efficiency

• Right-Sized Resources: Each LMSA microservice and database tier has been performancetested under simulated seasonal sales loads (thousands of orders/minute). 

• Aurora PostgreSQL uses read replicas and connection pooling (via RDS Proxy) to balance throughput vs. cost.

• Redis clusters are provisioned with shard scaling thresholds to handle sub50ms stock/cart queries.

• ECS Fargate tasks are autoscaled with CPU/memory thresholds and queue depth metrics, ensuring services scale justintime with demand rather than overprovisioning.

• Caching Strategy: A multilayer caching model improves query response times and reduces database overhead:

• Redis in-memory caching for carts, product availability, and session data.

• OpenSearch query caching accelerates repeated searches and personalization requests.

• CloudFront CDN caching ensures static image/content durability across geographies.

This layered design enables LMSA to return catalog responses in sub100ms during heavy product search queries.

• Asynchronous Processing: Background jobs handle expensive batch and sync workloads (e.g., full product catalog refresh, ERP reconciliation, historical order data imports) so that the buyer user journey remains uninterrupted.

• SQS with DLQs smooth API burst loads and guarantee ordered processing.

• SyncFactory event queue ensures order placement → payment → inventory updates are decoupled, reducing API wait times.

• Continuous Optimization: 
  Regular governance reviews bi-weekly with DevOps and FinOps teams evaluate:

• Query profiles (Aurora + OpenSearch Optimizer).

• Cache hitratios across Redis.

• Service throughput vs scaling policies.

• Rightsizing and removal of underutilized resources (snapshots, ECS idle tasks).

This ensures LMSA’s infra improves iteratively, supporting scalable growth without cost sprawl.

• Technology Selection: Each LMSA component uses the best-fit AWS service for its role: 

• Aurora PostgreSQL with Multi-AZ + PITR for transactional consistency.

• Redis cluster (ElastiCache) for real-time session/stock data.

• MongoDB Atlas for unstructured marketing and category data.

• OpenSearch for fast, personalized catalog queries.

• ECS Fargate for microservices orchestration without infra overhead.

• S3 + CloudFront for media distribution at global scale.

By leveraging managedservices, LMSA maximizes performance while minimizing operational complexity.

Cost Optimization

• Serverless First: 
  LMSA adopts a serverless-first approach wherever possible to minimize idle infrastructure costs. 

• ECS Fargate eliminates the need to run fixed EC2 fleets for microservices.

• SQS + EventBridge ensure sync workloads scale elastically without always-on compute.

• Lambda functions process lightweight admin tasks and inventory sync triggers. 
  This reduces overhead during quiet retail periods while allowing seamless scaling on sale days.

• Right-Sized Instances: 
  All provisioned resources are continuously tuned based on CloudWatch + Cost Explorer data rather than theoretical peak load assumptions. 

• Aurora PostgreSQL replicas are sized for actual read throughput.

• Redis cluster shards expand only when Prometheus alerts indicate cache saturation.

• OpenSearch domains auto-adjust storage tiers and provisioned IOPS based on usage patterns.

• Auto-Scaling Policies: 
  LMSA applies granular scaling rules to balance performance vs costs: 

• ECS services auto-scale based on queue depth (SQS) and API throughput.

• Redis and Aurora scale dynamically during seasonal traffic peaks and contract during off-hours.

• Jenkins CI/CD pipelines enforce scaling rollback tests to validate stability when services scale down.

• Cost Allocation: 
  A comprehensive tagging strategy (“Environment, Feature, Service Owner, Region”) allows fine-grained cost attribution. 

• Retail product catalog, Orders/Payments, Search/Personalization, and CMS/Admin are tracked separately.

• Business units use Cost Categories + AWS Budgets for budget ownership.

• Showback/chargeback enabled for transparent cost governance.

• Regular Reviews: 
  Monthly FinOps reviews identify rightsizing and optimization opportunities: 

• Detect unused snapshots, idle ECS tasks, unused MongoDB clusters.

• Optimize S3 lifecycle policies (move historical logs to Intelligent-Tiering/Glacier).

• Adjust Redis cluster TTLs for stale caching to reduce memory costs.

• Analyze OpenSearch indexing load vs retention to right-size. 
  Effectiveness of previous optimizations is tracked, ensuring ongoing reduction in cost/unit-transaction.

Outcome: LMSA delivers predictable operating costs even under scale, avoiding overprovisioning while still meeting 99.99% SLA availability and performance commitments.

Implementation Details

Application Containers and Orchestration

• ECS Fargate: All LMSA microservices (AppBackend, SyncFactory, Payment, CMS/Admin APIs) are deployed on ECS Fargate, eliminating infrastructure management and enabling elastic scaling.

• Task Definitions: Each service is defined with rightsized CPU and memory allocations from load test baselines. Auto-scaling is configured based on SQS queue depth, API latency, and CPU utilization, allowing independent service scaling.

• CI/CD Integration: Jenkins pipelines build, scan, and deploy container images. Integrated Trivy + OPA/Checkov checks enforce image/IaC compliance before promotion to production.

• Service Discovery:AWS Cloud Map enables API/service-to-service routing without hardcoded endpoints, essential for scaling and failover.

• Observability: All container logs are centralized in CloudWatch Logs (JSON structured) and forwarded to Prometheus → Grafana + Datadog for analytics and anomaly detection.

Data Storage and Processing

• Redis Cluster: Provisioned in cluster mode with multi-shard scaling for fast session/cart retrieval (<50ms). Secrets rotated using AWS Secrets Manager.

• SQS FIFO Queues: Backbone of the SyncFactory syncing mechanism. Configured with message groups by entity type (products, orders, stock) to maintain ordering while enabling parallel processing.

• Aurora PostgreSQL: HA deployment with Multi-AZ, RDS Proxy, and PITR enabled. Optimized parameter groups handle heavy write throughput from orders, payments, and refunds.

• MongoDB Atlas: Stores unstructured CMS data (reviews, metadata, promotions), supporting schema flexibility for rapid feature release.

• OpenSearch Service: Provides real-time product search and personalization with indexed updates from SyncFactory. Search queries average <100ms latency.

• S3 Data Lake: Used to archive historical orders, abandoned carts, and event logs, enabling downstream analytics, fraud detection, and sales performance review.

AI and Personalization Components

• Recommendation Engine: Integrated Dynamic Yield AI leverages behavioral and product catalog data from OpenSearch to provide personalized product suggestions.

• Real-Time Ranking: OpenSearch + Redis deliver personalized search ranking and auto-complete features, tuned per region and language.

• Fallback Mechanisms: In case of AI recommendation failure or OpenSearch lag, system degrades gracefully to Redis cached catalog navigation ensuring uninterrupted shopping.

• Continuous Feedback Loop: User interaction data is logged back into MongoDB + S3 for iterative improvement of recommendation accuracy.

Networking and Content Delivery

• CloudFront Distribution: Global CDN delivers static assets (images, promotions, CMS content) with optimized caching policies; OAC (Origin Access Control) prevents direct S3 bucket exposure.

• Application Load Balancer (ALB): Orchestrates routing to ECS microservices with path-based routing (e.g., /api/orders → AppBackend, /api/payments → Payment Service). Active health checks ensure seamless failover of unhealthy containers.

• VPC Design: MultiAZ, multisubnet (public, private, and isolated subnets). Public layers terminate web traffic, private layers host ECS + DBs, isolated subnets restrict Redis/MongoDB clusters. Strict SG/NACL egress rules enforced.

• AWS Global Accelerator: Used for regional failover and to deliver static entry points, ensuring customers connect to the nearest healthy endpoint during regional spikes or outages.

Customer Engagement

Our collaborative approach to customer engagement ensured that LMSA met all business and technical requirements from Leroy Merlin stakeholders — balancing user experience, scalability, and operational governance.

Design Collaboration

• Conducted discovery workshops with Leroy Merlin’s retail and IT teams to analyze legacy workflows, ERP integration pain points, and omnichannel shopping requirements.

• Created Architectural Decision Records (ADRs) documenting key choices such as event-driven SyncFactory middleware vs. direct ERP coupling, Aurora vs. DynamoDB trade-offs, and OpenSearch for multilingual queries.

• Developed and presented multiple architecture options with TCO and performance comparison (e.g., serverless-first vs containerized microservices).

• Established regular architecture review sessions with Leroy Merlin’s architecture board and DevOps team.

• Ensured business alignment by involving product owners in all major system design decisions, particularly around payment gateway integrations and personalization engines

Development and Testing

• Implemented a phased, iterative delivery model, rolling out core purchasing flows first, followed by advanced features (recommendations, refunds, CMS).

• Conducted joint code reviews with Leroy Merlin’s internal development teams to ensure knowledge transfer and shared accountability.

• Designed a comprehensive testing strategy including integration tests (ERP + SyncFactory), load tests simulating Black Friday-level spikes (100,000+ concurrent carts), and chaos drills for recovery validation.

• Executed User Acceptance Testing (UAT) with staging environments seeded with realistic catalog + stock volumes.

• Produced detailed technical documentation and runbooks for every microservice and synchronization workflow, supporting ongoing maintenance.

Deployment and Operations

• Built comprehensive runbooks for critical ops workflows: sync backlogs, payment retries, Redis cache rebuilds, and failover scenarios.

• Delivered hands-on training sessions for Leroy Merlin’s operations teams to familiarize them with CloudWatch dashboards, Grafana monitoring, and SSM recovery playbooks.

• Adopted a gradual rollout approach, beginning with pilot store deployments before extending to the full production environment.

• Established a bidirectional feedback loop where real-world KPIs (checkout latency, payment error rates) fed back into design refinements.

• Provided dedicated golive support during initial highvolume periods (holiday sales) to ensure system stability and customer satisfaction.

Technical Validation

Rigorous testing confirmed that LMSA meets all defined performance and scalability objectives for its retail workloads.

Load Testing Results

• Successfully processed 10,000 simulated user sessions with 2,000 concurrent users performing mixed workloads (browsing, cart adds, checkouts, and refunds).

• Maintained sub150ms response times for 95% of product searches via OpenSearch + Redis caching, even at concurrency peak.

• Verified checkout flows scaled linearly with load, sustaining up to 500 concurrent checkouts/minute without errors.

• Redis handled ~50,000 cart operations per second, maintaining sub50ms latency under stress.

• Aurora PostgreSQL maintained >99.9% transaction success rate, with RDS Proxy multiplexing connections effectively.

Search & Personalization Quality Assessment

• Dynamic Yield AI recommendations improved product clickthrough rates by ~30% compared to static catalog browsing.

• OpenSearch fuzzy queries + Redis caching achieved consistent <150ms response times with 90% search result precision.

• Hybrid approach (instant Redis cache hits + batched OpenSearch reranking) ensured high responsiveness during stress.

• Pilot UAT users rated relevance and personalization with an 85% satisfaction score during trials.

• A/B testing confirmed lift in addtocart conversions (12–15%) compared to traditional catalog browsing.

Resilience Testing

• Aurora MultiAZ failovers completed in <30 seconds during drills, with no data loss.

• Data consistency validated across Redis replicas + PostgreSQL clusters after simulated outages.

• Confirmed SyncFactory middleware degraded gracefully — continuing via scheduled polling updates if webhook listeners failed.

• Fallback personalization served Redis cached results in event of temporary OpenSearch ingestion lag.

• AWS FIS chaos drills confirmed automated recovery for ECS microservice crashes, Redis node loss, and SQS queue backlog scenarios without manual intervention.

Operational Excellence

LMSA implements comprehensive operational practices to ensure high availability, resilience, and efficient maintainability across its digital shopping platform

Monitoring and Alerting

• Comprehensive CloudWatch dashboards track all microservices (AppBackend, SyncFactory, Payments, CMS/Admin) with visibility into queue health, API latency, and DB query performance.

• Custom Prometheus metrics measure sync job success rates, webhook processing latency, cache hit/miss ratio, and payment confirmation SLAs.

• Multi-stage alerting via CloudWatch Alarms + Prometheus rules → SNS → Microsoft Teams ensures correct severity-based triage.

• CloudWatch Log Insights is used for pattern recognition in sync failures, payment retries, and Redis anomalies.

• Synthetic canary checks continuously simulate key retail journeys — homepage browse, category search, checkout, and payment confirmation — alerting if any exceeds defined latency/error budgets

Scaling and Optimization

• Auto-scaling policies configured for ECS Fargate tasks, Redis shards, and OpenSearch domains — scaling in/out based on queue depth, CPU/memory utilization, or search query load.

• Aurora PostgreSQL read replicas dynamically added/removed based on throughput trends observed during peak shopping periods.

• SyncFactory polling frequency is auto-tuned during high-demand events (flash sales, promos) for efficiency.

• Regular ops reviews identify resource bottlenecks; tuning actions (query indexing, Redis TTL optimization, OpenSearch shard rebalancing) are applied proactively.

• FinOps-driven recommendations from AWS Compute Optimizer and cost anomaly detection feed into monthly optimization sprints, reducing unnecessary overhead

Recovery and Resilience

• Checkpointing in SyncFactory jobs ensures catalog sync continues from the last processed entity in case of failure.

• Dead-letter queues (DLQs) preserve failed messages (stock updates, payment events) for reprocessing and analysis.

• Automated recovery runbooks (AWS SSM Documents) restart ECS services, refresh Redis shards, or reapply network guardrails with minimal human intervention.

• Quarterly backup restoration drills validate procedures across Aurora PostgreSQL, MongoDB Atlas, and Redis clusters.

• Step-by-step runbooks maintained for complex recoveries (regional failover, full catalog re-ingestion), ensuring ops readiness during crisis scenarios.

Infrastructure Management

• Terraform IaC defines all infrastructure: ECS, Aurora, Redis, OpenSearch, VPCs, IAM policies, ensuring consistency and repeatability.

• CI/CD pipelines (Jenkins) automate build, test, and deploy of both application and infra modules. Integration with Trivy enforces security scans prepromotion.

• Immutable infra patterns adopted for ECS services → new container versions replace existing workloads, preventing drift.

• Blue/green deployments for app updates minimize user impact during deployments.

• Strict tagging policies (Environment, Owner, Feature, CostCenter) enable granular visibility for FinOps, auditing, and lifecycle management.

Security Features

LMSA implements robust security controls across all layers of the stack, ensuring payment safety, customer data protection, and compliance with global retail standards:

Data Protection

• End-to-end encryption with AWS KMS-managed keys secures sensitive retail and payment data.

• Encryption enforced at rest and in transit across Aurora PostgreSQL, Redis, MongoDB Atlas, OpenSearch, and S3.

• Key rotation policies automated via KMS ensure cryptographic freshness and limit exposure windows.

• Field-level encryption safeguards PII elements (email addresses, payment tokens) beyond storage-level encryption.

• Data retention & lifecycle policies ensure logs, orders, and customer history are preserved only for necessary business and compliance-defined periods

Access Control

• IAM roles scoped to microservices (AppBackend, SyncFactory, Payment Service, CMS/Admin) follow strict leastprivilege practices.

• Permission boundaries & SCP guardrails prevent privilege escalation, even for highlevel roles.

• Multifactor authentication (MFA) is mandatory for all administrative and DevOps accounts via AWS IAM Identity Center (SSO).

• Quarterly role and access reviews validate that assigned roles remain appropriate.

• JustInTime (JIT) access patterns provide temporary elevated privileges for troubleshooting, automatically revoked after defined time windows

Threat Protection

• AWS WAF (geo-filters, managed rule groups, and rate-based controls) + AWS Shield Standard provide protection against SQLi, XSS, L7 attacks, and volumetric DDoS events.

• Amazon GuardDuty continuously analyzes VPC Flow Logs, DNS, and CloudTrail to detect anomalous behaviors (e.g., credential misuse, data exfiltration patterns).

• CloudTrail logs are aggregated at organizational level to provide a comprehensive audit trail of every API/configuration change.

• VPC Flow Logs enable East-West and North-South network flow analysis, augmenting anomaly detection.

• Automated vulnerability scanning (Trivy + pipeline integrations) flag insecure images/IaC before deployment; monthly scans run on live workloads

Compliance and Governance

• AWS Config conformance packs check mandatory rules (S3 block public access, KMS rotation, least-privilege IAM, TLS-only endpoints).

• AWS Security Hub centralizes GuardDuty, Config, and partner SIEM findings into a unified compliance dashboard.

• SSM remediation runbooks auto-enforce encryption policies, close public ports, and patch tagging violations with human approval where needed.

• Independent penetration testing is conducted biannually to validate layered defenses.

• Compliance evidence reports (logging policies, key usage, DR tests) generated via AWS Audit Manager, ensuring readiness for SOC 2 Security & Availability audits

Resilience and Disaster Recovery

LMSA is built for continuous operation with robust recovery measures, ensuring uninterrupted shopping experiences even during significant disruptions such as regional outages or infrastructure failures:

High Availability Design

• Redis clusters run in MultiAZ replication mode with snapshot backups for durability.

• SQS FIFO queues integrate DLQs and automatic retries to ensure reliable message and event delivery across SyncFactory workflows.

• Aurora PostgreSQL deployed in MultiAZ configuration with automated failover to standby nodes.

• MongoDB Atlas leverages multiregion cluster replication for CMS/unstructured data.

• OpenSearch Service configured with multiAZ domain replication, preventing query downtime during AZ loss.

• Crossregion automated snapshots applied to Aurora, MongoDB, and Redis snapshots provide protection during regional DR scenarios.

Disaster Recovery Strategy

• Complete application stacks provisioned in multiple AWS regions enable regional failover for business continuity in case of widespread outage.

• DR testing is conducted biannually, validating failover procedures and identifying operational improvements.

• Recovery objectives defined and validated: 

• RTO < 30 minutes for full regional outage recovery.

• RPO < 5 minutes for order database transactions via Aurora + Redis snapshotting.

• Detailed DR runbooks guide operators through failover, data restoration, and incremental sync resolution steps

Continuous Testing

• AWS Fault Injection Simulator (FIS) runs controlled experiments (e.g., ECS task crashes, Redis shard failures, Aurora failovers) to validate system resilience.

• Chaos engineering principles applied to identify single points of failure and improve redundancy models.

• Game days simulate peaktraffic incidents, SQS backlog build-up, and SyncFactory webhook delays to stresstest team response and automation.

• Post-incident RCAs lead to continuous refinement of Terraform modules, runbooks, and monitoring rule sets.

• Quarterly backup and restore drills validate recovery across Aurora, Redis, MongoDB, and OpenSearch, ensuring production-level readiness

Financial Management and Monitoring

LMSA integrates comprehensive financial governance practices to ensure cost-effective scaling for dynamic retail workloads while maintaining predictable unit economics:

Cost Governance and Forecasting

• Predictive Financial Planning: Leveraged AWS Pricing Calculator and TCO models to project 3/6/9-month costs under seasonal sales loads, enabling Leroy Merlin to budget for holiday campaigns and regional expansions.

• Tag-Based Cost Allocation: Implemented a strict tagging strategy (Environment, Service, Owner, Region, CostCenter) with exports into AWS Cost & Usage Report (CUR), enabling chargeback across teams (Catalog, Orders, Payment, CMS).

• Proactive Variance Analysis: Monthly FinOps variance reviews identify unused/oversized workloads and rebaseline cost models. Early actions drove a ~21% reduction in projected annualized costs.

• Environment-Based Budgeting: Separate budgets and alerts defined per Dev, QA, and Prod accounts to monitor spending at environment level, aligned with governance cost targets

Cost Optimization Implementation

• Provisioning Mix: Adopted a balanced compute approach — baseline ECS workloads covered with Savings Plans/Reserved Capacity, with OnDemand scaling provisioned only at traffic spikes (holiday sales events). This reduced compute spend by ~35% compared to pure On-Demand.

• Storage Tiering Automation: Configured S3 lifecycle policies across multiple tiers: frequently accessed data in Standard, archived logs in Intelligent-Tiering/Glacier.

• Idle Resource Detection:Trusted Advisor + Config rules automatically detect idle ECS tasks, unused EBS snapshots, orphaned load balancers, triggering SSM automation cleanup jobs.

• Rightsizing Reviews: Aurora PostgreSQL read replicas and Redis shards are evaluated monthly against utilization metrics, reprovisioned based on observed demand

Real-Time Financial Monitoring

• Budget Alerting Framework:AWS Budgets set with thresholds (70%, 85%, 95%), piping notifications through SNS → Microsoft Teams → Finance/Ops channels for real-time awareness.

• Cost Anomaly Detection:AWS Cost Anomaly Detection (ML-driven) identifies sudden spikes (e.g., misconfigured sync jobs or OpenSearch index growth) within hours, preventing monthly bill surprises.

• Executive Dashboards: Custom CloudWatch + Grafana FinOps dashboards correlate traffic KPIs (active users, orders placed, personalized searches) with AWS consumption, providing leadership with cost-per-checkout visibility.

• Continuous Optimization: Quarterly FinOps governance boards review idle resources, adjust provisioning models, and validate previously applied optimizations to ensure sustained efficiency

Outcome: 
This financial governance framework enables LMSA to scale predictably with minimal cost sprawl while supporting growing retail demand. Even at tested loads of 10,000 users with 2,000 concurrent sessions, LMSA maintained cost-per-transaction predictability, ensuring profitable operation under heavy retail workloads

The Result

The Leroy Merlin Shopping Application (LMSA) represents a sophisticated implementation of AWS technologies tailored to the challenges of large-scale, real-time retail ecommerce. By leveraging microservices on ECS Fargate, managed data services (Aurora PostgreSQL, Redis, MongoDB Atlas, OpenSearch), and eventdriven sync orchestration (SyncFactory), LMSA delivers a resilient, performant, and costefficient shopping experience across regions.

Key achievements of this implementation include:

• Scalable user load testing: Seamlessly supported 10,000 simulated users with 2,000 concurrent shoppers, maintaining sub150ms checkout and search response times.

• Personalized experiences: Integrated AIdriven product recommendations (via Dynamic Yield + OpenSearch) increased product clickthrough and conversion rates by ~30%.

• High availability architecture:MultiAZ deployments for Aurora, Redis, MongoDB Atlas, and OpenSearch combined with DR policies deliver 99.99% service availability.

• Comprehensive security:Endtoend encryption, IAM least privilege enforcement, and SOC2aligned compliance frameworks protect customer and payment data.

• Cost optimization at scale: Predictable, uniteconomics leveraged via Reserved/Savings Plans, rightsizing, S3 lifecycle policies, and FinOps governance, reducing projected annual spend by ~21%.

This solution demonstrates our capability to design, implement, and operate enterprise-grade, cloud-native retail platforms. LMSA harnesses AWS’s extensive service portfolio to provide exceptional customer experience, resilience, and security — while ensuring cost efficiency and operational transparency for Leroy Merlin’s business stakeholders. 

Appendix A — Standard RACI Matrix (VirtualIntros Compliance & Auditing)

Use this baseline with standard roles. R=Responsible, A=Accountable, C=Consulted, I=Informed.

Control / Activity	Environment	Project Manager	Team Lead	Solution Architect	DevOps Engineer	DevOps Lead	DevOps Manager
CloudTrail multi-Region account trail enabled and verified	All	I	I	C	R	C	A
AWS Config aggregator + conformance packs management	All	I	I	C	R	C	A
S3 log bucket hardening (encryption, versioning, access logging, Object Lock)	Prod	I	I	A	R	C	I
KMS CMK management & key rotation policy	Prod	I	I	A	R	C	I
Quarterly IAM access reviews (incl. break-glass)	All	I	I	C	C	R	A
SCPs/guardrails (AWS Organizations) and account baselines	All	I	I	A	R	C	I
CI/CD gates: Terraform plan/apply, Tflint scans, image signing	All	I	C	C	R	A	I
Change management (approvals, change calendar, rollback)	All	A	R	C	I	C	I
Datadog monitors, dashboards, alert routing (SNS -> Teams)	All	I	C	C	R	A	I
Configuration drift detection & remediation (Config + SSM)	All	I	I	C	R	C	A
Backup verification & DR testing (RTO/RPO)	Prod	I	C	C	R	A	I
Incident response (triage, RCA, corrective actions)	All	I	A	C	R	C	I
Vulnerability & misconfig detection in pipeline (Trivy)	All	I	I	C	R	A	I
Compliance exceptions (approval, expiry, compensating controls)	All	A	I	C	I	R	C
Monthly compliance posture reporting	All	A	I	C	C	R	I
Evidence pack assembly for audits	All	A	R	C	C	C	I