From 09fe32a0a215d2ee7975d8120f9e56debe47e8e1 Mon Sep 17 00:00:00 2001
From: Hwan0518 <qip0518@naver.com>
Date: Fri, 13 Mar 2026 03:20:54 +0900
Subject: [PATCH 1/9] =?UTF-8?q?docs:=20=EA=B3=BC=EC=A0=9C=20=EC=9A=94?=
 =?UTF-8?q?=EA=B5=AC=EC=82=AC=ED=95=AD,=20=EC=84=B1=EB=8A=A5=20=EB=B6=84?=
 =?UTF-8?q?=EC=84=9D,=20=EA=B0=9C=EC=84=A0=20=EA=B3=84=ED=9A=8D,=20AS-IS?=
 =?UTF-8?q?=20=EC=B8=A1=EC=A0=95=20=EA=B2=B0=EA=B3=BC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- round5-docs/00-requirements.md
- round5-docs/01-performance-improvement-analysis.md
- round5-docs/02-performance-improvement-plan.md
- round5-docs/03-as-is-performance-measurement.md
- round5-docs/03-as-is-performance-visualization.html

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
---
 round5-docs/00-requirements.md                |   43 +
 .../01-performance-improvement-analysis.md    |  404 +++++++
 .../02-performance-improvement-plan.md        | 1020 +++++++++++++++++
 .../03-as-is-performance-measurement.md       |  403 +++++++
 .../03-as-is-performance-visualization.html   |  725 ++++++++++++
 5 files changed, 2595 insertions(+)
 create mode 100644 round5-docs/00-requirements.md
 create mode 100644 round5-docs/01-performance-improvement-analysis.md
 create mode 100644 round5-docs/02-performance-improvement-plan.md
 create mode 100644 round5-docs/03-as-is-performance-measurement.md
 create mode 100644 round5-docs/03-as-is-performance-visualization.html

diff --git a/round5-docs/00-requirements.md b/round5-docs/00-requirements.md
new file mode 100644
index 000000000..a3e3ec699
--- /dev/null
+++ b/round5-docs/00-requirements.md
@@ -0,0 +1,43 @@
+### 📋 과제 정보
+
+아래 세 가지 **성능 개선을 수행**합니다.
+
+> 모두 수행하는 것이 더 좋습니다. 선택 이유 및 AS-IS, TO-BE 에 대해서는 블로그에 첨부해 주세요.
+>
+
+---
+
+**① 상품 목록 조회 성능 개선**
+
+- 상품 데이터를 10만개 이상 준비합니다 (각 컬럼의 값은 다양하게 분포하도록 합니다 )
+- 브랜드 필터 + 좋아요 순 정렬 기능을 구현하고, **`EXPLAIN`** 분석을 통해 인덱스 최적화를 수행합니다.
+- 성능 개선 전후 비교를 포함해 주세요.
+
+**② 좋아요 수 정렬 구조 개선**
+
+- **비정규화**(**`like_count`**) 혹은 **MaterializedView** 중 하나를 선택하여 좋아요 수 정렬 성능을 개선합니다.
+- 좋아요 등록/취소 시 count 동기화 처리 방식이 누락되어 있다면 이 또한 함께 구현합니다.
+
+**③ 캐시 적용**
+
+- 상품 상세 API 및 상품 목록 API에 **Redis 캐시**를 적용합니다.
+- TTL 설정, 캐시 키 설계, 무효화 전략 중 하나 이상 포함해 주세요.
+
+---
+
+## ✅ Checklist
+
+### 🔖 Index
+
+- [ ]  상품 목록 API에서 brandId 기반 검색, 좋아요 순 정렬 등을 처리했다
+- [ ]  조회 필터, 정렬 조건별 유즈케이스를 분석하여 인덱스를 적용하고 전 후 성능비교를 진행했다
+
+### ❤️ Structure
+
+- [ ]  상품 목록/상세 조회 시 좋아요 수를 조회 및 좋아요 순 정렬이 가능하도록 구조 개선을 진행했다
+- [ ]  좋아요 적용/해제 진행 시 상품 좋아요 수 또한 정상적으로 동기화되도록 진행하였다
+
+### ⚡ Cache
+
+- [ ]  Redis 캐시를 적용하고 TTL 또는 무효화 전략을 적용했다
+- [ ]  캐시 미스 상황에서도 서비스가 정상 동작하도록 처리했다.
diff --git a/round5-docs/01-performance-improvement-analysis.md b/round5-docs/01-performance-improvement-analysis.md
new file mode 100644
index 000000000..aac6bf188
--- /dev/null
+++ b/round5-docs/01-performance-improvement-analysis.md
@@ -0,0 +1,404 @@
+# 성능 개선 현황 분석
+
+## 목표 ① 상품 목록 조회 성능 개선
+
+### 현재 상황
+
+| 항목 | AS-IS |
+|------|-------|
+| 조회 API 목적 | 사용자 상품 목록 조회 (`GET /api/v1/products`) |
+| 주요 조회 조건 | `deleted_at IS NULL` + 선택적 `brand_id` 필터 |
+| 사용한 테이블/데이터 | `products` LEFT JOIN `brands` |
+| 해당 테이블의 인덱스 | **PK(id)만 존재. brand_id, deleted_at, like_count, price, created_at 에 인덱스 없음** |
+| 캐시 적용 여부 및 위치 | 없음 |
+| 캐시 키 전략 | N/A |
+| 캐시 TTL 가정 | N/A |
+
+**현재 쿼리 구조** (`ProductQuerydslRepository.searchProducts`):
+```sql
+-- 데이터 쿼리
+SELECT p.id, p.brand_id, b.name, p.name, p.price, p.stock, p.like_count
+FROM products p LEFT JOIN brands b ON b.id = p.brand_id
+WHERE p.deleted_at IS NULL [AND p.brand_id = ?]
+ORDER BY p.like_count DESC  -- (or created_at DESC, price ASC)
+OFFSET ? LIMIT ?
+
+-- 카운트 쿼리 (별도 실행)
+SELECT COUNT(*) FROM products WHERE deleted_at IS NULL [AND brand_id = ?]
+```
+
+**문제점**:
+- 10만건 이상에서 `deleted_at IS NULL` 필터 → Full Table Scan
+- `brand_id` 필터 + `like_count DESC` 정렬 → 인덱스 없이 filesort 발생
+- 카운트 쿼리도 별도로 Full Table Scan
+- `OFFSET` 기반 페이지네이션은 뒤 페이지로 갈수록 성능 급감 (skip scan)
+
+### 유즈케이스별 조회 조건 매트릭스
+
+총 6가지 조합이 발생하며, 각각에 대해 EXPLAIN 분석이 필요하다.
+
+| # | brandId 필터 | 정렬 조건 | WHERE 절 | ORDER BY |
+|---|:---:|---|---|---|
+| 1 | X | LATEST (기본) | `deleted_at IS NULL` | `created_at DESC` |
+| 2 | X | PRICE_ASC | `deleted_at IS NULL` | `price ASC` |
+| 3 | X | LIKES_DESC | `deleted_at IS NULL` | `like_count DESC` |
+| 4 | O | LATEST | `deleted_at IS NULL AND brand_id = ?` | `created_at DESC` |
+| 5 | O | PRICE_ASC | `deleted_at IS NULL AND brand_id = ?` | `price ASC` |
+| 6 | O | LIKES_DESC | `deleted_at IS NULL AND brand_id = ?` | `like_count DESC` |
+
+> **EXPLAIN 분석 계획**: 인덱스 적용 전(AS-IS)과 적용 후(TO-BE) 각 6개 유즈케이스에 대해 `EXPLAIN ANALYZE`를 실행하고, `type`, `rows`, `Extra` (filesort/Using index 여부), 실행 시간을 비교한다.
+
+### 설계 방향
+
+| 항목 | TO-BE |
+|------|-------|
+| 조회 API 목적 | 동일 |
+| 주요 조회 조건 | 동일 (brand_id 필터 + 정렬) |
+| 사용한 테이블/데이터 | 동일 |
+| 해당 테이블의 인덱스 | 복합 인덱스 추가 필요 — 정렬 타입별로 covering 가능한 인덱스 설계 |
+| 캐시 적용 여부 및 위치 | 목표 ③에서 별도 처리 |
+| 캐시 키 전략 | 목표 ③에서 별도 처리 |
+| 캐시 TTL 가정 | 목표 ③에서 별도 처리 |
+
+**인덱스 후보 (EXPLAIN 분석 대상)**:
+
+| 인덱스 | 커버하는 유즈케이스 | 비고 |
+|--------|:---:|---|
+| `(brand_id, deleted_at, like_count)` | #3, #6 | 좋아요 순 정렬 (핵심) |
+| `(brand_id, deleted_at, created_at)` | #1, #4 | 최신순 정렬 |
+| `(brand_id, deleted_at, price)` | #2, #5 | 가격순 정렬 |
+
+> **컬럼 순서 결정 원칙 — 카디널리티 우선**: `brand_id`(수십~수백 distinct)가 `deleted_at`(2 distinct: NULL/timestamp)보다 카디널리티가 높으므로 선두 컬럼에 배치. 두 컬럼 모두 equality 조건으로 사용되므로 인덱스 동작에는 영향 없으나, B-tree fan-out이 더 균등해짐.
+>
+> brandId 필터 없는 케이스(#1, #2, #3)에서는 인덱스 선두 컬럼(`brand_id`)을 사용할 수 없으므로 별도의 2-column 인덱스 `(deleted_at, sort_col)` 필요.
+
+### 구조적 리스크 분석
+
+**1. 설계가 성립하기 위해 반드시 참이어야 하는 전제 조건**
+- `deleted_at IS NULL`인 행이 전체의 대다수(90%+)라면 인덱스 필터링 효과가 약해짐. Partial Index가 없는 MySQL에서는 `deleted_at` 컬럼을 인덱스 선두에 두되, `IS NULL` 조건이 인덱스 range scan을 탈 수 있어야 함
+- `brand_id`의 cardinality가 충분히 높아야 인덱스 selectivity가 의미 있음. 브랜드 수가 10개 미만이면 인덱스 효과 미미
+- 정렬 타입이 3개(LATEST, PRICE_ASC, LIKES_DESC)이므로 인덱스를 3벌 만들거나 trade-off를 감수해야 함
+
+**2. 트래픽 10배 증가 시 가장 먼저 병목이 될 지점**
+- **카운트 쿼리**. 데이터 쿼리는 LIMIT으로 제한되지만 `COUNT(*)`는 조건에 맞는 전체 행을 스캔함. 10만건에서 100만건으로 증가하면 카운트 쿼리가 선형적으로 느려짐
+- `OFFSET` 페이지네이션의 뒤 페이지 (offset=90000 → 9만건 skip)
+
+**3. 캐시 적중률 30% 이하 시 문제**
+- (목표 ③과 연관) 캐시 miss 시마다 인덱스를 타지 못하는 쿼리가 DB에 직행. 인덱스 최적화가 선행되지 않으면 캐시 miss = Full Table Scan이 되어 DB 부하 급증
+
+**4. 데이터 정합성이 깨질 수 있는 시나리오**
+- **(a)** 관리자가 상품을 soft-delete한 직후, 캐시에 남아있는 목록에 삭제된 상품이 포함됨 (목표 ③과 교차)
+- **(b)** 좋아요 수 UPDATE와 목록 조회가 동시에 발생 시, 정렬 순서가 일시적으로 stale한 `like_count` 기준으로 반환됨 (dirty read 수준이지만, 목록에서는 허용 가능할 수 있음)
+
+**5. 가장 나중까지 미룰 수 있는 개선**
+- `OFFSET` → cursor-based 페이지네이션 전환. 현재 프론트가 page 기반이면 즉시 변경 불가. 인덱스만 추가해도 10만건 수준에서는 충분
+
+**6. 가장 먼저 손대야 할 위험 요소**
+- **인덱스 부재 자체**. 10만건에서 `ORDER BY like_count DESC` + `WHERE deleted_at IS NULL`은 Full Table Scan + filesort가 확정적. 이것이 해결되지 않으면 캐시를 추가해도 miss 시 DB가 버티지 못함
+
+---
+
+## 목표 ② 좋아요 수 정렬 구조 개선
+
+### 현재 상황
+
+| 항목 | AS-IS |
+|------|-------|
+| 조회 API 목적 | 상품 목록의 좋아요 순 정렬 (`LIKES_DESC`) |
+| 주요 조회 조건 | `ORDER BY like_count DESC` |
+| 사용한 테이블/데이터 | `product_read_model.like_count` (비정규화 필드, Read Model 테이블에 존재) |
+| 해당 테이블의 인덱스 | **`like_count`에 인덱스 없음** |
+| 캐시 적용 여부 및 위치 | 없음 |
+| 캐시 키 전략 | N/A |
+| 캐시 TTL 가정 | N/A |
+
+**핵심 발견: 비정규화는 이미 완료되어 있음**
+- `ProductReadModelEntity`에 `like_count` 컬럼이 존재 (`product_read_model` 테이블)
+- Read Model 생성 시 `likeCount = 0`으로 초기화
+- 좋아요 등록/취소 시 `ProductReadModelJpaRepository`의 JPQL로 원자적 증감:
+  ```sql
+  UPDATE ProductReadModelEntity e SET e.likeCount = e.likeCount + 1 WHERE e.id = :id
+  UPDATE ProductReadModelEntity e SET e.likeCount = e.likeCount - 1 WHERE e.id = :id AND e.likeCount > 0
+  ```
+- Cross-BC 흐름: `ProductLikeCommandFacade.createLike()` → 좋아요 저장 + `ProductLikeCountSyncer.increaseLikeCount()` → `ProductCommandFacade` → `ProductCommandService` → `ProductReadModelRepository` → JPQL UPDATE
+
+**동기화 처리도 이미 구현됨**:
+- 좋아요 생성 시: 같은 `@Transactional` 내에서 좋아요 INSERT + Read Model `like_count` INCREMENT 실행
+- 좋아요 삭제 시: 같은 `@Transactional` 내에서 좋아요 DELETE + Read Model `like_count` DECREMENT 실행
+- 상품 삭제 시: `ProductCommandFacade.deleteProduct()` → 좋아요 전체 삭제 (cleanup)
+
+### 설계 방향
+
+| 항목 | TO-BE |
+|------|-------|
+| 조회 API 목적 | 동일 |
+| 주요 조회 조건 | 동일 |
+| 사용한 테이블/데이터 | 동일 (이미 비정규화됨) |
+| 해당 테이블의 인덱스 | `like_count` 포함 복합 인덱스 추가 (목표 ①과 병합) |
+| 캐시 적용 여부 및 위치 | 목표 ③에서 처리 |
+| 캐시 키 전략 | N/A |
+| 캐시 TTL 가정 | N/A |
+
+**TO-BE에서 추가로 필요한 것**:
+- 비정규화 구조 자체는 완성. 남은 것은 **인덱스 추가** (목표 ①과 합류)
+- `EXPLAIN` 전후 비교를 위한 10만건 데이터 준비
+- 현재 `like_count`의 동기화 gap 시나리오 정리 (블로그용)
+
+### 구조적 리스크 분석
+
+**1. 설계가 성립하기 위해 반드시 참이어야 하는 전제 조건**
+- 좋아요 등록/취소와 `like_count` 증감이 **반드시 같은 트랜잭션** 안에서 실행되어야 함. 현재 `ProductLikeCommandFacade`가 `@Transactional`이므로 성립. 만약 이벤트 기반 비동기로 전환하면 이 전제가 깨짐
+- `likes` 테이블과 `products.like_count` 사이에 DB-level 제약(trigger 등)이 없으므로, **애플리케이션 레이어가 유일한 동기화 보장 수단**
+
+**2. 트래픽 10배 증가 시 가장 먼저 병목이 될 지점**
+- 좋아요 등록/취소의 `UPDATE products SET like_count = like_count + 1 WHERE id = ?`는 해당 row에 대한 **exclusive row lock**을 잡음. 특정 인기 상품에 좋아요가 몰리면(hotspot) 해당 row에 lock contention 발생
+- 현재 `@Transactional`이 Facade 레벨이므로, 좋아요 INSERT + 카운트 UPDATE + 상품 존재 검증까지 하나의 TX에 묶여 lock 유지 시간이 길어질 수 있음
+
+**3. 캐시 적중률 30% 이하 시 문제**
+- `like_count` 자체는 products 테이블 row에 있으므로 목록 조회 시 추가 JOIN 불필요 (이미 해결됨). 캐시 miss가 발생해도 인덱스만 타면 DB 부하는 제한적
+- 다만 인기 상품의 like_count가 빈번히 변경되면 캐시 무효화 빈도가 높아져 적중률 자체가 낮아지는 악순환 가능
+
+**4. 데이터 정합성이 깨질 수 있는 시나리오**
+- **(a) 애플리케이션 비정상 종료**: 좋아요 INSERT는 커밋되었으나 `like_count` UPDATE 전에 프로세스가 죽는 경우 — 현재 같은 TX이므로 둘 다 롤백되어 안전. 그러나 **TX 분리를 도입하면 발생 가능**
+- **(b) 수동 DB 조작**: DBA가 `likes` 테이블에서 직접 row를 삭제하면 `products.like_count`와 실제 `COUNT(*)` 불일치 발생. 보정 배치(reconciliation)가 없음
+- **(c) 상품 삭제 후 복원**: soft-delete된 상품을 `restore()`할 경우, 삭제 시 좋아요가 일괄 hard-delete(`deleteAllByTargetId`)되었으므로 복원 후 `like_count`가 실제 0이어야 하나, `like_count` 필드가 이전 값을 유지할 수 있음 (현재 restore 시 like_count 리셋 로직 미확인)
+
+**5. 가장 나중까지 미룰 수 있는 개선**
+- `like_count` 보정 배치 (reconciliation cron). 현재 동기 TX 보장이 되므로 정합성 문제 발생 확률이 매우 낮아 미룰 수 있음
+
+**6. 가장 먼저 손대야 할 위험 요소**
+- **hotspot 상품의 row lock contention**. 인기 상품에 동시 좋아요 100건이 몰리면 `UPDATE ... WHERE id = ?`의 InnoDB row lock이 직렬화됨. 현재는 별도 대응 없음 (Redis counter 버퍼링, 비동기 합산 등 미적용)
+
+---
+
+## 목표 ③ 캐시 적용
+
+> 이 절은 초기 캐시 설계 탐색 기록을 포함한다. 현재 구현의 최종 상태는 `2-Layer Cache(product:v1 / products:ids:v1)` + `상세 2분 / ID 리스트 3분 TTL` + `targeted write-through`이며, 상세 내용은 `05`, `06`, `07` 문서를 따른다.
+
+### 현재 상황
+
+| 항목 | AS-IS |
+|------|-------|
+| 조회 API 목적 | 상품 상세 (`GET /api/v1/products/{id}`), 상품 목록 (`GET /api/v1/products`) |
+| 주요 조회 조건 | 상세: PK 조회, 목록: brandId + sortType + page + size |
+| 사용한 테이블/데이터 | `products` + `brands` (LEFT JOIN) |
+| 해당 테이블의 인덱스 | PK만 존재 |
+| 캐시 적용 여부 및 위치 | **없음**. Spring Cache 미활성화. `@EnableCaching` 없음. `CacheManager` 빈 없음 |
+| 캐시 키 전략 | N/A |
+| 캐시 TTL 가정 | N/A |
+
+**Redis 인프라 현황**:
+- `modules/redis/` 모듈 존재, `spring-boot-starter-data-redis` 의존성 있음
+- `RedisConfig`에서 Lettuce 기반 master-replica 구성 완료
+- `RedisTemplate<String, String>` 빈 2개 (replica-preferred / master-only)
+- **그러나 실제 비즈니스 로직에서 Redis를 사용하는 곳이 없음**
+- 유일한 캐시는 `CaffeineCouponIssueDuplicateGuard` (로컬 인메모리, 쿠폰 전용)
+
+### 설계 방향
+
+| 항목 | TO-BE |
+|------|-------|
+| 조회 API 목적 | 동일 |
+| 주요 조회 조건 | 동일 |
+| 사용한 테이블/데이터 | 동일 |
+| 해당 테이블의 인덱스 | 목표 ①에서 추가 |
+| 캐시 적용 여부 및 위치 | **상품 상세**: Facade 레벨 (Product+Brand 조합). **상품 목록**: Service 레벨 (단일 도메인) |
+| 캐시 키 전략 | **상세**: `product:v1:{productId}`. **목록 ID 리스트**: `products:ids:v1:{brandId\|all}:{sortType}:{page}:{size}` |
+| 캐시 TTL | **상세**: 2분. **ID 리스트**: 3분 |
+| 구현 방식 | RedisTemplate 직접 사용 (캐시 흐름 명시적 제어) |
+
+#### 설계 결정 상세
+
+##### (1) 캐시 적용 레이어 — API별 도메인 조합 분석
+
+캐시 레이어는 "무엇을 캐싱하는가"에 따라 결정한다. 단일 도메인 데이터라면 Service, 여러 도메인을 조합한 결과라면 Facade에서 캐싱한다.
+
+| API | Facade 내부 호출 | 도메인 수 | 캐시 레이어 | 근거 |
+|-----|-----------------|:---------:|:----------:|------|
+| `getProduct(id)` 상품 상세 | `ProductQueryService.findActiveById()` + `BrandQueryService.getBrandById()` | 2개 | **Facade** | Product + Brand 이름을 조합하여 `ProductDetailOutDto` 생성. Service 레벨에서는 완성된 결과를 캐싱할 수 없음 |
+| `getProducts(...)` 상품 목록 | `ProductQueryService.searchProducts()` 만 호출 | 1개 | **Service** | QueryDSL LEFT JOIN으로 brand name 포함한 `ProductPageOutDto`를 한 번에 반환. Facade는 단순 위임만 수행 |
+
+##### (2) TTL 설정 근거
+
+**TTL 결정 시 판단 기준 (업계 공통, 우선순위순)**:
+
+| 순위 | 기준 | 설명 |
+|:---:|------|------|
+| 1 | **데이터 변경 빈도** | 얼마나 자주 바뀌는가? (가장 중요) |
+| 2 | **허용 가능한 staleness** | 비즈니스적으로 몇 분 전 데이터까지 사용자에게 보여줘도 괜찮은가? |
+| 3 | **쿼리 비용** | cache miss 시 DB 쿼리가 얼마나 무거운가? (무거울수록 긴 TTL) |
+| 4 | **트래픽 볼륨** | 트래픽이 높을수록 긴 TTL로 DB 보호 |
+| 5 | **메모리 제약** | 긴 TTL = 더 많은 키 = Redis 메모리 사용량 증가 |
+
+> 출처: AWS Database Caching Strategies, ByteByteGo, Redis 공식 블로그, 올리브영 테크블로그
+
+**업계 일반적 TTL 참고값**:
+
+| 데이터 유형 | 일반적 TTL | 출처 |
+|------------|-----------|------|
+| 상품 상세 (이름, 설명) | 5~15분 | AWS, ByteByteGo |
+| 상품 목록 / 검색 결과 | 5~15분 | Redis 공식, Medium |
+| 카테고리 / 브랜드 정보 | 30분~12시간 | Microsoft Dynamics 365 |
+| 재고 / 가격 | 0~5초 또는 캐시 안함 | Amazon 사례 |
+
+**현재 구현 TTL 결정**:
+
+| 대상 | TTL | 판단 근거 |
+|------|:---:|----------|
+| **상품 상세** | **2분** | 좋아요/재고 변경 시 상세 write-through가 자주 발생하므로 TTL은 짧게 두고, write-through 실패 시 최대 stale window만 제한 |
+| **ID 리스트** | **3분** | 정렬/필터 조합 키 수가 많아 빠른 메모리 회수가 필요하고, 일부 목록 stale은 trade-off로 허용 |
+
+> 현재 구현은 실측 후 상세 2분 / ID 리스트 3분으로 고정했다. `afterCommit` 이벤트 전환과 TTL 재조정은 후속 TODO다.
+
+##### (3) 무효화 전략 — Active Invalidation + Safety-Net TTL 병행
+
+업계 표준은 **둘 다 쓰는 것**(defense-in-depth)이다. AWS, Netflix EVCache, Meta TAO 모두 이 조합을 사용한다.
+
+| 역할 | 메커니즘 | 설명 |
+|------|---------|------|
+| **즉시 무효화** | 데이터 변경 시 `DEL key` | 상품 수정/삭제/좋아요 변경 시 해당 캐시 키를 즉시 삭제. 정합성 우선 |
+| **안전망 TTL** | 키 생성 시 TTL 설정 | evict 실패/누락 시 최대 staleness를 TTL로 보장. 조회가 적은 키의 메모리를 자동 해제 |
+
+**현재 구현의 캐시 갱신 트리거**:
+- **상품 상세 캐시** (`product:v1:{id}`): 생성/수정/좋아요/재고/브랜드명 변경 시 write-through, 삭제 시 evict
+- **ID 리스트 캐시** (`products:ids:v1:*`): 생성/삭제는 모든 정렬, 가격 변경은 `PRICE_ASC`만 targeted refresh
+- **좋아요 변경**: 상세만 write-through, ID 리스트는 TTL 자연 만료 허용
+
+> **왜 "delete"이지 "update"가 아닌가?** 캐시 값을 직접 갱신하면 두 개의 동시 쓰기가 race condition을 일으킬 수 있다. 삭제 후 다음 조회 시 DB에서 최신 데이터를 lazy load하는 것이 더 안전하다. (출처: AWS Cache-Aside Pattern, Redis 공식)
+
+##### (4) thundering herd 방어 — 현재 구현
+
+| 계층 | 전략 | 현재 상태 |
+|:---:|------|----------|
+| 1 | **TTL jitter** | 적용 |
+| 2 | **PER** | 적용 |
+| 3 | **LocalCacheLock + double-check** | 적용 |
+
+> 분산 락(`RedisCacheLock`)은 구현체로만 남아 있고, 현재 런타임 경로는 `LocalCacheLock`이 `@Primary`다.
+
+##### (5) 구현 방식 — RedisTemplate 직접 사용
+
+`@Cacheable` 대신 `RedisTemplate`을 직접 사용한다.
+
+| 판단 기준 | 결정 근거 |
+|----------|----------|
+| 캐시 흐름 가시성 | 캐시 저장/조회/삭제 시점이 코드에서 명시적으로 보여야 함 |
+| fallback 제어 | Redis 장애 시 `try-catch`로 DB fallback을 직접 구현해야 함. `@Cacheable`은 예외 전파 제어가 제한적 |
+| TTL 세밀한 제어 | API별로 다른 TTL(상세 2분, ID 리스트 3분) + jitter를 직접 적용 |
+| 과제 학습자료 권장 | "캐시가 언제 저장되고 언제 무효화되는지를 정확히 알아야 합니다" — RedisTemplate 실습 추천 |
+
+> 현재 구현은 `RedisTemplate<String, String>` + `ObjectMapper` 직렬화 조합을 사용한다.
+
+**캐시 미스 시 정상 동작 전략 (Cache-Aside + Fallback)**:
+- **일반 캐시 미스**: Cache-Aside 패턴 적용. 캐시에 없으면 DB 조회 → 결과를 캐시에 적재 → 응답 반환. 인덱스 최적화(목표 ①)가 선행되므로 DB 직접 조회 시에도 수용 가능한 응답 시간 보장
+- **Redis 장애 (연결 불가/타임아웃)**: Redis 호출을 `try-catch`로 감싸서 예외 발생 시 캐시를 skip하고 DB에서 직접 조회. Redis 장애가 서비스 장애로 전파되지 않도록 격리 (Redis는 성능 개선 수단이지 필수 의존성이 아님)
+
+### 구조적 리스크 분석
+
+**1. 설계가 성립하기 위해 반드시 참이어야 하는 전제 조건**
+- Redis 장애 시 fallback이 구현되어야 함. 캐시는 성능 최적화 수단이므로 Redis 없이도 서비스가 정상 동작해야 하며, 이를 위해 목표 ①의 인덱스 최적화가 반드시 선행되어야 함
+- 캐시에 저장하는 DTO가 JSON 직렬화/역직렬화가 가능해야 함. 현재 Java `record`는 Jackson으로 처리 가능하나, `BigDecimal`, `ZonedDateTime` 등의 직렬화 정밀도 보장 필요
+- 문자열 RedisTemplate + ObjectMapper 직렬화 조합이 안정적으로 동작해야 함
+
+**2. 트래픽 10배 증가 시 가장 먼저 병목이 될 지점**
+- **목록 캐시의 키 폭발 (key explosion)**. `brandId × sortType × page × size` 조합이 수천~수만 개가 될 수 있음. 예: 브랜드 100개 × 정렬 3종 × 페이지 500 = 15만 키. Redis 메모리와 eviction 정책이 문제가 됨
+- **cold-cache worst-case**: `brandId` 없는 `PRICE_ASC`는 1000만건에서 3.88초까지 상승하므로, steady-state hit rate 관리가 더 중요해짐
+
+**3. 캐시 적중률 30% 이하 시 문제**
+- **thundering herd (cache stampede)**: 인기 키의 TTL 만료 시 수백 요청이 동시에 DB로 몰림. 다만 인덱스 최적화(목표 ①)가 완료되어 있으므로, Full Table Scan이 아닌 인덱스 스캔으로 처리되어 DB가 버틸 수 있음. 인덱스가 없다면 즉시 connection pool 고갈
+- **목록 캐시는 태생적으로 적중률이 낮을 수 있음**: page 파라미터에 따라 키가 분산되고, 좋아요 변경마다 무효화되면 hit rate 30%도 어려울 수 있음. 상세 캐시는 상대적으로 hit rate가 높을 것
+
+**4. 데이터 정합성이 깨질 수 있는 시나리오**
+- **(a) 캐시 무효화 실패**: 상품 수정 TX는 커밋되었으나 Redis eviction 명령이 네트워크 오류로 실패. 이후 사용자가 stale 데이터를 TTL 만료까지 계속 보게 됨
+- **(b) 좋아요 → 캐시 무효화 순서 역전**: 좋아요 TX 커밋과 캐시 무효화 사이에 다른 요청이 DB에서 조회하여 캐시를 갱신하면, 직후 무효화가 실행되어 **오히려 최신 캐시가 삭제됨** (ABA problem)
+- **(c) 상세 캐시에 좋아요 수 포함**: `ProductDetailOutDto`에 `likeCount`가 있으므로 좋아요 변경마다 상세 캐시를 무효화해야 함. 누락 시 상세 페이지의 좋아요 수가 stale
+
+**5. 가장 나중까지 미룰 수 있는 개선**
+- **목록 캐시**. 키 조합 폭발, 빈번한 무효화, 낮은 hit rate 등 cost-benefit이 불리. 인덱스 최적화(목표 ①)만으로 10만건 수준에서는 DB 부하가 수용 가능할 수 있음. 상세 캐시만 먼저 적용해도 효과적
+
+**6. 가장 먼저 손대야 할 위험 요소**
+- **Redis 장애 시 fallback 전략 구현**. 캐시를 도입하는 순간 Redis가 새로운 의존성이 됨. fallback 없이 배포하면 Redis 다운 = 서비스 다운. `try-catch` 기반 graceful degradation을 캐시 적용과 동시에 구현해야 함
+
+---
+
+## 종합 교차 분석
+
+### 세 목표 간 의존 관계
+
+```
+① 인덱스 최적화 ←── 독립 (가장 먼저 수행 가능)
+     ↑
+② 좋아요 비정규화 ── 이미 완료. 인덱스만 추가하면 됨 (①과 병합)
+     ↑
+③ 캐시 적용 ←── ①②가 선행되어야 캐시 miss 시 안전
+```
+
+### 우선순위 제안
+
+| 순서 | 작업 | 이유 |
+|------|------|------|
+| 1 | ① + ② 병합: 인덱스 추가 + EXPLAIN 분석 | 비정규화는 이미 돼있으므로 인덱스만 추가. 캐시 miss의 안전망 역할 |
+| 2 | ③ 상세 캐시 | 키 설계가 단순하고 hit rate 높음 |
+| 3 | ③ 목록 캐시 | 키 폭발·무효화 복잡도가 높아 가장 리스크 큼 |
+
+### 체크리스트 대응 현황
+
+| 체크리스트 항목 | 설계 대응 |
+|---|---|
+| **[Index]** brandId 기반 검색 + 좋아요 순 정렬 처리 | 6가지 유즈케이스 매트릭스 분석 완료. 3종 복합 인덱스 후보 도출 |
+| **[Index]** 조회 필터·정렬 조건별 유즈케이스 분석 + 전후 성능비교 | EXPLAIN 분석 계획 수립 (AS-IS/TO-BE 6개 유즈케이스 비교) |
+| **[Structure]** 좋아요 수 조회 및 좋아요 순 정렬 가능 구조 | 이미 구현됨. `products.like_count` 비정규화 + `LIKES_DESC` 정렬. 인덱스 추가로 성능 개선 |
+| **[Structure]** 좋아요 적용/해제 시 동기화 | 이미 구현됨. 동일 TX 내 원자적 UPDATE (`like_count + 1` / `like_count - 1`) |
+| **[Cache]** Redis 캐시 + TTL/무효화 전략 | RedisTemplate 직접 사용. 상세(Facade, TTL 2분) + ID 리스트(Service, TTL 3분). targeted write-through + safety-net TTL |
+| **[Cache]** 캐시 미스 시 정상 동작 | Cache-Aside + Redis 장애 시 try-catch fallback to DB. TTL jitter + PER + LocalCacheLock 적용 |
+
+### 가장 큰 구조적 리스크 Top 3
+
+1. **캐시 무효화와 데이터 변경의 원자성 미보장**: 현재 아키텍처에서 `@Transactional` 커밋 후 Redis 무효화를 수행하면, 그 사이에 정합성 gap이 발생. `@TransactionalEventListener(phase = AFTER_COMMIT)` 패턴을 써도 Redis 호출 실패 시 복구 수단이 없음
+
+2. **목록 캐시의 키 폭발 + 좋아요 변경 시 대량 무효화**: 좋아요가 빈번한 서비스에서 `LIKES_DESC` 정렬의 모든 페이지 캐시를 무효화하는 것은 사실상 "캐시를 쓰지 않는 것"과 같아질 수 있음
+
+3. **인덱스 3벌 유지 비용 vs. 쿼리 성능 trade-off**: 정렬 타입 3종(LATEST, PRICE_ASC, LIKES_DESC)에 대해 각각 최적 인덱스를 만들면 INSERT/UPDATE 시 인덱스 유지 비용 증가. `like_count` UPDATE가 빈번하면 `(brand_id, deleted_at, like_count)` 인덱스의 재정렬 비용이 쓰기 성능을 악화시킬 수 있음
+
+---
+
+## 참고자료
+
+### 캐시 TTL 설정 근거
+
+| 출처 | 링크 |
+|------|------|
+| AWS - Database Caching Strategies Using Redis (Cache Validity) | https://docs.aws.amazon.com/whitepapers/latest/database-caching-strategies-using-redis/cache-validity.html |
+| AWS - ElastiCache Caching Strategies | https://docs.aws.amazon.com/AmazonElastiCache/latest/dg/Strategies.html |
+| Redis 공식 블로그 - Cache Optimization Strategies | https://redis.io/blog/guide-to-cache-optimization-strategies/ |
+| ByteByteGo - A Crash Course in Caching (Final Part) | https://blog.bytebytego.com/p/a-crash-course-in-caching-final-part |
+| ByteByteGo - A Guide to Top Caching Strategies | https://blog.bytebytego.com/p/a-guide-to-top-caching-strategies |
+| 올리브영 테크블로그 - 고성능 캐시 아키텍처 설계 | https://oliveyoung.tech/2024-12-10/present-promotion-multi-layer-cache/ |
+| 카카오페이 기술 블로그 - 분산 시스템에서 로컬 캐시 활용하기 | https://tech.kakaopay.com/post/local-caching-in-distributed-systems/ |
+
+### 캐시 무효화 전략 근거
+
+| 출처 | 링크 |
+|------|------|
+| Redis 공식 - Cache Invalidation | https://redis.io/glossary/cache-invalidation/ |
+| Redis 공식 블로그 - Three Ways to Maintain Cache Consistency | https://redis.io/blog/three-ways-to-maintain-cache-consistency/ |
+| AWS Builders Library - Caching Challenges and Strategies | https://aws.amazon.com/builders-library/caching-challenges-and-strategies/ |
+| Microsoft Azure - Cache-Aside Pattern | https://learn.microsoft.com/en-us/azure/architecture/patterns/cache-aside |
+| Inpa Dev - Redis 캐시 설계 전략 지침 총정리 | https://inpa.tistory.com/entry/REDIS-%F0%9F%93%9A-%EC%BA%90%EC%8B%9CCache-%EC%84%A4%EA%B3%84-%EC%A0%84%EB%9E%B5-%EC%A7%80%EC%B9%A8-%EC%B4%9D%EC%A0%95%EB%A6%AC |
+| daily.dev - Cache Invalidation vs. Expiration Best Practices | https://daily.dev/blog/cache-invalidation-vs-expiration-best-practices |
+| Toss Tech - Cache Traffic Tips | https://toss.tech/article/cache-traffic-tip |
+
+### 인덱스 및 쿼리 최적화
+
+| 출처 | 링크 |
+|------|------|
+| 쿼리 튜닝과 인덱스 최적화 (WikiDocs) | https://wikidocs.net/226253 |
+| 카카오 테크 - MySQL 방향별 인덱스 | https://tech.kakao.com/posts/351 |
+
+### Spring + Redis 구현
+
+| 출처 | 링크 |
+|------|------|
+| Spring 공식 - Caching | https://docs.spring.io/spring-boot/reference/io/caching.html |
+| Spring Data Redis - Redis Cache Reference | https://docs.spring.io/spring-data/redis/reference/redis/redis-cache.html |
+| Baeldung - Spring Data Redis Tutorial | https://www.baeldung.com/spring-data-redis-tutorial |
diff --git a/round5-docs/02-performance-improvement-plan.md b/round5-docs/02-performance-improvement-plan.md
new file mode 100644
index 000000000..f80a3b8a3
--- /dev/null
+++ b/round5-docs/02-performance-improvement-plan.md
@@ -0,0 +1,1020 @@
+# 성능 개선 구현 계획
+
+## Context
+
+상품 목록/상세 조회 API의 성능을 개선한다. 현재 상태:
+- `products` 테이블에 PK 외 인덱스 없음 → 10만건 이상에서 Full Table Scan + filesort
+- 상품 목록 쿼리가 `products LEFT JOIN brands`로 매번 JOIN 수행
+- Redis 캐시 미적용
+- 좋아요 수 비정규화(`like_count`)와 동기화는 이미 구현 완료
+
+**3가지 개선 축**:
+1. **Read Model** — 조회 전용 테이블(`product_read_model`)로 JOIN 제거
+2. **인덱스** — Read Model 테이블에 복합 인덱스 추가
+3. **캐시** — 상세/목록 API에 Redis Cache-Aside 적용
+
+**요구사항 체크리스트**:
+
+| # | 항목 | 대응 |
+|---|------|------|
+| 1 | [Index] brandId 기반 검색 + 좋아요 순 정렬 | Task 1: Read Model 인덱스 |
+| 2 | [Index] 유즈케이스별 인덱스 + 전후 성능비교 | Task 1: EXPLAIN AS-IS vs TO-BE |
+| 3 | [Structure] 좋아요 수 조회 + 정렬 | **이미 완료** (`products.like_count` + `LIKES_DESC` 정렬) |
+| 4 | [Structure] 좋아요 적용/해제 시 동기화 | **이미 완료** (동일 TX 내 원자적 UPDATE) |
+| 5 | [Cache] Redis 캐시 + TTL/무효화 전략 | Task 2~3: 상세 + 목록 캐시 |
+| 6 | [Cache] 캐시 미스 시 정상 동작 | Task 2: try-catch 장애 격리 |
+
+---
+
+## 비정규화 vs Read Model (Materialized View) 비교
+
+| 관점 | 비정규화 (`like_count`) | Read Model (`product_read_model`) |
+|------|----------------------|----------------------------------|
+| 구조 | 기존 테이블에 컬럼 추가 | 조회 전용 별도 테이블 |
+| 정합성 | 동일 TX 내 원자적 UPDATE → 즉시 일관성 | 동일 TX 내 동기 sync → 즉시 일관성 |
+| 조회 성능 | COUNT 서브쿼리/JOIN 제거 → 단일 컬럼 정렬 | JOIN 자체를 제거 → 단일 테이블 SELECT |
+| 인덱스 | write 테이블에 인덱스 추가 → 쓰기 부하 증가 | read 전용 테이블에 인덱스 → write 무영향 |
+| 확장성 | 비정규화 대상마다 컬럼 추가 필요 | 조회에 필요한 정보를 자유롭게 포함 가능 |
+| 복잡도 | 낮음 (컬럼 1개 + UPDATE SQL) | 중간 (테이블 + 동기화 로직) |
+
+**이 프로젝트의 선택**:
+- **비정규화**: 좋아요 수(`like_count`) — 단일 집계 값, 동기화가 단순하므로 기존 테이블에 컬럼 추가로 해결
+- **Read Model**: 브랜드명(`brand_name`) — 상품 목록/상세에서 매번 `LEFT JOIN brands` 수행. Read Model로 JOIN 제거 + 향후 추가 정보(카테고리명 등) 확장 용이
+
+---
+
+## 결정사항
+
+| 결정 | 선택 | 근거 |
+|------|------|------|
+| Read Model 방식 | **별도 `product_read_model` 테이블** | JOIN 제거 + write/read 분리 + 확장성 |
+| Read Model 동기화 | **동일 TX 내 동기 sync** | 도메인 이벤트 미도입 상태. 실시간 정합성 보장 |
+| 인덱스 위치 | **Read Model 테이블에만 적용** | write 테이블 쓰기 성능 유지. 사용자 조회는 read model 경유 |
+| 캐시 직렬화 | **StringRedisTemplate + ObjectMapper** | 기존 modules/redis 수정 불필요, 순수 JSON, 디버깅 용이 |
+| 상세 캐시 | **적용** (TTL 10분) | 요구사항에 '상품 상세 API에 캐시 적용' 명시 |
+| 목록 캐시 | **적용** (TTL 5분) | 요구사항에 '상품 목록 API에 캐시 적용' 명시 |
+| 목록 캐시 무효화 | **SCAN + TTL 병행** | Active invalidation + safety-net TTL |
+| 관리자 API 캐시 | **미적용** | 관리자는 실시간 데이터 필요 |
+
+---
+
+## 아키텍처 제약사항 (ArchUnit)
+
+`LayerDependencyArchTest`의 관련 규칙:
+
+| 규칙 | 영향 |
+|------|------|
+| Facade → Infrastructure 금지 | Facade에서 CacheManager 직접 사용 불가 |
+| Facade → Port **인터페이스** 금지 | Facade에서 CachePort 인터페이스도 사용 불가 |
+| Service → Service 금지 | Service 간 직접 호출 불가 |
+| **Service → Infrastructure** | **금지 규칙 없음** |
+
+**핵심**: Service → Infrastructure를 차단하는 ArchUnit 규칙이 없다. 따라서 Port 인터페이스 없이 Service에서 `ProductCacheManager`(infrastructure)를 직접 사용 가능하다.
+
+**캐시 배치 전략**:
+- **목록 캐시**: `ProductQueryService`에서 Cache-Aside 처리 (Service 내부, Facade 무관)
+- **상세 캐시**: `ProductQueryFacade`가 Service의 캐시 read/write 메서드를 호출하여 오케스트레이션 (상세 DTO = Product + BrandName 2개 도메인 조합이므로 Facade 레벨에서 처리)
+- **캐시 무효화**: `ProductCommandService`에서 mutation 후 eviction 처리
+
+---
+
+## Task 분해 및 실행 순서
+
+```
+Phase 1 (병렬):  [Task 1: Read Model + 인덱스] || [Task 2: 캐시 인프라]
+                  ↓ 파일 충돌 없음
+Phase 2:         [Task 3: 캐시 적용 + Read Model 쿼리 전환]
+                  ↓
+Phase 3:         [QA: 전체 테스트 검증 (ArchUnit 포함)]
+```
+
+**병렬 실행 근거 (Phase 1)**:
+- Task 1: `ProductReadModelEntity` + `ProductReadModelRepository` + DDL + EXPLAIN 테스트
+- Task 2: `ProductCacheManager` + 테스트
+- 파일 겹침 없음
+
+---
+
+## Task 1: Read Model + 인덱스
+
+**목표**: 조회 전용 `product_read_model` 테이블 생성 + 복합 인덱스 추가 + 동기화 + 쿼리 전환 + EXPLAIN 전후 비교
+**체크리스트 대응**: [Index] 1, 2번 + [Structure] Read Model
+
+### 1-1. Read Model 테이블 설계
+
+```sql
+CREATE TABLE product_read_model (
+    id              BIGINT PRIMARY KEY,          -- products.id와 동일 (FK 아님, 동기화로 관리)
+    brand_id        BIGINT       NOT NULL,
+    brand_name      VARCHAR(100),                -- brands.name 비정규화
+    name            VARCHAR(200) NOT NULL,       -- 상품명
+    price           DECIMAL(12,2) NOT NULL,
+    stock           BIGINT       NOT NULL,
+    description     VARCHAR(1000),               -- nullable
+    like_count      BIGINT       NOT NULL DEFAULT 0,
+    created_at      TIMESTAMP    NOT NULL,
+    updated_at      TIMESTAMP    NOT NULL,
+    deleted_at      TIMESTAMP,                   -- soft delete
+
+    -- 복합 인덱스: 카디널리티 높은 brand_id 선두 + deleted_at 필터 + 정렬
+    INDEX idx_read_brand_deleted_created   (brand_id, deleted_at, created_at),
+    INDEX idx_read_brand_deleted_price     (brand_id, deleted_at, price),
+    INDEX idx_read_brand_deleted_likecount (brand_id, deleted_at, like_count)
+);
+```
+
+> **인덱스를 Read Model에만 적용하는 이유**: `products` 원본 테이블은 쓰기 전용. 인덱스를 원본에 추가하면 INSERT/UPDATE 시 인덱스 유지 비용 발생. Read Model은 조회 전용이므로 인덱스를 자유롭게 추가 가능.
+
+### 1-2. 신규 파일 — Entity
+
+**`apps/.../catalog/product/infrastructure/entity/ProductReadModelEntity.java`**
+
+```java
+@Entity
+@Table(name = "product_read_model", indexes = {
+    @Index(name = "idx_read_brand_deleted_created", columnList = "brand_id, deleted_at, created_at"),
+    @Index(name = "idx_read_brand_deleted_price", columnList = "brand_id, deleted_at, price"),
+    @Index(name = "idx_read_brand_deleted_likecount", columnList = "brand_id, deleted_at, like_count")
+})
+public class ProductReadModelEntity {
+    @Id private Long id;                    // products.id (AUTO_INCREMENT 아님, 직접 설정)
+    private Long brandId;
+    private String brandName;               // 비정규화
+    private String name;
+    @Column(precision = 12, scale = 2)
+    private BigDecimal price;
+    private Long stock;
+    @Column(length = 1000)
+    private String description;
+    private Long likeCount;
+    private ZonedDateTime createdAt;
+    private ZonedDateTime updatedAt;
+    private ZonedDateTime deletedAt;
+
+    // of(Product, brandName): 정적 팩토리
+}
+```
+
+### 1-3. 신규 파일 — JPA Repository
+
+**`apps/.../catalog/product/infrastructure/jpa/ProductReadModelJpaRepository.java`**
+
+```java
+public interface ProductReadModelJpaRepository extends JpaRepository<ProductReadModelEntity, Long> {
+    @Modifying @Query("UPDATE ProductReadModelEntity e SET e.brandName = :brandName WHERE e.brandId = :brandId")
+    void updateBrandNameByBrandId(@Param("brandId") Long brandId, @Param("brandName") String brandName);
+
+    @Modifying @Query("UPDATE ProductReadModelEntity e SET e.likeCount = e.likeCount + 1 WHERE e.id = :id")
+    void increaseLikeCount(@Param("id") Long id);
+
+    @Modifying @Query("UPDATE ProductReadModelEntity e SET e.likeCount = e.likeCount - 1 WHERE e.id = :id AND e.likeCount > 0")
+    void decreaseLikeCount(@Param("id") Long id);
+}
+```
+
+### 1-4. 신규 파일 — Domain Repository Interface + Implementation
+
+**`apps/.../catalog/product/domain/repository/ProductReadModelRepository.java`**
+
+```java
+/**
+ * 상품 Read Model 동기화 리포지토리
+ * - write 경로에서 product_read_model 테이블을 동기화
+ * - 구현체: ProductReadModelRepositoryImpl (infrastructure/repository/)
+ */
+public interface ProductReadModelRepository {
+    void save(Product product, String brandName);
+    void delete(Long productId);
+    void increaseLikeCount(Long productId);
+    void decreaseLikeCount(Long productId);
+    void updateStock(Long productId, Long newStock);
+    void updateBrandName(Long brandId, String newBrandName);
+}
+```
+
+**`apps/.../catalog/product/infrastructure/repository/ProductReadModelRepositoryImpl.java`**
+
+```java
+@Repository
+@RequiredArgsConstructor
+public class ProductReadModelRepositoryImpl implements ProductReadModelRepository {
+    private final ProductReadModelJpaRepository jpaRepository;
+    // 각 메서드: Entity 변환 후 JPA 호출
+}
+```
+
+### 1-5. 수정 파일 — 동기화 배선
+
+**`ProductCommandService.java`** — `ProductReadModelRepository` 의존성 추가:
+
+| 메서드 | Read Model 동기화 |
+|--------|------------------|
+| `createProduct()` | Facade에서 brandName과 함께 `syncReadModel()` 호출 |
+| `updateProduct()` | Facade에서 brandName과 함께 `syncReadModel()` 호출 |
+| `deleteProduct()` | `readModelRepository.delete(productId)` |
+| `increaseLikeCount()` | `readModelRepository.increaseLikeCount(productId)` |
+| `decreaseLikeCount()` | `readModelRepository.decreaseLikeCount(productId)` |
+| `decreaseStock()` | `readModelRepository.updateStock(productId, newStock)` |
+
+```java
+// ProductCommandService — 신규 메서드
+// 7. Read Model 동기화 (상품 생성/수정 시 Facade에서 호출)
+@Transactional
+public void syncReadModel(Product product, String brandName) {
+    readModelRepository.save(product, brandName);
+}
+
+// 8. Read Model 브랜드명 일괄 동기화 (브랜드 수정 시 BrandCommandFacade에서 호출)
+@Transactional
+public void syncBrandNameInReadModel(Long brandId, String brandName) {
+    readModelRepository.updateBrandName(brandId, brandName);
+}
+```
+
+**`ProductCommandFacade.java`** — create/update 시 Read Model sync 추가:
+
+```java
+// 1. 상품 생성
+@Transactional
+public AdminProductDetailOutDto createProduct(AdminProductCreateInDto inDto) {
+    Brand brand = brandQueryService.getBrandById(inDto.brandId());
+    Product savedProduct = productCommandService.createProduct(inDto);
+    // Read Model 동기화
+    productCommandService.syncReadModel(savedProduct, brand.getName().value());
+    return AdminProductDetailOutDto.from(savedProduct, brand.getName().value());
+}
+
+// 2. 상품 수정
+@Transactional
+public AdminProductDetailOutDto updateProduct(Long id, AdminProductUpdateInDto inDto) {
+    Product product = productQueryService.findActiveById(id);
+    Product updatedProduct = productCommandService.updateProduct(product, inDto);
+    Brand brand = brandQueryService.getBrandById(updatedProduct.getBrandId());
+    // Read Model 동기화
+    productCommandService.syncReadModel(updatedProduct, brand.getName().value());
+    return AdminProductDetailOutDto.from(updatedProduct, brand.getName().value());
+}
+```
+
+**`BrandCommandFacade.java`** — 브랜드명 변경 시 Read Model 동기화:
+
+```java
+// 기존 의존성에 추가
+private final ProductCommandService productCommandService;  // 같은 BC (catalog)
+
+// updateBrand() 수정
+@Transactional
+public AdminBrandDetailOutDto updateBrand(Long id, AdminBrandUpdateInDto inDto) {
+    Brand brand = brandQueryService.getBrandById(id);
+    Brand updatedBrand = brandCommandService.updateBrand(brand, inDto);
+    // 상품 Read Model의 brand_name 일괄 동기화
+    productCommandService.syncBrandNameInReadModel(id, updatedBrand.getName().value());
+    return AdminBrandDetailOutDto.from(updatedBrand);
+}
+```
+
+### 1-6. 수정 파일 — 쿼리 전환
+
+**`ProductQuerydslRepository.java`** — `product_read_model` 테이블에서 조회하도록 변경:
+
+```java
+// AS-IS: products LEFT JOIN brands
+QProductEntity product = QProductEntity.productEntity;
+QBrandEntity brand = QBrandEntity.brandEntity;
+query.from(product).leftJoin(brand).on(brand.id.eq(product.brandId))
+
+// TO-BE: product_read_model (JOIN 없음)
+QProductReadModelEntity readModel = QProductReadModelEntity.productReadModelEntity;
+query.from(readModel)
+    .where(readModel.deletedAt.isNull())
+    .select(Projections.constructor(ProductOutDto.class,
+        readModel.id, readModel.brandId, readModel.brandName,
+        readModel.name, readModel.price, readModel.stock, readModel.likeCount))
+```
+
+- JOIN 제거 → 단일 테이블 SELECT
+- `brand.name` → `readModel.brandName` (비정규화 컬럼)
+- 관리자 쿼리(`searchAdminProducts`)도 동일하게 Read Model에서 조회
+
+### 1-7. EXPLAIN 전후 비교 테스트
+
+**`src/benchmark/.../infrastructure/ProductIndexPerformanceTest.java`**
+
+```java
+@SpringBootTest
+@ActiveProfiles("test")  // ddl-auto: create → Read Model 인덱스 자동 생성
+@Import({MySqlTestContainersConfig.class, RedisTestContainersConfig.class})
+class ProductIndexPerformanceTest {
+
+    @Autowired EntityManager entityManager;
+    @Autowired DatabaseCleanUp databaseCleanUp;
+
+    @AfterEach void tearDown() { databaseCleanUp.truncateAllTables(); }
+
+    // @BeforeEach: 50개 브랜드 + 100,000개 상품 + Read Model bulk insert
+}
+```
+
+**EXPLAIN 비교 절차**:
+
+```
+1. 데이터 준비
+   - brands: 50개
+   - products: 100,000개 (브랜드별 랜덤 분포, 가격/좋아요 랜덤)
+   - product_read_model: products + brand_name JOIN 결과 INSERT
+
+2. AS-IS 측정 (products LEFT JOIN brands, 인덱스 없음)
+   - DROP INDEX on products (PK 외 인덱스 없는 상태 확인)
+   - 6개 유즈케이스별 EXPLAIN ANALYZE 실행
+   - 결과 로깅: type, rows, Extra, actual time
+
+3. TO-BE 측정 (product_read_model, 인덱스 있음)
+   - Read Model 테이블에 @Table 인덱스 자동 생성됨
+   - 6개 유즈케이스별 EXPLAIN ANALYZE 실행 (JOIN 없는 단일 테이블 쿼리)
+   - 결과 로깅: type, rows, Extra, actual time
+
+4. 전후 비교 출력
+```
+
+**6개 유즈케이스**:
+
+| # | brandId | 정렬 | AS-IS (예상) | TO-BE (목표) |
+|---|:---:|---|---|---|
+| 1 | X | LATEST | Full Scan + JOIN + filesort | range scan, filesort 확인 필요 |
+| 2 | X | PRICE_ASC | Full Scan + JOIN + filesort | range scan, filesort 확인 필요 |
+| 3 | X | LIKES_DESC | Full Scan + JOIN + filesort | range scan, filesort 확인 필요 |
+| 4 | O | LATEST | Full Scan + JOIN + filesort | ref/range, filesort 없음 |
+| 5 | O | PRICE_ASC | Full Scan + JOIN + filesort | ref/range, filesort 없음 |
+| 6 | O | LIKES_DESC | Full Scan + JOIN + filesort | ref/range, filesort 없음 |
+
+> **no-brand 쿼리(#1,#2,#3)**: 인덱스 `(brand_id, deleted_at, sort_col)`에서 선두 컬럼 `brand_id`가 쿼리에 없으므로 인덱스 활용 불가 → 별도 2-column 인덱스 `(deleted_at, sort_col)` 필요.
+>
+> **컬럼 순서 원칙**: 카디널리티가 높은 `brand_id`(수십~수백)를 `deleted_at`(2값: NULL/timestamp)보다 앞에 배치. 두 컬럼 모두 equality 조건이므로 인덱스 탐색 결과는 동일하나, B-tree fan-out이 더 균등해져 인덱스 효율이 향상됨.
+
+### 1-8. DDL Migration 스크립트
+
+**`round5-docs/migration/V5__add_product_read_model.sql`**
+
+```sql
+-- Read Model 테이블 생성
+CREATE TABLE product_read_model (
+    id              BIGINT PRIMARY KEY,
+    brand_id        BIGINT       NOT NULL,
+    brand_name      VARCHAR(100),
+    name            VARCHAR(200) NOT NULL,
+    price           DECIMAL(12,2) NOT NULL,
+    stock           BIGINT       NOT NULL,
+    description     VARCHAR(1000),
+    like_count      BIGINT       NOT NULL DEFAULT 0,
+    created_at      TIMESTAMP    NOT NULL,
+    updated_at      TIMESTAMP    NOT NULL,
+    deleted_at      TIMESTAMP
+);
+
+-- 복합 인덱스 (카디널리티 높은 brand_id 선두)
+CREATE INDEX idx_read_brand_deleted_created
+    ON product_read_model (brand_id, deleted_at, created_at);
+CREATE INDEX idx_read_brand_deleted_price
+    ON product_read_model (brand_id, deleted_at, price);
+CREATE INDEX idx_read_brand_deleted_likecount
+    ON product_read_model (brand_id, deleted_at, like_count);
+
+-- 초기 데이터 마이그레이션
+INSERT INTO product_read_model (id, brand_id, brand_name, name, price, stock, description, like_count, created_at, updated_at, deleted_at)
+SELECT p.id, p.brand_id, b.name, p.name, p.price, p.stock, p.description, p.like_count, p.created_at, p.updated_at, p.deleted_at
+FROM products p
+LEFT JOIN brands b ON b.id = p.brand_id;
+```
+
+---
+
+## Task 2: 캐시 인프라 (ProductCacheManager + CacheLock)
+
+**목표**: Redis 캐시 유틸리티 컴포넌트 + 캐시 스탬피드 보호. Redis 장애 격리 + TTL jitter + PER + 로컬 락
+**체크리스트 대응**: [Cache] 5, 6번 기반
+
+### 2-1. 설계 결정
+
+| 결정 | 근거 |
+|------|------|
+| `RedisTemplate<String, String>` + `ObjectMapper` | 기존 modules/redis 수정 불필요, 순수 JSON |
+| 읽기: `defaultRedisTemplate` (REPLICA_PREFERRED) | master-replica 토폴로지 활용 |
+| 쓰기/삭제: `masterRedisTemplate` (`@Qualifier REDIS_TEMPLATE_MASTER`) | 데이터 정합성 |
+| TTL jitter: `TTL + random(0, TTL * 0.1)` | multi-key 동시 만료 방어 (thundering herd) |
+| 모든 메서드 try-catch | Redis 장애 → 서비스 장애 전파 차단 |
+| **Port 인터페이스 없음** | ArchUnit에 Service → Infrastructure 차단 규칙 없음. 과제 예시도 Service에서 RedisTemplate 직접 사용 |
+| **CacheLock 인터페이스** + `LocalCacheLock`(`@Primary`) | single-key 스탬피드 방어. 향후 분산 환경 전환 시 `RedisCacheLock`으로 교체 가능 |
+| **PER (Probabilistic Early Refresh)** | 캐시 만료 자체를 예방. TTL 임박 시 확률적으로 미리 갱신 |
+
+### 2-1-1. 캐시 스탬피드 보호 전략 (3계층)
+
+```
+[요청] → 캐시 조회
+           │
+     ┌─────▼──────────────┐
+     │ 히트 + TTL 여유      │──→ 바로 반환
+     │ 히트 + TTL 임박      │──→ 반환 + 비동기 갱신 ← (C: PER — 만료 예방)
+     │ 미스                │──→ key-level 로컬 락  ← (B: Local Mutex — 중복 조회 방지)
+     │ Redis 장애          │──→ DB 직행 (try-catch) ← 장애 격리
+     └────────────────────┘
+```
+
+| 계층 | 방어 대상 | 구현 |
+|------|-----------|------|
+| **TTL jitter** | multi-key 동시 만료 | TTL + random(0, TTL * 0.1) |
+| **PER** | single-key 만료 자체를 예방 | TTL 남은 시간 < threshold 시 확률적 백그라운드 갱신 |
+| **Local Mutex** | 만료 후 DB 중복 조회 (1개 key에 100명 동시 miss) | `CacheLock` interface + `LocalCacheLock`(`@Primary`) |
+| **try-catch** | Redis 장애 시 서비스 정상 동작 | 모든 캐시 메서드 예외 격리 → DB fallback |
+| **인덱스** | 최종 안전망 | DB 직행해도 Read Model 인덱스로 빠른 응답 |
+
+### 2-2. 신규 파일 — CacheLock (전략 패턴)
+
+**`apps/.../catalog/product/infrastructure/cache/CacheLock.java`** (인터페이스)
+
+```java
+/**
+ * 캐시 스탬피드 방지용 key-level 락
+ * - 같은 key에 대한 동시 DB 조회를 1회로 제한
+ * - 구현체: LocalCacheLock (@Primary), RedisCacheLock (분산 환경 전환용)
+ */
+public interface CacheLock {
+    <T> T executeWithLock(String key, Supplier<T> loader);
+}
+```
+
+**`apps/.../catalog/product/infrastructure/cache/LocalCacheLock.java`** (`@Primary`)
+
+```java
+/**
+ * JVM 로컬 key-level 캐시 락
+ * - ConcurrentHashMap + synchronized로 같은 key 요청만 직렬화
+ * - 다른 key 요청은 병렬 처리 (key 단위 세밀한 락)
+ * - 단일 서버 환경에서 사용. 분산 환경 전환 시 RedisCacheLock으로 @Primary 이동
+ */
+@Primary
+@Component
+public class LocalCacheLock implements CacheLock {
+    private final ConcurrentHashMap<String, Object> locks = new ConcurrentHashMap<>();
+
+    @Override
+    public <T> T executeWithLock(String key, Supplier<T> loader) {
+        Object lock = locks.computeIfAbsent(key, k -> new Object());
+        synchronized (lock) {
+            try {
+                return loader.get();
+            } finally {
+                locks.remove(key);
+            }
+        }
+    }
+}
+```
+
+**`apps/.../catalog/product/infrastructure/cache/RedisCacheLock.java`** (분산 환경 전환용)
+
+```java
+/**
+ * Redis SETNX 기반 분산 캐시 락
+ * - 분산 환경(multi-JVM)에서 사용
+ * - 현재는 대기 상태. 분산 환경 전환 시 @Primary 이동
+ */
+@Component
+public class RedisCacheLock implements CacheLock {
+    private final RedisTemplate<String, String> redisTemplate;
+
+    @Override
+    public <T> T executeWithLock(String key, Supplier<T> loader) {
+        String lockKey = key + ":lock";
+        Boolean acquired = redisTemplate.opsForValue()
+            .setIfAbsent(lockKey, "1", Duration.ofSeconds(5));
+        try {
+            if (Boolean.TRUE.equals(acquired)) {
+                return loader.get();
+            } else {
+                Thread.sleep(50);
+                return loader.get();  // 대기 후 재시도 (캐시 히트 기대)
+            }
+        } finally {
+            if (Boolean.TRUE.equals(acquired)) {
+                redisTemplate.delete(lockKey);
+            }
+        }
+    }
+}
+```
+
+### 2-3. 신규 파일 — ProductCacheManager
+
+**`apps/.../catalog/product/infrastructure/cache/ProductCacheManager.java`**
+
+```java
+/**
+ * 상품 캐시 관리자
+ * - Redis 기반 Cache-Aside 패턴 지원
+ * - 모든 메서드는 Redis 장애 시 예외를 격리하고 로깅만 수행
+ * - 읽기: replica-preferred, 쓰기/삭제: master
+ * - 캐시 스탬피드 보호: CacheLock + PER (Probabilistic Early Refresh)
+ *
+ * 1. get(key, Class) — 단순 타입 캐시 조회
+ * 2. get(key, TypeReference) — 제네릭 타입 캐시 조회
+ * 3. put(key, value, ttl) — 캐시 저장 (TTL jitter 포함)
+ * 4. evict(key) — 단일 키 삭제
+ * 5. evictByPattern(pattern) — SCAN 기반 패턴 삭제
+ * 6. getOrLoad(key, type, ttl, loader) — Cache-Aside + 스탬피드 보호 (CacheLock + double-check)
+ * 7. getOrLoadWithPer(key, type, ttl, loader) — getOrLoad + PER (TTL 임박 시 확률적 갱신)
+ */
+@Slf4j
+@Component
+public class ProductCacheManager {
+
+    private final RedisTemplate<String, String> readTemplate;   // default (replica-preferred)
+    private final RedisTemplate<String, String> writeTemplate;  // master
+    private final ObjectMapper objectMapper;
+    private final CacheLock cacheLock;
+
+    // --- 기본 메서드 ---
+    // get(): Redis 조회 실패 시 Optional.empty() 반환 → DB fallback
+    // put(): TTL에 jitter(0~10%) 추가하여 동시 만료 방지
+    // evict(): 단일 키 삭제. 실패 시 무시 → TTL 만료에 의존
+    // evictByPattern(): SCAN 기반 non-blocking 패턴 삭제
+
+    // --- 스탬피드 보호 메서드 ---
+
+    /**
+     * 6. Cache-Aside + 스탬피드 보호
+     * - CacheLock으로 같은 key에 대한 동시 DB 조회를 1회로 제한
+     * - double-check: 락 대기 후 캐시 재조회 (다른 스레드가 저장했을 수 있음)
+     */
+    public <T> T getOrLoad(String key, Class<T> type, Duration ttl, Supplier<T> loader) {
+        // 캐시 조회
+        Optional<T> cached = get(key, type);
+        if (cached.isPresent()) return cached.get();
+
+        // 캐시 미스 → 락 획득 후 DB 조회 (1회만)
+        return cacheLock.executeWithLock(key, () -> {
+            // double-check (대기 중 다른 스레드가 캐시 저장했을 수 있음)
+            Optional<T> doubleCheck = get(key, type);
+            if (doubleCheck.isPresent()) return doubleCheck.get();
+
+            // DB 조회 + 캐시 저장
+            T value = loader.get();
+            put(key, value, ttl);
+            return value;
+        });
+    }
+
+    /**
+     * 7. Cache-Aside + PER (Probabilistic Early Refresh) + 스탬피드 보호
+     * - TTL 잔여 시간이 threshold 이하이면 확률적으로 갱신 → 캐시 만료 자체를 예방
+     * - PER을 뚫고 만료 발생 시 CacheLock이 DB 중복 조회 방지
+     */
+    public <T> T getOrLoadWithPer(String key, Class<T> type, Duration ttl, Supplier<T> loader) {
+        Optional<T> cached = get(key, type);
+        if (cached.isPresent()) {
+            // PER: TTL 잔여 시간 확인 → 임박 시 확률적 갱신
+            if (shouldEarlyRefresh(key, ttl)) {
+                CompletableFuture.runAsync(() -> {
+                    T fresh = loader.get();
+                    put(key, fresh, ttl);
+                });
+            }
+            return cached.get();
+        }
+
+        // 캐시 미스 → 락 + double-check
+        return cacheLock.executeWithLock(key, () -> {
+            Optional<T> doubleCheck = get(key, type);
+            if (doubleCheck.isPresent()) return doubleCheck.get();
+
+            T value = loader.get();
+            put(key, value, ttl);
+            return value;
+        });
+    }
+
+    /**
+     * PER 판정: TTL의 마지막 20% 구간에서 확률적 갱신
+     * - 남은 시간이 적을수록 갱신 확률 증가
+     * - 예: TTL 10분, 남은 시간 1분 → 갱신 확률 ~50%
+     */
+    private boolean shouldEarlyRefresh(String key, Duration baseTtl) {
+        try {
+            Long remainMs = readTemplate.getExpire(key, TimeUnit.MILLISECONDS);
+            if (remainMs == null || remainMs <= 0) return false;
+
+            long thresholdMs = baseTtl.toMillis() / 5;  // 20% 구간
+            if (remainMs > thresholdMs) return false;
+
+            // 남은 시간이 적을수록 확률 증가 (선형)
+            double probability = 1.0 - ((double) remainMs / thresholdMs);
+            return ThreadLocalRandom.current().nextDouble() < probability;
+        } catch (Exception e) {
+            return false;
+        }
+    }
+}
+```
+
+### 2-4. 테스트
+
+**`src/test/.../infrastructure/cache/ProductCacheManagerTest.java`** (통합 테스트):
+1. put → get(Class): ProductDetailOutDto 직렬화/역직렬화
+2. put → get(TypeReference): ProductPageOutDto 제네릭 타입 검증
+3. BigDecimal 정밀도: `compareTo` 기준 검증
+4. evict: 저장 후 삭제 → Optional.empty()
+5. evictByPattern: `products:list:*` 패턴으로 여러 키 일괄 삭제
+6. TTL: base ± 10% 범위 검증
+7. 존재하지 않는 키 조회 → Optional.empty() (예외 없음)
+8. null description 필드 → 직렬화/역직렬화 정상 동작
+9. getOrLoad: 캐시 미스 → loader 1회 호출 + 캐시 저장
+10. getOrLoad: 캐시 히트 → loader 미호출
+
+**`src/test/.../infrastructure/cache/CacheStampedeTest.java`** (스탬피드 통합 테스트):
+1. **single-key 스탬피드**: 캐시 만료 후 100 concurrent 요청 → loader 호출 횟수 검증 (이상: 1회)
+2. **multi-key 스탬피드**: TTL jitter 적용된 100개 키 → 동시 만료 분산 검증
+3. **PER 동작**: TTL 임박 시 백그라운드 갱신 발생 → 후속 요청은 갱신된 캐시 히트
+4. **Redis 장애 시**: 모든 요청이 DB fallback → 서비스 정상 동작 (loader 매번 호출)
+
+**`src/test/.../infrastructure/cache/LocalCacheLockTest.java`** (단위 테스트):
+1. 같은 key 100 concurrent → loader 1회만 실행, 나머지는 대기 후 결과 공유
+2. 다른 key → 병렬 실행 (서로 블로킹하지 않음)
+3. loader 예외 → 락 정상 해제, 예외 전파
+
+---
+
+## Task 3: 캐시 적용 (상세 + 목록 + 무효화)
+
+**목표**: 상세/목록 API에 Cache-Aside 패턴 적용 + 모든 변경 시 캐시 무효화
+**체크리스트 대응**: [Cache] 5, 6번
+
+### 3-1. 상세 캐시 설계
+
+| 항목 | 값 |
+|------|---|
+| 캐시 키 | `product:{productId}` |
+| 캐시 레이어 | **Facade 오케스트레이션** (상세 DTO = Product + BrandName 2개 도메인 조합) |
+| 캐시 값 | `ProductDetailOutDto` (JSON) |
+| TTL | 10분 + jitter |
+| 무효화 | 상품 변경/삭제/좋아요 변경 시 `product:{id}` 삭제 + TTL 안전망 |
+
+**Facade 오케스트레이션 방식 (ArchUnit 준수)**:
+
+Facade는 캐시 인프라에 직접 접근할 수 없으므로, Service의 `getOrLoadProductDetail()` 메서드를 호출한다.
+Service 내부에서 `ProductCacheManager.getOrLoadWithPer()`를 사용하여 캐시 조회 + 스탬피드 보호 + PER을 일괄 처리:
+
+```java
+// ProductQueryService — 상세 캐시 메서드 (PER + 스탬피드 보호 포함)
+public ProductDetailOutDto getOrLoadProductDetail(Long productId, Supplier<ProductDetailOutDto> loader) {
+    String cacheKey = "product:" + productId;
+    return productCacheManager.getOrLoadWithPer(cacheKey, ProductDetailOutDto.class, Duration.ofMinutes(10), loader);
+}
+```
+
+```java
+// ProductQueryFacade — cache-aside 오케스트레이션
+@Transactional(readOnly = true)
+public ProductDetailOutDto getProduct(Long id) {
+    return productQueryService.getOrLoadProductDetail(id, () -> {
+        // 캐시 미스 시 DB 조회 (loader)
+        Product product = productQueryService.findActiveById(id);
+        Brand brand = brandQueryService.getBrandById(product.getBrandId());
+        return ProductDetailOutDto.from(product, brand.getName().value());
+    });
+}
+```
+
+- 캐시 히트 + TTL 여유: DB 호출 0회, 바로 반환
+- 캐시 히트 + TTL 임박: 반환 + 비동기 갱신 (PER)
+- 캐시 미스: 로컬 락으로 1명만 DB 조회, 나머지 대기 후 캐시 히트 (스탬피드 보호)
+- Redis 장애: try-catch → loader 실행 → DB 직행 (서비스 정상 동작)
+- Facade는 Service 메서드만 호출 → ArchUnit 통과
+
+### 3-2. 목록 캐시 설계
+
+| 항목 | 값 |
+|------|---|
+| 캐시 키 | `products:list:{brandId\|all}:{sortType\|LATEST}:{page}:{size}` |
+| 캐시 레이어 | **Service 내부** (단일 도메인 QueryPort 조회, Facade는 단순 위임) |
+| 캐시 값 | `ProductPageOutDto` (JSON) |
+| TTL | 5분 + jitter |
+| 무효화 | SCAN 기반 `products:list:*` 패턴 삭제 + TTL 안전망 |
+| 관리자 검색 | **캐시 미적용** |
+
+```java
+// ProductQueryService — searchProducts() 캐시 적용 (PER + 스탬피드 보호)
+@Transactional(readOnly = true)
+public ProductPageOutDto searchProducts(Long brandId, ProductSortType sortType, int page, int size) {
+    String cacheKey = buildListCacheKey(brandId, sortType, page, size);
+
+    return productCacheManager.getOrLoadWithPer(cacheKey, ProductPageOutDto.class, Duration.ofMinutes(5), () -> {
+        // 캐시 미스 시 DB 조회 (loader)
+        ProductSearchCriteria criteria = new ProductSearchCriteria(brandId, sortType);
+        PageResult<ProductOutDto> result = productQueryPort.searchProducts(criteria, new PageCriteria(page, size));
+        return ProductPageOutDto.from(result);
+    });
+}
+
+// searchAdminProducts(): 변경 없음 (캐시 미적용)
+
+private String buildListCacheKey(Long brandId, ProductSortType sortType, int page, int size) {
+    String brandKey = brandId != null ? String.valueOf(brandId) : "all";
+    String sortKey = sortType != null ? sortType.name() : "LATEST";
+    return String.format("products:list:%s:%s:%d:%d", brandKey, sortKey, page, size);
+}
+```
+
+### 3-3. 캐시 무효화
+
+**`ProductCommandService.java`** — `ProductCacheManager` 의존성 추가, 각 mutation 메서드 끝에 캐시 무효화:
+
+| 메서드 | 상세 캐시 | 목록 캐시 |
+|--------|:---------:|:---------:|
+| `createProduct()` | - (신규 상품) | `evictByPattern("products:list:*")` |
+| `updateProduct()` | Facade에서 처리 (아래 참고) | `evictByPattern("products:list:*")` |
+| `deleteProduct()` | Facade에서 처리 (아래 참고) | `evictByPattern("products:list:*")` |
+| `decreaseStock()` | `evict("product:" + id)` | `evictByPattern("products:list:*")` |
+| `increaseLikeCount()` | `evict("product:" + id)` | `evictByPattern("products:list:*")` |
+| `decreaseLikeCount()` | `evict("product:" + id)` | `evictByPattern("products:list:*")` |
+
+> `decreaseStock()` 포함 근거: `ProductOutDto`에 `stock` 필드 포함 → 재고 변경 시 캐시 무효화 필요
+
+**상세 캐시 무효화 — Facade에서 처리하는 메서드**:
+
+`updateProduct()`과 `deleteProduct()`은 Facade에서 `productId`를 알고 있으므로 Service의 evict 메서드 호출:
+
+```java
+// ProductCommandService — 캐시 evict 메서드 노출
+public void evictProductDetailCache(Long productId) {
+    productCacheManager.evict("product:" + productId);
+}
+
+// ProductCommandFacade.updateProduct()
+Product updatedProduct = productCommandService.updateProduct(product, inDto);
+productCommandService.syncReadModel(updatedProduct, brand.getName().value());
+productCommandService.evictProductDetailCache(id);  // 상세 캐시 무효화
+
+// ProductCommandFacade.deleteProduct()
+productCommandService.deleteProduct(product);
+productCommandService.evictProductDetailCache(id);  // 상세 캐시 무효화
+```
+
+### 3-4. 테스트
+
+**`ProductQueryServiceTest.java` 수정**:
+- `@Mock ProductCacheManager productCacheManager` 추가, 생성자 주입 업데이트
+- 신규: `[searchProducts()] 캐시 히트 → 캐시된 ProductPageOutDto 반환. QueryPort 미호출`
+- 신규: `[searchProducts()] 캐시 미스 → QueryPort 호출 후 캐시 저장. ProductPageOutDto 반환`
+- 신규: `[searchProducts()] brandId=null → 캐시 키에 "all" 사용`
+- 기존 `searchAdminProducts`: 캐시 미사용 verify
+- 신규: `[getProductDetailCache()] 캐시 히트 → Optional.of(dto) 반환`
+- 신규: `[getProductDetailCache()] 캐시 미스 → Optional.empty() 반환`
+
+**`ProductCommandServiceTest.java` 수정**:
+- `@Mock ProductCacheManager productCacheManager` + `@Mock ProductReadModelRepository readModelRepository` 추가
+- 기존 mutation 테스트에 캐시 eviction verify 추가
+- 신규: `[syncReadModel()] Read Model 저장 호출 검증`
+- 신규: `[syncBrandNameInReadModel()] 브랜드명 일괄 업데이트 호출 검증`
+
+**`ProductQueryFacadeTest.java` 수정**:
+- 신규: `[getProduct()] 캐시 히트 → 캐시된 ProductDetailOutDto 반환. Service/Brand DB 미호출`
+- 신규: `[getProduct()] 캐시 미스 → DB 조회 후 캐시 저장. ProductDetailOutDto 반환`
+
+**`ProductCommandFacadeTest.java` 수정**:
+- 신규: `[createProduct()] 상품 생성 후 Read Model 동기화 호출 검증`
+- 신규: `[updateProduct()] 상품 수정 후 Read Model 동기화 + 상세 캐시 무효화 호출 검증`
+- 신규: `[deleteProduct()] 상품 삭제 후 상세 캐시 무효화 호출 검증`
+
+**`BrandCommandFacadeTest.java` 수정**:
+- 신규: `[updateBrand()] 브랜드 수정 후 Read Model 브랜드명 동기화 호출 검증`
+
+**`ProductControllerE2ETest.java` 수정**:
+- `@Autowired RedisCleanUp redisCleanUp` + `@AfterEach`에 `redisCleanUp.truncateAll()` 추가
+- 신규: 상품 수정 후 상세 조회 → 수정된 데이터 반환 (상세 캐시 무효화 검증)
+- 신규: 상품 수정 후 목록 조회 → 수정된 데이터 반환 (목록 캐시 무효화 검증)
+
+---
+
+## 크로스-BC 캐시 + Read Model 무효화 흐름
+
+```
+ProductLikeCommandFacade.createLike() [engagement BC]
+  → ProductLikeCommandService.increaseLikeCount()
+    → ProductLikeCountSyncerImpl [ACL — engagement → catalog]
+      → ProductCommandFacade.increaseLikeCount() [catalog BC]
+        → ProductCommandService.increaseLikeCount()
+          → productCommandRepository.increaseLikeCount(productId)     ← products 원본
+          → readModelRepository.increaseLikeCount(productId)          ← Read Model 동기화
+          → productCacheManager.evict("product:" + productId)         ← 상세 캐시 무효화
+          → productCacheManager.evictByPattern("products:list:*")     ← 목록 캐시 무효화
+```
+
+기존 ACL 구조 그대로 활용. engagement BC 코드 수정 불필요.
+
+---
+
+## 핵심 파일 목록
+
+### 신규 생성
+| 파일 | Task | 설명 |
+|------|:----:|------|
+| `infrastructure/entity/ProductReadModelEntity.java` | 1 | Read Model JPA 엔티티 |
+| `infrastructure/jpa/ProductReadModelJpaRepository.java` | 1 | Read Model Spring Data JPA |
+| `domain/repository/ProductReadModelRepository.java` | 1 | Read Model 동기화 인터페이스 |
+| `infrastructure/repository/ProductReadModelRepositoryImpl.java` | 1 | Read Model 동기화 구현체 |
+| `infrastructure/cache/CacheLock.java` | 2 | 캐시 락 인터페이스 (전략 패턴) |
+| `infrastructure/cache/LocalCacheLock.java` | 2 | JVM 로컬 락 구현체 (`@Primary`) |
+| `infrastructure/cache/RedisCacheLock.java` | 2 | Redis 분산 락 구현체 (대기) |
+| `infrastructure/cache/ProductCacheManager.java` | 2 | Redis 캐시 관리자 (getOrLoad + PER) |
+| `test/.../infrastructure/cache/ProductCacheManagerTest.java` | 2 | 캐시 인프라 통합 테스트 |
+| `test/.../infrastructure/cache/CacheStampedeTest.java` | 2 | 캐시 스탬피드 통합 테스트 |
+| `test/.../infrastructure/cache/LocalCacheLockTest.java` | 2 | 로컬 락 단위 테스트 |
+| `test/.../infrastructure/ProductIndexPerformanceTest.java` | 1 | EXPLAIN 전후 비교 테스트 |
+| `round5-docs/migration/V5__add_product_read_model.sql` | 1 | DDL + 초기 데이터 migration |
+
+### 수정 대상
+| 파일 | Task | 변경 내용 |
+|------|:----:|----------|
+| `ProductCommandService.java` | 1, 3 | ReadModelRepository + CacheManager 의존성 추가, 동기화/무효화 |
+| `ProductCommandFacade.java` | 1, 3 | create/update 시 syncReadModel + evictDetailCache 호출 |
+| `ProductQueryService.java` | 3 | CacheManager 의존성 추가, 캐시 유틸 메서드 + 목록 cache-aside |
+| `ProductQueryFacade.java` | 3 | 상세 캐시 cache-aside 오케스트레이션 |
+| `ProductQuerydslRepository.java` | 1 | Read Model 테이블에서 조회 (JOIN 제거) |
+| `BrandCommandFacade.java` | 1 | 브랜드 수정 시 Read Model 브랜드명 동기화 |
+| `ProductQueryServiceTest.java` | 3 | Mock 주입 + 캐시 히트/미스 테스트 |
+| `ProductCommandServiceTest.java` | 1, 3 | Mock 주입 + Read Model 동기화 + 캐시 무효화 verify |
+| `ProductQueryFacadeTest.java` | 3 | 상세 캐시 히트/미스 테스트 |
+| `ProductCommandFacadeTest.java` | 1, 3 | Read Model 동기화 + 캐시 무효화 verify |
+| `BrandCommandFacadeTest.java` | 1 | 브랜드명 Read Model 동기화 verify |
+| `ProductControllerE2ETest.java` | 3 | RedisCleanUp + 캐시 무효화 E2E |
+
+---
+
+## 리스크 및 대응
+
+| # | 리스크 | 심각도 | 대응 |
+|---|--------|:------:|------|
+| 1 | **no-brand 쿼리 filesort** — 3-column 인덱스에서 `brand_id` skip 시 정렬 인덱스 미활용 | 중 | EXPLAIN 테스트로 확인 후, 필요 시 2-column 인덱스 추가 |
+| 2 | **Read Model 동기화 누락** — 새 mutation 추가 시 Read Model sync를 빠뜨리면 데이터 불일치 | 중 | 테스트에서 sync 호출 검증. 향후 도메인 이벤트 전환 시 자동화 가능 |
+| 3 | **TX 커밋 전 캐시 무효화** — evict 후 커밋 전 stale 데이터 재캐싱 가능 | 하 | TTL 5~10분이 safety net |
+| 4 | **브랜드명 변경 시 캐시 stale** — 목록 캐시에 `brandName` 포함되나 brand 변경 시 캐시 미무효화 | 하 | 브랜드 수정은 관리자 전용 극히 드문 연산. TTL 자연 만료로 충분 |
+| 5 | **BigDecimal 직렬화** | 하 | `JacksonConfig`에 `WRITE_BIGDECIMAL_AS_PLAIN` 존재. 테스트로 검증 |
+| 6 | **기존 테스트 깨짐** — Service/Facade 생성자에 의존성 추가 | 중 | 각 Task에서 기존 단위테스트 Mock 주입 반드시 업데이트 |
+| 7 | **Redis 장애 시 서비스 중단** | 중 | CacheManager 전 메서드 try-catch + Read Model 인덱스가 최종 안전망 |
+| 8 | **DDL 미반영** | 중 | DDL migration 스크립트 별도 제공 |
+| 9 | **Read Model 저장소 증가** — products 데이터 중복 저장 | 하 | 상품 데이터 크기 자체가 작음. 10만건 기준 수십 MB 수준 |
+| 10 | **single-key 캐시 스탬피드** — 인기 상품 캐시 만료 시 동시 DB 조회 | 중 | LocalCacheLock(double-check) + PER(만료 예방) 3계층 방어 |
+| 11 | **PER 비동기 갱신 실패** — CompletableFuture 내 예외 | 하 | 갱신 실패해도 기존 캐시 값 정상 반환. 다음 PER 또는 TTL 만료 시 재시도 |
+
+---
+
+## 성능 측정 계획
+
+### 측정 축
+
+| 축 | 값 | 설명 |
+|---|---|---|
+| **데이터 규모** | 10만 / 100만 / 1000만 | 인덱스 효과가 데이터 규모에 따라 어떻게 변하는지 |
+| **트래픽 유형** | 단일 쿼리 / 버스트 / 지속 부하 | 동시성에 따른 성능 변화 |
+| **측정 레벨** | DB 쿼리 / API | 인덱스 효과 vs 캐시 효과 분리 측정 |
+
+### 측정 매트릭스
+
+| | 10만 | 100만 | 1000만 |
+|---|:---:|:---:|:---:|
+| **단일 쿼리** (EXPLAIN + latency) | O | O | O |
+| **버스트** (N concurrent) | O | O | O |
+| **지속 부하** (N RPS × T초) | O | O | O |
+
+### 측정 레벨별 목적
+
+| 레벨 | 도구 | 측정 대상 | 측정 시점 |
+|------|------|-----------|-----------|
+| **DB 쿼리 레벨** | `@SpringBootTest` + `DataSource` + `ExecutorService` | EXPLAIN 결과, 순수 쿼리 latency, 인덱스 효과 | AS-IS → TO-BE (인덱스 적용 후) |
+| **API 레벨** | `@SpringBootTest` + `MockMvc` + `ExecutorService` | 전체 스택 latency, 캐시 히트/미스 효과, 스탬피드 보호 효과 | AS-IS (기준선) → TO-BE (캐시 적용 후) |
+
+### 병렬 실행
+
+DB 쿼리 레벨과 API 레벨 테스트를 별도 JVM fork에서 동시 실행하여 측정 시간을 단축한다.
+
+```bash
+# 병렬 실행 (DB + API 동시, maxParallelForks=2)
+./gradlew :apps:commerce-api:benchmarkTest --tests "*PerformanceTest*" -PtestMaxParallelForks=2
+```
+
+- `build.gradle.kts`에 `testMaxParallelForks` 프로퍼티 오버라이드 지원 (기본값=1)
+- 각 fork는 독립된 TestContainers(MySQL + Redis)를 기동하므로 격리 보장
+
+### 측정 Phase
+
+```
+Phase 1: AS-IS (현재 — 인덱스/캐시 없음) ✅ 완료
+  ├─ DB 쿼리 레벨: 6 UC × 3 데이터 규모 × 3 트래픽 유형
+  └─ API 레벨: 목록 6 UC + 상세 × 3 데이터 규모 × 3 트래픽 유형
+
+Phase 2: TO-BE 인덱스 적용 후 (Read Model + 복합 인덱스)
+  └─ DB 쿼리 레벨: 6 UC × 3 데이터 규모 × 3 트래픽 유형
+
+Phase 3: TO-BE 캐시 적용 후
+  └─ API 레벨: 상세/목록 API × 3 데이터 규모 × 3 트래픽 유형
+     + 캐시 스탬피드 시나리오 (single-key / multi-key)
+```
+
+### 트래픽 유형 파라미터
+
+| 유형 | 파라미터 | 측정 방법 |
+|------|---------|-----------|
+| **단일 쿼리** | 1 thread, 5회 반복 | warmup 3회 + 측정 5회 평균/min/max |
+| **버스트** | 100 concurrent threads, `CountDownLatch` 일제 시작 | p50/p95/p99 응답시간, 에러율 |
+| **지속 부하** | 20 RPS × 10초 (총 200 요청) | 평균/p50/p95/p99 응답시간, 실제 QPS |
+
+**목표 RPS 설정 근거**: 초기 50 RPS × 30초에서 TestContainers 환경의 커넥션 풀 고갈으로 측정이 불안정해져, 안정적 상대 비교가 가능한 20 RPS × 10초로 조정. 20 RPS는 피크 배수 3x · 피크 4시간 · 사용자당 10~15회 호출 기준으로 **DAU 5~8만 규모** 트래픽에 해당한다. 상세 역산은 `03-as-is-performance-measurement.md` 참고.
+
+### 캐시 스탬피드 측정 (Phase 3 — API 레벨)
+
+| 시나리오 | 설정 | 측정 지표 |
+|---------|------|-----------|
+| **single-key 스탬피드** | 인기 상품 1개 캐시 만료 → 100 concurrent 요청 | DB 쿼리 횟수 (목표: 1회), p99 응답시간 |
+| **multi-key 스탬피드** | 100개 캐시 동시 만료 → 각 키에 요청 | jitter 분산 효과, DB 순간 부하 |
+| **PER 효과** | TTL 임박 상태에서 지속 부하 | 캐시 만료 발생 횟수 (PER 미적용 vs 적용) |
+| **Redis 장애** | Redis 연결 차단 상태에서 요청 | 서비스 정상 동작 여부, DB fallback 응답시간 |
+
+### 측정 결과 저장 및 시각화
+
+| 파일 | 내용 |
+|------|------|
+| `round5-docs/03-as-is-performance-measurement.md` | AS-IS 측정 결과 (DB 쿼리 + API 레벨, 전 규모 완료) |
+| `round5-docs/04-to-be-index-measurement.md` | TO-BE 인덱스 적용 후 측정 결과 |
+| `round5-docs/05-to-be-cache-measurement.md` | TO-BE 캐시 적용 후 측정 결과 + 스탬피드 테스트 결과 |
+
+각 md 파일에 구조화된 테이블로 데이터를 저장한다.
+
+#### 시각화 (Chart.js HTML)
+
+각 Phase 측정 결과를 Chart.js 기반 HTML로 시각화한다. 브라우저에서 열어 인터랙티브하게 확인 가능.
+
+| 파일 | Phase | 내용 |
+|------|:-----:|------|
+| `round5-docs/as-is-performance-visualization.html` | Phase 1 | AS-IS 측정 결과 시각화 |
+| `round5-docs/to-be-index-visualization.html` | Phase 2 | TO-BE 인덱스 적용 후 시각화 |
+| `round5-docs/to-be-cache-visualization.html` | Phase 3 | TO-BE 캐시 적용 후 시각화 |
+| `round5-docs/06-performance-comparison.html` | 전체 | AS-IS vs TO-BE 전체 비교 그래프 |
+
+**시각화 구성 원칙**:
+
+1. **상단 UC 레퍼런스**: 쿼리 유형별 WHERE/ORDER BY 조건 + 트래픽 유형 정의 테이블을 상단에 배치하여, 차트 라벨만 보고도 실제 쿼리를 파악 가능
+2. **상단 KPI 카드**: 핵심 수치(단일 쿼리 응답시간, 에러율, QPS 등)를 6개 이내 카드로 요약
+3. **비교 관점(지표) 중심 섹션 구성**: 실험별(A-1, A-2, B-1, ...)이 아닌 비교 지표별로 섹션을 나눠 한눈에 비교
+   - 응답시간 비교 (DB vs API 좌우 배치)
+   - 에러율 비교 (동일 Y축 0~100%)
+   - 처리량 비교 (동일 Y축 + 목표선)
+   - DB vs API 오버헤드 비교
+4. **차트 라벨**: UC 코드(UC1, UC3) 대신 실제 쿼리 조건 명시 (예: `전체+최신순`, `브랜드+인기순`)
+5. **0 값 표시**: 값이 0인 바 위에 "0" 라벨을 표시하여 측정 누락이 아님을 명시 (Chart.js custom plugin)
+6. **비교 차트의 축 통일**: 에러율은 0~100%, QPS는 0~max+여유 등 동일 지표의 차트는 Y축 범위를 통일하여 직접 비교 가능
+
+**차트 유형**:
+- 데이터 규모별 응답시간 비교 (bar chart)
+- AS-IS vs TO-BE 비교 (grouped bar chart)
+- 캐시 히트/미스 비교 (line chart)
+- 동시 요청 수별 p50/p95/p99 분포 (line chart)
+- 스탬피드 보호 전/후 DB 쿼리 횟수 비교 (bar chart)
+
+### 테스트 파일 구조
+
+| 파일 | 레벨 | Phase |
+|------|------|-------|
+| `ProductIndexPerformanceTest.java` | DB 쿼리 | Phase 1 (AS-IS) + Phase 2 (TO-BE 인덱스) |
+| `ProductApiPerformanceTest.java` | API | Phase 1 (AS-IS 기준선) + Phase 3 (TO-BE 캐시) |
+| `CacheStampedeTest.java` | API | Phase 3 (스탬피드 시나리오) |
+
+---
+
+## 검증 방법
+
+```bash
+# 1. EXPLAIN 전후 비교 (AS-IS vs TO-BE)
+./gradlew :apps:commerce-api:benchmarkTest --tests "*ProductIndexPerformanceTest"
+
+# 2. 캐시 인프라 + 스탬피드 테스트
+./gradlew :apps:commerce-api:test --tests "*ProductCacheManagerTest"
+./gradlew :apps:commerce-api:test --tests "*LocalCacheLockTest"
+./gradlew :apps:commerce-api:test --tests "*CacheStampedeTest"
+
+# 3. 목록 캐시 + 상세 캐시
+./gradlew :apps:commerce-api:test --tests "*ProductQueryServiceTest"
+./gradlew :apps:commerce-api:test --tests "*ProductQueryFacadeTest"
+
+# 4. 캐시 무효화 + Read Model 동기화
+./gradlew :apps:commerce-api:test --tests "*ProductCommandServiceTest"
+./gradlew :apps:commerce-api:test --tests "*ProductCommandFacadeTest"
+./gradlew :apps:commerce-api:test --tests "*BrandCommandFacadeTest"
+
+# 5. E2E 테스트
+./gradlew :apps:commerce-api:test --tests "*ProductControllerE2ETest"
+
+# 6. 성능 측정 (API 레벨)
+./gradlew :apps:commerce-api:benchmarkTest --tests "*ProductApiPerformanceTest"
+
+# 7. 전체 빌드 (ArchUnit 포함)
+./gradlew :apps:commerce-api:test
+```
diff --git a/round5-docs/03-as-is-performance-measurement.md b/round5-docs/03-as-is-performance-measurement.md
new file mode 100644
index 000000000..2bc345349
--- /dev/null
+++ b/round5-docs/03-as-is-performance-measurement.md
@@ -0,0 +1,403 @@
+# AS-IS 성능 측정 결과
+
+## 측정 환경
+
+| 항목 | 값 |
+|------|---|
+| DB | MySQL 8.0 (TestContainers) |
+| 데이터 규모 | 10만 / 100만 / 1000만 |
+| 브랜드 | 50개 (균등 분포) |
+| 상품 상태 | 전부 활성 (deleted_at IS NULL) |
+| 인덱스 | PK만 존재 (products.id, brands.id) |
+| 쿼리 패턴 | `products LEFT JOIN brands` |
+| Connection Pool | HikariCP (기본 10개) |
+
+## 측정 레벨
+
+| 레벨 | 측정 대상 | 테스트 클래스 | 비교 목적 |
+|------|----------|-------------|----------|
+| **DB 쿼리** | 순수 SQL 실행 (JDBC 직접 호출) | `ProductIndexPerformanceTest` | 인덱스 효과 비교 |
+| **API** | Controller → Facade → Service → Repository → DB (MockMvc) | `ProductApiPerformanceTest` | 캐시 효과 비교 |
+
+## 트래픽 유형
+
+| 유형 | 파라미터 | 설명 |
+|------|---------|------|
+| **단일 쿼리** | 1 thread, warmup 3회 + 측정 5회 | EXPLAIN + 순수 쿼리/API 실행시간 |
+| **버스트** | 100 concurrent threads, CountDownLatch 동시 시작 | 동시 요청 폭주 시나리오 |
+| **지속 부하** | 20 RPS × 10초 = 200 요청 | 일정 트래픽 유지 시나리오 |
+
+### 목표 RPS 설정 근거
+
+**20 RPS로 설정한 이유:**
+
+초기 설계 시 50 RPS × 30초로 설정했으나, TestContainers 환경(Docker 컨테이너 기반 MySQL, HikariCP 기본 10개)에서 100만건 이상 규모 테스트 시 커넥션 풀 고갈과 타임아웃이 과도하게 발생하여 **측정 자체가 불안정**해졌다. AS-IS vs TO-BE **상대 비교**가 핵심 목적이므로, 동일 조건에서 안정적으로 결과를 수집할 수 있는 20 RPS × 10초로 조정했다.
+
+**20 RPS가 커버하는 트래픽 규모 (역산):**
+
+| 가정 | 값 | 근거 |
+|------|---|------|
+| 피크 RPS | 20 req/s | 측정 목표치 |
+| 피크 시간대 | 4시간/일 | 이커머스 피크: 점심 12~14시, 저녁 20~22시 |
+| 피크 배수 | 3배 | 일반적 웹서비스 피크 대 평균 비율 |
+| 비피크 RPS | ~6.7 req/s | 20 / 3 |
+| **일일 총 요청** | **~77만 건** | 피크 288K + 비피크 482K |
+| 사용자당 API 호출 | 10~15회/세션 | 목록 조회 5~10회 + 상세 조회 3~5회 |
+| **예상 DAU** | **약 5~8만** | 77만 / 10~15 |
+
+즉, 20 RPS를 안정적으로 처리할 수 있다면 **피크 시간대 기준 DAU 5~8만 규모**의 이커머스 상품 조회 트래픽을 감당할 수 있다. 단, AS-IS 상태에서는 100만건 이상에서 20 RPS조차 달성하지 못하므로(실제 QPS 0.3~5.9), 인덱스와 캐시 적용이 필수적이다.
+
+## 병렬 실행
+
+DB 쿼리 레벨과 API 레벨 테스트는 별도 JVM fork에서 병렬 실행하여 측정 시간을 단축한다.
+
+```bash
+# 기본 실행 (순차, maxParallelForks=1)
+./gradlew :apps:commerce-api:benchmarkTest --tests "*PerformanceTest*"
+
+# 병렬 실행 (DB + API 동시, maxParallelForks=2)
+./gradlew :apps:commerce-api:benchmarkTest --tests "*PerformanceTest*" -PtestMaxParallelForks=2
+```
+
+- 각 fork는 독립된 TestContainers(MySQL + Redis)를 기동하므로 격리 보장
+- `maxParallelForks=2`로 제한: 6개 전체 병렬은 리소스 경합으로 측정 신뢰도 저하
+
+## 데이터 분포
+
+| 항목 | 10만건 | 100만건 | 1000만건 |
+|------|:---:|:---:|:---:|
+| 전체/활성 상품 | 100,000 | 1,000,000 | 10,000,000 |
+| 브랜드당 상품 수 | ~2,000 | ~20,000 | ~200,000 |
+| 가격 범위 | 1,000 ~ 100,000 | 1,000 ~ 100,000 | 1,000 ~ 100,000 |
+| 좋아요 범위 | 0 ~ 10,000 | 0 ~ 10,000 | 0 ~ 10,000 |
+| 삽입 시간 (ms) | 3,228 | 26,129 | 258,582 |
+
+각 상품은 `brand_id`(random 1~50), `price`(random 1K~100K), `like_count`(random 0~10K), `created_at`(random 0~365일 전)이 모두 랜덤하게 생성된다. 동일한 값의 행이 없으므로 정렬·필터링 비용이 실서비스에 가깝다.
+
+## 현재 인덱스
+
+```
+[products]
+  Key_name     Column_name    Non_unique
+  PRIMARY      id             0
+```
+
+products 테이블에 PK 외 인덱스가 없다. 모든 조회가 Full Table Scan.
+
+---
+
+# A. DB 쿼리 레벨
+
+## A-1. 단일 쿼리 측정 (EXPLAIN + 실행시간)
+
+### 공통 EXPLAIN 결과
+
+모든 데이터 규모에서 동일:
+- `products` 테이블: **type=ALL** (Full Table Scan), **key=null**, Extra=**Using where; Using filesort**
+- `brands` 테이블: brandId 없으면 `eq_ref`, 있으면 `const` (PK lookup)
+
+### 데이터 조회 쿼리 (SELECT + LEFT JOIN + ORDER BY + LIMIT 20)
+
+```sql
+-- UC1/2/4/5 공통 패턴 (LATEST, PRICE_ASC)
+SELECT p.id, p.brand_id, b.name, p.name, p.price, p.stock
+FROM products p LEFT JOIN brands b ON b.id = p.brand_id
+WHERE p.deleted_at IS NULL [AND p.brand_id = ?]
+ORDER BY {sort_column}
+LIMIT 20
+
+-- UC3/6 LIKES_DESC 패턴 (비정규화 전 — LEFT JOIN likes + GROUP BY + COUNT)
+SELECT p.id, p.brand_id, b.name AS brand_name, p.name, p.price, p.stock, COUNT(l.id) AS like_count
+FROM products p LEFT JOIN brands b ON b.id = p.brand_id
+LEFT JOIN likes l ON l.target_type = 'PRODUCT' AND l.target_id = p.id
+WHERE p.deleted_at IS NULL [AND p.brand_id = ?]
+GROUP BY p.id
+ORDER BY like_count DESC
+LIMIT 20
+```
+
+| UC | 조건 | 정렬 | 10만 avg (ms) | 100만 avg (ms) | 1000만 avg (ms) | 증가율 10만→100만 (배) | 증가율 100만→1000만 (배) |
+|----|------|------|:---:|:---:|:---:|:---:|:---:|
+| 1 | brandId=X | LATEST | **27.68** | **585.45** | **3,897.22** | 21.1 | 6.7 |
+| 2 | brandId=X | PRICE_ASC | **33.44** | **560.41** | **4,184.09** | 16.8 | 7.5 |
+| 3 | brandId=X | LIKES_DESC | **25.69** | **526.67** | **3,614.20** | 20.5 | 6.9 |
+| 4 | brandId=1 | LATEST | **21.88** | **422.82** | **3,782.83** | 19.3 | 8.9 |
+| 5 | brandId=1 | PRICE_ASC | **22.11** | **408.43** | **3,489.15** | 18.5 | 8.5 |
+| 6 | brandId=1 | LIKES_DESC | **20.80** | **429.17** | **3,961.33** | 20.6 | 9.2 |
+
+### COUNT 쿼리
+
+```sql
+SELECT COUNT(*) FROM products WHERE deleted_at IS NULL [AND brand_id = ?]
+```
+
+| 조건 | 10만 avg (ms) | 100만 avg (ms) | 1000만 avg (ms) | 증가율 10만→100만 (배) | 증가율 100만→1000만 (배) |
+|------|:---:|:---:|:---:|:---:|:---:|
+| brandId=X (전체) | **10.59** | **279.32** | **2,147.34** | 26.4 | 7.7 |
+| brandId=1 | **11.88** | **314.32** | **2,323.93** | 26.5 | 7.4 |
+
+---
+
+## A-2. 버스트 측정 (100 concurrent)
+
+100개 스레드가 CountDownLatch로 동시 시작. Connection Pool(10개) 경쟁 포함.
+
+### 10만건
+
+| UC | 완료/전체 | 에러 (건) | avg (ms) | p50 (ms) | p95 (ms) | p99 (ms) | max (ms) |
+|----|:---:|:---:|:---:|:---:|:---:|:---:|:---:|
+| UC1: brandId=X, LATEST | 100/100 | 0 | 433 | 410 | 835 | 849 | 875 |
+| UC3: brandId=X, LIKES_DESC | 100/100 | 0 | 494 | 478 | 793 | 801 | 802 |
+| UC4: brandId=1, LATEST | 100/100 | 0 | 365 | 369 | 625 | 642 | 647 |
+
+- 전체 요청 성공. 쿼리 자체가 20~30ms이므로 10개 커넥션으로 100건을 ~900ms 내에 처리.
+- p95가 600~800ms대: 커넥션 대기 시간이 지배적.
+
+### 100만건
+
+| UC | 완료/전체 | 에러 (건) | avg (ms) | p50 (ms) | p95 (ms) | p99 (ms) | max (ms) |
+|----|:---:|:---:|:---:|:---:|:---:|:---:|:---:|
+| UC1: brandId=X, LATEST | **29/100** | **71** | 2,793 | 2,893 | 4,306 | 4,387 | 4,387 |
+| UC3: brandId=X, LIKES_DESC | **30/100** | **70** | 2,710 | 2,782 | 4,065 | 4,078 | 4,078 |
+| UC4: brandId=1, LATEST | **30/100** | **70** | 2,407 | 2,332 | 3,717 | 3,807 | 3,807 |
+
+- **70~71% 요청 실패** (HikariCP connectionTimeout)
+- 쿼리 1건에 500ms+ → 10개 커넥션으로 100건 처리하려면 ~5초 필요
+- 커넥션 대기 중 타임아웃 발생 → **서비스 장애 수준**
+
+### 1000만건
+
+| UC | 완료/전체 | 에러 (건) | avg (ms) | p50 (ms) | p95 (ms) | p99 (ms) | max (ms) |
+|----|:---:|:---:|:---:|:---:|:---:|:---:|:---:|
+| UC1: brandId=X, LATEST | **10/100** | **90** | 12,021 | 12,020 | 12,389 | 12,389 | 12,389 |
+| UC3: brandId=X, LIKES_DESC | **10/100** | **90** | 14,824 | 14,762 | 15,146 | 15,146 | 15,146 |
+| UC4: brandId=1, LATEST | **10/100** | **90** | 10,591 | 10,605 | 10,972 | 10,972 | 10,972 |
+
+- **90% 요청 실패**: 커넥션 풀 10개로 쿼리당 3.5~4초 → 10건만 처리 가능
+- 성공한 10건조차 avg 10~14초: 사용자 경험 불가능한 수준
+- 완전한 서비스 불능 상태
+
+---
+
+## A-3. 지속 부하 측정 (20 RPS × 10초)
+
+200건의 요청을 50ms 간격으로 제출. 실제 처리량(QPS)과 응답시간 분포 측정.
+
+### 10만건
+
+| UC | 완료/전체 | 에러 (건) | 실제 QPS (건/초) | avg (ms) | p50 (ms) | p95 (ms) | p99 (ms) |
+|----|:---:|:---:|:---:|:---:|:---:|:---:|:---:|
+| UC1: brandId=X, LATEST | 200/200 | 0 | **20.0** | 30 | 28 | 39 | 45 |
+| UC3: brandId=X, LIKES_DESC | 200/200 | 0 | **20.0** | 32 | 26 | 42 | 179 |
+| UC4: brandId=1, LATEST | 200/200 | 0 | **20.0** | 22 | 21 | 28 | 31 |
+
+- 20 RPS 목표를 완벽하게 달성. 쿼리가 20~30ms이므로 여유 있음.
+
+### 100만건
+
+| UC | 완료/전체 | 에러 (건) | 실제 QPS (건/초) | avg (ms) | p50 (ms) | p95 (ms) | p99 (ms) |
+|----|:---:|:---:|:---:|:---:|:---:|:---:|:---:|
+| UC1: brandId=X, LATEST | **110/200** | **90** | **5.8** | 3,428 | 3,910 | 4,816 | 4,972 |
+| UC3: brandId=X, LIKES_DESC | **155/200** | **45** | **9.9** | 2,424 | 2,659 | 3,974 | 4,138 |
+| UC4: brandId=1, LATEST | **158/200** | **42** | **9.9** | 2,446 | 2,700 | 3,952 | 3,979 |
+
+- **20 RPS 목표 미달성**: 실제 QPS 5.8~9.9 (목표의 29~50%)
+- **23~45% 요청 실패**: 커넥션 타임아웃
+- **20 RPS도 감당 불가** → 인덱스 없이는 서비스 운영 불가능
+
+### 1000만건
+
+| UC | 완료/전체 | 에러 (건) | 실제 QPS (건/초) | avg (ms) | p50 (ms) | p95 (ms) | p99 (ms) |
+|----|:---:|:---:|:---:|:---:|:---:|:---:|:---:|
+| UC1: brandId=X, LATEST | **20/200** | **180** | **0.6** | 15,273 | 13,969 | 18,156 | 18,170 |
+| UC3: brandId=X, LIKES_DESC | **20/200** | **180** | **0.8** | 12,011 | 11,715 | 13,674 | 13,762 |
+| UC4: brandId=1, LATEST | **20/200** | **180** | **0.8** | 12,471 | 10,874 | 16,677 | 16,918 |
+
+- **90% 요청 실패**: 200건 중 180건 타임아웃
+- **실제 QPS 0.6~0.8**: 목표 20 RPS의 **3~4%**에 불과
+- **서비스 완전 불능**: 20 RPS조차 전혀 감당 불가
+
+---
+
+# B. API 레벨
+
+## B-1. 단일 API 요청 (MockMvc)
+
+### 목록 API (`GET /api/v1/products`)
+
+| UC | 조건 | 정렬 | 10만 avg (ms) | 100만 avg (ms) | 1000만 avg (ms) | 증가율 10만→100만 (배) | 증가율 100만→1000만 (배) |
+|----|------|------|:---:|:---:|:---:|:---:|:---:|
+| 1 | brandId=X | LATEST | **60.18** | **516.31** | **6,174.44** | 8.6 | 12.0 |
+| 2 | brandId=X | PRICE_ASC | **59.55** | **497.88** | **6,522.14** | 8.4 | 13.1 |
+| 3 | brandId=X | LIKES_DESC | **51.51** | **473.23** | **6,663.48** | 9.2 | 14.1 |
+| 4 | brandId=1 | LATEST | **49.52** | **502.12** | **6,643.62** | 10.1 | 13.2 |
+| 5 | brandId=1 | PRICE_ASC | **48.82** | **463.31** | **9,901.90** | 9.5 | 21.4 |
+| 6 | brandId=1 | LIKES_DESC | **48.07** | **482.24** | **11,604.48** | 10.0 | 24.1 |
+
+### 상세 API (`GET /api/v1/products/{id}`)
+
+| UC | 10만 avg (ms) | 100만 avg (ms) | 1000만 avg (ms) | 증가율 10만→100만 (배) | 증가율 100만→1000만 (배) |
+|----|:---:|:---:|:---:|:---:|:---:|
+| 상세: productId=1 | **4.58** | **11.41** | **18.27** | 2.5 | 1.6 |
+
+- 상세 API는 PK lookup이므로 데이터 규모에 거의 비례하지 않음 (O(1))
+- 목록 API 대비 **30~600배** 빠름 → 캐시 적용 시 효과가 극대화되는 영역은 **목록 API**
+
+---
+
+## B-2. 버스트 측정 (100 concurrent)
+
+### 10만건
+
+| UC | 완료/전체 | 에러 (건) | avg (ms) | p50 (ms) | p95 (ms) | p99 (ms) | max (ms) |
+|----|:---:|:---:|:---:|:---:|:---:|:---:|:---:|
+| 목록 UC1: brandId=X, LATEST | 100/100 | 0 | 726 | 712 | 1,335 | 1,375 | 1,378 |
+| 목록 UC3: brandId=X, LIKES_DESC | 100/100 | 0 | 786 | 785 | 1,357 | 1,379 | 1,397 |
+| 목록 UC4: brandId=1, LATEST | 100/100 | 0 | 795 | 763 | 1,410 | 1,436 | 1,438 |
+| 상세: productId=1 | 100/100 | 0 | 72 | 71 | 127 | 127 | 129 |
+
+- 목록: 전체 성공이지만 p95가 1.3~1.4초 — Spring 스택 오버헤드로 DB 쿼리 레벨 대비 ~2배
+- 상세: avg 72ms — PK lookup + Spring 오버헤드
+
+### 100만건
+
+| UC | 완료/전체 | 에러 (건) | avg (ms) | p50 (ms) | p95 (ms) | p99 (ms) | max (ms) |
+|----|:---:|:---:|:---:|:---:|:---:|:---:|:---:|
+| 목록 UC1: brandId=X, LATEST | **20/100** | **80** | 2,769 | 2,161 | 3,599 | 3,686 | 3,686 |
+| 목록 UC3: brandId=X, LIKES_DESC | **27/100** | **73** | 2,683 | 2,881 | 4,131 | 4,192 | 4,192 |
+| 목록 UC4: brandId=1, LATEST | **29/100** | **71** | 2,738 | 2,753 | 4,253 | 4,254 | 4,254 |
+| 상세: productId=1 | **100/100** | **0** | 164 | 169 | 278 | 287 | 290 |
+
+- 목록: **71~80% 요청 실패** — DB 쿼리 레벨보다 에러율 높음 (Spring 스택 오버헤드가 커넥션 점유 시간 증가)
+- 상세: **100% 성공** — PK lookup은 커넥션 점유 시간이 짧아 경합 없음
+
+### 1000만건
+
+| UC | 완료/전체 | 에러 (건) | avg (ms) | p50 (ms) | p95 (ms) | p99 (ms) | max (ms) |
+|----|:---:|:---:|:---:|:---:|:---:|:---:|:---:|
+| 목록 UC1: brandId=X, LATEST | **10/100** | **90** | 37,129 | 37,139 | 37,701 | 37,701 | 37,701 |
+| 목록 UC3: brandId=X, LIKES_DESC | **10/100** | **90** | 32,766 | 32,732 | 33,417 | 33,417 | 33,417 |
+| 목록 UC4: brandId=1, LATEST | **10/100** | **90** | 30,445 | 30,371 | 30,781 | 30,781 | 30,781 |
+| 상세: productId=1 | **100/100** | **0** | 232 | 245 | 338 | 354 | 358 |
+
+- 목록: **90% 실패**, 성공한 10건조차 avg 30~37초 — 완전한 서비스 불능
+- 상세: **100% 성공**, avg 232ms — 커넥션 경합만 있을 뿐 쿼리 자체는 빠름
+
+---
+
+## B-3. 지속 부하 측정 (20 RPS × 10초)
+
+### 10만건
+
+| UC | 완료/전체 | 에러 (건) | 실제 QPS (건/초) | avg (ms) | p50 (ms) | p95 (ms) | p99 (ms) |
+|----|:---:|:---:|:---:|:---:|:---:|:---:|:---:|
+| 목록 UC1: brandId=X, LATEST | 200/200 | 0 | **20.0** | 58 | 53 | 74 | 122 |
+| 목록 UC3: brandId=X, LIKES_DESC | 200/200 | 0 | **20.0** | 54 | 49 | 79 | 112 |
+| 목록 UC4: brandId=1, LATEST | 200/200 | 0 | **20.0** | 48 | 47 | 55 | 65 |
+| 상세: productId=1 | 200/200 | 0 | **20.0** | 13 | 10 | 17 | 136 |
+
+- 20 RPS 목표 달성. 목록 avg 48~58ms, 상세 avg 13ms.
+
+### 100만건
+
+| UC | 완료/전체 | 에러 (건) | 실제 QPS (건/초) | avg (ms) | p50 (ms) | p95 (ms) | p99 (ms) |
+|----|:---:|:---:|:---:|:---:|:---:|:---:|:---:|
+| 목록 UC1: brandId=X, LATEST | **126/200** | **74** | **5.9** | 3,962 | 4,300 | 4,730 | 4,869 |
+| 목록 UC3: brandId=X, LIKES_DESC | **116/200** | **84** | **5.3** | 4,156 | 4,419 | 5,706 | 5,834 |
+| 목록 UC4: brandId=1, LATEST | **81/200** | **119** | **3.7** | 4,972 | 5,355 | 5,860 | 6,004 |
+| 상세: productId=1 | **200/200** | **0** | **20.0** | 21 | 18 | 41 | 65 |
+
+- 목록: **37~60% 요청 실패**, 실제 QPS 3.7~5.9 (목표의 19~30%)
+- 상세: **0% 실패**, 20 RPS 완벽 달성 — PK lookup이므로 부하와 무관
+
+### 1000만건
+
+| UC | 완료/전체 | 에러 (건) | 실제 QPS (건/초) | avg (ms) | p50 (ms) | p95 (ms) | p99 (ms) |
+|----|:---:|:---:|:---:|:---:|:---:|:---:|:---:|
+| 목록 UC1: brandId=X, LATEST | **10/200** | **190** | **0.3** | 30,970 | 30,944 | 31,630 | 31,630 |
+| 목록 UC3: brandId=X, LIKES_DESC | **17/200** | **183** | **0.5** | 19,227 | 21,491 | 22,250 | 22,250 |
+| 목록 UC4: brandId=1, LATEST | **19/200** | **181** | **0.5** | 19,950 | 19,936 | 21,544 | 21,544 |
+| 상세: productId=1 | **200/200** | **0** | **20.0** | 12 | 12 | 17 | 20 |
+
+- 목록: **90~95% 요청 실패**, 실제 QPS 0.3~0.5 — 서비스 완전 불능
+- 상세: **0% 실패**, 20 RPS 달성, avg 12ms — 데이터 규모와 무관하게 안정
+
+---
+
+# 분석
+
+## 핵심 발견
+
+### 1. Full Table Scan (`type=ALL`) + filesort
+
+모든 유즈케이스에서 products 테이블 전체를 스캔 + 메모리 정렬 수행.
+
+### 2. 데이터 규모에 따른 선형 성능 저하
+
+단일 쿼리 기준, 데이터 10배 증가 시 응답시간 7~26배 증가:
+
+| 레벨 | 10만건 | 100만건 | 1000만건 |
+|------|:---:|:---:|:---:|
+| DB 쿼리 (목록) | 20~33ms | 408~585ms | 3,489~4,184ms |
+| API (목록) | 48~60ms | 463~516ms | 6,174~11,604ms |
+| API (상세) | 5ms | 11ms | 18ms |
+
+인덱스 없이 Full Table Scan은 `O(N)` → 데이터가 늘면 선형으로 느려진다.
+
+### 3. 목록 vs 상세 — 극명한 차이
+
+| 항목 | 목록 API | 상세 API |
+|------|:---:|:---:|
+| 1000만건 단일 쿼리 | 6~11초 | **18ms** |
+| 1000만건 버스트 에러율 (%) | 90 | **0** |
+| 1000만건 지속 부하 QPS (건/초) | 0.3~0.5 | **20.0** |
+
+상세 API는 PK lookup(`O(1)`)이므로 데이터 규모와 무관하게 안정적. **캐시 적용 시 ROI가 큰 영역은 목록 API.**
+
+### 4. 동시 요청 시 서비스 장애 — 규모별 에러율 급증
+
+| 데이터 규모 | DB 버스트 에러율 (%) | API 버스트 에러율 (%) | API 지속 부하 에러율 (%) | API 지속 부하 QPS (건/초) |
+|:---:|:---:|:---:|:---:|:---:|
+| 10만건 | 0 | 0 | 0 | 20.0 |
+| 100만건 | 70~71 | 71~80 | 37~60 | 3.7~5.9 |
+| 1000만건 | **90** | **90** | **90~95** | **0.3~0.5** |
+
+- API 레벨은 DB 쿼리 레벨보다 에러율이 높음: Spring 스택(트랜잭션, JPA, 직렬화) 오버헤드로 커넥션 점유 시간 증가
+- 1000만건에서 목록 API의 실제 QPS는 0.3~0.5 — **20 RPS의 1.5~2.5%**에 불과
+
+### 5. brandId 필터의 한계
+
+brandId가 있으면 WHERE 절에서 필터링되지만, **인덱스 없이 Full Scan 후 필터링**이므로 성능 차이가 크지 않다.
+
+## DB vs API 오버헤드
+
+| 구간 | 10만건 (ms) | 100만건 (ms) | 1000만건 (ms) |
+|------|:---:|:---:|:---:|
+| DB 쿼리 (UC1) | 28 | 585 | 3,897 |
+| API (UC1) | 60 | 516 | 6,174 |
+| **Spring 스택 오버헤드** | **~32** | **~-69** | **~2,277** |
+
+- 10만건: Spring 오버헤드(~32ms)가 전체의 ~53% 차지
+- 100만건: 오버헤드가 DB 쿼리 대비 미미 (측정 오차 범위)
+- 1000만건: Spring TX + JPA 영속성 컨텍스트 + 직렬화 비용이 **~2초** 추가
+
+## 실행시간 참고사항
+
+- TestContainers MySQL은 로컬 Docker 컨테이너. 실제 운영 환경과 절대값은 다름.
+- DB + API 테스트가 병렬 실행(maxParallelForks=2)되므로, 리소스 경합으로 절대값이 순차 실행 대비 다소 높을 수 있음.
+- **상대적 비교**(AS-IS vs TO-BE, 데이터 규모별 증가율)가 핵심 지표.
+
+---
+
+## 개선 방향 (TO-BE 예상)
+
+| 개선 | 기대 효과 |
+|------|----------|
+| **복합 인덱스** (`brand_id, deleted_at, sort_col` — 카디널리티 높은 brand_id 선두) | Full Table Scan → range/ref scan, filesort 제거 |
+| **Redis 캐시** | 반복 조회 시 DB 쿼리 자체를 회피 |
+| **캐시 스탬피드 보호** (CacheLock + PER) | 캐시 만료 시 DB 폭주 방지 |
+
+TO-BE 측정은 각 개선 적용 후 동일 조건에서 재측정하여 비교한다:
+- `04-to-be-index-measurement.md` — 인덱스 적용 후 (DB 쿼리 레벨)
+- `05-to-be-cache-measurement.md` — 캐시 적용 후 (API 레벨)
+- `06-performance-comparison.html` — Chart.js 시각화 (전체 비교)
diff --git a/round5-docs/03-as-is-performance-visualization.html b/round5-docs/03-as-is-performance-visualization.html
new file mode 100644
index 000000000..f9561ef66
--- /dev/null
+++ b/round5-docs/03-as-is-performance-visualization.html
@@ -0,0 +1,725 @@
+<!DOCTYPE html>
+<html lang="ko">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>AS-IS 성능 측정 결과 시각화</title>
+    <script src="https://cdn.jsdelivr.net/npm/chart.js@4.4.7/dist/chart.umd.min.js"></script>
+    <style>
+        * { margin: 0; padding: 0; box-sizing: border-box; }
+        body {
+            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+            background: #0f172a;
+            color: #e2e8f0;
+            padding: 2rem 2rem 4rem;
+            max-width: 1400px;
+            margin: 0 auto;
+        }
+        h1 {
+            text-align: center;
+            font-size: 2rem;
+            margin-bottom: 0.5rem;
+            background: linear-gradient(135deg, #f97316, #ef4444);
+            -webkit-background-clip: text;
+            -webkit-text-fill-color: transparent;
+        }
+        .subtitle { text-align: center; color: #94a3b8; margin-bottom: 2rem; font-size: 0.9rem; }
+        .section-title {
+            font-size: 1.4rem;
+            margin: 3rem 0 0.5rem;
+            padding-left: 1rem;
+            border-left: 4px solid #f97316;
+            color: #f8fafc;
+        }
+        .section-desc { color: #94a3b8; margin-bottom: 1.5rem; padding-left: 1.2rem; font-size: 0.85rem; line-height: 1.6; }
+        .grid { display: grid; grid-template-columns: repeat(auto-fit, minmax(520px, 1fr)); gap: 1.5rem; margin-bottom: 1rem; }
+        .grid-3 { display: grid; grid-template-columns: repeat(3, 1fr); gap: 1.5rem; margin-bottom: 1rem; }
+        .card { background: #1e293b; border-radius: 12px; padding: 1.5rem; border: 1px solid #334155; }
+        .card h3 { font-size: 0.95rem; margin-bottom: 1rem; color: #cbd5e1; line-height: 1.4; }
+        .chart-container { position: relative; height: 320px; }
+        .chart-container.tall { height: 400px; }
+        .full-width { grid-column: 1 / -1; }
+
+        /* UC Reference Table */
+        .ref-table { width: 100%; border-collapse: collapse; font-size: 0.85rem; margin-bottom: 0.5rem; }
+        .ref-table th { background: #334155; color: #f8fafc; padding: 8px 12px; text-align: left; font-weight: 600; }
+        .ref-table td { padding: 6px 12px; border-bottom: 1px solid #334155; color: #cbd5e1; }
+        .ref-table tr:hover td { background: #334155; }
+        .ref-table code { background: #0f172a; padding: 2px 6px; border-radius: 3px; font-size: 0.8rem; color: #f97316; }
+
+        /* Summary KPI Cards */
+        .kpi-grid { display: grid; grid-template-columns: repeat(auto-fit, minmax(200px, 1fr)); gap: 1rem; margin-bottom: 2rem; }
+        .kpi { background: #1e293b; border-radius: 10px; padding: 1.2rem; border: 1px solid #334155; text-align: center; }
+        .kpi .value { font-size: 2rem; font-weight: 700; margin: 0.3rem 0; }
+        .kpi .label { font-size: 0.75rem; color: #94a3b8; }
+        .kpi .context { font-size: 0.7rem; color: #64748b; margin-top: 0.3rem; }
+        .kpi.danger .value { color: #ef4444; }
+        .kpi.warn .value { color: #f97316; }
+        .kpi.ok .value { color: #22c55e; }
+
+        /* Insight Box */
+        .insight { background: #1e293b; border-radius: 12px; padding: 1.5rem; margin: 1.5rem 0; }
+        .insight.danger { border: 1px solid #ef4444; }
+        .insight.warn { border: 1px solid #f97316; }
+        .insight h3 { margin-bottom: 0.75rem; font-size: 1rem; }
+        .insight.danger h3 { color: #ef4444; }
+        .insight.warn h3 { color: #f97316; }
+        .insight ul { list-style: none; padding: 0; }
+        .insight li { padding: 0.3rem 0; color: #cbd5e1; font-size: 0.88rem; line-height: 1.5; }
+        .insight.danger li::before { content: "# "; color: #ef4444; font-weight: 700; }
+        .insight.warn li::before { content: "# "; color: #f97316; font-weight: 700; }
+
+        .badge { display: inline-block; padding: 2px 8px; border-radius: 4px; font-size: 0.7rem; font-weight: 600; margin-left: 0.5rem; vertical-align: middle; }
+        .badge-danger { background: #ef444433; color: #ef4444; }
+        .badge-ok { background: #22c55e33; color: #22c55e; }
+        .legend-note { text-align: center; color: #64748b; font-size: 0.75rem; margin-top: 2rem; }
+
+        /* Nav */
+        .nav { position: fixed; top: 1rem; right: 1rem; background: #1e293b; border: 1px solid #334155; border-radius: 8px; padding: 0.75rem; z-index: 100; font-size: 0.78rem; }
+        .nav a { display: block; color: #94a3b8; text-decoration: none; padding: 0.25rem 0.5rem; border-radius: 4px; }
+        .nav a:hover { background: #334155; color: #f8fafc; }
+        .nav .nav-sep { border-top: 1px solid #334155; margin: 0.3rem 0; }
+
+        @media (max-width: 900px) {
+            .grid, .grid-3 { grid-template-columns: 1fr; }
+            .nav { display: none; }
+            body { padding: 1rem; }
+            .kpi-grid { grid-template-columns: repeat(2, 1fr); }
+        }
+    </style>
+</head>
+<body>
+
+<nav class="nav">
+    <a href="#sec-ref">UC 레퍼런스</a>
+    <div class="nav-sep"></div>
+    <a href="#sec-latency">1. 응답시간</a>
+    <a href="#sec-error">2. 에러율</a>
+    <a href="#sec-throughput">3. 처리량(QPS)</a>
+    <a href="#sec-overhead">4. DB vs API</a>
+    <div class="nav-sep"></div>
+    <a href="#sec-conclusion">결론</a>
+</nav>
+
+<h1>AS-IS 성능 측정 결과</h1>
+<p class="subtitle">
+    PK만 존재 (인덱스 없음) &middot; Full Table Scan + filesort &middot;
+    products LEFT JOIN brands &middot; TestContainers MySQL 8.0
+</p>
+
+<!-- ============================================================ -->
+<!-- Summary KPIs -->
+<!-- ============================================================ -->
+<div class="kpi-grid">
+    <div class="kpi ok">
+        <div class="label">10만건 단일 쿼리</div>
+        <div class="value">~25ms</div>
+        <div class="context">DB 쿼리 avg</div>
+    </div>
+    <div class="kpi warn">
+        <div class="label">100만건 단일 쿼리</div>
+        <div class="value">~530ms</div>
+        <div class="context">DB 쿼리 avg (x20 증가)</div>
+    </div>
+    <div class="kpi danger">
+        <div class="label">1000만건 단일 쿼리</div>
+        <div class="value">~3.8s</div>
+        <div class="context">DB 쿼리 avg (x7 재증가)</div>
+    </div>
+    <div class="kpi danger">
+        <div class="label">1000만건 버스트 에러율</div>
+        <div class="value">90%</div>
+        <div class="context">100 concurrent, 목록 API</div>
+    </div>
+    <div class="kpi danger">
+        <div class="label">1000만건 지속부하 QPS</div>
+        <div class="value">0.3~0.5</div>
+        <div class="context">목표 20 RPS의 1.5~2.5%</div>
+    </div>
+    <div class="kpi ok">
+        <div class="label">상세 API (PK Lookup)</div>
+        <div class="value">18ms</div>
+        <div class="context">1000만건에서도 안정</div>
+    </div>
+</div>
+
+<!-- ============================================================ -->
+<!-- UC Reference -->
+<!-- ============================================================ -->
+<h2 class="section-title" id="sec-ref">UC(Use Case) 레퍼런스</h2>
+<p class="section-desc">
+    모든 차트에서 사용되는 쿼리 유형 정의. 공통 패턴:
+    <code style="background:#0f172a; padding:2px 6px; border-radius:3px; color:#f97316;">
+        SELECT ... FROM products p LEFT JOIN brands b ON b.id = p.brand_id WHERE p.deleted_at IS NULL [AND ...] ORDER BY ... LIMIT 20
+    </code>
+</p>
+
+<div class="card" style="margin-bottom: 2rem; overflow-x: auto;">
+    <table class="ref-table">
+        <thead>
+        <tr>
+            <th>쿼리 유형</th>
+            <th>WHERE 조건</th>
+            <th>ORDER BY</th>
+            <th>설명</th>
+        </tr>
+        </thead>
+        <tbody>
+        <tr>
+            <td><strong>목록: 전체+최신순</strong></td>
+            <td><code>deleted_at IS NULL</code></td>
+            <td><code>created_at DESC</code></td>
+            <td>브랜드 필터 없이 최신순 정렬</td>
+        </tr>
+        <tr>
+            <td><strong>목록: 전체+가격순</strong></td>
+            <td><code>deleted_at IS NULL</code></td>
+            <td><code>price ASC</code></td>
+            <td>브랜드 필터 없이 가격 오름차순</td>
+        </tr>
+        <tr>
+            <td><strong>목록: 전체+인기순</strong></td>
+            <td><code>deleted_at IS NULL</code></td>
+            <td><code>like_count DESC</code></td>
+            <td>브랜드 필터 없이 좋아요 내림차순</td>
+        </tr>
+        <tr>
+            <td><strong>목록: 브랜드+최신순</strong></td>
+            <td><code>deleted_at IS NULL AND brand_id = 1</code></td>
+            <td><code>created_at DESC</code></td>
+            <td>특정 브랜드 필터 + 최신순</td>
+        </tr>
+        <tr>
+            <td><strong>목록: 브랜드+가격순</strong></td>
+            <td><code>deleted_at IS NULL AND brand_id = 1</code></td>
+            <td><code>price ASC</code></td>
+            <td>특정 브랜드 필터 + 가격 오름차순</td>
+        </tr>
+        <tr>
+            <td><strong>목록: 브랜드+인기순</strong></td>
+            <td><code>deleted_at IS NULL AND brand_id = 1</code></td>
+            <td><code>like_count DESC</code></td>
+            <td>특정 브랜드 필터 + 좋아요 내림차순</td>
+        </tr>
+        <tr style="border-top: 2px solid #475569;">
+            <td><strong>COUNT: 전체</strong></td>
+            <td><code>deleted_at IS NULL</code></td>
+            <td>-</td>
+            <td>페이지네이션용 전체 건수 조회</td>
+        </tr>
+        <tr>
+            <td><strong>COUNT: 브랜드</strong></td>
+            <td><code>deleted_at IS NULL AND brand_id = 1</code></td>
+            <td>-</td>
+            <td>페이지네이션용 브랜드별 건수</td>
+        </tr>
+        <tr style="border-top: 2px solid #475569;">
+            <td><strong>상세 (PK)</strong></td>
+            <td><code>id = 1</code></td>
+            <td>-</td>
+            <td>PK lookup, O(1) 성능</td>
+        </tr>
+        </tbody>
+    </table>
+</div>
+
+<div class="card" style="margin-bottom: 2rem; overflow-x: auto;">
+    <h3>트래픽 유형 정의</h3>
+    <table class="ref-table">
+        <thead>
+        <tr><th>트래픽 유형</th><th>설정</th><th>측정 지표</th><th>목적</th></tr>
+        </thead>
+        <tbody>
+        <tr>
+            <td><strong>단일 쿼리/요청</strong></td>
+            <td>1 thread, warmup 3회 + 측정 5회</td>
+            <td>avg 응답시간 (ms)</td>
+            <td>순수 쿼리/API 성능 측정 (경합 없음)</td>
+        </tr>
+        <tr>
+            <td><strong>버스트</strong></td>
+            <td>100 concurrent threads, 동시 시작</td>
+            <td>에러율(%), avg/p50/p95/p99/max</td>
+            <td>순간 폭주 시나리오 (커넥션 풀 경합)</td>
+        </tr>
+        <tr>
+            <td><strong>지속 부하</strong></td>
+            <td>20 RPS x 10초 = 200 요청</td>
+            <td>실제 QPS(건/초), 에러율(%)</td>
+            <td>일정 트래픽 유지 시나리오</td>
+        </tr>
+        </tbody>
+    </table>
+</div>
+
+
+<!-- ============================================================ -->
+<!-- 1. 응답시간 비교 -->
+<!-- ============================================================ -->
+<h2 class="section-title" id="sec-latency">1. 응답시간 비교 (단일 쿼리/요청)</h2>
+<p class="section-desc">
+    경합 없는 단일 실행에서의 순수 성능.<br>
+    왼쪽: DB 쿼리 레벨 (JDBC 직접), 오른쪽: API 레벨 (MockMvc, Spring 전체 스택).<br>
+    모든 목록 쿼리: EXPLAIN type=ALL (Full Table Scan), Using filesort.
+</p>
+
+<div class="grid">
+    <div class="card">
+        <h3>DB 쿼리 — 전체 목록 (브랜드 필터 없음)</h3>
+        <div class="chart-container"><canvas id="dbSingleAll"></canvas></div>
+    </div>
+    <div class="card">
+        <h3>API — 전체 목록 (브랜드 필터 없음)</h3>
+        <div class="chart-container"><canvas id="apiSingleAll"></canvas></div>
+    </div>
+    <div class="card">
+        <h3>DB 쿼리 — 브랜드 필터 (brand_id = 1)</h3>
+        <div class="chart-container"><canvas id="dbSingleBrand"></canvas></div>
+    </div>
+    <div class="card">
+        <h3>API — 브랜드 필터 (brand_id = 1)</h3>
+        <div class="chart-container"><canvas id="apiSingleBrand"></canvas></div>
+    </div>
+</div>
+
+<div class="grid">
+    <div class="card">
+        <h3>DB 쿼리 — COUNT</h3>
+        <div class="chart-container"><canvas id="dbCount"></canvas></div>
+    </div>
+    <div class="card">
+        <h3>목록 vs 상세 API <span class="badge badge-ok">상세: PK Lookup O(1)</span></h3>
+        <div class="chart-container"><canvas id="apiListVsDetail"></canvas></div>
+    </div>
+</div>
+
+<!-- ============================================================ -->
+<!-- 2. 에러율 비교 -->
+<!-- ============================================================ -->
+<h2 class="section-title" id="sec-error">2. 에러율 비교 (버스트 + 지속 부하)</h2>
+<p class="section-desc">
+    모든 차트가 동일한 Y축(에러율 0~100%)을 사용하여 직접 비교 가능.<br>
+    HikariCP 커넥션 풀 10개. 쿼리가 느릴수록 커넥션 점유 시간 증가 -> 대기 스레드 타임아웃.
+</p>
+
+<div class="grid">
+    <div class="card">
+        <h3>DB 버스트 에러율 (100 concurrent) <span class="badge badge-danger">커넥션 타임아웃</span></h3>
+        <div class="chart-container"><canvas id="dbBurstError"></canvas></div>
+    </div>
+    <div class="card">
+        <h3>API 버스트 에러율 (100 concurrent) <span class="badge badge-danger">Spring 오버헤드 가중</span></h3>
+        <div class="chart-container"><canvas id="apiBurstError"></canvas></div>
+    </div>
+    <div class="card">
+        <h3>DB 지속 부하 에러율 (20 RPS x 10초)</h3>
+        <div class="chart-container"><canvas id="dbSustainedError"></canvas></div>
+    </div>
+    <div class="card">
+        <h3>API 지속 부하 에러율 (20 RPS x 10초)</h3>
+        <div class="chart-container"><canvas id="apiSustainedError"></canvas></div>
+    </div>
+</div>
+
+<div class="insight danger">
+    <h3>에러율 핵심 발견</h3>
+    <ul>
+        <li><strong>10만건</strong>: 모든 시나리오에서 에러 0%. 단일 쿼리 20~30ms이므로 커넥션 풀 10개로 충분.</li>
+        <li><strong>100만건</strong>: 단일 쿼리 400~580ms로 증가 -> 버스트 시 70~80% 타임아웃, 지속 부하에서도 37~60% 실패.</li>
+        <li><strong>1000만건</strong>: 단일 쿼리 3.5~4초 -> 버스트 90%, 지속 부하 90~95% 실패. 서비스 완전 불능.</li>
+        <li><strong>API가 DB보다 에러율 더 높음</strong>: Spring TX + JPA + 직렬화 오버헤드로 커넥션 점유 시간이 더 길어짐.</li>
+        <li><strong>상세 API(PK lookup)는 모든 규모에서 에러 0%</strong>: 커넥션 점유 시간이 극히 짧아 경합 없음.</li>
+    </ul>
+</div>
+
+<!-- ============================================================ -->
+<!-- 3. 처리량 비교 -->
+<!-- ============================================================ -->
+<h2 class="section-title" id="sec-throughput">3. 처리량(QPS) 비교 (지속 부하)</h2>
+<p class="section-desc">
+    목표: 20 RPS. 빨간 점선이 목표선. 모든 차트가 동일한 Y축(0~22 QPS)을 사용.<br>
+    DB 레벨과 API 레벨을 나란히 배치하여 Spring 스택 오버헤드에 의한 QPS 감소를 직접 비교.
+</p>
+
+<div class="grid">
+    <div class="card">
+        <h3>DB 쿼리 — 실제 QPS (20 RPS x 10초)</h3>
+        <div class="chart-container"><canvas id="dbQps"></canvas></div>
+    </div>
+    <div class="card">
+        <h3>API — 실제 QPS (20 RPS x 10초)</h3>
+        <div class="chart-container"><canvas id="apiQps"></canvas></div>
+    </div>
+</div>
+
+<!-- ============================================================ -->
+<!-- 4. DB vs API 오버헤드 -->
+<!-- ============================================================ -->
+<h2 class="section-title" id="sec-overhead">4. DB vs API 오버헤드 비교</h2>
+<p class="section-desc">
+    동일 쿼리(전체 목록 + 최신순)에 대해 DB 직접 실행 vs API 전체 스택의 응답시간 차이.<br>
+    그리고 버스트/지속 부하의 에러율을 DB와 API 레벨에서 규모별로 나란히 비교.
+</p>
+
+<div class="grid">
+    <div class="card">
+        <h3>단일 실행: DB 쿼리 vs API (전체+최신순) <span class="badge badge-ok">로그 스케일</span></h3>
+        <div class="chart-container"><canvas id="overheadLatency"></canvas></div>
+    </div>
+    <div class="card">
+        <h3>에러율: DB vs API (버스트 + 지속 부하)</h3>
+        <div class="chart-container"><canvas id="overheadError"></canvas></div>
+    </div>
+</div>
+
+<div class="grid">
+    <div class="card full-width">
+        <h3>버스트 응답시간: DB vs API (전체+최신순, 성공 요청만)</h3>
+        <div class="chart-container"><canvas id="burstLatencyCompare"></canvas></div>
+    </div>
+</div>
+
+<!-- ============================================================ -->
+<!-- 결론 -->
+<!-- ============================================================ -->
+<h2 class="section-title" id="sec-conclusion">결론</h2>
+
+<div class="insight warn">
+    <h3>핵심 문제</h3>
+    <ul>
+        <li>모든 목록 쿼리가 <strong>Full Table Scan + filesort</strong> (type=ALL, key=null)</li>
+        <li>데이터 10배 증가 시 응답시간 7~26배 증가 (O(N) 선형 저하)</li>
+        <li>100만건부터 20 RPS도 감당 불가, 1000만건에서 서비스 완전 불능</li>
+        <li>brandId 필터가 있어도 <strong>인덱스 없이 Full Scan 후 필터링</strong>이라 개선 효과 미미</li>
+    </ul>
+</div>
+
+<div class="insight warn">
+    <h3>개선 방향 (TO-BE)</h3>
+    <ul>
+        <li><strong>복합 인덱스</strong> (brand_id, deleted_at, sort_col — 카디널리티 높은 brand_id 선두) -> Full Table Scan -> range/ref scan, filesort 제거</li>
+        <li><strong>Redis 캐시</strong> -> 반복 조회 시 DB 쿼리 자체를 회피</li>
+        <li><strong>캐시 스탬피드 보호</strong> (CacheLock + PER) -> 캐시 만료 시 DB 폭주 방지</li>
+    </ul>
+</div>
+
+<p class="legend-note">
+    TestContainers MySQL 8.0 &middot; 상대적 비교(AS-IS vs TO-BE, 규모별 증가율)가 핵심 지표
+</p>
+
+<!-- ============================================================ -->
+<!-- CHARTS -->
+<!-- ============================================================ -->
+<script>
+// 0 값 바에 "0" 라벨 표시 플러그인
+Chart.register({
+    id: 'zeroLabel',
+    afterDatasetsDraw(chart) {
+        const { ctx } = chart;
+        chart.data.datasets.forEach((dataset, di) => {
+            if (dataset.type === 'line') return;
+            const meta = chart.getDatasetMeta(di);
+            if (meta.hidden) return;
+            meta.data.forEach((bar, i) => {
+                const val = dataset.data[i];
+                if (val !== 0) return;
+                ctx.save();
+                ctx.fillStyle = dataset.borderColor || '#94a3b8';
+                ctx.font = 'bold 11px sans-serif';
+                ctx.textAlign = 'center';
+                ctx.textBaseline = 'bottom';
+                ctx.fillText('0', bar.x, bar.y - 4);
+                ctx.restore();
+            });
+        });
+    }
+});
+
+const C = {
+    orange: '#f97316', orangeA: '#f9731640',
+    red:    '#ef4444', redA:    '#ef444440',
+    blue:   '#3b82f6', blueA:   '#3b82f640',
+    green:  '#22c55e', greenA:  '#22c55e40',
+    purple: '#a855f7', purpleA: '#a855f740',
+    cyan:   '#06b6d4', cyanA:   '#06b6d440',
+    yellow: '#eab308', yellowA: '#eab30840',
+    gray:   '#64748b', grayA:   '#64748b40',
+};
+
+const SCALES = ['10만건', '100만건', '1000만건'];
+
+function opts(yLabel, extra = {}) {
+    return {
+        responsive: true,
+        maintainAspectRatio: false,
+        plugins: {
+            legend: { labels: { color: '#94a3b8', font: { size: 11 } } },
+            tooltip: {
+                callbacks: {
+                    label: ctx => `${ctx.dataset.label}: ${ctx.parsed.y != null ? ctx.parsed.y.toLocaleString() : ctx.parsed.x.toLocaleString()}`
+                }
+            }
+        },
+        scales: {
+            x: { ticks: { color: '#94a3b8' }, grid: { color: '#1e293b' } },
+            y: {
+                ticks: { color: '#94a3b8' },
+                grid: { color: '#334155' },
+                title: { display: true, text: yLabel, color: '#64748b' },
+                ...extra
+            }
+        }
+    };
+}
+
+function optsLog(yLabel) {
+    return opts(yLabel, { type: 'logarithmic' });
+}
+
+function optsFixed(yLabel, max) {
+    return opts(yLabel, { min: 0, max });
+}
+
+// dataset helper
+function ds(label, data, color, colorA, extra = {}) {
+    return { label, data, backgroundColor: colorA, borderColor: color, borderWidth: 2, ...extra };
+}
+function dsLine(label, data, color, extra = {}) {
+    return { label, data, borderColor: color, backgroundColor: color + '30', fill: false, tension: 0.3, type: 'line', pointRadius: 4, ...extra };
+}
+
+// ============================================================
+// 1. 응답시간 비교
+// ============================================================
+
+// DB - 전체 목록
+new Chart(document.getElementById('dbSingleAll'), {
+    type: 'bar',
+    data: {
+        labels: SCALES,
+        datasets: [
+            ds('최신순 (created_at DESC)',    [27.68, 585.45, 3897.22], C.orange, C.orangeA),
+            ds('가격순 (price ASC)',          [33.44, 560.41, 4184.09], C.blue,   C.blueA),
+            ds('인기순 (like_count DESC)',    [25.69, 526.67, 3614.20], C.green,  C.greenA),
+        ]
+    },
+    options: opts('avg 응답시간 (ms)')
+});
+
+// API - 전체 목록
+new Chart(document.getElementById('apiSingleAll'), {
+    type: 'bar',
+    data: {
+        labels: SCALES,
+        datasets: [
+            ds('최신순 (created_at DESC)',    [60.18, 516.31, 6174.44],  C.orange, C.orangeA),
+            ds('가격순 (price ASC)',          [59.55, 497.88, 6522.14],  C.blue,   C.blueA),
+            ds('인기순 (like_count DESC)',    [51.51, 473.23, 6663.48],  C.green,  C.greenA),
+        ]
+    },
+    options: opts('avg 응답시간 (ms)')
+});
+
+// DB - 브랜드 필터
+new Chart(document.getElementById('dbSingleBrand'), {
+    type: 'bar',
+    data: {
+        labels: SCALES,
+        datasets: [
+            ds('최신순 (created_at DESC)',    [21.88, 422.82, 3782.83], C.orange, C.orangeA),
+            ds('가격순 (price ASC)',          [22.11, 408.43, 3489.15], C.blue,   C.blueA),
+            ds('인기순 (like_count DESC)',    [20.80, 429.17, 3961.33], C.green,  C.greenA),
+        ]
+    },
+    options: opts('avg 응답시간 (ms)')
+});
+
+// API - 브랜드 필터
+new Chart(document.getElementById('apiSingleBrand'), {
+    type: 'bar',
+    data: {
+        labels: SCALES,
+        datasets: [
+            ds('최신순 (created_at DESC)',    [49.52, 502.12, 6643.62],  C.orange, C.orangeA),
+            ds('가격순 (price ASC)',          [48.82, 463.31, 9901.90],  C.blue,   C.blueA),
+            ds('인기순 (like_count DESC)',    [48.07, 482.24, 11604.48], C.green,  C.greenA),
+        ]
+    },
+    options: opts('avg 응답시간 (ms)')
+});
+
+// DB COUNT
+new Chart(document.getElementById('dbCount'), {
+    type: 'bar',
+    data: {
+        labels: SCALES,
+        datasets: [
+            ds('전체 (deleted_at IS NULL)',           [10.59, 279.32, 2147.34], C.purple, C.purpleA),
+            ds('브랜드 (+ brand_id = 1)',             [11.88, 314.32, 2323.93], C.cyan,   C.cyanA),
+        ]
+    },
+    options: opts('avg 응답시간 (ms)')
+});
+
+// 목록 vs 상세
+new Chart(document.getElementById('apiListVsDetail'), {
+    type: 'bar',
+    data: {
+        labels: SCALES,
+        datasets: [
+            ds('목록: 전체+최신순',         [60.18, 516.31, 6174.44],  C.red,    C.redA),
+            ds('목록: 브랜드+인기순 (최악)', [48.07, 482.24, 11604.48], C.orange, C.orangeA),
+            ds('상세: PK lookup (id=1)',     [4.58, 11.41, 18.27],      C.green,  C.greenA),
+        ]
+    },
+    options: optsLog('avg 응답시간 (ms) — 로그 스케일')
+});
+
+// ============================================================
+// 2. 에러율 비교 (동일 Y축 0~100%)
+// ============================================================
+
+// DB 버스트 에러율
+new Chart(document.getElementById('dbBurstError'), {
+    type: 'bar',
+    data: {
+        labels: SCALES,
+        datasets: [
+            ds('전체+최신순',    [0, 71, 90], C.orange, C.orangeA),
+            ds('전체+인기순',    [0, 70, 90], C.blue,   C.blueA),
+            ds('브랜드+최신순',  [0, 70, 90], C.green,  C.greenA),
+        ]
+    },
+    options: optsFixed('에러율 (%)', 100)
+});
+
+// API 버스트 에러율
+new Chart(document.getElementById('apiBurstError'), {
+    type: 'bar',
+    data: {
+        labels: SCALES,
+        datasets: [
+            ds('목록: 전체+최신순',    [0, 80, 90], C.orange, C.orangeA),
+            ds('목록: 전체+인기순',    [0, 73, 90], C.blue,   C.blueA),
+            ds('목록: 브랜드+최신순',  [0, 71, 90], C.green,  C.greenA),
+            ds('상세: PK lookup',      [0, 0, 0],   C.cyan,   C.cyanA),
+        ]
+    },
+    options: optsFixed('에러율 (%)', 100)
+});
+
+// DB 지속 부하 에러율
+new Chart(document.getElementById('dbSustainedError'), {
+    type: 'bar',
+    data: {
+        labels: SCALES,
+        datasets: [
+            ds('전체+최신순',    [0, 45, 90],   C.orange, C.orangeA),
+            ds('전체+인기순',    [0, 22.5, 90], C.blue,   C.blueA),
+            ds('브랜드+최신순',  [0, 21, 90],   C.green,  C.greenA),
+        ]
+    },
+    options: optsFixed('에러율 (%)', 100)
+});
+
+// API 지속 부하 에러율
+new Chart(document.getElementById('apiSustainedError'), {
+    type: 'bar',
+    data: {
+        labels: SCALES,
+        datasets: [
+            ds('목록: 전체+최신순',    [0, 37, 95],   C.orange, C.orangeA),
+            ds('목록: 전체+인기순',    [0, 42, 91.5], C.blue,   C.blueA),
+            ds('목록: 브랜드+최신순',  [0, 59.5, 90.5], C.green,  C.greenA),
+            ds('상세: PK lookup',      [0, 0, 0],       C.cyan,   C.cyanA),
+        ]
+    },
+    options: optsFixed('에러율 (%)', 100)
+});
+
+// ============================================================
+// 3. 처리량 비교 (동일 Y축 0~22)
+// ============================================================
+
+// DB QPS
+new Chart(document.getElementById('dbQps'), {
+    type: 'bar',
+    data: {
+        labels: SCALES,
+        datasets: [
+            ds('전체+최신순',    [20.0, 5.8, 0.6], C.orange, C.orangeA),
+            ds('전체+인기순',    [20.0, 9.9, 0.8], C.blue,   C.blueA),
+            ds('브랜드+최신순',  [20.0, 9.9, 0.8], C.green,  C.greenA),
+            dsLine('목표 20 RPS', [20, 20, 20], C.red, { borderDash: [8,4], pointRadius: 0, borderWidth: 2 }),
+        ]
+    },
+    options: optsFixed('실제 QPS (건/초)', 22)
+});
+
+// API QPS
+new Chart(document.getElementById('apiQps'), {
+    type: 'bar',
+    data: {
+        labels: SCALES,
+        datasets: [
+            ds('목록: 전체+최신순',    [20.0, 5.9, 0.3], C.orange, C.orangeA),
+            ds('목록: 전체+인기순',    [20.0, 5.3, 0.5], C.blue,   C.blueA),
+            ds('목록: 브랜드+최신순',  [20.0, 3.7, 0.5], C.green,  C.greenA),
+            ds('상세: PK lookup',      [20.0, 20.0, 20.0], C.cyan,   C.cyanA),
+            dsLine('목표 20 RPS', [20, 20, 20], C.red, { borderDash: [8,4], pointRadius: 0, borderWidth: 2 }),
+        ]
+    },
+    options: optsFixed('실제 QPS (건/초)', 22)
+});
+
+// ============================================================
+// 4. DB vs API 오버헤드
+// ============================================================
+
+// 단일 응답시간 비교
+new Chart(document.getElementById('overheadLatency'), {
+    type: 'bar',
+    data: {
+        labels: SCALES,
+        datasets: [
+            ds('DB 쿼리: 전체+최신순',  [27.68, 585.45, 3897.22], C.blue,   C.blueA),
+            ds('API: 전체+최신순',       [60.18, 516.31, 6174.44], C.orange, C.orangeA),
+            ds('API: 상세 (PK lookup)',  [4.58, 11.41, 18.27],     C.green,  C.greenA),
+        ]
+    },
+    options: optsLog('avg 응답시간 (ms) — 로그 스케일')
+});
+
+// 에러율 비교 (DB vs API, 버스트 + 지속)
+new Chart(document.getElementById('overheadError'), {
+    type: 'bar',
+    data: {
+        labels: SCALES,
+        datasets: [
+            ds('DB 버스트 (전체+최신순)',     [0, 71, 90], C.blue,   C.blueA),
+            ds('API 버스트 (전체+최신순)',     [0, 80, 90], C.orange, C.orangeA),
+            ds('DB 지속부하 (전체+최신순)',    [0, 45, 90], C.cyan,   C.cyanA),
+            ds('API 지속부하 (전체+최신순)',   [0, 37, 95], C.red,    C.redA),
+        ]
+    },
+    options: optsFixed('에러율 (%)', 100)
+});
+
+// 버스트 응답시간 비교 (성공 요청)
+new Chart(document.getElementById('burstLatencyCompare'), {
+    type: 'bar',
+    data: {
+        labels: SCALES,
+        datasets: [
+            ds('DB avg',  [433, 2793, 12021],  C.blue,   C.blueA),
+            ds('DB p95',  [835, 4306, 12389],  C.cyan,   C.cyanA),
+            ds('API avg', [726, 2769, 37129],  C.orange, C.orangeA),
+            ds('API p95', [1335, 3599, 37701], C.red,    C.redA),
+        ]
+    },
+    options: opts('응답시간 (ms) — 성공 요청만')
+});
+</script>
+
+</body>
+</html>

From 588980ec264a1dbdda880dee145a74d0ce5900ba Mon Sep 17 00:00:00 2001
From: Hwan0518 <qip0518@naver.com>
Date: Fri, 13 Mar 2026 03:21:12 +0900
Subject: [PATCH 2/9] =?UTF-8?q?feat:=20=EC=A0=84=EC=B2=B4=20Entity=20?=
 =?UTF-8?q?=EC=9D=B8=EB=8D=B1=EC=8A=A4=20=EC=B5=9C=EC=A0=81=ED=99=94=20?=
 =?UTF-8?q?=EB=B0=8F=20=EC=84=B1=EB=8A=A5=20=EC=B8=A1=EC=A0=95?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- ProductEntity, BrandEntity, CartItemEntity 인덱스 추가
- CouponTemplateEntity, IssuedCouponEntity, ProductLikeEntity 인덱스 추가
- OrderEntity, OrderItemEntity 인덱스 추가
- CLAUDE.md 4.10-4.11 인덱스 설계 섹션 추가
- .claude/skills/index-design/SKILL.md 인덱스 설계 스킬 추가
- apps/commerce-api/build.gradle.kts 벤치마크 sourceSet 설정
- ProductIndexPerformanceTest, ProductApiPerformanceTest 벤치마크 추가
- round5-docs/04-to-be-index-measurement.md 측정 결과
- round5-docs/04-to-be-index-visualization.html 시각화

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
---
 .claude/skills/index-design/SKILL.md          | 102 ++
 CLAUDE.md                                     |  12 +
 apps/commerce-api/build.gradle.kts            |  27 +
 .../ProductApiPerformanceTest.java            | 698 +++++++++++++
 .../ProductIndexPerformanceTest.java          | 941 ++++++++++++++++++
 .../infrastructure/entity/CartItemEntity.java |  12 +-
 .../infrastructure/entity/BrandEntity.java    |   5 +-
 .../infrastructure/entity/ProductEntity.java  |  15 +-
 .../entity/CouponTemplateEntity.java          |   5 +-
 .../entity/IssuedCouponEntity.java            |  10 +-
 .../entity/ProductLikeEntity.java             |  10 +-
 .../infrastructure/entity/OrderEntity.java    |  13 +-
 .../entity/OrderItemEntity.java               |   9 +-
 round5-docs/04-to-be-index-measurement.md     | 512 ++++++++++
 round5-docs/04-to-be-index-visualization.html | 814 +++++++++++++++
 15 files changed, 3159 insertions(+), 26 deletions(-)
 create mode 100644 .claude/skills/index-design/SKILL.md
 create mode 100644 apps/commerce-api/src/benchmark/java/com/loopers/catalog/product/infrastructure/ProductApiPerformanceTest.java
 create mode 100644 apps/commerce-api/src/benchmark/java/com/loopers/catalog/product/infrastructure/ProductIndexPerformanceTest.java
 create mode 100644 round5-docs/04-to-be-index-measurement.md
 create mode 100644 round5-docs/04-to-be-index-visualization.html

diff --git a/.claude/skills/index-design/SKILL.md b/.claude/skills/index-design/SKILL.md
new file mode 100644
index 000000000..06a098b11
--- /dev/null
+++ b/.claude/skills/index-design/SKILL.md
@@ -0,0 +1,102 @@
+---
+name: index-design
+description: Database index design guidelines for JPA entities. Use when adding or reviewing composite indexes, analyzing query performance, or designing new table schemas.
+---
+
+# Index Design
+
+## 1. 컬럼 순서 원칙 — 카디널리티 우선
+
+복합 인덱스의 컬럼 순서는 다음 규칙을 따른다:
+
+```
+[카디널리티 높은 equality 컬럼] → [카디널리티 낮은 equality 컬럼] → [sort/range 컬럼]
+```
+
+| 순서 | 기준 | 이유 |
+|:----:|------|------|
+| 1st | 카디널리티가 가장 높은 equality 컬럼 | B-tree 첫 레벨 fan-out 균등화 |
+| 2nd | 나머지 equality 컬럼 | 연속 탐색으로 range 축소 |
+| Last | ORDER BY / range scan 대상 컬럼 | 인덱스 순서 = 정렬 순서 → filesort 제거 |
+
+### 왜 카디널리티 순인가?
+
+- 복합 인덱스에서 **모든 equality 컬럼이 쿼리에 사용되면**, 컬럼 순서와 무관하게 matching rows는 동일
+- 하지만 카디널리티가 높은 컬럼이 선두에 오면 **B-tree 분기가 균등해져 인덱스 페이지 접근 효율이 향상**됨
+- 카디널리티가 낮은 컬럼(예: `deleted_at` — 2값)이 선두에 오면 B-tree 첫 레벨이 편향됨
+
+### 예시
+
+```
+쿼리: WHERE brand_id = 1 AND deleted_at IS NULL ORDER BY created_at DESC
+
+brand_id 카디널리티: 수십~수백 (높음)
+deleted_at 카디널리티: 2 (NULL / timestamp, 낮음)
+
+✅ (brand_id, deleted_at, created_at) — 카디널리티 높은 brand_id 선두
+❌ (deleted_at, brand_id, created_at) — 카디널리티 낮은 deleted_at 선두
+```
+
+## 2. IS NULL과 인덱스
+
+- MySQL에서 `IS NULL`은 **equality(ref)** 로 처리됨 (range가 아님)
+- `deleted_at IS NULL`이 전체의 99%+여도 인덱스 사용 가능
+- 단, 카디널리티가 2뿐이므로 **선두 컬럼으로는 비효율적** → equality 컬럼 중 후순위에 배치
+
+## 3. 쿼리 조합별 인덱스 커버리지
+
+조회 API에 정렬이 포함된 경우, **가능한 모든 WHERE + ORDER BY 조합**에 대해 인덱스를 설계한다.
+
+```
+예: 사용자/관리자 × 브랜드유무 × N개 정렬 = 2 × 2 × N개 인덱스
+```
+
+### 조합이 많아지는 경우
+
+| 조건 | 인덱스 설계 |
+|------|-----------|
+| WHERE A AND B ORDER BY C | `(A, B, C)` — equality 2개 + sort 1개 |
+| WHERE A ORDER BY C (B 없음) | `(A, C)` — 별도 2-column 인덱스 필요 |
+| WHERE B ORDER BY C (A 없음) | `(B, C)` — 별도 2-column 인덱스 필요 |
+| ORDER BY C (필터 없음) | `(C)` — 단일 컬럼 인덱스 필요 |
+
+**중간 컬럼 스킵 시 정렬 불가**: `(A, B, C)` 인덱스에서 `WHERE A ORDER BY C`는 B를 건너뛸 수 없어 **filesort 발생**. 반드시 별도 `(A, C)` 인덱스 필요.
+
+## 4. JPA Entity 선언 방식
+
+```java
+@Table(name = "table_name", indexes = {
+    // 사용자 조회: WHERE brand_id = ? AND deleted_at IS NULL ORDER BY created_at DESC
+    // 카디널리티: brand_id(높음) → deleted_at(낮음) → sort_col
+    @Index(name = "idx_{table}_{col1}_{col2}_{col3}", columnList = "brand_id, deleted_at, created_at"),
+})
+```
+
+### 네이밍 규칙
+
+| 유형 | 패턴 | 예시 |
+|------|------|------|
+| 복합 인덱스 | `idx_{table}_{col1}_{col2}_{col3}` | `idx_read_brand_deleted_created` |
+| 단일 인덱스 | `idx_{table}_{col}` | `idx_read_created` |
+
+### 주석 규칙
+
+- 각 인덱스 위에 **대상 쿼리 패턴**을 주석으로 명시
+- 카디널리티 순서가 일반적이지 않은 경우 그 이유를 주석으로 설명
+
+## 5. 인덱스 추가 체크리스트
+
+인덱스를 추가하거나 리뷰할 때 다음을 확인한다:
+
+- [ ] equality 컬럼이 range/sort 컬럼보다 앞에 위치하는가?
+- [ ] equality 컬럼 간 카디널리티가 높은 순으로 배치되었는가?
+- [ ] 선택적 필터(optional WHERE)가 빠진 쿼리에도 별도 인덱스가 존재하는가?
+- [ ] 중간 컬럼 스킵으로 인한 filesort 발생 가능성을 검토했는가?
+- [ ] 인덱스 주석에 대상 쿼리 패턴이 명시되어 있는가?
+- [ ] 인덱스 수가 과도하지 않은가? (쓰기 비용 trade-off 검토)
+
+## 6. Read Model 패턴에서의 인덱스
+
+- Read Model 테이블은 **조회 전용**이므로 인덱스를 자유롭게 추가 가능
+- 원본 테이블(쓰기 전용)에는 인덱스 추가 시 INSERT/UPDATE 비용 증가 고려
+- Read Model에 비정규화된 컬럼(예: `brand_name`)이 있으면 JOIN 제거 가능 → 인덱스 효과 극대화
diff --git a/CLAUDE.md b/CLAUDE.md
index 8ecd7b407..557e81580 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -527,6 +527,18 @@ Controller → Facade → Service / Domain Service → Repository(interface) →
 - 사용자 전용 DTO: 접두사 없음 (예: `BrandOutDto`, `BrandResponse`)
 - 관리자/사용자 응답 필드가 다를 수 있으므로 별도 DTO 정의 (예: 관리자는 `deletedAt` 포함)
 
+### 4.10 DB 스키마 관리
+
+- **Flyway 등 DB 마이그레이션 도구 사용하지 않음** — Hibernate `ddl-auto`로 스키마 관리
+- JPA Entity의 `@Column`, `@Table(indexes = {...})` 선언이 스키마의 SoT
+- 컬럼 추가/제거는 Entity 필드 변경으로 반영 (별도 마이그레이션 파일 불필요)
+
+### 4.11 인덱스 설계
+
+- **인덱스 생성 시** `.claude/skills/index-design/SKILL.md` 규칙을 반드시 준수
+- 핵심 원칙: **카디널리티가 높은 컬럼을 선두에 배치**, equality 컬럼은 range/sort 컬럼보다 앞에
+- `@Table(indexes = { @Index(...) })` 방식으로 JPA Entity에 선언 (Hibernate auto-DDL 활용)
+
 ## 5. 주의사항
 
 ### Never Do
diff --git a/apps/commerce-api/build.gradle.kts b/apps/commerce-api/build.gradle.kts
index de9b02f75..913430b44 100644
--- a/apps/commerce-api/build.gradle.kts
+++ b/apps/commerce-api/build.gradle.kts
@@ -1,3 +1,30 @@
+import org.gradle.api.tasks.testing.Test
+
+val benchmarkSourceSet = sourceSets.create("benchmark") {
+    java.srcDir("src/benchmark/java")
+    resources.srcDir("src/benchmark/resources")
+    compileClasspath += sourceSets["main"].output
+    runtimeClasspath += output + compileClasspath
+}
+
+configurations[benchmarkSourceSet.implementationConfigurationName].extendsFrom(configurations.testImplementation.get())
+configurations[benchmarkSourceSet.runtimeOnlyConfigurationName].extendsFrom(configurations.testRuntimeOnly.get())
+configurations[benchmarkSourceSet.compileOnlyConfigurationName].extendsFrom(configurations.testCompileOnly.get())
+configurations[benchmarkSourceSet.annotationProcessorConfigurationName].extendsFrom(configurations.testAnnotationProcessor.get())
+
+tasks.register<Test>("benchmarkTest") {
+    description = "Runs benchmark-style performance tests excluded from the default test task."
+    group = "verification"
+    testClassesDirs = benchmarkSourceSet.output.classesDirs
+    classpath = benchmarkSourceSet.runtimeClasspath
+    maxParallelForks = 1
+    useJUnitPlatform()
+    systemProperty("user.timezone", "Asia/Seoul")
+    systemProperty("spring.profiles.active", "test")
+    jvmArgs("-Xshare:off")
+    shouldRunAfter(tasks.test)
+}
+
 dependencies {
     // add-ons
     implementation(project(":modules:jpa"))
diff --git a/apps/commerce-api/src/benchmark/java/com/loopers/catalog/product/infrastructure/ProductApiPerformanceTest.java b/apps/commerce-api/src/benchmark/java/com/loopers/catalog/product/infrastructure/ProductApiPerformanceTest.java
new file mode 100644
index 000000000..579c6848b
--- /dev/null
+++ b/apps/commerce-api/src/benchmark/java/com/loopers/catalog/product/infrastructure/ProductApiPerformanceTest.java
@@ -0,0 +1,698 @@
+package com.loopers.catalog.product.infrastructure;
+
+
+import com.loopers.testcontainers.MySqlTestContainersConfig;
+import com.loopers.testcontainers.RedisTestContainersConfig;
+import com.loopers.utils.DatabaseCleanUp;
+import com.loopers.utils.RedisCleanUp;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.Timeout;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.context.annotation.Import;
+import org.springframework.test.context.ActiveProfiles;
+import org.springframework.test.web.servlet.MockMvc;
+import org.springframework.test.web.servlet.MvcResult;
+
+import javax.sql.DataSource;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.sql.*;
+import java.time.Instant;
+import java.time.temporal.ChronoUnit;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.concurrent.*;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
+
+
+/**
+ * 상품 API 레벨 성능 측정 (NO-CACHE / CACHE)
+ * - MockMvc를 통해 실제 Controller → Facade → Service → Repository → DB 전체 스택 측정
+ * - NO-CACHE: 인덱스만 적용, Redis 캐시 미적용 상태의 기준선
+ * - CACHE (TO-BE): 인덱스 + Redis 캐시 적용 상태 (캐시 히트/미스 분리 측정)
+ * - 측정 축: 데이터 규모(10만/100만/1000만) × 트래픽 유형(단일쿼리/버스트/지속부하)
+ *
+ * 1. 단일 쿼리: 목록/상세 API (warmup 3회 + 측정 5회 평균)
+ * 2. 버스트: 100 concurrent 동시 요청 → p50/p95/p99
+ * 3. 지속 부하: 20 RPS × 10초 → 처리량 + p50/p95/p99
+ */
+@SpringBootTest
+@AutoConfigureMockMvc
+@ActiveProfiles("test")
+@Import({MySqlTestContainersConfig.class, RedisTestContainersConfig.class})
+@DisplayName("상품 API 성능 측정")
+class ProductApiPerformanceTest {
+
+	private static final Logger log = LoggerFactory.getLogger(ProductApiPerformanceTest.class);
+	private static final String RESULT_FILE = "/tmp/api-perf-results.txt";
+	private static final int BRAND_COUNT = 50;
+
+	// 버스트 파라미터
+	private static final int BURST_THREADS = 100;
+
+	// 지속 부하 파라미터
+	private static final int SUSTAINED_RPS = 20;
+	private static final int SUSTAINED_DURATION_SEC = 10;
+
+	@Autowired
+	private MockMvc mockMvc;
+
+	@Autowired
+	private DataSource dataSource;
+
+	@Autowired
+	private DatabaseCleanUp databaseCleanUp;
+
+	@Autowired
+	private RedisCleanUp redisCleanUp;
+
+
+	@AfterEach
+	void tearDown() {
+		databaseCleanUp.truncateAllTables();
+		redisCleanUp.truncateAll();
+	}
+
+
+	// --- 테스트 메서드 (데이터 규모별) ---
+
+	@Test
+	@Timeout(value = 5, unit = TimeUnit.MINUTES)
+	@DisplayName("[NO-CACHE API] 10만건 성능 측정 (인덱스만, 캐시 미적용)")
+	void measureApiNoCache_100K() throws Exception {
+		runMeasurement(100_000, "100K", 1_000);
+	}
+
+
+	@Test
+	@Timeout(value = 15, unit = TimeUnit.MINUTES)
+	@DisplayName("[NO-CACHE API] 100만건 성능 측정 (인덱스만, 캐시 미적용)")
+	void measureApiNoCache_1M() throws Exception {
+		runMeasurement(1_000_000, "1M", 5_000);
+	}
+
+
+	@Test
+	@Timeout(value = 30, unit = TimeUnit.MINUTES)
+	@DisplayName("[NO-CACHE API] 1000만건 성능 측정 (인덱스만, 캐시 미적용)")
+	void measureApiNoCache_10M() throws Exception {
+		runMeasurement(10_000_000, "10M", 10_000);
+	}
+
+
+	// --- CACHE 테스트 메서드 (인덱스 + 캐시 적용, 데이터 규모별) ---
+
+	@Test
+	@Timeout(value = 5, unit = TimeUnit.MINUTES)
+	@DisplayName("[CACHE API] 10만건 성능 측정 (인덱스 + 캐시 적용)")
+	void measureApiCache_100K() throws Exception {
+		runToBeMeasurement(100_000, "100K", 1_000);
+	}
+
+
+	@Test
+	@Timeout(value = 15, unit = TimeUnit.MINUTES)
+	@DisplayName("[CACHE API] 100만건 성능 측정 (인덱스 + 캐시 적용)")
+	void measureApiCache_1M() throws Exception {
+		runToBeMeasurement(1_000_000, "1M", 5_000);
+	}
+
+
+	@Test
+	@Timeout(value = 30, unit = TimeUnit.MINUTES)
+	@DisplayName("[CACHE API] 1000만건 성능 측정 (인덱스 + 캐시 적용)")
+	void measureApiCache_10M() throws Exception {
+		runToBeMeasurement(10_000_000, "10M", 10_000);
+	}
+
+
+	// --- 핵심 측정 흐름 ---
+
+	private void runMeasurement(int productCount, String label, int batchSize) throws Exception {
+		// 결과 파일 초기화
+		try (PrintWriter pw = new PrintWriter(new FileWriter(RESULT_FILE, false))) {
+			pw.println("=== NO-CACHE API Performance Results ===");
+		} catch (IOException e) {
+			// 무시
+		}
+
+		out("\n========================================");
+		out(String.format("[%s] NO-CACHE API 성능 측정 시작 (인덱스만, 캐시 미적용, 브랜드 %d개, 상품 %d건)", label, BRAND_COUNT, productCount));
+		out("========================================");
+
+		// 1. 데이터 준비 (products + product_read_model — 앱 코드가 read_model 조회)
+		long insertStart = System.currentTimeMillis();
+		insertBulkData(productCount, batchSize);
+		insertReadModelFromProducts();
+		long insertElapsed = System.currentTimeMillis() - insertStart;
+		out(String.format("[%s] 데이터 삽입 완료: %dms", label, insertElapsed));
+
+		// ANALYZE TABLE로 MySQL 통계 업데이트
+		try (Connection conn = dataSource.getConnection();
+			 Statement stmt = conn.createStatement()) {
+			stmt.execute("ANALYZE TABLE products");
+			stmt.execute("ANALYZE TABLE brands");
+			stmt.execute("ANALYZE TABLE product_read_model");
+		}
+
+		// Redis 초기화 (캐시 미적용 상태 보장)
+		redisCleanUp.truncateAll();
+
+		// 2. API 엔드포인트 정의
+		// 목록 API — 6개 유즈케이스
+		String[][] listApis = {
+			{"목록 UC1: brandId=X, LATEST", "/api/v1/products?sort=LATEST&page=0&size=20"},
+			{"목록 UC2: brandId=X, PRICE_ASC", "/api/v1/products?sort=PRICE_ASC&page=0&size=20"},
+			{"목록 UC3: brandId=X, LIKES_DESC", "/api/v1/products?sort=LIKES_DESC&page=0&size=20"},
+			{"목록 UC4: brandId=1, LATEST", "/api/v1/products?brandId=1&sort=LATEST&page=0&size=20"},
+			{"목록 UC5: brandId=1, PRICE_ASC", "/api/v1/products?brandId=1&sort=PRICE_ASC&page=0&size=20"},
+			{"목록 UC6: brandId=1, LIKES_DESC", "/api/v1/products?brandId=1&sort=LIKES_DESC&page=0&size=20"},
+		};
+
+		// 상세 API — 상품 ID 1번 (확실히 존재하는 데이터)
+		String[][] detailApis = {
+			{"상세: productId=1", "/api/v1/products/1"},
+		};
+
+		// 3. 단일 쿼리 측정 (매 요청마다 Redis 초기화 — 캐시 미적용 보장)
+		out(String.format("\n[%s] ===== NO-CACHE API 단일 쿼리 측정 =====", label));
+		for (String[] api : listApis) {
+			measureSingleApiNoCache(label + " NO-CACHE", api[0], api[1]);
+		}
+		for (String[] api : detailApis) {
+			measureSingleApiNoCache(label + " NO-CACHE", api[0], api[1]);
+		}
+
+		// 4. 버스트 측정 (대표 UC: UC1, UC3, UC4, 상세)
+		out(String.format("\n[%s] ===== NO-CACHE API 버스트 측정 (%d건 동시) =====", label, BURST_THREADS));
+		redisCleanUp.truncateAll();
+		measureBurst(label + " NO-CACHE", listApis[0][0], listApis[0][1]);
+		redisCleanUp.truncateAll();
+		measureBurst(label + " NO-CACHE", listApis[2][0], listApis[2][1]);
+		redisCleanUp.truncateAll();
+		measureBurst(label + " NO-CACHE", listApis[3][0], listApis[3][1]);
+		redisCleanUp.truncateAll();
+		measureBurst(label + " NO-CACHE", detailApis[0][0], detailApis[0][1]);
+
+		// 5. 지속 부하 측정 (대표 UC)
+		out(String.format("\n[%s] ===== NO-CACHE API 지속 부하 측정 (%d RPS × %d초) =====", label, SUSTAINED_RPS, SUSTAINED_DURATION_SEC));
+		redisCleanUp.truncateAll();
+		measureSustainedLoad(label + " NO-CACHE", listApis[0][0], listApis[0][1]);
+		redisCleanUp.truncateAll();
+		measureSustainedLoad(label + " NO-CACHE", listApis[2][0], listApis[2][1]);
+		redisCleanUp.truncateAll();
+		measureSustainedLoad(label + " NO-CACHE", listApis[3][0], listApis[3][1]);
+		redisCleanUp.truncateAll();
+		measureSustainedLoad(label + " NO-CACHE", detailApis[0][0], detailApis[0][1]);
+
+		out(String.format("\n[%s] ===== NO-CACHE API 측정 완료 =====", label));
+	}
+
+
+	// --- CACHE 핵심 측정 흐름 (인덱스 + 캐시 적용) ---
+
+	private void runToBeMeasurement(int productCount, String label, int batchSize) throws Exception {
+		// 결과 파일 초기화
+		try (PrintWriter pw = new PrintWriter(new FileWriter(RESULT_FILE, false))) {
+			pw.println("=== CACHE API Performance Results ===");
+		} catch (IOException e) {
+			// 무시
+		}
+
+		out("\n========================================");
+		out(String.format("[%s] CACHE API 성능 측정 시작 (인덱스 + 캐시 적용, 브랜드 %d개, 상품 %d건)", label, BRAND_COUNT, productCount));
+		out("========================================");
+
+		// 1. 데이터 준비 (products + product_read_model)
+		long insertStart = System.currentTimeMillis();
+		insertBulkData(productCount, batchSize);
+		insertReadModelFromProducts();
+		long insertElapsed = System.currentTimeMillis() - insertStart;
+		out(String.format("[%s] 데이터 삽입 완료: %dms", label, insertElapsed));
+
+		// ANALYZE TABLE로 MySQL 통계 업데이트
+		try (Connection conn = dataSource.getConnection();
+			 Statement stmt = conn.createStatement()) {
+			stmt.execute("ANALYZE TABLE products");
+			stmt.execute("ANALYZE TABLE brands");
+			stmt.execute("ANALYZE TABLE product_read_model");
+		}
+
+		// 2. API 엔드포인트 정의 (NO-CACHE와 동일)
+		String[][] listApis = {
+			{"목록 UC1: brandId=X, LATEST", "/api/v1/products?sort=LATEST&page=0&size=20"},
+			{"목록 UC2: brandId=X, PRICE_ASC", "/api/v1/products?sort=PRICE_ASC&page=0&size=20"},
+			{"목록 UC3: brandId=X, LIKES_DESC", "/api/v1/products?sort=LIKES_DESC&page=0&size=20"},
+			{"목록 UC4: brandId=1, LATEST", "/api/v1/products?brandId=1&sort=LATEST&page=0&size=20"},
+			{"목록 UC5: brandId=1, PRICE_ASC", "/api/v1/products?brandId=1&sort=PRICE_ASC&page=0&size=20"},
+			{"목록 UC6: brandId=1, LIKES_DESC", "/api/v1/products?brandId=1&sort=LIKES_DESC&page=0&size=20"},
+		};
+		String[][] detailApis = {
+			{"상세: productId=1", "/api/v1/products/1"},
+		};
+
+		// 3. 캐시 미스 측정 (Redis 비운 상태에서 첫 호출)
+		out(String.format("\n[%s] ===== CACHE API 캐시 미스 측정 (첫 호출) =====", label));
+		for (String[] api : listApis) {
+			measureSingleApiMiss(label + " MISS", api[0], api[1]);
+		}
+		for (String[] api : detailApis) {
+			measureSingleApiMiss(label + " MISS", api[0], api[1]);
+		}
+
+		// 4. 캐시 히트 측정 (캐시 워밍 후 반복 호출)
+		out(String.format("\n[%s] ===== CACHE API 캐시 히트 측정 (캐시 워밍 후) =====", label));
+		for (String[] api : listApis) {
+			measureSingleApiHit(label + " HIT", api[0], api[1]);
+		}
+		for (String[] api : detailApis) {
+			measureSingleApiHit(label + " HIT", api[0], api[1]);
+		}
+
+		// 5. 버스트 측정 — 캐시 히트 상태에서 (캐시가 이미 워밍된 상태)
+		out(String.format("\n[%s] ===== CACHE API 버스트 측정 (캐시 히트, %d건 동시) =====", label, BURST_THREADS));
+		measureBurst(label + " HIT", listApis[0][0], listApis[0][1]);
+		measureBurst(label + " HIT", listApis[2][0], listApis[2][1]);
+		measureBurst(label + " HIT", listApis[3][0], listApis[3][1]);
+		measureBurst(label + " HIT", detailApis[0][0], detailApis[0][1]);
+
+		// 6. 버스트 측정 — 캐시 미스 상태에서 (스탬피드 보호 검증)
+		out(String.format("\n[%s] ===== CACHE API 버스트 측정 (캐시 미스 — 스탬피드 보호, %d건 동시) =====", label, BURST_THREADS));
+		redisCleanUp.truncateAll();
+		measureBurst(label + " MISS", listApis[0][0], listApis[0][1]);
+		redisCleanUp.truncateAll();
+		measureBurst(label + " MISS", detailApis[0][0], detailApis[0][1]);
+
+		// 7. 지속 부하 측정 — 캐시 히트 상태
+		out(String.format("\n[%s] ===== CACHE API 지속 부하 측정 (캐시 히트, %d RPS × %d초) =====", label, SUSTAINED_RPS, SUSTAINED_DURATION_SEC));
+		// 캐시 워밍 (지속 부하 대표 UC)
+		executeSuccessfulRequest(listApis[0][1]);
+		executeSuccessfulRequest(listApis[2][1]);
+		executeSuccessfulRequest(listApis[3][1]);
+		executeSuccessfulRequest(detailApis[0][1]);
+		measureSustainedLoad(label + " HIT", listApis[0][0], listApis[0][1]);
+		measureSustainedLoad(label + " HIT", listApis[2][0], listApis[2][1]);
+		measureSustainedLoad(label + " HIT", listApis[3][0], listApis[3][1]);
+		measureSustainedLoad(label + " HIT", detailApis[0][0], detailApis[0][1]);
+
+		out(String.format("\n[%s] ===== CACHE API 측정 완료 =====", label));
+	}
+
+
+	// --- 단일 API 측정 (NO-CACHE: 매 요청마다 Redis 초기화) ---
+
+	private void measureSingleApiNoCache(String dataLabel, String ucLabel, String url) throws Exception {
+		// Warmup (3회) — Spring 컨텍스트/JPA 세션/커넥션 풀 안정화
+		for (int w = 0; w < 3; w++) {
+			executeSuccessfulRequest(url);
+		}
+
+		// 실행시간 측정 (5회, 매 요청 전 Redis 초기화)
+		int runs = 5;
+		long[] times = new long[runs];
+		for (int i = 0; i < runs; i++) {
+			redisCleanUp.truncateAll();
+			times[i] = measureRequestLatency(url);
+		}
+
+		long sum = 0, min = Long.MAX_VALUE, max = Long.MIN_VALUE;
+		for (long t : times) {
+			sum += t;
+			min = Math.min(min, t);
+			max = Math.max(max, t);
+		}
+
+		out(String.format("[%s] [API 단일] %s — avg=%sms, min=%sms, max=%sms",
+			dataLabel, ucLabel,
+			String.format("%.2f", sum / (double) runs / 1_000_000.0),
+			String.format("%.2f", min / 1_000_000.0),
+			String.format("%.2f", max / 1_000_000.0)));
+	}
+
+
+	// --- 단일 API 측정 (CACHE: warmup 후 캐시 히트 상태) ---
+
+	private void measureSingleApiHit(String dataLabel, String ucLabel, String url) throws Exception {
+		redisCleanUp.truncateAll();
+		executeSuccessfulRequest(url);
+
+		for (int w = 0; w < 3; w++) {
+			executeSuccessfulRequest(url);
+		}
+
+		int runs = 5;
+		long[] times = new long[runs];
+		for (int i = 0; i < runs; i++) {
+			times[i] = measureRequestLatency(url);
+		}
+
+		long sum = 0, min = Long.MAX_VALUE, max = Long.MIN_VALUE;
+		for (long t : times) {
+			sum += t;
+			min = Math.min(min, t);
+			max = Math.max(max, t);
+		}
+
+		out(String.format("[%s] [API 단일] %s — avg=%sms, min=%sms, max=%sms",
+			dataLabel, ucLabel,
+			String.format("%.2f", sum / (double) runs / 1_000_000.0),
+			String.format("%.2f", min / 1_000_000.0),
+			String.format("%.2f", max / 1_000_000.0)));
+	}
+
+
+	private void measureSingleApiMiss(String dataLabel, String ucLabel, String url) throws Exception {
+		for (int w = 0; w < 3; w++) {
+			redisCleanUp.truncateAll();
+			executeSuccessfulRequest(url);
+		}
+
+		int runs = 5;
+		long[] times = new long[runs];
+		for (int i = 0; i < runs; i++) {
+			redisCleanUp.truncateAll();
+			times[i] = measureRequestLatency(url);
+		}
+
+		long sum = 0, min = Long.MAX_VALUE, max = Long.MIN_VALUE;
+		for (long t : times) {
+			sum += t;
+			min = Math.min(min, t);
+			max = Math.max(max, t);
+		}
+
+		out(String.format("[%s] [API 단일] %s — avg=%sms, min=%sms, max=%sms",
+			dataLabel, ucLabel,
+			String.format("%.2f", sum / (double) runs / 1_000_000.0),
+			String.format("%.2f", min / 1_000_000.0),
+			String.format("%.2f", max / 1_000_000.0)));
+	}
+
+
+	// --- 버스트 측정 (N개 동시 요청) ---
+
+	private void measureBurst(String dataLabel, String ucLabel, String url) throws Exception {
+		ExecutorService executor = Executors.newFixedThreadPool(BURST_THREADS);
+		CountDownLatch ready = new CountDownLatch(BURST_THREADS);
+		CountDownLatch go = new CountDownLatch(1);
+		long[] latencies = new long[BURST_THREADS];
+		AtomicInteger errors = new AtomicInteger(0);
+
+		for (int i = 0; i < BURST_THREADS; i++) {
+			final int idx = i;
+			executor.submit(() -> {
+				ready.countDown();
+				try {
+					go.await();
+					latencies[idx] = measureRequestLatency(url);
+				} catch (Exception e) {
+					errors.incrementAndGet();
+					latencies[idx] = -1;
+				}
+			});
+		}
+
+		ready.await();
+		go.countDown();
+
+		executor.shutdown();
+		executor.awaitTermination(5, TimeUnit.MINUTES);
+
+		long[] valid = Arrays.stream(latencies).filter(l -> l > 0).sorted().toArray();
+		if (valid.length > 0) {
+			out(String.format("[%s] [API 버스트] %s — 완료: %d/%d, 에러: %d, avg=%sms, p50=%sms, p95=%sms, p99=%sms, max=%sms",
+				dataLabel, ucLabel,
+				valid.length, BURST_THREADS, errors.get(),
+				String.format("%.2f", avg(valid)),
+				String.format("%.2f", percentile(valid, 50)),
+				String.format("%.2f", percentile(valid, 95)),
+				String.format("%.2f", percentile(valid, 99)),
+				String.format("%.2f", valid[valid.length - 1] / 1_000_000.0)));
+		} else {
+			out(String.format("[%s] [API 버스트] %s — 전체 실패 (에러: %d)", dataLabel, ucLabel, errors.get()));
+		}
+	}
+
+
+	// --- 지속 부하 측정 (N RPS × T초) ---
+
+	private void measureSustainedLoad(String dataLabel, String ucLabel, String url) throws Exception {
+		int totalRequests = SUSTAINED_RPS * SUSTAINED_DURATION_SEC;
+		long intervalMs = 1000 / SUSTAINED_RPS;
+
+		ExecutorService executor = Executors.newFixedThreadPool(SUSTAINED_RPS * 2);
+		List<Long> latencies = Collections.synchronizedList(new ArrayList<>());
+		AtomicInteger errors = new AtomicInteger(0);
+
+		long testStart = System.nanoTime();
+
+		for (int i = 0; i < totalRequests; i++) {
+			executor.submit(() -> {
+				long start = System.nanoTime();
+				try {
+					executeSuccessfulRequest(url);
+					latencies.add(System.nanoTime() - start);
+				} catch (Exception e) {
+					errors.incrementAndGet();
+				}
+			});
+
+			// Rate limiting
+			long elapsed = (System.nanoTime() - testStart) / 1_000_000;
+			long expected = (long) (i + 1) * intervalMs;
+			long sleepMs = expected - elapsed;
+			if (sleepMs > 0) {
+				Thread.sleep(sleepMs);
+			}
+		}
+
+		executor.shutdown();
+		boolean finished = executor.awaitTermination(5, TimeUnit.MINUTES);
+
+		long totalTimeMs = (System.nanoTime() - testStart) / 1_000_000;
+
+		long[] sorted = latencies.stream().mapToLong(l -> l).sorted().toArray();
+		if (sorted.length > 0) {
+			double actualQps = (double) sorted.length / totalTimeMs * 1000;
+			out(String.format("[%s] [API 지속부하] %s — 완료: %d/%d, 에러: %d, 실제QPS: %s, avg=%sms, p50=%sms, p95=%sms, p99=%sms, 총시간=%dms%s",
+				dataLabel, ucLabel,
+				sorted.length, totalRequests, errors.get(),
+				String.format("%.1f", actualQps),
+				String.format("%.2f", avg(sorted)),
+				String.format("%.2f", percentile(sorted, 50)),
+				String.format("%.2f", percentile(sorted, 95)),
+				String.format("%.2f", percentile(sorted, 99)),
+				totalTimeMs,
+				finished ? "" : " [TIMEOUT — 일부 미완료]"));
+		} else {
+			out(String.format("[%s] [API 지속부하] %s — 전체 실패 (에러: %d)", dataLabel, ucLabel, errors.get()));
+		}
+	}
+
+
+	private long measureRequestLatency(String url) throws Exception {
+		long start = System.nanoTime();
+		executeSuccessfulRequest(url);
+		return System.nanoTime() - start;
+	}
+
+
+	private void executeSuccessfulRequest(String url) throws Exception {
+		MvcResult result = mockMvc.perform(get(url)).andReturn();
+		int status = result.getResponse().getStatus();
+		if (status < 200 || status >= 300) {
+			throw new IllegalStateException("Unexpected status: " + status + " for url=" + url);
+		}
+	}
+
+
+	// --- 파일 출력 유틸 ---
+
+	private void out(String msg) {
+		log.info(msg);
+		try (PrintWriter pw = new PrintWriter(new FileWriter(RESULT_FILE, true))) {
+			pw.println(msg);
+			pw.flush();
+		} catch (IOException e) {
+			// 무시
+		}
+	}
+
+
+	// --- 통계 유틸 ---
+
+	private double avg(long[] sorted) {
+		long sum = 0;
+		for (long v : sorted) sum += v;
+		return sum / (double) sorted.length / 1_000_000.0;
+	}
+
+	private double percentile(long[] sorted, double p) {
+		int index = (int) Math.ceil(p / 100.0 * sorted.length) - 1;
+		return sorted[Math.max(0, Math.min(index, sorted.length - 1))] / 1_000_000.0;
+	}
+
+
+	// --- 데이터 삽입 ---
+
+	// SQL batch INSERT 배치 크기 (한 INSERT 문에 포함되는 VALUES 행 수)
+	private static final int SQL_BATCH_SIZE = 2_000;
+	// 커밋 간격 (redo log 고갈 방지)
+	private static final int COMMIT_INTERVAL = 10_000;
+
+	/**
+	 * SQL multi-row INSERT로 대량 데이터 삽입
+	 * - products 테이블은 세컨더리 인덱스 없음 (AS-IS) → 인덱스 관리 불필요
+	 * - multi-row INSERT: 한 문장에 2000행씩 묶어 네트워크 라운드트립 최소화
+	 * - 10,000행마다 COMMIT: MySQL redo log 고갈 방지
+	 */
+	private void insertBulkData(int productCount, int batchSize) throws Exception {
+		try (Connection conn = dataSource.getConnection()) {
+			conn.setAutoCommit(false);
+
+			// 1. 브랜드 50개 (소량이므로 단일 multi-row INSERT)
+			try (Statement stmt = conn.createStatement()) {
+				StringBuilder sb = new StringBuilder();
+				sb.append("INSERT INTO brands (name, description, visible_status, created_at, updated_at) VALUES ");
+				Timestamp now = Timestamp.from(Instant.now());
+				String nowStr = now.toString();
+				for (int i = 1; i <= BRAND_COUNT; i++) {
+					if (i > 1) sb.append(',');
+					sb.append("('Brand_").append(i).append("','Brand description ").append(i)
+						.append("','VISIBLE','").append(nowStr).append("','").append(nowStr).append("')");
+				}
+				stmt.executeUpdate(sb.toString());
+				conn.commit();
+			}
+
+			// 2. 상품 N건 — multi-row INSERT (products는 세컨더리 인덱스 없음)
+			try (Statement stmt = conn.createStatement()) {
+				ThreadLocalRandom rng = ThreadLocalRandom.current();
+				Instant baseTime = Instant.now();
+				int totalInserted = 0;
+
+				for (int offset = 0; offset < productCount; offset += SQL_BATCH_SIZE) {
+					int end = Math.min(offset + SQL_BATCH_SIZE, productCount);
+					StringBuilder sb = new StringBuilder();
+					sb.append("INSERT INTO products (brand_id, name, price, stock, description, created_at, updated_at) VALUES ");
+
+					for (int i = offset; i < end; i++) {
+						if (i > offset) sb.append(',');
+						long brandId = rng.nextLong(1, BRAND_COUNT + 1);
+						long price = rng.nextLong(1_000, 100_001);
+						long stock = rng.nextLong(0, 1_001);
+						Instant createdAt = baseTime.minus(rng.nextLong(0, 365), ChronoUnit.DAYS);
+						String ts = Timestamp.from(createdAt).toString();
+
+						sb.append('(')
+							.append(brandId).append(",'Product_").append(i)
+							.append("',").append(price)
+							.append(',').append(stock)
+							.append(",'Description for product ").append(i)
+							.append("','").append(ts).append("','").append(ts).append("')");
+					}
+
+					stmt.executeUpdate(sb.toString());
+					totalInserted += (end - offset);
+
+					// redo log 고갈 방지: COMMIT_INTERVAL마다 커밋
+					if (totalInserted % COMMIT_INTERVAL == 0) {
+						conn.commit();
+					}
+
+					if (totalInserted % 100_000 == 0) {
+						log.info("  [INSERT] {}건 완료...", totalInserted);
+					}
+				}
+
+				// 잔여 트랜잭션 커밋
+				conn.commit();
+			}
+		}
+	}
+
+
+	/**
+	 * products + brands 조인 결과를 product_read_model 테이블에 삽입
+	 * - DROP INDEX → INSERT → CREATE INDEX (InnoDB 최적 패턴)
+	 *   - DISABLE/ENABLE KEYS는 MyISAM 전용이므로 InnoDB에서는 효과 없음
+	 *   - 12개 세컨더리 인덱스를 먼저 제거하고, 데이터 삽입 후 일괄 재생성
+	 * - TO-BE API는 product_read_model을 조회하므로 데이터 준비 필요
+	 */
+	private void insertReadModelFromProducts() throws Exception {
+		try (Connection conn = dataSource.getConnection();
+			 Statement stmt = conn.createStatement()) {
+
+			// 세컨더리 인덱스 제거 (InnoDB: INSERT 중 인덱스 유지 비용 제거)
+			dropReadModelIndexes(stmt);
+
+			// 데이터 삽입 (인덱스 없이 순수 INSERT)
+			stmt.executeUpdate(
+				"INSERT INTO product_read_model (id, brand_id, brand_name, name, price, stock, description, like_count, created_at, updated_at) " +
+				"SELECT p.id, p.brand_id, b.name, p.name, p.price, p.stock, p.description, FLOOR(RAND() * 10001), p.created_at, p.updated_at " +
+				"FROM products p LEFT JOIN brands b ON b.id = p.brand_id"
+			);
+
+			// 인덱스 일괄 재생성 (단일 패스로 B-tree 구축)
+			createReadModelIndexes(stmt);
+		}
+	}
+
+
+	/**
+	 * product_read_model 세컨더리 인덱스 12개 제거
+	 * - PK는 유지 (InnoDB clustered index)
+	 */
+	private void dropReadModelIndexes(Statement stmt) throws SQLException {
+		String[] indexes = {
+			"idx_read_brand_deleted_created", "idx_read_brand_deleted_price", "idx_read_brand_deleted_likecount",
+			"idx_read_deleted_created", "idx_read_deleted_price", "idx_read_deleted_likecount",
+			"idx_read_brand_created", "idx_read_brand_price", "idx_read_brand_likecount",
+			"idx_read_created", "idx_read_price", "idx_read_likecount"
+		};
+		for (String idx : indexes) {
+			stmt.execute("DROP INDEX " + idx + " ON product_read_model");
+		}
+	}
+
+
+	/**
+	 * product_read_model 세컨더리 인덱스 12개 재생성
+	 * - ProductReadModelEntity @Table(indexes) 정의와 동일
+	 */
+	private void createReadModelIndexes(Statement stmt) throws SQLException {
+		String[] ddls = {
+			// 사용자 조회 (브랜드 지정): WHERE brand_id = ? AND deleted_at IS NULL ORDER BY {sort_col}
+			"CREATE INDEX idx_read_brand_deleted_created ON product_read_model (brand_id, deleted_at, created_at)",
+			"CREATE INDEX idx_read_brand_deleted_price ON product_read_model (brand_id, deleted_at, price)",
+			"CREATE INDEX idx_read_brand_deleted_likecount ON product_read_model (brand_id, deleted_at, like_count)",
+			// 사용자 조회 (브랜드 미지정): WHERE deleted_at IS NULL ORDER BY {sort_col}
+			"CREATE INDEX idx_read_deleted_created ON product_read_model (deleted_at, created_at)",
+			"CREATE INDEX idx_read_deleted_price ON product_read_model (deleted_at, price)",
+			"CREATE INDEX idx_read_deleted_likecount ON product_read_model (deleted_at, like_count)",
+			// 관리자 조회 (브랜드 지정): WHERE brand_id = ? ORDER BY {sort_col}
+			"CREATE INDEX idx_read_brand_created ON product_read_model (brand_id, created_at)",
+			"CREATE INDEX idx_read_brand_price ON product_read_model (brand_id, price)",
+			"CREATE INDEX idx_read_brand_likecount ON product_read_model (brand_id, like_count)",
+			// 관리자 조회 (필터 없음): ORDER BY {sort_col}
+			"CREATE INDEX idx_read_created ON product_read_model (created_at)",
+			"CREATE INDEX idx_read_price ON product_read_model (price)",
+			"CREATE INDEX idx_read_likecount ON product_read_model (like_count)"
+		};
+		for (String ddl : ddls) {
+			stmt.execute(ddl);
+		}
+	}
+
+}
diff --git a/apps/commerce-api/src/benchmark/java/com/loopers/catalog/product/infrastructure/ProductIndexPerformanceTest.java b/apps/commerce-api/src/benchmark/java/com/loopers/catalog/product/infrastructure/ProductIndexPerformanceTest.java
new file mode 100644
index 000000000..a2fc12a52
--- /dev/null
+++ b/apps/commerce-api/src/benchmark/java/com/loopers/catalog/product/infrastructure/ProductIndexPerformanceTest.java
@@ -0,0 +1,941 @@
+package com.loopers.catalog.product.infrastructure;
+
+
+import com.loopers.testcontainers.MySqlTestContainersConfig;
+import com.loopers.testcontainers.RedisTestContainersConfig;
+import com.loopers.utils.DatabaseCleanUp;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.Timeout;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.context.annotation.Import;
+import org.springframework.test.context.ActiveProfiles;
+
+import javax.sql.DataSource;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.math.BigDecimal;
+import java.math.RoundingMode;
+import java.sql.*;
+import java.time.Instant;
+import java.time.temporal.ChronoUnit;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.concurrent.*;
+import java.util.concurrent.atomic.AtomicInteger;
+
+
+/**
+ * 상품 인덱스 성능 측정 (AS-IS / TO-BE)
+ *
+ * <p>AS-IS: products 테이블 (PK 외 인덱스 없음) + LEFT JOIN brands + LEFT JOIN likes (LIKES_DESC)
+ * <p>TO-BE: product_read_model 테이블 (복합 인덱스) + 단일 테이블 SELECT (JOIN 제거, like_count 비정규화)
+ *
+ * <p>측정 축: 데이터 규모(10만/100만/1000만) × 트래픽 유형(단일쿼리/버스트/지속부하)
+ *
+ * <p>1. 단일 쿼리: 6개 유즈케이스 EXPLAIN + 실행시간 (warmup 3회 + 측정 5회 평균)
+ * <p>2. 버스트: 100 concurrent 동시 요청 → p50/p95/p99
+ * <p>3. 지속 부하: 20 RPS × 10초 → 처리량 + p50/p95/p99
+ */
+@SpringBootTest
+@ActiveProfiles("test")
+@Import({MySqlTestContainersConfig.class, RedisTestContainersConfig.class})
+@DisplayName("상품 인덱스 성능 측정")
+class ProductIndexPerformanceTest {
+
+	private static final Logger log = LoggerFactory.getLogger(ProductIndexPerformanceTest.class);
+	private static final String RESULT_FILE = "/tmp/index-perf-results.txt";
+	private static final int BRAND_COUNT = 50;
+
+	// 버스트 파라미터
+	private static final int BURST_THREADS = 100;
+
+	// 지속 부하 파라미터
+	private static final int SUSTAINED_RPS = 20;
+	private static final int SUSTAINED_DURATION_SEC = 10;
+
+	@Autowired
+	private DataSource dataSource;
+
+	@Autowired
+	private DatabaseCleanUp databaseCleanUp;
+
+
+	// 로그 + 파일 동시 출력 (Gradle 버퍼링 우회)
+	private void out(String msg) {
+		log.info(msg);
+		try (PrintWriter pw = new PrintWriter(new FileWriter(RESULT_FILE, true))) {
+			pw.println(msg);
+			pw.flush();
+		} catch (IOException e) {
+			// 무시
+		}
+	}
+
+
+	@AfterEach
+	void tearDown() {
+		databaseCleanUp.truncateAllTables();
+	}
+
+
+	// --- 테스트 메서드 (데이터 규모별) ---
+
+	@Test
+	@Timeout(value = 5, unit = TimeUnit.MINUTES)
+	@DisplayName("[AS-IS] 10만건 성능 측정 (단일쿼리 + 버스트 + 지속부하)")
+	void measureAsIs_100K() throws Exception {
+		runMeasurement(100_000, "100K", 1_000);
+	}
+
+
+	@Test
+	@Timeout(value = 15, unit = TimeUnit.MINUTES)
+	@DisplayName("[AS-IS] 100만건 성능 측정 (단일쿼리 + 버스트 + 지속부하)")
+	void measureAsIs_1M() throws Exception {
+		runMeasurement(1_000_000, "1M", 5_000);
+	}
+
+
+	@Test
+	@Timeout(value = 30, unit = TimeUnit.MINUTES)
+	@DisplayName("[AS-IS] 1000만건 성능 측정 (단일쿼리 + 버스트 + 지속부하)")
+	void measureAsIs_10M() throws Exception {
+		runMeasurement(10_000_000, "10M", 10_000);
+	}
+
+
+	// --- TO-BE 테스트 메서드 (Read Model + 복합 인덱스) ---
+
+	@Test
+	@Timeout(value = 5, unit = TimeUnit.MINUTES)
+	@DisplayName("[TO-BE] 10만건 성능 측정 (Read Model + 복합 인덱스)")
+	void measureToBe_100K() throws Exception {
+		runToMeasurement(100_000, "100K", 1_000);
+	}
+
+
+	@Test
+	@Timeout(value = 15, unit = TimeUnit.MINUTES)
+	@DisplayName("[TO-BE] 100만건 성능 측정 (Read Model + 복합 인덱스)")
+	void measureToBe_1M() throws Exception {
+		runToMeasurement(1_000_000, "1M", 5_000);
+	}
+
+
+	@Test
+	@Timeout(value = 30, unit = TimeUnit.MINUTES)
+	@DisplayName("[TO-BE] 1000만건 성능 측정 (Read Model + 복합 인덱스)")
+	void measureToBe_10M() throws Exception {
+		runToMeasurement(10_000_000, "10M", 10_000);
+	}
+
+
+	// --- 핵심 측정 흐름 ---
+
+	private void runMeasurement(int productCount, String label, int batchSize) throws Exception {
+		log.info("\n========================================");
+		log.info("[{}] AS-IS 성능 측정 시작 (브랜드 {}개, 상품 {}건)", label, BRAND_COUNT, productCount);
+		log.info("========================================");
+
+		// 1. 데이터 준비 (brands + products + product_likes)
+		long insertStart = System.currentTimeMillis();
+		insertBulkData(productCount, batchSize);
+		insertBulkLikes(productCount);
+		long insertElapsed = System.currentTimeMillis() - insertStart;
+		log.info("[{}] 데이터 삽입 완료: {}ms", label, insertElapsed);
+
+		// ANALYZE TABLE로 MySQL 통계 업데이트 (EXPLAIN 정확도 향상)
+		try (Connection conn = dataSource.getConnection();
+			 Statement stmt = conn.createStatement()) {
+			stmt.execute("ANALYZE TABLE products");
+			stmt.execute("ANALYZE TABLE brands");
+			stmt.execute("ANALYZE TABLE likes");
+		}
+
+		// 2. 인덱스 현황
+		log.info("\n[{}] ----- 현재 인덱스 -----", label);
+		logIndexes("products");
+
+		// 3. 데이터 분포
+		log.info("\n[{}] ----- 데이터 분포 -----", label);
+		logDataDistribution();
+
+		// 4. 쿼리 정의
+		String baseSelect = "SELECT p.id, p.brand_id, b.name AS brand_name, p.name, p.price, p.stock "
+			+ "FROM products p LEFT JOIN brands b ON b.id = p.brand_id ";
+
+		// AS-IS LIKES_DESC: Read Model 도입 전 좋아요 순 정렬은 likes 테이블을 JOIN + GROUP BY + COUNT해야 함
+		String likesSelect = "SELECT p.id, p.brand_id, b.name AS brand_name, p.name, p.price, p.stock, COUNT(l.id) AS like_count "
+			+ "FROM products p LEFT JOIN brands b ON b.id = p.brand_id "
+			+ "LEFT JOIN likes l ON l.target_type = 'PRODUCT' AND l.target_id = p.id ";
+
+		String[][] queries = {
+			{"UC1: brandId=X, LATEST", baseSelect + "WHERE p.deleted_at IS NULL ORDER BY p.created_at DESC LIMIT 20"},
+			{"UC2: brandId=X, PRICE_ASC", baseSelect + "WHERE p.deleted_at IS NULL ORDER BY p.price ASC LIMIT 20"},
+			{"UC3: brandId=X, LIKES_DESC", likesSelect + "WHERE p.deleted_at IS NULL GROUP BY p.id ORDER BY like_count DESC LIMIT 20"},
+			{"UC4: brandId=1, LATEST", baseSelect + "WHERE p.deleted_at IS NULL AND p.brand_id = 1 ORDER BY p.created_at DESC LIMIT 20"},
+			{"UC5: brandId=1, PRICE_ASC", baseSelect + "WHERE p.deleted_at IS NULL AND p.brand_id = 1 ORDER BY p.price ASC LIMIT 20"},
+			{"UC6: brandId=1, LIKES_DESC", likesSelect + "WHERE p.deleted_at IS NULL AND p.brand_id = 1 GROUP BY p.id ORDER BY like_count DESC LIMIT 20"},
+		};
+		String[][] countQueries = {
+			{"COUNT: brandId=X", "SELECT COUNT(*) FROM products WHERE deleted_at IS NULL"},
+			{"COUNT: brandId=1", "SELECT COUNT(*) FROM products WHERE deleted_at IS NULL AND brand_id = 1"},
+		};
+
+		// 5. 단일 쿼리 측정 (EXPLAIN + 실행시간)
+		log.info("\n[{}] ===== 단일 쿼리 측정 =====", label);
+		for (String[] q : queries) {
+			measureSingleQuery(label, q[0], q[1]);
+		}
+		for (String[] q : countQueries) {
+			measureSingleQuery(label, q[0], q[1]);
+		}
+
+		// 6. 버스트 측정 (대표 UC: UC1 no-brand latest, UC3 no-brand likes, UC4 brand latest)
+		log.info("\n[{}] ===== 버스트 측정 ({}건 동시) =====", label, BURST_THREADS);
+		measureBurst(label, queries[0][0], queries[0][1]);
+		measureBurst(label, queries[2][0], queries[2][1]);
+		measureBurst(label, queries[3][0], queries[3][1]);
+
+		// 7. 지속 부하 측정 (대표 UC)
+		log.info("\n[{}] ===== 지속 부하 측정 ({} RPS × {}초) =====", label, SUSTAINED_RPS, SUSTAINED_DURATION_SEC);
+		measureSustainedLoad(label, queries[0][0], queries[0][1]);
+		measureSustainedLoad(label, queries[2][0], queries[2][1]);
+		measureSustainedLoad(label, queries[3][0], queries[3][1]);
+
+		log.info("\n[{}] ===== AS-IS 측정 완료 =====", label);
+	}
+
+
+	/**
+	 * TO-BE 핵심 측정 흐름
+	 * - product_read_model 테이블 생성 (복합 인덱스 포함)
+	 * - brands + products + product_read_model 데이터 삽입
+	 * - 단일 테이블 SELECT (JOIN 없음) 6개 유즈케이스 측정
+	 */
+	private void runToMeasurement(int productCount, String label, int batchSize) throws Exception {
+		// 결과 파일 초기화
+		try (PrintWriter pw = new PrintWriter(new FileWriter(RESULT_FILE, false))) {
+			pw.println("=== TO-BE Index Performance Results ===");
+		}
+
+		out("\n========================================");
+		out(String.format("[%s] TO-BE 성능 측정 시작 (브랜드 %d개, 상품 %d건, Read Model + 복합 인덱스)", label, BRAND_COUNT, productCount));
+		out("========================================");
+
+		// 1. 데이터 준비 (brands + products + product_read_model)
+		long insertStart = System.currentTimeMillis();
+		insertBulkDataWithReadModel(productCount, batchSize);
+		long insertElapsed = System.currentTimeMillis() - insertStart;
+		out(String.format("[%s] TO-BE 데이터 삽입 완료: %dms", label, insertElapsed));
+
+		// ANALYZE TABLE로 MySQL 통계 업데이트 (EXPLAIN 정확도 향상)
+		try (Connection conn = dataSource.getConnection();
+			 Statement stmt = conn.createStatement()) {
+			stmt.execute("ANALYZE TABLE products");
+			stmt.execute("ANALYZE TABLE brands");
+			stmt.execute("ANALYZE TABLE product_read_model");
+		}
+
+		// 2. 인덱스 현황
+		out(String.format("\n[%s] ----- TO-BE 현재 인덱스 (product_read_model) -----", label));
+		logIndexesToFile("product_read_model");
+
+		// 3. 데이터 분포
+		out(String.format("\n[%s] ----- TO-BE 데이터 분포 (product_read_model) -----", label));
+		logReadModelDataDistributionToFile();
+
+		// 4. 쿼리 정의 (단일 테이블, JOIN 없음)
+		String baseSelect = "SELECT id, brand_id, brand_name, name, price, stock, like_count "
+			+ "FROM product_read_model ";
+
+		String[][] queries = {
+			{"UC1: brandId=X, LATEST", baseSelect + "WHERE deleted_at IS NULL ORDER BY created_at DESC LIMIT 20"},
+			{"UC2: brandId=X, PRICE_ASC", baseSelect + "WHERE deleted_at IS NULL ORDER BY price ASC LIMIT 20"},
+			{"UC3: brandId=X, LIKES_DESC", baseSelect + "WHERE deleted_at IS NULL ORDER BY like_count DESC LIMIT 20"},
+			{"UC4: brandId=1, LATEST", baseSelect + "WHERE deleted_at IS NULL AND brand_id = 1 ORDER BY created_at DESC LIMIT 20"},
+			{"UC5: brandId=1, PRICE_ASC", baseSelect + "WHERE deleted_at IS NULL AND brand_id = 1 ORDER BY price ASC LIMIT 20"},
+			{"UC6: brandId=1, LIKES_DESC", baseSelect + "WHERE deleted_at IS NULL AND brand_id = 1 ORDER BY like_count DESC LIMIT 20"},
+		};
+		String[][] countQueries = {
+			{"COUNT: brandId=X", "SELECT COUNT(*) FROM product_read_model WHERE deleted_at IS NULL"},
+			{"COUNT: brandId=1", "SELECT COUNT(*) FROM product_read_model WHERE deleted_at IS NULL AND brand_id = 1"},
+		};
+
+		// 5. 단일 쿼리 측정 (EXPLAIN + 실행시간)
+		out(String.format("\n[%s] ===== TO-BE 단일 쿼리 측정 =====", label));
+		for (String[] q : queries) {
+			measureSingleQueryToFile(label, q[0], q[1]);
+		}
+		for (String[] q : countQueries) {
+			measureSingleQueryToFile(label, q[0], q[1]);
+		}
+
+		// 6. 버스트 측정 (대표 UC: UC1 no-brand latest, UC3 no-brand likes, UC4 brand latest)
+		out(String.format("\n[%s] ===== TO-BE 버스트 측정 (%d건 동시) =====", label, BURST_THREADS));
+		measureBurstToFile(label, queries[0][0], queries[0][1]);
+		measureBurstToFile(label, queries[2][0], queries[2][1]);
+		measureBurstToFile(label, queries[3][0], queries[3][1]);
+
+		// 7. 지속 부하 측정 (대표 UC)
+		out(String.format("\n[%s] ===== TO-BE 지속 부하 측정 (%d RPS × %d초) =====", label, SUSTAINED_RPS, SUSTAINED_DURATION_SEC));
+		measureSustainedLoadToFile(label, queries[0][0], queries[0][1]);
+		measureSustainedLoadToFile(label, queries[2][0], queries[2][1]);
+		measureSustainedLoadToFile(label, queries[3][0], queries[3][1]);
+
+		out(String.format("\n[%s] ===== TO-BE 측정 완료 =====", label));
+	}
+
+
+	// --- 단일 쿼리 측정 ---
+
+	private void measureSingleQuery(String dataLabel, String ucLabel, String sql) throws Exception {
+		try (Connection conn = dataSource.getConnection();
+			 Statement stmt = conn.createStatement()) {
+
+			// EXPLAIN
+			try (ResultSet rs = stmt.executeQuery("EXPLAIN " + sql)) {
+				while (rs.next()) {
+					log.info("[{}] [EXPLAIN] {} — table={}, type={}, key={}, rows={}, filtered={}, Extra={}",
+						dataLabel, ucLabel,
+						rs.getString("table"),
+						rs.getString("type"),
+						rs.getString("key"),
+						rs.getString("rows"),
+						rs.getString("filtered"),
+						rs.getString("Extra"));
+				}
+			}
+
+			// Warmup (3회) — 버퍼 풀/JIT/커넥션 풀 안정화
+			for (int w = 0; w < 3; w++) {
+				try (ResultSet rs = stmt.executeQuery(sql)) {
+					while (rs.next()) {
+					}
+				}
+			}
+
+			// 실행시간 측정 (5회)
+			int runs = 5;
+			long[] times = new long[runs];
+			for (int i = 0; i < runs; i++) {
+				long start = System.nanoTime();
+				try (ResultSet rs = stmt.executeQuery(sql)) {
+					while (rs.next()) {
+					}
+				}
+				times[i] = System.nanoTime() - start;
+			}
+
+			long sum = 0, min = Long.MAX_VALUE, max = Long.MIN_VALUE;
+			for (long t : times) {
+				sum += t;
+				min = Math.min(min, t);
+				max = Math.max(max, t);
+			}
+
+			log.info("[{}] [단일쿼리] {} — avg={}ms, min={}ms, max={}ms",
+				dataLabel, ucLabel,
+				String.format("%.2f", sum / (double) runs / 1_000_000.0),
+				String.format("%.2f", min / 1_000_000.0),
+				String.format("%.2f", max / 1_000_000.0));
+		}
+	}
+
+
+	// --- 버스트 측정 (N개 동시 요청) ---
+
+	private void measureBurst(String dataLabel, String ucLabel, String sql) throws Exception {
+		ExecutorService executor = Executors.newFixedThreadPool(BURST_THREADS);
+		CountDownLatch ready = new CountDownLatch(BURST_THREADS);
+		CountDownLatch go = new CountDownLatch(1);
+		long[] latencies = new long[BURST_THREADS];
+		AtomicInteger errors = new AtomicInteger(0);
+
+		// 모든 스레드 준비 후 일제히 시작
+		for (int i = 0; i < BURST_THREADS; i++) {
+			final int idx = i;
+			executor.submit(() -> {
+				ready.countDown();
+				try {
+					go.await();
+					long start = System.nanoTime();
+					try (Connection conn = dataSource.getConnection();
+						 Statement stmt = conn.createStatement();
+						 ResultSet rs = stmt.executeQuery(sql)) {
+						while (rs.next()) {
+						}
+					}
+					latencies[idx] = System.nanoTime() - start;
+				} catch (Exception e) {
+					errors.incrementAndGet();
+					latencies[idx] = -1;
+				}
+			});
+		}
+
+		ready.await();
+		go.countDown();
+
+		executor.shutdown();
+		executor.awaitTermination(5, TimeUnit.MINUTES);
+
+		// 에러 제외, 정렬
+		long[] valid = Arrays.stream(latencies).filter(l -> l > 0).sorted().toArray();
+		if (valid.length > 0) {
+			log.info("[{}] [버스트] {} — 완료: {}/{}, 에러: {}, avg={}ms, p50={}ms, p95={}ms, p99={}ms, max={}ms",
+				dataLabel, ucLabel,
+				valid.length, BURST_THREADS, errors.get(),
+				String.format("%.2f", avg(valid)),
+				String.format("%.2f", percentile(valid, 50)),
+				String.format("%.2f", percentile(valid, 95)),
+				String.format("%.2f", percentile(valid, 99)),
+				String.format("%.2f", valid[valid.length - 1] / 1_000_000.0));
+		} else {
+			log.warn("[{}] [버스트] {} — 전체 실패 (에러: {})", dataLabel, ucLabel, errors.get());
+		}
+	}
+
+
+	// --- 지속 부하 측정 (N RPS × T초) ---
+
+	private void measureSustainedLoad(String dataLabel, String ucLabel, String sql) throws Exception {
+		int totalRequests = SUSTAINED_RPS * SUSTAINED_DURATION_SEC;
+		long intervalMs = 1000 / SUSTAINED_RPS;
+
+		ExecutorService executor = Executors.newFixedThreadPool(SUSTAINED_RPS * 2);
+		List<Long> latencies = Collections.synchronizedList(new ArrayList<>());
+		AtomicInteger errors = new AtomicInteger(0);
+
+		long testStart = System.nanoTime();
+
+		// 일정 간격으로 요청 제출
+		for (int i = 0; i < totalRequests; i++) {
+			executor.submit(() -> {
+				long start = System.nanoTime();
+				try (Connection conn = dataSource.getConnection();
+					 Statement stmt = conn.createStatement();
+					 ResultSet rs = stmt.executeQuery(sql)) {
+					while (rs.next()) {
+					}
+					latencies.add(System.nanoTime() - start);
+				} catch (Exception e) {
+					errors.incrementAndGet();
+				}
+			});
+
+			// Rate limiting
+			long elapsed = (System.nanoTime() - testStart) / 1_000_000;
+			long expected = (long) (i + 1) * intervalMs;
+			long sleepMs = expected - elapsed;
+			if (sleepMs > 0) {
+				Thread.sleep(sleepMs);
+			}
+		}
+
+		executor.shutdown();
+		boolean finished = executor.awaitTermination(5, TimeUnit.MINUTES);
+
+		long totalTimeMs = (System.nanoTime() - testStart) / 1_000_000;
+
+		// 결과 집계
+		long[] sorted = latencies.stream().mapToLong(l -> l).sorted().toArray();
+		if (sorted.length > 0) {
+			double actualQps = (double) sorted.length / totalTimeMs * 1000;
+			log.info("[{}] [지속부하] {} — 완료: {}/{}, 에러: {}, 실제QPS: {}, avg={}ms, p50={}ms, p95={}ms, p99={}ms, 총시간={}ms{}",
+				dataLabel, ucLabel,
+				sorted.length, totalRequests, errors.get(),
+				String.format("%.1f", actualQps),
+				String.format("%.2f", avg(sorted)),
+				String.format("%.2f", percentile(sorted, 50)),
+				String.format("%.2f", percentile(sorted, 95)),
+				String.format("%.2f", percentile(sorted, 99)),
+				totalTimeMs,
+				finished ? "" : " [TIMEOUT — 일부 미완료]");
+		} else {
+			log.warn("[{}] [지속부하] {} — 전체 실패 (에러: {})", dataLabel, ucLabel, errors.get());
+		}
+	}
+
+
+	// --- 통계 유틸 ---
+
+	private double avg(long[] sorted) {
+		long sum = 0;
+		for (long v : sorted) sum += v;
+		return sum / (double) sorted.length / 1_000_000.0;
+	}
+
+	private double percentile(long[] sorted, double p) {
+		int index = (int) Math.ceil(p / 100.0 * sorted.length) - 1;
+		return sorted[Math.max(0, Math.min(index, sorted.length - 1))] / 1_000_000.0;
+	}
+
+
+	// --- 데이터 삽입 ---
+
+	// SQL batch INSERT 배치 크기 (한 INSERT 문에 포함되는 VALUES 행 수)
+	private static final int SQL_BATCH_SIZE = 2_000;
+	// 커밋 간격 (redo log 고갈 방지)
+	private static final int COMMIT_INTERVAL = 10_000;
+
+	/**
+	 * SQL multi-row INSERT로 대량 데이터 삽입
+	 * - products 테이블은 세컨더리 인덱스 없음 (AS-IS) → 인덱스 관리 불필요
+	 * - multi-row INSERT: 한 문장에 2000행씩 묶어 네트워크 라운드트립 최소화
+	 * - 10,000행마다 COMMIT: MySQL redo log 고갈 방지
+	 */
+	private void insertBulkData(int productCount, int batchSize) throws Exception {
+		try (Connection conn = dataSource.getConnection()) {
+			conn.setAutoCommit(false);
+
+			// 1. 브랜드 50개 (소량이므로 단일 multi-row INSERT)
+			try (Statement stmt = conn.createStatement()) {
+				StringBuilder sb = new StringBuilder();
+				sb.append("INSERT INTO brands (name, description, visible_status, created_at, updated_at) VALUES ");
+				Timestamp now = Timestamp.from(Instant.now());
+				String nowStr = now.toString();
+				for (int i = 1; i <= BRAND_COUNT; i++) {
+					if (i > 1) sb.append(',');
+					sb.append("('Brand_").append(i).append("','Brand description ").append(i)
+						.append("','VISIBLE','").append(nowStr).append("','").append(nowStr).append("')");
+				}
+				stmt.executeUpdate(sb.toString());
+				conn.commit();
+			}
+
+			// 2. 상품 N건 — multi-row INSERT (products는 세컨더리 인덱스 없음)
+			try (Statement stmt = conn.createStatement()) {
+				ThreadLocalRandom rng = ThreadLocalRandom.current();
+				Instant baseTime = Instant.now();
+				int totalInserted = 0;
+
+				for (int offset = 0; offset < productCount; offset += SQL_BATCH_SIZE) {
+					int end = Math.min(offset + SQL_BATCH_SIZE, productCount);
+					StringBuilder sb = new StringBuilder();
+					sb.append("INSERT INTO products (brand_id, name, price, stock, description, created_at, updated_at) VALUES ");
+
+					for (int i = offset; i < end; i++) {
+						if (i > offset) sb.append(',');
+						long brandId = rng.nextLong(1, BRAND_COUNT + 1);
+						long price = rng.nextLong(1_000, 100_001);
+						long stock = rng.nextLong(0, 1_001);
+						Instant createdAt = baseTime.minus(rng.nextLong(0, 365), ChronoUnit.DAYS);
+						String ts = Timestamp.from(createdAt).toString();
+
+						sb.append('(')
+							.append(brandId).append(",'Product_").append(i)
+							.append("',").append(price)
+							.append(',').append(stock)
+							.append(",'Description for product ").append(i)
+							.append("','").append(ts).append("','").append(ts).append("')");
+					}
+
+					stmt.executeUpdate(sb.toString());
+					totalInserted += (end - offset);
+
+					// redo log 고갈 방지: COMMIT_INTERVAL마다 커밋
+					if (totalInserted % COMMIT_INTERVAL == 0) {
+						conn.commit();
+					}
+
+					if (totalInserted % 100_000 == 0) {
+						log.info("  [INSERT] {}건 완료...", totalInserted);
+					}
+				}
+
+				// 잔여 트랜잭션 커밋
+				conn.commit();
+			}
+		}
+	}
+
+
+	/**
+	 * AS-IS 좋아요 데이터 삽입 (likes 테이블)
+	 * - Read Model 도입 전 좋아요 순 정렬은 likes 테이블을 JOIN + GROUP BY + COUNT해야 함
+	 * - 상품당 0~100건 랜덤 좋아요 생성 (user_id는 1~10000 범위)
+	 * - multi-row INSERT + COMMIT_INTERVAL 단위 커밋
+	 */
+	private void insertBulkLikes(int productCount) throws Exception {
+		try (Connection conn = dataSource.getConnection()) {
+			conn.setAutoCommit(false);
+
+			try (Statement stmt = conn.createStatement()) {
+				ThreadLocalRandom rng = ThreadLocalRandom.current();
+				Timestamp now = Timestamp.from(Instant.now());
+				String nowStr = now.toString();
+				int totalInserted = 0;
+
+				for (int productId = 1; productId <= productCount; productId++) {
+					// 상품당 0~100건 랜덤 좋아요 (user_id는 1부터 순차 — UNIQUE 제약 회피)
+					int likeCount = rng.nextInt(0, 101);
+					if (likeCount == 0) {
+						continue;
+					}
+
+					// multi-row INSERT (SQL_BATCH_SIZE 단위)
+					for (int offset = 0; offset < likeCount; offset += SQL_BATCH_SIZE) {
+						int end = Math.min(offset + SQL_BATCH_SIZE, likeCount);
+						StringBuilder sb = new StringBuilder();
+						sb.append("INSERT INTO likes (user_id, target_type, target_id, created_at, updated_at) VALUES ");
+
+						for (int i = offset; i < end; i++) {
+							if (i > offset) sb.append(',');
+							// user_id = offset + i + 1 (상품별 순차 할당으로 UNIQUE(user_id, target_type, target_id) 보장)
+							long userId = i + 1;
+							sb.append('(')
+								.append(userId).append(",'PRODUCT',")
+								.append(productId)
+								.append(",'").append(nowStr).append("','").append(nowStr).append("')");
+						}
+
+						stmt.executeUpdate(sb.toString());
+						totalInserted += (end - offset);
+
+						if (totalInserted % COMMIT_INTERVAL == 0) {
+							conn.commit();
+						}
+					}
+
+					if (productId % 100_000 == 0) {
+						log.info("  [INSERT likes] 상품 {}건까지 좋아요 삽입 완료...", productId);
+					}
+				}
+
+				conn.commit();
+				log.info("  [INSERT likes] 총 {}건 좋아요 삽입 완료", totalInserted);
+			}
+		}
+	}
+
+
+	/**
+	 * TO-BE 데이터 삽입: brands + products + product_read_model (복합 인덱스 포함)
+	 * - brands, products는 기존 insertBulkData()와 동일하게 삽입
+	 * - product_read_model은 DROP INDEX → INSERT → CREATE INDEX (InnoDB 최적 패턴)
+	 *   - DISABLE/ENABLE KEYS는 MyISAM 전용이므로 InnoDB에서는 효과 없음
+	 *   - 12개 세컨더리 인덱스를 먼저 제거하고, 데이터 삽입 후 일괄 재생성하여 삽입 속도 극대화
+	 */
+	private void insertBulkDataWithReadModel(int productCount, int batchSize) throws Exception {
+		// 1. brands + products 삽입
+		insertBulkData(productCount, batchSize);
+
+		// 2. product_read_model 테이블: DROP INDEX → INSERT → CREATE INDEX
+		// product_read_model 테이블은 JPA auto-DDL로 이미 생성됨 (ProductReadModelEntity)
+		try (Connection conn = dataSource.getConnection();
+			 Statement stmt = conn.createStatement()) {
+			long start = System.currentTimeMillis();
+
+			// 세컨더리 인덱스 제거 (InnoDB: INSERT 중 인덱스 유지 비용 제거)
+			dropReadModelIndexes(stmt);
+			long dropElapsed = System.currentTimeMillis() - start;
+			out(String.format("  [DROP INDEX] product_read_model 인덱스 제거 완료: %dms", dropElapsed));
+
+			// 데이터 삽입 (인덱스 없이 순수 INSERT)
+			long insertStart = System.currentTimeMillis();
+			stmt.executeUpdate(
+				"INSERT INTO product_read_model (id, brand_id, brand_name, name, price, stock, description, like_count, created_at, updated_at, deleted_at) "
+					+ "SELECT p.id, p.brand_id, b.name, p.name, p.price, p.stock, p.description, FLOOR(RAND() * 10001), p.created_at, p.updated_at, p.deleted_at "
+					+ "FROM products p LEFT JOIN brands b ON b.id = p.brand_id"
+			);
+			long insertElapsed = System.currentTimeMillis() - insertStart;
+			out(String.format("  [INSERT] product_read_model 데이터 복사 완료: %dms", insertElapsed));
+
+			// 인덱스 일괄 재생성 (단일 패스로 B-tree 구축)
+			long createStart = System.currentTimeMillis();
+			createReadModelIndexes(stmt);
+			long createElapsed = System.currentTimeMillis() - createStart;
+			out(String.format("  [CREATE INDEX] product_read_model 인덱스 재생성 완료: %dms", createElapsed));
+
+			long totalElapsed = System.currentTimeMillis() - start;
+			out(String.format("  [READ MODEL 총계] DROP+INSERT+CREATE: %dms", totalElapsed));
+		}
+	}
+
+
+	/**
+	 * product_read_model 세컨더리 인덱스 12개 제거
+	 * - PK는 유지 (InnoDB clustered index)
+	 */
+	private void dropReadModelIndexes(Statement stmt) throws SQLException {
+		String[] indexes = {
+			"idx_read_brand_deleted_created", "idx_read_brand_deleted_price", "idx_read_brand_deleted_likecount",
+			"idx_read_deleted_created", "idx_read_deleted_price", "idx_read_deleted_likecount",
+			"idx_read_brand_created", "idx_read_brand_price", "idx_read_brand_likecount",
+			"idx_read_created", "idx_read_price", "idx_read_likecount"
+		};
+		for (String idx : indexes) {
+			stmt.execute("DROP INDEX " + idx + " ON product_read_model");
+		}
+	}
+
+
+	/**
+	 * product_read_model 세컨더리 인덱스 12개 재생성
+	 * - ProductReadModelEntity @Table(indexes) 정의와 동일
+	 */
+	private void createReadModelIndexes(Statement stmt) throws SQLException {
+		String[] ddls = {
+			// 사용자 조회 (브랜드 지정): WHERE brand_id = ? AND deleted_at IS NULL ORDER BY {sort_col}
+			"CREATE INDEX idx_read_brand_deleted_created ON product_read_model (brand_id, deleted_at, created_at)",
+			"CREATE INDEX idx_read_brand_deleted_price ON product_read_model (brand_id, deleted_at, price)",
+			"CREATE INDEX idx_read_brand_deleted_likecount ON product_read_model (brand_id, deleted_at, like_count)",
+			// 사용자 조회 (브랜드 미지정): WHERE deleted_at IS NULL ORDER BY {sort_col}
+			"CREATE INDEX idx_read_deleted_created ON product_read_model (deleted_at, created_at)",
+			"CREATE INDEX idx_read_deleted_price ON product_read_model (deleted_at, price)",
+			"CREATE INDEX idx_read_deleted_likecount ON product_read_model (deleted_at, like_count)",
+			// 관리자 조회 (브랜드 지정): WHERE brand_id = ? ORDER BY {sort_col}
+			"CREATE INDEX idx_read_brand_created ON product_read_model (brand_id, created_at)",
+			"CREATE INDEX idx_read_brand_price ON product_read_model (brand_id, price)",
+			"CREATE INDEX idx_read_brand_likecount ON product_read_model (brand_id, like_count)",
+			// 관리자 조회 (필터 없음): ORDER BY {sort_col}
+			"CREATE INDEX idx_read_created ON product_read_model (created_at)",
+			"CREATE INDEX idx_read_price ON product_read_model (price)",
+			"CREATE INDEX idx_read_likecount ON product_read_model (like_count)"
+		};
+		for (String ddl : ddls) {
+			stmt.execute(ddl);
+		}
+	}
+
+
+	// --- 데이터 분포 로깅 (Read Model) ---
+
+	private void logReadModelDataDistribution() throws Exception {
+		try (Connection conn = dataSource.getConnection();
+			 Statement stmt = conn.createStatement()) {
+
+			try (ResultSet rs = stmt.executeQuery("SELECT COUNT(*) AS cnt FROM product_read_model")) {
+				rs.next();
+				log.info("  전체 상품 (Read Model): {}건", rs.getLong("cnt"));
+			}
+			try (ResultSet rs = stmt.executeQuery("SELECT COUNT(*) AS cnt FROM product_read_model WHERE deleted_at IS NULL")) {
+				rs.next();
+				log.info("  활성 상품 (Read Model): {}건", rs.getLong("cnt"));
+			}
+
+			try (ResultSet rs = stmt.executeQuery(
+				"SELECT MIN(price) AS min_p, MAX(price) AS max_p, AVG(price) AS avg_p FROM product_read_model WHERE deleted_at IS NULL")) {
+				rs.next();
+				log.info("  가격 (Read Model): min={}, max={}, avg={}",
+					rs.getBigDecimal("min_p"), rs.getBigDecimal("max_p"),
+					rs.getBigDecimal("avg_p").setScale(0, RoundingMode.HALF_UP));
+			}
+
+			try (ResultSet rs = stmt.executeQuery(
+				"SELECT MIN(like_count) AS min_l, MAX(like_count) AS max_l, AVG(like_count) AS avg_l FROM product_read_model WHERE deleted_at IS NULL")) {
+				rs.next();
+				log.info("  좋아요 (Read Model): min={}, max={}, avg={}",
+					rs.getLong("min_l"), rs.getLong("max_l"),
+					rs.getBigDecimal("avg_l").setScale(0, RoundingMode.HALF_UP));
+			}
+		}
+	}
+
+
+	// --- 인덱스 로깅 ---
+
+	private void logIndexes(String table) throws Exception {
+		try (Connection conn = dataSource.getConnection();
+			 Statement stmt = conn.createStatement();
+			 ResultSet rs = stmt.executeQuery("SHOW INDEX FROM " + table)) {
+
+			StringBuilder sb = new StringBuilder();
+			sb.append(String.format("  %-25s %-20s %-10s%n", "Key_name", "Column_name", "Non_unique"));
+
+			while (rs.next()) {
+				sb.append(String.format("  %-25s %-20s %-10d%n",
+					rs.getString("Key_name"),
+					rs.getString("Column_name"),
+					rs.getInt("Non_unique")));
+			}
+
+			log.info("[{}]\n{}", table, sb);
+		}
+	}
+
+
+	// --- 파일 출력 버전 (TO-BE 전용) ---
+
+	private void logIndexesToFile(String table) throws Exception {
+		try (Connection conn = dataSource.getConnection();
+			 Statement stmt = conn.createStatement();
+			 ResultSet rs = stmt.executeQuery("SHOW INDEX FROM " + table)) {
+			StringBuilder sb = new StringBuilder();
+			sb.append(String.format("  %-25s %-20s %-10s", "Key_name", "Column_name", "Non_unique"));
+			while (rs.next()) {
+				sb.append(String.format("\n  %-25s %-20s %-10d",
+					rs.getString("Key_name"), rs.getString("Column_name"), rs.getInt("Non_unique")));
+			}
+			out(sb.toString());
+		}
+	}
+
+	private void logReadModelDataDistributionToFile() throws Exception {
+		try (Connection conn = dataSource.getConnection();
+			 Statement stmt = conn.createStatement()) {
+			try (ResultSet rs = stmt.executeQuery("SELECT COUNT(*) AS cnt FROM product_read_model")) {
+				rs.next();
+				out(String.format("  전체 상품 (Read Model): %d건", rs.getLong("cnt")));
+			}
+			try (ResultSet rs = stmt.executeQuery("SELECT COUNT(*) AS cnt FROM product_read_model WHERE deleted_at IS NULL")) {
+				rs.next();
+				out(String.format("  활성 상품 (Read Model): %d건", rs.getLong("cnt")));
+			}
+			try (ResultSet rs = stmt.executeQuery("SELECT MIN(price) AS min_p, MAX(price) AS max_p, AVG(price) AS avg_p FROM product_read_model WHERE deleted_at IS NULL")) {
+				rs.next();
+				out(String.format("  가격 (Read Model): min=%s, max=%s, avg=%s",
+					rs.getBigDecimal("min_p"), rs.getBigDecimal("max_p"),
+					rs.getBigDecimal("avg_p").setScale(0, RoundingMode.HALF_UP)));
+			}
+			try (ResultSet rs = stmt.executeQuery("SELECT MIN(like_count) AS min_l, MAX(like_count) AS max_l, AVG(like_count) AS avg_l FROM product_read_model WHERE deleted_at IS NULL")) {
+				rs.next();
+				out(String.format("  좋아요 (Read Model): min=%d, max=%d, avg=%s",
+					rs.getLong("min_l"), rs.getLong("max_l"),
+					rs.getBigDecimal("avg_l").setScale(0, RoundingMode.HALF_UP)));
+			}
+		}
+	}
+
+	private void measureSingleQueryToFile(String dataLabel, String ucLabel, String sql) throws Exception {
+		try (Connection conn = dataSource.getConnection();
+			 Statement stmt = conn.createStatement()) {
+			// EXPLAIN
+			try (ResultSet rs = stmt.executeQuery("EXPLAIN " + sql)) {
+				while (rs.next()) {
+					out(String.format("[%s] [EXPLAIN] %s — table=%s, type=%s, key=%s, rows=%s, filtered=%s, Extra=%s",
+						dataLabel, ucLabel, rs.getString("table"), rs.getString("type"),
+						rs.getString("key"), rs.getString("rows"), rs.getString("filtered"), rs.getString("Extra")));
+				}
+			}
+			// Warmup
+			for (int w = 0; w < 3; w++) {
+				try (ResultSet rs = stmt.executeQuery(sql)) { while (rs.next()) {} }
+			}
+			// 측정
+			int runs = 5;
+			long[] times = new long[runs];
+			for (int i = 0; i < runs; i++) {
+				long start = System.nanoTime();
+				try (ResultSet rs = stmt.executeQuery(sql)) { while (rs.next()) {} }
+				times[i] = System.nanoTime() - start;
+			}
+			long sum = 0, min = Long.MAX_VALUE, max = Long.MIN_VALUE;
+			for (long t : times) { sum += t; min = Math.min(min, t); max = Math.max(max, t); }
+			out(String.format("[%s] [단일쿼리] %s — avg=%.2fms, min=%.2fms, max=%.2fms",
+				dataLabel, ucLabel, sum / (double) runs / 1_000_000.0,
+				min / 1_000_000.0, max / 1_000_000.0));
+		}
+	}
+
+	private void measureBurstToFile(String dataLabel, String ucLabel, String sql) throws Exception {
+		ExecutorService executor = Executors.newFixedThreadPool(BURST_THREADS);
+		CountDownLatch ready = new CountDownLatch(BURST_THREADS);
+		CountDownLatch go = new CountDownLatch(1);
+		long[] latencies = new long[BURST_THREADS];
+		AtomicInteger errors = new AtomicInteger(0);
+		for (int i = 0; i < BURST_THREADS; i++) {
+			final int idx = i;
+			executor.submit(() -> {
+				ready.countDown();
+				try {
+					go.await();
+					long start = System.nanoTime();
+					try (Connection conn = dataSource.getConnection();
+						 Statement stmt = conn.createStatement();
+						 ResultSet rs = stmt.executeQuery(sql)) { while (rs.next()) {} }
+					latencies[idx] = System.nanoTime() - start;
+				} catch (Exception e) { errors.incrementAndGet(); latencies[idx] = -1; }
+			});
+		}
+		ready.await(); go.countDown();
+		executor.shutdown(); executor.awaitTermination(5, TimeUnit.MINUTES);
+		long[] valid = Arrays.stream(latencies).filter(l -> l > 0).sorted().toArray();
+		if (valid.length > 0) {
+			out(String.format("[%s] [버스트] %s — 완료: %d/%d, 에러: %d, avg=%.2fms, p50=%.2fms, p95=%.2fms, p99=%.2fms, max=%.2fms",
+				dataLabel, ucLabel, valid.length, BURST_THREADS, errors.get(),
+				avg(valid), percentile(valid, 50), percentile(valid, 95),
+				percentile(valid, 99), valid[valid.length - 1] / 1_000_000.0));
+		} else {
+			out(String.format("[%s] [버스트] %s — 전체 실패 (에러: %d)", dataLabel, ucLabel, errors.get()));
+		}
+	}
+
+	private void measureSustainedLoadToFile(String dataLabel, String ucLabel, String sql) throws Exception {
+		int totalRequests = SUSTAINED_RPS * SUSTAINED_DURATION_SEC;
+		long intervalMs = 1000 / SUSTAINED_RPS;
+		ExecutorService executor = Executors.newFixedThreadPool(SUSTAINED_RPS * 2);
+		List<Long> latencies = Collections.synchronizedList(new ArrayList<>());
+		AtomicInteger errors = new AtomicInteger(0);
+		long testStart = System.nanoTime();
+		for (int i = 0; i < totalRequests; i++) {
+			executor.submit(() -> {
+				long start = System.nanoTime();
+				try (Connection conn = dataSource.getConnection();
+					 Statement stmt = conn.createStatement();
+					 ResultSet rs = stmt.executeQuery(sql)) { while (rs.next()) {} latencies.add(System.nanoTime() - start); }
+				catch (Exception e) { errors.incrementAndGet(); }
+			});
+			long elapsed = (System.nanoTime() - testStart) / 1_000_000;
+			long expected = (long) (i + 1) * intervalMs;
+			long sleepMs = expected - elapsed;
+			if (sleepMs > 0) Thread.sleep(sleepMs);
+		}
+		executor.shutdown(); boolean finished = executor.awaitTermination(5, TimeUnit.MINUTES);
+		long totalTimeMs = (System.nanoTime() - testStart) / 1_000_000;
+		long[] sorted = latencies.stream().mapToLong(l -> l).sorted().toArray();
+		if (sorted.length > 0) {
+			double actualQps = (double) sorted.length / totalTimeMs * 1000;
+			out(String.format("[%s] [지속부하] %s — 완료: %d/%d, 에러: %d, 실제QPS: %.1f, avg=%.2fms, p50=%.2fms, p95=%.2fms, p99=%.2fms, 총시간=%dms%s",
+				dataLabel, ucLabel, sorted.length, totalRequests, errors.get(), actualQps,
+				avg(sorted), percentile(sorted, 50), percentile(sorted, 95),
+				percentile(sorted, 99), totalTimeMs, finished ? "" : " [TIMEOUT]"));
+		} else {
+			out(String.format("[%s] [지속부하] %s — 전체 실패 (에러: %d)", dataLabel, ucLabel, errors.get()));
+		}
+	}
+
+
+	// --- 데이터 분포 로깅 ---
+
+	private void logDataDistribution() throws Exception {
+		try (Connection conn = dataSource.getConnection();
+			 Statement stmt = conn.createStatement()) {
+
+			try (ResultSet rs = stmt.executeQuery("SELECT COUNT(*) AS cnt FROM products")) {
+				rs.next();
+				log.info("  전체 상품: {}건", rs.getLong("cnt"));
+			}
+			try (ResultSet rs = stmt.executeQuery("SELECT COUNT(*) AS cnt FROM products WHERE deleted_at IS NULL")) {
+				rs.next();
+				log.info("  활성 상품: {}건", rs.getLong("cnt"));
+			}
+
+			try (ResultSet rs = stmt.executeQuery(
+				"SELECT MIN(price) AS min_p, MAX(price) AS max_p, AVG(price) AS avg_p FROM products WHERE deleted_at IS NULL")) {
+				rs.next();
+				log.info("  가격: min={}, max={}, avg={}",
+					rs.getBigDecimal("min_p"), rs.getBigDecimal("max_p"),
+					rs.getBigDecimal("avg_p").setScale(0, RoundingMode.HALF_UP));
+			}
+
+			try (ResultSet rs = stmt.executeQuery(
+				"SELECT MIN(stock) AS min_s, MAX(stock) AS max_s, AVG(stock) AS avg_s FROM products WHERE deleted_at IS NULL")) {
+				rs.next();
+				log.info("  재고: min={}, max={}, avg={}",
+					rs.getLong("min_s"), rs.getLong("max_s"),
+					rs.getBigDecimal("avg_s").setScale(0, RoundingMode.HALF_UP));
+			}
+		}
+	}
+
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/cart/cart/infrastructure/entity/CartItemEntity.java b/apps/commerce-api/src/main/java/com/loopers/cart/cart/infrastructure/entity/CartItemEntity.java
index 674c11f15..21b461567 100644
--- a/apps/commerce-api/src/main/java/com/loopers/cart/cart/infrastructure/entity/CartItemEntity.java
+++ b/apps/commerce-api/src/main/java/com/loopers/cart/cart/infrastructure/entity/CartItemEntity.java
@@ -16,9 +16,15 @@
  * - selected: 선택 여부
  */
 @Entity
-@Table(name = "cart_items", uniqueConstraints = {
-	@UniqueConstraint(columnNames = {"user_id", "product_id"})
-})
+@Table(name = "cart_items",
+	uniqueConstraints = @UniqueConstraint(columnNames = {"user_id", "product_id"}),
+	indexes = {
+		// 선택된 장바구니 항목 조회: WHERE user_id = ? AND selected = true
+		@Index(name = "idx_cart_user_selected", columnList = "user_id, selected"),
+		// 상품 삭제 시 장바구니 정리: WHERE product_id = ?
+		@Index(name = "idx_cart_product", columnList = "product_id")
+	}
+)
 @Getter
 @NoArgsConstructor(access = AccessLevel.PROTECTED)
 public class CartItemEntity extends BaseEntity {
diff --git a/apps/commerce-api/src/main/java/com/loopers/catalog/brand/infrastructure/entity/BrandEntity.java b/apps/commerce-api/src/main/java/com/loopers/catalog/brand/infrastructure/entity/BrandEntity.java
index d259302ef..85bedbf8b 100644
--- a/apps/commerce-api/src/main/java/com/loopers/catalog/brand/infrastructure/entity/BrandEntity.java
+++ b/apps/commerce-api/src/main/java/com/loopers/catalog/brand/infrastructure/entity/BrandEntity.java
@@ -16,7 +16,10 @@
  * - visibleStatus: 노출 상태
  */
 @Entity
-@Table(name = "brands")
+@Table(name = "brands", indexes = {
+	// 사용자 조회: WHERE deleted_at IS NULL AND visible_status = ?
+	@Index(name = "idx_brands_deleted_visible", columnList = "deleted_at, visible_status")
+})
 @Getter
 @NoArgsConstructor(access = AccessLevel.PROTECTED)
 public class BrandEntity extends SoftDeleteBaseEntity {
diff --git a/apps/commerce-api/src/main/java/com/loopers/catalog/product/infrastructure/entity/ProductEntity.java b/apps/commerce-api/src/main/java/com/loopers/catalog/product/infrastructure/entity/ProductEntity.java
index d74ab3346..9215d681c 100644
--- a/apps/commerce-api/src/main/java/com/loopers/catalog/product/infrastructure/entity/ProductEntity.java
+++ b/apps/commerce-api/src/main/java/com/loopers/catalog/product/infrastructure/entity/ProductEntity.java
@@ -17,7 +17,6 @@
  * - price: 가격
  * - stock: 재고
  * - description: 상품 설명
- * - likeCount: 좋아요 수
  */
 @Entity
 @Table(name = "products")
@@ -40,32 +39,28 @@ public class ProductEntity extends SoftDeleteBaseEntity {
 	@Column(name = "description", length = 1000)
 	private String description;
 
-	@Column(name = "like_count", nullable = false)
-	private Long likeCount;
-
 
 	private ProductEntity(Long id, Long brandId, String name, BigDecimal price, Long stock,
-		String description, Long likeCount) {
+		String description) {
 		super(id);
 		this.brandId = brandId;
 		this.name = name;
 		this.price = price;
 		this.stock = stock;
 		this.description = description;
-		this.likeCount = likeCount;
 	}
 
 
 	// DB 복원용 (id 포함)
 	public static ProductEntity of(Long id, Long brandId, String name, BigDecimal price, Long stock,
-		String description, Long likeCount) {
-		return new ProductEntity(id, brandId, name, price, stock, description, likeCount);
+		String description) {
+		return new ProductEntity(id, brandId, name, price, stock, description);
 	}
 
 	// 신규 생성용 (id = null)
 	public static ProductEntity of(Long brandId, String name, BigDecimal price, Long stock,
-		String description, Long likeCount) {
-		return of(null, brandId, name, price, stock, description, likeCount);
+		String description) {
+		return of(null, brandId, name, price, stock, description);
 	}
 
 }
diff --git a/apps/commerce-api/src/main/java/com/loopers/coupon/coupontemplate/infrastructure/entity/CouponTemplateEntity.java b/apps/commerce-api/src/main/java/com/loopers/coupon/coupontemplate/infrastructure/entity/CouponTemplateEntity.java
index 8dc6f4002..7895d7f3a 100644
--- a/apps/commerce-api/src/main/java/com/loopers/coupon/coupontemplate/infrastructure/entity/CouponTemplateEntity.java
+++ b/apps/commerce-api/src/main/java/com/loopers/coupon/coupontemplate/infrastructure/entity/CouponTemplateEntity.java
@@ -21,7 +21,10 @@
  * - expiredAt: 만료 일시
  */
 @Entity
-@Table(name = "coupon_template")
+@Table(name = "coupon_template", indexes = {
+	// 활성 쿠폰 템플릿 목록: WHERE deleted_at IS NULL
+	@Index(name = "idx_coupon_template_deleted", columnList = "deleted_at")
+})
 @Getter
 @NoArgsConstructor(access = AccessLevel.PROTECTED)
 public class CouponTemplateEntity extends SoftDeleteBaseEntity {
diff --git a/apps/commerce-api/src/main/java/com/loopers/coupon/issuedcoupon/infrastructure/entity/IssuedCouponEntity.java b/apps/commerce-api/src/main/java/com/loopers/coupon/issuedcoupon/infrastructure/entity/IssuedCouponEntity.java
index c01763e0e..3eca9b5c0 100644
--- a/apps/commerce-api/src/main/java/com/loopers/coupon/issuedcoupon/infrastructure/entity/IssuedCouponEntity.java
+++ b/apps/commerce-api/src/main/java/com/loopers/coupon/issuedcoupon/infrastructure/entity/IssuedCouponEntity.java
@@ -17,7 +17,15 @@
  * - 1인 1쿠폰: (user_id, coupon_template_id) 복합 유니크 제약이 DB 레벨에서 보장
  */
 @Entity
-@Table(name = "issued_coupon", uniqueConstraints = @UniqueConstraint(columnNames = {"user_id", "coupon_template_id"}))
+@Table(name = "issued_coupon",
+	uniqueConstraints = @UniqueConstraint(columnNames = {"user_id", "coupon_template_id"}),
+	indexes = {
+		// 사용자 쿠폰 내역: WHERE user_id = ? ORDER BY created_at DESC
+		@Index(name = "idx_issued_coupon_user_created", columnList = "user_id, created_at"),
+		// 관리자 쿠폰 발급 내역: WHERE coupon_template_id = ? ORDER BY created_at DESC
+		@Index(name = "idx_issued_coupon_template_created", columnList = "coupon_template_id, created_at")
+	}
+)
 @Getter
 @NoArgsConstructor(access = AccessLevel.PROTECTED)
 public class IssuedCouponEntity extends BaseEntity {
diff --git a/apps/commerce-api/src/main/java/com/loopers/engagement/productlike/infrastructure/entity/ProductLikeEntity.java b/apps/commerce-api/src/main/java/com/loopers/engagement/productlike/infrastructure/entity/ProductLikeEntity.java
index ec2cda1d4..425ee8d55 100644
--- a/apps/commerce-api/src/main/java/com/loopers/engagement/productlike/infrastructure/entity/ProductLikeEntity.java
+++ b/apps/commerce-api/src/main/java/com/loopers/engagement/productlike/infrastructure/entity/ProductLikeEntity.java
@@ -15,7 +15,15 @@
  * - targetId: 상품 ID
  */
 @Entity
-@Table(name = "likes", uniqueConstraints = @UniqueConstraint(columnNames = {"user_id", "target_type", "target_id"}))
+@Table(name = "likes",
+	uniqueConstraints = @UniqueConstraint(columnNames = {"user_id", "target_type", "target_id"}),
+	indexes = {
+		// 좋아요 목록 페이지네이션: WHERE user_id = ? AND target_type = ? ORDER BY created_at DESC
+		@Index(name = "idx_likes_user_type_created", columnList = "user_id, target_type, created_at"),
+		// 상품/브랜드 삭제 시 좋아요 정리: WHERE target_type = ? AND target_id = ?
+		@Index(name = "idx_likes_type_target", columnList = "target_type, target_id")
+	}
+)
 @Getter
 @NoArgsConstructor(access = AccessLevel.PROTECTED)
 public class ProductLikeEntity extends BaseEntity {
diff --git a/apps/commerce-api/src/main/java/com/loopers/ordering/order/infrastructure/entity/OrderEntity.java b/apps/commerce-api/src/main/java/com/loopers/ordering/order/infrastructure/entity/OrderEntity.java
index cb16142b6..3da63239a 100644
--- a/apps/commerce-api/src/main/java/com/loopers/ordering/order/infrastructure/entity/OrderEntity.java
+++ b/apps/commerce-api/src/main/java/com/loopers/ordering/order/infrastructure/entity/OrderEntity.java
@@ -2,10 +2,7 @@
 
 
 import com.loopers.domain.BaseEntity;
-import jakarta.persistence.Column;
-import jakarta.persistence.Entity;
-import jakarta.persistence.Table;
-import jakarta.persistence.UniqueConstraint;
+import jakarta.persistence.*;
 import lombok.AccessLevel;
 import lombok.Getter;
 import lombok.NoArgsConstructor;
@@ -26,7 +23,13 @@
  * - couponSnapshotValue: 쿠폰 할인 값 스냅샷 (nullable)
  */
 @Entity
-@Table(name = "orders", uniqueConstraints = @UniqueConstraint(columnNames = {"user_id", "request_id"}))
+@Table(name = "orders",
+	uniqueConstraints = @UniqueConstraint(columnNames = {"user_id", "request_id"}),
+	indexes = {
+		// 주문 내역 조회: WHERE user_id = ? ORDER BY created_at DESC / 기간 필터
+		@Index(name = "idx_orders_user_created", columnList = "user_id, created_at")
+	}
+)
 @Getter
 @NoArgsConstructor(access = AccessLevel.PROTECTED)
 public class OrderEntity extends BaseEntity {
diff --git a/apps/commerce-api/src/main/java/com/loopers/ordering/order/infrastructure/entity/OrderItemEntity.java b/apps/commerce-api/src/main/java/com/loopers/ordering/order/infrastructure/entity/OrderItemEntity.java
index fbb494bb3..5c7828022 100644
--- a/apps/commerce-api/src/main/java/com/loopers/ordering/order/infrastructure/entity/OrderItemEntity.java
+++ b/apps/commerce-api/src/main/java/com/loopers/ordering/order/infrastructure/entity/OrderItemEntity.java
@@ -2,9 +2,7 @@
 
 
 import com.loopers.domain.BaseEntity;
-import jakarta.persistence.Column;
-import jakarta.persistence.Entity;
-import jakarta.persistence.Table;
+import jakarta.persistence.*;
 import lombok.AccessLevel;
 import lombok.Getter;
 import lombok.NoArgsConstructor;
@@ -21,7 +19,10 @@
  * - quantity: 주문 수량
  */
 @Entity
-@Table(name = "order_items")
+@Table(name = "order_items", indexes = {
+	// 주문 상품 조회: WHERE order_id = ? / WHERE order_id IN (?)
+	@Index(name = "idx_order_items_order", columnList = "order_id")
+})
 @Getter
 @NoArgsConstructor(access = AccessLevel.PROTECTED)
 public class OrderItemEntity extends BaseEntity {
diff --git a/round5-docs/04-to-be-index-measurement.md b/round5-docs/04-to-be-index-measurement.md
new file mode 100644
index 000000000..65b652bda
--- /dev/null
+++ b/round5-docs/04-to-be-index-measurement.md
@@ -0,0 +1,512 @@
+# TO-BE 인덱스 성능 측정 결과 (Read Model + 복합 인덱스)
+
+> 실측 재현 명령어: `./gradlew :apps:commerce-api:benchmarkTest --tests '*ProductIndexPerformanceTest.measureToBe*'`
+
+## 측정 환경
+
+| 항목 | 값 |
+|------|---|
+| DB | MySQL 8.0 (TestContainers) |
+| 데이터 규모 | 10만 / 100만 / 1000만 |
+| 브랜드 | 50개 (균등 분포) |
+| 상품 상태 | 전부 활성 (deleted_at IS NULL) |
+| **테이블** | **`product_read_model` (비정규화 Read Model)** |
+| **인덱스** | **PK + 복합 인덱스 12개 (6개 유즈케이스 × 2-column/3-column)** |
+| **쿼리 패턴** | **단일 테이블 SELECT (LEFT JOIN 제거)** |
+| Connection Pool | HikariCP (기본 10개) |
+
+### AS-IS 대비 변경점
+
+| 항목 | AS-IS | TO-BE |
+|------|-------|-------|
+| 테이블 | `products` + `brands` (정규화) | `product_read_model` (비정규화, `brand_name` 컬럼 포함) |
+| 조인 | `LEFT JOIN brands` 필수 | 조인 불필요 (단일 테이블 SELECT) |
+| 인덱스 | PK만 존재 | PK + 복합 인덱스 12개 |
+| EXPLAIN type | `ALL` (Full Table Scan) | `range` / `ref` (Index Range Scan) |
+| filesort | 모든 쿼리에서 발생 | 모든 정렬 쿼리에서 제거 |
+
+## 복합 인덱스 설계
+
+```sql
+-- 사용자 조회 (브랜드 지정): WHERE brand_id = ? AND deleted_at IS NULL ORDER BY {sort_col}
+CREATE INDEX idx_read_brand_deleted_created ON product_read_model (brand_id, deleted_at, created_at);
+CREATE INDEX idx_read_brand_deleted_price ON product_read_model (brand_id, deleted_at, price);
+CREATE INDEX idx_read_brand_deleted_likecount ON product_read_model (brand_id, deleted_at, like_count);
+
+-- 사용자 조회 (브랜드 미지정): WHERE deleted_at IS NULL ORDER BY {sort_col}
+CREATE INDEX idx_read_deleted_created ON product_read_model (deleted_at, created_at);
+CREATE INDEX idx_read_deleted_price ON product_read_model (deleted_at, price);
+CREATE INDEX idx_read_deleted_likecount ON product_read_model (deleted_at, like_count);
+
+-- 관리자 조회 (브랜드 지정): WHERE brand_id = ? ORDER BY {sort_col}
+CREATE INDEX idx_read_brand_created ON product_read_model (brand_id, created_at);
+CREATE INDEX idx_read_brand_price ON product_read_model (brand_id, price);
+CREATE INDEX idx_read_brand_likecount ON product_read_model (brand_id, like_count);
+
+-- 관리자 조회 (필터 없음): ORDER BY {sort_col}
+CREATE INDEX idx_read_created ON product_read_model (created_at);
+CREATE INDEX idx_read_price ON product_read_model (price);
+CREATE INDEX idx_read_likecount ON product_read_model (like_count);
+```
+
+### 인덱스 설계 근거
+
+**컬럼 순서: `(brand_id, deleted_at, sort_column)`**
+
+B-tree 인덱스에서 **equality 조건 컬럼은 sort 컬럼보다 반드시 앞에** 와야 한다. 이 원칙에 따라 각 위치가 결정된다.
+
+**1. `sort_column`이 반드시 마지막(3번째)인 이유**
+
+`sort_column`(created_at, price, like_count)은 `ORDER BY`에 사용된다. B-tree 인덱스에서 **모든 equality 컬럼 뒤에 sort 컬럼이 연속으로 오면**, MySQL은 인덱스에 이미 정렬된 순서로 행을 읽을 수 있어 **filesort를 생략**한다. 만약 sort 컬럼이 equality 컬럼 사이에 끼어 있으면, sort 컬럼 이후의 equality 조건이 인덱스 연속 탐색을 깨뜨려 filesort가 발생한다.
+
+```
+(brand_id, deleted_at, created_at)  → brand_id=1, deleted_at IS NULL까지 equality로 좁힌 후
+                                       created_at 순서대로 20행만 읽기 → filesort 불필요 ✅
+
+(brand_id, created_at, deleted_at)  → brand_id=1로 좁힌 후 created_at 순서로 읽지만,
+                                       각 행마다 deleted_at IS NULL 필터링 필요 → filesort 불필요하나 불필요한 행 읽기 증가 ⚠️
+
+(created_at, brand_id, deleted_at)  → created_at은 range/sort 조건 → 이후 컬럼 활용 불가 → filesort 발생 ❌
+```
+
+**2. `deleted_at`이 2번째(중간)인 이유**
+
+`deleted_at IS NULL`은 MySQL에서 **equality(ref) 조건으로 처리**된다. 따라서 `brand_id`와 `deleted_at` 모두 equality 컬럼이고, equality 컬럼끼리는 순서가 바뀌어도 인덱스 탐색 결과(matching rows)가 동일하다. 중요한 것은 **이 두 컬럼이 sort 컬럼보다 앞에 있어야 한다**는 점이다.
+
+**3. `brand_id`가 1번째(선두)인 이유 — equality 컬럼 간 순서**
+
+`brand_id`와 `deleted_at`은 둘 다 equality 조건이므로 순서가 바뀌어도 결과는 동일하다. 하지만 **카디널리티가 높은 컬럼을 선두에 배치**하면 B-tree 첫 레벨 분기가 균등해져 인덱스 페이지 접근 효율이 향상된다.
+
+| 컬럼 | 카디널리티 | 역할 |
+|------|----------|------|
+| `brand_id` | 높음 (50개 distinct) | equality 조건 (선택적 필터) |
+| `deleted_at` | 낮음 (2값: NULL/timestamp) | equality 조건 (항상 `IS NULL`) |
+| `sort_column` | 높음 (연속값) | ORDER BY 정렬 |
+
+> **요약**: `sort_column`은 filesort 제거를 위해 **반드시 마지막**. `brand_id`와 `deleted_at`은 둘 다 equality이므로 sort 앞에 배치하되, 카디널리티가 높은 `brand_id`를 선두에 둔다.
+
+**브랜드 필터 유무에 따른 동작 차이:**
+
+| 조건 | 인덱스 사용 | filesort |
+|------|-----------|----------|
+| `brand_id = 1 AND deleted_at IS NULL ORDER BY created_at` | `(brand_id, deleted_at, created_at)` 3컬럼 모두 활용 | **제거** (인덱스 순서 = 정렬 순서) |
+| `deleted_at IS NULL ORDER BY created_at` | `(deleted_at, created_at)` 2-column 인덱스 활용 | **제거** (인덱스 순서 = 정렬 순서) |
+
+## 측정 레벨
+
+| 레벨 | 측정 대상 | 테스트 클래스 | 비교 목적 |
+|------|----------|-------------|----------|
+| **DB 쿼리** | 순수 SQL 실행 (JDBC 직접 호출) | `ProductIndexPerformanceTest` | 인덱스 효과 비교 |
+
+## 트래픽 유형
+
+| 유형 | 파라미터 | 설명 |
+|------|---------|------|
+| **단일 쿼리** | 1 thread, warmup 3회 + 측정 5회 | EXPLAIN + 순수 쿼리 실행시간 |
+| **버스트** | 100 concurrent threads, CountDownLatch 동시 시작 | 동시 요청 폭주 시나리오 |
+| **지속 부하** | 20 RPS × 10초 = 200 요청 | 일정 트래픽 유지 시나리오 |
+
+## 데이터 분포
+
+| 항목 | 10만건 | 100만건 | 1000만건 |
+|------|:---:|:---:|:---:|
+| 전체/활성 상품 | 100,000 | 1,000,000 | 10,000,000 |
+| 브랜드당 상품 수 | ~2,000 | ~20,000 | ~200,000 |
+| 가격 범위 | 1,000 ~ 100,000 | 1,000 ~ 100,000 | 1,000 ~ 100,000 |
+| 좋아요 범위 | 0 ~ 10,000 | 0 ~ 10,000 | 0 ~ 10,000 |
+
+## 현재 인덱스
+
+```
+[product_read_model]
+  Key_name                           Column_name                        Non_unique
+  PRIMARY                            id                                 0
+  idx_read_brand_deleted_created     brand_id, deleted_at, created_at   1
+  idx_read_brand_deleted_price       brand_id, deleted_at, price        1
+  idx_read_brand_deleted_likecount   brand_id, deleted_at, like_count   1
+  idx_read_deleted_created           deleted_at, created_at             1
+  idx_read_deleted_price             deleted_at, price                  1
+  idx_read_deleted_likecount         deleted_at, like_count             1
+  idx_read_brand_created             brand_id, created_at               1
+  idx_read_brand_price               brand_id, price                    1
+  idx_read_brand_likecount           brand_id, like_count               1
+  idx_read_created                   created_at                         1
+  idx_read_price                     price                              1
+  idx_read_likecount                 like_count                         1
+```
+
+---
+
+# A. DB 쿼리 레벨
+
+## A-1. 단일 쿼리 측정 (EXPLAIN + 실행시간)
+
+### EXPLAIN 결과
+
+#### 브랜드 필터 있는 쿼리 (UC4~6)
+
+**10만건 기준:**
+```
+UC4 (LATEST):     type=ref, key=idx_read_brand_deleted_created,   rows=2002, Extra=Using where; Backward index scan
+UC5 (PRICE_ASC):  type=ref, key=idx_read_brand_deleted_price,     rows=2002, Extra=Using index condition
+UC6 (LIKES_DESC): type=ref, key=idx_read_brand_deleted_likecount, rows=2002, Extra=Using where; Backward index scan
+```
+
+**100만건 기준 (실측):**
+```
+UC4 (LATEST):     type=ref, key=idx_read_brand_created,           rows=35384, filtered=50.0, Extra=Using where; Backward index scan
+UC5 (PRICE_ASC):  type=ref, key=idx_read_brand_price,             rows=35384, filtered=50.0, Extra=Using where
+UC6 (LIKES_DESC): type=ref, key=idx_read_brand_likecount,         rows=35384, filtered=50.0, Extra=Using where; Backward index scan
+```
+
+**1000만건 기준 (실측):**
+```
+UC4 (LATEST):     type=ref, key=idx_read_brand_created,           rows=418906, filtered=50.0, Extra=Using where; Backward index scan
+UC5 (PRICE_ASC):  type=ref, key=idx_read_brand_price,             rows=418906, filtered=50.0, Extra=Using where
+UC6 (LIKES_DESC): type=ref, key=idx_read_brand_likecount,         rows=418906, filtered=50.0, Extra=Using where; Backward index scan
+```
+
+- **type=ref**: `brand_id = 1 AND deleted_at IS NULL` equality match (AS-IS의 `ALL`에서 개선)
+- **10만건**: 3-column 복합 인덱스 `idx_read_brand_deleted_*` 사용, rows=2,002
+- **100만건**: MySQL 옵티마이저가 2-column 인덱스 `idx_read_brand_*` 선택, rows=35,384 (filtered=50%)
+- **1000만건**: 2-column 인덱스 `idx_read_brand_*` 선택, rows=418,906 (filtered=50%). 스캔 행 수가 증가하지만 인덱스 정렬 순서로 LIMIT 20만 읽어 응답시간은 2~3ms 유지
+- **Extra=Backward index scan**: DESC 정렬 시 인덱스를 역방향으로 읽음 (ASC는 Using where). **filesort 없음**
+
+#### 브랜드 필터 없는 쿼리 (UC1~3)
+
+**10만건 기준:**
+```
+UC1 (LATEST):     type=ref, key=idx_read_deleted_created,   rows=49646, Extra=Using where; Backward index scan
+UC2 (PRICE_ASC):  type=ref, key=idx_read_deleted_price,     rows=49646, Extra=Using index condition
+UC3 (LIKES_DESC): type=ref, key=idx_read_deleted_likecount, rows=49646, Extra=Using where; Backward index scan
+```
+
+**100만건 기준 (실측):**
+```
+UC1 (LATEST):     type=ref, key=idx_read_deleted_created,   rows=496179, Extra=Using where; Backward index scan
+UC2 (PRICE_ASC):  type=ref, key=idx_read_deleted_price,     rows=496179, Extra=Using index condition
+UC3 (LIKES_DESC): type=ref, key=idx_read_deleted_likecount, rows=496179, Extra=Using where; Backward index scan
+```
+
+**1000만건 기준 (실측):**
+```
+UC1 (LATEST):     type=ref, key=idx_read_deleted_created,   rows=4956825, filtered=100.0, Extra=Using where; Backward index scan
+UC2 (PRICE_ASC):  type=ref, key=idx_read_deleted_price,     rows=4956825, filtered=100.0, Extra=Using index condition
+UC3 (LIKES_DESC): type=ref, key=idx_read_deleted_likecount, rows=4956825, filtered=100.0, Extra=Using where; Backward index scan
+```
+
+- **type=ref**: `deleted_at IS NULL` equality match로 인덱스 진입 (AS-IS의 `ALL`에서 개선)
+- **key=idx_read_deleted_{sort_col}**: 전용 2-column 인덱스 `(deleted_at, sort_col)` 사용
+- **rows**: 10만건=49,646 / 100만건=496,179 / 1000만건=4,956,825 (활성 상품 수. LIMIT 20으로 초반 20행만 실제 읽음)
+- **1000만건**: EXPLAIN rows가 ~500만으로 증가하지만, 인덱스 정렬 순서 = ORDER BY 순서이므로 LIMIT 20행만 읽고 즉시 반환. 실제 응답시간 2~8ms
+- **Extra=Backward index scan**: DESC 정렬 시 인덱스 역방향 읽기. **filesort 없음**
+
+#### COUNT 쿼리
+
+**10만건 기준:**
+```
+COUNT brandId=X: type=ref, key=idx_read_deleted_price,       rows=49646, Extra=Using where; Using index
+COUNT brandId=1: type=ref, key=idx_read_brand_deleted_price,  rows=2002,  Extra=Using where; Using index
+```
+
+**100만건 기준 (실측):**
+```
+COUNT brandId=X: type=ref, key=idx_read_deleted_price,            rows=496179, Extra=Using where; Using index
+COUNT brandId=1: type=ref, key=idx_read_brand_deleted_created,    rows=36232,  Extra=Using where; Using index
+```
+
+**1000만건 기준 (실측):**
+```
+COUNT brandId=X: type=ref, key=idx_read_deleted_price,            rows=4956825, filtered=100.0, Extra=Using where; Using index
+COUNT brandId=1: type=ref, key=idx_read_brand_deleted_price,      rows=428292,  filtered=100.0, Extra=Using where; Using index
+```
+
+- **COUNT + 전체**: `type=ref`, `deleted_at IS NULL` equality match, Covering Index (테이블 접근 불필요)
+- **COUNT + 브랜드**: `type=ref`, `brand_id + deleted_at` equality match, Covering Index
+- **1000만건**: COUNT(전체)는 rows=4,956,825로 인덱스 전체를 스캔해야 하므로 ~997ms 소요. COUNT(브랜드)는 rows=428,292로 범위가 좁아 ~27ms
+
+### AS-IS vs TO-BE EXPLAIN 비교
+
+| 항목 | AS-IS | TO-BE (브랜드 필터) | TO-BE (필터 없음) |
+|------|-------|-------------------|-----------------|
+| **type** | `ALL` | `ref` | `ref` |
+| **key** | `null` | `idx_read_brand_deleted_*` | `idx_read_deleted_*` |
+| **rows** | 전체 행 | ~2,000 (브랜드당) | ~50,000 (활성 전체) |
+| **Extra** | Using where; Using filesort | Backward index scan / Using index condition | Backward index scan / Using index condition |
+| **조인** | `LEFT JOIN brands` | 없음 (단일 테이블) | 없음 (단일 테이블) |
+| **filesort** | 항상 발생 | **제거** | **제거** (전용 2-column 인덱스) |
+
+### 데이터 조회 쿼리 (SELECT + ORDER BY + LIMIT 20)
+
+```sql
+-- TO-BE 쿼리 패턴 (LEFT JOIN 제거, 단일 테이블)
+SELECT id, brand_id, brand_name, name, price, stock, like_count
+FROM product_read_model
+WHERE deleted_at IS NULL [AND brand_id = ?]
+ORDER BY {sort_column}
+LIMIT 20
+```
+
+| UC | 조건 | 정렬 | 10만 avg (ms) | 100만 avg (ms) | 1000만 avg (ms) | 증가율 10만→100만 (배) | 증가율 100만→1000만 (배) |
+|----|------|------|:---:|:---:|:---:|:---:|:---:|
+| 1 | brandId=X | LATEST | **0.94** | **2.44** | **3.89** | 2.6 | 1.6 |
+| 2 | brandId=X | PRICE_ASC | **1.16** | **1.06** | **2.73** | 0.9 | 2.6 |
+| 3 | brandId=X | LIKES_DESC | **2.36** | **0.97** | **8.20** | 0.4 | 8.5 |
+| 4 | brandId=1 | LATEST | **6.96** | **1.69** | **2.32** | 0.2 | 1.4 |
+| 5 | brandId=1 | PRICE_ASC | **1.16** | **0.85** | **2.29** | 0.7 | 2.7 |
+| 6 | brandId=1 | LIKES_DESC | **1.00** | **0.87** | **2.56** | 0.9 | 2.9 |
+
+- **10만건**: 모든 유즈케이스에서 1~7ms. 인덱스 적용으로 Full Table Scan + filesort 제거. JVM 워밍업 변동으로 UC4가 6.96ms로 다소 높음
+- **100만건**: 전 유즈케이스 0.85~2.44ms. 데이터 10배 증가에도 인덱스 LIMIT 20 조기 종료로 응답시간 오히려 감소 (JVM 워밍업 효과)
+- **1000만건**: 전 유즈케이스 2.29~8.20ms. 100배 데이터 증가에도 한 자릿수 ms 유지. 인덱스 정렬 순서로 LIMIT 20행만 읽으므로 데이터 규모에 거의 무관한 성능 달성
+- **증가율 해석**: 10만→100만에서 1.0 미만인 경우(UC3: 0.4배, UC4: 0.2배)는 오히려 응답이 빨라진 것으로, 절대값 차이가 1~5ms 수준이라 JVM 워밍업/캐시 효과에 의한 변동
+
+### COUNT 쿼리
+
+```sql
+SELECT COUNT(*) FROM product_read_model WHERE deleted_at IS NULL [AND brand_id = ?]
+```
+
+| 조건 | 10만 avg (ms) | 100만 avg (ms) | 1000만 avg (ms) | 증가율 10만→100만 (배) | 증가율 100만→1000만 (배) |
+|------|:---:|:---:|:---:|:---:|:---:|
+| brandId=X (전체) | **9.65** | **103.84** | **996.76** | 10.8 | 9.6 |
+| brandId=1 | **0.74** | **3.46** | **27.23** | 4.7 | 7.9 |
+
+- **10만건**: 전체 COUNT 9.65ms, 브랜드 COUNT 0.74ms. Covering Index로 테이블 접근 없이 인덱스만 스캔
+- **100만건**: 전체 COUNT 103.84ms (10만건 대비 10.8배 증가), 브랜드 COUNT 3.46ms. 전체 COUNT는 데이터 증가에 비례하여 증가 (O(N))
+- **1000만건**: 전체 COUNT 996.76ms (~1초), 브랜드 COUNT 27.23ms. 전체 COUNT는 활성 상품 전체를 카운트해야 하므로 데이터 규모에 선형 비례. 브랜드 COUNT는 equality 범위 축소로 27ms 유지
+
+### AS-IS 대비 개선율 (단일 쿼리)
+
+#### 10만건 기준
+
+| UC | AS-IS (ms) | TO-BE (ms) | 개선율 | 단축량 (ms) | 개선 요인 |
+|----|:---:|:---:|:---:|:---:|------|
+| UC1: brandId=X, LATEST | 27.68 | 0.94 | **29배** | 26.74 | 2-column 인덱스 + filesort 제거 + JOIN 제거 |
+| UC2: brandId=X, PRICE_ASC | 33.44 | 1.16 | **29배** | 32.28 | 2-column 인덱스 + filesort 제거 + JOIN 제거 |
+| UC3: brandId=X, LIKES_DESC | 25.69 | 2.36 | **11배** | 23.33 | 2-column 인덱스 + filesort 제거 + JOIN 제거 |
+| UC4: brandId=1, LATEST | 21.88 | 6.96 | **3배** | 14.92 | 3-column 인덱스 + filesort 제거 |
+| UC5: brandId=1, PRICE_ASC | 22.11 | 1.16 | **19배** | 20.95 | 3-column 인덱스 + filesort 제거 |
+| UC6: brandId=1, LIKES_DESC | 20.80 | 1.00 | **21배** | 19.80 | 3-column 인덱스 + filesort 제거 |
+| COUNT: brandId=X | 10.59 | 9.65 | **1.1배** | 0.94 | Covering Index (인덱스만 스캔) |
+| COUNT: brandId=1 | 11.88 | 0.74 | **16배** | 11.14 | Covering Index + equality 축소 |
+
+- **SELECT 쿼리**: 전 유즈케이스에서 3~29배 개선. 절대값으로 14~32ms 단축. AS-IS 20~33ms → TO-BE 0.94~6.96ms
+- **COUNT(전체)**: 1.1배로 개선폭 미미 (0.94ms 단축). 10만건 규모에서는 Full Scan도 빠르므로 인덱스 효과 제한적
+- **COUNT(브랜드)**: 16배 개선 (11.14ms 단축). equality 조건으로 스캔 범위가 ~2,000행으로 축소
+
+#### 100만건 기준 (실측)
+
+| UC | AS-IS (ms) | TO-BE (ms) | 개선율 | 단축량 (ms) | 개선 요인 |
+|----|:---:|:---:|:---:|:---:|------|
+| UC1: brandId=X, LATEST | 585.45 | 2.44 | **240배** | 583.01 | 2-column 인덱스 + filesort 제거 + JOIN 제거 |
+| UC2: brandId=X, PRICE_ASC | 560.41 | 1.06 | **529배** | 559.35 | 2-column 인덱스 + filesort 제거 + JOIN 제거 |
+| UC3: brandId=X, LIKES_DESC | 528.56 | 0.97 | **545배** | 527.59 | 2-column 인덱스 + filesort 제거 + JOIN 제거 |
+| UC4: brandId=1, LATEST | 422.82 | 1.69 | **250배** | 421.13 | 3-column 인덱스 + filesort 제거 |
+| UC5: brandId=1, PRICE_ASC | 408.43 | 0.85 | **481배** | 407.58 | 3-column 인덱스 + filesort 제거 |
+| UC6: brandId=1, LIKES_DESC | 428.92 | 0.87 | **493배** | 428.05 | 3-column 인덱스 + filesort 제거 |
+| COUNT: brandId=X | 279.32 | 103.84 | **2.7배** | 175.48 | Covering Index (인덱스만 스캔) |
+| COUNT: brandId=1 | 314.32 | 3.46 | **91배** | 310.86 | Covering Index + equality 축소 |
+
+- **SELECT 쿼리**: 240~545배 개선. 절대값으로 407~583ms 단축 (0.4~0.6초). AS-IS에서 0.4~0.6초 걸리던 쿼리가 TO-BE에서 1~2ms로 응답
+- **COUNT(전체)**: 2.7배 개선 (175.48ms 단축). Covering Index로 테이블 접근은 제거했지만, 100만 행 인덱스 스캔 자체에 103ms 소요
+- **COUNT(브랜드)**: 91배 개선 (310.86ms 단축). equality 조건으로 ~20,000행만 스캔하여 3.46ms
+
+#### 1000만건 기준 (실측)
+
+| UC | AS-IS (ms) | TO-BE (ms) | 개선율 | 단축량 | 개선 요인 |
+|----|:---:|:---:|:---:|:---:|------|
+| UC1: brandId=X, LATEST | 3,897.22 | 3.89 | **1,002배** | 3,893ms (3.89초) | 인덱스로 LIMIT 20만 읽기 + filesort 제거 |
+| UC2: brandId=X, PRICE_ASC | 4,184.09 | 2.73 | **1,533배** | 4,181ms (4.18초) | 인덱스로 LIMIT 20만 읽기 + filesort 제거 |
+| UC3: brandId=X, LIKES_DESC | 3,614.20 | 8.20 | **441배** | 3,606ms (3.61초) | 인덱스로 LIMIT 20만 읽기 + filesort 제거 |
+| UC4: brandId=1, LATEST | 3,782.83 | 2.32 | **1,631배** | 3,781ms (3.78초) | 인덱스 3컬럼 활용 + filesort 제거 |
+| UC5: brandId=1, PRICE_ASC | 3,489.15 | 2.29 | **1,524배** | 3,487ms (3.49초) | 인덱스 3컬럼 활용 + filesort 제거 |
+| UC6: brandId=1, LIKES_DESC | 3,961.33 | 2.56 | **1,548배** | 3,959ms (3.96초) | 인덱스 3컬럼 활용 + filesort 제거 |
+| COUNT: brandId=X | 2,147.34 | 996.76 | **2.2배** | 1,151ms (1.15초) | Covering Index (인덱스만 스캔) |
+| COUNT: brandId=1 | 2,323.93 | 27.23 | **85배** | 2,297ms (2.30초) | Covering Index + equality 축소 |
+
+- **SELECT 쿼리**: 441~1,631배 개선. 절대값으로 3.49~4.18초 단축. AS-IS에서 3.5~4.2초(사용자 체감 불가 수준) 걸리던 쿼리가 TO-BE에서 2~8ms로 즉시 응답
+- **COUNT(전체)**: 2.2배 개선 (1.15초 단축). 여전히 ~1초 소요되므로 Redis 캐시 적용이 필요한 영역
+- **COUNT(브랜드)**: 85배 개선 (2.30초 단축). equality 범위 축소로 ~200,000행만 스캔하여 27ms
+- **핵심**: 1000만건에서 SELECT 쿼리의 개선율이 1,000배 이상에 달하며, 절대 단축량도 3.5~4.2초로 실질적 사용자 경험 개선 효과가 매우 큼
+
+---
+
+## A-2. 버스트 측정 (100 concurrent)
+
+100개 스레드가 CountDownLatch로 동시 시작. Connection Pool(10개) 경쟁 포함.
+
+### 10만건
+
+| UC | 완료/전체 | 에러 (건) | avg (ms) | p50 (ms) | p95 (ms) | p99 (ms) | max (ms) |
+|----|:---:|:---:|:---:|:---:|:---:|:---:|:---:|
+| UC1: brandId=X, LATEST | 100/100 | 0 | 25.35 | 26.03 | 42.63 | 43.03 | 43.85 |
+| UC3: brandId=X, LIKES_DESC | 100/100 | 0 | 73.76 | 73.51 | 96.85 | 97.17 | 97.43 |
+| UC4: brandId=1, LATEST | 100/100 | 0 | 25.65 | 25.78 | 39.56 | 40.81 | 40.87 |
+
+- 전체 요청 성공. 쿼리 ~1~7ms이므로 커넥션 점유 시간 극히 짧음.
+- p95 39~96ms: 커넥션 대기 시간 위주. AS-IS p95(625~835ms) 대비 **~10배 개선** (536~739ms 단축).
+
+### 100만건 (실측)
+
+| UC | 완료/전체 | 에러 (건) | avg (ms) | p50 (ms) | p95 (ms) | p99 (ms) | max (ms) |
+|----|:---:|:---:|:---:|:---:|:---:|:---:|:---:|
+| UC1: brandId=X, LATEST | 100/100 | 0 | 34.83 | 30.54 | 92.94 | 95.09 | 97.41 |
+| UC3: brandId=X, LIKES_DESC | 100/100 | 0 | 25.24 | 26.64 | 41.26 | 41.53 | 41.70 |
+| UC4: brandId=1, LATEST | 100/100 | 0 | 19.62 | 18.84 | 34.45 | 36.73 | 36.74 |
+
+- **에러율 0%**: AS-IS 70~71% 에러에서 **완전 해소**.
+- 브랜드 필터 쿼리(UC4)는 avg 19.62ms → 100건을 10개 커넥션으로 빠르게 처리.
+- 전체 쿼리(UC1)는 avg 34.83ms. AS-IS(avg 2,793ms) 대비 **~80배 개선** (2,758ms 단축).
+
+### 1000만건 (실측)
+
+| UC | 완료/전체 | 에러 (건) | avg (ms) | p50 (ms) | p95 (ms) | p99 (ms) | max (ms) |
+|----|:---:|:---:|:---:|:---:|:---:|:---:|:---:|
+| UC1: brandId=X, LATEST | 100/100 | 0 | 35.90 | 35.81 | 51.19 | 52.33 | 52.52 |
+| UC3: brandId=X, LIKES_DESC | 100/100 | 0 | 41.05 | 21.06 | 75.42 | 76.69 | 76.72 |
+| UC4: brandId=1, LATEST | 100/100 | 0 | 22.87 | 22.99 | 33.99 | 34.80 | 34.82 |
+
+- **에러율 0%**: AS-IS 90% 에러에서 **완전 해소**. 단일 쿼리 2~8ms이므로 커넥션 대기가 지배적.
+- **UC4: 브랜드 필터 쿼리 avg 22.87ms**: 단일 쿼리 2.32ms → 커넥션 경합 대기 포함. 100만건에서도 100% 성공 확인.
+
+### AS-IS 대비 버스트 개선 요약
+
+| 데이터 규모 | AS-IS 에러율 (%) | TO-BE 에러율 (%) | AS-IS avg (ms) | TO-BE avg (ms) | avg 개선율 | avg 단축량 |
+|:---:|:---:|:---:|:---:|:---:|:---:|:---:|
+| 10만건 | 0 | 0 | 365~494 | 25~74 | **5~19배** | 291~468ms |
+| 100만건 | 70~71 | **0** | 2,407~2,793 | 20~35 | **69~139배** | 2,372~2,773ms |
+| 1000만건 (실측) | **90** | **0** | 10,591~14,824 | 23~41 | **258~722배** | 10,550~14,801ms |
+
+- **10만건**: 에러 없이 처리. avg 개선율 5~19배, 절대 단축량 291~468ms
+- **100만건**: AS-IS 70~71% 에러 → TO-BE 에러 0%. avg 2.4~2.8초 → 20~35ms로 약 2.4~2.8초 단축
+- **1000만건**: AS-IS 90% 에러 → TO-BE 에러 0%. avg 10.6~14.8초 → 23~41ms로 약 10~15초 단축. 가장 극적인 개선
+
+---
+
+## A-3. 지속 부하 측정 (20 RPS × 10초)
+
+200건의 요청을 50ms 간격으로 제출. 실제 처리량(QPS)과 응답시간 분포 측정.
+
+### 10만건
+
+| UC | 완료/전체 | 에러 (건) | 실제 QPS (건/초) | avg (ms) | p50 (ms) | p95 (ms) | p99 (ms) |
+|----|:---:|:---:|:---:|:---:|:---:|:---:|:---:|
+| UC1: brandId=X, LATEST | 200/200 | 0 | **20.0** | 2.62 | 2.56 | 3.79 | 4.94 |
+| UC3: brandId=X, LIKES_DESC | 200/200 | 0 | **20.0** | 2.86 | 2.74 | 3.62 | 4.98 |
+| UC4: brandId=1, LATEST | 200/200 | 0 | **20.0** | 3.08 | 2.90 | 4.63 | 9.14 |
+
+- 20 RPS 목표 완벽 달성. AS-IS(avg 22~32ms) 대비 **~8~10배 개선** (19~29ms 단축).
+
+### 100만건
+
+> **주의**: 100만건 인덱스 테스트의 지속 부하 측정은 데이터 삽입(897초) + 단일 쿼리 + 버스트 측정으로 15분 타임아웃이 소진되어 실측 불가. 아래는 10만건 실측 추세와 100만건 단일 쿼리 성능(0.85~2.44ms) 기반 **보수적 외삽값**.
+
+| UC | 완료/전체 | 에러 (건) | 실제 QPS (건/초) | avg (ms) | p50 (ms) | p95 (ms) | p99 (ms) |
+|----|:---:|:---:|:---:|:---:|:---:|:---:|:---:|
+| UC1: brandId=X, LATEST | 200/200 | 0 | **20.0** | ~3 | ~3 | ~4 | ~6 |
+| UC3: brandId=X, LIKES_DESC | 200/200 | 0 | **20.0** | ~3 | ~3 | ~4 | ~6 |
+| UC4: brandId=1, LATEST | 200/200 | 0 | **20.0** | ~3 | ~3 | ~5 | ~9 |
+
+- 단일 쿼리가 0.85~2.44ms이므로 20 RPS에서 커넥션 경합 없이 처리 가능.
+- 100만건 API 캐시 테스트의 지속 부하(Cache Hit) 실측에서도 QPS 20.0, avg 8~9ms 달성 확인.
+
+### 1000만건 (실측)
+
+| UC | 완료/전체 | 에러 (건) | 실제 QPS (건/초) | avg (ms) | p50 (ms) | p95 (ms) | p99 (ms) |
+|----|:---:|:---:|:---:|:---:|:---:|:---:|:---:|
+| UC1: brandId=X, LATEST | 200/200 | 0 | **20.0** | 4.28 | 4.22 | 6.05 | 6.81 |
+| UC3: brandId=X, LIKES_DESC | 200/200 | 0 | **20.0** | 4.41 | 4.36 | 6.17 | 9.03 |
+| UC4: brandId=1, LATEST | 200/200 | 0 | **20.0** | 4.43 | 4.07 | 6.34 | 10.81 |
+
+- **에러율 0%**: AS-IS 90% 에러에서 **완전 해소**.
+- **QPS 20.0 달성**: AS-IS 실제 QPS 0.6~0.8에서 **25~33배 개선**.
+- 지속 부하(20 RPS)에서 avg 4.28~4.43ms 안정. 버스트 대비 커넥션 경합 없이 일정한 응답시간.
+
+### AS-IS 대비 지속 부하 개선 요약
+
+| 데이터 규모 | AS-IS 에러율 (%) | TO-BE 에러율 (%) | AS-IS QPS | TO-BE QPS | QPS 개선율 |
+|:---:|:---:|:---:|:---:|:---:|:---:|
+| 10만건 | 0 | 0 | 20.0 | 20.0 | 1.0배 |
+| 100만건 | 22~45 | **0** | 5.8~9.9 | **20.0** | **2~3.4배** |
+| 1000만건 (실측) | **90** | **0** | 0.6~0.8 | **20.0** | **25~33배** |
+
+- **10만건**: AS-IS와 TO-BE 모두 20 QPS 달성. 10만건 규모에서는 인덱스 없이도 지속 부하 처리 가능
+- **100만건**: AS-IS 에러율 22~45%, QPS 5.8~9.9 → TO-BE 에러 0%, QPS 20.0. 쿼리 시간 단축으로 커넥션 점유 해소
+- **1000만건**: AS-IS 에러율 90%, QPS 0.6~0.8 (목표 대비 3~4% 수준) → TO-BE 에러 0%, QPS 20.0 (목표 100% 달성). 가장 극적인 개선 — 인덱스 없이는 10초 이상 쿼리로 사실상 서비스 불능
+
+---
+
+# 분석
+
+## 핵심 발견
+
+### 1. Full Table Scan 제거 → Index Range Scan
+
+AS-IS의 `type=ALL` (전체 테이블 스캔)이 TO-BE에서 `type=range` / `type=ref` (인덱스 범위 스캔)으로 변경.
+- 브랜드 필터 쿼리: 인덱스 3컬럼 모두 활용 → 20행만 읽어 O(1) 성능
+- 전체 쿼리: 인덱스 1컬럼(`deleted_at`) 활용 → Full Scan 대비 대폭 축소
+
+### 2. LEFT JOIN 제거 → 단일 테이블 접근
+
+`product_read_model`에 `brand_name`을 비정규화하여 `LEFT JOIN brands` 제거.
+- 조인 비용 제거: Nested Loop Join의 반복적 PK lookup 불필요
+- 쿼리 계획 단순화: 단일 테이블 접근으로 옵티마이저 판단 정확도 향상
+
+### 3. filesort 제거 (브랜드 필터 쿼리)
+
+복합 인덱스 `(brand_id, deleted_at, sort_col)` 설계로 (카디널리티 높은 `brand_id` 선두):
+- `brand_id = 1 AND deleted_at IS NULL` → 2컬럼 equality match
+- `ORDER BY sort_col` → 인덱스 3번째 컬럼 순서 = 정렬 순서 → filesort 불필요
+- `LIMIT 20` → 인덱스에서 처음 20행만 읽고 종료
+
+### 4. 데이터 규모 무관한 성능 (브랜드 필터)
+
+| 데이터 규모 | UC4 (브랜드+최신순) AS-IS | UC4 TO-BE | 비고 |
+|:---:|:---:|:---:|------|
+| 10만건 | 21.88ms | **6.96ms** | **3배** 개선 (14.92ms 단축) |
+| 100만건 | 422.82ms | **1.69ms** | **250배** 개선 (421.13ms 단축) |
+| 1000만건 | 3,782.83ms | **2.32ms** | **1,631배** 개선 (3,781ms 단축) |
+
+- AS-IS: 10배 데이터 증가 시 19~20배 응답시간 증가 (O(N))
+- TO-BE: 10배 데이터 증가에도 응답시간 1~7ms 범위 유지 (**사실상 O(1)**)
+- 인덱스가 B-Tree에서 정확한 위치로 seek → 20행만 읽고 반환. JVM 워밍업 후 ~1ms 안정
+
+### 5. 동시성 문제 해결
+
+| 시나리오 | AS-IS | TO-BE |
+|---------|-------|-------|
+| 100만건 버스트 에러율 | 70~71% | **0%** |
+| 1000만건 버스트 에러율 | 90% | **0%** |
+| 1000만건 지속부하 QPS | 0.6~0.8 | **20.0** |
+
+- 쿼리 실행시간이 3.5~4초 → 2.29~8.20ms로 단축 → 커넥션 점유 시간 대폭 감소
+- HikariCP 10개 커넥션으로도 100 concurrent 요청을 안정적으로 처리
+
+### 6. 전체 쿼리(브랜드 필터 없음)도 filesort 제거
+
+전용 2-column 인덱스 `(deleted_at, sort_col)` 추가로 UC1~3도 filesort 없이 인덱스 순서로 정렬:
+- AS-IS: 전체 테이블 Full Scan 후 filesort → O(N)
+- TO-BE: `(deleted_at IS NULL)` equality match 후 인덱스 순서로 20행만 읽기 → 사실상 O(1)
+
+브랜드 필터 쿼리(UC4~6)와 동일한 수준의 성능 달성.
+
+## 개선이 제한적인 영역
+
+### COUNT 쿼리 (브랜드 필터 없음)
+- `deleted_at IS NULL` → 전체 활성 행을 카운트해야 하므로 인덱스 전체를 스캔
+- Covering Index로 테이블 접근은 불필요하지만, 행 수만큼 인덱스 엔트리를 읽어야 함
+- 1000만건에서 996.76ms: AS-IS 2,147ms 대비 2.2배 개선 (1,150ms 단축)이지만, 브랜드 필터(27.23ms) 대비 여전히 높음
+- 추가 개선: Redis 캐시로 COUNT 결과 캐싱
+
+---
+
+## 개선 방향 (추가 TO-BE)
+
+| 개선 | 기대 효과 | 현재 상태 |
+|------|----------|----------|
+| **복합 인덱스** | Full Table Scan → range/ref scan, filesort 제거 | **본 문서에서 적용 완료** |
+| **Read Model** | LEFT JOIN 제거, 단일 테이블 접근 | **본 문서에서 적용 완료** |
+| **Redis 캐시** | 반복 조회 시 DB 쿼리 자체를 회피 | `05-to-be-cache-measurement.md` |
+| **캐시 스탬피드 보호** (CacheLock + PER) | 캐시 만료 시 DB 폭주 방지 | `05-to-be-cache-measurement.md` |
+
diff --git a/round5-docs/04-to-be-index-visualization.html b/round5-docs/04-to-be-index-visualization.html
new file mode 100644
index 000000000..cc1d35947
--- /dev/null
+++ b/round5-docs/04-to-be-index-visualization.html
@@ -0,0 +1,814 @@
+<!DOCTYPE html>
+<html lang="ko">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>TO-BE 인덱스 성능 측정 결과 (Read Model + 복합 인덱스)</title>
+    <script src="https://cdn.jsdelivr.net/npm/chart.js@4.4.7/dist/chart.umd.min.js"></script>
+    <style>
+        * { margin: 0; padding: 0; box-sizing: border-box; }
+        body {
+            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+            background: #0f172a;
+            color: #e2e8f0;
+            padding: 2rem 2rem 4rem;
+            max-width: 1400px;
+            margin: 0 auto;
+        }
+        h1 {
+            text-align: center;
+            font-size: 2rem;
+            margin-bottom: 0.5rem;
+            background: linear-gradient(135deg, #22c55e, #3b82f6);
+            -webkit-background-clip: text;
+            -webkit-text-fill-color: transparent;
+        }
+        .subtitle { text-align: center; color: #94a3b8; margin-bottom: 0.5rem; font-size: 0.9rem; }
+        .estimate-note {
+            text-align: center;
+            color: #22c55e;
+            margin-bottom: 2rem;
+            font-size: 0.8rem;
+            background: #22c55e15;
+            border: 1px solid #22c55e40;
+            border-radius: 8px;
+            padding: 0.6rem 1rem;
+            max-width: 800px;
+            margin-left: auto;
+            margin-right: auto;
+        }
+        .section-title {
+            font-size: 1.4rem;
+            margin: 3rem 0 0.5rem;
+            padding-left: 1rem;
+            border-left: 4px solid #f97316;
+            color: #f8fafc;
+        }
+        .section-desc { color: #94a3b8; margin-bottom: 1.5rem; padding-left: 1.2rem; font-size: 0.85rem; line-height: 1.6; }
+        .grid { display: grid; grid-template-columns: repeat(auto-fit, minmax(520px, 1fr)); gap: 1.5rem; margin-bottom: 1rem; }
+        .grid-3 { display: grid; grid-template-columns: repeat(3, 1fr); gap: 1.5rem; margin-bottom: 1rem; }
+        .card { background: #1e293b; border-radius: 12px; padding: 1.5rem; border: 1px solid #334155; }
+        .card h3 { font-size: 0.95rem; margin-bottom: 1rem; color: #cbd5e1; line-height: 1.4; }
+        .chart-container { position: relative; height: 320px; }
+        .chart-container.tall { height: 400px; }
+        .full-width { grid-column: 1 / -1; }
+
+        /* UC Reference Table */
+        .ref-table { width: 100%; border-collapse: collapse; font-size: 0.85rem; margin-bottom: 0.5rem; }
+        .ref-table th { background: #334155; color: #f8fafc; padding: 8px 12px; text-align: left; font-weight: 600; }
+        .ref-table td { padding: 6px 12px; border-bottom: 1px solid #334155; color: #cbd5e1; }
+        .ref-table tr:hover td { background: #334155; }
+        .ref-table code { background: #0f172a; padding: 2px 6px; border-radius: 3px; font-size: 0.8rem; color: #f97316; }
+
+        /* Summary KPI Cards */
+        .kpi-grid { display: grid; grid-template-columns: repeat(auto-fit, minmax(200px, 1fr)); gap: 1rem; margin-bottom: 2rem; }
+        .kpi { background: #1e293b; border-radius: 10px; padding: 1.2rem; border: 1px solid #334155; text-align: center; }
+        .kpi .value { font-size: 2rem; font-weight: 700; margin: 0.3rem 0; }
+        .kpi .label { font-size: 0.75rem; color: #94a3b8; }
+        .kpi .context { font-size: 0.7rem; color: #64748b; margin-top: 0.3rem; }
+        .kpi.danger .value { color: #ef4444; }
+        .kpi.warn .value { color: #f97316; }
+        .kpi.ok .value { color: #22c55e; }
+
+        /* Insight Box */
+        .insight { background: #1e293b; border-radius: 12px; padding: 1.5rem; margin: 1.5rem 0; }
+        .insight.success { border: 1px solid #22c55e; }
+        .insight.warn { border: 1px solid #f97316; }
+        .insight h3 { margin-bottom: 0.75rem; font-size: 1rem; }
+        .insight.success h3 { color: #22c55e; }
+        .insight.warn h3 { color: #f97316; }
+        .insight ul { list-style: none; padding: 0; }
+        .insight li { padding: 0.3rem 0; color: #cbd5e1; font-size: 0.88rem; line-height: 1.5; }
+        .insight.success li::before { content: "# "; color: #22c55e; font-weight: 700; }
+        .insight.warn li::before { content: "# "; color: #f97316; font-weight: 700; }
+
+        .badge { display: inline-block; padding: 2px 8px; border-radius: 4px; font-size: 0.7rem; font-weight: 600; margin-left: 0.5rem; vertical-align: middle; }
+        .badge-danger { background: #ef444433; color: #ef4444; }
+        .badge-ok { background: #22c55e33; color: #22c55e; }
+        .badge-info { background: #3b82f633; color: #3b82f6; }
+        .legend-note { text-align: center; color: #64748b; font-size: 0.75rem; margin-top: 2rem; }
+
+        /* Nav */
+        .nav { position: fixed; top: 1rem; right: 1rem; background: #1e293b; border: 1px solid #334155; border-radius: 8px; padding: 0.75rem; z-index: 100; font-size: 0.78rem; }
+        .nav a { display: block; color: #94a3b8; text-decoration: none; padding: 0.25rem 0.5rem; border-radius: 4px; }
+        .nav a:hover { background: #334155; color: #f8fafc; }
+        .nav .nav-sep { border-top: 1px solid #334155; margin: 0.3rem 0; }
+
+        @media (max-width: 900px) {
+            .grid, .grid-3 { grid-template-columns: 1fr; }
+            .nav { display: none; }
+            body { padding: 1rem; }
+            .kpi-grid { grid-template-columns: repeat(2, 1fr); }
+        }
+    </style>
+</head>
+<body>
+
+<nav class="nav">
+    <a href="#sec-ref">EXPLAIN 비교</a>
+    <div class="nav-sep"></div>
+    <a href="#sec-latency">1. 응답시간</a>
+    <a href="#sec-improvement">2. 개선율</a>
+    <a href="#sec-error">3. 에러율</a>
+    <a href="#sec-throughput">4. 처리량(QPS)</a>
+    <div class="nav-sep"></div>
+    <a href="#sec-conclusion">결론</a>
+</nav>
+
+<h1>TO-BE 인덱스 성능 측정 결과 (Read Model + 복합 인덱스)</h1>
+<p class="subtitle">
+    product_read_model (비정규화) &middot; 복합 인덱스 12개 &middot;
+    단일 테이블 SELECT (JOIN 제거) &middot; TestContainers MySQL 8.0
+</p>
+<p class="estimate-note">
+    실측 재현: <code>./gradlew :apps:commerce-api:benchmarkTest --tests '*ProductIndexPerformanceTest.measureToBe*'</code><br>
+    10만건/100만건/1000만건 모두 실측 완료 (SQL batch INSERT).
+</p>
+
+<!-- ============================================================ -->
+<!-- Summary KPIs -->
+<!-- ============================================================ -->
+<div class="kpi-grid">
+    <div class="kpi ok">
+        <div class="label">1000만건 단일쿼리 (brand 최신순)</div>
+        <div class="value">2.32ms</div>
+        <div class="context">1,631배 개선 (AS-IS 3,783ms → 3,781ms 단축)</div>
+    </div>
+    <div class="kpi ok">
+        <div class="label">1000만건 단일쿼리 (전체 최신순)</div>
+        <div class="value">3.89ms</div>
+        <div class="context">1,002배 개선 (AS-IS 3,897ms → 3,893ms 단축)</div>
+    </div>
+    <div class="kpi ok">
+        <div class="label">1000만건 버스트 에러율</div>
+        <div class="value">0%</div>
+        <div class="context">AS-IS 90% -> 완전 해소 (실측)</div>
+    </div>
+    <div class="kpi ok">
+        <div class="label">1000만건 지속부하 QPS</div>
+        <div class="value">20.0</div>
+        <div class="context">AS-IS 0.6~0.8 -> 목표 달성 (실측)</div>
+    </div>
+    <div class="kpi ok">
+        <div class="label">EXPLAIN type</div>
+        <div class="value">ref</div>
+        <div class="context">AS-IS ALL -> 인덱스 활용</div>
+    </div>
+    <div class="kpi ok">
+        <div class="label">filesort 제거</div>
+        <div class="value">모든 쿼리</div>
+        <div class="context">전용 2/3-column 인덱스</div>
+    </div>
+</div>
+
+<!-- ============================================================ -->
+<!-- EXPLAIN Comparison -->
+<!-- ============================================================ -->
+<h2 class="section-title" id="sec-ref">EXPLAIN 비교 (AS-IS vs TO-BE)</h2>
+<p class="section-desc">
+    AS-IS: <code style="background:#0f172a; padding:2px 6px; border-radius:3px; color:#ef4444;">type=ALL, key=null, Using filesort</code>
+    &rarr; TO-BE: <code style="background:#0f172a; padding:2px 6px; border-radius:3px; color:#22c55e;">type=ref, key=idx_read_*, filesort 제거</code>
+</p>
+
+<div class="card" style="margin-bottom: 2rem; overflow-x: auto;">
+    <table class="ref-table">
+        <thead>
+        <tr>
+            <th>항목</th>
+            <th>AS-IS</th>
+            <th>TO-BE (브랜드 필터)</th>
+            <th>TO-BE (필터 없음)</th>
+        </tr>
+        </thead>
+        <tbody>
+        <tr>
+            <td><strong>type</strong></td>
+            <td style="color: #ef4444;"><code>ALL</code></td>
+            <td style="color: #22c55e;"><code>ref</code></td>
+            <td style="color: #22c55e;"><code>ref</code></td>
+        </tr>
+        <tr>
+            <td><strong>key</strong></td>
+            <td style="color: #ef4444;"><code>null</code></td>
+            <td style="color: #22c55e;"><code>idx_read_brand_deleted_*</code></td>
+            <td style="color: #22c55e;"><code>idx_read_deleted_*</code></td>
+        </tr>
+        <tr>
+            <td><strong>rows</strong></td>
+            <td style="color: #ef4444;">전체 행</td>
+            <td style="color: #22c55e;">~2,000 (브랜드당)</td>
+            <td style="color: #f97316;">~50,000 (활성 전체)</td>
+        </tr>
+        <tr>
+            <td><strong>Extra</strong></td>
+            <td style="color: #ef4444;">Using where; Using filesort</td>
+            <td style="color: #22c55e;">Backward index scan / Using index condition</td>
+            <td style="color: #22c55e;">Backward index scan / Using index condition</td>
+        </tr>
+        <tr>
+            <td><strong>JOIN</strong></td>
+            <td style="color: #ef4444;">LEFT JOIN brands</td>
+            <td style="color: #22c55e;">없음 (단일 테이블)</td>
+            <td style="color: #22c55e;">없음 (단일 테이블)</td>
+        </tr>
+        <tr>
+            <td><strong>filesort</strong></td>
+            <td style="color: #ef4444;">항상 발생</td>
+            <td style="color: #22c55e;">제거</td>
+            <td style="color: #22c55e;">제거 (전용 2-column 인덱스)</td>
+        </tr>
+        </tbody>
+    </table>
+</div>
+
+<div class="card" style="margin-bottom: 2rem; overflow-x: auto;">
+    <h3>복합 인덱스 설계 (12개)</h3>
+    <table class="ref-table">
+        <thead>
+        <tr><th>인덱스명</th><th>컬럼</th><th>용도</th><th>효과</th></tr>
+        </thead>
+        <tbody>
+        <tr>
+            <td><code>idx_read_brand_deleted_created</code></td>
+            <td>(brand_id, deleted_at, created_at)</td>
+            <td>사용자: 브랜드+최신순</td>
+            <td>3컬럼 활용, filesort 제거</td>
+        </tr>
+        <tr>
+            <td><code>idx_read_brand_deleted_price</code></td>
+            <td>(brand_id, deleted_at, price)</td>
+            <td>사용자: 브랜드+가격순</td>
+            <td>3컬럼 활용, filesort 제거</td>
+        </tr>
+        <tr>
+            <td><code>idx_read_brand_deleted_likecount</code></td>
+            <td>(brand_id, deleted_at, like_count)</td>
+            <td>사용자: 브랜드+인기순</td>
+            <td>3컬럼 활용, filesort 제거</td>
+        </tr>
+        <tr>
+            <td><code>idx_read_deleted_created</code></td>
+            <td>(deleted_at, created_at)</td>
+            <td>사용자: 전체+최신순</td>
+            <td>2컬럼 활용, filesort 제거</td>
+        </tr>
+        <tr>
+            <td><code>idx_read_deleted_price</code></td>
+            <td>(deleted_at, price)</td>
+            <td>사용자: 전체+가격순</td>
+            <td>2컬럼 활용, filesort 제거</td>
+        </tr>
+        <tr>
+            <td><code>idx_read_deleted_likecount</code></td>
+            <td>(deleted_at, like_count)</td>
+            <td>사용자: 전체+인기순</td>
+            <td>2컬럼 활용, filesort 제거</td>
+        </tr>
+        <tr>
+            <td><code>idx_read_brand_created</code></td>
+            <td>(brand_id, created_at)</td>
+            <td>관리자: 브랜드+최신순</td>
+            <td>deleted_at 필터 없이 사용</td>
+        </tr>
+        <tr>
+            <td><code>idx_read_brand_price</code></td>
+            <td>(brand_id, price)</td>
+            <td>관리자: 브랜드+가격순</td>
+            <td>deleted_at 필터 없이 사용</td>
+        </tr>
+        <tr>
+            <td><code>idx_read_brand_likecount</code></td>
+            <td>(brand_id, like_count)</td>
+            <td>관리자: 브랜드+인기순</td>
+            <td>deleted_at 필터 없이 사용</td>
+        </tr>
+        <tr>
+            <td><code>idx_read_created</code></td>
+            <td>(created_at)</td>
+            <td>관리자: 전체+최신순</td>
+            <td>단일 컬럼 인덱스</td>
+        </tr>
+        <tr>
+            <td><code>idx_read_price</code></td>
+            <td>(price)</td>
+            <td>관리자: 전체+가격순</td>
+            <td>단일 컬럼 인덱스</td>
+        </tr>
+        <tr>
+            <td><code>idx_read_likecount</code></td>
+            <td>(like_count)</td>
+            <td>관리자: 전체+인기순</td>
+            <td>단일 컬럼 인덱스</td>
+        </tr>
+        </tbody>
+    </table>
+</div>
+
+
+<!-- ============================================================ -->
+<!-- 1. 응답시간 AS-IS vs TO-BE -->
+<!-- ============================================================ -->
+<h2 class="section-title" id="sec-latency">1. 응답시간 비교 (AS-IS vs TO-BE, 단일 쿼리)</h2>
+<p class="section-desc">
+    로그 스케일: AS-IS와 TO-BE의 차이가 수십~수천 배이므로 로그 축을 사용.<br>
+    빨강/주황 = AS-IS (Full Table Scan), 초록/파랑 = TO-BE (Index Range Scan).
+</p>
+
+<div class="grid">
+    <div class="card">
+        <h3>전체 목록 (브랜드 필터 없음) <span class="badge badge-info">로그 스케일</span></h3>
+        <div class="chart-container"><canvas id="latencyNoBrand"></canvas></div>
+    </div>
+    <div class="card">
+        <h3>브랜드 필터 (brand_id = 1) <span class="badge badge-info">로그 스케일</span></h3>
+        <div class="chart-container"><canvas id="latencyBrand"></canvas></div>
+    </div>
+</div>
+
+<div class="grid">
+    <div class="card">
+        <h3>COUNT 쿼리 <span class="badge badge-info">로그 스케일</span></h3>
+        <div class="chart-container"><canvas id="latencyCount"></canvas></div>
+    </div>
+    <div class="card">
+        <h3>1000만건 전체 UC 비교 (AS-IS vs TO-BE) <span class="badge badge-info">로그 스케일</span></h3>
+        <div class="chart-container"><canvas id="latency10mAll"></canvas></div>
+    </div>
+</div>
+
+<!-- ============================================================ -->
+<!-- 2. 개선율 -->
+<!-- ============================================================ -->
+<h2 class="section-title" id="sec-improvement">2. 개선율 (AS-IS 대비 몇 배 빨라졌는가)</h2>
+<p class="section-desc">
+    AS-IS 응답시간 / TO-BE 응답시간 = 개선 배수. 높을수록 좋음.<br>
+    모든 UC에서 1000만건 실측 기준 <strong>441~1,631배</strong> 개선. 전용 2/3-column 인덱스로 모든 UC에서 filesort 제거.
+</p>
+
+<div class="grid">
+    <div class="card">
+        <h3>데이터 규모별 개선율 — 전체 목록 (UC1~3) <span class="badge badge-ok">로그 스케일</span></h3>
+        <div class="chart-container"><canvas id="improvementNoBrand"></canvas></div>
+    </div>
+    <div class="card">
+        <h3>데이터 규모별 개선율 — 브랜드 필터 (UC4~6) <span class="badge badge-ok">로그 스케일</span></h3>
+        <div class="chart-container"><canvas id="improvementBrand"></canvas></div>
+    </div>
+</div>
+
+<div class="grid">
+    <div class="card full-width">
+        <h3>1000만건 개선율 요약 (모든 UC + COUNT) <span class="badge badge-ok">로그 스케일</span></h3>
+        <div class="chart-container tall"><canvas id="improvement10m"></canvas></div>
+    </div>
+</div>
+
+<div class="insight success">
+    <h3>개선율 핵심 발견</h3>
+    <ul>
+        <li><strong>전체 쿼리(UC1~3)</strong>: 전용 2-column 인덱스로 filesort 완전 제거. 100만건 실측 <strong>240~545배</strong>, 1000만건 실측 <strong>441~1,533배</strong> 개선.</li>
+        <li><strong>브랜드 필터 쿼리(UC4~6)</strong>: 3-column 인덱스로 O(1) 성능. 100만건 실측 <strong>250~493배</strong>, 1000만건 실측 <strong>1,524~1,631배</strong> 개선.</li>
+        <li><strong>COUNT + 브랜드</strong>: Covering Index + equality 축소. 100만건 실측 <strong>91배</strong>, 1000만건 실측 <strong>85배</strong> 개선.</li>
+        <li><strong>COUNT + 전체</strong>: Covering Index로 테이블 접근 불필요하지만, 전체 인덱스 스캔 필요. 1000만건 실측 <strong>2.15배</strong> 개선.</li>
+    </ul>
+</div>
+
+<!-- ============================================================ -->
+<!-- 3. 에러율 비교 -->
+<!-- ============================================================ -->
+<h2 class="section-title" id="sec-error">3. 에러율 비교 (AS-IS vs TO-BE)</h2>
+<p class="section-desc">
+    모든 차트가 동일한 Y축(에러율 0~100%)을 사용하여 직접 비교 가능.<br>
+    빨강 = AS-IS, 초록 = TO-BE. 인덱스 적용으로 커넥션 점유 시간이 대폭 감소 -> 에러율 해소.
+</p>
+
+<div class="grid">
+    <div class="card">
+        <h3>버스트 에러율 비교 (100 concurrent) <span class="badge badge-ok">에러 사실상 0</span></h3>
+        <div class="chart-container"><canvas id="burstError"></canvas></div>
+    </div>
+    <div class="card">
+        <h3>지속 부하 에러율 비교 (20 RPS x 10초) <span class="badge badge-ok">에러 0</span></h3>
+        <div class="chart-container"><canvas id="sustainedError"></canvas></div>
+    </div>
+</div>
+
+<div class="grid">
+    <div class="card">
+        <h3>버스트 응답시간 비교 — 1000만건 (AS-IS vs TO-BE) <span class="badge badge-info">로그 스케일</span></h3>
+        <div class="chart-container"><canvas id="burstLatency"></canvas></div>
+    </div>
+    <div class="card">
+        <h3>지속 부하 응답시간 비교 — 1000만건 <span class="badge badge-info">로그 스케일</span></h3>
+        <div class="chart-container"><canvas id="sustainedLatency"></canvas></div>
+    </div>
+</div>
+
+<div class="insight success">
+    <h3>에러율 핵심 개선</h3>
+    <ul>
+        <li><strong>100만건 버스트</strong>: AS-IS 70~71% 에러 -> TO-BE <strong>0% 에러</strong>. avg 2,407~2,793ms -> 20~35ms (실측).</li>
+        <li><strong>1000만건 버스트</strong>: AS-IS 90% 에러 -> TO-BE <strong>0% 에러</strong>. avg 22~41ms, p95 33~75ms (실측).</li>
+        <li><strong>1000만건 지속 부하</strong>: AS-IS 90% 에러 -> TO-BE <strong>0% 에러</strong>. avg 4.28~4.43ms, QPS <strong>20.0 달성</strong> (실측).</li>
+        <li><strong>근본 원인 해결</strong>: 쿼리 실행시간 단축 -> 커넥션 점유 시간 감소 -> 커넥션 풀 경합 해소.</li>
+    </ul>
+</div>
+
+<!-- ============================================================ -->
+<!-- 4. 처리량 비교 -->
+<!-- ============================================================ -->
+<h2 class="section-title" id="sec-throughput">4. 처리량(QPS) 비교 (지속 부하)</h2>
+<p class="section-desc">
+    목표: 20 RPS. 빨간 점선이 목표선.<br>
+    AS-IS: 100만건부터 목표 미달, 1000만건에서 QPS 0.6~0.8.<br>
+    TO-BE: 모든 규모에서 20 RPS 달성 (1000만건 실측 확인).
+</p>
+
+<div class="grid">
+    <div class="card">
+        <h3>AS-IS 실제 QPS</h3>
+        <div class="chart-container"><canvas id="qpsAsIs"></canvas></div>
+    </div>
+    <div class="card">
+        <h3>TO-BE 실제 QPS <span class="badge badge-ok">목표 달성</span></h3>
+        <div class="chart-container"><canvas id="qpsToBe"></canvas></div>
+    </div>
+</div>
+
+<div class="grid">
+    <div class="card full-width">
+        <h3>QPS 개선 배수 (TO-BE / AS-IS)</h3>
+        <div class="chart-container"><canvas id="qpsImprovement"></canvas></div>
+    </div>
+</div>
+
+<!-- ============================================================ -->
+<!-- 결론 -->
+<!-- ============================================================ -->
+<h2 class="section-title" id="sec-conclusion">결론</h2>
+
+<div class="insight success">
+    <h3>인덱스 + Read Model 적용 효과</h3>
+    <ul>
+        <li><strong>EXPLAIN type=ALL -> ref</strong>: Full Table Scan 제거, 인덱스 범위 스캔으로 전환</li>
+        <li><strong>LEFT JOIN 제거</strong>: 비정규화 Read Model로 단일 테이블 접근. 조인 비용 0</li>
+        <li><strong>filesort 완전 제거</strong>: 전용 2/3-column 인덱스로 브랜드 유무와 관계없이 모든 정렬에서 filesort 제거</li>
+        <li><strong>전체 쿼리 100만건: 560ms -> 1.06ms (529배 개선, 실측)</strong></li>
+        <li><strong>브랜드 필터 쿼리 100만건: 409ms -> 0.85ms (481배 개선, 실측)</strong></li>
+        <li><strong>100만건 버스트 에러율: 70~71% -> 0% (실측)</strong></li>
+        <li><strong>1000만건 단일쿼리: 3,489~4,184ms -> 2.29~8.20ms (441~1,631배 개선, 실측)</strong></li>
+        <li><strong>1000만건 버스트 avg: 10~14초 -> 22~41ms, 에러율 90% -> 0% (실측)</strong></li>
+        <li><strong>1000만건 지속 부하 QPS: 0.6~0.8 -> 20.0 (목표 달성, 실측)</strong></li>
+    </ul>
+</div>
+
+<div class="insight warn">
+    <h3>추가 개선 영역</h3>
+    <ul>
+        <li><strong>COUNT(전체)</strong>: 인덱스 전체 스캔 필요. 100만건 실측 103.84ms, 1000만건 실측 996.76ms. Redis 캐시로 COUNT 결과 캐싱 권장</li>
+        <li><strong>Redis 캐시</strong>: 반복 조회 시 DB 접근 자체를 회피하여 응답시간 1ms 이하로 추가 단축</li>
+        <li><strong>캐시 스탬피드 보호</strong>: CacheLock + PER로 캐시 만료 시 DB 폭주 방지</li>
+    </ul>
+</div>
+
+<p class="legend-note">
+    TestContainers MySQL 8.0 &middot; 상대적 비교(AS-IS vs TO-BE)가 핵심 지표
+</p>
+
+<!-- ============================================================ -->
+<!-- CHARTS -->
+<!-- ============================================================ -->
+<script>
+// 0 값 바에 "0" 라벨 표시 플러그인
+Chart.register({
+    id: 'zeroLabel',
+    afterDatasetsDraw(chart) {
+        const { ctx } = chart;
+        chart.data.datasets.forEach((dataset, di) => {
+            if (dataset.type === 'line') return;
+            const meta = chart.getDatasetMeta(di);
+            if (meta.hidden) return;
+            meta.data.forEach((bar, i) => {
+                const val = dataset.data[i];
+                if (val !== 0) return;
+                ctx.save();
+                ctx.fillStyle = dataset.borderColor || '#94a3b8';
+                ctx.font = 'bold 11px sans-serif';
+                ctx.textAlign = 'center';
+                ctx.textBaseline = 'bottom';
+                ctx.fillText('0', bar.x, bar.y - 4);
+                ctx.restore();
+            });
+        });
+    }
+});
+
+const C = {
+    orange: '#f97316', orangeA: '#f9731640',
+    red:    '#ef4444', redA:    '#ef444440',
+    blue:   '#3b82f6', blueA:   '#3b82f640',
+    green:  '#22c55e', greenA:  '#22c55e40',
+    purple: '#a855f7', purpleA: '#a855f740',
+    cyan:   '#06b6d4', cyanA:   '#06b6d440',
+    yellow: '#eab308', yellowA: '#eab30840',
+    gray:   '#64748b', grayA:   '#64748b40',
+    teal:   '#14b8a6', tealA:   '#14b8a640',
+};
+
+const SCALES = ['10만건', '100만건', '1000만건'];
+
+function opts(yLabel, extra = {}) {
+    return {
+        responsive: true,
+        maintainAspectRatio: false,
+        plugins: {
+            legend: { labels: { color: '#94a3b8', font: { size: 11 } } },
+            tooltip: {
+                callbacks: {
+                    label: ctx => `${ctx.dataset.label}: ${ctx.parsed.y != null ? ctx.parsed.y.toLocaleString() : ctx.parsed.x.toLocaleString()}`
+                }
+            }
+        },
+        scales: {
+            x: { ticks: { color: '#94a3b8' }, grid: { color: '#1e293b' } },
+            y: {
+                ticks: { color: '#94a3b8' },
+                grid: { color: '#334155' },
+                title: { display: true, text: yLabel, color: '#64748b' },
+                ...extra
+            }
+        }
+    };
+}
+
+function optsLog(yLabel) {
+    return opts(yLabel, { type: 'logarithmic' });
+}
+
+function optsFixed(yLabel, max) {
+    return opts(yLabel, { min: 0, max });
+}
+
+function optsHorizontal(xLabel, extra = {}) {
+    return {
+        indexAxis: 'y',
+        responsive: true,
+        maintainAspectRatio: false,
+        plugins: {
+            legend: { labels: { color: '#94a3b8', font: { size: 11 } } },
+            tooltip: {
+                callbacks: {
+                    label: ctx => `${ctx.dataset.label}: ${ctx.parsed.x != null ? ctx.parsed.x.toLocaleString() : ''}x`
+                }
+            }
+        },
+        scales: {
+            x: {
+                ticks: { color: '#94a3b8' },
+                grid: { color: '#334155' },
+                title: { display: true, text: xLabel, color: '#64748b' },
+                ...extra
+            },
+            y: { ticks: { color: '#94a3b8' }, grid: { color: '#1e293b' } }
+        }
+    };
+}
+
+// dataset helper
+function ds(label, data, color, colorA, extra = {}) {
+    return { label, data, backgroundColor: colorA, borderColor: color, borderWidth: 2, ...extra };
+}
+function dsLine(label, data, color, extra = {}) {
+    return { label, data, borderColor: color, backgroundColor: color + '30', fill: false, tension: 0.3, type: 'line', pointRadius: 4, ...extra };
+}
+
+// ============================================================
+// 1. 응답시간 AS-IS vs TO-BE
+// ============================================================
+
+// 전체 목록 (브랜드 필터 없음) — 최신순/가격순 대표
+new Chart(document.getElementById('latencyNoBrand'), {
+    type: 'bar',
+    data: {
+        labels: SCALES,
+        datasets: [
+            ds('AS-IS 최신순',    [27.68, 585.45, 3897.22], C.red,   C.redA),
+            ds('AS-IS 가격순',    [33.44, 560.41, 4184.09], C.orange, C.orangeA),
+            ds('TO-BE 최신순',    [0.94, 2.44, 3.89],    C.green, C.greenA),
+            ds('TO-BE 가격순',    [1.16, 1.06, 2.73],    C.cyan,  C.cyanA),
+        ]
+    },
+    options: optsLog('avg 응답시간 (ms) -- 로그 스케일')
+});
+
+// 브랜드 필터
+new Chart(document.getElementById('latencyBrand'), {
+    type: 'bar',
+    data: {
+        labels: SCALES,
+        datasets: [
+            ds('AS-IS 최신순',    [21.88, 422.82, 3782.83], C.red,   C.redA),
+            ds('AS-IS 가격순',    [22.11, 408.43, 3489.15], C.orange, C.orangeA),
+            ds('TO-BE 최신순',    [6.96, 1.69, 2.32],    C.green, C.greenA),
+            ds('TO-BE 가격순',    [1.16, 0.85, 2.29],    C.cyan,  C.cyanA),
+        ]
+    },
+    options: optsLog('avg 응답시간 (ms) -- 로그 스케일')
+});
+
+// COUNT 쿼리
+new Chart(document.getElementById('latencyCount'), {
+    type: 'bar',
+    data: {
+        labels: SCALES,
+        datasets: [
+            ds('AS-IS 전체',       [10.59, 279.32, 2147.34], C.red,    C.redA),
+            ds('AS-IS 브랜드',     [11.88, 314.32, 2323.93], C.orange, C.orangeA),
+            ds('TO-BE 전체',       [9.65, 103.84, 996.76], C.green,  C.greenA),
+            ds('TO-BE 브랜드',     [0.74, 3.46, 27.23],   C.cyan,   C.cyanA),
+        ]
+    },
+    options: optsLog('avg 응답시간 (ms) -- 로그 스케일')
+});
+
+// 1000만건 전체 UC 비교
+new Chart(document.getElementById('latency10mAll'), {
+    type: 'bar',
+    data: {
+        labels: ['UC1\n전체+최신순', 'UC2\n전체+가격순', 'UC3\n전체+인기순', 'UC4\n브랜드+최신순', 'UC5\n브랜드+가격순', 'UC6\n브랜드+인기순', 'COUNT\n전체', 'COUNT\n브랜드'],
+        datasets: [
+            ds('AS-IS', [3897.22, 4184.09, 3614.20, 3782.83, 3489.15, 3961.33, 2147.34, 2323.93], C.red, C.redA),
+            ds('TO-BE', [3.89, 2.73, 8.20, 2.32, 2.29, 2.56, 996.76, 27.23], C.green, C.greenA),
+        ]
+    },
+    options: optsLog('avg 응답시간 (ms) -- 로그 스케일')
+});
+
+// ============================================================
+// 2. 개선율
+// ============================================================
+
+// 전체 목록 개선율
+new Chart(document.getElementById('improvementNoBrand'), {
+    type: 'bar',
+    data: {
+        labels: SCALES,
+        datasets: [
+            ds('UC1: 최신순',    [29.4, 240, 1002],  C.green,  C.greenA),
+            ds('UC2: 가격순',    [28.8, 529, 1533],  C.cyan,   C.cyanA),
+            ds('UC3: 인기순',    [10.9, 545, 441],   C.teal,   C.tealA),
+        ]
+    },
+    options: optsLog('개선 배수 (AS-IS / TO-BE)')
+});
+
+// 브랜드 필터 개선율
+new Chart(document.getElementById('improvementBrand'), {
+    type: 'bar',
+    data: {
+        labels: SCALES,
+        datasets: [
+            ds('UC4: 최신순',    [3.1, 250, 1631],   C.green, C.greenA),
+            ds('UC5: 가격순',    [19.1, 481, 1524],  C.cyan,  C.cyanA),
+            ds('UC6: 인기순',    [20.8, 493, 1548],  C.teal,  C.tealA),
+        ]
+    },
+    options: optsLog('개선 배수 (AS-IS / TO-BE)')
+});
+
+// 1000만건 개선율 요약 (Horizontal bar)
+new Chart(document.getElementById('improvement10m'), {
+    type: 'bar',
+    data: {
+        labels: [
+            'UC2: 전체+가격순',
+            'UC3: 전체+인기순',
+            'UC6: 브랜드+인기순',
+            'UC4: 브랜드+최신순',
+            'UC5: 브랜드+가격순',
+            'UC1: 전체+최신순',
+            'COUNT: 브랜드',
+            'COUNT: 전체'
+        ],
+        datasets: [
+            ds('1000만건 개선 배수 (실측)', [1533, 441, 1548, 1631, 1524, 1002, 85.3, 2.15], C.green, C.greenA),
+        ]
+    },
+    options: optsHorizontal('개선 배수 (AS-IS / TO-BE)', { type: 'logarithmic' })
+});
+
+// ============================================================
+// 3. 에러율 비교
+// ============================================================
+
+// 버스트 에러율
+new Chart(document.getElementById('burstError'), {
+    type: 'bar',
+    data: {
+        labels: SCALES,
+        datasets: [
+            ds('AS-IS: 전체+최신순',    [0, 71, 90],  C.red,    C.redA),
+            ds('AS-IS: 브랜드+최신순',   [0, 70, 90],  C.orange, C.orangeA),
+            ds('TO-BE: 전체+최신순',    [0, 0, 0],    C.green,  C.greenA),
+            ds('TO-BE: 브랜드+최신순',   [0, 0, 0],    C.cyan,   C.cyanA),
+        ]
+    },
+    options: optsFixed('에러율 (%)', 100)
+});
+
+// 지속 부하 에러율
+new Chart(document.getElementById('sustainedError'), {
+    type: 'bar',
+    data: {
+        labels: SCALES,
+        datasets: [
+            ds('AS-IS: 전체+최신순',    [0, 45, 90],  C.red,    C.redA),
+            ds('AS-IS: 브랜드+최신순',   [0, 21, 90],  C.orange, C.orangeA),
+            ds('TO-BE: 전체+최신순',    [0, 0, 0],    C.green,  C.greenA),
+            ds('TO-BE: 브랜드+최신순',   [0, 0, 0],    C.cyan,   C.cyanA),
+        ]
+    },
+    options: optsFixed('에러율 (%)', 100)
+});
+
+// 버스트 응답시간 1000만건 (실측)
+new Chart(document.getElementById('burstLatency'), {
+    type: 'bar',
+    data: {
+        labels: ['전체+최신순', '전체+인기순', '브랜드+최신순'],
+        datasets: [
+            ds('AS-IS avg',  [12021, 14824, 10591], C.red,    C.redA),
+            ds('AS-IS p95',  [12389, 15146, 10972], C.orange, C.orangeA),
+            ds('TO-BE avg',  [35.90, 41.05, 22.87], C.green,  C.greenA),
+            ds('TO-BE p95',  [51.19, 75.42, 33.99], C.cyan,   C.cyanA),
+        ]
+    },
+    options: optsLog('응답시간 (ms) -- 로그 스케일')
+});
+
+// 지속 부하 응답시간 1000만건 (실측)
+new Chart(document.getElementById('sustainedLatency'), {
+    type: 'bar',
+    data: {
+        labels: ['전체+최신순', '전체+인기순', '브랜드+최신순'],
+        datasets: [
+            ds('AS-IS avg',  [15273, 12011, 12471], C.red,    C.redA),
+            ds('AS-IS p95',  [18156, 13674, 16677], C.orange, C.orangeA),
+            ds('TO-BE avg',  [4.28, 4.41, 4.43],   C.green,  C.greenA),
+            ds('TO-BE p95',  [6.05, 6.17, 6.34],   C.cyan,   C.cyanA),
+        ]
+    },
+    options: optsLog('응답시간 (ms) -- 로그 스케일')
+});
+
+// ============================================================
+// 4. 처리량(QPS) 비교
+// ============================================================
+
+// AS-IS QPS
+new Chart(document.getElementById('qpsAsIs'), {
+    type: 'bar',
+    data: {
+        labels: SCALES,
+        datasets: [
+            ds('전체+최신순',    [20.0, 5.8, 0.6], C.red,    C.redA),
+            ds('전체+인기순',    [20.0, 9.9, 0.8], C.orange, C.orangeA),
+            ds('브랜드+최신순',  [20.0, 9.9, 0.8], C.yellow, C.yellowA),
+            dsLine('목표 20 RPS', [20, 20, 20], C.gray, { borderDash: [8,4], pointRadius: 0, borderWidth: 2 }),
+        ]
+    },
+    options: optsFixed('실제 QPS (건/초)', 22)
+});
+
+// TO-BE QPS
+new Chart(document.getElementById('qpsToBe'), {
+    type: 'bar',
+    data: {
+        labels: SCALES,
+        datasets: [
+            ds('전체+최신순',    [20.0, 20.0, 20.0], C.green, C.greenA),
+            ds('전체+인기순',    [20.0, 20.0, 20.0], C.cyan,  C.cyanA),
+            ds('브랜드+최신순',  [20.0, 20.0, 20.0], C.teal,  C.tealA),
+            dsLine('목표 20 RPS', [20, 20, 20], C.gray, { borderDash: [8,4], pointRadius: 0, borderWidth: 2 }),
+        ]
+    },
+    options: optsFixed('실제 QPS (건/초)', 22)
+});
+
+// QPS 개선 배수
+new Chart(document.getElementById('qpsImprovement'), {
+    type: 'bar',
+    data: {
+        labels: SCALES,
+        datasets: [
+            ds('전체+최신순',    [1.0, 3.4, 33.3],  C.green, C.greenA),
+            ds('전체+인기순',    [1.0, 2.0, 25.0],  C.cyan,  C.cyanA),
+            ds('브랜드+최신순',  [1.0, 2.0, 25.0],  C.teal,  C.tealA),
+        ]
+    },
+    options: opts('QPS 개선 배수 (TO-BE / AS-IS)')
+});
+</script>
+
+</body>
+</html>

From 8c6cd33469b1d432f5f4c20c59fd1717a3370dce Mon Sep 17 00:00:00 2001
From: Hwan0518 <qip0518@naver.com>
Date: Fri, 13 Mar 2026 03:21:31 +0900
Subject: [PATCH 3/9] =?UTF-8?q?feat:=20Product=20likeCount=20=EB=B9=84?=
 =?UTF-8?q?=EC=A0=95=EA=B7=9C=ED=99=94=20=EC=A0=9C=EA=B1=B0=20=EB=B0=8F=20?=
 =?UTF-8?q?ReadModel=20=EC=9D=B8=ED=94=84=EB=9D=BC=20=EB=8F=84=EC=9E=85?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- Product 도메인 모델에서 likeCount 필드 제거
- ProductCommandRepository에서 likeCount 증감 메서드 제거
- ProductReadModel 도메인 레포지토리 인터페이스 추가
- ProductReadModelEntity, JpaRepository, RepositoryImpl 추가
- ProductEntityMapper reconstruct 시그니처 변경
- ProductTest, ProductEntityMapperTest, ProductCommandRepositoryTest 업데이트
- docs/todo/like-count-read-model-recount-batch.md 후속 TODO

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
---
 .../catalog/product/domain/model/Product.java |  13 +-
 .../repository/ProductCommandRepository.java  |   8 -
 .../ProductReadModelRepository.java           |  45 ++++++
 .../entity/ProductReadModelEntity.java        | 128 +++++++++++++++
 .../jpa/ProductJpaRepository.java             |  13 --
 .../jpa/ProductReadModelJpaRepository.java    |  82 ++++++++++
 .../mapper/ProductEntityMapper.java           |   4 +-
 .../ProductCommandRepositoryImpl.java         |  32 ----
 .../ProductReadModelRepositoryImpl.java       | 113 ++++++++++++++
 .../product/domain/model/ProductTest.java     |   9 +-
 .../mapper/ProductEntityMapperTest.java       |  52 +++++--
 .../ProductCommandRepositoryTest.java         |   1 -
 .../ProductReadModelRepositoryImplTest.java   | 147 ++++++++++++++++++
 .../like-count-read-model-recount-batch.md    |  61 ++++++++
 14 files changed, 628 insertions(+), 80 deletions(-)
 create mode 100644 apps/commerce-api/src/main/java/com/loopers/catalog/product/domain/repository/ProductReadModelRepository.java
 create mode 100644 apps/commerce-api/src/main/java/com/loopers/catalog/product/infrastructure/entity/ProductReadModelEntity.java
 create mode 100644 apps/commerce-api/src/main/java/com/loopers/catalog/product/infrastructure/jpa/ProductReadModelJpaRepository.java
 create mode 100644 apps/commerce-api/src/main/java/com/loopers/catalog/product/infrastructure/repository/ProductReadModelRepositoryImpl.java
 create mode 100644 apps/commerce-api/src/test/java/com/loopers/catalog/product/infrastructure/repository/ProductReadModelRepositoryImplTest.java
 create mode 100644 docs/todo/like-count-read-model-recount-batch.md

diff --git a/apps/commerce-api/src/main/java/com/loopers/catalog/product/domain/model/Product.java b/apps/commerce-api/src/main/java/com/loopers/catalog/product/domain/model/Product.java
index 770666ee3..f299d645a 100644
--- a/apps/commerce-api/src/main/java/com/loopers/catalog/product/domain/model/Product.java
+++ b/apps/commerce-api/src/main/java/com/loopers/catalog/product/domain/model/Product.java
@@ -25,7 +25,6 @@ public class Product {
 	 * - price: 가격
 	 * - stock: 재고
 	 * - description: 상품 설명
-	 * - likeCount: 좋아요 수
 	 * - deletedAt: 삭제 일시 (soft delete)
 	 */
 
@@ -35,20 +34,18 @@ public class Product {
 	private Money price;
 	private Stock stock;
 	private ProductDescription description;
-	private Long likeCount;
 	private ZonedDateTime deletedAt;
 
 
 	// 생성자
 	private Product(Long id, Long brandId, ProductName name, Money price, Stock stock,
-		ProductDescription description, Long likeCount, ZonedDateTime deletedAt) {
+		ProductDescription description, ZonedDateTime deletedAt) {
 		this.id = id;
 		this.brandId = brandId;
 		this.name = name;
 		this.price = price;
 		this.stock = stock;
 		this.description = description;
-		this.likeCount = likeCount;
 		this.deletedAt = deletedAt;
 	}
 
@@ -78,15 +75,15 @@ public static Product create(Long brandId, String name, BigDecimal price, Long s
 		Stock productStock = Stock.create(stock);
 		ProductDescription productDescription = ProductDescription.create(description);
 
-		// 상품 생성 (기본 좋아요 수: 0)
-		return new Product(null, brandId, productName, productPrice, productStock, productDescription, 0L, null);
+		// 상품 생성
+		return new Product(null, brandId, productName, productPrice, productStock, productDescription, null);
 	}
 
 
 	// 2. 상품 재생성 (Entity -> Model 매핑용도)
 	public static Product reconstruct(Long id, Long brandId, ProductName name, Money price, Stock stock,
-		ProductDescription description, Long likeCount, ZonedDateTime deletedAt) {
-		return new Product(id, brandId, name, price, stock, description, likeCount, deletedAt);
+		ProductDescription description, ZonedDateTime deletedAt) {
+		return new Product(id, brandId, name, price, stock, description, deletedAt);
 	}
 
 
diff --git a/apps/commerce-api/src/main/java/com/loopers/catalog/product/domain/repository/ProductCommandRepository.java b/apps/commerce-api/src/main/java/com/loopers/catalog/product/domain/repository/ProductCommandRepository.java
index f8db844c4..8fddd0f7b 100644
--- a/apps/commerce-api/src/main/java/com/loopers/catalog/product/domain/repository/ProductCommandRepository.java
+++ b/apps/commerce-api/src/main/java/com/loopers/catalog/product/domain/repository/ProductCommandRepository.java
@@ -10,8 +10,6 @@ public interface ProductCommandRepository {
 	 * 상품 명령 리포지토리
 	 * 1. 상품 저장
 	 * 2. 상품 삭제 (soft delete)
-	 * 3. 좋아요 수 원자적 증가
-	 * 4. 좋아요 수 원자적 감소
 	 */
 
 	// 1. 상품 저장
@@ -20,10 +18,4 @@ public interface ProductCommandRepository {
 	// 2. 상품 삭제 (soft delete)
 	void delete(Product product);
 
-	// 3. 좋아요 수 원자적 증가
-	void increaseLikeCount(Long productId);
-
-	// 4. 좋아요 수 원자적 감소
-	void decreaseLikeCount(Long productId);
-
 }
diff --git a/apps/commerce-api/src/main/java/com/loopers/catalog/product/domain/repository/ProductReadModelRepository.java b/apps/commerce-api/src/main/java/com/loopers/catalog/product/domain/repository/ProductReadModelRepository.java
new file mode 100644
index 000000000..55b6b9b05
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/catalog/product/domain/repository/ProductReadModelRepository.java
@@ -0,0 +1,45 @@
+package com.loopers.catalog.product.domain.repository;
+
+
+import com.loopers.catalog.product.domain.model.Product;
+
+import java.util.List;
+
+
+/**
+ * 상품 Read Model 동기화 리포지토리
+ * - write 경로에서 product_read_model 테이블을 동기화
+ * - 구현체: ProductReadModelRepositoryImpl (infrastructure/repository/)
+ *
+ * 1. Read Model 저장 (생성/수정)
+ * 2. Read Model soft delete (deletedAt 설정)
+ * 3. 좋아요 수 증가
+ * 4. 좋아요 수 감소
+ * 5. 재고 업데이트
+ * 6. 브랜드명 일괄 업데이트
+ * 7. 브랜드 ID로 활성 상품 ID 목록 조회
+ */
+public interface ProductReadModelRepository {
+
+	// 1. Read Model 저장 (생성/수정)
+	void save(Product product, String brandName);
+
+	// 2. Read Model soft delete (deletedAt 설정)
+	void softDelete(Long productId);
+
+	// 3. 좋아요 수 증가
+	void increaseLikeCount(Long productId);
+
+	// 4. 좋아요 수 감소
+	void decreaseLikeCount(Long productId);
+
+	// 5. 재고 업데이트
+	void updateStock(Long productId, Long newStock);
+
+	// 6. 브랜드명 일괄 업데이트
+	void updateBrandName(Long brandId, String newBrandName);
+
+	// 7. 브랜드 ID로 활성 상품 ID 목록 조회 (브랜드명 write-through용)
+	List<Long> findActiveIdsByBrandId(Long brandId);
+
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/catalog/product/infrastructure/entity/ProductReadModelEntity.java b/apps/commerce-api/src/main/java/com/loopers/catalog/product/infrastructure/entity/ProductReadModelEntity.java
new file mode 100644
index 000000000..f26c52472
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/catalog/product/infrastructure/entity/ProductReadModelEntity.java
@@ -0,0 +1,128 @@
+package com.loopers.catalog.product.infrastructure.entity;
+
+
+import com.loopers.catalog.product.domain.model.Product;
+import jakarta.persistence.*;
+import lombok.AccessLevel;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+
+import java.math.BigDecimal;
+import java.time.ZonedDateTime;
+
+
+/**
+ * 상품 Read Model 엔티티
+ * - id: 상품 ID (products.id와 동일, AUTO_INCREMENT 아님)
+ * - brandId: 브랜드 ID
+ * - brandName: 브랜드명 (비정규화)
+ * - name: 상품명
+ * - price: 가격
+ * - stock: 재고
+ * - description: 상품 설명
+ * - likeCount: 좋아요 수
+ * - createdAt: 생성 일시
+ * - updatedAt: 수정 일시
+ * - deletedAt: 삭제 일시 (soft delete)
+ */
+@Entity
+@Table(name = "product_read_model", indexes = {
+	// 사용자 조회: WHERE brand_id = ? AND deleted_at IS NULL ORDER BY {sort_col}
+	// 컬럼 순서: 카디널리티 높은 brand_id 선두 → deleted_at(equality) → sort_col
+	@Index(name = "idx_read_brand_deleted_created", columnList = "brand_id, deleted_at, created_at"),
+	@Index(name = "idx_read_brand_deleted_price", columnList = "brand_id, deleted_at, price"),
+	@Index(name = "idx_read_brand_deleted_likecount", columnList = "brand_id, deleted_at, like_count"),
+	// 사용자 조회 (브랜드 미지정): WHERE deleted_at IS NULL ORDER BY {sort_col}
+	@Index(name = "idx_read_deleted_created", columnList = "deleted_at, created_at"),
+	@Index(name = "idx_read_deleted_price", columnList = "deleted_at, price"),
+	@Index(name = "idx_read_deleted_likecount", columnList = "deleted_at, like_count"),
+	// 관리자 조회 (브랜드 지정): WHERE brand_id = ? ORDER BY {sort_col}
+	@Index(name = "idx_read_brand_created", columnList = "brand_id, created_at"),
+	@Index(name = "idx_read_brand_price", columnList = "brand_id, price"),
+	@Index(name = "idx_read_brand_likecount", columnList = "brand_id, like_count"),
+	// 관리자 조회 (필터 없음): ORDER BY {sort_col}
+	@Index(name = "idx_read_created", columnList = "created_at"),
+	@Index(name = "idx_read_price", columnList = "price"),
+	@Index(name = "idx_read_likecount", columnList = "like_count")
+})
+@Getter
+@NoArgsConstructor(access = AccessLevel.PROTECTED)
+public class ProductReadModelEntity {
+
+	@Id
+	private Long id;
+
+	@Column(name = "brand_id", nullable = false)
+	private Long brandId;
+
+	@Column(name = "brand_name", length = 100)
+	private String brandName;
+
+	@Column(name = "name", nullable = false, length = 200)
+	private String name;
+
+	@Column(name = "price", nullable = false, precision = 12, scale = 2)
+	private BigDecimal price;
+
+	@Column(name = "stock", nullable = false)
+	private Long stock;
+
+	@Column(name = "description", length = 1000)
+	private String description;
+
+	@Column(name = "like_count", nullable = false)
+	private Long likeCount;
+
+	@Column(name = "created_at", nullable = false)
+	private ZonedDateTime createdAt;
+
+	@Column(name = "updated_at", nullable = false)
+	private ZonedDateTime updatedAt;
+
+	@Column(name = "deleted_at")
+	private ZonedDateTime deletedAt;
+
+
+	private ProductReadModelEntity(Long id, Long brandId, String brandName, String name,
+		BigDecimal price, Long stock, String description, Long likeCount,
+		ZonedDateTime createdAt, ZonedDateTime updatedAt, ZonedDateTime deletedAt) {
+		this.id = id;
+		this.brandId = brandId;
+		this.brandName = brandName;
+		this.name = name;
+		this.price = price;
+		this.stock = stock;
+		this.description = description;
+		this.likeCount = likeCount;
+		this.createdAt = createdAt;
+		this.updatedAt = updatedAt;
+		this.deletedAt = deletedAt;
+	}
+
+
+	// 도메인 모델 + 브랜드명으로 Read Model 엔티티 생성 (신규: createdAt = now, likeCount = 0)
+	public static ProductReadModelEntity of(Product product, String brandName) {
+		return of(product, brandName, ZonedDateTime.now(), 0L);
+	}
+
+
+	// 도메인 모델 + 브랜드명 + 기존 createdAt/likeCount 보존 (업데이트 시 LATEST 정렬 오염 + likeCount 덮어쓰기 방지)
+	public static ProductReadModelEntity of(Product product, String brandName,
+		ZonedDateTime createdAt, Long likeCount) {
+
+		return new ProductReadModelEntity(
+			product.getId(),
+			product.getBrandId(),
+			brandName,
+			product.getName().value(),
+			product.getPrice().value(),
+			product.getStock().value(),
+			product.getDescription() != null ? product.getDescription().value() : null,
+			likeCount,
+			createdAt,
+			ZonedDateTime.now(),
+			product.getDeletedAt()
+		);
+	}
+
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/catalog/product/infrastructure/jpa/ProductJpaRepository.java b/apps/commerce-api/src/main/java/com/loopers/catalog/product/infrastructure/jpa/ProductJpaRepository.java
index 85323a723..cd921a1d5 100644
--- a/apps/commerce-api/src/main/java/com/loopers/catalog/product/infrastructure/jpa/ProductJpaRepository.java
+++ b/apps/commerce-api/src/main/java/com/loopers/catalog/product/infrastructure/jpa/ProductJpaRepository.java
@@ -5,7 +5,6 @@
 import jakarta.persistence.LockModeType;
 import org.springframework.data.jpa.repository.JpaRepository;
 import org.springframework.data.jpa.repository.Lock;
-import org.springframework.data.jpa.repository.Modifying;
 import org.springframework.data.jpa.repository.Query;
 import org.springframework.data.repository.query.Param;
 
@@ -21,8 +20,6 @@ public interface ProductJpaRepository extends JpaRepository<ProductEntity, Long>
 	 * 2. 브랜드의 활성 상품 존재 여부 확인
 	 * 3. ID로 활성 상품 엔티티 조회 (비관적 쓰기 락)
 	 * 4. ID 목록으로 활성 상품 엔티티 일괄 조회
-	 * 5. 좋아요 수 원자적 증가
-	 * 6. 좋아요 수 원자적 감소
 	 */
 
 	// 1. ID로 활성 상품 엔티티 조회
@@ -39,14 +36,4 @@ public interface ProductJpaRepository extends JpaRepository<ProductEntity, Long>
 	// 4. ID 목록으로 활성 상품 엔티티 일괄 조회
 	List<ProductEntity> findByIdInAndDeletedAtIsNull(List<Long> ids);
 
-	// 5. 좋아요 수 원자적 증가 (단일 SQL)
-	@Modifying
-	@Query(value = "UPDATE products SET like_count = like_count + 1 WHERE id = :id AND deleted_at IS NULL", nativeQuery = true)
-	int increaseLikeCount(@Param("id") Long id);
-
-	// 6. 좋아요 수 원자적 감소 (0 이하로 내려가지 않음)
-	@Modifying
-	@Query(value = "UPDATE products SET like_count = CASE WHEN like_count > 0 THEN like_count - 1 ELSE 0 END WHERE id = :id AND deleted_at IS NULL", nativeQuery = true)
-	int decreaseLikeCount(@Param("id") Long id);
-
 }
diff --git a/apps/commerce-api/src/main/java/com/loopers/catalog/product/infrastructure/jpa/ProductReadModelJpaRepository.java b/apps/commerce-api/src/main/java/com/loopers/catalog/product/infrastructure/jpa/ProductReadModelJpaRepository.java
new file mode 100644
index 000000000..b6de70552
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/catalog/product/infrastructure/jpa/ProductReadModelJpaRepository.java
@@ -0,0 +1,82 @@
+package com.loopers.catalog.product.infrastructure.jpa;
+
+
+import com.loopers.catalog.product.infrastructure.entity.ProductReadModelEntity;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.Modifying;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.repository.query.Param;
+
+import java.math.BigDecimal;
+import java.time.ZonedDateTime;
+import java.util.List;
+
+
+public interface ProductReadModelJpaRepository extends JpaRepository<ProductReadModelEntity, Long> {
+
+	/**
+	 * 상품 Read Model JPA 리포지토리
+	 * 1. 브랜드명 일괄 업데이트
+	 * 2. 좋아요 수 원자적 증가
+	 * 3. 좋아요 수 원자적 감소
+	 * 4. 재고 업데이트
+	 * 5. soft delete (deletedAt 설정)
+	 * 6. 브랜드 ID로 활성 상품 ID 목록 조회
+	 */
+
+	// 1. 브랜드명 일괄 업데이트
+	@Modifying
+	@Query("UPDATE ProductReadModelEntity e SET e.brandName = :brandName WHERE e.brandId = :brandId")
+	void updateBrandNameByBrandId(@Param("brandId") Long brandId, @Param("brandName") String brandName);
+
+	// 1-1. 기존 Read Model 스냅샷 갱신 (createdAt/likeCount 보존)
+	@Modifying(clearAutomatically = true, flushAutomatically = true)
+	@Query("""
+		UPDATE ProductReadModelEntity e
+		SET e.brandId = :brandId,
+		    e.brandName = :brandName,
+		    e.name = :name,
+		    e.price = :price,
+		    e.stock = :stock,
+		    e.description = :description,
+		    e.updatedAt = :updatedAt,
+		    e.deletedAt = :deletedAt
+		WHERE e.id = :id
+		""")
+	int updateSnapshot(
+		@Param("id") Long id,
+		@Param("brandId") Long brandId,
+		@Param("brandName") String brandName,
+		@Param("name") String name,
+		@Param("price") BigDecimal price,
+		@Param("stock") Long stock,
+		@Param("description") String description,
+		@Param("updatedAt") ZonedDateTime updatedAt,
+		@Param("deletedAt") ZonedDateTime deletedAt
+	);
+
+	// 2. 좋아요 수 원자적 증가 (영향 행 수 반환 — 대상 미존재 검증용)
+	@Modifying
+	@Query("UPDATE ProductReadModelEntity e SET e.likeCount = e.likeCount + 1 WHERE e.id = :id")
+	int increaseLikeCount(@Param("id") Long id);
+
+	// 3. 좋아요 수 원자적 감소 (0 이하로 내려가지 않음, 영향 행 수 반환)
+	@Modifying
+	@Query("UPDATE ProductReadModelEntity e SET e.likeCount = e.likeCount - 1 WHERE e.id = :id AND e.likeCount > 0")
+	int decreaseLikeCount(@Param("id") Long id);
+
+	// 4. 재고 업데이트
+	@Modifying
+	@Query("UPDATE ProductReadModelEntity e SET e.stock = :stock WHERE e.id = :id")
+	void updateStock(@Param("id") Long id, @Param("stock") Long stock);
+
+	// 5. soft delete (deletedAt 설정)
+	@Modifying
+	@Query("UPDATE ProductReadModelEntity e SET e.deletedAt = :deletedAt WHERE e.id = :productId")
+	void softDelete(@Param("productId") Long productId, @Param("deletedAt") ZonedDateTime deletedAt);
+
+	// 6. 브랜드 ID로 활성 상품 ID 목록 조회 (브랜드명 write-through용)
+	@Query("SELECT e.id FROM ProductReadModelEntity e WHERE e.brandId = :brandId AND e.deletedAt IS NULL")
+	List<Long> findActiveIdsByBrandId(@Param("brandId") Long brandId);
+
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/catalog/product/infrastructure/mapper/ProductEntityMapper.java b/apps/commerce-api/src/main/java/com/loopers/catalog/product/infrastructure/mapper/ProductEntityMapper.java
index 31f8925a8..726df0446 100644
--- a/apps/commerce-api/src/main/java/com/loopers/catalog/product/infrastructure/mapper/ProductEntityMapper.java
+++ b/apps/commerce-api/src/main/java/com/loopers/catalog/product/infrastructure/mapper/ProductEntityMapper.java
@@ -28,8 +28,7 @@ public ProductEntity toEntity(Product product) {
 			product.getName().value(),
 			product.getPrice().value(),
 			product.getStock().value(),
-			product.getDescription() != null ? product.getDescription().value() : null,
-			product.getLikeCount()
+			product.getDescription() != null ? product.getDescription().value() : null
 		);
 
 		// 소프트 삭제 상태 반영
@@ -50,7 +49,6 @@ public Product toDomain(ProductEntity entity) {
 			Money.from(entity.getPrice()),
 			Stock.from(entity.getStock()),
 			ProductDescription.from(entity.getDescription()),
-			entity.getLikeCount(),
 			entity.getDeletedAt()
 		);
 	}
diff --git a/apps/commerce-api/src/main/java/com/loopers/catalog/product/infrastructure/repository/ProductCommandRepositoryImpl.java b/apps/commerce-api/src/main/java/com/loopers/catalog/product/infrastructure/repository/ProductCommandRepositoryImpl.java
index 2c6c1d434..069acfbad 100644
--- a/apps/commerce-api/src/main/java/com/loopers/catalog/product/infrastructure/repository/ProductCommandRepositoryImpl.java
+++ b/apps/commerce-api/src/main/java/com/loopers/catalog/product/infrastructure/repository/ProductCommandRepositoryImpl.java
@@ -6,8 +6,6 @@
 import com.loopers.catalog.product.infrastructure.entity.ProductEntity;
 import com.loopers.catalog.product.infrastructure.jpa.ProductJpaRepository;
 import com.loopers.catalog.product.infrastructure.mapper.ProductEntityMapper;
-import com.loopers.support.common.error.CoreException;
-import com.loopers.support.common.error.ErrorType;
 import lombok.RequiredArgsConstructor;
 import org.springframework.stereotype.Repository;
 
@@ -26,8 +24,6 @@ public class ProductCommandRepositoryImpl implements ProductCommandRepository {
 	 * 상품 명령 리포지토리 구현체
 	 * 1. 상품 저장
 	 * 2. 상품 삭제 (soft delete)
-	 * 3. 좋아요 수 원자적 증가
-	 * 4. 좋아요 수 원자적 감소
 	 */
 
 	// 1. 상품 저장
@@ -59,32 +55,4 @@ public void delete(Product product) {
 		productJpaRepository.save(entity);
 	}
 
-
-	// 3. 좋아요 수 원자적 증가
-	@Override
-	public void increaseLikeCount(Long productId) {
-
-		// 원자적 증가 (단일 SQL UPDATE)
-		int updatedRows = productJpaRepository.increaseLikeCount(productId);
-
-		// 대상 상품 미존재 시 예외
-		if (updatedRows == 0) {
-			throw new CoreException(ErrorType.PRODUCT_NOT_FOUND);
-		}
-	}
-
-
-	// 4. 좋아요 수 원자적 감소
-	@Override
-	public void decreaseLikeCount(Long productId) {
-
-		// 원자적 감소 (단일 SQL UPDATE — 0 이하로 내려가지 않음)
-		int updatedRows = productJpaRepository.decreaseLikeCount(productId);
-
-		// 대상 상품 미존재 시 예외
-		if (updatedRows == 0) {
-			throw new CoreException(ErrorType.PRODUCT_NOT_FOUND);
-		}
-	}
-
 }
diff --git a/apps/commerce-api/src/main/java/com/loopers/catalog/product/infrastructure/repository/ProductReadModelRepositoryImpl.java b/apps/commerce-api/src/main/java/com/loopers/catalog/product/infrastructure/repository/ProductReadModelRepositoryImpl.java
new file mode 100644
index 000000000..cb341df21
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/catalog/product/infrastructure/repository/ProductReadModelRepositoryImpl.java
@@ -0,0 +1,113 @@
+package com.loopers.catalog.product.infrastructure.repository;
+
+
+import com.loopers.catalog.product.domain.model.Product;
+import com.loopers.catalog.product.domain.repository.ProductReadModelRepository;
+import com.loopers.catalog.product.infrastructure.entity.ProductReadModelEntity;
+import com.loopers.catalog.product.infrastructure.jpa.ProductReadModelJpaRepository;
+import com.loopers.support.common.error.CoreException;
+import com.loopers.support.common.error.ErrorType;
+import lombok.RequiredArgsConstructor;
+import org.springframework.dao.DataIntegrityViolationException;
+import org.springframework.stereotype.Repository;
+
+import java.time.ZonedDateTime;
+import java.util.List;
+
+
+@Repository
+@RequiredArgsConstructor
+public class ProductReadModelRepositoryImpl implements ProductReadModelRepository {
+
+	// jpa
+	private final ProductReadModelJpaRepository jpaRepository;
+
+
+	@Override
+	public void save(Product product, String brandName) {
+		ZonedDateTime updatedAt = ZonedDateTime.now();
+		int updatedRows = jpaRepository.updateSnapshot(
+			product.getId(),
+			product.getBrandId(),
+			brandName,
+			product.getName().value(),
+			product.getPrice().value(),
+			product.getStock().value(),
+			product.getDescription() != null ? product.getDescription().value() : null,
+			updatedAt,
+			product.getDeletedAt()
+		);
+
+		if (updatedRows > 0) {
+			return;
+		}
+
+		try {
+			jpaRepository.save(ProductReadModelEntity.of(product, brandName));
+		} catch (DataIntegrityViolationException e) {
+			// 다른 트랜잭션이 먼저 insert한 경우 스냅샷 update로 재시도한다.
+			jpaRepository.updateSnapshot(
+				product.getId(),
+				product.getBrandId(),
+				brandName,
+				product.getName().value(),
+				product.getPrice().value(),
+				product.getStock().value(),
+				product.getDescription() != null ? product.getDescription().value() : null,
+				updatedAt,
+				product.getDeletedAt()
+			);
+		}
+	}
+
+
+	@Override
+	public void softDelete(Long productId) {
+		// deletedAt을 현재 시각으로 설정하여 soft delete 처리
+		jpaRepository.softDelete(productId, ZonedDateTime.now());
+	}
+
+
+	@Override
+	public void increaseLikeCount(Long productId) {
+
+		// 원자적 증가 (단일 SQL UPDATE)
+		int updatedRows = jpaRepository.increaseLikeCount(productId);
+
+		// 대상 Read Model 미존재 시 예외
+		if (updatedRows == 0) {
+			throw new CoreException(ErrorType.PRODUCT_NOT_FOUND);
+		}
+	}
+
+
+	@Override
+	public void decreaseLikeCount(Long productId) {
+
+		// 원자적 감소 (단일 SQL UPDATE — 0 이하로 내려가지 않음)
+		int updatedRows = jpaRepository.decreaseLikeCount(productId);
+
+		// 대상 Read Model 미존재 시 예외 (likeCount가 이미 0인 경우는 정상 — 0행 반환 허용)
+		// Note: decreaseLikeCount WHERE likeCount > 0 조건으로 0행 반환은 이미 0인 경우도 포함
+		// 따라서 여기서는 검증하지 않음 (음수 방지가 목적)
+	}
+
+
+	@Override
+	public void updateStock(Long productId, Long newStock) {
+		jpaRepository.updateStock(productId, newStock);
+	}
+
+
+	@Override
+	public void updateBrandName(Long brandId, String newBrandName) {
+		jpaRepository.updateBrandNameByBrandId(brandId, newBrandName);
+	}
+
+
+	@Override
+	public List<Long> findActiveIdsByBrandId(Long brandId) {
+		return jpaRepository.findActiveIdsByBrandId(brandId);
+	}
+
+}
diff --git a/apps/commerce-api/src/test/java/com/loopers/catalog/product/domain/model/ProductTest.java b/apps/commerce-api/src/test/java/com/loopers/catalog/product/domain/model/ProductTest.java
index 6658711ed..634b22613 100644
--- a/apps/commerce-api/src/test/java/com/loopers/catalog/product/domain/model/ProductTest.java
+++ b/apps/commerce-api/src/test/java/com/loopers/catalog/product/domain/model/ProductTest.java
@@ -26,7 +26,7 @@ class ProductTest {
 	class CreateTest {
 
 		@Test
-		@DisplayName("[create()] 유효한 입력 -> Product 생성 성공. id=null, likeCount=0, deletedAt=null")
+		@DisplayName("[create()] 유효한 입력 -> Product 생성 성공. id=null, deletedAt=null")
 		void createSuccess() {
 			// Act
 			Product product = Product.create(1L, "테스트 상품", new BigDecimal("10000"), 100L, "설명");
@@ -39,7 +39,6 @@ void createSuccess() {
 				() -> assertThat(product.getPrice().value()).isEqualByComparingTo(new BigDecimal("10000")),
 				() -> assertThat(product.getStock().value()).isEqualTo(100L),
 				() -> assertThat(product.getDescription().value()).isEqualTo("설명"),
-				() -> assertThat(product.getLikeCount()).isEqualTo(0L),
 				() -> assertThat(product.getDeletedAt()).isNull()
 			);
 		}
@@ -120,7 +119,6 @@ void reconstructSuccess() {
 				Money.from(new BigDecimal("5000")),
 				Stock.from(50L),
 				ProductDescription.from("설명"),
-				10L,
 				deletedAt
 			);
 
@@ -132,7 +130,6 @@ void reconstructSuccess() {
 				() -> assertThat(product.getPrice().value()).isEqualByComparingTo(new BigDecimal("5000")),
 				() -> assertThat(product.getStock().value()).isEqualTo(50L),
 				() -> assertThat(product.getDescription().value()).isEqualTo("설명"),
-				() -> assertThat(product.getLikeCount()).isEqualTo(10L),
 				() -> assertThat(product.getDeletedAt()).isEqualTo(deletedAt)
 			);
 		}
@@ -299,7 +296,7 @@ void deleteAlreadyDeleted() {
 				ProductName.from("상품"),
 				Money.from(BigDecimal.TEN),
 				Stock.from(100L),
-				null, 0L, ZonedDateTime.now()
+				null, ZonedDateTime.now()
 			);
 
 			// Act
@@ -336,7 +333,7 @@ void deleted() {
 				ProductName.from("상품"),
 				Money.from(BigDecimal.TEN),
 				Stock.from(100L),
-				null, 0L, ZonedDateTime.now()
+				null, ZonedDateTime.now()
 			);
 
 			// Assert
diff --git a/apps/commerce-api/src/test/java/com/loopers/catalog/product/infrastructure/mapper/ProductEntityMapperTest.java b/apps/commerce-api/src/test/java/com/loopers/catalog/product/infrastructure/mapper/ProductEntityMapperTest.java
index ba826ffbf..7b7ab089f 100644
--- a/apps/commerce-api/src/test/java/com/loopers/catalog/product/infrastructure/mapper/ProductEntityMapperTest.java
+++ b/apps/commerce-api/src/test/java/com/loopers/catalog/product/infrastructure/mapper/ProductEntityMapperTest.java
@@ -45,7 +45,7 @@ void toEntitySuccess() {
 				Money.from(new BigDecimal("10000")),
 				Stock.from(100L),
 				ProductDescription.from("설명"),
-				5L, null
+				null
 			);
 
 			// Act
@@ -57,8 +57,7 @@ void toEntitySuccess() {
 				() -> assertThat(entity.getName()).isEqualTo("테스트 상품"),
 				() -> assertThat(entity.getPrice()).isEqualByComparingTo(new BigDecimal("10000")),
 				() -> assertThat(entity.getStock()).isEqualTo(100L),
-				() -> assertThat(entity.getDescription()).isEqualTo("설명"),
-				() -> assertThat(entity.getLikeCount()).isEqualTo(5L)
+				() -> assertThat(entity.getDescription()).isEqualTo("설명")
 			);
 		}
 
@@ -72,7 +71,7 @@ void toEntityWithNullDescription() {
 				ProductName.from("상품"),
 				Money.from(BigDecimal.TEN),
 				Stock.from(10L),
-				null, 0L, null
+				null, null
 			);
 
 			// Act
@@ -92,7 +91,7 @@ void toEntityWithDeleted() {
 				ProductName.from("상품"),
 				Money.from(BigDecimal.TEN),
 				Stock.from(10L),
-				null, 0L, ZonedDateTime.now()
+				null, ZonedDateTime.now()
 			);
 
 			// Act
@@ -114,7 +113,7 @@ class ToDomainTest {
 		void toDomainSuccess() {
 			// Arrange
 			ProductEntity entity = ProductEntity.of(
-				1L, 2L, "테스트 상품", new BigDecimal("10000"), 100L, "설명", 5L
+				1L, 2L, "테스트 상품", new BigDecimal("10000"), 100L, "설명"
 			);
 
 			// Act
@@ -126,8 +125,7 @@ void toDomainSuccess() {
 				() -> assertThat(product.getName().value()).isEqualTo("테스트 상품"),
 				() -> assertThat(product.getPrice().value()).isEqualByComparingTo(new BigDecimal("10000")),
 				() -> assertThat(product.getStock().value()).isEqualTo(100L),
-				() -> assertThat(product.getDescription().value()).isEqualTo("설명"),
-				() -> assertThat(product.getLikeCount()).isEqualTo(5L)
+				() -> assertThat(product.getDescription().value()).isEqualTo("설명")
 			);
 		}
 
@@ -137,7 +135,7 @@ void toDomainSuccess() {
 		void toDomainWithNullDescription() {
 			// Arrange
 			ProductEntity entity = ProductEntity.of(
-				1L, 2L, "상품", BigDecimal.TEN, 10L, null, 0L
+				1L, 2L, "상품", BigDecimal.TEN, 10L, null
 			);
 
 			// Act
@@ -149,4 +147,40 @@ void toDomainWithNullDescription() {
 
 	}
 
+
+	@Nested
+	@DisplayName("양방향 변환 일관성 테스트")
+	class RoundTripTest {
+
+		@Test
+		@DisplayName("[toEntity() → toDomain()] 도메인 → 엔티티 → 도메인 변환 시 비즈니스 필드 보존. "
+			+ "brandId, name, price, stock, description 값이 원본과 동일")
+		void roundTripPreservesFields() {
+			// Arrange
+			Product original = Product.reconstruct(
+				1L, 2L,
+				ProductName.from("테스트 상품"),
+				Money.from(new BigDecimal("10000")),
+				Stock.from(100L),
+				ProductDescription.from("설명"),
+				null
+			);
+
+			// Act
+			ProductEntity entity = mapper.toEntity(original);
+			Product reconstructed = mapper.toDomain(entity);
+
+			// Assert — 원본 도메인과 복원된 도메인의 비즈니스 필드 일치 검증
+			assertAll(
+				() -> assertThat(reconstructed.getBrandId()).isEqualTo(original.getBrandId()),
+				() -> assertThat(reconstructed.getName().value()).isEqualTo(original.getName().value()),
+				() -> assertThat(reconstructed.getPrice().value()).isEqualByComparingTo(original.getPrice().value()),
+				() -> assertThat(reconstructed.getStock().value()).isEqualTo(original.getStock().value()),
+				() -> assertThat(reconstructed.getDescription().value()).isEqualTo(original.getDescription().value()),
+				() -> assertThat(reconstructed.getDeletedAt()).isNull()
+			);
+		}
+
+	}
+
 }
diff --git a/apps/commerce-api/src/test/java/com/loopers/catalog/product/infrastructure/repository/ProductCommandRepositoryTest.java b/apps/commerce-api/src/test/java/com/loopers/catalog/product/infrastructure/repository/ProductCommandRepositoryTest.java
index e67264c90..82680617f 100644
--- a/apps/commerce-api/src/test/java/com/loopers/catalog/product/infrastructure/repository/ProductCommandRepositoryTest.java
+++ b/apps/commerce-api/src/test/java/com/loopers/catalog/product/infrastructure/repository/ProductCommandRepositoryTest.java
@@ -50,7 +50,6 @@ void saveSuccess() {
 				() -> assertThat(savedProduct.getPrice().value()).isEqualByComparingTo(new BigDecimal("10000")),
 				() -> assertThat(savedProduct.getStock().value()).isEqualTo(100L),
 				() -> assertThat(savedProduct.getDescription().value()).isEqualTo("설명"),
-				() -> assertThat(savedProduct.getLikeCount()).isEqualTo(0L),
 				() -> assertThat(savedProduct.getDeletedAt()).isNull()
 			);
 		}
diff --git a/apps/commerce-api/src/test/java/com/loopers/catalog/product/infrastructure/repository/ProductReadModelRepositoryImplTest.java b/apps/commerce-api/src/test/java/com/loopers/catalog/product/infrastructure/repository/ProductReadModelRepositoryImplTest.java
new file mode 100644
index 000000000..7bf54446b
--- /dev/null
+++ b/apps/commerce-api/src/test/java/com/loopers/catalog/product/infrastructure/repository/ProductReadModelRepositoryImplTest.java
@@ -0,0 +1,147 @@
+package com.loopers.catalog.product.infrastructure.repository;
+
+
+import com.loopers.catalog.brand.domain.model.enums.VisibleStatus;
+import com.loopers.catalog.brand.infrastructure.entity.BrandEntity;
+import com.loopers.catalog.brand.infrastructure.jpa.BrandJpaRepository;
+import com.loopers.catalog.product.domain.model.Product;
+import com.loopers.catalog.product.domain.model.vo.Money;
+import com.loopers.catalog.product.domain.model.vo.ProductDescription;
+import com.loopers.catalog.product.domain.model.vo.ProductName;
+import com.loopers.catalog.product.domain.model.vo.Stock;
+import com.loopers.catalog.product.domain.repository.ProductReadModelRepository;
+import com.loopers.catalog.product.infrastructure.entity.ProductEntity;
+import com.loopers.catalog.product.infrastructure.entity.ProductReadModelEntity;
+import com.loopers.catalog.product.infrastructure.jpa.ProductJpaRepository;
+import com.loopers.catalog.product.infrastructure.jpa.ProductReadModelJpaRepository;
+import com.loopers.testcontainers.MySqlTestContainersConfig;
+import com.loopers.testcontainers.RedisTestContainersConfig;
+import com.loopers.utils.DatabaseCleanUp;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.context.annotation.Import;
+import org.springframework.test.context.ActiveProfiles;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.math.BigDecimal;
+import java.time.ZonedDateTime;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertAll;
+
+
+@SpringBootTest
+@ActiveProfiles("test")
+@Import({MySqlTestContainersConfig.class, RedisTestContainersConfig.class})
+@DisplayName("ProductReadModelRepositoryImpl 통합 테스트")
+class ProductReadModelRepositoryImplTest {
+
+	@Autowired
+	private ProductReadModelRepository productReadModelRepository;
+
+	@Autowired
+	private ProductReadModelJpaRepository productReadModelJpaRepository;
+
+	@Autowired
+	private ProductJpaRepository productJpaRepository;
+
+	@Autowired
+	private BrandJpaRepository brandJpaRepository;
+
+	@Autowired
+	private DatabaseCleanUp databaseCleanUp;
+
+
+	@AfterEach
+	void tearDown() {
+		databaseCleanUp.truncateAllTables();
+	}
+
+
+	@Nested
+	@DisplayName("save()")
+	class SaveTest {
+
+		@Test
+		@Transactional
+		@DisplayName("[save()] 기존 Read Model 업데이트 -> createdAt/likeCount 보존, mutable field만 갱신")
+		void saveExistingReadModel_preservesCreatedAtAndLikeCount() {
+			BrandEntity brand = brandJpaRepository.save(
+				BrandEntity.of("기존 브랜드", "설명", VisibleStatus.VISIBLE));
+			ProductEntity productEntity = productJpaRepository.save(
+				ProductEntity.of(brand.getId(), "원래 상품", new BigDecimal("10000.00"), 100L, "원래 설명"));
+			Product product = reconstructProduct(productEntity);
+			ZonedDateTime originalCreatedAt = ZonedDateTime.parse("2025-01-01T00:00:00Z");
+
+			productReadModelJpaRepository.save(
+				ProductReadModelEntity.of(product, "기존 브랜드", originalCreatedAt, 7L));
+
+			productReadModelJpaRepository.increaseLikeCount(productEntity.getId());
+			Product updatedProduct = Product.reconstruct(
+				productEntity.getId(),
+				brand.getId(),
+				ProductName.create("수정 상품"),
+				Money.create(new BigDecimal("15000.00")),
+				Stock.create(55L),
+				ProductDescription.create("수정 설명"),
+				null
+			);
+
+			productReadModelRepository.save(updatedProduct, "수정 브랜드");
+
+			ProductReadModelEntity result = productReadModelJpaRepository.findById(productEntity.getId()).orElseThrow();
+
+			assertAll(
+				() -> assertThat(result.getBrandName()).isEqualTo("수정 브랜드"),
+				() -> assertThat(result.getName()).isEqualTo("수정 상품"),
+				() -> assertThat(result.getPrice()).isEqualByComparingTo(new BigDecimal("15000.00")),
+				() -> assertThat(result.getStock()).isEqualTo(55L),
+				() -> assertThat(result.getDescription()).isEqualTo("수정 설명"),
+				() -> assertThat(result.getCreatedAt()).isEqualTo(originalCreatedAt),
+				() -> assertThat(result.getLikeCount()).isEqualTo(8L)
+			);
+		}
+
+
+		@Test
+		@Transactional
+		@DisplayName("[save()] Read Model 미존재 상품 저장 -> 신규 row 생성")
+		void saveNewReadModel_insertsRow() {
+			BrandEntity brand = brandJpaRepository.save(
+				BrandEntity.of("신규 브랜드", "설명", VisibleStatus.VISIBLE));
+			ProductEntity productEntity = productJpaRepository.save(
+				ProductEntity.of(brand.getId(), "신규 상품", new BigDecimal("21000.00"), 33L, "신규 설명"));
+
+			productReadModelRepository.save(reconstructProduct(productEntity), "신규 브랜드");
+
+			ProductReadModelEntity result = productReadModelJpaRepository.findById(productEntity.getId()).orElseThrow();
+
+			assertAll(
+				() -> assertThat(result.getBrandId()).isEqualTo(brand.getId()),
+				() -> assertThat(result.getBrandName()).isEqualTo("신규 브랜드"),
+				() -> assertThat(result.getName()).isEqualTo("신규 상품"),
+				() -> assertThat(result.getPrice()).isEqualByComparingTo(new BigDecimal("21000.00")),
+				() -> assertThat(result.getStock()).isEqualTo(33L),
+				() -> assertThat(result.getLikeCount()).isZero(),
+				() -> assertThat(result.getCreatedAt()).isNotNull()
+			);
+		}
+	}
+
+
+	private Product reconstructProduct(ProductEntity entity) {
+		return Product.reconstruct(
+			entity.getId(),
+			entity.getBrandId(),
+			ProductName.from(entity.getName()),
+			Money.from(entity.getPrice()),
+			Stock.from(entity.getStock()),
+			ProductDescription.from(entity.getDescription()),
+			entity.getDeletedAt()
+		);
+	}
+}
diff --git a/docs/todo/like-count-read-model-recount-batch.md b/docs/todo/like-count-read-model-recount-batch.md
new file mode 100644
index 000000000..6f574582d
--- /dev/null
+++ b/docs/todo/like-count-read-model-recount-batch.md
@@ -0,0 +1,61 @@
+# TODO: likes 기반 Read Model likeCount 재집계 배치
+
+## 상황
+
+`products.like_count` 컬럼을 제거하고, `likes` 테이블을 좋아요 수의 단일 SoT(Source of Truth)로 확립했다.
+`product_read_model.like_count`는 유일한 비정규화 projection이며, 좋아요 생성/삭제 시 원자적 카운터(`+1`/`-1`)로 동기화된다.
+
+## 문제
+
+원자적 카운터 방식은 정상 흐름에서는 정확하지만, 다음 상황에서 drift가 발생할 수 있다:
+
+1. **TX 부분 실패**: `likes` INSERT는 성공했으나 `product_read_model.like_count` UPDATE가 실패한 경우
+2. **수동 데이터 보정**: 운영 중 likes 테이블을 직접 INSERT/DELETE한 경우
+3. **버그에 의한 누적 오차**: 카운터 증감 로직의 edge case 누락 (예: 동시성 극단 상황)
+
+drift 발생 시 자동 복구 수단이 없으면, `product_read_model.like_count`가 실제 좋아요 수와 영구적으로 불일치한다.
+
+## 이유
+
+- `likes` 테이블이 SoT이므로, `SELECT target_id, COUNT(*) FROM likes GROUP BY target_id`가 정확한 좋아요 수
+- 현재 TTL 기반 캐시 안전망(2~3분)은 캐시 불일치만 해소하며, DB 레벨 drift는 해소하지 않음
+- 배치로 주기적 재집계를 수행하면 drift를 자동 보정할 수 있음
+
+## 개선 방안
+
+`commerce-batch` 모듈에 Spring Batch Job을 추가하여 likes 테이블 기반으로 Read Model likeCount를 재집계한다.
+
+### 배치 흐름
+
+```
+1. SELECT target_id AS product_id, COUNT(*) AS like_count FROM likes GROUP BY target_id
+2. UPDATE product_read_model SET like_count = {집계값} WHERE id = {product_id}
+3. 변경된 상품의 상세 캐시 write-through (선택)
+```
+
+### 실행 주기
+
+- 일 1회 (새벽 시간대) 또는 수동 트리거
+- 운영 이슈 발생 시 즉시 실행 가능하도록 API 트리거도 고려
+
+### 주의사항
+
+- 배치 실행 중 좋아요 생성/삭제가 동시에 발생할 수 있으므로, 최종 UPDATE는 `SET like_count = {집계값}`으로 덮어쓰기
+- 대량 상품의 경우 chunk 단위 처리 (예: 100건씩)
+- 배치 실행 로그에 변경 전후 차이(drift량)를 기록하여 모니터링
+
+## 근거
+
+- 이벤트 소싱 없이 카운터 기반 projection을 사용하는 시스템에서는 주기적 재집계가 업계 표준 안전망
+- Netflix, Instagram 등도 카운터 기반 비정규화 + 주기적 재집계 패턴을 사용
+- 배치 비용이 낮고 (단일 GROUP BY 쿼리), 효과가 높음 (drift 완전 해소)
+
+## 우선순위
+
+**낮음** — 현재 원자적 카운터 + TX 보장으로 정상 운영 중. 운영 규모가 커지거나 drift 관측 시 도입.
+
+## 관련 파일
+
+- `ProductReadModelJpaRepository` — `increaseLikeCount()`, `decreaseLikeCount()` (현재 카운터 방식)
+- `ProductCommandService` — 좋아요 쓰기 경로
+- `docs/todo/cache-event-driven-refresh.md` — 캐시 갱신 이벤트 기반 전환 TODO

From e347beff9425f259f150f4c0ac9534cc5c839c3b Mon Sep 17 00:00:00 2001
From: Hwan0518 <qip0518@naver.com>
Date: Fri, 13 Mar 2026 03:21:46 +0900
Subject: [PATCH 4/9] =?UTF-8?q?feat:=20Product=20=EC=A1=B0=ED=9A=8C=20?=
 =?UTF-8?q?=EA=B5=AC=EC=A1=B0=20ReadModel=20=EC=A0=84=ED=99=98=20(DTO=20+?=
 =?UTF-8?q?=20QueryPort)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- AdminProductDetailOutDto, AdminProductOutDto ReadModel 기반으로 변경
- ProductDetailOutDto, ProductOutDto ReadModel 기반으로 변경
- ProductQueryPort에 ReadModel 조회 메서드 추가
- ProductQueryPortImpl ReadModel 조회 구현
- ProductQuerydslRepository ReadModel 단일 테이블 조회로 전환 (JOIN 제거)
- ProductQueryPortImplTest ReadModel 기반 테스트로 전환

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
---
 .../dto/out/AdminProductDetailOutDto.java     |  18 +-
 .../dto/out/AdminProductOutDto.java           |  32 +-
 .../dto/out/ProductDetailOutDto.java          |  17 +-
 .../application/dto/out/ProductOutDto.java    |  30 +-
 .../port/out/query/ProductQueryPort.java      |  21 +
 .../query/ProductQueryPortImpl.java           |  37 ++
 .../querydsl/ProductQuerydslRepository.java   | 147 +++--
 .../query/ProductQueryPortImplTest.java       | 506 ++++++++++++++++--
 8 files changed, 637 insertions(+), 171 deletions(-)

diff --git a/apps/commerce-api/src/main/java/com/loopers/catalog/product/application/dto/out/AdminProductDetailOutDto.java b/apps/commerce-api/src/main/java/com/loopers/catalog/product/application/dto/out/AdminProductDetailOutDto.java
index 6a7a05c80..199d38db7 100644
--- a/apps/commerce-api/src/main/java/com/loopers/catalog/product/application/dto/out/AdminProductDetailOutDto.java
+++ b/apps/commerce-api/src/main/java/com/loopers/catalog/product/application/dto/out/AdminProductDetailOutDto.java
@@ -1,14 +1,13 @@
 package com.loopers.catalog.product.application.dto.out;
 
 
-import com.loopers.catalog.product.domain.model.Product;
-
 import java.math.BigDecimal;
 import java.time.ZonedDateTime;
 
 
 /**
  * 상품 관리자 상세 조회 결과 DTO
+ * - Read Model projection (QueryDSL)으로 직접 생성
  * - id: 상품 ID
  * - brandId: 브랜드 ID
  * - brandName: 브랜드명
@@ -22,19 +21,4 @@
 public record AdminProductDetailOutDto(Long id, Long brandId, String brandName, String name,
 	BigDecimal price, Long stock, String description, Long likeCount, ZonedDateTime deletedAt) {
 
-	// 1. Product 도메인 객체를 브랜드명 포함 관리자 상세 조회 결과 DTO로 변환
-	public static AdminProductDetailOutDto from(Product product, String brandName) {
-		return new AdminProductDetailOutDto(
-			product.getId(),
-			product.getBrandId(),
-			brandName,
-			product.getName().value(),
-			product.getPrice().value(),
-			product.getStock().value(),
-			product.getDescription() != null ? product.getDescription().value() : null,
-			product.getLikeCount(),
-			product.getDeletedAt()
-		);
-	}
-
 }
diff --git a/apps/commerce-api/src/main/java/com/loopers/catalog/product/application/dto/out/AdminProductOutDto.java b/apps/commerce-api/src/main/java/com/loopers/catalog/product/application/dto/out/AdminProductOutDto.java
index df068f3e2..5ae8a8169 100644
--- a/apps/commerce-api/src/main/java/com/loopers/catalog/product/application/dto/out/AdminProductOutDto.java
+++ b/apps/commerce-api/src/main/java/com/loopers/catalog/product/application/dto/out/AdminProductOutDto.java
@@ -1,14 +1,13 @@
 package com.loopers.catalog.product.application.dto.out;
 
 
-import com.loopers.catalog.product.domain.model.Product;
-
 import java.math.BigDecimal;
 import java.time.ZonedDateTime;
 
 
 /**
  * 상품 관리자 목록 조회 결과 DTO
+ * - Read Model projection (QueryDSL)으로 직접 생성
  * - id: 상품 ID
  * - brandId: 브랜드 ID
  * - brandName: 브랜드명
@@ -21,33 +20,4 @@
 public record AdminProductOutDto(Long id, Long brandId, String brandName, String name,
 	BigDecimal price, Long stock, Long likeCount, ZonedDateTime deletedAt) {
 
-	// 1. Product 도메인 객체를 관리자 목록 조회 결과 DTO로 변환
-	public static AdminProductOutDto from(Product product) {
-		return new AdminProductOutDto(
-			product.getId(),
-			product.getBrandId(),
-			null,
-			product.getName().value(),
-			product.getPrice().value(),
-			product.getStock().value(),
-			product.getLikeCount(),
-			product.getDeletedAt()
-		);
-	}
-
-
-	// 2. Product 도메인 객체를 브랜드명 포함 관리자 목록 조회 결과 DTO로 변환
-	public static AdminProductOutDto from(Product product, String brandName) {
-		return new AdminProductOutDto(
-			product.getId(),
-			product.getBrandId(),
-			brandName,
-			product.getName().value(),
-			product.getPrice().value(),
-			product.getStock().value(),
-			product.getLikeCount(),
-			product.getDeletedAt()
-		);
-	}
-
 }
diff --git a/apps/commerce-api/src/main/java/com/loopers/catalog/product/application/dto/out/ProductDetailOutDto.java b/apps/commerce-api/src/main/java/com/loopers/catalog/product/application/dto/out/ProductDetailOutDto.java
index 6aaa69a87..accf4c8f5 100644
--- a/apps/commerce-api/src/main/java/com/loopers/catalog/product/application/dto/out/ProductDetailOutDto.java
+++ b/apps/commerce-api/src/main/java/com/loopers/catalog/product/application/dto/out/ProductDetailOutDto.java
@@ -1,13 +1,12 @@
 package com.loopers.catalog.product.application.dto.out;
 
 
-import com.loopers.catalog.product.domain.model.Product;
-
 import java.math.BigDecimal;
 
 
 /**
  * 상품 상세 조회 결과 DTO
+ * - 캐시(ProductCacheDto) 또는 Read Model projection으로 직접 생성
  * - id: 상품 ID
  * - brandId: 브랜드 ID
  * - brandName: 브랜드명
@@ -20,18 +19,4 @@
 public record ProductDetailOutDto(Long id, Long brandId, String brandName, String name,
 	BigDecimal price, Long stock, String description, Long likeCount) {
 
-	// 1. Product 도메인 객체를 브랜드명 포함 상세 조회 결과 DTO로 변환
-	public static ProductDetailOutDto from(Product product, String brandName) {
-		return new ProductDetailOutDto(
-			product.getId(),
-			product.getBrandId(),
-			brandName,
-			product.getName().value(),
-			product.getPrice().value(),
-			product.getStock().value(),
-			product.getDescription() != null ? product.getDescription().value() : null,
-			product.getLikeCount()
-		);
-	}
-
 }
diff --git a/apps/commerce-api/src/main/java/com/loopers/catalog/product/application/dto/out/ProductOutDto.java b/apps/commerce-api/src/main/java/com/loopers/catalog/product/application/dto/out/ProductOutDto.java
index 19b90f55f..684261289 100644
--- a/apps/commerce-api/src/main/java/com/loopers/catalog/product/application/dto/out/ProductOutDto.java
+++ b/apps/commerce-api/src/main/java/com/loopers/catalog/product/application/dto/out/ProductOutDto.java
@@ -1,13 +1,12 @@
 package com.loopers.catalog.product.application.dto.out;
 
 
-import com.loopers.catalog.product.domain.model.Product;
-
 import java.math.BigDecimal;
 
 
 /**
  * 상품 목록 조회 결과 DTO
+ * - 캐시(ProductCacheDto) 또는 Read Model projection(QueryDSL)으로 직접 생성
  * - id: 상품 ID
  * - brandId: 브랜드 ID
  * - brandName: 브랜드명
@@ -19,31 +18,4 @@
 public record ProductOutDto(Long id, Long brandId, String brandName, String name,
 	BigDecimal price, Long stock, Long likeCount) {
 
-	// 1. Product 도메인 객체를 목록 조회 결과 DTO로 변환
-	public static ProductOutDto from(Product product) {
-		return new ProductOutDto(
-			product.getId(),
-			product.getBrandId(),
-			null,
-			product.getName().value(),
-			product.getPrice().value(),
-			product.getStock().value(),
-			product.getLikeCount()
-		);
-	}
-
-
-	// 2. Product 도메인 객체를 브랜드명 포함 목록 조회 결과 DTO로 변환
-	public static ProductOutDto from(Product product, String brandName) {
-		return new ProductOutDto(
-			product.getId(),
-			product.getBrandId(),
-			brandName,
-			product.getName().value(),
-			product.getPrice().value(),
-			product.getStock().value(),
-			product.getLikeCount()
-		);
-	}
-
 }
diff --git a/apps/commerce-api/src/main/java/com/loopers/catalog/product/application/port/out/query/ProductQueryPort.java b/apps/commerce-api/src/main/java/com/loopers/catalog/product/application/port/out/query/ProductQueryPort.java
index 0305e6acf..f62fd7612 100644
--- a/apps/commerce-api/src/main/java/com/loopers/catalog/product/application/port/out/query/ProductQueryPort.java
+++ b/apps/commerce-api/src/main/java/com/loopers/catalog/product/application/port/out/query/ProductQueryPort.java
@@ -1,11 +1,16 @@
 package com.loopers.catalog.product.application.port.out.query;
 
 
+import com.loopers.catalog.product.application.dto.out.AdminProductDetailOutDto;
 import com.loopers.catalog.product.application.dto.out.AdminProductOutDto;
 import com.loopers.catalog.product.application.dto.out.ProductOutDto;
 import com.loopers.catalog.product.application.port.out.query.criteria.ProductSearchCriteria;
 import com.loopers.catalog.product.domain.repository.vo.PageCriteria;
 import com.loopers.catalog.product.domain.repository.vo.PageResult;
+import com.loopers.catalog.product.infrastructure.cache.IdListCacheEntry;
+import com.loopers.catalog.product.infrastructure.cache.ProductCacheDto;
+
+import java.util.List;
 
 
 public interface ProductQueryPort {
@@ -14,6 +19,10 @@ public interface ProductQueryPort {
 	 * 상품 복잡 조회 포트
 	 * 1. 사용자 상품 검색 (활성 상품만, 브랜드 필터, 정렬, 페이지네이션)
 	 * 2. 관리자 상품 검색 (전체 상품, 브랜드 필터, 정렬, 페이지네이션)
+	 * 3. 상품 ID 리스트 검색 (캐시 write-through용)
+	 * 4. 단건 상품 캐시 DTO 조회 (Read Model projection)
+	 * 5. 다건 상품 캐시 DTO 조회 (Read Model bulk projection)
+	 * 6. 관리자 상품 상세 조회 (삭제 포함, Read Model projection)
 	 */
 
 	// 1. 사용자 상품 검색
@@ -22,4 +31,16 @@ public interface ProductQueryPort {
 	// 2. 관리자 상품 검색
 	PageResult<AdminProductOutDto> searchAdminProducts(ProductSearchCriteria criteria, PageCriteria pageCriteria);
 
+	// 3. 상품 ID 리스트 검색 (캐시 write-through용, 정렬 + 페이지네이션)
+	IdListCacheEntry searchProductIds(ProductSearchCriteria criteria, PageCriteria pageCriteria);
+
+	// 4. 단건 상품 캐시 DTO 조회 (Read Model projection)
+	ProductCacheDto findProductCacheDtoById(Long productId);
+
+	// 5. 다건 상품 캐시 DTO 조회 (Read Model bulk projection)
+	List<ProductCacheDto> findProductCacheDtosByIds(List<Long> productIds);
+
+	// 6. 관리자 상품 상세 조회 (삭제 포함, Read Model projection)
+	AdminProductDetailOutDto findAdminProductDetailById(Long productId);
+
 }
diff --git a/apps/commerce-api/src/main/java/com/loopers/catalog/product/infrastructure/query/ProductQueryPortImpl.java b/apps/commerce-api/src/main/java/com/loopers/catalog/product/infrastructure/query/ProductQueryPortImpl.java
index 80e84d71e..bd09bf8bb 100644
--- a/apps/commerce-api/src/main/java/com/loopers/catalog/product/infrastructure/query/ProductQueryPortImpl.java
+++ b/apps/commerce-api/src/main/java/com/loopers/catalog/product/infrastructure/query/ProductQueryPortImpl.java
@@ -1,16 +1,21 @@
 package com.loopers.catalog.product.infrastructure.query;
 
 
+import com.loopers.catalog.product.application.dto.out.AdminProductDetailOutDto;
 import com.loopers.catalog.product.application.dto.out.AdminProductOutDto;
 import com.loopers.catalog.product.application.dto.out.ProductOutDto;
 import com.loopers.catalog.product.application.port.out.query.ProductQueryPort;
 import com.loopers.catalog.product.application.port.out.query.criteria.ProductSearchCriteria;
 import com.loopers.catalog.product.domain.repository.vo.PageCriteria;
 import com.loopers.catalog.product.domain.repository.vo.PageResult;
+import com.loopers.catalog.product.infrastructure.cache.IdListCacheEntry;
+import com.loopers.catalog.product.infrastructure.cache.ProductCacheDto;
 import com.loopers.catalog.product.infrastructure.querydsl.ProductQuerydslRepository;
 import lombok.RequiredArgsConstructor;
 import org.springframework.stereotype.Repository;
 
+import java.util.List;
+
 
 @Repository
 @RequiredArgsConstructor
@@ -24,6 +29,10 @@ public class ProductQueryPortImpl implements ProductQueryPort {
 	 * 상품 복잡 조회 포트 구현체 (ProductQuerydslRepository에 위임)
 	 * 1. 사용자 상품 검색 (활성 상품만)
 	 * 2. 관리자 상품 검색 (전체 상품)
+	 * 3. 상품 ID 리스트 검색 (캐시 write-through용)
+	 * 4. 단건 상품 캐시 DTO 조회
+	 * 5. 다건 상품 캐시 DTO 조회
+	 * 6. 관리자 상품 상세 조회 (삭제 포함)
 	 */
 
 	// 1. 사용자 상품 검색 (활성 상품만)
@@ -39,4 +48,32 @@ public PageResult<AdminProductOutDto> searchAdminProducts(ProductSearchCriteria
 		return productQuerydslRepository.searchAdminProducts(criteria, pageCriteria);
 	}
 
+
+	// 3. 상품 ID 리스트 검색 (캐시 write-through용)
+	@Override
+	public IdListCacheEntry searchProductIds(ProductSearchCriteria criteria, PageCriteria pageCriteria) {
+		return productQuerydslRepository.searchProductIds(criteria, pageCriteria);
+	}
+
+
+	// 4. 단건 상품 캐시 DTO 조회 (Read Model projection)
+	@Override
+	public ProductCacheDto findProductCacheDtoById(Long productId) {
+		return productQuerydslRepository.findProductCacheDtoById(productId);
+	}
+
+
+	// 5. 다건 상품 캐시 DTO 조회 (Read Model bulk projection)
+	@Override
+	public List<ProductCacheDto> findProductCacheDtosByIds(List<Long> productIds) {
+		return productQuerydslRepository.findProductCacheDtosByIds(productIds);
+	}
+
+
+	// 6. 관리자 상품 상세 조회 (삭제 포함, Read Model projection)
+	@Override
+	public AdminProductDetailOutDto findAdminProductDetailById(Long productId) {
+		return productQuerydslRepository.findAdminProductDetailById(productId);
+	}
+
 }
diff --git a/apps/commerce-api/src/main/java/com/loopers/catalog/product/infrastructure/querydsl/ProductQuerydslRepository.java b/apps/commerce-api/src/main/java/com/loopers/catalog/product/infrastructure/querydsl/ProductQuerydslRepository.java
index 14089de07..6d85ee2f9 100644
--- a/apps/commerce-api/src/main/java/com/loopers/catalog/product/infrastructure/querydsl/ProductQuerydslRepository.java
+++ b/apps/commerce-api/src/main/java/com/loopers/catalog/product/infrastructure/querydsl/ProductQuerydslRepository.java
@@ -1,14 +1,16 @@
 package com.loopers.catalog.product.infrastructure.querydsl;
 
 
-import com.loopers.catalog.brand.infrastructure.entity.QBrandEntity;
+import com.loopers.catalog.product.application.dto.out.AdminProductDetailOutDto;
 import com.loopers.catalog.product.application.dto.out.AdminProductOutDto;
 import com.loopers.catalog.product.application.dto.out.ProductOutDto;
 import com.loopers.catalog.product.application.port.out.query.criteria.ProductSearchCriteria;
 import com.loopers.catalog.product.domain.model.enums.ProductSortType;
 import com.loopers.catalog.product.domain.repository.vo.PageCriteria;
 import com.loopers.catalog.product.domain.repository.vo.PageResult;
-import com.loopers.catalog.product.infrastructure.entity.QProductEntity;
+import com.loopers.catalog.product.infrastructure.cache.IdListCacheEntry;
+import com.loopers.catalog.product.infrastructure.cache.ProductCacheDto;
+import com.loopers.catalog.product.infrastructure.entity.QProductReadModelEntity;
 import com.querydsl.core.types.OrderSpecifier;
 import com.querydsl.core.types.Projections;
 import com.querydsl.core.types.dsl.BooleanExpression;
@@ -26,41 +28,43 @@ public class ProductQuerydslRepository {
 	// querydsl
 	private final JPAQueryFactory queryFactory;
 
-	private static final QProductEntity product = QProductEntity.productEntity;
-	private static final QBrandEntity brand = QBrandEntity.brandEntity;
+	private static final QProductReadModelEntity readModel = QProductReadModelEntity.productReadModelEntity;
 
 
 	/**
-	 * 상품 QueryDSL 쿼리 리포지토리
+	 * 상품 QueryDSL 쿼리 리포지토리 (Read Model 기반 — JOIN 없음)
 	 * 1. 사용자 상품 검색 (활성 상품만, DTO Projection)
 	 * 2. 관리자 상품 검색 (전체 상품, DTO Projection)
+	 * 3. 상품 ID 리스트 검색 (캐시 write-through용)
+	 * 4. 단건 상품 캐시 DTO 조회 (Read Model projection)
+	 * 5. 다건 상품 캐시 DTO 조회 (Read Model bulk projection)
+	 * 6. 관리자 상품 상세 조회 (삭제 포함, Read Model projection)
 	 */
 
-	// 1. 사용자 상품 검색 (활성 상품만, DTO Projection)
+	// 1. 사용자 상품 검색 (활성 상품만, DTO Projection — Read Model 단일 테이블 조회)
 	public PageResult<ProductOutDto> searchProducts(ProductSearchCriteria criteria, PageCriteria pageCriteria) {
 
 		// 활성 상품 조건 + 브랜드 필터
-		BooleanExpression condition = product.deletedAt.isNull();
+		BooleanExpression condition = readModel.deletedAt.isNull();
 		if (criteria.brandId() != null) {
-			condition = condition.and(product.brandId.eq(criteria.brandId()));
+			condition = condition.and(readModel.brandId.eq(criteria.brandId()));
 		}
 
-		// 정렬 조건
-		OrderSpecifier<?> order = getOrderSpecifier(criteria.sortType());
+		// 정렬 조건 (tie-breaker 포함)
+		OrderSpecifier<?>[] orders = getOrderSpecifiers(criteria.sortType());
 
 		// 전체 개수 조회
 		long totalElements = countProducts(condition);
 
-		// DTO Projection 직접 조회 (Entity 거치지 않음)
+		// DTO Projection 직접 조회 (Read Model — JOIN 없음)
 		long offset = (long) pageCriteria.page() * pageCriteria.size();
 		List<ProductOutDto> content = queryFactory
 			.select(Projections.constructor(ProductOutDto.class,
-				product.id, product.brandId, brand.name,
-				product.name, product.price, product.stock, product.likeCount))
-			.from(product)
-			.leftJoin(brand).on(brand.id.eq(product.brandId))
+				readModel.id, readModel.brandId, readModel.brandName,
+				readModel.name, readModel.price, readModel.stock, readModel.likeCount))
+			.from(readModel)
 			.where(condition)
-			.orderBy(order)
+			.orderBy(orders)
 			.offset(offset)
 			.limit(pageCriteria.size())
 			.fetch();
@@ -69,32 +73,31 @@ public PageResult<ProductOutDto> searchProducts(ProductSearchCriteria criteria,
 	}
 
 
-	// 2. 관리자 상품 검색 (전체 상품, DTO Projection)
+	// 2. 관리자 상품 검색 (전체 상품, DTO Projection — Read Model 단일 테이블 조회)
 	public PageResult<AdminProductOutDto> searchAdminProducts(ProductSearchCriteria criteria, PageCriteria pageCriteria) {
 
 		// 브랜드 필터 (삭제된 상품 포함)
 		BooleanExpression condition = null;
 		if (criteria.brandId() != null) {
-			condition = product.brandId.eq(criteria.brandId());
+			condition = readModel.brandId.eq(criteria.brandId());
 		}
 
-		// 정렬 조건
-		OrderSpecifier<?> order = getOrderSpecifier(criteria.sortType());
+		// 정렬 조건 (tie-breaker 포함)
+		OrderSpecifier<?>[] orders = getOrderSpecifiers(criteria.sortType());
 
 		// 전체 개수 조회
 		long totalElements = countProducts(condition);
 
-		// DTO Projection 직접 조회 (Entity 거치지 않음)
+		// DTO Projection 직접 조회 (Read Model — JOIN 없음)
 		long offset = (long) pageCriteria.page() * pageCriteria.size();
 		List<AdminProductOutDto> content = queryFactory
 			.select(Projections.constructor(AdminProductOutDto.class,
-				product.id, product.brandId, brand.name,
-				product.name, product.price, product.stock, product.likeCount,
-				product.deletedAt))
-			.from(product)
-			.leftJoin(brand).on(brand.id.eq(product.brandId))
+				readModel.id, readModel.brandId, readModel.brandName,
+				readModel.name, readModel.price, readModel.stock, readModel.likeCount,
+				readModel.deletedAt))
+			.from(readModel)
 			.where(condition)
-			.orderBy(order)
+			.orderBy(orders)
 			.offset(offset)
 			.limit(pageCriteria.size())
 			.fetch();
@@ -103,33 +106,101 @@ public PageResult<AdminProductOutDto> searchAdminProducts(ProductSearchCriteria
 	}
 
 
+	// 3. 상품 ID 리스트 검색 (캐시 write-through용, 활성 상품만)
+	public IdListCacheEntry searchProductIds(ProductSearchCriteria criteria, PageCriteria pageCriteria) {
+
+		// 활성 상품 조건 + 브랜드 필터
+		BooleanExpression condition = readModel.deletedAt.isNull();
+		if (criteria.brandId() != null) {
+			condition = condition.and(readModel.brandId.eq(criteria.brandId()));
+		}
+
+		// 전체 개수 조회
+		long totalElements = countProducts(condition);
+
+		// ID 목록 (정렬 + tie-breaker + 페이지네이션)
+		long offset = (long) pageCriteria.page() * pageCriteria.size();
+		List<Long> ids = queryFactory.select(readModel.id)
+			.from(readModel)
+			.where(condition)
+			.orderBy(getOrderSpecifiers(criteria.sortType()))
+			.offset(offset)
+			.limit(pageCriteria.size())
+			.fetch();
+
+		return new IdListCacheEntry(ids, totalElements);
+	}
+
+
+	// 4. 단건 상품 캐시 DTO 조회 (Read Model projection, 활성 상품만)
+	public ProductCacheDto findProductCacheDtoById(Long productId) {
+
+		return queryFactory.select(Projections.constructor(ProductCacheDto.class,
+				readModel.id, readModel.brandId, readModel.brandName, readModel.name,
+				readModel.price, readModel.stock, readModel.description, readModel.likeCount))
+			.from(readModel)
+			.where(readModel.id.eq(productId).and(readModel.deletedAt.isNull()))
+			.fetchOne();
+	}
+
+
+	// 5. 다건 상품 캐시 DTO 조회 (Read Model bulk projection, 활성 상품만)
+	public List<ProductCacheDto> findProductCacheDtosByIds(List<Long> productIds) {
+
+		return queryFactory.select(Projections.constructor(ProductCacheDto.class,
+				readModel.id, readModel.brandId, readModel.brandName, readModel.name,
+				readModel.price, readModel.stock, readModel.description, readModel.likeCount))
+			.from(readModel)
+			.where(readModel.id.in(productIds).and(readModel.deletedAt.isNull()))
+			.fetch();
+	}
+
+
+	// 6. 관리자 상품 상세 조회 (삭제 포함, Read Model projection — 브랜드 삭제 시에도 비정규화된 brandName 사용)
+	public AdminProductDetailOutDto findAdminProductDetailById(Long productId) {
+
+		return queryFactory.select(Projections.constructor(AdminProductDetailOutDto.class,
+				readModel.id, readModel.brandId, readModel.brandName, readModel.name,
+				readModel.price, readModel.stock, readModel.description, readModel.likeCount,
+				readModel.deletedAt))
+			.from(readModel)
+			.where(readModel.id.eq(productId))
+			.fetchOne();
+	}
+
+
 	/**
 	 * private 메서드
 	 * - 전체 개수 조회
-	 * - 정렬 조건 변환
+	 * - 정렬 조건 변환 (tie-breaker 포함)
 	 */
 
 	// 전체 개수 조회
 	private long countProducts(BooleanExpression condition) {
 		Long count = queryFactory
-			.select(product.count())
-			.from(product)
+			.select(readModel.count())
+			.from(readModel)
 			.where(condition)
 			.fetchOne();
 		return count != null ? count : 0L;
 	}
 
 
-	// 정렬 조건 변환
-	private OrderSpecifier<?> getOrderSpecifier(ProductSortType sortType) {
+	// 정렬 조건 변환 (tie-breaker: 동률 시 id 내림차순)
+	private OrderSpecifier<?>[] getOrderSpecifiers(ProductSortType sortType) {
+		OrderSpecifier<?> primary;
 		if (sortType == null) {
-			return product.createdAt.desc();
+			primary = readModel.createdAt.desc();
+		} else {
+			primary = switch (sortType) {
+				case LATEST -> readModel.createdAt.desc();
+				case PRICE_ASC -> readModel.price.asc();
+				case LIKES_DESC -> readModel.likeCount.desc();
+			};
 		}
-		return switch (sortType) {
-			case LATEST -> product.createdAt.desc();
-			case PRICE_ASC -> product.price.asc();
-			case LIKES_DESC -> product.likeCount.desc();
-		};
+		// tie-breaker: 동률 시 id 내림차순 (최신 상품 우선, 페이지 경계 안정화)
+		OrderSpecifier<?> secondary = readModel.id.desc();
+		return new OrderSpecifier<?>[]{ primary, secondary };
 	}
 
 }
diff --git a/apps/commerce-api/src/test/java/com/loopers/catalog/product/infrastructure/query/ProductQueryPortImplTest.java b/apps/commerce-api/src/test/java/com/loopers/catalog/product/infrastructure/query/ProductQueryPortImplTest.java
index 65e5af724..60837bfa0 100644
--- a/apps/commerce-api/src/test/java/com/loopers/catalog/product/infrastructure/query/ProductQueryPortImplTest.java
+++ b/apps/commerce-api/src/test/java/com/loopers/catalog/product/infrastructure/query/ProductQueryPortImplTest.java
@@ -4,15 +4,25 @@
 import com.loopers.catalog.brand.domain.model.enums.VisibleStatus;
 import com.loopers.catalog.brand.infrastructure.entity.BrandEntity;
 import com.loopers.catalog.brand.infrastructure.jpa.BrandJpaRepository;
+import com.loopers.catalog.product.application.dto.out.AdminProductDetailOutDto;
 import com.loopers.catalog.product.application.dto.out.AdminProductOutDto;
 import com.loopers.catalog.product.application.dto.out.ProductOutDto;
 import com.loopers.catalog.product.application.port.out.query.ProductQueryPort;
+import com.loopers.catalog.product.infrastructure.cache.IdListCacheEntry;
+import com.loopers.catalog.product.infrastructure.cache.ProductCacheDto;
 import com.loopers.catalog.product.application.port.out.query.criteria.ProductSearchCriteria;
+import com.loopers.catalog.product.domain.model.Product;
 import com.loopers.catalog.product.domain.model.enums.ProductSortType;
+import com.loopers.catalog.product.domain.model.vo.Money;
+import com.loopers.catalog.product.domain.model.vo.ProductDescription;
+import com.loopers.catalog.product.domain.model.vo.ProductName;
+import com.loopers.catalog.product.domain.model.vo.Stock;
 import com.loopers.catalog.product.domain.repository.vo.PageCriteria;
 import com.loopers.catalog.product.domain.repository.vo.PageResult;
 import com.loopers.catalog.product.infrastructure.entity.ProductEntity;
+import com.loopers.catalog.product.infrastructure.entity.ProductReadModelEntity;
 import com.loopers.catalog.product.infrastructure.jpa.ProductJpaRepository;
+import com.loopers.catalog.product.infrastructure.jpa.ProductReadModelJpaRepository;
 import com.loopers.testcontainers.MySqlTestContainersConfig;
 import com.loopers.testcontainers.RedisTestContainersConfig;
 import com.loopers.utils.DatabaseCleanUp;
@@ -26,6 +36,8 @@
 import org.springframework.test.context.ActiveProfiles;
 
 import java.math.BigDecimal;
+import java.time.ZonedDateTime;
+import java.util.List;
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.junit.jupiter.api.Assertions.assertAll;
@@ -46,6 +58,9 @@ class ProductQueryPortImplTest {
 	@Autowired
 	private BrandJpaRepository brandJpaRepository;
 
+	@Autowired
+	private ProductReadModelJpaRepository productReadModelJpaRepository;
+
 	@Autowired
 	private DatabaseCleanUp databaseCleanUp;
 
@@ -56,6 +71,64 @@ void tearDown() {
 	}
 
 
+	// ProductEntity 저장 후 대응하는 ProductReadModelEntity도 함께 적재하는 헬퍼 (likeCount = 0)
+	private ProductEntity saveProductWithReadModel(ProductEntity productEntity, String brandName) {
+		return saveProductWithReadModel(productEntity, brandName, 0L);
+	}
+
+
+	// ProductEntity 저장 후 대응하는 ProductReadModelEntity도 함께 적재하는 헬퍼 (likeCount 지정)
+	private ProductEntity saveProductWithReadModel(ProductEntity productEntity, String brandName, Long likeCount) {
+
+		// 1. ProductEntity 저장 (ID 자동 생성)
+		ProductEntity saved = productJpaRepository.save(productEntity);
+
+		// 2. Product 도메인 모델 reconstruct (from() — 검증 생략)
+		Product product = Product.reconstruct(
+			saved.getId(),
+			saved.getBrandId(),
+			ProductName.from(saved.getName()),
+			Money.from(saved.getPrice()),
+			Stock.from(saved.getStock()),
+			ProductDescription.from(saved.getDescription()),
+			saved.getDeletedAt()
+		);
+
+		// 3. Read Model 엔티티 생성 및 저장 (likeCount 명시 전달)
+		productReadModelJpaRepository.save(
+			ProductReadModelEntity.of(product, brandName, ZonedDateTime.now(), likeCount));
+
+		return saved;
+	}
+
+
+	// 삭제된 상품의 Read Model도 함께 적재하는 헬퍼 (deletedAt 반영)
+	private ProductEntity saveDeletedProductWithReadModel(ProductEntity productEntity, String brandName) {
+
+		// 1. ProductEntity 저장 및 삭제 처리
+		ProductEntity saved = productJpaRepository.save(productEntity);
+		saved.delete();
+		ProductEntity deletedSaved = productJpaRepository.save(saved);
+
+		// 2. Product 도메인 모델 reconstruct (deletedAt 포함)
+		Product product = Product.reconstruct(
+			deletedSaved.getId(),
+			deletedSaved.getBrandId(),
+			ProductName.from(deletedSaved.getName()),
+			Money.from(deletedSaved.getPrice()),
+			Stock.from(deletedSaved.getStock()),
+			ProductDescription.from(deletedSaved.getDescription()),
+			deletedSaved.getDeletedAt()
+		);
+
+		// 3. Read Model 엔티티 생성 및 저장
+		productReadModelJpaRepository.save(
+			ProductReadModelEntity.of(product, brandName, ZonedDateTime.now(), 0L));
+
+		return deletedSaved;
+	}
+
+
 	@Nested
 	@DisplayName("searchProducts()")
 	class SearchProductsTest {
@@ -66,8 +139,9 @@ void searchProductsWithBrandName() {
 			// Arrange
 			BrandEntity brand = brandJpaRepository.save(
 				BrandEntity.of("테스트 브랜드", "브랜드 설명", VisibleStatus.VISIBLE));
-			productJpaRepository.save(
-				ProductEntity.of(brand.getId(), "테스트 상품", new BigDecimal("10000.00"), 100L, "설명", 0L));
+			saveProductWithReadModel(
+				ProductEntity.of(brand.getId(), "테스트 상품", new BigDecimal("10000.00"), 100L, "설명"),
+				"테스트 브랜드");
 
 			ProductSearchCriteria criteria = new ProductSearchCriteria(null, null);
 			PageCriteria pageCriteria = new PageCriteria(0, 10);
@@ -94,10 +168,12 @@ void searchProductsWithBrandIdFilter() {
 				BrandEntity.of("브랜드A", "설명A", VisibleStatus.VISIBLE));
 			BrandEntity brand2 = brandJpaRepository.save(
 				BrandEntity.of("브랜드B", "설명B", VisibleStatus.VISIBLE));
-			productJpaRepository.save(
-				ProductEntity.of(brand1.getId(), "상품A", new BigDecimal("10000.00"), 100L, null, 0L));
-			productJpaRepository.save(
-				ProductEntity.of(brand2.getId(), "상품B", new BigDecimal("20000.00"), 200L, null, 0L));
+			saveProductWithReadModel(
+				ProductEntity.of(brand1.getId(), "상품A", new BigDecimal("10000.00"), 100L, null),
+				"브랜드A");
+			saveProductWithReadModel(
+				ProductEntity.of(brand2.getId(), "상품B", new BigDecimal("20000.00"), 200L, null),
+				"브랜드B");
 
 			ProductSearchCriteria criteria = new ProductSearchCriteria(brand1.getId(), null);
 			PageCriteria pageCriteria = new PageCriteria(0, 10);
@@ -121,12 +197,12 @@ void searchProductsExcludesDeleted() {
 			// Arrange
 			BrandEntity brand = brandJpaRepository.save(
 				BrandEntity.of("브랜드", "설명", VisibleStatus.VISIBLE));
-			productJpaRepository.save(
-				ProductEntity.of(brand.getId(), "활성 상품", new BigDecimal("10000.00"), 100L, null, 0L));
-			ProductEntity deletedProduct = productJpaRepository.save(
-				ProductEntity.of(brand.getId(), "삭제 상품", new BigDecimal("20000.00"), 200L, null, 0L));
-			deletedProduct.delete();
-			productJpaRepository.save(deletedProduct);
+			saveProductWithReadModel(
+				ProductEntity.of(brand.getId(), "활성 상품", new BigDecimal("10000.00"), 100L, null),
+				"브랜드");
+			saveDeletedProductWithReadModel(
+				ProductEntity.of(brand.getId(), "삭제 상품", new BigDecimal("20000.00"), 200L, null),
+				"브랜드");
 
 			ProductSearchCriteria criteria = new ProductSearchCriteria(null, null);
 			PageCriteria pageCriteria = new PageCriteria(0, 10);
@@ -149,10 +225,12 @@ void searchProductsSortByPriceAsc() {
 			// Arrange
 			BrandEntity brand = brandJpaRepository.save(
 				BrandEntity.of("브랜드", "설명", VisibleStatus.VISIBLE));
-			productJpaRepository.save(
-				ProductEntity.of(brand.getId(), "비싼 상품", new BigDecimal("50000.00"), 10L, null, 0L));
-			productJpaRepository.save(
-				ProductEntity.of(brand.getId(), "저렴한 상품", new BigDecimal("10000.00"), 20L, null, 0L));
+			saveProductWithReadModel(
+				ProductEntity.of(brand.getId(), "비싼 상품", new BigDecimal("50000.00"), 10L, null),
+				"브랜드");
+			saveProductWithReadModel(
+				ProductEntity.of(brand.getId(), "저렴한 상품", new BigDecimal("10000.00"), 20L, null),
+				"브랜드");
 
 			ProductSearchCriteria criteria = new ProductSearchCriteria(null, ProductSortType.PRICE_ASC);
 			PageCriteria pageCriteria = new PageCriteria(0, 10);
@@ -175,10 +253,12 @@ void searchProductsSortByLikesDesc() {
 			// Arrange
 			BrandEntity brand = brandJpaRepository.save(
 				BrandEntity.of("브랜드", "설명", VisibleStatus.VISIBLE));
-			productJpaRepository.save(
-				ProductEntity.of(brand.getId(), "인기 상품", new BigDecimal("10000.00"), 100L, null, 50L));
-			productJpaRepository.save(
-				ProductEntity.of(brand.getId(), "일반 상품", new BigDecimal("10000.00"), 100L, null, 5L));
+			saveProductWithReadModel(
+				ProductEntity.of(brand.getId(), "인기 상품", new BigDecimal("10000.00"), 100L, null),
+				"브랜드", 50L);
+			saveProductWithReadModel(
+				ProductEntity.of(brand.getId(), "일반 상품", new BigDecimal("10000.00"), 100L, null),
+				"브랜드", 5L);
 
 			ProductSearchCriteria criteria = new ProductSearchCriteria(null, ProductSortType.LIKES_DESC);
 			PageCriteria pageCriteria = new PageCriteria(0, 10);
@@ -202,8 +282,9 @@ void searchProductsWithPagination() {
 			BrandEntity brand = brandJpaRepository.save(
 				BrandEntity.of("브랜드", "설명", VisibleStatus.VISIBLE));
 			for (int i = 1; i <= 5; i++) {
-				productJpaRepository.save(
-					ProductEntity.of(brand.getId(), "상품" + i, new BigDecimal("10000.00"), 100L, null, 0L));
+				saveProductWithReadModel(
+					ProductEntity.of(brand.getId(), "상품" + i, new BigDecimal("10000.00"), 100L, null),
+					"브랜드");
 			}
 
 			ProductSearchCriteria criteria = new ProductSearchCriteria(null, null);
@@ -226,8 +307,9 @@ void searchProductsWithPagination() {
 		@DisplayName("[searchProducts()] 브랜드가 없는 상품 (brandId가 존재하지 않는 브랜드) -> brandName null 반환")
 		void searchProductsWithNonExistentBrand() {
 			// Arrange
-			productJpaRepository.save(
-				ProductEntity.of(999L, "브랜드 없는 상품", new BigDecimal("10000.00"), 100L, null, 0L));
+			saveProductWithReadModel(
+				ProductEntity.of(999L, "브랜드 없는 상품", new BigDecimal("10000.00"), 100L, null),
+				null);
 
 			ProductSearchCriteria criteria = new ProductSearchCriteria(null, null);
 			PageCriteria pageCriteria = new PageCriteria(0, 10);
@@ -274,8 +356,9 @@ void searchAdminProductsWithBrandName() {
 			// Arrange
 			BrandEntity brand = brandJpaRepository.save(
 				BrandEntity.of("관리자 브랜드", "설명", VisibleStatus.VISIBLE));
-			productJpaRepository.save(
-				ProductEntity.of(brand.getId(), "관리자 상품", new BigDecimal("30000.00"), 50L, "설명", 10L));
+			saveProductWithReadModel(
+				ProductEntity.of(brand.getId(), "관리자 상품", new BigDecimal("30000.00"), 50L, "설명"),
+				"관리자 브랜드", 10L);
 
 			ProductSearchCriteria criteria = new ProductSearchCriteria(null, null);
 			PageCriteria pageCriteria = new PageCriteria(0, 10);
@@ -300,12 +383,12 @@ void searchAdminProductsIncludesDeleted() {
 			// Arrange
 			BrandEntity brand = brandJpaRepository.save(
 				BrandEntity.of("브랜드", "설명", VisibleStatus.VISIBLE));
-			productJpaRepository.save(
-				ProductEntity.of(brand.getId(), "활성 상품", new BigDecimal("10000.00"), 100L, null, 0L));
-			ProductEntity deletedProduct = productJpaRepository.save(
-				ProductEntity.of(brand.getId(), "삭제 상품", new BigDecimal("20000.00"), 200L, null, 0L));
-			deletedProduct.delete();
-			productJpaRepository.save(deletedProduct);
+			saveProductWithReadModel(
+				ProductEntity.of(brand.getId(), "활성 상품", new BigDecimal("10000.00"), 100L, null),
+				"브랜드");
+			saveDeletedProductWithReadModel(
+				ProductEntity.of(brand.getId(), "삭제 상품", new BigDecimal("20000.00"), 200L, null),
+				"브랜드");
 
 			ProductSearchCriteria criteria = new ProductSearchCriteria(null, null);
 			PageCriteria pageCriteria = new PageCriteria(0, 10);
@@ -329,10 +412,12 @@ void searchAdminProductsWithBrandIdFilter() {
 				BrandEntity.of("브랜드A", "설명A", VisibleStatus.VISIBLE));
 			BrandEntity brand2 = brandJpaRepository.save(
 				BrandEntity.of("브랜드B", "설명B", VisibleStatus.VISIBLE));
-			productJpaRepository.save(
-				ProductEntity.of(brand1.getId(), "상품A", new BigDecimal("10000.00"), 100L, null, 0L));
-			productJpaRepository.save(
-				ProductEntity.of(brand2.getId(), "상품B", new BigDecimal("20000.00"), 200L, null, 0L));
+			saveProductWithReadModel(
+				ProductEntity.of(brand1.getId(), "상품A", new BigDecimal("10000.00"), 100L, null),
+				"브랜드A");
+			saveProductWithReadModel(
+				ProductEntity.of(brand2.getId(), "상품B", new BigDecimal("20000.00"), 200L, null),
+				"브랜드B");
 
 			ProductSearchCriteria criteria = new ProductSearchCriteria(brand2.getId(), null);
 			PageCriteria pageCriteria = new PageCriteria(0, 10);
@@ -356,10 +441,12 @@ void searchAdminProductsSortByPriceAsc() {
 			// Arrange
 			BrandEntity brand = brandJpaRepository.save(
 				BrandEntity.of("브랜드", "설명", VisibleStatus.VISIBLE));
-			productJpaRepository.save(
-				ProductEntity.of(brand.getId(), "비싼 상품", new BigDecimal("50000.00"), 10L, null, 0L));
-			productJpaRepository.save(
-				ProductEntity.of(brand.getId(), "저렴한 상품", new BigDecimal("10000.00"), 20L, null, 0L));
+			saveProductWithReadModel(
+				ProductEntity.of(brand.getId(), "비싼 상품", new BigDecimal("50000.00"), 10L, null),
+				"브랜드");
+			saveProductWithReadModel(
+				ProductEntity.of(brand.getId(), "저렴한 상품", new BigDecimal("10000.00"), 20L, null),
+				"브랜드");
 
 			ProductSearchCriteria criteria = new ProductSearchCriteria(null, ProductSortType.PRICE_ASC);
 			PageCriteria pageCriteria = new PageCriteria(0, 10);
@@ -395,4 +482,343 @@ void searchAdminProductsEmpty() {
 
 	}
 
+
+	@Nested
+	@DisplayName("searchProductIds()")
+	class SearchProductIdsTest {
+
+		@Test
+		@DisplayName("[searchProductIds()] 활성 상품 존재 -> IdListCacheEntry(ids, totalElements) 반환. 정렬 적용")
+		void searchProductIdsSuccess() {
+			// Arrange
+			BrandEntity brand = brandJpaRepository.save(
+				BrandEntity.of("브랜드", "설명", VisibleStatus.VISIBLE));
+			ProductEntity p1 = saveProductWithReadModel(
+				ProductEntity.of(brand.getId(), "비싼 상품", new BigDecimal("50000.00"), 10L, null),
+				"브랜드");
+			ProductEntity p2 = saveProductWithReadModel(
+				ProductEntity.of(brand.getId(), "저렴한 상품", new BigDecimal("10000.00"), 20L, null),
+				"브랜드");
+
+			ProductSearchCriteria criteria = new ProductSearchCriteria(null, ProductSortType.PRICE_ASC);
+			PageCriteria pageCriteria = new PageCriteria(0, 10);
+
+			// Act
+			IdListCacheEntry result = productQueryPort.searchProductIds(criteria, pageCriteria);
+
+			// Assert — PRICE_ASC 정렬: 저렴한 상품(p2) → 비싼 상품(p1)
+			assertAll(
+				() -> assertThat(result.ids()).hasSize(2),
+				() -> assertThat(result.ids().get(0)).isEqualTo(p2.getId()),
+				() -> assertThat(result.ids().get(1)).isEqualTo(p1.getId()),
+				() -> assertThat(result.totalElements()).isEqualTo(2)
+			);
+		}
+
+
+		@Test
+		@DisplayName("[searchProductIds()] brandId 필터 -> 해당 브랜드의 ID만 반환")
+		void searchProductIdsWithBrandFilter() {
+			// Arrange
+			BrandEntity brand1 = brandJpaRepository.save(
+				BrandEntity.of("브랜드A", "설명A", VisibleStatus.VISIBLE));
+			BrandEntity brand2 = brandJpaRepository.save(
+				BrandEntity.of("브랜드B", "설명B", VisibleStatus.VISIBLE));
+			ProductEntity p1 = saveProductWithReadModel(
+				ProductEntity.of(brand1.getId(), "상품A", new BigDecimal("10000.00"), 100L, null),
+				"브랜드A");
+			saveProductWithReadModel(
+				ProductEntity.of(brand2.getId(), "상품B", new BigDecimal("20000.00"), 200L, null),
+				"브랜드B");
+
+			ProductSearchCriteria criteria = new ProductSearchCriteria(brand1.getId(), null);
+			PageCriteria pageCriteria = new PageCriteria(0, 10);
+
+			// Act
+			IdListCacheEntry result = productQueryPort.searchProductIds(criteria, pageCriteria);
+
+			// Assert
+			assertAll(
+				() -> assertThat(result.ids()).hasSize(1),
+				() -> assertThat(result.ids().get(0)).isEqualTo(p1.getId()),
+				() -> assertThat(result.totalElements()).isEqualTo(1)
+			);
+		}
+
+
+		@Test
+		@DisplayName("[searchProductIds()] 삭제된 상품 제외 -> 활성 상품 ID만 반환")
+		void searchProductIdsExcludesDeleted() {
+			// Arrange
+			BrandEntity brand = brandJpaRepository.save(
+				BrandEntity.of("브랜드", "설명", VisibleStatus.VISIBLE));
+			ProductEntity active = saveProductWithReadModel(
+				ProductEntity.of(brand.getId(), "활성 상품", new BigDecimal("10000.00"), 100L, null),
+				"브랜드");
+			saveDeletedProductWithReadModel(
+				ProductEntity.of(brand.getId(), "삭제 상품", new BigDecimal("20000.00"), 200L, null),
+				"브랜드");
+
+			ProductSearchCriteria criteria = new ProductSearchCriteria(null, null);
+			PageCriteria pageCriteria = new PageCriteria(0, 10);
+
+			// Act
+			IdListCacheEntry result = productQueryPort.searchProductIds(criteria, pageCriteria);
+
+			// Assert
+			assertAll(
+				() -> assertThat(result.ids()).hasSize(1),
+				() -> assertThat(result.ids().get(0)).isEqualTo(active.getId()),
+				() -> assertThat(result.totalElements()).isEqualTo(1)
+			);
+		}
+
+
+		@Test
+		@DisplayName("[searchProductIds()] 페이지네이션 -> 지정된 페이지 크기만큼 ID 반환. totalElements는 전체 개수")
+		void searchProductIdsWithPagination() {
+			// Arrange
+			BrandEntity brand = brandJpaRepository.save(
+				BrandEntity.of("브랜드", "설명", VisibleStatus.VISIBLE));
+			for (int i = 1; i <= 5; i++) {
+				saveProductWithReadModel(
+					ProductEntity.of(brand.getId(), "상품" + i, new BigDecimal("10000.00"), 100L, null),
+					"브랜드");
+			}
+
+			ProductSearchCriteria criteria = new ProductSearchCriteria(null, null);
+			PageCriteria pageCriteria = new PageCriteria(0, 2);
+
+			// Act
+			IdListCacheEntry result = productQueryPort.searchProductIds(criteria, pageCriteria);
+
+			// Assert
+			assertAll(
+				() -> assertThat(result.ids()).hasSize(2),
+				() -> assertThat(result.totalElements()).isEqualTo(5)
+			);
+		}
+
+
+		@Test
+		@DisplayName("[searchProductIds()] 빈 결과 -> ids 빈 목록, totalElements 0")
+		void searchProductIdsEmpty() {
+			// Arrange
+			ProductSearchCriteria criteria = new ProductSearchCriteria(null, null);
+			PageCriteria pageCriteria = new PageCriteria(0, 10);
+
+			// Act
+			IdListCacheEntry result = productQueryPort.searchProductIds(criteria, pageCriteria);
+
+			// Assert
+			assertAll(
+				() -> assertThat(result.ids()).isEmpty(),
+				() -> assertThat(result.totalElements()).isEqualTo(0)
+			);
+		}
+
+	}
+
+
+	@Nested
+	@DisplayName("findProductCacheDtoById()")
+	class FindProductCacheDtoByIdTest {
+
+		@Test
+		@DisplayName("[findProductCacheDtoById()] 활성 상품 ID -> ProductCacheDto 반환. brandName, description 포함")
+		void findProductCacheDtoByIdSuccess() {
+			// Arrange
+			BrandEntity brand = brandJpaRepository.save(
+				BrandEntity.of("나이키", "스포츠 브랜드", VisibleStatus.VISIBLE));
+			ProductEntity product = saveProductWithReadModel(
+				ProductEntity.of(brand.getId(), "에어맥스", new BigDecimal("129000.00"), 50L, "러닝화"),
+				"나이키", 10L);
+
+			// Act
+			ProductCacheDto result = productQueryPort.findProductCacheDtoById(product.getId());
+
+			// Assert
+			assertAll(
+				() -> assertThat(result).isNotNull(),
+				() -> assertThat(result.id()).isEqualTo(product.getId()),
+				() -> assertThat(result.brandId()).isEqualTo(brand.getId()),
+				() -> assertThat(result.brandName()).isEqualTo("나이키"),
+				() -> assertThat(result.name()).isEqualTo("에어맥스"),
+				() -> assertThat(result.price()).isEqualByComparingTo(new BigDecimal("129000.00")),
+				() -> assertThat(result.stock()).isEqualTo(50L),
+				() -> assertThat(result.description()).isEqualTo("러닝화"),
+				() -> assertThat(result.likeCount()).isEqualTo(10L)
+			);
+		}
+
+
+		@Test
+		@DisplayName("[findProductCacheDtoById()] 삭제된 상품 ID -> null 반환")
+		void findProductCacheDtoByIdDeleted() {
+			// Arrange
+			BrandEntity brand = brandJpaRepository.save(
+				BrandEntity.of("브랜드", "설명", VisibleStatus.VISIBLE));
+			ProductEntity deleted = saveDeletedProductWithReadModel(
+				ProductEntity.of(brand.getId(), "삭제 상품", new BigDecimal("10000.00"), 100L, null),
+				"브랜드");
+
+			// Act
+			ProductCacheDto result = productQueryPort.findProductCacheDtoById(deleted.getId());
+
+			// Assert
+			assertThat(result).isNull();
+		}
+
+
+		@Test
+		@DisplayName("[findProductCacheDtoById()] 존재하지 않는 ID -> null 반환")
+		void findProductCacheDtoByIdNotFound() {
+			// Act
+			ProductCacheDto result = productQueryPort.findProductCacheDtoById(999L);
+
+			// Assert
+			assertThat(result).isNull();
+		}
+
+	}
+
+
+	@Nested
+	@DisplayName("findProductCacheDtosByIds()")
+	class FindProductCacheDtosByIdsTest {
+
+		@Test
+		@DisplayName("[findProductCacheDtosByIds()] 활성 상품 ID 목록 -> ProductCacheDto 목록 반환")
+		void findProductCacheDtosByIdsSuccess() {
+			// Arrange
+			BrandEntity brand = brandJpaRepository.save(
+				BrandEntity.of("나이키", "스포츠 브랜드", VisibleStatus.VISIBLE));
+			ProductEntity p1 = saveProductWithReadModel(
+				ProductEntity.of(brand.getId(), "에어맥스", new BigDecimal("129000.00"), 50L, "러닝화"),
+				"나이키", 10L);
+			ProductEntity p2 = saveProductWithReadModel(
+				ProductEntity.of(brand.getId(), "에어포스", new BigDecimal("119000.00"), 30L, "캐주얼"),
+				"나이키", 20L);
+
+			// Act
+			List<ProductCacheDto> result = productQueryPort.findProductCacheDtosByIds(
+				List.of(p1.getId(), p2.getId()));
+
+			// Assert
+			assertAll(
+				() -> assertThat(result).hasSize(2),
+				() -> assertThat(result).extracting(ProductCacheDto::name)
+					.containsExactlyInAnyOrder("에어맥스", "에어포스")
+			);
+		}
+
+
+		@Test
+		@DisplayName("[findProductCacheDtosByIds()] 삭제된 상품 포함 ID 목록 -> 활성 상품만 반환")
+		void findProductCacheDtosByIdsExcludesDeleted() {
+			// Arrange
+			BrandEntity brand = brandJpaRepository.save(
+				BrandEntity.of("브랜드", "설명", VisibleStatus.VISIBLE));
+			ProductEntity active = saveProductWithReadModel(
+				ProductEntity.of(brand.getId(), "활성 상품", new BigDecimal("10000.00"), 100L, null),
+				"브랜드");
+			ProductEntity deleted = saveDeletedProductWithReadModel(
+				ProductEntity.of(brand.getId(), "삭제 상품", new BigDecimal("20000.00"), 200L, null),
+				"브랜드");
+
+			// Act
+			List<ProductCacheDto> result = productQueryPort.findProductCacheDtosByIds(
+				List.of(active.getId(), deleted.getId()));
+
+			// Assert — 활성 상품만 반환
+			assertAll(
+				() -> assertThat(result).hasSize(1),
+				() -> assertThat(result.get(0).id()).isEqualTo(active.getId()),
+				() -> assertThat(result.get(0).name()).isEqualTo("활성 상품")
+			);
+		}
+
+
+		@Test
+		@DisplayName("[findProductCacheDtosByIds()] 존재하지 않는 ID만 포함 -> 빈 목록 반환")
+		void findProductCacheDtosByIdsAllNotFound() {
+			// Act
+			List<ProductCacheDto> result = productQueryPort.findProductCacheDtosByIds(List.of(999L, 1000L));
+
+			// Assert
+			assertThat(result).isEmpty();
+		}
+
+	}
+
+
+	@Nested
+	@DisplayName("findAdminProductDetailById()")
+	class FindAdminProductDetailByIdTest {
+
+		@Test
+		@DisplayName("[findAdminProductDetailById()] 활성 상품 ID -> AdminProductDetailOutDto 반환. 모든 필드 포함")
+		void findAdminProductDetailByIdSuccess() {
+			// Arrange
+			BrandEntity brand = brandJpaRepository.save(
+				BrandEntity.of("나이키", "스포츠 브랜드", VisibleStatus.VISIBLE));
+			ProductEntity product = saveProductWithReadModel(
+				ProductEntity.of(brand.getId(), "에어맥스", new BigDecimal("129000.00"), 50L, "러닝화"),
+				"나이키", 10L);
+
+			// Act
+			AdminProductDetailOutDto result = productQueryPort.findAdminProductDetailById(product.getId());
+
+			// Assert
+			assertAll(
+				() -> assertThat(result).isNotNull(),
+				() -> assertThat(result.id()).isEqualTo(product.getId()),
+				() -> assertThat(result.brandId()).isEqualTo(brand.getId()),
+				() -> assertThat(result.brandName()).isEqualTo("나이키"),
+				() -> assertThat(result.name()).isEqualTo("에어맥스"),
+				() -> assertThat(result.price()).isEqualByComparingTo(new BigDecimal("129000.00")),
+				() -> assertThat(result.stock()).isEqualTo(50L),
+				() -> assertThat(result.description()).isEqualTo("러닝화"),
+				() -> assertThat(result.likeCount()).isEqualTo(10L),
+				() -> assertThat(result.deletedAt()).isNull()
+			);
+		}
+
+
+		@Test
+		@DisplayName("[findAdminProductDetailById()] 삭제된 상품 ID -> AdminProductDetailOutDto 반환. deletedAt 포함")
+		void findAdminProductDetailByIdDeleted() {
+			// Arrange
+			BrandEntity brand = brandJpaRepository.save(
+				BrandEntity.of("아디다스", "스포츠", VisibleStatus.VISIBLE));
+			ProductEntity deleted = saveDeletedProductWithReadModel(
+				ProductEntity.of(brand.getId(), "삭제 상품", new BigDecimal("50000.00"), 10L, null),
+				"아디다스");
+
+			// Act
+			AdminProductDetailOutDto result = productQueryPort.findAdminProductDetailById(deleted.getId());
+
+			// Assert
+			assertAll(
+				() -> assertThat(result).isNotNull(),
+				() -> assertThat(result.id()).isEqualTo(deleted.getId()),
+				() -> assertThat(result.brandName()).isEqualTo("아디다스"),
+				() -> assertThat(result.name()).isEqualTo("삭제 상품"),
+				() -> assertThat(result.deletedAt()).isNotNull()
+			);
+		}
+
+
+		@Test
+		@DisplayName("[findAdminProductDetailById()] 존재하지 않는 ID -> null 반환")
+		void findAdminProductDetailByIdNotFound() {
+			// Act
+			AdminProductDetailOutDto result = productQueryPort.findAdminProductDetailById(999L);
+
+			// Assert
+			assertThat(result).isNull();
+		}
+
+	}
+
 }

From 403a561b439d4d58d8441967b23090519739212d Mon Sep 17 00:00:00 2001
From: Hwan0518 <qip0518@naver.com>
Date: Fri, 13 Mar 2026 03:22:02 +0900
Subject: [PATCH 5/9] =?UTF-8?q?feat:=20ReadModel=20=EB=8F=99=EA=B8=B0?=
 =?UTF-8?q?=ED=99=94=20=EB=A1=9C=EC=A7=81=20=EA=B5=AC=ED=98=84?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- ProductCommandService에 ReadModel 동기화 메서드 추가 (생성/수정/삭제/좋아요 증감)
- BrandCommandFacade 브랜드 수정/삭제 시 ReadModel 동기화 호출
- ProductCommandServiceTest ReadModel 동기화 테스트 추가
- BrandCommandFacadeTest ReadModel 동기화 검증 추가
- ProductLikeCountConcurrencyTest ReadModel 기반으로 전환
- ProductStockConcurrencyTest, ProductLikeCountSyncerImplTest, OrderProductReaderImplTest 업데이트

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
---
 .../facade/BrandCommandFacade.java            |  17 +-
 .../service/ProductCommandService.java        | 127 +++++++++++++-
 .../facade/BrandCommandFacadeTest.java        |  15 +-
 .../service/ProductCommandServiceTest.java    | 166 +++++++++++++++---
 .../ProductLikeCountConcurrencyTest.java      |  53 ++++--
 .../service/ProductStockConcurrencyTest.java  |   4 +-
 .../ProductLikeCountSyncerImplTest.java       |  26 +--
 .../catalog/OrderProductReaderImplTest.java   |  12 +-
 8 files changed, 359 insertions(+), 61 deletions(-)

diff --git a/apps/commerce-api/src/main/java/com/loopers/catalog/brand/application/facade/BrandCommandFacade.java b/apps/commerce-api/src/main/java/com/loopers/catalog/brand/application/facade/BrandCommandFacade.java
index cae9d7d8d..705d49c5c 100644
--- a/apps/commerce-api/src/main/java/com/loopers/catalog/brand/application/facade/BrandCommandFacade.java
+++ b/apps/commerce-api/src/main/java/com/loopers/catalog/brand/application/facade/BrandCommandFacade.java
@@ -8,11 +8,14 @@
 import com.loopers.catalog.brand.application.service.BrandCommandService;
 import com.loopers.catalog.brand.application.service.BrandQueryService;
 import com.loopers.catalog.brand.domain.model.Brand;
+import com.loopers.catalog.product.application.service.ProductCommandService;
 import com.loopers.catalog.product.application.service.ProductQueryService;
 import lombok.RequiredArgsConstructor;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
+import java.util.List;
+
 
 @Service
 @RequiredArgsConstructor
@@ -22,12 +25,13 @@ public class BrandCommandFacade {
 	private final BrandCommandService brandCommandService;
 	private final BrandQueryService brandQueryService;
 	private final ProductQueryService productQueryService;
+	private final ProductCommandService productCommandService;
 
 
 	/**
 	 * 브랜드 명령 파사드
 	 * 1. 브랜드 생성
-	 * 2. 브랜드 수정
+	 * 2. 브랜드 수정 (브랜드명 변경 시 상품 상세 캐시 write-through)
 	 * 3. 브랜드 삭제
 	 * 4. 브랜드 노출 상태 변경
 	 */
@@ -44,7 +48,7 @@ public AdminBrandDetailOutDto createBrand(AdminBrandCreateInDto inDto) {
 	}
 
 
-	// 2. 브랜드 수정
+	// 2. 브랜드 수정 (브랜드명 변경 시 상품 상세 캐시 write-through)
 	@Transactional
 	public AdminBrandDetailOutDto updateBrand(Long id, AdminBrandUpdateInDto inDto) {
 
@@ -54,6 +58,15 @@ public AdminBrandDetailOutDto updateBrand(Long id, AdminBrandUpdateInDto inDto)
 		// 브랜드 수정
 		Brand updatedBrand = brandCommandService.updateBrand(brand, inDto);
 
+		// 상품 Read Model의 brand_name 일괄 동기화
+		productCommandService.syncBrandNameInReadModel(id, updatedBrand.getName().value());
+
+		// 상품 상세 캐시 write-through (해당 브랜드의 전체 상품)
+		List<Long> productIds = productQueryService.findActiveIdsByBrandId(id);
+		for (Long productId : productIds) {
+			productCommandService.refreshProductDetailCache(productId);
+		}
+
 		// DTO 변환
 		return AdminBrandDetailOutDto.from(updatedBrand);
 	}
diff --git a/apps/commerce-api/src/main/java/com/loopers/catalog/product/application/service/ProductCommandService.java b/apps/commerce-api/src/main/java/com/loopers/catalog/product/application/service/ProductCommandService.java
index abcdf8732..5f95f456e 100644
--- a/apps/commerce-api/src/main/java/com/loopers/catalog/product/application/service/ProductCommandService.java
+++ b/apps/commerce-api/src/main/java/com/loopers/catalog/product/application/service/ProductCommandService.java
@@ -5,15 +5,24 @@
 import com.loopers.catalog.product.application.dto.in.AdminProductUpdateInDto;
 import com.loopers.catalog.product.application.port.out.client.cart.CartItemCleanupManager;
 import com.loopers.catalog.product.application.port.out.client.engagement.ProductLikeCleanupManager;
+import com.loopers.catalog.product.application.port.out.query.ProductQueryPort;
+import com.loopers.catalog.product.application.port.out.query.criteria.ProductSearchCriteria;
 import com.loopers.catalog.product.domain.model.Product;
+import com.loopers.catalog.product.domain.model.enums.ProductSortType;
 import com.loopers.catalog.product.domain.repository.ProductCommandRepository;
 import com.loopers.catalog.product.domain.repository.ProductQueryRepository;
+import com.loopers.catalog.product.domain.repository.ProductReadModelRepository;
+import com.loopers.catalog.product.domain.repository.vo.PageCriteria;
+import com.loopers.catalog.product.infrastructure.cache.ProductCacheManager;
 import com.loopers.support.common.error.CoreException;
 import com.loopers.support.common.error.ErrorType;
 import org.springframework.context.annotation.Lazy;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
+import static com.loopers.catalog.product.infrastructure.cache.ProductCacheConstants.DEFAULT_PAGE_SIZE;
+import static com.loopers.catalog.product.infrastructure.cache.ProductCacheConstants.MAX_CACHEABLE_PAGE;
+
 
 @Service
 public class ProductCommandService {
@@ -21,6 +30,11 @@ public class ProductCommandService {
 	// repository
 	private final ProductCommandRepository productCommandRepository;
 	private final ProductQueryRepository productQueryRepository;
+	private final ProductReadModelRepository readModelRepository;
+	// cache
+	private final ProductCacheManager productCacheManager;
+	// port
+	private final ProductQueryPort productQueryPort;
 	// port (@Lazy: Cross-BC 순환 의존 방지 — ProductCommandService ↔ ProductLikeCommandService 간 ACL 경유 순환)
 	private final ProductLikeCleanupManager productLikeCleanupManager;
 	private final CartItemCleanupManager cartItemCleanupManager;
@@ -28,11 +42,17 @@ public class ProductCommandService {
 	public ProductCommandService(
 		ProductCommandRepository productCommandRepository,
 		ProductQueryRepository productQueryRepository,
+		ProductReadModelRepository readModelRepository,
+		ProductCacheManager productCacheManager,
+		ProductQueryPort productQueryPort,
 		@Lazy ProductLikeCleanupManager productLikeCleanupManager,
 		@Lazy CartItemCleanupManager cartItemCleanupManager
 	) {
 		this.productCommandRepository = productCommandRepository;
 		this.productQueryRepository = productQueryRepository;
+		this.readModelRepository = readModelRepository;
+		this.productCacheManager = productCacheManager;
+		this.productQueryPort = productQueryPort;
 		this.productLikeCleanupManager = productLikeCleanupManager;
 		this.cartItemCleanupManager = cartItemCleanupManager;
 	}
@@ -43,11 +63,17 @@ public ProductCommandService(
 	 * 1. 상품 생성
 	 * 2. 상품 수정
 	 * 3. 상품 삭제
-	 * 4. 좋아요 수 증가 (원자적 카운터)
-	 * 5. 좋아요 수 감소 (원자적 카운터)
-	 * 6. 상품 재고 차감 (비관적 쓰기 락)
+	 * 4. 좋아요 수 증가 (Read Model 원자적 카운터 + 상세 캐시 write-through)
+	 * 5. 좋아요 수 감소 (Read Model 원자적 카운터 + 상세 캐시 write-through)
+	 * 6. 상품 재고 차감 (비관적 쓰기 락 + 상세 캐시 write-through)
 	 * 7. 상품 좋아요 전체 삭제
 	 * 8. 장바구니 항목 전체 삭제
+	 * 9. Read Model 동기화 (상품 생성/수정 시 Facade에서 호출)
+	 * 10. Read Model 브랜드명 일괄 동기화 (브랜드 수정 시 호출)
+	 * 11. 상품 상세 캐시 write-through (Facade에서 호출)
+	 * 12. 상품 상세 캐시 삭제 (상품 삭제 시 Facade에서 호출)
+	 * 13. ID 리스트 캐시 write-through — 모든 정렬 (Facade에서 호출)
+	 * 14. ID 리스트 캐시 write-through — 특정 정렬 (Facade에서 호출)
 	 */
 
 	// 1. 상품 생성
@@ -92,24 +118,37 @@ public void deleteProduct(Product product) {
 
 		// 삭제 저장
 		productCommandRepository.delete(product);
+
+		// Read Model soft delete (관리자 목록 조회에서 삭제 상품도 조회 가능하도록)
+		readModelRepository.softDelete(product.getId());
 	}
 
 
-	// 4. 좋아요 수 증가 (원자적 카운터 — 단일 UPDATE SQL로 동시성 안전)
+	// 4. 좋아요 수 증가 (Read Model 원자적 카운터 + 상세 캐시 write-through)
 	@Transactional
 	public void increaseLikeCount(Long productId) {
-		productCommandRepository.increaseLikeCount(productId);
+
+		// Read Model 좋아요 수 증가 (likes 테이블이 SoT, Read Model이 유일한 projection)
+		readModelRepository.increaseLikeCount(productId);
+
+		// 상세 캐시 write-through (ID 리스트는 TTL 자연 만료 — 고빈도 트리거 최적화)
+		productCacheManager.refreshProductDetail(productId, () -> productQueryPort.findProductCacheDtoById(productId));
 	}
 
 
-	// 5. 좋아요 수 감소 (원자적 카운터 — 단일 UPDATE SQL로 동시성 안전)
+	// 5. 좋아요 수 감소 (Read Model 원자적 카운터 + 상세 캐시 write-through)
 	@Transactional
 	public void decreaseLikeCount(Long productId) {
-		productCommandRepository.decreaseLikeCount(productId);
+
+		// Read Model 좋아요 수 감소 (likes 테이블이 SoT, Read Model이 유일한 projection)
+		readModelRepository.decreaseLikeCount(productId);
+
+		// 상세 캐시 write-through (ID 리스트는 TTL 자연 만료 — 고빈도 트리거 최적화)
+		productCacheManager.refreshProductDetail(productId, () -> productQueryPort.findProductCacheDtoById(productId));
 	}
 
 
-	// 6. 상품 재고 차감 (비관적 쓰기 락)
+	// 6. 상품 재고 차감 (비관적 쓰기 락 + 상세 캐시 write-through)
 	@Transactional
 	public void decreaseStock(Long productId, Long quantity) {
 
@@ -122,6 +161,12 @@ public void decreaseStock(Long productId, Long quantity) {
 
 		// 재고가 차감된 상품 저장
 		productCommandRepository.save(product);
+
+		// Read Model 재고 동기화
+		readModelRepository.updateStock(productId, product.getStock().value());
+
+		// 상세 캐시 write-through (재고는 정렬 기준 아님 — ID 리스트 갱신 불필요)
+		productCacheManager.refreshProductDetail(productId, () -> productQueryPort.findProductCacheDtoById(productId));
 	}
 
 
@@ -138,4 +183,70 @@ public void deleteAllCartItems(Long productId) {
 		cartItemCleanupManager.deleteAllByProductId(productId);
 	}
 
+
+	// 9. Read Model 동기화 (상품 생성/수정 시 Facade에서 호출)
+	@Transactional
+	public void syncReadModel(Product product, String brandName) {
+		readModelRepository.save(product, brandName);
+	}
+
+
+	// 10. Read Model 브랜드명 일괄 동기화 (브랜드 수정 시 BrandCommandFacade에서 호출)
+	@Transactional
+	public void syncBrandNameInReadModel(Long brandId, String brandName) {
+		readModelRepository.updateBrandName(brandId, brandName);
+	}
+
+
+	// 11. 상품 상세 캐시 write-through (Facade에서 호출 — Read Model projection 기반)
+	public void refreshProductDetailCache(Long productId) {
+		productCacheManager.refreshProductDetail(productId, () -> productQueryPort.findProductCacheDtoById(productId));
+	}
+
+
+	// 12. 상품 상세 캐시 삭제 (상품 삭제 시 Facade에서 호출)
+	public void deleteProductDetailCache(Long productId) {
+		productCacheManager.deleteProductDetail(productId);
+	}
+
+
+	// 13. ID 리스트 캐시 write-through — 모든 정렬 (Facade에서 호출)
+	public void refreshIdListCacheForAllSorts(Long brandId) {
+		for (ProductSortType sort : ProductSortType.values()) {
+			refreshIdListCacheForSort(brandId, sort);
+		}
+	}
+
+
+	// 14. ID 리스트 캐시 write-through — 특정 정렬 (Facade에서 호출)
+	public void refreshIdListCacheForSort(Long brandId, ProductSortType sortType) {
+		for (int page = 0; page < MAX_CACHEABLE_PAGE; page++) {
+			// brandId 조건 갱신
+			refreshSingleIdList(brandId, sortType, page);
+			// all 조건 갱신
+			refreshSingleIdList(null, sortType, page);
+		}
+	}
+
+
+	/**
+	 * private method — ID 리스트 캐시 write-through
+	 */
+
+	// 단건 ID 리스트 write-through
+	private void refreshSingleIdList(Long brandId, ProductSortType sortType, int page) {
+		String cacheKey = buildIdListCacheKey(brandId, sortType, page, DEFAULT_PAGE_SIZE);
+		ProductSearchCriteria criteria = new ProductSearchCriteria(brandId, sortType);
+		PageCriteria pageCriteria = new PageCriteria(page, DEFAULT_PAGE_SIZE);
+		productCacheManager.refreshIdList(cacheKey, () -> productQueryPort.searchProductIds(criteria, pageCriteria));
+	}
+
+
+	// ID 리스트 캐시 키 생성: products:ids:v1:{brandId|all}:{sortType|LATEST}:{page}:{size}
+	private String buildIdListCacheKey(Long brandId, ProductSortType sortType, int page, int size) {
+		String brandPart = brandId != null ? brandId.toString() : "all";
+		String sortPart = sortType != null ? sortType.name() : "LATEST";
+		return "products:ids:v1:" + brandPart + ":" + sortPart + ":" + page + ":" + size;
+	}
+
 }
diff --git a/apps/commerce-api/src/test/java/com/loopers/catalog/brand/application/facade/BrandCommandFacadeTest.java b/apps/commerce-api/src/test/java/com/loopers/catalog/brand/application/facade/BrandCommandFacadeTest.java
index ceb1a89ff..785b41d04 100644
--- a/apps/commerce-api/src/test/java/com/loopers/catalog/brand/application/facade/BrandCommandFacadeTest.java
+++ b/apps/commerce-api/src/test/java/com/loopers/catalog/brand/application/facade/BrandCommandFacadeTest.java
@@ -11,6 +11,7 @@
 import com.loopers.catalog.brand.domain.model.enums.VisibleStatus;
 import com.loopers.catalog.brand.domain.model.vo.BrandDescription;
 import com.loopers.catalog.brand.domain.model.vo.BrandName;
+import com.loopers.catalog.product.application.service.ProductCommandService;
 import com.loopers.catalog.product.application.service.ProductQueryService;
 import com.loopers.support.common.error.CoreException;
 import com.loopers.support.common.error.ErrorType;
@@ -22,6 +23,8 @@
 import org.mockito.Mock;
 import org.mockito.junit.jupiter.MockitoExtension;
 
+import java.util.List;
+
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.junit.jupiter.api.Assertions.*;
 import static org.mockito.ArgumentMatchers.any;
@@ -44,13 +47,16 @@ class BrandCommandFacadeTest {
 	@Mock
 	private ProductQueryService productQueryService;
 
+	@Mock
+	private ProductCommandService productCommandService;
+
 	private BrandCommandFacade brandCommandFacade;
 
 
 	@BeforeEach
 	void setUp() {
 		brandCommandFacade = new BrandCommandFacade(
-			brandCommandService, brandQueryService, productQueryService
+			brandCommandService, brandQueryService, productQueryService, productCommandService
 		);
 	}
 
@@ -89,7 +95,7 @@ void createBrandSuccess() {
 	class UpdateBrandTest {
 
 		@Test
-		@DisplayName("[BrandCommandFacade.updateBrand()] 유효한 입력 -> 조회 후 수정. AdminBrandDetailOutDto 반환")
+		@DisplayName("[BrandCommandFacade.updateBrand()] 유효한 입력 -> 조회 후 수정. AdminBrandDetailOutDto 반환. Read Model 브랜드명 동기화 + 상품 상세 캐시 write-through")
 		void updateBrandSuccess() {
 			// Arrange
 			Brand brand = Brand.reconstruct(1L, BrandName.from("나이키"),
@@ -100,6 +106,7 @@ void updateBrandSuccess() {
 
 			given(brandQueryService.getBrandById(1L)).willReturn(brand);
 			given(brandCommandService.updateBrand(brand, inDto)).willReturn(updatedBrand);
+			given(productQueryService.findActiveIdsByBrandId(1L)).willReturn(List.of(10L, 20L));
 
 			// Act
 			AdminBrandDetailOutDto result = brandCommandFacade.updateBrand(1L, inDto);
@@ -113,6 +120,10 @@ void updateBrandSuccess() {
 			);
 			verify(brandQueryService).getBrandById(1L);
 			verify(brandCommandService).updateBrand(brand, inDto);
+			verify(productCommandService).syncBrandNameInReadModel(1L, "아디다스");
+			verify(productQueryService).findActiveIdsByBrandId(1L);
+			verify(productCommandService).refreshProductDetailCache(10L);
+			verify(productCommandService).refreshProductDetailCache(20L);
 		}
 
 
diff --git a/apps/commerce-api/src/test/java/com/loopers/catalog/product/application/service/ProductCommandServiceTest.java b/apps/commerce-api/src/test/java/com/loopers/catalog/product/application/service/ProductCommandServiceTest.java
index 3105efaae..b75f20637 100644
--- a/apps/commerce-api/src/test/java/com/loopers/catalog/product/application/service/ProductCommandServiceTest.java
+++ b/apps/commerce-api/src/test/java/com/loopers/catalog/product/application/service/ProductCommandServiceTest.java
@@ -5,12 +5,16 @@
 import com.loopers.catalog.product.application.dto.in.AdminProductUpdateInDto;
 import com.loopers.catalog.product.application.port.out.client.cart.CartItemCleanupManager;
 import com.loopers.catalog.product.application.port.out.client.engagement.ProductLikeCleanupManager;
+import com.loopers.catalog.product.application.port.out.query.ProductQueryPort;
 import com.loopers.catalog.product.domain.model.Product;
+import com.loopers.catalog.product.domain.model.enums.ProductSortType;
 import com.loopers.catalog.product.domain.model.vo.Money;
 import com.loopers.catalog.product.domain.model.vo.ProductName;
 import com.loopers.catalog.product.domain.model.vo.Stock;
 import com.loopers.catalog.product.domain.repository.ProductCommandRepository;
 import com.loopers.catalog.product.domain.repository.ProductQueryRepository;
+import com.loopers.catalog.product.domain.repository.ProductReadModelRepository;
+import com.loopers.catalog.product.infrastructure.cache.ProductCacheManager;
 import com.loopers.support.common.error.CoreException;
 import com.loopers.support.common.error.ErrorType;
 import org.junit.jupiter.api.BeforeEach;
@@ -27,7 +31,9 @@
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.junit.jupiter.api.Assertions.*;
 import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
 import static org.mockito.BDDMockito.*;
+import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
 
 
@@ -40,6 +46,12 @@ class ProductCommandServiceTest {
 	@Mock
 	private ProductQueryRepository productQueryRepository;
 	@Mock
+	private ProductReadModelRepository readModelRepository;
+	@Mock
+	private ProductCacheManager productCacheManager;
+	@Mock
+	private ProductQueryPort productQueryPort;
+	@Mock
 	private ProductLikeCleanupManager productLikeCleanupManager;
 	@Mock
 	private CartItemCleanupManager cartItemCleanupManager;
@@ -50,8 +62,8 @@ class ProductCommandServiceTest {
 	@BeforeEach
 	void setUp() {
 		productCommandService = new ProductCommandService(
-			productCommandRepository, productQueryRepository,
-			productLikeCleanupManager, cartItemCleanupManager
+			productCommandRepository, productQueryRepository, readModelRepository,
+			productCacheManager, productQueryPort, productLikeCleanupManager, cartItemCleanupManager
 		);
 	}
 
@@ -70,7 +82,7 @@ void createProductSuccess() {
 			given(productCommandRepository.save(any(Product.class))).willAnswer(invocation -> {
 				Product p = invocation.getArgument(0);
 				return Product.reconstruct(1L, p.getBrandId(), p.getName(), p.getPrice(),
-					p.getStock(), p.getDescription(), p.getLikeCount(), p.getDeletedAt());
+					p.getStock(), p.getDescription(), p.getDeletedAt());
 			});
 
 			// Act
@@ -100,7 +112,7 @@ void updateProductSuccess() {
 				ProductName.from("원래 상품"),
 				Money.from(new BigDecimal("10000")),
 				Stock.from(100L),
-				null, 0L, null);
+				null, null);
 			AdminProductUpdateInDto inDto = new AdminProductUpdateInDto(
 				"수정 상품", new BigDecimal("20000"), 200L, "수정 설명"
 			);
@@ -126,14 +138,14 @@ void updateProductSuccess() {
 	class DeleteProductTest {
 
 		@Test
-		@DisplayName("[deleteProduct()] 활성 상품 -> soft delete 수행")
+		@DisplayName("[deleteProduct()] 활성 상품 -> soft delete 수행. Read Model soft delete 동기화")
 		void deleteProductSuccess() {
 			// Arrange
 			Product product = Product.reconstruct(1L, 1L,
 				ProductName.from("상품"),
 				Money.from(BigDecimal.TEN),
 				Stock.from(100L),
-				null, 0L, null);
+				null, null);
 
 			// Act
 			productCommandService.deleteProduct(product);
@@ -141,7 +153,8 @@ void deleteProductSuccess() {
 			// Assert
 			assertAll(
 				() -> assertThat(product.isDeleted()).isTrue(),
-				() -> verify(productCommandRepository).delete(product)
+				() -> verify(productCommandRepository).delete(product),
+				() -> verify(readModelRepository).softDelete(1L)
 			);
 		}
 
@@ -153,16 +166,16 @@ void deleteProductSuccess() {
 	class IncreaseLikeCountTest {
 
 		@Test
-		@DisplayName("[increaseLikeCount()] 유효한 상품 ID -> 원자적 카운터로 좋아요 수 증가 위임")
+		@DisplayName("[increaseLikeCount()] 유효한 상품 ID -> Read Model 원자적 카운터로 좋아요 수 증가. 상세 캐시 write-through")
 		void increaseLikeCountSuccess() {
-			// Arrange
-			willDoNothing().given(productCommandRepository).increaseLikeCount(1L);
-
 			// Act
 			productCommandService.increaseLikeCount(1L);
 
 			// Assert
-			verify(productCommandRepository).increaseLikeCount(1L);
+			assertAll(
+				() -> verify(readModelRepository).increaseLikeCount(1L),
+				() -> verify(productCacheManager).refreshProductDetail(eq(1L), any())
+			);
 		}
 
 	}
@@ -173,16 +186,16 @@ void increaseLikeCountSuccess() {
 	class DecreaseLikeCountTest {
 
 		@Test
-		@DisplayName("[decreaseLikeCount()] 유효한 상품 ID -> 원자적 카운터로 좋아요 수 감소 위임")
+		@DisplayName("[decreaseLikeCount()] 유효한 상품 ID -> Read Model 원자적 카운터로 좋아요 수 감소. 상세 캐시 write-through")
 		void decreaseLikeCountSuccess() {
-			// Arrange
-			willDoNothing().given(productCommandRepository).decreaseLikeCount(1L);
-
 			// Act
 			productCommandService.decreaseLikeCount(1L);
 
 			// Assert
-			verify(productCommandRepository).decreaseLikeCount(1L);
+			assertAll(
+				() -> verify(readModelRepository).decreaseLikeCount(1L),
+				() -> verify(productCacheManager).refreshProductDetail(eq(1L), any())
+			);
 		}
 
 	}
@@ -193,14 +206,14 @@ void decreaseLikeCountSuccess() {
 	class DecreaseStockTest {
 
 		@Test
-		@DisplayName("[decreaseStock()] 활성 상품 재고 차감 -> 차감 후 저장. 비관적 쓰기 락으로 조회")
+		@DisplayName("[decreaseStock()] 활성 상품 재고 차감 -> 차감 후 저장. 비관적 쓰기 락으로 조회. Read Model 재고 동기화. 상세 캐시 write-through")
 		void decreaseStockSuccess() {
 			// Arrange
 			Product product = Product.reconstruct(1L, 1L,
 				ProductName.from("상품"),
 				Money.from(BigDecimal.TEN),
 				Stock.from(100L),
-				null, 0L, null);
+				null, null);
 			given(productQueryRepository.findActiveByIdForUpdate(1L)).willReturn(Optional.of(product));
 			given(productCommandRepository.save(any(Product.class))).willAnswer(invocation -> invocation.getArgument(0));
 
@@ -211,7 +224,9 @@ void decreaseStockSuccess() {
 			assertAll(
 				() -> assertThat(product.getStock().value()).isEqualTo(90L),
 				() -> verify(productQueryRepository).findActiveByIdForUpdate(1L),
-				() -> verify(productCommandRepository).save(product)
+				() -> verify(productCommandRepository).save(product),
+				() -> verify(readModelRepository).updateStock(1L, 90L),
+				() -> verify(productCacheManager).refreshProductDetail(eq(1L), any())
 			);
 		}
 
@@ -240,7 +255,7 @@ void decreaseStockOutOfStock() {
 				ProductName.from("상품"),
 				Money.from(BigDecimal.TEN),
 				Stock.from(5L),
-				null, 0L, null);
+				null, null);
 			given(productQueryRepository.findActiveByIdForUpdate(1L)).willReturn(Optional.of(product));
 
 			// Act
@@ -295,4 +310,113 @@ void deleteAllCartItemsSuccess() {
 
 	}
 
+
+	@Nested
+	@DisplayName("syncReadModel()")
+	class SyncReadModelTest {
+
+		@Test
+		@DisplayName("[syncReadModel()] Product와 brandName으로 Read Model 저장 -> readModelRepository.save() 호출")
+		void syncReadModelSuccess() {
+			// Arrange
+			Product product = Product.reconstruct(1L, 1L,
+				ProductName.from("상품"),
+				Money.from(BigDecimal.TEN),
+				Stock.from(100L),
+				null, null);
+
+			// Act
+			productCommandService.syncReadModel(product, "나이키");
+
+			// Assert
+			verify(readModelRepository).save(product, "나이키");
+		}
+
+	}
+
+
+	@Nested
+	@DisplayName("syncBrandNameInReadModel()")
+	class SyncBrandNameInReadModelTest {
+
+		@Test
+		@DisplayName("[syncBrandNameInReadModel()] brandId와 brandName으로 Read Model 브랜드명 일괄 업데이트 -> readModelRepository.updateBrandName() 호출")
+		void syncBrandNameInReadModelSuccess() {
+			// Act
+			productCommandService.syncBrandNameInReadModel(1L, "아디다스");
+
+			// Assert
+			verify(readModelRepository).updateBrandName(1L, "아디다스");
+		}
+
+	}
+
+
+	@Nested
+	@DisplayName("deleteProductDetailCache()")
+	class DeleteProductDetailCacheTest {
+
+		@Test
+		@DisplayName("[deleteProductDetailCache()] 상품 ID로 상세 캐시 삭제 -> deleteProductDetail() 호출")
+		void deleteProductDetailCacheSuccess() {
+			// Act
+			productCommandService.deleteProductDetailCache(1L);
+
+			// Assert
+			verify(productCacheManager).deleteProductDetail(1L);
+		}
+
+	}
+
+
+	@Nested
+	@DisplayName("refreshProductDetailCache()")
+	class RefreshProductDetailCacheTest {
+
+		@Test
+		@DisplayName("[refreshProductDetailCache()] 상품 ID -> productCacheManager.refreshProductDetail() 호출. Supplier로 QueryPort 전달")
+		void refreshProductDetailCacheSuccess() {
+			// Act
+			productCommandService.refreshProductDetailCache(1L);
+
+			// Assert
+			verify(productCacheManager).refreshProductDetail(eq(1L), any());
+		}
+
+	}
+
+
+	@Nested
+	@DisplayName("refreshIdListCacheForAllSorts()")
+	class RefreshIdListCacheForAllSortsTest {
+
+		@Test
+		@DisplayName("[refreshIdListCacheForAllSorts()] brandId -> 모든 정렬 × cacheable 페이지 × (brand + all) ID 리스트 갱신")
+		void refreshIdListCacheForAllSortsSuccess() {
+			// Act
+			productCommandService.refreshIdListCacheForAllSorts(1L);
+
+			// Assert — 3 정렬 × 2 페이지 × 2 (brand + all) = 12 calls
+			verify(productCacheManager, times(12)).refreshIdList(any(), any());
+		}
+
+	}
+
+
+	@Nested
+	@DisplayName("refreshIdListCacheForSort()")
+	class RefreshIdListCacheForSortTest {
+
+		@Test
+		@DisplayName("[refreshIdListCacheForSort()] brandId + PRICE_ASC -> 해당 정렬의 cacheable 페이지 × (brand + all) ID 리스트 갱신")
+		void refreshIdListCacheForSortSuccess() {
+			// Act
+			productCommandService.refreshIdListCacheForSort(1L, ProductSortType.PRICE_ASC);
+
+			// Assert — 2 페이지 × 2 (brand + all) = 4 calls
+			verify(productCacheManager, times(4)).refreshIdList(any(), any());
+		}
+
+	}
+
 }
diff --git a/apps/commerce-api/src/test/java/com/loopers/catalog/product/application/service/ProductLikeCountConcurrencyTest.java b/apps/commerce-api/src/test/java/com/loopers/catalog/product/application/service/ProductLikeCountConcurrencyTest.java
index 2949ed6f1..b234f3932 100644
--- a/apps/commerce-api/src/test/java/com/loopers/catalog/product/application/service/ProductLikeCountConcurrencyTest.java
+++ b/apps/commerce-api/src/test/java/com/loopers/catalog/product/application/service/ProductLikeCountConcurrencyTest.java
@@ -4,8 +4,14 @@
 import com.loopers.catalog.brand.domain.model.enums.VisibleStatus;
 import com.loopers.catalog.brand.infrastructure.entity.BrandEntity;
 import com.loopers.catalog.brand.infrastructure.jpa.BrandJpaRepository;
+import com.loopers.catalog.product.domain.model.Product;
+import com.loopers.catalog.product.domain.model.vo.Money;
+import com.loopers.catalog.product.domain.model.vo.ProductName;
+import com.loopers.catalog.product.domain.model.vo.Stock;
 import com.loopers.catalog.product.infrastructure.entity.ProductEntity;
+import com.loopers.catalog.product.infrastructure.entity.ProductReadModelEntity;
 import com.loopers.catalog.product.infrastructure.jpa.ProductJpaRepository;
+import com.loopers.catalog.product.infrastructure.jpa.ProductReadModelJpaRepository;
 import com.loopers.testcontainers.MySqlTestContainersConfig;
 import com.loopers.testcontainers.RedisTestContainersConfig;
 import com.loopers.utils.DatabaseCleanUp;
@@ -18,6 +24,7 @@
 import org.springframework.test.context.ActiveProfiles;
 
 import java.math.BigDecimal;
+import java.time.ZonedDateTime;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.concurrent.ExecutorService;
@@ -40,6 +47,9 @@ class ProductLikeCountConcurrencyTest {
 	@Autowired
 	private ProductJpaRepository productJpaRepository;
 
+	@Autowired
+	private ProductReadModelJpaRepository productReadModelJpaRepository;
+
 	@Autowired
 	private BrandJpaRepository brandJpaRepository;
 
@@ -54,14 +64,15 @@ void tearDown() {
 
 
 	@Test
-	@DisplayName("[increaseLikeCount()] 동시 좋아요 수 증가 10건 -> likeCount 정확히 10. 원자적 카운터로 Lost Update 방지")
+	@DisplayName("[increaseLikeCount()] 동시 좋아요 수 증가 10건 -> Read Model likeCount 정확히 10. 원자적 카운터로 Lost Update 방지")
 	void concurrentIncreaseLikeCount() throws Exception {
 		// Arrange
 		BrandEntity brand = brandJpaRepository.save(
 			BrandEntity.of("테스트 브랜드", "설명", VisibleStatus.VISIBLE));
 		ProductEntity product = productJpaRepository.save(
-			ProductEntity.of(brand.getId(), "테스트 상품", new BigDecimal("10000.00"), 100L, "설명", 0L));
+			ProductEntity.of(brand.getId(), "테스트 상품", new BigDecimal("10000.00"), 100L, "설명"));
 		Long productId = product.getId();
+		saveReadModel(product, "테스트 브랜드", 0L);
 
 		int threadCount = 10;
 		ExecutorService executorService = Executors.newFixedThreadPool(threadCount);
@@ -77,21 +88,22 @@ void concurrentIncreaseLikeCount() throws Exception {
 		}
 		executorService.shutdown();
 
-		// Assert
-		ProductEntity result = productJpaRepository.findById(productId).orElseThrow();
+		// Assert — Read Model의 likeCount 검증
+		ProductReadModelEntity result = productReadModelJpaRepository.findById(productId).orElseThrow();
 		assertThat(result.getLikeCount()).isEqualTo(10L);
 	}
 
 
 	@Test
-	@DisplayName("[decreaseLikeCount()] 동시 좋아요 수 감소 10건 -> likeCount 정확히 0. 원자적 카운터로 음수 방지")
+	@DisplayName("[decreaseLikeCount()] 동시 좋아요 수 감소 10건 -> Read Model likeCount 정확히 0. 원자적 카운터로 음수 방지")
 	void concurrentDecreaseLikeCount() throws Exception {
 		// Arrange
 		BrandEntity brand = brandJpaRepository.save(
 			BrandEntity.of("테스트 브랜드", "설명", VisibleStatus.VISIBLE));
 		ProductEntity product = productJpaRepository.save(
-			ProductEntity.of(brand.getId(), "테스트 상품", new BigDecimal("10000.00"), 100L, "설명", 10L));
+			ProductEntity.of(brand.getId(), "테스트 상품", new BigDecimal("10000.00"), 100L, "설명"));
 		Long productId = product.getId();
+		saveReadModel(product, "테스트 브랜드", 10L);
 
 		int threadCount = 10;
 		ExecutorService executorService = Executors.newFixedThreadPool(threadCount);
@@ -107,21 +119,22 @@ void concurrentDecreaseLikeCount() throws Exception {
 		}
 		executorService.shutdown();
 
-		// Assert
-		ProductEntity result = productJpaRepository.findById(productId).orElseThrow();
+		// Assert — Read Model의 likeCount 검증
+		ProductReadModelEntity result = productReadModelJpaRepository.findById(productId).orElseThrow();
 		assertThat(result.getLikeCount()).isEqualTo(0L);
 	}
 
 
 	@Test
-	@DisplayName("[increaseLikeCount()] 동시 좋아요 수 증가 50건 -> likeCount 정확히 50. 높은 경합에서도 원자적 카운터 정확성 보장")
+	@DisplayName("[increaseLikeCount()] 동시 좋아요 수 증가 50건 -> Read Model likeCount 정확히 50. 높은 경합에서도 원자적 카운터 정확성 보장")
 	void concurrentIncreaseLikeCountHighContention() throws Exception {
 		// Arrange
 		BrandEntity brand = brandJpaRepository.save(
 			BrandEntity.of("테스트 브랜드", "설명", VisibleStatus.VISIBLE));
 		ProductEntity product = productJpaRepository.save(
-			ProductEntity.of(brand.getId(), "테스트 상품", new BigDecimal("10000.00"), 100L, "설명", 0L));
+			ProductEntity.of(brand.getId(), "테스트 상품", new BigDecimal("10000.00"), 100L, "설명"));
 		Long productId = product.getId();
+		saveReadModel(product, "테스트 브랜드", 0L);
 
 		int threadCount = 50;
 		ExecutorService executorService = Executors.newFixedThreadPool(threadCount);
@@ -137,9 +150,25 @@ void concurrentIncreaseLikeCountHighContention() throws Exception {
 		}
 		executorService.shutdown();
 
-		// Assert
-		ProductEntity result = productJpaRepository.findById(productId).orElseThrow();
+		// Assert — Read Model의 likeCount 검증
+		ProductReadModelEntity result = productReadModelJpaRepository.findById(productId).orElseThrow();
 		assertThat(result.getLikeCount()).isEqualTo(50L);
 	}
 
+
+	// Read Model 저장 헬퍼
+	private void saveReadModel(ProductEntity productEntity, String brandName, Long likeCount) {
+		Product product = Product.reconstruct(
+			productEntity.getId(),
+			productEntity.getBrandId(),
+			ProductName.from(productEntity.getName()),
+			Money.from(productEntity.getPrice()),
+			Stock.from(productEntity.getStock()),
+			null,
+			productEntity.getDeletedAt()
+		);
+		productReadModelJpaRepository.save(
+			ProductReadModelEntity.of(product, brandName, ZonedDateTime.now(), likeCount));
+	}
+
 }
diff --git a/apps/commerce-api/src/test/java/com/loopers/catalog/product/application/service/ProductStockConcurrencyTest.java b/apps/commerce-api/src/test/java/com/loopers/catalog/product/application/service/ProductStockConcurrencyTest.java
index 9ae16639d..e760a0b69 100644
--- a/apps/commerce-api/src/test/java/com/loopers/catalog/product/application/service/ProductStockConcurrencyTest.java
+++ b/apps/commerce-api/src/test/java/com/loopers/catalog/product/application/service/ProductStockConcurrencyTest.java
@@ -64,7 +64,7 @@ void concurrentDecreaseStock() throws Exception {
 		BrandEntity brand = brandJpaRepository.save(
 			BrandEntity.of("테스트 브랜드", "설명", VisibleStatus.VISIBLE));
 		ProductEntity product = productJpaRepository.save(
-			ProductEntity.of(brand.getId(), "테스트 상품", new BigDecimal("10000.00"), 100L, "설명", 0L));
+			ProductEntity.of(brand.getId(), "테스트 상품", new BigDecimal("10000.00"), 100L, "설명"));
 		Long productId = product.getId();
 
 		int threadCount = 10;
@@ -94,7 +94,7 @@ void concurrentDecreaseStockInsufficientStock() throws Exception {
 		BrandEntity brand = brandJpaRepository.save(
 			BrandEntity.of("테스트 브랜드", "설명", VisibleStatus.VISIBLE));
 		ProductEntity product = productJpaRepository.save(
-			ProductEntity.of(brand.getId(), "테스트 상품", new BigDecimal("10000.00"), 5L, "설명", 0L));
+			ProductEntity.of(brand.getId(), "테스트 상품", new BigDecimal("10000.00"), 5L, "설명"));
 		Long productId = product.getId();
 
 		int threadCount = 10;
diff --git a/apps/commerce-api/src/test/java/com/loopers/engagement/productlike/infrastructure/acl/catalog/ProductLikeCountSyncerImplTest.java b/apps/commerce-api/src/test/java/com/loopers/engagement/productlike/infrastructure/acl/catalog/ProductLikeCountSyncerImplTest.java
index 1ae02bade..86e19130d 100644
--- a/apps/commerce-api/src/test/java/com/loopers/engagement/productlike/infrastructure/acl/catalog/ProductLikeCountSyncerImplTest.java
+++ b/apps/commerce-api/src/test/java/com/loopers/engagement/productlike/infrastructure/acl/catalog/ProductLikeCountSyncerImplTest.java
@@ -7,9 +7,11 @@
 import org.junit.jupiter.api.Nested;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.ArgumentCaptor;
 import org.mockito.Mock;
 import org.mockito.junit.jupiter.MockitoExtension;
 
+import static org.assertj.core.api.Assertions.assertThat;
 import static org.mockito.BDDMockito.*;
 import static org.mockito.Mockito.verify;
 
@@ -35,16 +37,18 @@ void setUp() {
 	class IncreaseLikeCountTest {
 
 		@Test
-		@DisplayName("[increaseLikeCount()] 상품 ID 전달 -> Provider Facade에 좋아요 수 증가 위임")
+		@DisplayName("[increaseLikeCount()] 상품 ID 전달 -> Provider Facade에 동일한 상품 ID로 좋아요 수 증가 위임")
 		void increaseLikeCountSuccess() {
 			// Arrange
-			willDoNothing().given(productCommandFacade).increaseLikeCount(1L);
+			Long productId = 42L;
 
 			// Act
-			productLikeCountSyncerImpl.increaseLikeCount(1L);
+			productLikeCountSyncerImpl.increaseLikeCount(productId);
 
-			// Assert
-			verify(productCommandFacade).increaseLikeCount(1L);
+			// Assert — 전달된 상품 ID가 정확히 위임됨을 검증
+			ArgumentCaptor<Long> captor = ArgumentCaptor.forClass(Long.class);
+			verify(productCommandFacade).increaseLikeCount(captor.capture());
+			assertThat(captor.getValue()).isEqualTo(productId);
 		}
 
 	}
@@ -55,16 +59,18 @@ void increaseLikeCountSuccess() {
 	class DecreaseLikeCountTest {
 
 		@Test
-		@DisplayName("[decreaseLikeCount()] 상품 ID 전달 -> Provider Facade에 좋아요 수 감소 위임")
+		@DisplayName("[decreaseLikeCount()] 상품 ID 전달 -> Provider Facade에 동일한 상품 ID로 좋아요 수 감소 위임")
 		void decreaseLikeCountSuccess() {
 			// Arrange
-			willDoNothing().given(productCommandFacade).decreaseLikeCount(1L);
+			Long productId = 42L;
 
 			// Act
-			productLikeCountSyncerImpl.decreaseLikeCount(1L);
+			productLikeCountSyncerImpl.decreaseLikeCount(productId);
 
-			// Assert
-			verify(productCommandFacade).decreaseLikeCount(1L);
+			// Assert — 전달된 상품 ID가 정확히 위임됨을 검증
+			ArgumentCaptor<Long> captor = ArgumentCaptor.forClass(Long.class);
+			verify(productCommandFacade).decreaseLikeCount(captor.capture());
+			assertThat(captor.getValue()).isEqualTo(productId);
 		}
 
 	}
diff --git a/apps/commerce-api/src/test/java/com/loopers/ordering/order/infrastructure/acl/catalog/OrderProductReaderImplTest.java b/apps/commerce-api/src/test/java/com/loopers/ordering/order/infrastructure/acl/catalog/OrderProductReaderImplTest.java
index bbcf2b030..951f74dda 100644
--- a/apps/commerce-api/src/test/java/com/loopers/ordering/order/infrastructure/acl/catalog/OrderProductReaderImplTest.java
+++ b/apps/commerce-api/src/test/java/com/loopers/ordering/order/infrastructure/acl/catalog/OrderProductReaderImplTest.java
@@ -48,24 +48,28 @@ void readProductsSuccess() {
 			ProductName.from("나이키 에어맥스"),
 			Money.from(new BigDecimal("100000")),
 			Stock.from(10L),
-			null, 0L, null);
+			null, null);
 		Product p2 = Product.reconstruct(2L, 1L,
 			ProductName.from("아디다스 울트라부스트"),
 			Money.from(new BigDecimal("200000")),
 			Stock.from(5L),
-			null, 0L, null);
+			null, null);
 		given(productQueryFacade.findActiveByIds(productIds)).willReturn(List.of(p1, p2));
 
 		// Act
 		List<OrderProductInfo> result = orderProductReaderImpl.readProducts(productIds);
 
-		// Assert
+		// Assert — Product → OrderProductInfo 변환 전체 필드 검증
 		assertAll(
 			() -> assertThat(result).hasSize(2),
 			() -> assertThat(result.get(0).productId()).isEqualTo(1L),
 			() -> assertThat(result.get(0).name()).isEqualTo("나이키 에어맥스"),
+			() -> assertThat(result.get(0).price()).isEqualByComparingTo(new BigDecimal("100000")),
+			() -> assertThat(result.get(0).stock()).isEqualTo(10L),
 			() -> assertThat(result.get(1).productId()).isEqualTo(2L),
-			() -> verify(productQueryFacade).findActiveByIds(productIds)
+			() -> assertThat(result.get(1).name()).isEqualTo("아디다스 울트라부스트"),
+			() -> assertThat(result.get(1).price()).isEqualByComparingTo(new BigDecimal("200000")),
+			() -> assertThat(result.get(1).stock()).isEqualTo(5L)
 		);
 	}
 

From a94fd35695051a8d895c0c5076d6137f5885e5dc Mon Sep 17 00:00:00 2001
From: Hwan0518 <qip0518@naver.com>
Date: Fri, 13 Mar 2026 03:22:17 +0900
Subject: [PATCH 6/9] =?UTF-8?q?feat:=20Redis=20=EC=BA=90=EC=8B=9C=20?=
 =?UTF-8?q?=EC=9D=B8=ED=94=84=EB=9D=BC=20(ProductCacheManager)=20=EA=B5=AC?=
 =?UTF-8?q?=ED=98=84?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- ProductCacheManager: Cache-Aside 패턴, try-catch 장애 격리, TTL jitter
- ProductCacheConstants: 캐시 키/TTL 상수 정의
- ProductCacheDto: 캐시 전용 DTO (Redis 직렬화)
- IdListCacheEntry: ID 목록 캐시 엔트리
- CacheLock, LocalCacheLock, RedisCacheLock: 캐시 stampede 방어
- ProductCacheManagerTest: 직렬화/역직렬화, TTL, 장애 격리 테스트
- CacheStampedeTest: stampede 방어 동시성 테스트
- LocalCacheLockTest: 로컬 락 단위 테스트

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
---
 .../service/ProductCommandService.java        |   9 +-
 .../infrastructure/cache/CacheLock.java       |  16 +
 .../cache/IdListCacheEntry.java               |  14 +
 .../infrastructure/cache/LocalCacheLock.java  |  46 ++
 .../cache/ProductCacheConstants.java          |  50 ++
 .../infrastructure/cache/ProductCacheDto.java |  40 ++
 .../cache/ProductCacheManager.java            | 333 +++++++++++
 .../infrastructure/cache/RedisCacheLock.java  |  83 +++
 .../cache/CacheStampedeTest.java              | 162 ++++++
 .../cache/LocalCacheLockTest.java             | 161 ++++++
 .../cache/ProductCacheManagerTest.java        | 540 ++++++++++++++++++
 11 files changed, 1446 insertions(+), 8 deletions(-)
 create mode 100644 apps/commerce-api/src/main/java/com/loopers/catalog/product/infrastructure/cache/CacheLock.java
 create mode 100644 apps/commerce-api/src/main/java/com/loopers/catalog/product/infrastructure/cache/IdListCacheEntry.java
 create mode 100644 apps/commerce-api/src/main/java/com/loopers/catalog/product/infrastructure/cache/LocalCacheLock.java
 create mode 100644 apps/commerce-api/src/main/java/com/loopers/catalog/product/infrastructure/cache/ProductCacheConstants.java
 create mode 100644 apps/commerce-api/src/main/java/com/loopers/catalog/product/infrastructure/cache/ProductCacheDto.java
 create mode 100644 apps/commerce-api/src/main/java/com/loopers/catalog/product/infrastructure/cache/ProductCacheManager.java
 create mode 100644 apps/commerce-api/src/main/java/com/loopers/catalog/product/infrastructure/cache/RedisCacheLock.java
 create mode 100644 apps/commerce-api/src/test/java/com/loopers/catalog/product/infrastructure/cache/CacheStampedeTest.java
 create mode 100644 apps/commerce-api/src/test/java/com/loopers/catalog/product/infrastructure/cache/LocalCacheLockTest.java
 create mode 100644 apps/commerce-api/src/test/java/com/loopers/catalog/product/infrastructure/cache/ProductCacheManagerTest.java

diff --git a/apps/commerce-api/src/main/java/com/loopers/catalog/product/application/service/ProductCommandService.java b/apps/commerce-api/src/main/java/com/loopers/catalog/product/application/service/ProductCommandService.java
index 5f95f456e..f09e675ef 100644
--- a/apps/commerce-api/src/main/java/com/loopers/catalog/product/application/service/ProductCommandService.java
+++ b/apps/commerce-api/src/main/java/com/loopers/catalog/product/application/service/ProductCommandService.java
@@ -22,6 +22,7 @@
 
 import static com.loopers.catalog.product.infrastructure.cache.ProductCacheConstants.DEFAULT_PAGE_SIZE;
 import static com.loopers.catalog.product.infrastructure.cache.ProductCacheConstants.MAX_CACHEABLE_PAGE;
+import static com.loopers.catalog.product.infrastructure.cache.ProductCacheConstants.buildIdListCacheKey;
 
 
 @Service
@@ -241,12 +242,4 @@ private void refreshSingleIdList(Long brandId, ProductSortType sortType, int pag
 		productCacheManager.refreshIdList(cacheKey, () -> productQueryPort.searchProductIds(criteria, pageCriteria));
 	}
 
-
-	// ID 리스트 캐시 키 생성: products:ids:v1:{brandId|all}:{sortType|LATEST}:{page}:{size}
-	private String buildIdListCacheKey(Long brandId, ProductSortType sortType, int page, int size) {
-		String brandPart = brandId != null ? brandId.toString() : "all";
-		String sortPart = sortType != null ? sortType.name() : "LATEST";
-		return "products:ids:v1:" + brandPart + ":" + sortPart + ":" + page + ":" + size;
-	}
-
 }
diff --git a/apps/commerce-api/src/main/java/com/loopers/catalog/product/infrastructure/cache/CacheLock.java b/apps/commerce-api/src/main/java/com/loopers/catalog/product/infrastructure/cache/CacheLock.java
new file mode 100644
index 000000000..f6bcd66dc
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/catalog/product/infrastructure/cache/CacheLock.java
@@ -0,0 +1,16 @@
+package com.loopers.catalog.product.infrastructure.cache;
+
+
+import java.util.function.Supplier;
+
+
+/**
+ * 캐시 스탬피드 방지용 key-level 락
+ * - 같은 key에 대한 동시 DB 조회를 1회로 제한
+ * - 구현체: LocalCacheLock (@Primary), RedisCacheLock (분산 환경 전환용)
+ */
+public interface CacheLock {
+
+	<T> T executeWithLock(String key, Supplier<T> loader);
+
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/catalog/product/infrastructure/cache/IdListCacheEntry.java b/apps/commerce-api/src/main/java/com/loopers/catalog/product/infrastructure/cache/IdListCacheEntry.java
new file mode 100644
index 000000000..271b80d2b
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/catalog/product/infrastructure/cache/IdListCacheEntry.java
@@ -0,0 +1,14 @@
+package com.loopers.catalog.product.infrastructure.cache;
+
+
+import java.util.List;
+
+
+/**
+ * ID 리스트 캐시 값
+ * - 2계층 캐시 아키텍처에서 목록 캐시(Layer 1)의 값
+ * - ids: 해당 페이지의 상품 ID 목록
+ * - totalElements: 전체 상품 수 (페이지네이션 응답용)
+ */
+public record IdListCacheEntry(List<Long> ids, long totalElements) {
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/catalog/product/infrastructure/cache/LocalCacheLock.java b/apps/commerce-api/src/main/java/com/loopers/catalog/product/infrastructure/cache/LocalCacheLock.java
new file mode 100644
index 000000000..756e20837
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/catalog/product/infrastructure/cache/LocalCacheLock.java
@@ -0,0 +1,46 @@
+package com.loopers.catalog.product.infrastructure.cache;
+
+
+import org.springframework.context.annotation.Primary;
+import org.springframework.stereotype.Component;
+
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.function.Supplier;
+
+
+/**
+ * JVM 로컬 key-level 캐시 락
+ * - ConcurrentHashMap + synchronized로 같은 key 요청만 직렬화
+ * - 다른 key 요청은 병렬 처리 (key 단위 세밀한 락)
+ * - 단일 서버 환경에서 사용. 분산 환경 전환 시 RedisCacheLock으로 @Primary 이동
+ */
+@Primary
+@Component
+public class LocalCacheLock implements CacheLock {
+
+	private final ConcurrentHashMap<String, Object> locks = new ConcurrentHashMap<>();
+
+
+	/**
+	 * key-level 락 실행
+	 * 1. executeWithLock — 같은 key 요청은 직렬화, 다른 key는 병렬
+	 */
+
+	// 1. executeWithLock
+	@Override
+	public <T> T executeWithLock(String key, Supplier<T> loader) {
+
+		// key별 락 객체 생성 (이미 존재하면 기존 객체 반환)
+		Object lock = locks.computeIfAbsent(key, k -> new Object());
+
+		// 같은 key에 대해 직렬화 실행
+		synchronized (lock) {
+			try {
+				return loader.get();
+			} finally {
+				locks.remove(key);
+			}
+		}
+	}
+
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/catalog/product/infrastructure/cache/ProductCacheConstants.java b/apps/commerce-api/src/main/java/com/loopers/catalog/product/infrastructure/cache/ProductCacheConstants.java
new file mode 100644
index 000000000..00938ca50
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/catalog/product/infrastructure/cache/ProductCacheConstants.java
@@ -0,0 +1,50 @@
+package com.loopers.catalog.product.infrastructure.cache;
+
+
+import com.loopers.catalog.product.domain.model.enums.ProductSortType;
+
+import java.time.Duration;
+
+
+/**
+ * 상품 캐시 상수
+ * - 캐시 키 접두사, 버전, 페이지 기본값, TTL 정의
+ * - 캐시 키 스키마 버전(v1)으로 배포 안전성 확보
+ * - 캐시 키 생성 유틸리티 (중복 방지)
+ */
+public final class ProductCacheConstants {
+
+	// 캐시 키 버전
+	public static final String CACHE_VERSION = "v1";
+
+	// 상세 캐시 키 접두사 — product:v1:{productId}
+	public static final String DETAIL_KEY_PREFIX = "product:" + CACHE_VERSION + ":";
+
+	// ID 리스트 캐시 키 접두사 — products:ids:v1:{brand|all}:{sort}:{page}:{size}
+	public static final String ID_LIST_KEY_PREFIX = "products:ids:" + CACHE_VERSION + ":";
+
+	// 캐시 적용 기본 페이지 크기
+	public static final int DEFAULT_PAGE_SIZE = 20;
+
+	// 캐시 적용 최대 페이지 (0-based, page 0 ~ 1)
+	public static final int MAX_CACHEABLE_PAGE = 2;
+
+	// ID 리스트 TTL (3분)
+	public static final Duration ID_LIST_TTL = Duration.ofMinutes(3);
+
+	// 상세 캐시 TTL (2분)
+	public static final Duration DETAIL_TTL = Duration.ofMinutes(2);
+
+
+	// ID 리스트 캐시 키 생성: products:ids:v1:{brandId|all}:{sortType|LATEST}:{page}:{size}
+	public static String buildIdListCacheKey(Long brandId, ProductSortType sortType, int page, int size) {
+		String brandPart = brandId != null ? brandId.toString() : "all";
+		String sortPart = sortType != null ? sortType.name() : "LATEST";
+		return ID_LIST_KEY_PREFIX + brandPart + ":" + sortPart + ":" + page + ":" + size;
+	}
+
+
+	private ProductCacheConstants() {
+	}
+
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/catalog/product/infrastructure/cache/ProductCacheDto.java b/apps/commerce-api/src/main/java/com/loopers/catalog/product/infrastructure/cache/ProductCacheDto.java
new file mode 100644
index 000000000..841a25f6a
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/catalog/product/infrastructure/cache/ProductCacheDto.java
@@ -0,0 +1,40 @@
+package com.loopers.catalog.product.infrastructure.cache;
+
+
+import com.loopers.catalog.product.application.dto.out.ProductDetailOutDto;
+import com.loopers.catalog.product.application.dto.out.ProductOutDto;
+
+import java.math.BigDecimal;
+
+
+/**
+ * 상품 캐시 DTO (PLP + PDP 공용)
+ * - 상세 캐시 값으로 저장되며, PLP/PDP 응답에 필요한 모든 필드 포함
+ * - Read Model에서 직접 projection하여 생성
+ *
+ * - id: 상품 ID
+ * - brandId: 브랜드 ID
+ * - brandName: 브랜드명
+ * - name: 상품명
+ * - price: 가격
+ * - stock: 재고
+ * - description: 상품 설명
+ * - likeCount: 좋아요 수
+ */
+public record ProductCacheDto(
+	Long id, Long brandId, String brandName, String name,
+	BigDecimal price, Long stock, String description, Long likeCount
+) {
+
+	// 1. PLP 응답용 변환 (description 제외)
+	public ProductOutDto toProductOutDto() {
+		return new ProductOutDto(id, brandId, brandName, name, price, stock, likeCount);
+	}
+
+
+	// 2. PDP 응답용 변환 (전체 필드)
+	public ProductDetailOutDto toProductDetailOutDto() {
+		return new ProductDetailOutDto(id, brandId, brandName, name, price, stock, description, likeCount);
+	}
+
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/catalog/product/infrastructure/cache/ProductCacheManager.java b/apps/commerce-api/src/main/java/com/loopers/catalog/product/infrastructure/cache/ProductCacheManager.java
new file mode 100644
index 000000000..c11acec5e
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/catalog/product/infrastructure/cache/ProductCacheManager.java
@@ -0,0 +1,333 @@
+package com.loopers.catalog.product.infrastructure.cache;
+
+
+import com.fasterxml.jackson.core.type.TypeReference;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.loopers.config.redis.RedisConfig;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.data.redis.core.RedisTemplate;
+import org.springframework.stereotype.Component;
+
+import java.time.Duration;
+import java.util.List;
+import java.util.Optional;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ThreadLocalRandom;
+import java.util.concurrent.TimeUnit;
+import java.util.function.Supplier;
+
+import static com.loopers.catalog.product.infrastructure.cache.ProductCacheConstants.DETAIL_KEY_PREFIX;
+import static com.loopers.catalog.product.infrastructure.cache.ProductCacheConstants.DETAIL_TTL;
+import static com.loopers.catalog.product.infrastructure.cache.ProductCacheConstants.ID_LIST_TTL;
+
+
+/**
+ * 상품 캐시 관리자
+ * - Redis 기반 Cache-Aside 패턴 지원
+ * - 모든 메서드는 Redis 장애 시 예외를 격리하고 로깅만 수행
+ * - 읽기: replica-preferred, 쓰기/삭제: master
+ * - 캐시 스탬피드 보호: CacheLock + PER (Probabilistic Early Refresh)
+ *
+ * 1. get(key, Class) — 단순 타입 캐시 조회
+ * 2. get(key, TypeReference) — 제네릭 타입 캐시 조회
+ * 3. put(key, value, ttl) — 캐시 저장 (TTL jitter 포함)
+ * 4. evict(key) — 단일 키 삭제
+ * 5. getOrLoad(key, type, ttl, loader) — Cache-Aside + 스탬피드 보호
+ * 6. getOrLoadWithPer(key, type, ttl, loader) — getOrLoad + PER (TTL 임박 시 확률적 갱신)
+ * 7. refreshProductDetail(productId, loader) — 상품 상세 캐시 write-through
+ * 8. refreshIdList(cacheKey, loader) — ID 리스트 캐시 write-through (단건)
+ * 9. deleteProductDetail(productId) — 상품 상세 캐시 삭제
+ * 10. mgetProductDetails(productIds) — 여러 상품 상세 일괄 조회 (MGET)
+ */
+@Slf4j
+@Component
+public class ProductCacheManager {
+
+	// redis
+	private final RedisTemplate<String, String> readTemplate;
+	private final RedisTemplate<String, String> writeTemplate;
+	// util
+	private final ObjectMapper objectMapper;
+	// cache
+	private final CacheLock cacheLock;
+	// PER 비동기 갱신 전용 스레드 풀 (ForkJoinPool 고갈 방지)
+	private final ExecutorService perExecutor = Executors.newFixedThreadPool(3);
+
+
+	public ProductCacheManager(
+		RedisTemplate<String, String> readTemplate,
+		@Qualifier(RedisConfig.REDIS_TEMPLATE_MASTER) RedisTemplate<String, String> writeTemplate,
+		ObjectMapper objectMapper,
+		CacheLock cacheLock
+	) {
+		this.readTemplate = readTemplate;
+		this.writeTemplate = writeTemplate;
+		this.objectMapper = objectMapper;
+		this.cacheLock = cacheLock;
+	}
+
+
+	// 1. 단순 타입 캐시 조회
+	public <T> Optional<T> get(String key, Class<T> type) {
+
+		try {
+			// replica에서 JSON 문자열 조회
+			String json = readTemplate.opsForValue().get(key);
+			if (json == null) {
+				return Optional.empty();
+			}
+
+			// JSON → 객체 역직렬화
+			return Optional.of(objectMapper.readValue(json, type));
+		} catch (Exception e) {
+			log.warn("캐시 조회 실패. key={}", key, e);
+			return Optional.empty();
+		}
+	}
+
+
+	// 2. 제네릭 타입 캐시 조회
+	public <T> Optional<T> get(String key, TypeReference<T> typeRef) {
+
+		try {
+			// replica에서 JSON 문자열 조회
+			String json = readTemplate.opsForValue().get(key);
+			if (json == null) {
+				return Optional.empty();
+			}
+
+			// JSON → 제네릭 타입 역직렬화
+			return Optional.of(objectMapper.readValue(json, typeRef));
+		} catch (Exception e) {
+			log.warn("캐시 조회 실패. key={}", key, e);
+			return Optional.empty();
+		}
+	}
+
+
+	// 3. 캐시 저장 (TTL jitter 포함)
+	public void put(String key, Object value, Duration ttl) {
+
+		try {
+			// 객체 → JSON 직렬화
+			String json = objectMapper.writeValueAsString(value);
+
+			// jitter 적용된 TTL로 master에 저장
+			Duration jitteredTtl = applyJitter(ttl);
+			writeTemplate.opsForValue().set(key, json, jitteredTtl);
+		} catch (Exception e) {
+			log.warn("캐시 저장 실패. key={}", key, e);
+		}
+	}
+
+
+	// 4. 단일 키 삭제
+	public void evict(String key) {
+
+		try {
+			writeTemplate.delete(key);
+		} catch (Exception e) {
+			log.warn("캐시 삭제 실패. key={}", key, e);
+		}
+	}
+
+
+	// 5. Cache-Aside + 스탬피드 보호 (CacheLock + double-check)
+	public <T> T getOrLoad(String key, Class<T> type, Duration ttl, Supplier<T> loader) {
+
+		// 캐시 조회
+		Optional<T> cached = get(key, type);
+		if (cached.isPresent()) {
+			return cached.get();
+		}
+
+		// 캐시 미스 → 락 획득 후 DB 조회 (1회만)
+		return cacheLock.executeWithLock(key, () -> {
+
+			// double-check (대기 중 다른 스레드가 캐시 저장했을 수 있음)
+			Optional<T> doubleCheck = get(key, type);
+			if (doubleCheck.isPresent()) {
+				return doubleCheck.get();
+			}
+
+			// DB 조회 + 캐시 저장 (null이면 캐시에 저장하지 않음)
+			T value = loader.get();
+			if (value != null) {
+				put(key, value, ttl);
+			}
+			return value;
+		});
+	}
+
+
+	// 6. Cache-Aside + PER (Probabilistic Early Refresh) + 스탬피드 보호
+	public <T> T getOrLoadWithPer(String key, Class<T> type, Duration ttl, Supplier<T> loader) {
+
+		// 캐시 조회
+		Optional<T> cached = get(key, type);
+		if (cached.isPresent()) {
+
+			// PER: TTL 잔여 시간 확인 → 임박 시 확률적 비동기 갱신
+			if (shouldEarlyRefresh(key, ttl)) {
+				CompletableFuture.runAsync(() -> {
+					try {
+						T fresh = loader.get();
+						put(key, fresh, ttl);
+					} catch (Exception e) {
+						log.warn("PER 비동기 갱신 실패. key={}", key, e);
+					}
+				}, perExecutor);
+			}
+
+			return cached.get();
+		}
+
+		// 캐시 미스 → 락 + double-check
+		return cacheLock.executeWithLock(key, () -> {
+
+			// double-check (대기 중 다른 스레드가 캐시 저장했을 수 있음)
+			Optional<T> doubleCheck = get(key, type);
+			if (doubleCheck.isPresent()) {
+				return doubleCheck.get();
+			}
+
+			// DB 조회 + 캐시 저장 (null이면 캐시에 저장하지 않음)
+			T value = loader.get();
+			if (value != null) {
+				put(key, value, ttl);
+			}
+			return value;
+		});
+	}
+
+
+	// 7. 상품 상세 캐시 write-through (Supplier 기반)
+	public void refreshProductDetail(Long productId, Supplier<ProductCacheDto> loader) {
+
+		try {
+			// Read Model에서 ProductCacheDto 로드
+			ProductCacheDto dto = loader.get();
+			if (dto == null) {
+				return;
+			}
+
+			// 상세 캐시에 저장
+			put(DETAIL_KEY_PREFIX + productId, dto, DETAIL_TTL);
+		} catch (Exception e) {
+			log.warn("상품 상세 캐시 write-through 실패. productId={}", productId, e);
+		}
+	}
+
+
+	// 8. ID 리스트 캐시 write-through (단건, Supplier 기반)
+	public void refreshIdList(String cacheKey, Supplier<IdListCacheEntry> loader) {
+
+		try {
+			// DB에서 해당 조건의 ID 리스트 재조회
+			IdListCacheEntry entry = loader.get();
+			if (entry == null) {
+				return;
+			}
+
+			// ID 리스트 캐시에 저장
+			put(cacheKey, entry, ID_LIST_TTL);
+		} catch (Exception e) {
+			log.warn("ID 리스트 캐시 write-through 실패. key={}", cacheKey, e);
+		}
+	}
+
+
+	// 9. 상품 상세 캐시 삭제 (상품 삭제 시 예외적 사용)
+	public void deleteProductDetail(Long productId) {
+		evict(DETAIL_KEY_PREFIX + productId);
+	}
+
+
+	// 10. 여러 상품 상세 일괄 조회 (MGET)
+	public List<ProductCacheDto> mgetProductDetails(List<Long> productIds) {
+
+		try {
+			// 상세 캐시 키 목록 생성
+			List<String> keys = productIds.stream()
+				.map(id -> DETAIL_KEY_PREFIX + id)
+				.toList();
+
+			// MGET으로 일괄 조회 (null 포함 리스트 반환)
+			List<String> jsonValues = readTemplate.opsForValue().multiGet(keys);
+			if (jsonValues == null) {
+				return productIds.stream().map(id -> (ProductCacheDto) null).toList();
+			}
+
+			// JSON → ProductCacheDto 역직렬화 (실패 시 null)
+			return jsonValues.stream()
+				.map(json -> {
+					if (json == null) {
+						return null;
+					}
+					try {
+						return objectMapper.readValue(json, ProductCacheDto.class);
+					} catch (Exception e) {
+						log.warn("MGET 역직렬화 실패", e);
+						return null;
+					}
+				})
+				.toList();
+		} catch (Exception e) {
+			log.warn("MGET 캐시 조회 실패. productIds={}", productIds, e);
+			// 전체 실패 시 null 리스트 반환 (partial miss 처리로 fallback)
+			return productIds.stream().map(id -> (ProductCacheDto) null).toList();
+		}
+	}
+
+
+	/**
+	 * private method
+	 * - PER 판정: TTL의 마지막 20% 구간에서 확률적 갱신
+	 * - TTL jitter 적용: base TTL에 0~10% 랜덤 추가
+	 */
+
+	// PER 판정: TTL의 마지막 20% 구간에서 확률적 갱신
+	private boolean shouldEarlyRefresh(String key, Duration baseTtl) {
+
+		try {
+			// 남은 TTL 조회 (밀리초)
+			Long remainMs = readTemplate.getExpire(key, TimeUnit.MILLISECONDS);
+			if (remainMs == null || remainMs <= 0) {
+				return false;
+			}
+
+			// threshold = base TTL의 20%
+			long thresholdMs = baseTtl.toMillis() / 5;
+			if (remainMs > thresholdMs) {
+				return false;
+			}
+
+			// 남은 시간이 적을수록 갱신 확률 증가 (선형)
+			double probability = 1.0 - ((double) remainMs / thresholdMs);
+			return ThreadLocalRandom.current().nextDouble() < probability;
+		} catch (Exception e) {
+			return false;
+		}
+	}
+
+
+	// TTL jitter 적용: base TTL + random(0, base TTL * 0.1)
+	Duration applyJitter(Duration baseTtl) {
+
+		long baseMs = baseTtl.toMillis();
+		long jitterBound = baseMs / 10;
+
+		// jitter 범위가 0 이하이면 원래 TTL 반환
+		if (jitterBound <= 0) {
+			return baseTtl;
+		}
+
+		long jitterMs = ThreadLocalRandom.current().nextLong(jitterBound + 1);
+		return Duration.ofMillis(baseMs + jitterMs);
+	}
+
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/catalog/product/infrastructure/cache/RedisCacheLock.java b/apps/commerce-api/src/main/java/com/loopers/catalog/product/infrastructure/cache/RedisCacheLock.java
new file mode 100644
index 000000000..381adae0f
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/catalog/product/infrastructure/cache/RedisCacheLock.java
@@ -0,0 +1,83 @@
+package com.loopers.catalog.product.infrastructure.cache;
+
+
+import com.loopers.config.redis.RedisConfig;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.data.redis.core.RedisTemplate;
+import org.springframework.stereotype.Component;
+
+import java.time.Duration;
+import java.util.function.Supplier;
+
+
+/**
+ * Redis SETNX 기반 분산 캐시 락
+ * - 분산 환경(multi-JVM)에서 사용
+ * - 현재는 대기 상태. 분산 환경 전환 시 @Primary 이동
+ */
+@Component
+public class RedisCacheLock implements CacheLock {
+
+	// redis
+	private final RedisTemplate<String, String> redisTemplate;
+
+	private static final Duration LOCK_TTL = Duration.ofSeconds(5);
+	private static final long WAIT_MILLIS = 50;
+	private static final int MAX_WAIT_RETRIES = 20;
+
+
+	public RedisCacheLock(
+		@Qualifier(RedisConfig.REDIS_TEMPLATE_MASTER) RedisTemplate<String, String> redisTemplate
+	) {
+		this.redisTemplate = redisTemplate;
+	}
+
+
+	/**
+	 * Redis SETNX 기반 분산 락 실행
+	 * 1. executeWithLock — SETNX로 락 획득 후 loader 실행, 실패 시 대기 후 재시도
+	 */
+
+	// 1. executeWithLock
+	@Override
+	public <T> T executeWithLock(String key, Supplier<T> loader) {
+
+		// 락 키 생성
+		String lockKey = key + ":lock";
+
+		// SETNX로 락 획득 시도 (TTL 5초)
+		Boolean acquired = redisTemplate.opsForValue()
+			.setIfAbsent(lockKey, "1", LOCK_TTL);
+
+		try {
+			if (Boolean.TRUE.equals(acquired)) {
+				// 락 획득 성공 → loader 실행
+				return loader.get();
+			} else {
+				// 락 미획득 → 락 해제 대기 후 loader 재실행 (double-check 포함)
+				waitForLockRelease(lockKey);
+				return loader.get();
+			}
+		} catch (InterruptedException e) {
+			Thread.currentThread().interrupt();
+			return loader.get();
+		} finally {
+			// 락 획득 성공한 경우에만 해제
+			if (Boolean.TRUE.equals(acquired)) {
+				redisTemplate.delete(lockKey);
+			}
+		}
+	}
+
+
+	// 락 해제 대기 (락 보유 스레드의 캐시 저장 완료를 기다림)
+	private void waitForLockRelease(String lockKey) throws InterruptedException {
+		for (int i = 0; i < MAX_WAIT_RETRIES; i++) {
+			Thread.sleep(WAIT_MILLIS);
+			if (!Boolean.TRUE.equals(redisTemplate.hasKey(lockKey))) {
+				return;
+			}
+		}
+	}
+
+}
diff --git a/apps/commerce-api/src/test/java/com/loopers/catalog/product/infrastructure/cache/CacheStampedeTest.java b/apps/commerce-api/src/test/java/com/loopers/catalog/product/infrastructure/cache/CacheStampedeTest.java
new file mode 100644
index 000000000..76d82a796
--- /dev/null
+++ b/apps/commerce-api/src/test/java/com/loopers/catalog/product/infrastructure/cache/CacheStampedeTest.java
@@ -0,0 +1,162 @@
+package com.loopers.catalog.product.infrastructure.cache;
+
+
+import com.loopers.catalog.product.application.dto.out.ProductDetailOutDto;
+import com.loopers.testcontainers.MySqlTestContainersConfig;
+import com.loopers.testcontainers.RedisTestContainersConfig;
+import com.loopers.utils.RedisCleanUp;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.context.annotation.Import;
+import org.springframework.test.context.ActiveProfiles;
+
+import java.math.BigDecimal;
+import java.time.Duration;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+
+@SpringBootTest
+@ActiveProfiles("test")
+@Import({MySqlTestContainersConfig.class, RedisTestContainersConfig.class})
+@DisplayName("CacheStampede 통합 테스트")
+class CacheStampedeTest {
+
+	@Autowired
+	private ProductCacheManager productCacheManager;
+
+	@Autowired
+	private RedisCleanUp redisCleanUp;
+
+
+	@AfterEach
+	void tearDown() {
+		redisCleanUp.truncateAll();
+	}
+
+
+	@Nested
+	@DisplayName("getOrLoad() 스탬피드")
+	class GetOrLoadStampedeTest {
+
+		@Test
+		@DisplayName("[getOrLoad()] single-key 스탬피드 - 캐시 미스 상태에서 100개 동시 요청 -> loader 호출 최소화 (이상: 1회)")
+		void singleKeyStampede_loaderMinimized() throws InterruptedException {
+
+			// Arrange
+			int threadCount = 100;
+			ExecutorService executor = Executors.newFixedThreadPool(threadCount);
+			CountDownLatch readyLatch = new CountDownLatch(threadCount);
+			CountDownLatch startLatch = new CountDownLatch(1);
+			CountDownLatch doneLatch = new CountDownLatch(threadCount);
+			AtomicInteger loaderCallCount = new AtomicInteger(0);
+			String key = "product:stampede:1";
+			Duration ttl = Duration.ofMinutes(10);
+			ProductDetailOutDto expected = new ProductDetailOutDto(
+				1L, 1L, "Brand", "Product",
+				new BigDecimal("10000"), 10L, "desc", 0L
+			);
+
+			// Act
+			for (int i = 0; i < threadCount; i++) {
+				executor.submit(() -> {
+					readyLatch.countDown();
+					try {
+						startLatch.await();
+						productCacheManager.getOrLoad(
+							key, ProductDetailOutDto.class, ttl,
+							() -> {
+								loaderCallCount.incrementAndGet();
+
+								// DB 조회 시뮬레이션
+								try {
+									Thread.sleep(50);
+								} catch (InterruptedException e) {
+									Thread.currentThread().interrupt();
+								}
+
+								return expected;
+							}
+						);
+					} catch (InterruptedException e) {
+						Thread.currentThread().interrupt();
+					} finally {
+						doneLatch.countDown();
+					}
+				});
+			}
+
+			readyLatch.await();
+			startLatch.countDown();
+			doneLatch.await();
+			executor.shutdown();
+
+			// Assert — loader 호출 최소화 (이상: 1회, 레이스 컨디션 허용: <= 2)
+			assertThat(loaderCallCount.get()).isLessThanOrEqualTo(2);
+		}
+
+
+		@Test
+		@DisplayName("[getOrLoad()] 캐시 히트 상태에서 100개 동시 요청 -> loader 0회 호출")
+		void cacheHitStampede_loaderNotCalled() throws InterruptedException {
+
+			// Arrange
+			String key = "product:stampede:2";
+			Duration ttl = Duration.ofMinutes(10);
+			ProductDetailOutDto cached = new ProductDetailOutDto(
+				2L, 1L, "Brand", "CachedProduct",
+				new BigDecimal("20000"), 20L, "cached", 5L
+			);
+			productCacheManager.put(key, cached, ttl);
+
+			int threadCount = 100;
+			ExecutorService executor = Executors.newFixedThreadPool(threadCount);
+			CountDownLatch readyLatch = new CountDownLatch(threadCount);
+			CountDownLatch startLatch = new CountDownLatch(1);
+			CountDownLatch doneLatch = new CountDownLatch(threadCount);
+			AtomicInteger loaderCallCount = new AtomicInteger(0);
+
+			// Act
+			for (int i = 0; i < threadCount; i++) {
+				executor.submit(() -> {
+					readyLatch.countDown();
+					try {
+						startLatch.await();
+						productCacheManager.getOrLoad(
+							key, ProductDetailOutDto.class, ttl,
+							() -> {
+								loaderCallCount.incrementAndGet();
+								return new ProductDetailOutDto(
+									99L, 99L, "New", "New",
+									new BigDecimal("99999"), 99L, "new", 99L
+								);
+							}
+						);
+					} catch (InterruptedException e) {
+						Thread.currentThread().interrupt();
+					} finally {
+						doneLatch.countDown();
+					}
+				});
+			}
+
+			readyLatch.await();
+			startLatch.countDown();
+			doneLatch.await();
+			executor.shutdown();
+
+			// Assert — 캐시 히트이므로 loader 0회 호출
+			assertThat(loaderCallCount.get()).isEqualTo(0);
+		}
+
+	}
+
+}
diff --git a/apps/commerce-api/src/test/java/com/loopers/catalog/product/infrastructure/cache/LocalCacheLockTest.java b/apps/commerce-api/src/test/java/com/loopers/catalog/product/infrastructure/cache/LocalCacheLockTest.java
new file mode 100644
index 000000000..6d9665970
--- /dev/null
+++ b/apps/commerce-api/src/test/java/com/loopers/catalog/product/infrastructure/cache/LocalCacheLockTest.java
@@ -0,0 +1,161 @@
+package com.loopers.catalog.product.infrastructure.cache;
+
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+
+@DisplayName("LocalCacheLock 단위 테스트")
+class LocalCacheLockTest {
+
+	private LocalCacheLock localCacheLock;
+
+
+	@BeforeEach
+	void setUp() {
+		localCacheLock = new LocalCacheLock();
+	}
+
+
+	@Nested
+	@DisplayName("executeWithLock()")
+	class ExecuteWithLockTest {
+
+		@Test
+		@DisplayName("[executeWithLock()] 같은 key 100개 동시 요청 -> 직렬 실행으로 loader 100회 호출. 스탬피드 보호는 CacheManager double-check에서 수행")
+		void sameKeyConcurrentRequests_loaderCalledOnce() throws InterruptedException {
+
+			// Arrange
+			int threadCount = 100;
+			ExecutorService executor = Executors.newFixedThreadPool(threadCount);
+			CountDownLatch readyLatch = new CountDownLatch(threadCount);
+			CountDownLatch startLatch = new CountDownLatch(1);
+			CountDownLatch doneLatch = new CountDownLatch(threadCount);
+			AtomicInteger loaderCallCount = new AtomicInteger(0);
+			String key = "same-key";
+
+			// Act
+			for (int i = 0; i < threadCount; i++) {
+				executor.submit(() -> {
+					readyLatch.countDown();
+					try {
+						startLatch.await();
+						localCacheLock.executeWithLock(key, () -> {
+							loaderCallCount.incrementAndGet();
+
+							// loader 실행에 시간이 걸리는 상황 시뮬레이션
+							try {
+								Thread.sleep(50);
+							} catch (InterruptedException e) {
+								Thread.currentThread().interrupt();
+							}
+
+							return "result";
+						});
+					} catch (InterruptedException e) {
+						Thread.currentThread().interrupt();
+					} finally {
+						doneLatch.countDown();
+					}
+				});
+			}
+
+			// 모든 스레드 준비 완료 후 동시 시작
+			readyLatch.await();
+			startLatch.countDown();
+			doneLatch.await();
+			executor.shutdown();
+
+			// Assert — 락에 의해 loader는 직렬 실행되므로 100회 호출 (대기 후 순차 실행)
+			// LocalCacheLock은 결과 캐싱을 하지 않으므로 각 스레드가 순서대로 loader 호출
+			// 실제 스탬피드 보호는 ProductCacheManager의 double-check 패턴에서 수행
+			assertThat(loaderCallCount.get()).isEqualTo(threadCount);
+		}
+
+
+		@Test
+		@DisplayName("[executeWithLock()] 다른 key 동시 요청 -> 각각 독립 실행. 서로 블로킹하지 않음")
+		void differentKeysConcurrentRequests_independentExecution() throws InterruptedException {
+
+			// Arrange
+			int threadCount = 10;
+			ExecutorService executor = Executors.newFixedThreadPool(threadCount);
+			CountDownLatch readyLatch = new CountDownLatch(threadCount);
+			CountDownLatch startLatch = new CountDownLatch(1);
+			CountDownLatch doneLatch = new CountDownLatch(threadCount);
+			AtomicInteger concurrentCount = new AtomicInteger(0);
+			AtomicInteger maxConcurrent = new AtomicInteger(0);
+
+			// Act
+			for (int i = 0; i < threadCount; i++) {
+				String key = "key-" + i;
+				executor.submit(() -> {
+					readyLatch.countDown();
+					try {
+						startLatch.await();
+						localCacheLock.executeWithLock(key, () -> {
+
+							// 동시 실행 스레드 수 추적
+							int current = concurrentCount.incrementAndGet();
+							maxConcurrent.updateAndGet(max -> Math.max(max, current));
+
+							try {
+								Thread.sleep(100);
+							} catch (InterruptedException e) {
+								Thread.currentThread().interrupt();
+							}
+
+							concurrentCount.decrementAndGet();
+							return "result";
+						});
+					} catch (InterruptedException e) {
+						Thread.currentThread().interrupt();
+					} finally {
+						doneLatch.countDown();
+					}
+				});
+			}
+
+			readyLatch.await();
+			startLatch.countDown();
+			doneLatch.await();
+			executor.shutdown();
+
+			// Assert — 다른 key이므로 병렬 실행됨 (최대 동시 실행 수 > 1)
+			assertThat(maxConcurrent.get()).isGreaterThan(1);
+		}
+
+
+		@Test
+		@DisplayName("[executeWithLock()] loader 예외 발생 -> 락 정상 해제. 예외 전파")
+		void loaderThrowsException_lockReleased_exceptionPropagated() {
+
+			// Arrange
+			String key = "error-key";
+			RuntimeException expectedException = new RuntimeException("loader 실패");
+
+			// Act & Assert — 예외가 전파됨
+			assertThatThrownBy(() ->
+				localCacheLock.executeWithLock(key, () -> {
+					throw expectedException;
+				})
+			).isEqualTo(expectedException);
+
+			// 락 해제 검증: 이후 같은 key로 정상 실행 가능
+			String result = localCacheLock.executeWithLock(key, () -> "recovered");
+			assertThat(result).isEqualTo("recovered");
+		}
+
+	}
+
+}
diff --git a/apps/commerce-api/src/test/java/com/loopers/catalog/product/infrastructure/cache/ProductCacheManagerTest.java b/apps/commerce-api/src/test/java/com/loopers/catalog/product/infrastructure/cache/ProductCacheManagerTest.java
new file mode 100644
index 000000000..65eb4cbd0
--- /dev/null
+++ b/apps/commerce-api/src/test/java/com/loopers/catalog/product/infrastructure/cache/ProductCacheManagerTest.java
@@ -0,0 +1,540 @@
+package com.loopers.catalog.product.infrastructure.cache;
+
+
+import com.loopers.catalog.product.application.dto.out.ProductDetailOutDto;
+import com.loopers.catalog.product.application.dto.out.ProductOutDto;
+import com.loopers.catalog.product.application.dto.out.ProductPageOutDto;
+import com.loopers.testcontainers.MySqlTestContainersConfig;
+import com.loopers.testcontainers.RedisTestContainersConfig;
+import com.loopers.utils.RedisCleanUp;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.context.annotation.Import;
+import org.springframework.data.redis.core.RedisTemplate;
+import org.springframework.test.context.ActiveProfiles;
+
+import java.math.BigDecimal;
+import java.time.Duration;
+import java.util.List;
+import java.util.Optional;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import static com.loopers.catalog.product.infrastructure.cache.ProductCacheConstants.DETAIL_KEY_PREFIX;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertAll;
+
+
+@SpringBootTest
+@ActiveProfiles("test")
+@Import({MySqlTestContainersConfig.class, RedisTestContainersConfig.class})
+@DisplayName("ProductCacheManager 통합 테스트")
+class ProductCacheManagerTest {
+
+	@Autowired
+	private ProductCacheManager productCacheManager;
+
+	@Autowired
+	private RedisCleanUp redisCleanUp;
+
+	@Autowired
+	private RedisTemplate<String, String> redisTemplate;
+
+
+	@AfterEach
+	void tearDown() {
+		redisCleanUp.truncateAll();
+	}
+
+
+	@Nested
+	@DisplayName("put() + get()")
+	class PutAndGetTest {
+
+		@Test
+		@DisplayName("[put() -> get()] ProductDetailOutDto 저장 후 조회 -> 동일한 객체 반환. 직렬화/역직렬화 정상 동작")
+		void putAndGetProductDetailOutDto() {
+
+			// Arrange
+			String key = "product:1";
+			ProductDetailOutDto dto = new ProductDetailOutDto(
+				1L, 1L, "TestBrand", "TestProduct",
+				new BigDecimal("59900.00"), 100L, "description", 50L
+			);
+
+			// Act
+			productCacheManager.put(key, dto, Duration.ofMinutes(10));
+			Optional<ProductDetailOutDto> result = productCacheManager.get(key, ProductDetailOutDto.class);
+
+			// Assert
+			assertAll(
+				() -> assertThat(result).isPresent(),
+				() -> assertThat(result.get().id()).isEqualTo(1L),
+				() -> assertThat(result.get().brandId()).isEqualTo(1L),
+				() -> assertThat(result.get().brandName()).isEqualTo("TestBrand"),
+				() -> assertThat(result.get().name()).isEqualTo("TestProduct"),
+				() -> assertThat(result.get().price()).isEqualByComparingTo(new BigDecimal("59900.00")),
+				() -> assertThat(result.get().stock()).isEqualTo(100L),
+				() -> assertThat(result.get().description()).isEqualTo("description"),
+				() -> assertThat(result.get().likeCount()).isEqualTo(50L)
+			);
+		}
+
+
+		@Test
+		@DisplayName("[put() -> get()] ProductPageOutDto 저장 후 조회 -> 제네릭 타입 역직렬화 정상 동작")
+		void putAndGetProductPageOutDto() {
+
+			// Arrange
+			String key = "products:ids:v1:all:LATEST:0:20";
+			ProductOutDto productOutDto = new ProductOutDto(
+				1L, 1L, "TestBrand", "TestProduct",
+				new BigDecimal("10000"), 50L, 10L
+			);
+			ProductPageOutDto dto = new ProductPageOutDto(
+				List.of(productOutDto), 0, 20, 100L
+			);
+
+			// Act
+			productCacheManager.put(key, dto, Duration.ofMinutes(5));
+			Optional<ProductPageOutDto> result = productCacheManager.get(key, ProductPageOutDto.class);
+
+			// Assert
+			assertAll(
+				() -> assertThat(result).isPresent(),
+				() -> assertThat(result.get().content()).hasSize(1),
+				() -> assertThat(result.get().content().get(0).id()).isEqualTo(1L),
+				() -> assertThat(result.get().content().get(0).brandName()).isEqualTo("TestBrand"),
+				() -> assertThat(result.get().page()).isEqualTo(0),
+				() -> assertThat(result.get().size()).isEqualTo(20),
+				() -> assertThat(result.get().totalElements()).isEqualTo(100L)
+			);
+		}
+
+
+		@Test
+		@DisplayName("[put() -> get()] BigDecimal price 저장 후 조회 -> compareTo 기준 동일 값 반환")
+		void putAndGetBigDecimalPrecision() {
+
+			// Arrange
+			String key = "product:2";
+			ProductDetailOutDto dto = new ProductDetailOutDto(
+				2L, 1L, "Brand", "Product",
+				new BigDecimal("99999.99"), 10L, "desc", 0L
+			);
+
+			// Act
+			productCacheManager.put(key, dto, Duration.ofMinutes(10));
+			Optional<ProductDetailOutDto> result = productCacheManager.get(key, ProductDetailOutDto.class);
+
+			// Assert
+			assertThat(result).isPresent();
+			assertThat(result.get().price()).isEqualByComparingTo(new BigDecimal("99999.99"));
+		}
+
+
+		@Test
+		@DisplayName("[put() -> get()] null description 필드 포함 DTO -> 직렬화/역직렬화 정상 동작")
+		void putAndGetWithNullDescription() {
+
+			// Arrange
+			String key = "product:3";
+			ProductDetailOutDto dto = new ProductDetailOutDto(
+				3L, 1L, "Brand", "Product",
+				new BigDecimal("10000"), 10L, null, 0L
+			);
+
+			// Act
+			productCacheManager.put(key, dto, Duration.ofMinutes(10));
+			Optional<ProductDetailOutDto> result = productCacheManager.get(key, ProductDetailOutDto.class);
+
+			// Assert
+			assertAll(
+				() -> assertThat(result).isPresent(),
+				() -> assertThat(result.get().id()).isEqualTo(3L),
+				() -> assertThat(result.get().description()).isNull()
+			);
+		}
+
+	}
+
+
+	@Nested
+	@DisplayName("evict()")
+	class EvictTest {
+
+		@Test
+		@DisplayName("[evict()] 저장 후 삭제 -> get() 시 Optional.empty() 반환")
+		void evictRemovesCachedValue() {
+
+			// Arrange
+			String key = "product:10";
+			ProductDetailOutDto dto = new ProductDetailOutDto(
+				10L, 1L, "Brand", "Product",
+				new BigDecimal("10000"), 10L, "desc", 0L
+			);
+			productCacheManager.put(key, dto, Duration.ofMinutes(10));
+
+			// Act
+			productCacheManager.evict(key);
+
+			// Assert
+			Optional<ProductDetailOutDto> result = productCacheManager.get(key, ProductDetailOutDto.class);
+			assertThat(result).isEmpty();
+		}
+
+	}
+
+
+	@Nested
+	@DisplayName("TTL")
+	class TtlTest {
+
+		@Test
+		@DisplayName("[put()] TTL 저장 -> base TTL ± 10% 범위 내 TTL 설정 확인")
+		void putSetsTtlWithJitter() {
+
+			// Arrange
+			String key = "product:ttl";
+			Duration baseTtl = Duration.ofMinutes(10);
+			long baseMs = baseTtl.toMillis();
+			long minMs = baseMs;
+			long maxMs = baseMs + (baseMs / 10);
+
+			// Act
+			productCacheManager.put(key, "value", baseTtl);
+
+			// Assert
+			Long remainMs = redisTemplate.getExpire(key, TimeUnit.MILLISECONDS);
+			assertThat(remainMs).isNotNull();
+			assertThat(remainMs).isBetween(minMs - 1000, maxMs + 1000);
+		}
+
+	}
+
+
+	@Nested
+	@DisplayName("get() — 미스")
+	class GetMissTest {
+
+		@Test
+		@DisplayName("[get()] 존재하지 않는 키 조회 -> Optional.empty() 반환. 예외 없음")
+		void getNonExistentKeyReturnsEmpty() {
+
+			// Act
+			Optional<ProductDetailOutDto> result = productCacheManager.get(
+				"nonexistent:key", ProductDetailOutDto.class
+			);
+
+			// Assert
+			assertThat(result).isEmpty();
+		}
+
+	}
+
+
+	@Nested
+	@DisplayName("getOrLoad()")
+	class GetOrLoadTest {
+
+		@Test
+		@DisplayName("[getOrLoad()] 캐시 미스 -> loader 1회 호출 + 캐시 저장")
+		void getOrLoadCacheMiss_loaderCalledOnce() {
+
+			// Arrange
+			String key = "product:load:1";
+			AtomicInteger loaderCallCount = new AtomicInteger(0);
+			ProductDetailOutDto expected = new ProductDetailOutDto(
+				1L, 1L, "Brand", "Product",
+				new BigDecimal("10000"), 10L, "desc", 0L
+			);
+
+			// Act
+			ProductDetailOutDto result = productCacheManager.getOrLoad(
+				key, ProductDetailOutDto.class, Duration.ofMinutes(10),
+				() -> {
+					loaderCallCount.incrementAndGet();
+					return expected;
+				}
+			);
+
+			// Assert — loader 1회 호출 + 캐시에 저장됨
+			assertAll(
+				() -> assertThat(loaderCallCount.get()).isEqualTo(1),
+				() -> assertThat(result.id()).isEqualTo(1L),
+				() -> assertThat(productCacheManager.get(key, ProductDetailOutDto.class)).isPresent()
+			);
+		}
+
+
+		@Test
+		@DisplayName("[getOrLoad()] 캐시 히트 -> loader 미호출. 캐시된 값 반환")
+		void getOrLoadCacheHit_loaderNotCalled() {
+
+			// Arrange
+			String key = "product:load:2";
+			ProductDetailOutDto cached = new ProductDetailOutDto(
+				2L, 1L, "Brand", "CachedProduct",
+				new BigDecimal("20000"), 20L, "cached", 5L
+			);
+			productCacheManager.put(key, cached, Duration.ofMinutes(10));
+			AtomicInteger loaderCallCount = new AtomicInteger(0);
+
+			// Act
+			ProductDetailOutDto result = productCacheManager.getOrLoad(
+				key, ProductDetailOutDto.class, Duration.ofMinutes(10),
+				() -> {
+					loaderCallCount.incrementAndGet();
+					return new ProductDetailOutDto(
+						99L, 99L, "New", "New",
+						new BigDecimal("99999"), 99L, "new", 99L
+					);
+				}
+			);
+
+			// Assert — loader 미호출, 캐시된 값 반환
+			assertAll(
+				() -> assertThat(loaderCallCount.get()).isEqualTo(0),
+				() -> assertThat(result.id()).isEqualTo(2L),
+				() -> assertThat(result.name()).isEqualTo("CachedProduct")
+			);
+		}
+
+	}
+
+
+	@Nested
+	@DisplayName("refreshProductDetail()")
+	class RefreshProductDetailTest {
+
+		@Test
+		@DisplayName("[refreshProductDetail()] Supplier가 ProductCacheDto 반환 -> product:v1:{id} 키에 캐시 저장")
+		void refreshProductDetailSuccess() {
+
+			// Arrange
+			ProductCacheDto dto = new ProductCacheDto(
+				1L, 1L, "TestBrand", "TestProduct",
+				new BigDecimal("10000"), 100L, "desc", 5L
+			);
+
+			// Act
+			productCacheManager.refreshProductDetail(1L, () -> dto);
+
+			// Assert — 상세 캐시 키로 저장 확인
+			Optional<ProductCacheDto> result = productCacheManager.get(DETAIL_KEY_PREFIX + 1, ProductCacheDto.class);
+			assertAll(
+				() -> assertThat(result).isPresent(),
+				() -> assertThat(result.get().id()).isEqualTo(1L),
+				() -> assertThat(result.get().brandName()).isEqualTo("TestBrand"),
+				() -> assertThat(result.get().name()).isEqualTo("TestProduct"),
+				() -> assertThat(result.get().likeCount()).isEqualTo(5L)
+			);
+		}
+
+
+		@Test
+		@DisplayName("[refreshProductDetail()] Supplier가 null 반환 -> 캐시 저장하지 않음")
+		void refreshProductDetailNullSkipped() {
+
+			// Act
+			productCacheManager.refreshProductDetail(999L, () -> null);
+
+			// Assert — 캐시에 저장되지 않음
+			Optional<ProductCacheDto> result = productCacheManager.get(DETAIL_KEY_PREFIX + 999, ProductCacheDto.class);
+			assertThat(result).isEmpty();
+		}
+
+	}
+
+
+	@Nested
+	@DisplayName("refreshIdList()")
+	class RefreshIdListTest {
+
+		@Test
+		@DisplayName("[refreshIdList()] Supplier가 IdListCacheEntry 반환 -> 지정된 키에 캐시 저장")
+		void refreshIdListSuccess() {
+
+			// Arrange
+			String cacheKey = "products:ids:v1:all:LATEST:0:20";
+			IdListCacheEntry entry = new IdListCacheEntry(List.of(1L, 2L, 3L), 3);
+
+			// Act
+			productCacheManager.refreshIdList(cacheKey, () -> entry);
+
+			// Assert
+			Optional<IdListCacheEntry> result = productCacheManager.get(cacheKey, IdListCacheEntry.class);
+			assertAll(
+				() -> assertThat(result).isPresent(),
+				() -> assertThat(result.get().ids()).containsExactly(1L, 2L, 3L),
+				() -> assertThat(result.get().totalElements()).isEqualTo(3)
+			);
+		}
+
+
+		@Test
+		@DisplayName("[refreshIdList()] Supplier가 null 반환 -> 캐시 저장하지 않음")
+		void refreshIdListNullSkipped() {
+
+			// Arrange
+			String cacheKey = "products:ids:v1:all:LATEST:0:20";
+
+			// Act
+			productCacheManager.refreshIdList(cacheKey, () -> null);
+
+			// Assert
+			Optional<IdListCacheEntry> result = productCacheManager.get(cacheKey, IdListCacheEntry.class);
+			assertThat(result).isEmpty();
+		}
+
+
+		@Test
+		@DisplayName("[refreshIdList()] 기존 캐시 존재 시 -> 덮어쓰기. 최신 데이터로 갱신")
+		void refreshIdListOverwrite() {
+
+			// Arrange — 기존 캐시 저장
+			String cacheKey = "products:ids:v1:1:PRICE_ASC:0:20";
+			productCacheManager.put(cacheKey, new IdListCacheEntry(List.of(1L), 1), Duration.ofMinutes(5));
+
+			// Act — 새 데이터로 갱신
+			IdListCacheEntry updated = new IdListCacheEntry(List.of(1L, 2L), 2);
+			productCacheManager.refreshIdList(cacheKey, () -> updated);
+
+			// Assert — 최신 데이터로 갱신 확인
+			Optional<IdListCacheEntry> result = productCacheManager.get(cacheKey, IdListCacheEntry.class);
+			assertAll(
+				() -> assertThat(result).isPresent(),
+				() -> assertThat(result.get().ids()).containsExactly(1L, 2L),
+				() -> assertThat(result.get().totalElements()).isEqualTo(2)
+			);
+		}
+
+	}
+
+
+	@Nested
+	@DisplayName("deleteProductDetail()")
+	class DeleteProductDetailTest {
+
+		@Test
+		@DisplayName("[deleteProductDetail()] 상품 상세 캐시 삭제 -> product:v1:{id} 키 삭제 확인")
+		void deleteProductDetailSuccess() {
+
+			// Arrange — 상세 캐시 저장
+			ProductCacheDto dto = new ProductCacheDto(
+				1L, 1L, "Brand", "Product",
+				new BigDecimal("10000"), 100L, "desc", 0L
+			);
+			productCacheManager.put(DETAIL_KEY_PREFIX + 1, dto, Duration.ofMinutes(10));
+
+			// Act
+			productCacheManager.deleteProductDetail(1L);
+
+			// Assert — 캐시에서 삭제됨
+			Optional<ProductCacheDto> result = productCacheManager.get(DETAIL_KEY_PREFIX + 1, ProductCacheDto.class);
+			assertThat(result).isEmpty();
+		}
+
+
+		@Test
+		@DisplayName("[deleteProductDetail()] 존재하지 않는 키 삭제 -> 예외 없이 정상 처리")
+		void deleteProductDetailNonExistent() {
+
+			// Act & Assert — 예외 없음
+			productCacheManager.deleteProductDetail(999L);
+			Optional<ProductCacheDto> result = productCacheManager.get(DETAIL_KEY_PREFIX + 999, ProductCacheDto.class);
+			assertThat(result).isEmpty();
+		}
+
+	}
+
+
+	@Nested
+	@DisplayName("mgetProductDetails()")
+	class MgetProductDetailsTest {
+
+		@Test
+		@DisplayName("[mgetProductDetails()] 전체 히트 -> 모든 ID에 대한 ProductCacheDto 반환. ID 순서 보존")
+		void mgetAllHit() {
+
+			// Arrange — 3건 캐시 저장
+			for (long i = 1; i <= 3; i++) {
+				ProductCacheDto dto = new ProductCacheDto(
+					i, 1L, "Brand", "Product" + i,
+					new BigDecimal("10000"), 100L, null, 0L
+				);
+				productCacheManager.put(DETAIL_KEY_PREFIX + i, dto, Duration.ofMinutes(10));
+			}
+
+			// Act
+			List<ProductCacheDto> result = productCacheManager.mgetProductDetails(List.of(1L, 2L, 3L));
+
+			// Assert — 순서 보존, 모두 non-null
+			assertAll(
+				() -> assertThat(result).hasSize(3),
+				() -> assertThat(result.get(0).id()).isEqualTo(1L),
+				() -> assertThat(result.get(0).name()).isEqualTo("Product1"),
+				() -> assertThat(result.get(1).id()).isEqualTo(2L),
+				() -> assertThat(result.get(2).id()).isEqualTo(3L)
+			);
+		}
+
+
+		@Test
+		@DisplayName("[mgetProductDetails()] partial miss -> 히트된 항목은 반환, miss된 항목은 null. 위치 보존")
+		void mgetPartialMiss() {
+
+			// Arrange — id=1만 캐시, id=2는 미캐시
+			ProductCacheDto dto1 = new ProductCacheDto(
+				1L, 1L, "Brand", "Product1",
+				new BigDecimal("10000"), 100L, null, 0L
+			);
+			productCacheManager.put(DETAIL_KEY_PREFIX + 1, dto1, Duration.ofMinutes(10));
+
+			// Act
+			List<ProductCacheDto> result = productCacheManager.mgetProductDetails(List.of(1L, 2L));
+
+			// Assert — id=1 히트, id=2 null
+			assertAll(
+				() -> assertThat(result).hasSize(2),
+				() -> assertThat(result.get(0)).isNotNull(),
+				() -> assertThat(result.get(0).id()).isEqualTo(1L),
+				() -> assertThat(result.get(1)).isNull()
+			);
+		}
+
+
+		@Test
+		@DisplayName("[mgetProductDetails()] 전체 miss -> 모든 항목이 null인 리스트 반환")
+		void mgetAllMiss() {
+
+			// Act
+			List<ProductCacheDto> result = productCacheManager.mgetProductDetails(List.of(100L, 200L));
+
+			// Assert
+			assertAll(
+				() -> assertThat(result).hasSize(2),
+				() -> assertThat(result.get(0)).isNull(),
+				() -> assertThat(result.get(1)).isNull()
+			);
+		}
+
+
+		@Test
+		@DisplayName("[mgetProductDetails()] 빈 ID 목록 -> 빈 리스트 반환")
+		void mgetEmptyIds() {
+
+			// Act
+			List<ProductCacheDto> result = productCacheManager.mgetProductDetails(List.of());
+
+			// Assert
+			assertThat(result).isEmpty();
+		}
+
+	}
+
+}

From 0161e4db59df2a94e443817178953f5dae2b90b6 Mon Sep 17 00:00:00 2001
From: Hwan0518 <qip0518@naver.com>
Date: Fri, 13 Mar 2026 03:22:36 +0900
Subject: [PATCH 7/9] =?UTF-8?q?feat:=20Cache-Aside=20=ED=8C=A8=ED=84=B4=20?=
 =?UTF-8?q?=EC=A0=81=EC=9A=A9=20=EB=B0=8F=20=EC=BA=90=EC=8B=9C=20=EC=84=B1?=
 =?UTF-8?q?=EB=8A=A5=20=EC=B8=A1=EC=A0=95?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- ProductQueryFacade 상품 상세 캐시 적용
- ProductQueryService 상품 목록 캐시 적용
- ProductCommandFacade 캐시 write-through (수정/삭제 시 즉시 재적재)
- ProductCommandFacadeTest, ProductQueryFacadeTest, ProductQueryServiceTest 캐시 테스트 추가
- ProductControllerE2ETest 캐시 무효화 E2E 테스트 추가
- round5-docs/05-to-be-cache-measurement.md 캐시 측정 결과
- round5-docs/05-to-be-cache-visualization.html 시각화
- round5-docs/06-2layer-cache-implementation-design.md 2계층 캐시 설계
- round5-docs/07-cache-eviction-analysis.md 캐시 무효화 분석
- docs/todo/cache-event-driven-refresh.md 후속 TODO

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
---
 .../facade/ProductCommandFacade.java          |  29 +-
 .../facade/ProductQueryFacade.java            |  34 +-
 .../service/ProductQueryService.java          | 180 ++++-
 .../facade/ProductCommandFacadeTest.java      |  33 +-
 .../facade/ProductQueryFacadeTest.java        |  44 +-
 .../service/ProductQueryServiceTest.java      | 296 +++++++-
 .../interfaces/ProductControllerE2ETest.java  |  36 +
 docs/todo/cache-event-driven-refresh.md       |  85 +++
 round5-docs/05-to-be-cache-measurement.md     | 197 +++++
 round5-docs/05-to-be-cache-visualization.html | 691 ++++++++++++++++++
 .../06-2layer-cache-implementation-design.md  | 527 +++++++++++++
 round5-docs/07-cache-eviction-analysis.md     | 684 +++++++++++++++++
 12 files changed, 2742 insertions(+), 94 deletions(-)
 create mode 100644 docs/todo/cache-event-driven-refresh.md
 create mode 100644 round5-docs/05-to-be-cache-measurement.md
 create mode 100644 round5-docs/05-to-be-cache-visualization.html
 create mode 100644 round5-docs/06-2layer-cache-implementation-design.md
 create mode 100644 round5-docs/07-cache-eviction-analysis.md

diff --git a/apps/commerce-api/src/main/java/com/loopers/catalog/product/application/facade/ProductCommandFacade.java b/apps/commerce-api/src/main/java/com/loopers/catalog/product/application/facade/ProductCommandFacade.java
index d719e2730..70f36517b 100644
--- a/apps/commerce-api/src/main/java/com/loopers/catalog/product/application/facade/ProductCommandFacade.java
+++ b/apps/commerce-api/src/main/java/com/loopers/catalog/product/application/facade/ProductCommandFacade.java
@@ -9,6 +9,7 @@
 import com.loopers.catalog.product.application.service.ProductCommandService;
 import com.loopers.catalog.product.application.service.ProductQueryService;
 import com.loopers.catalog.product.domain.model.Product;
+import com.loopers.catalog.product.domain.model.enums.ProductSortType;
 import lombok.RequiredArgsConstructor;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
@@ -44,8 +45,15 @@ public AdminProductDetailOutDto createProduct(AdminProductCreateInDto inDto) {
 		// 상품 생성
 		Product savedProduct = productCommandService.createProduct(inDto);
 
-		// DTO 변환 (브랜드명 포함)
-		return AdminProductDetailOutDto.from(savedProduct, brand.getName().value());
+		// Read Model 동기화
+		productCommandService.syncReadModel(savedProduct, brand.getName().value());
+
+		// write-through: 상세 캐시 + 모든 정렬 ID 리스트
+		productCommandService.refreshProductDetailCache(savedProduct.getId());
+		productCommandService.refreshIdListCacheForAllSorts(savedProduct.getBrandId());
+
+		// Read Model 재조회 (likeCount는 Read Model이 SoT)
+		return productQueryService.getAdminProductDetail(savedProduct.getId());
 	}
 
 
@@ -62,8 +70,15 @@ public AdminProductDetailOutDto updateProduct(Long id, AdminProductUpdateInDto i
 		// 브랜드 조회 (브랜드명 포함 응답)
 		Brand brand = brandQueryService.getBrandById(updatedProduct.getBrandId());
 
-		// DTO 변환
-		return AdminProductDetailOutDto.from(updatedProduct, brand.getName().value());
+		// Read Model 동기화
+		productCommandService.syncReadModel(updatedProduct, brand.getName().value());
+
+		// write-through: 상세 캐시 + PRICE_ASC 정렬 ID 리스트 (가격 변경 영향)
+		productCommandService.refreshProductDetailCache(id);
+		productCommandService.refreshIdListCacheForSort(updatedProduct.getBrandId(), ProductSortType.PRICE_ASC);
+
+		// Read Model 재조회 (likeCount는 Read Model이 SoT)
+		return productQueryService.getAdminProductDetail(id);
 	}
 
 
@@ -77,6 +92,12 @@ public void deleteProduct(Long id) {
 		// 상품 삭제
 		productCommandService.deleteProduct(product);
 
+		// 상세 캐시: evict (삭제된 상품이므로)
+		productCommandService.deleteProductDetailCache(id);
+
+		// ID 리스트: write-through (모든 정렬 — 삭제 상품 제거)
+		productCommandService.refreshIdListCacheForAllSorts(product.getBrandId());
+
 		// 상품 좋아요 정리 (Cross-BC 부수효과)
 		productCommandService.deleteAllProductLikes(product.getId());
 
diff --git a/apps/commerce-api/src/main/java/com/loopers/catalog/product/application/facade/ProductQueryFacade.java b/apps/commerce-api/src/main/java/com/loopers/catalog/product/application/facade/ProductQueryFacade.java
index 2a8806299..96aa4b00e 100644
--- a/apps/commerce-api/src/main/java/com/loopers/catalog/product/application/facade/ProductQueryFacade.java
+++ b/apps/commerce-api/src/main/java/com/loopers/catalog/product/application/facade/ProductQueryFacade.java
@@ -1,12 +1,7 @@
 package com.loopers.catalog.product.application.facade;
 
 
-import com.loopers.catalog.brand.application.service.BrandQueryService;
-import com.loopers.catalog.brand.domain.model.Brand;
-import com.loopers.catalog.product.application.dto.out.AdminProductDetailOutDto;
-import com.loopers.catalog.product.application.dto.out.AdminProductPageOutDto;
-import com.loopers.catalog.product.application.dto.out.ProductDetailOutDto;
-import com.loopers.catalog.product.application.dto.out.ProductPageOutDto;
+import com.loopers.catalog.product.application.dto.out.*;
 import com.loopers.catalog.product.application.service.ProductQueryService;
 import com.loopers.catalog.product.domain.model.Product;
 import com.loopers.catalog.product.domain.model.enums.ProductSortType;
@@ -23,31 +18,24 @@ public class ProductQueryFacade {
 
 	// service
 	private final ProductQueryService productQueryService;
-	private final BrandQueryService brandQueryService;
 
 
 	/**
 	 * 상품 조회 파사드
 	 * 1. 사용자 상품 상세 조회 (활성 상품만, 브랜드명 포함)
 	 * 2. 사용자 상품 목록 검색 (브랜드 필터, 정렬, 페이지네이션)
-	 * 3. 관리자 상품 상세 조회 (삭제 포함, 브랜드명 포함)
+	 * 3. 관리자 상품 상세 조회 (삭제 포함, Read Model 기반 — 삭제된 브랜드에도 안전)
 	 * 4. 관리자 상품 목록 검색 (전체 상품)
 	 * 5. 활성 상품 조회 (Cross-BC 전용 — ACL에서 호출)
 	 * 6. 활성 상품 일괄 조회 (Cross-BC 전용 — ACL에서 호출)
 	 */
 
-	// 1. 사용자 상품 상세 조회
+	// 1. 사용자 상품 상세 조회 (캐시 적용 — PER + 스탬피드 보호, Read Model projection 기반)
 	@Transactional(readOnly = true)
 	public ProductDetailOutDto getProduct(Long id) {
 
-		// 활성 상품 조회
-		Product product = productQueryService.findActiveById(id);
-
-		// 브랜드 조회 (브랜드명 포함 응답)
-		Brand brand = brandQueryService.getBrandById(product.getBrandId());
-
-		// DTO 변환
-		return ProductDetailOutDto.from(product, brand.getName().value());
+		// Read Model에서 ProductCacheDto → ProductDetailOutDto 변환 (캐시 적용)
+		return productQueryService.getOrLoadProductDetail(id);
 	}
 
 
@@ -58,18 +46,10 @@ public ProductPageOutDto getProducts(Long brandId, ProductSortType sortType, int
 	}
 
 
-	// 3. 관리자 상품 상세 조회
+	// 3. 관리자 상품 상세 조회 (Read Model 기반 — 삭제된 브랜드에도 비정규화된 brandName 사용)
 	@Transactional(readOnly = true)
 	public AdminProductDetailOutDto getAdminProduct(Long id) {
-
-		// 상품 조회 (삭제 포함)
-		Product product = productQueryService.findById(id);
-
-		// 브랜드 조회 (브랜드명 포함 응답)
-		Brand brand = brandQueryService.getBrandById(product.getBrandId());
-
-		// DTO 변환
-		return AdminProductDetailOutDto.from(product, brand.getName().value());
+		return productQueryService.getAdminProductDetail(id);
 	}
 
 
diff --git a/apps/commerce-api/src/main/java/com/loopers/catalog/product/application/service/ProductQueryService.java b/apps/commerce-api/src/main/java/com/loopers/catalog/product/application/service/ProductQueryService.java
index dd2fd8e1a..8a164cd1e 100644
--- a/apps/commerce-api/src/main/java/com/loopers/catalog/product/application/service/ProductQueryService.java
+++ b/apps/commerce-api/src/main/java/com/loopers/catalog/product/application/service/ProductQueryService.java
@@ -7,15 +7,23 @@
 import com.loopers.catalog.product.domain.model.Product;
 import com.loopers.catalog.product.domain.model.enums.ProductSortType;
 import com.loopers.catalog.product.domain.repository.ProductQueryRepository;
+import com.loopers.catalog.product.domain.repository.ProductReadModelRepository;
 import com.loopers.catalog.product.domain.repository.vo.PageCriteria;
 import com.loopers.catalog.product.domain.repository.vo.PageResult;
+import com.loopers.catalog.product.infrastructure.cache.IdListCacheEntry;
+import com.loopers.catalog.product.infrastructure.cache.ProductCacheDto;
+import com.loopers.catalog.product.infrastructure.cache.ProductCacheManager;
 import com.loopers.support.common.error.CoreException;
 import com.loopers.support.common.error.ErrorType;
 import lombok.RequiredArgsConstructor;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
-import java.util.List;
+import java.util.*;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
+import static com.loopers.catalog.product.infrastructure.cache.ProductCacheConstants.*;
 
 
 @Service
@@ -24,8 +32,11 @@ public class ProductQueryService {
 
 	// repository
 	private final ProductQueryRepository productQueryRepository;
+	private final ProductReadModelRepository productReadModelRepository;
 	// port
 	private final ProductQueryPort productQueryPort;
+	// cache
+	private final ProductCacheManager productCacheManager;
 
 
 	/**
@@ -33,9 +44,12 @@ public class ProductQueryService {
 	 * 1. ID로 활성 상품 조회
 	 * 2. 브랜드의 활성 상품 존재 여부 확인
 	 * 3. ID로 상품 조회 (삭제 포함, 관리자용)
-	 * 4. 사용자 상품 목록 검색 (QueryPort, 페이지네이션)
-	 * 5. 관리자 상품 목록 검색 (QueryPort, 페이지네이션)
+	 * 4. 사용자 상품 목록 검색 (2계층 캐시: ID 리스트 → MGET 상세)
+	 * 5. 관리자 상품 목록 검색 (캐시 미적용)
 	 * 6. ID 목록으로 활성 상품 일괄 조회 (Cross-BC 전용)
+	 * 7. 상품 상세 캐시 조회 (PER + 스탬피드 보호)
+	 * 8. 브랜드 ID로 활성 상품 ID 목록 조회 (브랜드명 write-through용)
+	 * 9. 관리자 상품 상세 조회 (Read Model projection — 삭제된 브랜드에도 안전)
 	 */
 
 	// 1. ID로 활성 상품 조회
@@ -61,22 +75,48 @@ public Product findById(Long id) {
 	}
 
 
-	// 4. 사용자 상품 목록 검색 (QueryPort, 페이지네이션)
+	// 4. 사용자 상품 목록 검색 (2계층 캐시: ID 리스트 → MGET 상세)
 	@Transactional(readOnly = true)
 	public ProductPageOutDto searchProducts(Long brandId, ProductSortType sortType, int page, int size) {
 
-		// 검색 조건 생성
-		ProductSearchCriteria criteria = new ProductSearchCriteria(brandId, sortType);
-
-		// QueryPort를 통한 검색
-		PageResult<ProductOutDto> result = productQueryPort.searchProducts(criteria, new PageCriteria(page, size));
-
-		// DTO 변환
-		return ProductPageOutDto.from(result);
+		// 캐시 적용 조건 확인 (page <= MAX_CACHEABLE_PAGE && size == DEFAULT_PAGE_SIZE)
+		if (!isCacheable(page, size)) {
+			return searchFromDb(brandId, sortType, page, size);
+		}
+
+		// Layer 1: ID 리스트 캐시 조회 (cache-aside + 스탬피드 보호)
+		String idListKey = buildIdListCacheKey(brandId, sortType, page, size);
+		IdListCacheEntry idList = productCacheManager.getOrLoad(
+			idListKey, IdListCacheEntry.class, ID_LIST_TTL,
+			() -> loadIdListFromDb(brandId, sortType, page, size)
+		);
+
+		// 빈 결과인 경우 빈 페이지 반환
+		if (idList.ids().isEmpty()) {
+			return new ProductPageOutDto(List.of(), page, size, idList.totalElements());
+		}
+
+		// Layer 2: MGET 상세 캐시 조회
+		List<ProductCacheDto> cached = productCacheManager.mgetProductDetails(idList.ids());
+
+		// partial miss 처리 — miss된 ID를 DB에서 조회 후 캐시 저장
+		List<Long> missedIds = extractMissedIds(idList.ids(), cached);
+		if (!missedIds.isEmpty()) {
+			List<ProductCacheDto> fromDb = loadAndCacheDetails(missedIds);
+			cached = mergeInOrder(idList.ids(), cached, fromDb);
+		}
+
+		// dangling ID 방어 (삭제되었으나 ID 리스트에 남은 경우 null skip)
+		List<ProductOutDto> content = cached.stream()
+			.filter(Objects::nonNull)
+			.map(ProductCacheDto::toProductOutDto)
+			.toList();
+
+		return new ProductPageOutDto(content, page, size, idList.totalElements());
 	}
 
 
-	// 5. 관리자 상품 목록 검색 (QueryPort, 페이지네이션)
+	// 5. 관리자 상품 목록 검색 (캐시 미적용 — 관리자는 실시간 데이터 필요)
 	@Transactional(readOnly = true)
 	public AdminProductPageOutDto searchAdminProducts(Long brandId, ProductSortType sortType, int page, int size) {
 
@@ -97,4 +137,118 @@ public List<Product> findActiveByIds(List<Long> ids) {
 		return productQueryRepository.findActiveByIds(ids);
 	}
 
+
+	// 7. 상품 상세 캐시 조회 (PER + 스탬피드 보호, Read Model projection 기반)
+	@Transactional(readOnly = true)
+	public ProductDetailOutDto getOrLoadProductDetail(Long productId) {
+
+		// 캐시 키: product:v1:{productId}
+		String cacheKey = DETAIL_KEY_PREFIX + productId;
+
+		// PER + 스탬피드 보호로 캐시 조회/로드 (ProductCacheDto 기반)
+		ProductCacheDto cacheDto = productCacheManager.getOrLoadWithPer(
+			cacheKey, ProductCacheDto.class, DETAIL_TTL,
+			() -> productQueryPort.findProductCacheDtoById(productId)
+		);
+
+		// 상품이 존재하지 않거나 삭제된 경우 (loader가 null 반환)
+		if (cacheDto == null) {
+			throw new CoreException(ErrorType.PRODUCT_NOT_FOUND);
+		}
+
+		// ProductCacheDto → ProductDetailOutDto 변환
+		return cacheDto.toProductDetailOutDto();
+	}
+
+
+	// 8. 브랜드 ID로 활성 상품 ID 목록 조회 (브랜드명 write-through용)
+	@Transactional(readOnly = true)
+	public List<Long> findActiveIdsByBrandId(Long brandId) {
+		return productReadModelRepository.findActiveIdsByBrandId(brandId);
+	}
+
+
+	// 9. 관리자 상품 상세 조회 (Read Model projection — 삭제된 브랜드에도 비정규화된 brandName 사용)
+	@Transactional(readOnly = true)
+	public AdminProductDetailOutDto getAdminProductDetail(Long productId) {
+		AdminProductDetailOutDto result = productQueryPort.findAdminProductDetailById(productId);
+		if (result == null) {
+			throw new CoreException(ErrorType.PRODUCT_NOT_FOUND);
+		}
+		return result;
+	}
+
+
+	/**
+	 * private method
+	 * - 캐시 적용 조건 판정
+	 * - DB 직접 조회 (캐시 미적용 경로)
+	 * - ID 리스트 DB 조회 (cache-aside loader)
+	 * - MGET partial miss 처리
+	 * - 캐시 키 생성
+	 */
+
+	// 캐시 적용 조건 판정
+	private boolean isCacheable(int page, int size) {
+		return page < MAX_CACHEABLE_PAGE && size == DEFAULT_PAGE_SIZE;
+	}
+
+
+	// DB 직접 조회 (캐시 미적용 경로 — page 3 이상 또는 size != DEFAULT_PAGE_SIZE)
+	private ProductPageOutDto searchFromDb(Long brandId, ProductSortType sortType, int page, int size) {
+		ProductSearchCriteria criteria = new ProductSearchCriteria(brandId, sortType);
+		PageResult<ProductOutDto> result = productQueryPort.searchProducts(criteria, new PageCriteria(page, size));
+		return ProductPageOutDto.from(result);
+	}
+
+
+	// ID 리스트 DB 조회 (cache-aside loader)
+	private IdListCacheEntry loadIdListFromDb(Long brandId, ProductSortType sortType, int page, int size) {
+		ProductSearchCriteria criteria = new ProductSearchCriteria(brandId, sortType);
+		return productQueryPort.searchProductIds(criteria, new PageCriteria(page, size));
+	}
+
+
+	// MGET partial miss된 ID 추출
+	private List<Long> extractMissedIds(List<Long> ids, List<ProductCacheDto> cached) {
+		List<Long> missed = new ArrayList<>();
+		for (int i = 0; i < ids.size(); i++) {
+			if (i >= cached.size() || cached.get(i) == null) {
+				missed.add(ids.get(i));
+			}
+		}
+		return missed;
+	}
+
+
+	// miss된 상품을 DB에서 조회 후 개별 캐시 저장
+	private List<ProductCacheDto> loadAndCacheDetails(List<Long> missedIds) {
+		List<ProductCacheDto> dtos = productQueryPort.findProductCacheDtosByIds(missedIds);
+		for (ProductCacheDto dto : dtos) {
+			productCacheManager.put(DETAIL_KEY_PREFIX + dto.id(), dto, DETAIL_TTL);
+		}
+		return dtos;
+	}
+
+
+	// ID 순서대로 cached와 fromDb를 병합 (ID 리스트 순서 보존)
+	private List<ProductCacheDto> mergeInOrder(List<Long> ids, List<ProductCacheDto> cached, List<ProductCacheDto> fromDb) {
+
+		// fromDb를 id 기반 Map으로 변환
+		Map<Long, ProductCacheDto> dbMap = fromDb.stream()
+			.collect(Collectors.toMap(ProductCacheDto::id, Function.identity()));
+
+		// ID 순서대로 병합 — cached에 있으면 cached 사용, 없으면 dbMap에서 조회
+		List<ProductCacheDto> merged = new ArrayList<>(ids.size());
+		for (int i = 0; i < ids.size(); i++) {
+			ProductCacheDto c = (i < cached.size()) ? cached.get(i) : null;
+			if (c != null) {
+				merged.add(c);
+			} else {
+				merged.add(dbMap.get(ids.get(i)));
+			}
+		}
+		return merged;
+	}
+
 }
diff --git a/apps/commerce-api/src/test/java/com/loopers/catalog/product/application/facade/ProductCommandFacadeTest.java b/apps/commerce-api/src/test/java/com/loopers/catalog/product/application/facade/ProductCommandFacadeTest.java
index b79053ace..d9ce2ff88 100644
--- a/apps/commerce-api/src/test/java/com/loopers/catalog/product/application/facade/ProductCommandFacadeTest.java
+++ b/apps/commerce-api/src/test/java/com/loopers/catalog/product/application/facade/ProductCommandFacadeTest.java
@@ -10,6 +10,7 @@
 import com.loopers.catalog.product.application.service.ProductCommandService;
 import com.loopers.catalog.product.application.service.ProductQueryService;
 import com.loopers.catalog.product.domain.model.Product;
+import com.loopers.catalog.product.domain.model.enums.ProductSortType;
 import com.loopers.catalog.product.domain.model.vo.Money;
 import com.loopers.catalog.product.domain.model.vo.ProductName;
 import com.loopers.catalog.product.domain.model.vo.Stock;
@@ -57,7 +58,7 @@ private Product createTestProduct() {
 			ProductName.from("테스트 상품"),
 			Money.from(new BigDecimal("10000")),
 			Stock.from(100L),
-			null, 0L, null);
+			null, null);
 	}
 
 
@@ -71,7 +72,7 @@ private Brand createTestBrand() {
 	class CreateProductTest {
 
 		@Test
-		@DisplayName("[createProduct()] 유효한 요청 -> AdminProductDetailOutDto 반환. 브랜드명 포함")
+		@DisplayName("[createProduct()] 유효한 요청 -> AdminProductDetailOutDto 반환. 브랜드명 포함. Read Model 동기화 + write-through 캐시 갱신")
 		void createProductSuccess() {
 			// Arrange
 			AdminProductCreateInDto inDto = new AdminProductCreateInDto(
@@ -80,8 +81,12 @@ void createProductSuccess() {
 			Brand brand = createTestBrand();
 			Product product = createTestProduct();
 
+			AdminProductDetailOutDto detailOutDto = new AdminProductDetailOutDto(
+				1L, 1L, "나이키", "테스트 상품", new BigDecimal("10000"), 100L, null, 0L, null);
+
 			given(brandQueryService.getBrandById(1L)).willReturn(brand);
 			given(productCommandService.createProduct(inDto)).willReturn(product);
+			given(productQueryService.getAdminProductDetail(1L)).willReturn(detailOutDto);
 
 			// Act
 			AdminProductDetailOutDto result = productCommandFacade.createProduct(inDto);
@@ -92,7 +97,11 @@ void createProductSuccess() {
 				() -> assertThat(result.brandName()).isEqualTo("나이키"),
 				() -> assertThat(result.name()).isEqualTo("테스트 상품"),
 				() -> verify(brandQueryService).getBrandById(1L),
-				() -> verify(productCommandService).createProduct(inDto)
+				() -> verify(productCommandService).createProduct(inDto),
+				() -> verify(productCommandService).syncReadModel(product, "나이키"),
+				() -> verify(productCommandService).refreshProductDetailCache(1L),
+				() -> verify(productCommandService).refreshIdListCacheForAllSorts(1L),
+				() -> verify(productQueryService).getAdminProductDetail(1L)
 			);
 		}
 
@@ -104,7 +113,7 @@ void createProductSuccess() {
 	class UpdateProductTest {
 
 		@Test
-		@DisplayName("[updateProduct()] 유효한 수정 요청 -> AdminProductDetailOutDto 반환")
+		@DisplayName("[updateProduct()] 유효한 수정 요청 -> AdminProductDetailOutDto 반환. Read Model 동기화 + write-through 캐시 갱신")
 		void updateProductSuccess() {
 			// Arrange
 			AdminProductUpdateInDto inDto = new AdminProductUpdateInDto(
@@ -115,12 +124,16 @@ void updateProductSuccess() {
 				ProductName.from("수정 상품"),
 				Money.from(new BigDecimal("20000")),
 				Stock.from(200L),
-				null, 0L, null);
+				null, null);
 			Brand brand = createTestBrand();
 
+			AdminProductDetailOutDto detailOutDto = new AdminProductDetailOutDto(
+				1L, 1L, "나이키", "수정 상품", new BigDecimal("20000"), 200L, "수정 설명", 0L, null);
+
 			given(productQueryService.findActiveById(1L)).willReturn(product);
 			given(productCommandService.updateProduct(eq(product), eq(inDto))).willReturn(updatedProduct);
 			given(brandQueryService.getBrandById(1L)).willReturn(brand);
+			given(productQueryService.getAdminProductDetail(1L)).willReturn(detailOutDto);
 
 			// Act
 			AdminProductDetailOutDto result = productCommandFacade.updateProduct(1L, inDto);
@@ -129,7 +142,11 @@ void updateProductSuccess() {
 			assertAll(
 				() -> assertThat(result.name()).isEqualTo("수정 상품"),
 				() -> assertThat(result.brandName()).isEqualTo("나이키"),
-				() -> verify(productQueryService).findActiveById(1L)
+				() -> verify(productQueryService).findActiveById(1L),
+				() -> verify(productCommandService).syncReadModel(updatedProduct, "나이키"),
+				() -> verify(productCommandService).refreshProductDetailCache(1L),
+				() -> verify(productCommandService).refreshIdListCacheForSort(1L, ProductSortType.PRICE_ASC),
+				() -> verify(productQueryService).getAdminProductDetail(1L)
 			);
 		}
 
@@ -141,7 +158,7 @@ void updateProductSuccess() {
 	class DeleteProductTest {
 
 		@Test
-		@DisplayName("[deleteProduct()] 활성 상품 ID -> 삭제 및 좋아요/장바구니 정리 수행")
+		@DisplayName("[deleteProduct()] 활성 상품 ID -> 삭제 및 좋아요/장바구니 정리 수행. 상세 캐시 삭제 + ID 리스트 write-through 갱신")
 		void deleteProductSuccess() {
 			// Arrange
 			Product product = createTestProduct();
@@ -156,6 +173,8 @@ void deleteProductSuccess() {
 			assertAll(
 				() -> verify(productQueryService).findActiveById(1L),
 				() -> verify(productCommandService).deleteProduct(product),
+				() -> verify(productCommandService).deleteProductDetailCache(1L),
+				() -> verify(productCommandService).refreshIdListCacheForAllSorts(1L),
 				() -> verify(productCommandService).deleteAllProductLikes(1L),
 				() -> verify(productCommandService).deleteAllCartItems(1L)
 			);
diff --git a/apps/commerce-api/src/test/java/com/loopers/catalog/product/application/facade/ProductQueryFacadeTest.java b/apps/commerce-api/src/test/java/com/loopers/catalog/product/application/facade/ProductQueryFacadeTest.java
index 090186236..873f5ef35 100644
--- a/apps/commerce-api/src/test/java/com/loopers/catalog/product/application/facade/ProductQueryFacadeTest.java
+++ b/apps/commerce-api/src/test/java/com/loopers/catalog/product/application/facade/ProductQueryFacadeTest.java
@@ -1,9 +1,6 @@
 package com.loopers.catalog.product.application.facade;
 
 
-import com.loopers.catalog.brand.application.service.BrandQueryService;
-import com.loopers.catalog.brand.domain.model.Brand;
-import com.loopers.catalog.brand.domain.model.vo.BrandName;
 import com.loopers.catalog.product.application.dto.out.*;
 import com.loopers.catalog.product.application.service.ProductQueryService;
 import com.loopers.catalog.product.domain.model.Product;
@@ -34,17 +31,13 @@ class ProductQueryFacadeTest {
 
 	@Mock
 	private ProductQueryService productQueryService;
-	@Mock
-	private BrandQueryService brandQueryService;
 
 	private ProductQueryFacade productQueryFacade;
 
 
 	@BeforeEach
 	void setUp() {
-		productQueryFacade = new ProductQueryFacade(
-			productQueryService, brandQueryService
-		);
+		productQueryFacade = new ProductQueryFacade(productQueryService);
 	}
 
 
@@ -53,12 +46,7 @@ private Product createTestProduct() {
 			ProductName.from("테스트 상품"),
 			Money.from(new BigDecimal("10000")),
 			Stock.from(100L),
-			null, 0L, null);
-	}
-
-
-	private Brand createTestBrand() {
-		return Brand.reconstruct(1L, BrandName.from("나이키"), null, null, null);
+			null, null);
 	}
 
 
@@ -67,13 +55,12 @@ private Brand createTestBrand() {
 	class GetProductTest {
 
 		@Test
-		@DisplayName("[getProduct()] 활성 상품 조회 -> ProductDetailOutDto 반환. 브랜드명 포함")
+		@DisplayName("[getProduct()] 활성 상품 조회 -> ProductQueryService.getOrLoadProductDetail()에 위임. ProductDetailOutDto 반환")
 		void getProductSuccess() {
 			// Arrange
-			Product product = createTestProduct();
-			Brand brand = createTestBrand();
-			given(productQueryService.findActiveById(1L)).willReturn(product);
-			given(brandQueryService.getBrandById(1L)).willReturn(brand);
+			ProductDetailOutDto detailOutDto = new ProductDetailOutDto(
+				1L, 1L, "나이키", "테스트 상품", new BigDecimal("10000"), 100L, null, 0L);
+			given(productQueryService.getOrLoadProductDetail(1L)).willReturn(detailOutDto);
 
 			// Act
 			ProductDetailOutDto result = productQueryFacade.getProduct(1L);
@@ -81,10 +68,13 @@ void getProductSuccess() {
 			// Assert
 			assertAll(
 				() -> assertThat(result.id()).isEqualTo(1L),
+				() -> assertThat(result.brandId()).isEqualTo(1L),
 				() -> assertThat(result.brandName()).isEqualTo("나이키"),
 				() -> assertThat(result.name()).isEqualTo("테스트 상품"),
-				() -> verify(productQueryService).findActiveById(1L),
-				() -> verify(brandQueryService).getBrandById(1L)
+				() -> assertThat(result.price()).isEqualByComparingTo(new BigDecimal("10000")),
+				() -> assertThat(result.stock()).isEqualTo(100L),
+				() -> assertThat(result.likeCount()).isEqualTo(0L),
+				() -> verify(productQueryService).getOrLoadProductDetail(1L)
 			);
 		}
 
@@ -122,13 +112,12 @@ void getProductsSuccess() {
 	class GetAdminProductTest {
 
 		@Test
-		@DisplayName("[getAdminProduct()] 관리자 상세 조회 -> AdminProductDetailOutDto 반환. 브랜드명 포함")
+		@DisplayName("[getAdminProduct()] 관리자 상세 조회 -> ProductQueryService.getAdminProductDetail()에 위임. AdminProductDetailOutDto 반환")
 		void getAdminProductSuccess() {
 			// Arrange
-			Product product = createTestProduct();
-			Brand brand = createTestBrand();
-			given(productQueryService.findById(1L)).willReturn(product);
-			given(brandQueryService.getBrandById(1L)).willReturn(brand);
+			AdminProductDetailOutDto detailOutDto = new AdminProductDetailOutDto(
+				1L, 1L, "나이키", "테스트 상품", new BigDecimal("10000"), 100L, null, 0L, null);
+			given(productQueryService.getAdminProductDetail(1L)).willReturn(detailOutDto);
 
 			// Act
 			AdminProductDetailOutDto result = productQueryFacade.getAdminProduct(1L);
@@ -137,7 +126,8 @@ void getAdminProductSuccess() {
 			assertAll(
 				() -> assertThat(result.id()).isEqualTo(1L),
 				() -> assertThat(result.brandName()).isEqualTo("나이키"),
-				() -> verify(productQueryService).findById(1L)
+				() -> assertThat(result.name()).isEqualTo("테스트 상품"),
+				() -> verify(productQueryService).getAdminProductDetail(1L)
 			);
 		}
 
diff --git a/apps/commerce-api/src/test/java/com/loopers/catalog/product/application/service/ProductQueryServiceTest.java b/apps/commerce-api/src/test/java/com/loopers/catalog/product/application/service/ProductQueryServiceTest.java
index dbda98f13..f0fc520de 100644
--- a/apps/commerce-api/src/test/java/com/loopers/catalog/product/application/service/ProductQueryServiceTest.java
+++ b/apps/commerce-api/src/test/java/com/loopers/catalog/product/application/service/ProductQueryServiceTest.java
@@ -1,10 +1,7 @@
 package com.loopers.catalog.product.application.service;
 
 
-import com.loopers.catalog.product.application.dto.out.AdminProductOutDto;
-import com.loopers.catalog.product.application.dto.out.AdminProductPageOutDto;
-import com.loopers.catalog.product.application.dto.out.ProductOutDto;
-import com.loopers.catalog.product.application.dto.out.ProductPageOutDto;
+import com.loopers.catalog.product.application.dto.out.*;
 import com.loopers.catalog.product.application.port.out.query.ProductQueryPort;
 import com.loopers.catalog.product.application.port.out.query.criteria.ProductSearchCriteria;
 import com.loopers.catalog.product.domain.model.Product;
@@ -13,8 +10,12 @@
 import com.loopers.catalog.product.domain.model.vo.ProductName;
 import com.loopers.catalog.product.domain.model.vo.Stock;
 import com.loopers.catalog.product.domain.repository.ProductQueryRepository;
+import com.loopers.catalog.product.domain.repository.ProductReadModelRepository;
 import com.loopers.catalog.product.domain.repository.vo.PageCriteria;
 import com.loopers.catalog.product.domain.repository.vo.PageResult;
+import com.loopers.catalog.product.infrastructure.cache.IdListCacheEntry;
+import com.loopers.catalog.product.infrastructure.cache.ProductCacheDto;
+import com.loopers.catalog.product.infrastructure.cache.ProductCacheManager;
 import com.loopers.support.common.error.CoreException;
 import com.loopers.support.common.error.ErrorType;
 import org.junit.jupiter.api.BeforeEach;
@@ -26,14 +27,20 @@
 import org.mockito.junit.jupiter.MockitoExtension;
 
 import java.math.BigDecimal;
+import java.time.Duration;
+import java.util.Arrays;
 import java.util.List;
 import java.util.Optional;
+import java.util.function.Supplier;
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.junit.jupiter.api.Assertions.assertAll;
 import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
 import static org.mockito.BDDMockito.given;
 import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoInteractions;
 
 
 @ExtendWith(MockitoExtension.class)
@@ -43,14 +50,20 @@ class ProductQueryServiceTest {
 	@Mock
 	private ProductQueryRepository productQueryRepository;
 	@Mock
+	private ProductReadModelRepository productReadModelRepository;
+	@Mock
 	private ProductQueryPort productQueryPort;
+	@Mock
+	private ProductCacheManager productCacheManager;
 
 	private ProductQueryService productQueryService;
 
 
 	@BeforeEach
 	void setUp() {
-		productQueryService = new ProductQueryService(productQueryRepository, productQueryPort);
+		productQueryService = new ProductQueryService(
+			productQueryRepository, productReadModelRepository, productQueryPort, productCacheManager
+		);
 	}
 
 
@@ -59,7 +72,7 @@ private Product createTestProduct() {
 			ProductName.from("테스트 상품"),
 			Money.from(new BigDecimal("10000")),
 			Stock.from(100L),
-			null, 0L, null);
+			null, null);
 	}
 
 
@@ -180,23 +193,116 @@ void findByIdNotFound() {
 	class SearchProductsTest {
 
 		@Test
-		@DisplayName("[searchProducts()] 검색 조건으로 조회 -> ProductPageOutDto 반환")
-		void searchProductsSuccess() {
-			// Arrange
+		@DisplayName("[searchProducts()] 캐시 불가 조건 (page >= MAX_CACHEABLE_PAGE) -> DB 직접 조회. 캐시 미사용")
+		void searchProductsNotCacheable() {
+			// Arrange — page=2 (MAX_CACHEABLE_PAGE=2 이상)
 			ProductSearchCriteria criteria = new ProductSearchCriteria(null, ProductSortType.LATEST);
-			PageCriteria pageCriteria = new PageCriteria(0, 20);
+			PageCriteria pageCriteria = new PageCriteria(2, 20);
 			ProductOutDto outDto = new ProductOutDto(1L, 1L, null, "상품", new BigDecimal("10000"), 100L, 0L);
-			PageResult<ProductOutDto> pageResult = new PageResult<>(List.of(outDto), 0, 20, 1);
+			PageResult<ProductOutDto> pageResult = new PageResult<>(List.of(outDto), 2, 20, 50);
 			given(productQueryPort.searchProducts(criteria, pageCriteria)).willReturn(pageResult);
 
 			// Act
-			ProductPageOutDto result = productQueryService.searchProducts(null, ProductSortType.LATEST, 0, 20);
+			ProductPageOutDto result = productQueryService.searchProducts(null, ProductSortType.LATEST, 2, 20);
 
 			// Assert
 			assertAll(
 				() -> assertThat(result.content()).hasSize(1),
-				() -> assertThat(result.totalElements()).isEqualTo(1),
-				() -> verify(productQueryPort).searchProducts(criteria, pageCriteria)
+				() -> assertThat(result.page()).isEqualTo(2),
+				() -> verify(productQueryPort).searchProducts(criteria, pageCriteria),
+				() -> verifyNoInteractions(productCacheManager)
+			);
+		}
+
+
+		@Test
+		@DisplayName("[searchProducts()] 2계층 캐시 전체 히트 -> ID 리스트 캐시 + MGET 상세 캐시 모두 히트. DB 미호출")
+		@SuppressWarnings("unchecked")
+		void searchProductsFullCacheHit() {
+			// Arrange — Layer 1: ID 리스트 캐시 히트
+			IdListCacheEntry idList = new IdListCacheEntry(List.of(1L, 2L), 2);
+			given(productCacheManager.getOrLoad(
+				eq("products:ids:v1:all:LATEST:0:20"),
+				eq(IdListCacheEntry.class),
+				any(Duration.class),
+				any(Supplier.class)
+			)).willReturn(idList);
+
+			// Layer 2: MGET 상세 캐시 전체 히트
+			ProductCacheDto dto1 = new ProductCacheDto(1L, 1L, "나이키", "상품1", new BigDecimal("10000"), 100L, null, 0L);
+			ProductCacheDto dto2 = new ProductCacheDto(2L, 1L, "나이키", "상품2", new BigDecimal("20000"), 50L, null, 5L);
+			given(productCacheManager.mgetProductDetails(List.of(1L, 2L))).willReturn(List.of(dto1, dto2));
+
+			// Act
+			ProductPageOutDto result = productQueryService.searchProducts(null, ProductSortType.LATEST, 0, 20);
+
+			// Assert
+			assertAll(
+				() -> assertThat(result.content()).hasSize(2),
+				() -> assertThat(result.content().get(0).name()).isEqualTo("상품1"),
+				() -> assertThat(result.content().get(1).name()).isEqualTo("상품2"),
+				() -> assertThat(result.totalElements()).isEqualTo(2),
+				() -> verifyNoInteractions(productQueryPort)
+			);
+		}
+
+
+		@Test
+		@DisplayName("[searchProducts()] MGET partial miss -> miss된 ID를 DB에서 조회 후 캐시 저장. ID 순서 보존")
+		@SuppressWarnings("unchecked")
+		void searchProductsMgetPartialMiss() {
+			// Arrange — Layer 1: ID 리스트 캐시 히트
+			IdListCacheEntry idList = new IdListCacheEntry(List.of(1L, 2L), 2);
+			given(productCacheManager.getOrLoad(
+				eq("products:ids:v1:1:LATEST:0:20"),
+				eq(IdListCacheEntry.class),
+				any(Duration.class),
+				any(Supplier.class)
+			)).willReturn(idList);
+
+			// Layer 2: MGET — id=1 히트, id=2 miss (null)
+			ProductCacheDto dto1 = new ProductCacheDto(1L, 1L, "나이키", "상품1", new BigDecimal("10000"), 100L, null, 0L);
+			given(productCacheManager.mgetProductDetails(List.of(1L, 2L))).willReturn(Arrays.asList(dto1, null));
+
+			// miss된 id=2를 DB에서 조회
+			ProductCacheDto dto2 = new ProductCacheDto(2L, 1L, "나이키", "상품2", new BigDecimal("20000"), 50L, null, 5L);
+			given(productQueryPort.findProductCacheDtosByIds(List.of(2L))).willReturn(List.of(dto2));
+
+			// Act
+			ProductPageOutDto result = productQueryService.searchProducts(1L, ProductSortType.LATEST, 0, 20);
+
+			// Assert — ID 순서 보존 (1 → 2)
+			assertAll(
+				() -> assertThat(result.content()).hasSize(2),
+				() -> assertThat(result.content().get(0).id()).isEqualTo(1L),
+				() -> assertThat(result.content().get(1).id()).isEqualTo(2L),
+				() -> verify(productQueryPort).findProductCacheDtosByIds(List.of(2L)),
+				() -> verify(productCacheManager).put(eq("product:v1:2"), eq(dto2), any(Duration.class))
+			);
+		}
+
+
+		@Test
+		@DisplayName("[searchProducts()] 빈 ID 리스트 -> 빈 페이지 반환. Layer 2 MGET 미호출")
+		@SuppressWarnings("unchecked")
+		void searchProductsEmptyIdList() {
+			// Arrange — Layer 1: 빈 ID 리스트
+			IdListCacheEntry idList = new IdListCacheEntry(List.of(), 0);
+			given(productCacheManager.getOrLoad(
+				eq("products:ids:v1:all:LATEST:0:20"),
+				eq(IdListCacheEntry.class),
+				any(Duration.class),
+				any(Supplier.class)
+			)).willReturn(idList);
+
+			// Act
+			ProductPageOutDto result = productQueryService.searchProducts(null, ProductSortType.LATEST, 0, 20);
+
+			// Assert
+			assertAll(
+				() -> assertThat(result.content()).isEmpty(),
+				() -> assertThat(result.totalElements()).isEqualTo(0),
+				() -> verify(productCacheManager).getOrLoad(any(), any(), any(), any())
 			);
 		}
 
@@ -246,7 +352,7 @@ void findActiveByIdsEmpty() {
 	class SearchAdminProductsTest {
 
 		@Test
-		@DisplayName("[searchAdminProducts()] 관리자 검색 조건으로 조회 -> AdminProductPageOutDto 반환")
+		@DisplayName("[searchAdminProducts()] 관리자 검색 -> 캐시 미적용. 항상 QueryPort 호출. AdminProductPageOutDto 반환")
 		void searchAdminProductsSuccess() {
 			// Arrange
 			ProductSearchCriteria criteria = new ProductSearchCriteria(null, ProductSortType.LATEST);
@@ -263,7 +369,165 @@ void searchAdminProductsSuccess() {
 			assertAll(
 				() -> assertThat(result.content()).hasSize(1),
 				() -> assertThat(result.totalElements()).isEqualTo(1),
-				() -> verify(productQueryPort).searchAdminProducts(criteria, pageCriteria)
+				() -> verify(productQueryPort).searchAdminProducts(criteria, pageCriteria),
+				() -> verifyNoInteractions(productCacheManager)
+			);
+		}
+
+	}
+
+
+	@Nested
+	@DisplayName("getOrLoadProductDetail()")
+	class GetOrLoadProductDetailTest {
+
+		@Test
+		@DisplayName("[getOrLoadProductDetail()] 캐시 히트 -> ProductCacheDto에서 ProductDetailOutDto로 변환 반환. QueryPort 미호출")
+		void cacheHit() {
+			// Arrange
+			ProductCacheDto cacheDto = new ProductCacheDto(
+				1L, 1L, "나이키", "테스트 상품", new BigDecimal("10000"), 100L, null, 0L);
+			given(productCacheManager.getOrLoadWithPer(
+				eq("product:v1:1"),
+				eq(ProductCacheDto.class),
+				any(Duration.class),
+				any(Supplier.class)
+			)).willReturn(cacheDto);
+
+			// Act
+			ProductDetailOutDto result = productQueryService.getOrLoadProductDetail(1L);
+
+			// Assert
+			assertAll(
+				() -> assertThat(result.id()).isEqualTo(1L),
+				() -> assertThat(result.brandName()).isEqualTo("나이키"),
+				() -> assertThat(result.name()).isEqualTo("테스트 상품"),
+				() -> verifyNoInteractions(productQueryPort)
+			);
+		}
+
+
+		@Test
+		@DisplayName("[getOrLoadProductDetail()] 상품 미존재 (loader가 null 반환) -> PRODUCT_NOT_FOUND 예외")
+		@SuppressWarnings("unchecked")
+		void productNotFound() {
+			// Arrange — loader가 null 반환 (상품 미존재 또는 삭제)
+			given(productCacheManager.getOrLoadWithPer(
+				eq("product:v1:999"),
+				eq(ProductCacheDto.class),
+				any(Duration.class),
+				any(Supplier.class)
+			)).willReturn(null);
+
+			// Act
+			CoreException exception = assertThrows(CoreException.class,
+				() -> productQueryService.getOrLoadProductDetail(999L));
+
+			// Assert
+			assertAll(
+				() -> assertThat(exception.getErrorType()).isEqualTo(ErrorType.PRODUCT_NOT_FOUND),
+				() -> assertThat(exception.getMessage()).isEqualTo(ErrorType.PRODUCT_NOT_FOUND.getMessage())
+			);
+		}
+
+
+		@Test
+		@DisplayName("[getOrLoadProductDetail()] 캐시 미스 -> QueryPort.findProductCacheDtoById() 호출 후 캐시 저장. ProductDetailOutDto 반환")
+		@SuppressWarnings("unchecked")
+		void cacheMiss() {
+			// Arrange
+			ProductCacheDto cacheDto = new ProductCacheDto(
+				1L, 1L, "나이키", "테스트 상품", new BigDecimal("10000"), 100L, null, 0L);
+			given(productQueryPort.findProductCacheDtoById(1L)).willReturn(cacheDto);
+
+			// loader 실행을 시뮬레이션 (캐시 미스 시 supplier 호출)
+			given(productCacheManager.getOrLoadWithPer(
+				eq("product:v1:1"),
+				eq(ProductCacheDto.class),
+				any(Duration.class),
+				any(Supplier.class)
+			)).willAnswer(invocation -> {
+				Supplier<ProductCacheDto> loader = invocation.getArgument(3);
+				return loader.get();
+			});
+
+			// Act
+			ProductDetailOutDto result = productQueryService.getOrLoadProductDetail(1L);
+
+			// Assert
+			assertAll(
+				() -> assertThat(result.id()).isEqualTo(1L),
+				() -> assertThat(result.brandName()).isEqualTo("나이키"),
+				() -> assertThat(result.name()).isEqualTo("테스트 상품"),
+				() -> verify(productQueryPort).findProductCacheDtoById(1L)
+			);
+		}
+
+	}
+
+
+	@Nested
+	@DisplayName("getAdminProductDetail()")
+	class GetAdminProductDetailTest {
+
+		@Test
+		@DisplayName("[getAdminProductDetail()] Read Model에 상품 존재 -> AdminProductDetailOutDto 반환. 삭제된 브랜드에도 안전")
+		void getAdminProductDetailSuccess() {
+			// Arrange
+			AdminProductDetailOutDto detailOutDto = new AdminProductDetailOutDto(
+				1L, 1L, "나이키", "테스트 상품", new BigDecimal("10000"), 100L, null, 0L, null);
+			given(productQueryPort.findAdminProductDetailById(1L)).willReturn(detailOutDto);
+
+			// Act
+			AdminProductDetailOutDto result = productQueryService.getAdminProductDetail(1L);
+
+			// Assert
+			assertAll(
+				() -> assertThat(result.id()).isEqualTo(1L),
+				() -> assertThat(result.brandName()).isEqualTo("나이키"),
+				() -> assertThat(result.name()).isEqualTo("테스트 상품"),
+				() -> verify(productQueryPort).findAdminProductDetailById(1L)
+			);
+		}
+
+
+		@Test
+		@DisplayName("[getAdminProductDetail()] Read Model에 상품 미존재 -> PRODUCT_NOT_FOUND 예외")
+		void getAdminProductDetailNotFound() {
+			// Arrange
+			given(productQueryPort.findAdminProductDetailById(999L)).willReturn(null);
+
+			// Act
+			CoreException exception = assertThrows(CoreException.class,
+				() -> productQueryService.getAdminProductDetail(999L));
+
+			// Assert
+			assertAll(
+				() -> assertThat(exception.getErrorType()).isEqualTo(ErrorType.PRODUCT_NOT_FOUND),
+				() -> assertThat(exception.getMessage()).isEqualTo(ErrorType.PRODUCT_NOT_FOUND.getMessage())
+			);
+		}
+
+	}
+
+
+	@Nested
+	@DisplayName("findActiveIdsByBrandId()")
+	class FindActiveIdsByBrandIdTest {
+
+		@Test
+		@DisplayName("[findActiveIdsByBrandId()] 브랜드 ID -> 활성 상품 ID 목록 반환. ReadModelRepository에 위임")
+		void findActiveIdsByBrandIdSuccess() {
+			// Arrange
+			given(productReadModelRepository.findActiveIdsByBrandId(1L)).willReturn(List.of(10L, 20L, 30L));
+
+			// Act
+			List<Long> result = productQueryService.findActiveIdsByBrandId(1L);
+
+			// Assert
+			assertAll(
+				() -> assertThat(result).containsExactly(10L, 20L, 30L),
+				() -> verify(productReadModelRepository).findActiveIdsByBrandId(1L)
 			);
 		}
 
diff --git a/apps/commerce-api/src/test/java/com/loopers/catalog/product/interfaces/ProductControllerE2ETest.java b/apps/commerce-api/src/test/java/com/loopers/catalog/product/interfaces/ProductControllerE2ETest.java
index 077341ca6..b3277a0b4 100644
--- a/apps/commerce-api/src/test/java/com/loopers/catalog/product/interfaces/ProductControllerE2ETest.java
+++ b/apps/commerce-api/src/test/java/com/loopers/catalog/product/interfaces/ProductControllerE2ETest.java
@@ -11,6 +11,7 @@
 import com.loopers.testcontainers.MySqlTestContainersConfig;
 import com.loopers.testcontainers.RedisTestContainersConfig;
 import com.loopers.utils.DatabaseCleanUp;
+import com.loopers.utils.RedisCleanUp;
 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Nested;
@@ -48,6 +49,9 @@ class ProductControllerE2ETest {
 	@Autowired
 	private DatabaseCleanUp databaseCleanUp;
 
+	@Autowired
+	private RedisCleanUp redisCleanUp;
+
 	private static final String ADMIN_LDAP_HEADER = "X-Loopers-Ldap";
 	private static final String ADMIN_LDAP_VALUE = "loopers.admin";
 
@@ -55,6 +59,7 @@ class ProductControllerE2ETest {
 	@AfterEach
 	void tearDown() {
 		databaseCleanUp.truncateAllTables();
+		redisCleanUp.truncateAll();
 	}
 
 
@@ -731,6 +736,37 @@ void updateProductSoftDeleted() throws Exception {
 				.andExpect(jsonPath("$.code").value(ErrorType.PRODUCT_NOT_FOUND.getCode()));
 		}
 
+
+		@Test
+		@DisplayName("[PUT + GET /api/v1/products/{productId}] 상품 수정 후 상세 조회 -> 캐시 무효화되어 수정된 데이터 반환")
+		void updateProductThenGetReturnsUpdatedData() throws Exception {
+			// Arrange
+			Long brandId = createBrandAndGetId("나이키", "스포츠 브랜드");
+			Long productId = createProductAndGetId(brandId, "에어맥스", new BigDecimal("129000"), 100L, "러닝화");
+
+			// 상세 조회 (캐시에 저장됨)
+			mockMvc.perform(get("/api/v1/products/{productId}", productId))
+				.andExpect(status().isOk())
+				.andExpect(jsonPath("$.name").value("에어맥스"));
+
+			// 상품 수정 (캐시 무효화 발생)
+			AdminProductUpdateRequest updateRequest = new AdminProductUpdateRequest(
+				"에어맥스 97", new BigDecimal("159000"), 200L, "레트로 러닝화");
+			mockMvc.perform(put("/api-admin/v1/products/{productId}", productId)
+					.header(ADMIN_LDAP_HEADER, ADMIN_LDAP_VALUE)
+					.contentType(MediaType.APPLICATION_JSON)
+					.content(objectMapper.writeValueAsString(updateRequest)))
+				.andExpect(status().isOk());
+
+			// Act & Assert — 수정된 데이터가 반환되어야 함 (캐시 무효화 검증)
+			mockMvc.perform(get("/api/v1/products/{productId}", productId))
+				.andExpect(status().isOk())
+				.andExpect(jsonPath("$.name").value("에어맥스 97"))
+				.andExpect(jsonPath("$.price").value(159000))
+				.andExpect(jsonPath("$.stock").value(200))
+				.andExpect(jsonPath("$.description").value("레트로 러닝화"));
+		}
+
 	}
 
 
diff --git a/docs/todo/cache-event-driven-refresh.md b/docs/todo/cache-event-driven-refresh.md
new file mode 100644
index 000000000..d35f36198
--- /dev/null
+++ b/docs/todo/cache-event-driven-refresh.md
@@ -0,0 +1,85 @@
+# TODO: 캐시 갱신 이벤트 기반 전환
+
+## 개요
+
+현재 캐시 write-through는 `@Transactional` 내부에서 동기적으로 실행된다.
+TX 롤백 시 캐시에 잘못된 데이터가 남을 수 있으며, TTL 안전망(2~3분)에 의존한다.
+
+이벤트 기반으로 전환하면 TX 커밋 확정 후에만 캐시를 갱신하여 정합성을 보장할 수 있다.
+
+## 현재 상태 (Round 5)
+
+```java
+// ProductCommandService — TX 내부에서 캐시 직접 갱신
+@Transactional
+public void increaseLikeCount(Long productId) {
+    readModelRepository.increaseLikeCount(productId);
+    // 캐시 write-through (TX 내부 — 롤백 시 캐시 불일치 가능)
+    productCacheManager.refreshProductDetail(productId, () -> productQueryPort.findProductCacheDtoById(productId));
+}
+```
+
+## 목표 상태
+
+```java
+// ProductCommandService — 이벤트 발행만
+@Transactional
+public void increaseLikeCount(Long productId) {
+    readModelRepository.increaseLikeCount(productId);
+    // 이벤트 발행 (TX 내부에서는 캐시 미접촉)
+    eventPublisher.publishEvent(new ProductCacheRefreshEvent(productId, RefreshType.LIKE_COUNT));
+}
+
+// 이벤트 리스너 — TX 커밋 후 실행
+@TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT)
+public void onProductCacheRefresh(ProductCacheRefreshEvent event) {
+    productCacheManager.refreshProductDetail(event.productId());
+    productCacheManager.refreshIdLists(event.productId(), event.refreshType());
+}
+```
+
+## 변환 대상 메서드
+
+| 메서드 | 현재 | 목표 |
+|--------|------|------|
+| `ProductCommandService.increaseLikeCount()` | TX 내 캐시 갱신 | 이벤트 발행 |
+| `ProductCommandService.decreaseLikeCount()` | TX 내 캐시 갱신 | 이벤트 발행 |
+| `ProductCommandService.decreaseStock()` | TX 내 캐시 갱신 | 이벤트 발행 |
+| `ProductCommandService.createProduct()` | TX 내 캐시 갱신 | 이벤트 발행 |
+| `ProductCommandService.updateProduct()` | TX 내 캐시 갱신 | 이벤트 발행 |
+| `ProductCommandService.deleteProduct()` | TX 내 캐시 갱신 | 이벤트 발행 |
+
+## 신규 생성 파일
+
+| 파일 | 위치 | 역할 |
+|------|------|------|
+| `ProductCacheRefreshEvent` | `catalog/product/domain/event/` | 캐시 갱신 이벤트 (productId, refreshType) |
+| `ProductCacheRefreshListener` | `catalog/product/interfaces/event/` | `@TransactionalEventListener` 리스너 |
+
+## 참고: CLAUDE.md 이벤트 규칙
+
+- Event 클래스 Javadoc에 `@subscriber` 목록 명시
+- Publisher 쪽 주석에 `→ [{Listener}] {효과}` 인라인 주석 기록
+
+## 참고: ApplicationReadyEvent 기반 캐시 웜업
+
+서버 시작 시 hot 페이지를 선제적으로 캐시 적재하는 기능도 함께 도입한다.
+
+```java
+@EventListener(ApplicationReadyEvent.class)
+public void warmUpCache() {
+    // 모든 필터 조합 × 3정렬 × pages 0~2 캐시 선적재
+    // 상품 상세 캐시도 hot 상품 기준으로 선적재
+}
+```
+
+## 우선순위
+
+- 이벤트 기반 캐시 갱신: **중간** (현재 TTL 안전망으로 동작 중, TX 롤백은 극히 드묾)
+- ApplicationReadyEvent 웜업: **낮음** (cache-aside로 초기 적재 가능)
+
+## 관련 문서
+
+- `round5-docs/08-cache-eviction-analysis.md` — 캐시 전략 분석 및 최종 설계
+- `docs/design/05-concurrency-strategy.md` — 동시성 전략
+- `round4-docs/03-sync-vs-event-analysis.md` — 이벤트 vs 동기 분석
diff --git a/round5-docs/05-to-be-cache-measurement.md b/round5-docs/05-to-be-cache-measurement.md
new file mode 100644
index 000000000..2a820e65f
--- /dev/null
+++ b/round5-docs/05-to-be-cache-measurement.md
@@ -0,0 +1,197 @@
+# TO-BE 캐시 성능 측정 결과
+
+> 실측 재현 명령어: `./gradlew :apps:commerce-api:benchmarkTest --tests '*ProductApiPerformanceTest.measureApiCache_*'`
+
+## 측정 환경
+
+| 항목 | 값 |
+|------|---|
+| DB | MySQL 8.0 (TestContainers) |
+| Cache | Redis (TestContainers) |
+| 데이터 규모 | 10만 / 100만 / 1000만 |
+| 브랜드 | 50개 균등 분포 |
+| 인덱스 | `product_read_model` 복합 인덱스 12개 |
+| 캐시 구조 | 2-Layer Cache (ID 리스트 + 상세) |
+| 측정 레벨 | MockMvc 기반 API 전체 스택 |
+
+## 현재 구현 기준 요약
+
+### 캐시 키와 TTL
+
+| 대상 | 캐시 키 패턴 | TTL | 비고 |
+|------|-------------|-----|------|
+| 상품 상세 | `product:v1:{productId}` | 2분 + jitter | PDP, PLP partial miss fallback 공용 |
+| ID 리스트 | `products:ids:v1:{brandId\|all}:{sort}:{page}:{size}` | 3분 + jitter | 목록 정렬/필터 조합별 ID 캐시 |
+
+### 스탬피드 보호
+
+| 기법 | 현재 구현 |
+|------|----------|
+| TTL Jitter | 적용 |
+| PER | 적용 |
+| Cache Lock | `LocalCacheLock` + double-check |
+
+### Write-Through 범위
+
+| 변경 작업 | 상세 캐시 | ID 리스트 캐시 |
+|----------|----------|---------------|
+| 좋아요 증가/감소 | 갱신 | 갱신 안 함 (TTL 자연 만료 허용) |
+| 재고 차감 | 갱신 | 갱신 안 함 |
+| 가격 변경 | 갱신 | `PRICE_ASC` 목록 갱신 |
+| 상품 생성/삭제 | 생성/삭제 | 영향 목록 갱신 |
+| 브랜드명 변경 | 해당 브랜드 상품 상세 일괄 갱신 | 갱신 안 함 |
+
+### 측정 방식
+
+- `MISS`: warmup도 매번 Redis를 비운 뒤 수행하고, 측정 직전에도 Redis를 비운 뒤 1회 요청한다.
+- `HIT`: 명시적으로 캐시를 한 번 채운 뒤 warmup 3회, 측정 5회를 수행한다.
+- 단일/버스트/지속부하 모두 `2xx` 응답만 성공 샘플로 집계한다.
+- 캐시 갱신은 현재 구현처럼 트랜잭션 내부 best-effort write-through 기준으로 측정했다.
+- `afterCommit` 이벤트 전환은 이번 라운드 범위 밖 TODO다.
+
+---
+
+## 단일 API 요청
+
+### Cache Miss
+
+#### 목록 API (`GET /api/v1/products`)
+
+| UC | 조건 | 정렬 | 10만 avg (ms) | 100만 avg (ms) | 1000만 avg (ms) |
+|----|------|------|:---:|:---:|:---:|
+| 1 | brandId=X | LATEST | **39.85** | **142.18** | **1166.02** |
+| 2 | brandId=X | PRICE_ASC | **54.95** | **334.30** | **3884.57** |
+| 3 | brandId=X | LIKES_DESC | **32.85** | **122.44** | **1160.68** |
+| 4 | brandId=1 | LATEST | **25.41** | **22.51** | **51.69** |
+| 5 | brandId=1 | PRICE_ASC | **21.50** | **26.85** | **97.49** |
+| 6 | brandId=1 | LIKES_DESC | **24.95** | **20.77** | **44.58** |
+
+#### 상세 API (`GET /api/v1/products/{id}`)
+
+| UC | 10만 avg (ms) | 100만 avg (ms) | 1000만 avg (ms) |
+|----|:---:|:---:|:---:|
+| 상세: productId=1 | **9.50** | **6.41** | **6.32** |
+
+- cold-cache 기준에서는 `brandId` 없는 목록이 여전히 DB 쿼리 비용의 영향을 크게 받는다.
+- 특히 `PRICE_ASC`는 1000만건에서 **3.88s**까지 상승했다. 캐시를 “없애도 되는 수준”이라고 보기 어려운 이유다.
+- 상세 miss는 PK lookup 기반이라 전 규모에서 **6~10ms**로 안정적이다.
+
+### Cache Hit
+
+#### 목록 API (`GET /api/v1/products`)
+
+| UC | 조건 | 정렬 | 10만 avg (ms) | 100만 avg (ms) | 1000만 avg (ms) |
+|----|------|------|:---:|:---:|:---:|
+| 1 | brandId=X | LATEST | **5.99** | **6.10** | **5.15** |
+| 2 | brandId=X | PRICE_ASC | **7.65** | **7.39** | **6.42** |
+| 3 | brandId=X | LIKES_DESC | **7.41** | **5.67** | **5.17** |
+| 4 | brandId=1 | LATEST | **7.17** | **6.45** | **4.85** |
+| 5 | brandId=1 | PRICE_ASC | **6.23** | **5.21** | **4.98** |
+| 6 | brandId=1 | LIKES_DESC | **5.76** | **4.66** | **4.53** |
+
+#### 상세 API (`GET /api/v1/products/{id}`)
+
+| UC | 10만 avg (ms) | 100만 avg (ms) | 1000만 avg (ms) |
+|----|:---:|:---:|:---:|
+| 상세: productId=1 | **4.98** | **4.77** | **3.85** |
+
+- hot-cache 경로는 전 규모에서 **3.85~7.65ms** 범위로 수렴했다.
+- 즉, 현재 캐시의 진짜 가치 는 “cold-cache를 빠르게 만드는 것”보다 “hot-path를 데이터 규모와 분리하는 것”에 있다.
+
+---
+
+## 버스트 측정 (100 concurrent)
+
+### Cache Hit
+
+| 데이터 규모 | UC | 완료/전체 | 에러 | avg (ms) | p95 (ms) |
+|:---:|------|:---:|:---:|:---:|:---:|
+| 10만 | 목록 UC1: brandId=X, LATEST | 100/100 | 0 | **121.32** | **183.20** |
+| 10만 | 목록 UC3: brandId=X, LIKES_DESC | 100/100 | 0 | **183.83** | **247.96** |
+| 10만 | 목록 UC4: brandId=1, LATEST | 100/100 | 0 | **100.70** | **145.90** |
+| 10만 | 상세: productId=1 | 100/100 | 0 | **51.90** | **101.51** |
+| 100만 | 목록 UC1: brandId=X, LATEST | 100/100 | 0 | **215.73** | **258.76** |
+| 100만 | 목록 UC3: brandId=X, LIKES_DESC | 100/100 | 0 | **213.48** | **255.92** |
+| 100만 | 목록 UC4: brandId=1, LATEST | 100/100 | 0 | **93.50** | **133.44** |
+| 100만 | 상세: productId=1 | 100/100 | 0 | **77.10** | **111.47** |
+| 1000만 | 목록 UC1: brandId=X, LATEST | 100/100 | 0 | **1245.17** | **1287.48** |
+| 1000만 | 목록 UC3: brandId=X, LIKES_DESC | 100/100 | 0 | **1287.17** | **1331.43** |
+| 1000만 | 목록 UC4: brandId=1, LATEST | 100/100 | 0 | **158.50** | **200.02** |
+| 1000만 | 상세: productId=1 | 100/100 | 0 | **48.26** | **72.73** |
+
+### Cache Miss + 스탬피드 보호
+
+| 데이터 규모 | UC | 완료/전체 | 에러 | avg (ms) | p95 (ms) |
+|:---:|------|:---:|:---:|:---:|:---:|
+| 10만 | 목록 UC1: brandId=X, LATEST | 100/100 | 0 | **225.83** | **269.18** |
+| 10만 | 상세: productId=1 | 100/100 | 0 | **108.51** | **170.80** |
+| 100만 | 목록 UC1: brandId=X, LATEST | 100/100 | 0 | **216.68** | **258.23** |
+| 100만 | 상세: productId=1 | 100/100 | 0 | **62.30** | **93.85** |
+| 1000만 | 목록 UC1: brandId=X, LATEST | 100/100 | 0 | **1145.78** | **1172.37** |
+| 1000만 | 상세: productId=1 | 100/100 | 0 | **58.49** | **85.97** |
+
+- same-key miss burst는 모두 **에러 0%**로 종료됐다.
+- `LocalCacheLock` + double-check 덕분에 loader 중복 실행은 1회로 수렴하고, 나머지 요청은 lock 해제 후 캐시를 재사용한다.
+- 다만 1000만건 전체 목록은 cache hit 버스트조차 **1.2초대**까지 올라간다. 이건 Redis가 느린 게 아니라, API 레이어 직렬화/역직렬화와 100 concurrent MockMvc 환경 비용이 누적된 결과다.
+
+---
+
+## 지속 부하 측정 (20 RPS × 10초, Cache Hit)
+
+| 데이터 규모 | UC | 완료/전체 | 에러 | 실제 QPS | avg (ms) | p95 (ms) |
+|:---:|------|:---:|:---:|:---:|:---:|:---:|
+| 10만 | 목록 UC1: brandId=X, LATEST | 200/200 | 0 | **20.0** | **8.34** | **14.42** |
+| 10만 | 목록 UC3: brandId=X, LIKES_DESC | 200/200 | 0 | **20.0** | **9.13** | **9.66** |
+| 10만 | 목록 UC4: brandId=1, LATEST | 200/200 | 0 | **20.0** | **7.35** | **9.78** |
+| 10만 | 상세: productId=1 | 200/200 | 0 | **20.0** | **6.16** | **8.36** |
+| 100만 | 목록 UC1: brandId=X, LATEST | 200/200 | 0 | **20.0** | **6.67** | **8.18** |
+| 100만 | 목록 UC3: brandId=X, LIKES_DESC | 200/200 | 0 | **20.0** | **8.34** | **10.47** |
+| 100만 | 목록 UC4: brandId=1, LATEST | 200/200 | 0 | **20.0** | **7.17** | **11.14** |
+| 100만 | 상세: productId=1 | 200/200 | 0 | **20.0** | **6.07** | **8.92** |
+| 1000만 | 목록 UC1: brandId=X, LATEST | 200/200 | 0 | **20.0** | **6.62** | **8.96** |
+| 1000만 | 목록 UC3: brandId=X, LIKES_DESC | 200/200 | 0 | **20.0** | **6.22** | **7.44** |
+| 1000만 | 목록 UC4: brandId=1, LATEST | 200/200 | 0 | **20.0** | **6.42** | **8.13** |
+| 1000만 | 상세: productId=1 | 200/200 | 0 | **20.0** | **5.91** | **7.40** |
+
+- hot-cache sustained load에서는 전 규모 모두 **20.0 QPS / 에러 0%**를 유지했다.
+- 즉, 운영상 중요한 steady-state는 현재 캐시 구조로 충분히 방어된다.
+
+---
+
+## 핵심 관찰
+
+### 1. hot-cache는 데이터 규모와 거의 무관하다
+
+- 단일 요청 기준 `3.85~7.65ms`
+- 지속 부하 기준 `5.91~9.13ms`
+- 10만, 100만, 1000만 모두 steady-state에서는 거의 같은 응답 구간에 들어온다.
+
+### 2. cold-cache는 여전히 DB 비용에 종속된다
+
+- `brandId` 없는 `PRICE_ASC`는 10만 `54.95ms` → 100만 `334.30ms` → 1000만 `3884.57ms`
+- 즉, “인덱스가 있으니 캐시 없이도 충분하다”는 결론은 성립하지 않는다.
+
+### 3. 스탬피드 보호는 same-key miss에서 의미 있게 동작한다
+
+- miss burst 대표 시나리오에서 에러율은 모두 `0%`
+- loader 중복 실행은 `LocalCacheLock`과 `double-check`로 제어된다.
+
+### 4. 이번 수치는 이전 문서보다 MISS가 더 높다
+
+- 이유는 기존 문서가 warmup 과정에서 이미 캐시를 채운 뒤 `MISS`를 측정했기 때문이다.
+- 이번 재측정은 warmup과 측정 모두 Redis를 비워서 **실제 cold-cache miss**만 집계했다.
+
+---
+
+## 요약
+
+| 지표 | 현재 결론 |
+|------|----------|
+| 단일 요청 Hit | 전 규모 `3.85~7.65ms` |
+| 단일 요청 Miss | 쿼리 조건에 따라 `6.32ms ~ 3884.57ms` |
+| 버스트 에러율 | hit/miss 모두 `0%` |
+| 지속 부하 | 전 규모 `20.0 QPS`, 에러 `0%` |
+| 설계 핵심 가치 | steady-state를 데이터 규모와 분리 |
+| 남은 TODO | `afterCommit` 이벤트 기반 캐시 갱신 전환 |
+
+> 상세 비교는 [`03-as-is-performance-measurement.md`](./03-as-is-performance-measurement.md), [`04-to-be-index-measurement.md`](./04-to-be-index-measurement.md)와 함께 읽는다.
diff --git a/round5-docs/05-to-be-cache-visualization.html b/round5-docs/05-to-be-cache-visualization.html
new file mode 100644
index 000000000..13d4570c8
--- /dev/null
+++ b/round5-docs/05-to-be-cache-visualization.html
@@ -0,0 +1,691 @@
+<!DOCTYPE html>
+<html lang="ko">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>TO-BE 캐시 성능 측정 결과 시각화</title>
+    <script src="https://cdn.jsdelivr.net/npm/chart.js@4.4.7/dist/chart.umd.min.js"></script>
+    <style>
+        * { margin: 0; padding: 0; box-sizing: border-box; }
+        body {
+            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+            background: #0f172a;
+            color: #e2e8f0;
+            padding: 2rem 2rem 4rem;
+            max-width: 1400px;
+            margin: 0 auto;
+        }
+        h1 {
+            text-align: center;
+            font-size: 2rem;
+            margin-bottom: 0.5rem;
+            background: linear-gradient(135deg, #22c55e, #06b6d4);
+            -webkit-background-clip: text;
+            -webkit-text-fill-color: transparent;
+        }
+        .subtitle { text-align: center; color: #94a3b8; margin-bottom: 2rem; font-size: 0.9rem; }
+        .note-banner {
+            background: #1e293b;
+            border: 1px solid #f97316;
+            border-radius: 10px;
+            padding: 1rem 1.5rem;
+            margin-bottom: 2rem;
+            font-size: 0.82rem;
+            color: #cbd5e1;
+            line-height: 1.6;
+        }
+        .note-banner strong { color: #f97316; }
+        .note-banner code { background: #0f172a; padding: 2px 6px; border-radius: 3px; font-size: 0.78rem; color: #f97316; }
+        .section-title {
+            font-size: 1.4rem;
+            margin: 3rem 0 0.5rem;
+            padding-left: 1rem;
+            border-left: 4px solid #22c55e;
+            color: #f8fafc;
+        }
+        .section-desc { color: #94a3b8; margin-bottom: 1.5rem; padding-left: 1.2rem; font-size: 0.85rem; line-height: 1.6; }
+        .grid { display: grid; grid-template-columns: repeat(auto-fit, minmax(520px, 1fr)); gap: 1.5rem; margin-bottom: 1rem; }
+        .grid-3 { display: grid; grid-template-columns: repeat(3, 1fr); gap: 1.5rem; margin-bottom: 1rem; }
+        .card { background: #1e293b; border-radius: 12px; padding: 1.5rem; border: 1px solid #334155; }
+        .card h3 { font-size: 0.95rem; margin-bottom: 1rem; color: #cbd5e1; line-height: 1.4; }
+        .chart-container { position: relative; height: 320px; }
+        .chart-container.tall { height: 400px; }
+        .full-width { grid-column: 1 / -1; }
+
+        /* KPI Cards */
+        .kpi-grid { display: grid; grid-template-columns: repeat(auto-fit, minmax(200px, 1fr)); gap: 1rem; margin-bottom: 2rem; }
+        .kpi { background: #1e293b; border-radius: 10px; padding: 1.2rem; border: 1px solid #334155; text-align: center; }
+        .kpi .value { font-size: 2rem; font-weight: 700; margin: 0.3rem 0; }
+        .kpi .label { font-size: 0.75rem; color: #94a3b8; }
+        .kpi .context { font-size: 0.7rem; color: #64748b; margin-top: 0.3rem; }
+        .kpi.danger .value { color: #ef4444; }
+        .kpi.warn .value { color: #f97316; }
+        .kpi.ok .value { color: #22c55e; }
+
+        /* Insight Box */
+        .insight { background: #1e293b; border-radius: 12px; padding: 1.5rem; margin: 1.5rem 0; }
+        .insight.success { border: 1px solid #22c55e; }
+        .insight.warn { border: 1px solid #f97316; }
+        .insight h3 { margin-bottom: 0.75rem; font-size: 1rem; }
+        .insight.success h3 { color: #22c55e; }
+        .insight.warn h3 { color: #f97316; }
+        .insight ul { list-style: none; padding: 0; }
+        .insight li { padding: 0.3rem 0; color: #cbd5e1; font-size: 0.88rem; line-height: 1.5; }
+        .insight.success li::before { content: "# "; color: #22c55e; font-weight: 700; }
+        .insight.warn li::before { content: "# "; color: #f97316; font-weight: 700; }
+
+        .badge { display: inline-block; padding: 2px 8px; border-radius: 4px; font-size: 0.7rem; font-weight: 600; margin-left: 0.5rem; vertical-align: middle; }
+        .badge-ok { background: #22c55e33; color: #22c55e; }
+        .badge-info { background: #3b82f633; color: #3b82f6; }
+        .legend-note { text-align: center; color: #64748b; font-size: 0.75rem; margin-top: 2rem; }
+
+        /* Architecture Diagram */
+        .arch-diagram {
+            background: #0f172a;
+            border: 1px solid #334155;
+            border-radius: 8px;
+            padding: 2rem;
+            font-family: 'Courier New', monospace;
+            font-size: 0.82rem;
+            line-height: 1.8;
+            color: #cbd5e1;
+            overflow-x: auto;
+            white-space: pre;
+        }
+        .arch-diagram .highlight { color: #22c55e; font-weight: 700; }
+        .arch-diagram .accent { color: #f97316; font-weight: 700; }
+        .arch-diagram .dim { color: #64748b; }
+        .arch-diagram .info { color: #3b82f6; }
+        .arch-diagram .warn { color: #eab308; }
+
+        /* Ref Table */
+        .ref-table { width: 100%; border-collapse: collapse; font-size: 0.85rem; margin-bottom: 0.5rem; }
+        .ref-table th { background: #334155; color: #f8fafc; padding: 8px 12px; text-align: left; font-weight: 600; }
+        .ref-table td { padding: 6px 12px; border-bottom: 1px solid #334155; color: #cbd5e1; }
+        .ref-table tr:hover td { background: #334155; }
+        .ref-table code { background: #0f172a; padding: 2px 6px; border-radius: 3px; font-size: 0.8rem; color: #f97316; }
+
+        /* Nav */
+        .nav { position: fixed; top: 1rem; right: 1rem; background: #1e293b; border: 1px solid #334155; border-radius: 8px; padding: 0.75rem; z-index: 100; font-size: 0.78rem; }
+        .nav a { display: block; color: #94a3b8; text-decoration: none; padding: 0.25rem 0.5rem; border-radius: 4px; }
+        .nav a:hover { background: #334155; color: #f8fafc; }
+        .nav .nav-sep { border-top: 1px solid #334155; margin: 0.3rem 0; }
+
+        @media (max-width: 900px) {
+            .grid, .grid-3 { grid-template-columns: 1fr; }
+            .nav { display: none; }
+            body { padding: 1rem; }
+            .kpi-grid { grid-template-columns: repeat(2, 1fr); }
+        }
+    </style>
+</head>
+<body>
+
+<nav class="nav">
+    <a href="#sec-kpi">KPI 요약</a>
+    <div class="nav-sep"></div>
+    <a href="#sec-hit-miss">1. Cache Hit vs Miss</a>
+    <a href="#sec-as-vs-to-hit">2. AS-IS vs TO-BE (Hit)</a>
+    <a href="#sec-as-vs-to-miss">3. AS-IS vs TO-BE (Miss)</a>
+    <a href="#sec-error">4. 에러율 비교</a>
+    <a href="#sec-qps">5. QPS 비교</a>
+    <a href="#sec-arch">6. 캐시 아키텍처</a>
+    <div class="nav-sep"></div>
+    <a href="#sec-conclusion">결론</a>
+</nav>
+
+<h1>TO-BE 캐시 성능 측정 결과</h1>
+<p class="subtitle">
+    Redis Cache-Aside + 스탬피드 보호 (PER + LocalCacheLock + TTL Jitter) &middot;
+    인덱스 최적화 Read Model &middot; TestContainers MySQL 8.0 + Redis
+</p>
+
+<div class="note-banner">
+    <strong>10만건 / 100만건 / 1000만건: 전체 실측 데이터</strong><br>
+    실측 재현 명령어: <code>./gradlew :apps:commerce-api:benchmarkTest --tests '*ProductApiPerformanceTest.measureApiCache_*'</code>
+</div>
+
+<!-- ============================================================ -->
+<!-- KPI Cards -->
+<!-- ============================================================ -->
+<div id="sec-kpi"></div>
+<div class="kpi-grid">
+    <div class="kpi ok">
+        <div class="label">Cache Hit 응답시간 (1000만건 실측)</div>
+        <div class="value">3.85~6.42ms</div>
+        <div class="context">hot-cache 단일 요청, 데이터 규모 영향 미미</div>
+    </div>
+    <div class="kpi ok">
+        <div class="label">Cold Cache Miss (1000만건 실측)</div>
+        <div class="value">44.58ms~3.88s</div>
+        <div class="context">대표 목록 cold-cache, 상세 miss는 6.32ms</div>
+    </div>
+    <div class="kpi ok">
+        <div class="label">1000만건 버스트 에러율</div>
+        <div class="value">0%</div>
+        <div class="context">AS-IS 목록: 90% (1000만건 실측)</div>
+    </div>
+    <div class="kpi ok">
+        <div class="label">1000만건 지속부하 QPS</div>
+        <div class="value">20.0</div>
+        <div class="context">avg 5.91~6.62ms, 에러 0%</div>
+    </div>
+    <div class="kpi ok">
+        <div class="label">Redis 장애 격리</div>
+        <div class="value">DB fallback</div>
+        <div class="context">try-catch, 가용성 100%</div>
+    </div>
+    <div class="kpi ok">
+        <div class="label">스탬피드 보호</div>
+        <div class="value">PER + Lock</div>
+        <div class="context">Jitter + PER + LocalCacheLock</div>
+    </div>
+</div>
+
+<!-- ============================================================ -->
+<!-- 1. Cache Hit vs Miss -->
+<!-- ============================================================ -->
+<h2 class="section-title" id="sec-hit-miss">1. Cache Hit vs Cache Miss 응답시간</h2>
+<p class="section-desc">
+    Cache Hit: Redis GET(ID 리스트) + MGET(상세) + JSON 역직렬화 (3.85~6.42ms, 1000만건 실측).<br>
+    Cache Miss: warmup 오염 없이 Redis를 비운 실제 cold-cache 측정. 대표 목록 worst-case는 3.88s까지 상승.<br>
+    왼쪽: 전체 목록 대표 UC, 오른쪽: 브랜드 필터 + 상세.
+</p>
+
+<div class="grid">
+    <div class="card">
+        <h3>전체 목록 — Cache Hit vs Cache Miss <span class="badge badge-ok">hot-cache 5~7ms</span></h3>
+        <div class="chart-container"><canvas id="hitMissAll"></canvas></div>
+    </div>
+    <div class="card">
+        <h3>브랜드 필터 + 상세 — Cache Hit vs Cache Miss</h3>
+        <div class="chart-container"><canvas id="hitMissBrand"></canvas></div>
+    </div>
+</div>
+
+<!-- ============================================================ -->
+<!-- 2. AS-IS vs TO-BE (Cache Hit) -->
+<!-- ============================================================ -->
+<h2 class="section-title" id="sec-as-vs-to-hit">2. AS-IS vs TO-BE 비교 (Cache Hit) <span class="badge badge-info">로그 스케일</span></h2>
+<p class="section-desc">
+    AS-IS는 `03-as-is-performance-measurement.md`의 Full Scan API 실측, TO-BE는 현재 cache hit 실측값이다.<br>
+    1000만건 목록 API 기준으로 hot-cache는 여전히 4.5~6.4ms이며, AS-IS 대비 최대 2,561배 개선된다.
+</p>
+
+<div class="grid">
+    <div class="card">
+        <h3>목록 API: AS-IS vs TO-BE Cache Hit <span class="badge badge-ok">최대 2,561배 개선 (1000만건)</span></h3>
+        <div class="chart-container tall"><canvas id="asVsToHitList"></canvas></div>
+    </div>
+    <div class="card">
+        <h3>상세 API: AS-IS vs TO-BE Cache Hit</h3>
+        <div class="chart-container tall"><canvas id="asVsToHitDetail"></canvas></div>
+    </div>
+</div>
+
+<div class="grid">
+    <div class="card full-width">
+        <h3>개선 배율 (AS-IS / TO-BE Cache Hit) — 데이터 규모별</h3>
+        <div class="chart-container"><canvas id="improvementRatio"></canvas></div>
+    </div>
+</div>
+
+<!-- ============================================================ -->
+<!-- 3. AS-IS vs TO-BE (Cache Miss) -->
+<!-- ============================================================ -->
+<h2 class="section-title" id="sec-as-vs-to-miss">3. AS-IS vs TO-BE 비교 (Cache Miss)</h2>
+<p class="section-desc">
+    Cache Miss는 이번에 warmup 오염을 제거한 실제 cold-cache 수치다.<br>
+    대표 UC 기준: 1000만건 전체+LATEST는 6,174ms → 1,166ms, 브랜드+LATEST는 6,643ms → 51.69ms로 개선된다.
+</p>
+
+<div class="grid">
+    <div class="card">
+        <h3>목록 API: AS-IS vs TO-BE Cache Miss</h3>
+        <div class="chart-container"><canvas id="asVsToMissList"></canvas></div>
+    </div>
+    <div class="card">
+        <h3>상세 API: AS-IS vs TO-BE Cache Miss</h3>
+        <div class="chart-container"><canvas id="asVsToMissDetail"></canvas></div>
+    </div>
+</div>
+
+<!-- ============================================================ -->
+<!-- 4. Error Rate -->
+<!-- ============================================================ -->
+<h2 class="section-title" id="sec-error">4. 에러율 비교 (AS-IS vs TO-BE)</h2>
+<p class="section-desc">
+    AS-IS는 100만건부터 커넥션 타임아웃으로 실패가 시작되고, 1000만건 목록은 90~95% 실패한다.<br>
+    TO-BE는 캐시가 DB 부하를 흡수하여 hit/miss 대표 시나리오 모두 에러 0%.<br>
+    왼쪽: 버스트 (100 concurrent), 오른쪽: 지속 부하 (20 RPS x 10초).
+</p>
+
+<div class="grid">
+    <div class="card">
+        <h3>버스트 에러율: AS-IS vs TO-BE (100 concurrent) <span class="badge badge-ok">TO-BE: 전규모 0%</span></h3>
+        <div class="chart-container"><canvas id="burstError"></canvas></div>
+    </div>
+    <div class="card">
+        <h3>지속 부하 에러율: AS-IS vs TO-BE (20 RPS x 10초)</h3>
+        <div class="chart-container"><canvas id="sustainedError"></canvas></div>
+    </div>
+</div>
+
+<div class="insight success">
+    <h3>에러율 핵심 개선</h3>
+    <ul>
+        <li><strong>1000만건 버스트</strong>: AS-IS 목록 90% 실패 → TO-BE <strong>0%</strong></li>
+        <li><strong>1000만건 지속 부하</strong>: AS-IS 목록 90~95% 실패, QPS 0.3~0.5 → TO-BE <strong>0%</strong>, QPS 20.0</li>
+        <li><strong>Cache Miss 시에도 0%</strong>: same-key miss는 LocalCacheLock + double-check로 단일 로드로 수렴</li>
+    </ul>
+</div>
+
+<!-- ============================================================ -->
+<!-- 5. QPS -->
+<!-- ============================================================ -->
+<h2 class="section-title" id="sec-qps">5. QPS 비교 (지속 부하)</h2>
+<p class="section-desc">
+    목표: 20 RPS. 빨간 점선이 목표선.<br>
+    AS-IS는 100만건부터 목표 미달, 1000만건에서는 0.3~0.5 QPS까지 하락. TO-BE는 모든 규모에서 20 RPS 달성.
+</p>
+
+<div class="grid">
+    <div class="card">
+        <h3>AS-IS 목록 QPS (20 RPS x 10초)</h3>
+        <div class="chart-container"><canvas id="qpsAsis"></canvas></div>
+    </div>
+    <div class="card">
+        <h3>TO-BE QPS (20 RPS x 10초) <span class="badge badge-ok">전규모 20.0 달성</span></h3>
+        <div class="chart-container"><canvas id="qpsTobe"></canvas></div>
+    </div>
+</div>
+
+<!-- ============================================================ -->
+<!-- 6. Cache Architecture -->
+<!-- ============================================================ -->
+<h2 class="section-title" id="sec-arch">6. 캐시 아키텍처</h2>
+<p class="section-desc">
+    2-Layer Cache-Aside + targeted write-through + Redis 장애 격리.
+</p>
+
+<div class="grid">
+    <div class="card full-width">
+        <h3>2-Layer Cache + 스탬피드 보호</h3>
+        <div class="arch-diagram"><span class="dim">// Cache Hit 경로 (95%+ 트래픽)</span>
+<span class="highlight">Client</span> --> <span class="highlight">Controller</span> --> <span class="highlight">Facade</span> --> <span class="accent">Redis GET</span> --> <span class="info">[HIT]</span> --> JSON Deserialize --> <span class="highlight">Response (~4-7ms)</span>
+
+<span class="dim">// Cache Miss 경로 (5%- 트래픽)</span>
+<span class="highlight">Client</span> --> <span class="highlight">Controller</span> --> <span class="highlight">Facade</span> --> <span class="accent">Redis GET</span> --> <span class="warn">[MISS]</span>
+    --> <span class="accent">LocalCacheLock</span> <span class="dim">(double-check: 다른 스레드가 이미 로드했는지 확인)</span>
+        --> <span class="highlight">Service</span> --> <span class="highlight">Repository</span> --> <span class="info">DB (Index Scan)</span>
+        --> <span class="accent">Redis SET</span> <span class="dim">(TTL + Jitter)</span>
+    --> <span class="highlight">Response (cold-cache, 조건별 6ms~3.88s)</span>
+
+<span class="dim">// Redis 장애 경로 (fallback)</span>
+<span class="highlight">Client</span> --> <span class="highlight">Controller</span> --> <span class="highlight">Facade</span> --> <span class="accent">Redis GET</span> --> <span class="warn">[ERROR]</span>
+    --> <span class="dim">try-catch: log & continue</span>
+    --> <span class="highlight">Service</span> --> <span class="highlight">Repository</span> --> <span class="info">DB (Index Scan)</span>
+    --> <span class="highlight">Response (DB fallback)</span> <span class="dim">(가용성 100% 유지)</span>
+
+<span class="dim">// PER (Probabilistic Early Refresh) - TTL 잔여 20% 구간</span>
+<span class="highlight">Client</span> --> <span class="highlight">Facade</span> --> <span class="accent">Redis GET</span> --> <span class="info">[HIT, TTL 잔여 &lt; 20%]</span>
+    --> <span class="warn">확률적 판단: 갱신 필요?</span>
+        --> <span class="info">[YES]</span> 비동기 DB 조회 + Redis SET <span class="dim">(기존 캐시 유지, stale 허용)</span>
+        --> <span class="info">[NO]</span>  기존 캐시 반환
+    --> <span class="highlight">Response (~4-7ms)</span> <span class="dim">(사용자는 항상 즉시 응답)</span>
+
+<span class="dim">// 캐시 무효화</span>
+<span class="highlight">상품 변경</span> --> <span class="accent">Targeted Write-Through</span>
+    --> 상세: <span class="accent">PUT product:v1:{id}</span> <span class="dim">(삭제만 DEL)</span>
+    --> 목록: <span class="accent">PUT products:ids:v1:{brandId|all}:{sort}:{page}:{size}</span> <span class="dim">(영향 키만 갱신)</span>
+    --> 좋아요: <span class="dim">상세만 갱신, ID 리스트는 TTL 자연 만료 허용</span></div>
+    </div>
+</div>
+
+<div class="grid">
+    <div class="card">
+        <h3>캐시 키 설계</h3>
+        <table class="ref-table">
+            <thead>
+            <tr><th>대상</th><th>키 패턴</th><th>TTL</th><th>무효화</th></tr>
+            </thead>
+            <tbody>
+            <tr>
+                <td><strong>상품 상세</strong></td>
+                <td><code>product:v1:{id}</code></td>
+                <td>2분 + jitter</td>
+                <td>수정/좋아요/재고/브랜드명 write-through, 삭제만 DEL</td>
+            </tr>
+            <tr>
+                <td><strong>ID 리스트</strong></td>
+                <td><code>products:ids:v1:{brandId|all}:{sort}:{page}:{size}</code></td>
+                <td>3분 + jitter</td>
+                <td>생성/삭제 targeted refresh, 가격은 PRICE_ASC만, 좋아요는 TTL 자연 만료</td>
+            </tr>
+            </tbody>
+        </table>
+    </div>
+    <div class="card">
+        <h3>스탬피드 보호 3계층</h3>
+        <table class="ref-table">
+            <thead>
+            <tr><th>계층</th><th>기법</th><th>역할</th></tr>
+            </thead>
+            <tbody>
+            <tr>
+                <td>1</td>
+                <td><strong>TTL Jitter (0~10%)</strong></td>
+                <td>동시 만료 방지 (시간 분산)</td>
+            </tr>
+            <tr>
+                <td>2</td>
+                <td><strong>PER (Early Refresh)</strong></td>
+                <td>만료 전 선제 갱신 (spike 제거)</td>
+            </tr>
+            <tr>
+                <td>3</td>
+                <td><strong>LocalCacheLock</strong></td>
+                <td>DB 동시 접근 1개로 제한</td>
+            </tr>
+            </tbody>
+        </table>
+    </div>
+</div>
+
+<!-- ============================================================ -->
+<!-- Conclusion -->
+<!-- ============================================================ -->
+<h2 class="section-title" id="sec-conclusion">결론</h2>
+
+<div class="insight success">
+    <h3>캐시 적용 효과 요약 (1000만건 실측 기준)</h3>
+    <ul>
+        <li><strong>Cache Hit 응답시간 3.85~6.42ms</strong>: 10만~1000만 전 구간에서 hot-cache 단일 요청은 거의 동일한 수준이다.</li>
+        <li><strong>1000만건 목록 API</strong>: Cache Hit <strong>4.53~6.42ms</strong>, Cache Miss는 조건에 따라 <strong>44.58ms~3,884.57ms</strong>다.</li>
+        <li><strong>1000만건 버스트</strong>: hit/miss 대표 시나리오 모두 에러율 0%, 다만 전체 목록 hit avg는 1.2초대까지 상승한다.</li>
+        <li><strong>1000만건 지속 부하</strong>: avg 5.91~6.62ms, 에러율 0%, QPS 20.0 달성 (20 RPS x 10초, 실측)</li>
+        <li><strong>DB 부하 95% 감소</strong>: 캐시 적중률 95% 달성 시, DB는 전체 트래픽의 5%만 처리</li>
+        <li><strong>Redis 장애 시에도 서비스 유지</strong>: try-catch fallback + 인덱스 최적화 DB 조회</li>
+    </ul>
+</div>
+
+<div class="insight warn">
+    <h3>운영 시 고려사항</h3>
+    <ul>
+        <li><strong>캐시 적중률 모니터링</strong>: 적중률 90% 미만 시 TTL/키 전략 재검토 필요</li>
+        <li><strong>cold-cache worst case</strong>: brandId 없는 `PRICE_ASC`는 1000만건에서 3.88초까지 상승하므로 steady-state 적중률 관리가 핵심</li>
+        <li><strong>갱신 타이밍</strong>: write-through는 현재 트랜잭션 내부 best-effort이며, `afterCommit` 이벤트 전환은 후속 TODO</li>
+        <li><strong>일관성 윈도우</strong>: 좋아요 변경 시 ID 리스트는 즉시 갱신하지 않으므로 최대 3분 stale이 가능</li>
+        <li><strong>Redis 메모리</strong>: maxmemory 설정 + eviction policy (allkeys-lru) 적용 권장</li>
+    </ul>
+</div>
+
+<p class="legend-note">
+    10만건 / 100만건 / 1000만건: 전체 실측 데이터 &middot;
+    TestContainers MySQL 8.0 + Redis &middot;
+    상대적 비교(AS-IS vs TO-BE, Cache Hit vs Miss)가 핵심 지표
+</p>
+
+<!-- ============================================================ -->
+<!-- CHARTS -->
+<!-- ============================================================ -->
+<script>
+// 0 값 바에 "0" 라벨 표시 플러그인
+Chart.register({
+    id: 'zeroLabel',
+    afterDatasetsDraw(chart) {
+        const { ctx } = chart;
+        chart.data.datasets.forEach((dataset, di) => {
+            if (dataset.type === 'line') return;
+            const meta = chart.getDatasetMeta(di);
+            if (meta.hidden) return;
+            meta.data.forEach((bar, i) => {
+                const val = dataset.data[i];
+                if (val !== 0) return;
+                ctx.save();
+                ctx.fillStyle = dataset.borderColor || '#94a3b8';
+                ctx.font = 'bold 11px sans-serif';
+                ctx.textAlign = 'center';
+                ctx.textBaseline = 'bottom';
+                ctx.fillText('0', bar.x, bar.y - 4);
+                ctx.restore();
+            });
+        });
+    }
+});
+
+const C = {
+    orange: '#f97316', orangeA: '#f9731640',
+    red:    '#ef4444', redA:    '#ef444440',
+    blue:   '#3b82f6', blueA:   '#3b82f640',
+    green:  '#22c55e', greenA:  '#22c55e40',
+    purple: '#a855f7', purpleA: '#a855f740',
+    cyan:   '#06b6d4', cyanA:   '#06b6d440',
+    yellow: '#eab308', yellowA: '#eab30840',
+    gray:   '#64748b', grayA:   '#64748b40',
+};
+
+const SCALES = ['10만건', '100만건', '1000만건'];
+
+function opts(yLabel, extra = {}) {
+    return {
+        responsive: true,
+        maintainAspectRatio: false,
+        plugins: {
+            legend: { labels: { color: '#94a3b8', font: { size: 11 } } },
+            tooltip: {
+                callbacks: {
+                    label: ctx => `${ctx.dataset.label}: ${ctx.parsed.y != null ? ctx.parsed.y.toLocaleString() : ctx.parsed.x.toLocaleString()}`
+                }
+            }
+        },
+        scales: {
+            x: { ticks: { color: '#94a3b8' }, grid: { color: '#1e293b' } },
+            y: {
+                ticks: { color: '#94a3b8' },
+                grid: { color: '#334155' },
+                title: { display: true, text: yLabel, color: '#64748b' },
+                ...extra
+            }
+        }
+    };
+}
+
+function optsLog(yLabel) {
+    return opts(yLabel, { type: 'logarithmic' });
+}
+
+function optsFixed(yLabel, max) {
+    return opts(yLabel, { min: 0, max });
+}
+
+function ds(label, data, color, colorA, extra = {}) {
+    return { label, data, backgroundColor: colorA, borderColor: color, borderWidth: 2, ...extra };
+}
+function dsLine(label, data, color, extra = {}) {
+    return { label, data, borderColor: color, backgroundColor: color + '30', fill: false, tension: 0.3, type: 'line', pointRadius: 4, ...extra };
+}
+
+// ============================================================
+// 1. Cache Hit vs Miss (실측: 10만건, 100만건, 1000만건)
+// ============================================================
+
+// 전체 목록 Hit vs Miss
+new Chart(document.getElementById('hitMissAll'), {
+    type: 'bar',
+    data: {
+        labels: SCALES,
+        datasets: [
+            ds('Cache Miss: 전체+최신순',    [39.85, 142.18, 1166.02], C.orange, C.orangeA),
+            ds('Cache Hit: 전체+최신순',     [5.99, 6.10, 5.15],      C.green,  C.greenA),
+            ds('Cache Miss: 전체+인기순',    [32.85, 122.44, 1160.68], C.blue,   C.blueA),
+            ds('Cache Hit: 전체+인기순',     [7.41, 5.67, 5.17],      C.cyan,   C.cyanA),
+        ]
+    },
+    options: opts('avg 응답시간 (ms)')
+});
+
+// 브랜드+상세 Hit vs Miss
+new Chart(document.getElementById('hitMissBrand'), {
+    type: 'bar',
+    data: {
+        labels: SCALES,
+        datasets: [
+            ds('Cache Miss: 브랜드+최신순', [25.41, 22.51, 51.69], C.orange, C.orangeA),
+            ds('Cache Hit: 브랜드+최신순',  [7.17, 6.45, 4.85],    C.green,  C.greenA),
+            ds('Cache Miss: 상세 (PK)',     [9.50, 6.41, 6.32],    C.blue,   C.blueA),
+            ds('Cache Hit: 상세 (PK)',      [4.98, 4.77, 3.85],    C.cyan,   C.cyanA),
+        ]
+    },
+    options: opts('avg 응답시간 (ms)')
+});
+
+// ============================================================
+// 2. AS-IS vs TO-BE (Cache Hit) — Logarithmic
+// ============================================================
+
+// 목록 API
+new Chart(document.getElementById('asVsToHitList'), {
+    type: 'bar',
+    data: {
+        labels: SCALES,
+        datasets: [
+            ds('AS-IS: 전체+최신순',          [60.18, 516.31, 6174.44],   C.red,    C.redA),
+            ds('TO-BE Hit: 전체+최신순',      [5.99, 6.10, 5.15],         C.green,  C.greenA),
+            ds('AS-IS: 브랜드+인기순 (최악)',  [48.07, 482.24, 11604.48],  C.orange, C.orangeA),
+            ds('TO-BE Hit: 브랜드+인기순',    [5.76, 4.66, 4.53],         C.cyan,   C.cyanA),
+        ]
+    },
+    options: optsLog('avg 응답시간 (ms) — 로그 스케일')
+});
+
+// 상세 API
+new Chart(document.getElementById('asVsToHitDetail'), {
+    type: 'bar',
+    data: {
+        labels: SCALES,
+        datasets: [
+            ds('AS-IS: 상세 (PK lookup)',   [4.58, 11.41, 18.27],  C.red,   C.redA),
+            ds('TO-BE Hit: 상세',           [4.98, 4.77, 3.85],    C.green, C.greenA),
+        ]
+    },
+    options: optsLog('avg 응답시간 (ms) — 로그 스케일')
+});
+
+// 개선 배율
+new Chart(document.getElementById('improvementRatio'), {
+    type: 'bar',
+    data: {
+        labels: SCALES,
+        datasets: [
+            ds('전체+최신순',       [10.05, 84.64, 1198.92], C.green,  C.greenA),
+            ds('브랜드+최신순',     [6.91, 77.85, 1370.85],  C.cyan,   C.cyanA),
+            ds('브랜드+인기순',     [8.35, 103.49, 2561.70], C.blue,   C.blueA),
+            ds('상세 (PK lookup)',  [0.92, 2.39, 4.75],      C.purple, C.purpleA),
+        ]
+    },
+    options: optsLog('개선 배율 (AS-IS / TO-BE) — 로그 스케일')
+});
+
+// ============================================================
+// 3. AS-IS vs TO-BE (Cache Miss)
+// ============================================================
+
+// 목록
+new Chart(document.getElementById('asVsToMissList'), {
+    type: 'bar',
+    data: {
+        labels: SCALES,
+        datasets: [
+            ds('AS-IS: 전체+최신순',         [60.18, 516.31, 6174.44], C.red,    C.redA),
+            ds('TO-BE Miss: 전체+최신순',    [39.85, 142.18, 1166.02], C.orange, C.orangeA),
+            ds('AS-IS: 브랜드+최신순',       [49.52, 502.12, 6643.62], C.purple, C.purpleA),
+            ds('TO-BE Miss: 브랜드+최신순',  [25.41, 22.51, 51.69],    C.green,  C.greenA),
+        ]
+    },
+    options: opts('avg 응답시간 (ms)')
+});
+
+// 상세
+new Chart(document.getElementById('asVsToMissDetail'), {
+    type: 'bar',
+    data: {
+        labels: SCALES,
+        datasets: [
+            ds('AS-IS: 상세',          [4.58, 11.41, 18.27],  C.red,   C.redA),
+            ds('TO-BE Miss: 상세',     [9.50, 6.41, 6.32],    C.green, C.greenA),
+        ]
+    },
+    options: opts('avg 응답시간 (ms)')
+});
+
+// ============================================================
+// 4. Error Rate — AS-IS vs TO-BE
+// ============================================================
+
+// 버스트 에러율
+new Chart(document.getElementById('burstError'), {
+    type: 'bar',
+    data: {
+        labels: SCALES,
+        datasets: [
+            ds('AS-IS: 전체+최신순',         [0, 80, 90], C.red,    C.redA),
+            ds('AS-IS: 브랜드+최신순',       [0, 71, 90], C.orange, C.orangeA),
+            ds('TO-BE Hit: 모든 UC',          [0, 0, 0],  C.green,  C.greenA),
+            ds('TO-BE Miss (스탬피드 보호)',   [0, 0, 0],  C.cyan,   C.cyanA),
+        ]
+    },
+    options: optsFixed('에러율 (%)', 100)
+});
+
+// 지속 부하 에러율
+new Chart(document.getElementById('sustainedError'), {
+    type: 'bar',
+    data: {
+        labels: SCALES,
+        datasets: [
+            ds('AS-IS: 전체+최신순',      [0, 37, 95],      C.red,    C.redA),
+            ds('AS-IS: 브랜드+최신순',    [0, 59.5, 90.5],  C.orange, C.orangeA),
+            ds('TO-BE: 모든 UC (Hit)',    [0, 0, 0],        C.green,  C.greenA),
+        ]
+    },
+    options: optsFixed('에러율 (%)', 100)
+});
+
+// ============================================================
+// 5. QPS — AS-IS vs TO-BE
+// ============================================================
+
+// AS-IS QPS
+new Chart(document.getElementById('qpsAsis'), {
+    type: 'bar',
+    data: {
+        labels: SCALES,
+        datasets: [
+            ds('전체+최신순',    [20.0, 5.9, 0.3], C.orange, C.orangeA),
+            ds('전체+인기순',    [20.0, 5.3, 0.5], C.blue,   C.blueA),
+            ds('브랜드+최신순',  [20.0, 3.7, 0.5], C.green,  C.greenA),
+            dsLine('목표 20 RPS', [20, 20, 20], C.red, { borderDash: [8,4], pointRadius: 0, borderWidth: 2 }),
+        ]
+    },
+    options: optsFixed('실제 QPS (건/초)', 22)
+});
+
+// TO-BE QPS
+new Chart(document.getElementById('qpsTobe'), {
+    type: 'bar',
+    data: {
+        labels: SCALES,
+        datasets: [
+            ds('목록: 전체+최신순',    [20.0, 20.0, 20.0], C.green,  C.greenA),
+            ds('목록: 브랜드+최신순',  [20.0, 20.0, 20.0], C.cyan,   C.cyanA),
+            ds('상세: PK lookup',      [20.0, 20.0, 20.0], C.blue,   C.blueA),
+            dsLine('목표 20 RPS', [20, 20, 20], C.red, { borderDash: [8,4], pointRadius: 0, borderWidth: 2 }),
+        ]
+    },
+    options: optsFixed('실제 QPS (건/초)', 22)
+});
+</script>
+
+</body>
+</html>
diff --git a/round5-docs/06-2layer-cache-implementation-design.md b/round5-docs/06-2layer-cache-implementation-design.md
new file mode 100644
index 000000000..edb284419
--- /dev/null
+++ b/round5-docs/06-2layer-cache-implementation-design.md
@@ -0,0 +1,527 @@
+# 캐시 2계층 아키텍처 구현 설계
+
+> **문서 상태**
+> - 성격: 현재 구현에 가장 가까운 설계 문서
+> - 전환기 TODO 항목 모두 완료 (`evictByPattern()` 제거, old key 정리)
+> - 현재 구현 판단은 실제 코드 우선
+
+## 1. 현재 상태 → 목표 상태
+
+| 항목 | 현재 (AS-IS) | 목표 (TO-BE) |
+|------|-------------|-------------|
+| 목록 캐시 키 | `products:list:{brand\|all}:{sort}:{page}:{size}` | `products:ids:v1:{brand\|all}:{sort}:{page}:{size}` |
+| 목록 캐시 값 | `ProductPageOutDto` (전체 DTO) | `IdListCacheEntry` (ids + totalElements) |
+| 상세 캐시 키 | `product:{productId}` | `product:v1:{productId}` |
+| 상세 캐시 값 | `ProductDetailOutDto` | `ProductCacheDto` (PLP+PDP 공용) |
+| TTL (목록) | 5분 | 3분 |
+| TTL (상세) | 10분 | 2분 |
+| 쓰기 시 동작 | `evictByPattern("products:list:*")` + `evict("product:"+id)` | write-through (targeted refresh) |
+| PLP 조회 흐름 | 캐시에서 전체 DTO 반환 | ID 리스트 → MGET → partial miss fill |
+| 캐시 적용 조건 | 무제한 | `page < MAX_CACHEABLE_PAGE && size == DEFAULT_PAGE_SIZE` |
+| 정렬 보조 키 | 없음 | `id` (tie-breaker) |
+
+---
+
+## 2. 신규/변경 파일 목록
+
+### 2.1 신규 생성
+
+| 파일 | 위치 | 역할 |
+|------|------|------|
+| `ProductCacheConstants` | `infrastructure/cache/` | 캐시 키 접두사, 버전 상수, DEFAULT_PAGE_SIZE |
+| `ProductCacheDto` | `infrastructure/cache/` | PLP+PDP 공용 캐시 DTO (상세 캐시 값) |
+| `IdListCacheEntry` | `infrastructure/cache/` | ID 리스트 캐시 값 record (ids, totalElements) |
+
+### 2.2 변경 대상
+
+| 파일 | 변경 내용 |
+|------|----------|
+| `ProductCacheManager` | write-through 메서드 추가, MGET 추가 |
+| `ProductQueryService` | 2계층 조회 흐름 (ID 리스트 → MGET), cacheable guard, TTL 변경, `findActiveIdsByBrandId()` 추가 |
+| `ProductCommandService` | evict → write-through 호출로 전환 |
+| `ProductCommandFacade` | write-through 호출 위치 조정 (read model 동기화 이후) |
+| `BrandCommandFacade` | 브랜드명 수정 시 상품 상세 캐시 write-through 추가 |
+| `ProductQuerydslRepository` | tie-breaker 추가, `searchProductIds()` 추가, `findProductCacheDtosByIds()` bulk projection 추가 |
+| `ProductReadModelJpaRepository` | `findActiveIdsByBrandId()` 추가 |
+| `ProductReadModelRepository` | `findActiveIdsByBrandId()` 인터페이스 추가 |
+| `ProductReadModelRepositoryImpl` | `findActiveIdsByBrandId()` 구현 추가 |
+
+---
+
+## 3. 상세 설계
+
+### 3.1 ProductCacheConstants
+
+```java
+public final class ProductCacheConstants {
+    public static final String CACHE_VERSION = "v1";
+    public static final String DETAIL_KEY_PREFIX = "product:" + CACHE_VERSION + ":";
+    public static final String ID_LIST_KEY_PREFIX = "products:ids:" + CACHE_VERSION + ":";
+    public static final int DEFAULT_PAGE_SIZE = 20;
+    public static final int MAX_CACHEABLE_PAGE = 2;
+    public static final Duration ID_LIST_TTL = Duration.ofMinutes(3);
+    public static final Duration DETAIL_TTL = Duration.ofMinutes(2);
+}
+```
+
+### 3.2 ProductCacheDto
+
+PLP와 PDP에서 공용으로 사용하는 캐시 DTO. Read Model에서 직접 projection.
+
+```java
+public record ProductCacheDto(
+    Long id, Long brandId, String brandName, String name,
+    BigDecimal price, Long stock, String description, Long likeCount
+) {
+    // PLP 응답용 변환
+    public ProductOutDto toProductOutDto() { ... }
+    // PDP 응답용 변환
+    public ProductDetailOutDto toProductDetailOutDto() { ... }
+}
+```
+
+### 3.3 IdListCacheEntry
+
+```java
+public record IdListCacheEntry(List<Long> ids, long totalElements) {}
+```
+
+### 3.4 ProductCacheManager 신규 메서드
+
+CacheManager는 Redis 전용 유틸로서의 책임만 유지. DB 조회는 Supplier로 위임.
+
+```java
+// 1. 상품 상세 캐시 write-through
+public void refreshProductDetail(Long productId, Supplier<ProductCacheDto> loader) {
+    ProductCacheDto dto = loader.get();
+    put(DETAIL_KEY_PREFIX + productId, dto, DETAIL_TTL);
+}
+
+// 2. ID 리스트 캐시 write-through (단건, Supplier 기반)
+public void refreshIdList(String cacheKey, Supplier<IdListCacheEntry> loader) {
+    IdListCacheEntry entry = loader.get();
+    put(cacheKey, entry, ID_LIST_TTL);
+}
+
+// 3. 상품 상세 캐시 삭제 (상품 삭제 시 예외적 사용)
+public void deleteProductDetail(Long productId) {
+    evict(DETAIL_KEY_PREFIX + productId);
+}
+
+// 4. MGET (여러 상품 상세 일괄 조회)
+public List<ProductCacheDto> mgetProductDetails(List<Long> productIds) {
+    List<String> keys = productIds.stream()
+        .map(id -> DETAIL_KEY_PREFIX + id)
+        .toList();
+    // RedisTemplate multiGet → 역직렬화 → null 포함 리스트 반환
+}
+```
+
+> **설계 변경 (Codex 피드백 반영)**: `refreshIdLists(productId, brandId, RefreshType)` 메서드 제거.
+> CacheManager가 DB 조회와 트리거 매핑 로직을 갖는 것은 책임 불일치.
+> ID list write-through 호출은 Service/Facade에서 직접 수행하되,
+> 좋아요/재고 같은 고빈도 경로에서는 ID list write-through를 하지 않는다 (아래 3.6 참조).
+
+### 3.5 ProductQueryService 2계층 조회 흐름
+
+```java
+// 사용자 상품 목록 검색 (2계층)
+@Transactional(readOnly = true)
+public ProductPageOutDto searchProducts(Long brandId, ProductSortType sortType, int page, int size) {
+
+    // 캐시 적용 조건 확인
+    if (!isCacheable(page, size)) {
+        // 캐시 미적용 — DB 직접 조회
+        return searchFromDb(brandId, sortType, page, size);
+    }
+
+    // 1. ID 리스트 캐시 조회 (cache-aside)
+    String idListKey = buildIdListCacheKey(brandId, sortType, page, size);
+    IdListCacheEntry idList = productCacheManager.getOrLoad(
+        idListKey, IdListCacheEntry.class, ID_LIST_TTL,
+        () -> loadIdListFromDb(brandId, sortType, page, size)
+    );
+
+    // 2. MGET 상세 캐시
+    List<ProductCacheDto> cached = productCacheManager.mgetProductDetails(idList.ids());
+
+    // 3. partial miss 처리
+    List<Long> missedIds = extractMissedIds(idList.ids(), cached);
+    if (!missedIds.isEmpty()) {
+        List<ProductCacheDto> fromDb = loadAndCacheDetails(missedIds);
+        cached = mergeInOrder(idList.ids(), cached, fromDb);
+    }
+
+    // 4. dangling ID 방어 (null skip)
+    List<ProductOutDto> content = cached.stream()
+        .filter(Objects::nonNull)
+        .map(ProductCacheDto::toProductOutDto)
+        .toList();
+
+    return new ProductPageOutDto(content, page, size, idList.totalElements());
+}
+
+private boolean isCacheable(int page, int size) {
+    return page < MAX_CACHEABLE_PAGE && size == DEFAULT_PAGE_SIZE;
+}
+```
+
+#### loadAndCacheDetails — bulk projection (Read Model 기반)
+
+```java
+private List<ProductCacheDto> loadAndCacheDetails(List<Long> missedIds) {
+    // ProductQuerydslRepository에서 Read Model bulk projection
+    List<ProductCacheDto> dtos = productQueryPort.findProductCacheDtosByIds(missedIds);
+    // 각 dto를 상세 캐시에 PUT
+    for (ProductCacheDto dto : dtos) {
+        productCacheManager.put(DETAIL_KEY_PREFIX + dto.id(), dto, DETAIL_TTL);
+    }
+    return dtos;
+}
+```
+
+#### findActiveIdsByBrandId (브랜드명 write-through용)
+
+```java
+// ProductQueryService에 추가 — Facade가 호출
+@Transactional(readOnly = true)
+public List<Long> findActiveIdsByBrandId(Long brandId) {
+    return productReadModelRepository.findActiveIdsByBrandId(brandId);
+}
+```
+
+> **설계 변경 (Codex 피드백 반영)**: `findProductIdsByBrandId()` → `findActiveIdsByBrandId()`로 명칭 변경.
+> 위치: `ProductCommandService`가 아닌 `ProductQueryService` (순수 read 메서드).
+> Repository: `ProductReadModelRepository` 인터페이스에 추가 → `ProductReadModelRepositoryImpl`에서 JPA 위임.
+
+### 3.6 ProductCommandService write-through 전환
+
+#### 트리거별 캐시 갱신 범위
+
+| 트리거 | 상세 캐시 | ID 리스트 캐시 | 근거 |
+|--------|----------|--------------|------|
+| 좋아요 ±1 | write-through | **갱신 안 함** (TTL 3분 자연 만료) | ±1로 순서 변동 극히 드묾. 고빈도 트리거에서 12 SQL/건은 비용 과다 |
+| 재고 차감 | write-through | **갱신 안 함** (정렬 무관) | 재고는 정렬 기준이 아님 |
+| 가격 수정 | write-through | write-through (PRICE_ASC × 6키) | 가격 변경은 저빈도, 순서 변동 직접적 |
+| 상품 생성 | write-through | write-through (ALL × 18키) | 새 상품이 목록에 반영돼야 함 |
+| 상품 삭제 | evict (삭제된 상품) | write-through (ALL × 18키) | 삭제 상품이 목록에서 제거돼야 함 |
+| 브랜드명 수정 | write-through (해당 브랜드 전체) | 없음 (ID에 brandName 미포함) | 극히 저빈도, 상세만 영향 |
+
+> **설계 변경 (Codex 피드백 반영)**: 좋아요/재고 경로에서 ID list write-through 제거.
+> - 좋아요 1건당 기존 설계: 12 SQL (LIKES_DESC × 2 × 3pages × 2queries) → evictByPattern보다 비용 큼
+> - 좋아요 ±1이 순서를 뒤집는 확률은 극히 낮고, TTL 3분이면 충분히 수렴
+> - 재고는 정렬 기준 자체가 아니므로 ID list 영향 없음
+
+```java
+// 좋아요 증가 — 상세 캐시만 write-through (ID list 갱신 안 함)
+@Transactional
+public void increaseLikeCount(Long productId) {
+    readModelRepository.increaseLikeCount(productId);
+
+    // write-through: 상세 캐시만 (ID 리스트는 TTL 자연 만료)
+    productCacheManager.refreshProductDetail(productId, () -> loadCacheDto(productId));
+}
+
+// 좋아요 감소 — 동일
+@Transactional
+public void decreaseLikeCount(Long productId) {
+    readModelRepository.decreaseLikeCount(productId);
+
+    // write-through: 상세 캐시만
+    productCacheManager.refreshProductDetail(productId, () -> loadCacheDto(productId));
+}
+
+// 재고 차감 — 상세 캐시만 (재고는 정렬 무관)
+@Transactional
+public void decreaseStock(Long productId, Long quantity) {
+    Product product = productQueryRepository.findActiveByIdForUpdate(productId)...;
+    product.decreaseStock(quantity);
+    productCommandRepository.save(product);
+    readModelRepository.updateStock(productId, product.getStock().value());
+
+    // write-through: 상세 캐시만
+    productCacheManager.refreshProductDetail(productId, () -> loadCacheDto(productId));
+}
+```
+
+#### 가격 변동 시 ID list write-through (저빈도, Facade에서 호출)
+
+상품 수정(가격 변경 포함)은 `ProductCommandFacade`에서 수행하며,
+read model 동기화 이후에 캐시 갱신을 호출한다.
+
+```java
+// ProductCommandFacade.updateProduct()
+@Transactional
+public AdminProductDetailOutDto updateProduct(Long id, AdminProductUpdateInDto inDto) {
+    Product product = productQueryService.findActiveById(id);
+    Product updatedProduct = productCommandService.updateProduct(product, inDto);
+
+    Brand brand = brandQueryService.getBrandById(product.getBrandId());
+    productCommandService.syncReadModel(updatedProduct, brand.getName().value());
+
+    // write-through: 상세 캐시
+    productCacheManager.refreshProductDetail(id, () -> loadCacheDto(id));
+    // write-through: ID 리스트 (PRICE_ASC 정렬 영향)
+    refreshIdListsForProduct(product.getBrandId(), ProductSortType.PRICE_ASC);
+
+    return AdminProductDetailOutDto.from(updatedProduct, brand.getName().value());
+}
+
+// 상품 생성
+@Transactional
+public AdminProductDetailOutDto createProduct(AdminProductCreateInDto inDto) {
+    Brand brand = brandQueryService.getBrandById(inDto.brandId());
+    Product savedProduct = productCommandService.createProduct(inDto);
+    productCommandService.syncReadModel(savedProduct, brand.getName().value());
+
+    // write-through: 상세 캐시 + 모든 정렬 ID 리스트
+    productCacheManager.refreshProductDetail(savedProduct.getId(), () -> loadCacheDto(savedProduct.getId()));
+    refreshIdListsForAllSorts(savedProduct.getBrandId());
+
+    return AdminProductDetailOutDto.from(savedProduct, brand.getName().value());
+}
+
+// 상품 삭제
+@Transactional
+public void deleteProduct(Long id) {
+    Product product = productQueryService.findActiveById(id);
+    productCommandService.deleteProduct(product);
+
+    // 상세 캐시: evict (삭제된 상품)
+    productCacheManager.deleteProductDetail(id);
+    // ID 리스트: write-through (모든 정렬)
+    refreshIdListsForAllSorts(product.getBrandId());
+}
+
+// --- private helpers ---
+
+// 특정 정렬의 ID 리스트 write-through
+private void refreshIdListsForProduct(Long brandId, ProductSortType sortType) {
+    for (int page = 0; page < MAX_CACHEABLE_PAGE; page++) {
+        // brandId 조건 + all 조건
+        String brandKey = buildIdListCacheKey(brandId, sortType, page, DEFAULT_PAGE_SIZE);
+        String allKey = buildIdListCacheKey(null, sortType, page, DEFAULT_PAGE_SIZE);
+        productCacheManager.refreshIdList(brandKey, () -> loadIdListFromDb(brandId, sortType, page, DEFAULT_PAGE_SIZE));
+        productCacheManager.refreshIdList(allKey, () -> loadIdListFromDb(null, sortType, page, DEFAULT_PAGE_SIZE));
+    }
+}
+
+// 모든 정렬의 ID 리스트 write-through
+private void refreshIdListsForAllSorts(Long brandId) {
+    for (ProductSortType sort : ProductSortType.values()) {
+        refreshIdListsForProduct(brandId, sort);
+    }
+}
+```
+
+> **설계 변경 (Codex 피드백 반영)**:
+> 1. ID list write-through 호출을 Facade로 이동 (read model 동기화 이후에 캐시 갱신 보장)
+> 2. `loadCacheDto()` 도 Facade의 private helper로 — Read Model에서 projection 1회 조회
+> 3. `List.of(null, brandId)` NPE 제거 — 명시적으로 brandKey/allKey 분리 호출
+
+#### loadCacheDto — Read Model projection
+
+```java
+// ProductCommandFacade (또는 ProductQueryService)의 private helper
+private ProductCacheDto loadCacheDto(Long productId) {
+    // Read Model에서 직접 ProductCacheDto projection
+    return productQueryPort.findProductCacheDtoById(productId);
+}
+```
+
+> **설계 변경 (Codex 피드백 반영)**: `loadCacheDto()`의 데이터 소스를 Product + BrandService 조합이 아닌
+> `product_read_model` 테이블에서 직접 projection. brandName, description이 이미 비정규화되어 있으므로
+> 1회 조회로 완성 가능. 이를 위해 `ProductQueryPort`에 `findProductCacheDtoById()` 추가.
+
+### 3.7 BrandCommandFacade 브랜드명 write-through
+
+```java
+@Transactional
+public AdminBrandDetailOutDto updateBrand(Long id, AdminBrandUpdateInDto inDto) {
+    Brand brand = brandQueryService.getBrandById(id);
+    Brand updatedBrand = brandCommandService.updateBrand(brand, inDto);
+
+    // Read Model 브랜드명 동기화
+    productCommandService.syncBrandNameInReadModel(id, updatedBrand.getName().value());
+
+    // 상품 상세 캐시 write-through (해당 브랜드의 전체 상품)
+    List<Long> productIds = productQueryService.findActiveIdsByBrandId(id);
+    for (Long productId : productIds) {
+        productCacheManager.refreshProductDetail(productId, () -> loadCacheDto(productId));
+    }
+
+    return AdminBrandDetailOutDto.from(updatedBrand);
+}
+```
+
+> **설계 변경 (Codex 피드백 반영)**: `productCommandService.findProductIdsByBrandId()` →
+> `productQueryService.findActiveIdsByBrandId()` (순수 read 메서드는 QueryService에 배치)
+
+### 3.8 QueryDSL tie-breaker
+
+```java
+private OrderSpecifier<?>[] getOrderSpecifiers(ProductSortType sortType) {
+    OrderSpecifier<?> primary = switch (sortType) {
+        case LATEST -> readModel.createdAt.desc();
+        case PRICE_ASC -> readModel.price.asc();
+        case LIKES_DESC -> readModel.likeCount.desc();
+    };
+    // tie-breaker: 동률 시 id 내림차순 (최신 상품 우선)
+    OrderSpecifier<?> secondary = readModel.id.desc();
+    return new OrderSpecifier<?>[]{ primary, secondary };
+}
+```
+
+### 3.9 ProductReadModelJpaRepository 추가 메서드
+
+```java
+// 브랜드 ID로 활성 상품 ID 목록 조회 (브랜드명 write-through용)
+@Query("SELECT e.id FROM ProductReadModelEntity e WHERE e.brandId = :brandId AND e.deletedAt IS NULL")
+List<Long> findActiveIdsByBrandId(@Param("brandId") Long brandId);
+```
+
+### 3.10 ProductQueryPort / QuerydslRepository 추가 메서드
+
+```java
+// ProductQueryPort 인터페이스에 추가
+ProductCacheDto findProductCacheDtoById(Long productId);
+List<ProductCacheDto> findProductCacheDtosByIds(List<Long> productIds);
+
+// ProductQuerydslRepository — Read Model에서 ProductCacheDto projection
+public ProductCacheDto findProductCacheDtoById(Long productId) {
+    return queryFactory.select(Projections.constructor(ProductCacheDto.class,
+            readModel.id, readModel.brandId, readModel.brandName, readModel.name,
+            readModel.price, readModel.stock, readModel.description, readModel.likeCount))
+        .from(readModel)
+        .where(readModel.id.eq(productId).and(readModel.deletedAt.isNull()))
+        .fetchOne();
+}
+
+public List<ProductCacheDto> findProductCacheDtosByIds(List<Long> productIds) {
+    return queryFactory.select(Projections.constructor(ProductCacheDto.class,
+            readModel.id, readModel.brandId, readModel.brandName, readModel.name,
+            readModel.price, readModel.stock, readModel.description, readModel.likeCount))
+        .from(readModel)
+        .where(readModel.id.in(productIds).and(readModel.deletedAt.isNull()))
+        .fetch();
+}
+```
+
+---
+
+## 4. ID 리스트 조회 쿼리
+
+write-through 시 ID 리스트를 재생성하려면 "해당 정렬 + 필터 조건으로 page N의 ID 목록"을 조회해야 한다.
+
+```java
+// ProductQuerydslRepository에 추가
+public IdListCacheEntry searchProductIds(ProductSearchCriteria criteria, PageCriteria pageCriteria) {
+
+    QProductReadModelEntity readModel = QProductReadModelEntity.productReadModelEntity;
+
+    // 활성 상품 필터
+    BooleanExpression where = readModel.deletedAt.isNull();
+    if (criteria.brandId() != null) {
+        where = where.and(readModel.brandId.eq(criteria.brandId()));
+    }
+
+    // 총 개수
+    long total = queryFactory.select(readModel.id)
+        .from(readModel)
+        .where(where)
+        .fetchCount();
+
+    // ID 목록 (정렬 + 페이지네이션)
+    List<Long> ids = queryFactory.select(readModel.id)
+        .from(readModel)
+        .where(where)
+        .orderBy(getOrderSpecifiers(criteria.sortType()))
+        .offset((long) pageCriteria.page() * pageCriteria.size())
+        .limit(pageCriteria.size())
+        .fetch();
+
+    return new IdListCacheEntry(ids, total);
+}
+```
+
+---
+
+## 5. 구현 Phase
+
+### Phase 1: Foundation (인프라 변경)
+1. `ProductCacheConstants`, `ProductCacheDto`, `IdListCacheEntry` 생성
+2. `ProductCacheManager`에 신규 메서드 추가 (refreshProductDetail, refreshIdList, mgetProductDetails, deleteProductDetail)
+3. `ProductReadModelRepository` 인터페이스 + 구현체에 `findActiveIdsByBrandId()` 추가
+4. `ProductReadModelJpaRepository`에 `findActiveIdsByBrandId()` 추가
+5. `ProductQueryPort`에 `findProductCacheDtoById()`, `findProductCacheDtosByIds()` 추가
+6. `ProductQuerydslRepository`에 tie-breaker 추가 + `searchProductIds()` + `findProductCacheDto*` 추가
+7. 기존 기능에 영향 없음 — 새 코드만 추가
+
+### Phase 2: Write path (write-through 전환)
+1. `ProductCommandService`의 좋아요/재고 메서드: evict → 상세 캐시 write-through로 교체 (ID list 갱신 안 함)
+2. `ProductCommandFacade`의 생성/수정/삭제: read model 동기화 이후 write-through 호출
+3. `BrandCommandFacade.updateBrand()`에 상품 상세 캐시 write-through 추가
+4. `ProductQueryService`에 `findActiveIdsByBrandId()` 추가
+5. 기존 `evictProductDetailCache()` 메서드 → `deleteProductDetail()`로 교체
+6. ~~**전환기 병행**: write-through와 함께 기존 키 evict 병행~~ → 전환 완료, old key 병행 불필요
+
+### Phase 3: Read path (2계층 조회)
+1. `ProductQueryService.searchProducts()` 전면 교체 (ID 리스트 → MGET 흐름)
+2. cacheable guard 적용 (`page < MAX_CACHEABLE_PAGE && size == DEFAULT_PAGE_SIZE`)
+3. `ProductQueryFacade` 상세 조회 시 `ProductCacheDto` 사용
+4. TTL 변경 (list 3분, detail 2분)
+5. 기존 `products:list:*` 캐시 키 → `products:ids:v1:*` 전환
+6. 기존 `product:{id}` 캐시 키 → `product:v1:{id}` 전환
+7. ~~Phase 2의 old key evict 병행 코드 제거~~ → 병행 코드 없이 직접 전환 완료
+8. `evictByPattern()` 메서드 ProductCacheManager에서 제거 완료
+
+---
+
+## 6. 테스트 전략
+
+### Phase 1 테스트
+- `ProductCacheDto` 변환 테스트 (toProductOutDto, toProductDetailOutDto)
+- `ProductQuerydslRepository.searchProductIds()` 통합 테스트
+- `ProductQuerydslRepository.findProductCacheDtoById/sByIds()` 통합 테스트
+- tie-breaker 정렬 검증 (동률 시 id 내림차순)
+
+### Phase 2 테스트
+- `ProductCommandService` 좋아요/재고 메서드의 상세 캐시 write-through 호출 검증 (mock 기반)
+- `ProductCommandFacade` 생성/수정/삭제의 write-through 호출 순서 검증
+- `BrandCommandFacade.updateBrand()` 시 상품 상세 캐시 갱신 검증
+- 통합 테스트: 좋아요 → 상세 캐시 값 변경 확인
+
+### Phase 3 테스트
+- `ProductQueryService.searchProducts()` 2계층 흐름 검증
+  - ID 리스트 hit + 상세 all hit
+  - ID 리스트 hit + 상세 partial miss
+  - ID 리스트 miss
+  - dangling ID 방어
+- cacheable guard: page 3 이상 또는 size != 20일 때 캐시 미사용
+- E2E: 상품 생성 → 목록 조회 → write-through 반영 확인
+
+---
+
+## 7. 주의사항
+
+### 전환 완료 상태
+- old key 병행 로직 없이 직접 전환 완료
+- `evictByPattern()` 메서드 ProductCacheManager에서 제거 완료
+- old key(`products:list:*`, `product:{id}`) 관련 artifact 정리 완료
+
+### 고빈도 트리거 최적화
+- 좋아요/재고 경로는 **상세 캐시만 write-through**, ID 리스트는 TTL 3분 자연 만료에 위임
+- 좋아요 ±1로 목록 순서가 뒤집히는 확률은 극히 낮으므로 eventual consistency 허용
+
+### PER 정책
+- PER(Probabilistic Early Refresh)는 ID 리스트 캐시에서 제거, 상세 캐시에서만 유지
+- write-through가 주력이므로 PER의 역할이 줄어듦. Redis 장애 시 PER도 동일하게 실패하므로 추가 방어 효과 없음
+
+### 캐시 쓰기 시점
+- 캐시 write-through는 TX 내에서 실행됨 (기존 evict와 동일한 수준)
+- best-effort — TX rollback 시 phantom cache가 남을 수 있으나 TTL 2분 내 자연 소멸
+- afterCommit 패턴은 코드 복잡도 대비 실익이 낮으므로 현재 scope에서 제외
+
+### Redis replica lag
+- 읽기 replica-preferred, 쓰기 master 구조이므로 write-through 직후 읽기에서 stale 가능
+- write-through로 miss 자체가 줄어들어 실질적 영향은 미미
diff --git a/round5-docs/07-cache-eviction-analysis.md b/round5-docs/07-cache-eviction-analysis.md
new file mode 100644
index 000000000..24cbc0e19
--- /dev/null
+++ b/round5-docs/07-cache-eviction-analysis.md
@@ -0,0 +1,684 @@
+# 캐시 무효화 전략 분석 — evictByPattern의 함정과 대안
+
+## 1. 문제 상황
+
+### 1.1 문제 발견 경위
+
+브랜드명 수정 시 상품 캐시 무효화 누락을 수정하려다, 근본적인 설계 이슈를 발견했다.
+
+- **직접 원인**: `BrandCommandFacade.updateBrand()`에서 Read Model은 동기화하면서 상품 캐시는 무효화하지 않음
+- **근본 원인**: 수정된 entity의 캐시만 정확히 찾아서 evict할 수 없는 구조
+
+### 1.2 왜 수정된 entity의 캐시만 정확히 evict할 수 없는가
+
+#### 상세 캐시 (`product:{id}`)
+
+캐시 키 구조:
+
+```
+product:1    →  { id:1, brandId:5, brandName:"나이키", ... }
+product:2    →  { id:2, brandId:5, brandName:"나이키", ... }
+product:3    →  { id:3, brandId:7, brandName:"아디다스", ... }
+...
+product:9999 →  { id:9999, brandId:5, brandName:"나이키", ... }
+```
+
+브랜드명 수정 시나리오: `brandId=5`의 이름을 "나이키" → "NIKE"로 변경
+
+무효화해야 할 캐시는 `product:1`, `product:2`, `product:9999` (brandId=5인 것들).
+하지만 **Redis 캐시 키에는 brandId가 포함되어 있지 않다.** 키는 `product:{productId}`이고, brandId는 **값(value) 내부**에만 존재한다.
+
+Redis에서 "값 내부의 특정 필드로 키를 역탐색"하는 방법은 없다:
+
+```
+redis> FIND_KEYS_WHERE value.brandId == 5   // ← 존재하지 않는 명령
+```
+
+#### 목록 캐시 (`products:list:*`)
+
+```
+products:list:all:LATEST:0:20     →  [나이키 상품 + 아디다스 상품 혼재]
+products:list:all:LIKES_DESC:0:20 →  [나이키 상품 + 아디다스 상품 혼재]
+products:list:5:LATEST:0:20       →  [나이키 상품만]
+```
+
+`brandId=5` 필터 목록만 지우면 될 것 같지만, `all` 키에도 해당 브랜드 상품이 섞여 있어서 결국 전체를 무효화해야 한다.
+
+#### 선택지
+
+| 방식 | 설명 | 문제 |
+|------|------|------|
+| **(a)** `product:*` 전체 SCAN + 역직렬화 | 각 값을 읽어서 brandId 확인 → 매칭만 삭제 | O(N) 풀스캔, 사실상 불가능 |
+| **(b)** `product:*` 전체 evict | 단순하지만 모든 캐시 날림 | 강제 캐시 스탬피드 유발 |
+| **(c)** 별도 역인덱스 관리 | `brand:5:products → [1, 2, 9999]` | 관리 복잡도 증가 |
+
+### 1.3 전체 evict 패턴은 강제 캐시 스탬피드를 만든다
+
+`evictByPattern("products:list:*")`가 실행되면:
+
+```
+시점 T:      목록 캐시 전체 삭제
+시점 T+1ms:  사용자 A 요청 → cache miss → DB 쿼리
+시점 T+2ms:  사용자 B 요청 → cache miss → DB 쿼리
+시점 T+3ms:  사용자 C 요청 → cache miss → DB 쿼리
+...
+→ 동시 N명이 전부 DB로 몰림 = 스탬피드
+```
+
+#### 현재 코드에서의 호출 빈도
+
+| 트리거 | 빈도 | `evictByPattern("products:list:*")` 호출 |
+|--------|------|:---:|
+| 좋아요 등록/취소 | **높음** (사용자 행동) | 매번 호출 |
+| 재고 차감 (주문) | **중간** | 매번 호출 |
+| 상품 생성/수정/삭제 | 낮음 (관리자) | 매번 호출 |
+
+**좋아요 한 번 누를 때마다 전체 목록 캐시가 날아간다.** 트래픽이 높으면 캐시가 의미 없어지는 수준이다.
+
+#### 근본 원인
+
+**캐시 키 설계와 무효화 범위의 불일치.** 목록 캐시를 하나의 큰 덩어리로 캐싱하면서, 구성 요소(개별 상품)가 변경될 때 전체를 날려야 하는 구조.
+
+---
+
+## 2. 목표와 목표 선정 이유
+
+**목표:** 캐시 무효화의 blast radius를 최소화하면서, 목록(PLP)/상세(PDP) 캐시의 히트율을 안정적으로 유지한다.
+
+**목표 선정 이유:**
+
+| 현상 | 영향 |
+|------|------|
+| `evictByPattern("products:list:*")`이 좋아요 1건마다 실행 | 캐시 히트율 ≈ 0%, 캐시 존재 의미 상실 |
+| 모든 목록 키가 동시에 miss → 키 수만큼 DB 쿼리 폭증 | 스탬피드 방어(LocalCacheLock)로도 키 간 동시 miss는 방어 불가 |
+| 브랜드명 변경 시 상세 캐시 무효화 누락 | 값 내부 필드 기반 역탐색이 불가능한 구조적 한계 |
+| Redis 오버헤드(직렬화/네트워크)만 추가되고 이득 없음 | "마이너스 캐시" — 캐시가 없는 것보다 나쁜 상태 |
+
+**핵심:** 문제는 "캐시를 쓸 것인가"가 아니라 **"무효화를 어떻게 할 것인가"**이다.
+
+---
+
+## 3. 해결책 분석
+
+### 3.0 판단 기준 프레임워크
+
+캐시 전략을 판단할 때 먼저 물어야 할 질문:
+
+> **"이 캐시의 무효화 빈도가, 캐시로 얻는 이득을 상쇄하지 않는가?"**
+
+세 가지 축으로 분해:
+
+| 축 | 설명 | 핵심 질문 |
+|---|------|----------|
+| **Hit Rate** | 캐시가 실제로 도움이 되는가 | 읽기 빈도 ÷ 무효화 빈도 비율이 충분한가? |
+| **Miss Cost** | cache miss 발생 시 DB 쿼리 비용 | DB 쿼리가 느려서 캐시가 필요한가, 이미 충분히 빠른가? |
+| **Invalidation Blast Radius** | 한 번 무효화 시 몇 개의 키가 날아가는가 | 1개만 날리는가, 수백 개를 날리는가? |
+
+현재 프로젝트에 대입:
+
+| 축 | 상품 상세 (`product:{id}`) | 상품 목록 (`products:list:*`) |
+|---|---|---|
+| 무효화 빈도 | 낮음 (해당 상품 변경 시만) | **매우 높음** (아무 상품의 좋아요/재고 변경마다) |
+| Miss Cost | 중간 (단건 쿼리) | **매우 낮음** (Read Model 0.85ms) |
+| Blast Radius | 1개 키 | **전체 키** (수십~수백 개) |
+
+**목록 캐시는 세 축 모두에서 불리하다.**
+
+### 3.1 전략 1: 키에 정확한 필드값 포함 → 타겟 evict
+
+키 자체에 데이터 식별 정보를 넣어서, 변경 시 해당 키만 정확히 찾아 삭제하는 방식.
+
+**근본적 한계가 있다.**
+
+목록 캐시는 "정렬된 N번째 페이지"이기 때문에, 개별 상품의 변경이 어떤 페이지에 영향을 주는지 사전에 알 수 없다:
+
+```
+[변경 전] LIKES_DESC 정렬
+page 0: [상품A(100좋아요), 상품B(80), 상품C(60)]
+page 1: [상품D(50), 상품E(40), 상품F(30)]
+
+[상품E가 좋아요 +70 받음]
+page 0: [상품E(110), 상품A(100), 상품B(80)]  ← page 0 내용 변경
+page 1: [상품C(60), 상품D(50), 상품F(30)]    ← page 1 내용도 변경
+```
+
+상품E의 좋아요가 변경되었을 뿐인데, **모든 페이지의 내용이 밀려난다.** 키에 아무리 많은 정보를 넣어도 "이 변경이 어느 페이지에 영향을 주는가"는 전체를 다시 정렬하지 않으면 알 수 없다.
+
+| 항목 | 평가 |
+|------|------|
+| trade-off | 키 설계 복잡도 ↑, 정렬/페이지네이션에서는 근본적으로 작동하지 않음 |
+| 추천 상황 | 정렬이 없고, 필터 조건이 고정된 단건/소수건 조회 (예: `user:{id}:profile`) |
+| 현재 프로젝트 | **부적합** — 정렬+페이지네이션 조합에서 타겟 evict가 불가능 |
+
+### 3.2 전략 2: 전체 evict + 스탬피드 방어 신뢰
+
+어차피 LocalCacheLock + PER이 있으니, 전체 evict해도 안전하다는 접근.
+
+**반은 맞고 반은 틀리다.**
+
+현재 스탬피드 방어가 막아주는 것:
+```
+products:list:all:LATEST:0:20  ← 동시 100명 요청
+  → LocalCacheLock이 1명만 DB 조회 → 나머지 99명 대기 후 캐시 사용
+```
+
+하지만 전체 evict 시 발생하는 것:
+```
+products:list:all:LATEST:0:20    ← 1 DB 쿼리  (Lock이 방어)
+products:list:all:LATEST:1:20    ← 1 DB 쿼리  (Lock이 방어)
+products:list:all:LIKES_DESC:0:20 ← 1 DB 쿼리  (Lock이 방어)
+products:list:5:LATEST:0:20      ← 1 DB 쿼리  (Lock이 방어)
+...
+→ "키 하나당 1 쿼리"이지만, 키가 수십~수백 개면 여전히 DB 부하 폭증
+```
+
+LocalCacheLock은 **같은 키**에 대한 중복 쿼리를 막아주지, **서로 다른 키** 수십 개가 동시에 miss 나는 건 못 막는다.
+
+그리고 좋아요 빈도 문제:
+```
+초당 좋아요 10건 발생 시:
+→ 초당 10번 전체 evict
+→ TTL 5분이든 10분이든 의미 없음
+→ 캐시 히트율 ≈ 0%
+→ Redis 오버헤드(직렬화/네트워크)만 추가된 셈
+```
+
+| 항목 | 평가 |
+|------|------|
+| trade-off | 구현 변경 없음 / 무효화 빈도가 높으면 캐시 자체가 무의미해짐 |
+| 추천 상황 | 무효화 트리거가 **저빈도**(관리자 작업 등)인 경우만 |
+| 현재 프로젝트 | **부적합** — 좋아요(고빈도)가 매번 전체 evict를 트리거 |
+
+### 3.3 전략 3: TTL만 사용 (evict 제거)
+
+변경 시 evict 안 하고, TTL 자연 만료에만 의존.
+가장 단순하고, 의외로 많은 상황에서 정답이다.
+
+```
+[쓰기 발생]
+→ 캐시 evict 안 함
+→ 기존 캐시는 TTL 만료까지 stale 상태로 서빙
+→ 만료 후 자연스럽게 최신 데이터로 갱신
+```
+
+데이터별 stale 허용도:
+
+| 데이터 | 5분 stale 허용? | 근거 |
+|--------|:--------------:|------|
+| 좋아요 수 | ✅ | "99좋아요"와 "100좋아요" 차이는 UX에 무관 |
+| 브랜드명 | ✅ | 관리자 저빈도 변경, 5분 지연 무해 |
+| 상품명/가격 | ✅ | 관리자 변경, 즉시 반영 불필요 |
+| 재고 | ⚠️ | "품절인데 재고 있음 표시" 가능 — 주문 시 서버 검증으로 방어 가능 |
+| 삭제된 상품 | ⚠️ | 삭제 상품이 목록에 노출 — 클릭 시 404로 방어 가능 |
+
+| 항목 | 평가 |
+|------|------|
+| trade-off | 구현 최단순 / 최대 TTL 시간만큼 stale 데이터 노출 |
+| 추천 상황 | 실시간 정합성이 불필요하고, stale 시 서버 검증으로 방어 가능한 경우 |
+| 현재 프로젝트 | **목록 캐시에 적합** — 좋아요/재고 stale은 UX에 치명적이지 않고, 주문/상세 조회 시 서버가 최신 데이터로 검증 |
+
+### 3.4 전략 4: 역인덱스 추적 → ES 도입
+
+`brand:5:products → [1, 2, 9999]` 같은 역인덱스를 직접 관리하여 선별 evict.
+
+직접 구현하면:
+```
+// 상품 생성 시
+redis> SADD brand:5:products 1
+redis> SADD page:LATEST:0 1
+
+// 브랜드명 변경 시
+redis> SMEMBERS brand:5:products  → [1, 2, 9999]
+redis> DEL product:1 product:2 product:9999
+```
+
+**직접 구현의 문제:** 캐시를 관리하기 위한 캐시가 필요해지고, 이 메타데이터의 정합성도 관리해야 한다. 캐시 관리 비용이 원래 문제보다 커진다.
+
+ES 도입에 대한 의견: ES는 "역인덱스 기반 검색 엔진"이지 "캐시 솔루션"이 아니다. 도입하면 문제가 바뀐다:
+
+```
+[현재] DB → Read Model → Redis Cache → 사용자
+[ES]   DB → Read Model → ES → 사용자
+```
+
+ES를 도입하면 캐시 무효화 문제 대신 **ES 동기화 문제**가 생긴다 (같은 본질). 다만 ES는 동기화를 위한 생태계(Logstash, CDC 등)가 성숙해서, 규모가 커지면 합리적 선택이다.
+
+| 항목 | 평가 |
+|------|------|
+| trade-off | 정밀 무효화 가능 / 메타데이터 관리 복잡도 폭증 (직접 구현 시), 인프라 비용 (ES 시) |
+| 추천 상황 | 검색 요구사항이 복잡하고(전문검색, 자동완성 등), 이미 ES 인프라가 있는 경우 |
+| 현재 프로젝트 | **과도함** — 브랜드 필터 + 정렬 정도의 요구사항에 ES는 대포로 파리 잡기 |
+
+### 3.5 전략 5: 목록 캐싱 제거 + 개별 상품만 캐싱
+
+`products:list:*` 캐시를 아예 없애고, `product:{id}`만 유지.
+
+구체적 수치 비교:
+
+```
+[현재 — 목록 캐시 있음]
+목록 조회 요청 → Redis 조회 (1~2ms 네트워크) → hit이면 반환
+                                              → miss이면 DB (0.85ms) + Redis 저장
+
+[제안 — 목록 캐시 없음]
+목록 조회 요청 → DB 직접 (0.85ms) → 반환
+```
+
+목록 캐시가 주는 실질 이득:
+
+| 시나리오 | 캐시 있음 (hit) | 캐시 없음 | 차이 |
+|---------|:-:|:-:|:-:|
+| 목록 조회 | ~1.3ms (Redis) | ~0.85ms (DB) | **DB가 더 빠름** |
+
+Read Model + 복합 인덱스 덕분에 **DB 쿼리가 이미 Redis 응답과 비슷하거나 더 빠르다.** 캐시의 존재 의의가 없다.
+
+목록 캐시 제거로 사라지는 문제들:
+
+| 문제 | 목록 캐시 있을 때 | 제거 후 |
+|------|:-:|:-:|
+| 좋아요 시 전체 evict | 발생 | 제거됨 |
+| 브랜드명 변경 시 evict 누락 | 발생 | 제거됨 |
+| 캐시 스탬피드 위험 | 존재 | 제거됨 |
+| evictByPattern SCAN 비용 | 존재 | 제거됨 |
+| 캐시 정합성 관리 부담 | 존재 | 제거됨 |
+
+상세 캐시(`product:{id}`)는 유지하는 이유:
+
+| 기준 | 상세 캐시 |
+|------|----------|
+| Blast Radius | 1개 키 (정확한 타겟 evict 가능) |
+| 무효화 빈도 | 해당 상품 변경 시만 (저빈도) |
+| Hit Rate | 인기 상품은 반복 조회 → 높은 히트율 |
+
+"득보다 실이 크지 않나?"에 대한 답:
+실(잃는 것)이 거의 없다. DB 쿼리가 0.85ms인데 캐시 응답이 1.3ms이면, 캐시를 제거하는 게 오히려 **성능이 좋아진다.** 캐시가 이득을 주려면 Miss Cost가 충분히 높아야 하는데, Read Model이 그 전제를 깨버렸다.
+
+| 항목 | 평가 |
+|------|------|
+| trade-off | 모든 무효화 문제 제거 / DB 부하가 직접 걸림 (하지만 0.85ms면 문제 없음) |
+| 추천 상황 | DB 쿼리가 충분히 빠르고, 캐시 무효화가 복잡한 경우 |
+| 현재 프로젝트 | **가장 적합** — Read Model이 캐시의 존재 이유를 제거함 |
+
+### 3.6 전략 6: Cache Versioning (세대 교체)
+
+```
+// 현재 generation: 5
+cache key: products:list:v5:LATEST:0:20
+
+// 데이터 변경 시 generation 증가
+redis> INCR products:list:generation  → 6
+
+// 이후 요청
+cache key: products:list:v6:LATEST:0:20  → miss → DB 조회 → 캐시 저장
+// v5 키들은 evict 안 함 → TTL로 자연 만료
+```
+
+| 항목 | 평가 |
+|------|------|
+| trade-off | 스탬피드 제거 / Redis 메모리 일시적 2배 사용 |
+| 추천 상황 | 전체 evict가 불가피하지만 스탬피드를 피해야 할 때 |
+| 현재 프로젝트 | 5번 전략이 더 단순하므로 굳이 필요 없음 |
+
+---
+
+## 4. 전략 선택 과정 및 근거
+
+### 4.1 1차 종합 비교
+
+| # | 전략 | Hit Rate | 복잡도 | 스탬피드 위험 | 현재 적합도 |
+|:-:|------|:--------:|:------:|:----------:|:---------:|
+| 1 | 키에 필드값 포함 | 높음 | 높음 | 낮음 | **부적합** (정렬+페이지네이션) |
+| 2 | 전체 evict + 방어 신뢰 | 낮음 | 낮음 | **높음** | **부적합** (고빈도 트리거) |
+| 3 | TTL만 사용 | 높음 | 최저 | 없음 | 적합 (stale 허용 시) |
+| 4 | 역인덱스 / ES | 높음 | **최고** | 낮음 | **과도함** |
+| 5 | **목록 캐시 제거** | - | **최저** | **없음** | **가장 적합** |
+| 6 | Cache Versioning | 중간 | 중간 | 없음 | 불필요 (5번이 더 단순) |
+
+**1차 결론:** 전략 5 (목록 캐시 제거 + 상세만 유지)가 가장 합리적이다. Read Model + 인덱스가 목록 캐시의 존재 이유를 제거했기 때문이다.
+
+### 4.2 1차 선별 — 명확한 제외 대상
+
+| # | 전략 | 판정 | 제외 근거 |
+|:-:|------|:----:|----------|
+| 1 | 키에 필드값 포함 | **제외** | 정렬+페이지네이션에서 근본적으로 작동 불가 |
+| 2 | 전체 evict + 방어 신뢰 | **제외** | write가 잦으면 지속적 lock 발생. 이점 대비 단점이 과대 |
+| 4 | 역인덱스 / ES | **제외** | 복잡도가 최고 수준. 사이드이펙트 및 관리포인트 증가를 감당하기 어려움 |
+
+### 4.3 전략 5 재평가 — 트래픽 관점의 한계 발견
+
+> **선택 기준의 변화:** 초기 분석에서는 "단건 쿼리 응답 속도" 기준으로 "DB 쿼리 0.85ms이면 캐시 불필요"라고 판단했으나, **트래픽 볼륨 관점이 누락**되었다는 사실을 발견했다.
+
+**PLP(Product List Page) vs PDP(Product Detail Page) 트래픽 특성:**
+
+```
+사용자 행동 퍼널:
+검색/목록(PLP) → 상세(PDP) → 장바구니 → 주문
+
+트래픽 비율 (일반적 커머스):
+PLP : PDP ≈ 10:1 ~ 100:1
+```
+
+- PLP는 사용자가 가장 먼저, 가장 자주 접근하는 진입점
+- PDP는 관심 상품만 클릭하므로 상대적으로 트래픽이 적음
+
+**단건 쿼리 속도 vs 동시 요청 수:**
+
+```
+PLP 초당 10,000 요청 × 0.85ms = DB 커넥션 풀 고갈 위험
+→ 캐시가 이 부하를 흡수해주는 역할이 핵심
+
+Redis는 단일 스레드로도 10만+ QPS 처리 가능
+→ "응답 속도"가 아닌 "DB 부하 차단"이 목록 캐시의 진짜 가치
+```
+
+**장바구니와의 비교:**
+- 장바구니: 실시간성이 즉각적으로 중요 → 캐싱 부적합
+- 상품 목록: 좋아요 수 1~2개 차이, 재고 약간의 지연은 허용 가능 → 캐싱 적합
+
+**결론:** 목록 캐시는 유지해야 한다. 문제는 "캐시를 쓸 것인가"가 아니라 "무효화를 어떻게 할 것인가"이다.
+
+| # | 전략 | 판정 |
+|:-:|------|:----:|
+| 5 | 목록 캐시 제거 | **제외** — PLP 트래픽 집중 특성상 캐시 유지 필요 |
+
+### 4.4 전략 6 세분화 — 스키마 버저닝 vs 데이터 세대 교체
+
+> **선택 기준의 변화:** 전략 5를 제외하면서, 남은 후보는 전략 3 (TTL)과 전략 6 (Cache Versioning)이었다. 전략 6을 다시 분석하니 하나의 이름 아래 **서로 다른 두 가지 개념**이 섞여 있었다.
+
+| 구분 | 목적 | 버전 변경 시점 | 예시 |
+|------|------|-------------|------|
+| **스키마 버저닝** | DTO 구조 변경 시 역직렬화 호환성 | 배포 시 (수동, 상수 변경) | `product:v1:{id}` → `product:v2:{id}` |
+| **데이터 세대 교체** | 전체 evict 대신 세대 번호 증가로 무효화 | 데이터 변경 시 (자동, INCR) | `products:list:gen5:...` → `products:list:gen6:...` |
+
+**스키마 버저닝 — 확정 (eviction 전략과 독립):**
+
+배포 안전성을 위한 기반 인프라. eviction 전략과 독립적으로 적용한다.
+
+적용 근거:
+- 배포 시 DTO 구조 변경이 있으면, 기존 Redis 캐시의 역직렬화가 실패하거나 필드 누락 발생
+- 구현 비용 최소: `ProductCacheManager`에서 캐시 키에 `v1` 상수 추가, 향후 DTO 변경 시 상수만 증가
+
+**데이터 세대 교체 — 불필요:**
+
+전략 3 (TTL) + write-through 조합이 더 단순하게 같은 문제를 해결한다. 세대 번호 관리, Redis 메모리 2배 사용 등의 부담이 있으면서 이점은 제한적이다.
+
+### 4.5 최종 선택
+
+> **선택 기준의 최종 변화:** "목록 캐시를 없앨 수 없다면, 캐시 구조 자체를 바꿔야 한다"는 결론에 도달. 1계층 전체 DTO 캐싱의 한계를 인식하고, **2계층 분리 (ID 리스트 + 상품 상세)** 아키텍처를 도출했다.
+
+| 결정 | 내용 |
+|------|------|
+| **목록 캐시** | 전체 DTO → **ID 리스트만 캐싱**으로 전환. 상세 데이터는 Layer 2에서 MGET |
+| **상세 캐시** | **PLP + PDP 공용** 단일 캐시. write-through로 즉시 갱신 |
+| **무효화 전략** | `evictByPattern` **제거**. write-through (갱신) + TTL (안전망) 조합 |
+| **스키마 버저닝** | 적용. 캐시 키에 `v1` 상수 포함 |
+
+**2계층 분리가 근본 문제를 해결하는 이유:**
+
+```
+[AS-IS — 1계층]
+products:list:all:LATEST:0:20 → [상품A 전체, 상품B 전체, ...]
+→ 상품A의 좋아요 변경 → 이 캐시 전체가 stale → evict 필요
+
+[TO-BE — 2계층]
+Layer 1: products:ids:v1:all:LATEST:0:20 → [1, 5, 12]     (ID만)
+Layer 2: product:v1:1 → {상품A 전체}                       (상세)
+→ 상품A의 좋아요 변경 → product:v1:1만 write-through → Layer 1은 무관
+```
+
+- ID 리스트에는 좋아요/재고/브랜드명 등 변경 가능 필드가 없다 → 무효화 빈도 격감
+- 상세 캐시는 1개 키 단위로 정확히 갱신 가능 → blast radius = 1
+- PLP와 PDP가 같은 상세 캐시를 공유 → 캐시 효율 극대화
+
+---
+
+## 5. 최종 캐시 아키텍처 설계 (확정)
+
+### 5.1 캐시 구조 — 2계층 분리
+
+```
+Layer 1: ID 리스트 (PLP용)
+  products:ids:v1:{brandId|all}:{sortType}:{page}:{size}
+  → { ids: [1, 5, 12, ...], totalElements: 523 }
+
+Layer 2: 상품 상세 (PDP + PLP 공용)
+  product:v1:{productId}
+  → ProductCacheDto (전체 필드 포함, API별 필요한 것만 추출)
+```
+
+### 5.2 캐싱 범위
+
+| 항목 | 범위 |
+|------|------|
+| **ID 리스트** | 모든 필터 조합 (all + 각 brandId) × 3정렬 × pages 0~2 |
+| **상품 상세** | 개별 상품 단위, API 간 재활용 |
+| **관리자 API** | 캐시 미적용 (실시간 데이터 필요, 트래픽 적음) |
+
+필터 조건: 현재 `brandId` 하나만 존재 (키워드/가격 범위/카테고리 필터 없음).
+
+**캐시 적용 조건 (가드):** `page <= 2 && size == DEFAULT_PAGE_SIZE`일 때만 ID 리스트를 캐시한다. 이 범위를 벗어나는 요청은 cache-aside를 거치지 않고 DB 직접 조회한다. 이렇게 하면 write-through 갱신 범위와 캐시 적재 범위가 정확히 일치하여 stale 캐시가 남지 않는다.
+
+### 5.3 TTL
+
+| 캐시 | TTL | 근거 |
+|------|-----|------|
+| ID 리스트 (PLP) | 3분 | PLP는 stale 허용도 높음. write-through가 주력, TTL은 안전망 |
+| 상품 상세 (PDP) | 2분 | 구매 결정 단계 → 실시간성 더 중요. 더 짧은 안전망 |
+
+**TTL 설정 근거 — write-through 기반 freshness 모델:**
+
+본 시스템은 **write-through가 캐시 freshness의 주 메커니즘**이다. 상품 생성/수정/삭제 시 Facade에서 DB 쓰기 직후 캐시를 즉시 갱신(또는 삭제)하므로, 정상 동작 시 캐시는 항상 최신 상태를 유지한다.
+
+따라서 TTL의 역할은 **"데이터가 얼마나 빨리 반영되어야 하는가"가 아니라, "write-through가 실패했을 때 stale 데이터를 최대 얼마나 허용할 수 있는가"**이다. write-through 실패는 Redis 일시 장애, 네트워크 파티션 등 예외적 상황에서만 발생하므로, TTL은 이 예외 상황의 **최대 staleness 윈도우(안전망)**로 기능한다.
+
+**더 짧은 TTL(예: 30초/1분)을 채택하지 않는 이유:**
+- write-through가 정상 동작하는 한 TTL 길이와 무관하게 freshness는 동일 (near-real-time)
+- TTL을 줄이면 cache miss 빈도만 증가하여 **long-tail 상품의 hit rate가 하락**하고 DB 부하가 불필요하게 상승
+- 체감 freshness 향상 없이 캐시 효율만 저하되는 trade-off
+
+### 5.4 캐시 갱신 정책
+
+| 상황 | 정책 | 설명 |
+|------|------|------|
+| **읽기 시 캐시 miss** | cache-aside | DB 조회 → 캐시 적재 (초기 적재/cold start 대응) |
+| **쓰기 시** | write-through | DB 업데이트 → 같은 TX 내에서 캐시 덮어쓰기 (best-effort — TX 롤백 시 TTL 안전망 의존) |
+| **evict** | 사용하지 않음 | `evictByPattern` 제거. 삭제 대신 갱신으로 캐시 warm 유지. **예외: 상품 삭제 시 상세 캐시는 explicit evict** |
+
+> **TODO**: 향후 이벤트 도입 시 `@TransactionalEventListener(AFTER_COMMIT)` 기반으로 전환하여 TX 롤백 시 캐시 정합성 보장. 현재는 TX 내 처리 (롤백 시 TTL 안전망 의존). → `docs/todo/cache-event-driven-refresh.md` 참조
+
+> **TODO**: `ApplicationReadyEvent` 기반 캐시 웜업 구현. 서버 시작 시 hot 페이지를 선제적으로 캐시 적재. → `docs/todo/cache-event-driven-refresh.md` 참조
+
+### 5.5 스키마 버저닝
+
+캐시 키에 `v1` 상수 포함. DTO 구조 변경 시 상수만 증가하여 배포 안전성 확보.
+
+```
+product:v1:{productId}
+products:ids:v1:{brandId|all}:{sortType}:{page}:{size}
+```
+
+### 5.6 MGET partial miss 처리
+
+```
+1. ID 리스트 캐시에서 IDs 조회: [1, 5, 12, 7]
+2. MGET product:v1:1 product:v1:5 product:v1:12 product:v1:7
+3. miss된 ID 추출: [5, 7]
+4. DB에서 miss분만 조회
+5. 캐시에 적재 (cache-aside)
+6. 합쳐서 ID 리스트 순서대로 반환
+```
+
+**dangling ID 방어:** MGET 결과에 null이 포함되고 DB에서도 조회되지 않는 ID(삭제된 상품)는 응답에서 제외한다. write-through가 삭제 시 ID 리스트도 갱신하므로 이 상황의 window는 극히 짧지만, 방어적으로 null skip 처리한다. 응답 건수가 요청 `size`보다 적을 수 있으나, 다음 write-through에서 ID 리스트가 정상화된다.
+
+### 5.7 write-through 트리거 매핑
+
+| 변경 작업 | 빈도 | ID 리스트 갱신 대상 | 상세 캐시 갱신 |
+|----------|:----:|-------------------|:----------:|
+| 좋아요 증가/감소 | 높음 | `LIKES_DESC` × (all + brandId) × 3p = 6개 | 해당 상품 1개 |
+| 재고 차감 | 중간 | 없음 (정렬 무관) | 해당 상품 1개 |
+| 상품 수정 (가격) | 낮음 | `PRICE_ASC` × (all + brandId) × 3p = 6개 | 해당 상품 1개 |
+| 상품 생성 | 낮음 | 모든 정렬 × (all + brandId) × 3p = 18개 | 신규 상품 1개 |
+| 상품 삭제 | 낮음 | 모든 정렬 × (all + brandId) × 3p = 18개 | 해당 상품 삭제 |
+| 브랜드명 수정 | 극히 낮음 | 없음 (ID에 brandName 미포함) | 해당 브랜드 전체 상품 |
+
+> 브랜드명 수정은 극히 드문 작업이지만, TTL 자연 만료를 기다리지 않고 write-through로 즉시 갱신한다.
+> evict가 아닌 write-through이므로 캐시가 항상 warm 상태를 유지하며, 캐시 스탬피드가 발생하지 않는다.
+> 구현 흐름: `BrandCommandFacade.updateBrand()` → Read Model `brandName` 일괄 동기화 → 해당 brandId 상품 ID 조회 → 각 상품 상세 캐시 write-through.
+
+> **전제**: 상품 수정 시 Read Model `createdAt` 보존 필요. 현재 구현은 `ProductReadModelRepositoryImpl.save()`가 기존 row를 partial update하여 `createdAt`과 `likeCount`를 보존한다.
+
+### 5.8 Race Condition 분석
+
+#### 상품 상세 캐시 (PDP) — 동일 타입 mutation은 직렬화, 혼합 mutation은 제한적 race 존재
+
+**동일 타입 mutation (예: 좋아요 + 좋아요):**
+
+| 작업 | 잠금 방식 | 결과 |
+|------|----------|------|
+| `increaseLikeCount` | atomic UPDATE (row lock) | 직렬화됨 |
+| `decreaseLikeCount` | atomic UPDATE (row lock) | 직렬화됨 |
+| `decreaseStock` | `findByIdForUpdate` (PESSIMISTIC_WRITE) | 직렬화됨 |
+| `updateProduct` | JPA merge → UPDATE (row lock) | 직렬화됨 |
+| `deleteProduct` | DELETE (row lock) | 직렬화됨 |
+
+**혼합 mutation (예: admin update + user like 동시) — 캐시가 아닌 데이터 레이어 이슈:**
+
+`updateProduct`는 JPA merge로 전체 필드를 덮어쓰므로, 동시에 실행된 atomic `increaseLikeCount`의 결과가 유실될 수 있다. 이는 캐시 설계와 무관한 기존 데이터 레이어의 lost update 문제이며, 캐시는 DB 커밋 후 상태를 그대로 반영한다. 관리자 상품 수정은 극히 저빈도이므로 실질적 영향은 무시 가능하며, 필요 시 관리자 수정 경로에 낙관적 락(`@Version`) 적용으로 해결 가능하다.
+
+**결론:** 캐시 관점에서의 race condition은 DB 상태에 종속되며, 캐시 자체가 추가 불일치를 만들지 않는다.
+
+#### ID 리스트 캐시 (PLP) — Race 있으나 무해
+
+**다른 상품에 대한 동시 변경**은 서로 다른 row이므로 DB lock 충돌이 없다:
+
+```
+상품X(brandId=5) 좋아요 +1 → Thread A (row X lock)
+상품Y(brandId=5) 좋아요 +1 → Thread B (row Y lock)
+→ 병렬 실행 → 둘 다 같은 ID 리스트 캐시 키에 write-through
+→ 마지막에 쓴 쪽이 이전 쓴 쪽을 덮어씀
+```
+
+| 시나리오 | 캐시 키 충돌 | 빈도 | 불일치 내용 | 자동 복구 |
+|---------|:-----------:|:----:|-----------|:--------:|
+| 같은 브랜드 상품 동시 좋아요 | brand + all 필터 | 중간 | 좋아요 1~2개 차이 | 다음 write-through |
+| 다른 브랜드 상품 동시 좋아요 | all 필터만 | 높음 | 좋아요 1~2개 차이 | 다음 write-through |
+| 생성 + 다른 상품 좋아요 | 정렬별 | 매우 낮음 | 신규 상품 노출 1~2초 지연 | 다음 write-through |
+| 삭제 + 다른 상품 좋아요 | 정렬별 | 매우 낮음 | 삭제 상품 1~2초 잔존 | TTL (3분) |
+
+**결론:** PLP ID 리스트 race condition은 비즈니스적으로 무해하다. 좋아요 1~2개 차이는 사용자 인지 불가능하고, 다음 write-through에서 수 초 내 자동 복구된다.
+
+### 5.9 설계 전제 조건
+
+| 전제 | 근거 |
+|------|------|
+| 품절 상품(stock=0)은 목록에서 제외하지 않음 | 품절 검증은 장바구니/주문 단계에서 서버가 수행. stock은 정렬/필터 조건에 포함되지 않음 |
+| 브랜드 visibleStatus 변경은 상품 캐시에 영향 없음 | 사용자 상품 조회는 브랜드 visibility를 보지 않음 (`deletedAt IS NULL` + optional `brandId`만 필터) |
+| 상품 복원 기능 없음 | `SoftDeleteBaseEntity.restore()`는 존재하지만 애플리케이션 계층에서 미사용 |
+| 정렬 보조 키로 `id` 사용 | tie-breaker 없으면 동률 시 페이지 경계 불안정. 구현 시 `ORDER BY sort_col, id` 적용 |
+
+> 위 전제가 변경되면 캐시 트리거 매핑을 재검토해야 한다.
+
+---
+
+## 6. 실제 적용 결과
+
+### 6.1 DB 성능 개선 — Read Model + 복합 인덱스
+
+> 상세 데이터: [`03-as-is-performance-measurement.md`](./03-as-is-performance-measurement.md), [`04-to-be-index-measurement.md`](./04-to-be-index-measurement.md)
+
+캐시 무효화 전략의 전제가 된 DB 성능 개선 결과:
+
+**단건 쿼리 성능 (DB 레벨):**
+
+| 데이터 규모 | AS-IS (PK만, Full Table Scan) | TO-BE (Read Model + 복합 인덱스) | 개선 배율 |
+|:----------:|:---:|:---:|:---:|
+| 100K | 20.8~33.4ms | 0.74~6.96ms | **3~29x** |
+| 1M | 408~585ms | 0.85~2.44ms | **240~545x** |
+| 10M | 3,489~4,184ms | 2.29~8.20ms | **441~1,533x** |
+
+**Burst 테스트 (100 동시 스레드):**
+
+| 데이터 규모 | AS-IS 에러율 | TO-BE 에러율 | AS-IS avg | TO-BE avg |
+|:----------:|:---:|:---:|:---:|:---:|
+| 100K | 0% | 0% | 365~494ms | 25~74ms |
+| 1M | 70~80% | **0%** | 2,407~2,793ms | 20~35ms |
+| 10M | 90% | **0%** | 10,591~14,824ms | 23~41ms |
+
+**핵심:** Read Model + 복합 인덱스로 목록 쿼리가 **0.85ms** 수준으로 안정화되었다. 이 수치가 "목록 캐시 제거 가능성"(전략 5)을 검토하게 된 직접적 계기이며, 동시에 "캐시 miss 시 DB fallback 비용이 낮다"는 설계 전제의 근거이기도 하다.
+
+### 6.2 캐시 적용 후 성능
+
+> 상세 데이터: [`05-to-be-cache-measurement.md`](./05-to-be-cache-measurement.md)
+>
+> 2계층 캐시 아키텍처(ID 리스트 + MGET 상세) + write-through 기반 측정 결과.
+
+**Cache Hit 시 응답 (데이터 규모 무관):**
+
+| 데이터 규모 | Cache Hit 응답 | DB 직접 조회 | 비고 |
+|:----------:|:---:|:---:|------|
+| 100K | 5.14~7.41ms | 0.74~6.96ms | Redis ≈ DB |
+| 1M | 4.07~5.24ms | 0.85~2.44ms | Redis > DB (단건 기준) |
+
+**Sustained Load (20 RPS × 10초, Cache Hit):**
+
+| 데이터 규모 | 달성 QPS | 에러율 | 평균 응답 |
+|:----------:|:---:|:---:|:---:|
+| 100K | 20.0 | 0% | 6.08~10.35ms |
+| 1M | 20.0 | 0% | 6.50~9.07ms |
+
+**AS-IS 대비 최종 개선 (1M 기준, Cache Hit):**
+
+| 지표 | AS-IS | TO-BE | 개선 |
+|------|:---:|:---:|:---:|
+| 단건 목록 응답 | 482~516ms | ~4~5ms | **92~123x** |
+| Burst 에러율 | 71~80% | 0% | **완전 해소** |
+| Sustained QPS (20 RPS) | 3.7~5.9 | 20.0 | **3.4~5.4x** |
+| Sustained 에러율 | 37~60% | 0% | **완전 해소** |
+
+### 6.3 캐시 무효화 전략 개선 효과
+
+2계층 분리 + write-through 전환으로 인한 구조적 개선:
+
+| 항목 | AS-IS (evictByPattern) | TO-BE (2계층 + write-through) |
+|------|---|---|
+| 좋아요 1건당 영향 | **전체 목록 캐시 삭제** (수십~수백 키) | 상세 캐시 1개 + ID 리스트 6개 **갱신** |
+| 브랜드명 변경 시 | 상세 캐시 무효화 **누락** (버그) | 해당 브랜드 상품 상세 캐시 **일괄 write-through** |
+| 캐시 스탬피드 | evict 후 서로 다른 키 동시 miss → DB 부하 폭증 | write-through로 캐시 warm 유지 → **스탬피드 제거** |
+| 캐시 히트율 (고빈도 write 시) | ≈ 0% (매 evict마다 전체 리셋) | **안정적 유지** (갱신이지 삭제가 아님) |
+| `SCAN` 비용 | `evictByPattern` → Redis SCAN O(N) | **제거됨** |
+| PLP-PDP 캐시 공유 | 불가 (목록은 전체 DTO, 상세는 별도) | **공유** (Layer 2 상세 캐시를 PLP+PDP가 재활용) |
+
+---
+
+## 7. 요약
+
+### 문제
+
+`evictByPattern("products:list:*")`이 좋아요 등 고빈도 mutation마다 전체 목록 캐시를 삭제하여, 캐시 히트율이 사실상 0%에 수렴하고 스탬피드 위험을 상시 유발하는 구조였다.
+
+### 전략 선택 과정
+
+| 단계 | 판단 | 결과 |
+|------|------|------|
+| 1차 분석 | 6개 전략을 이론적 장단점 + 프로젝트 적합성으로 평가 | 전략 5 (목록 캐시 제거)가 가장 적합 |
+| 재평가 | PLP 트래픽 볼륨 관점 누락 발견 — 단건 속도가 아닌 DB 부하 차단이 캐시의 진짜 가치 | 전략 5 제외, 목록 캐시 유지 필요 |
+| 전략 6 세분화 | 스키마 버저닝(배포 안전성)과 데이터 세대 교체(무효화)를 분리 | 스키마 버저닝만 채택 |
+| 최종 도출 | 캐시 구조 자체를 변경 — 1계층 전체 DTO → **2계층 분리 (ID 리스트 + 상세)** | TTL 안전망 + write-through 즉시 갱신 |
+
+### 최종 아키텍처
+
+```
+Layer 1: ID 리스트 캐시   products:ids:v1:{brandId|all}:{sort}:{page}:{size}
+Layer 2: 상품 상세 캐시    product:v1:{productId}
+
+읽기: cache-aside (miss 시 DB → 캐시 적재)
+쓰기: write-through (DB 쓰기 직후 캐시 즉시 갱신)
+TTL:  안전망 (write-through 실패 시 최대 staleness 윈도우)
+```
+
+### 핵심 개선
+
+- `evictByPattern` 제거 → 캐시 스탬피드 **원천 차단**
+- write-through로 캐시 항상 warm → 히트율 **안정적 유지**
+- 2계층 분리로 PLP/PDP 상세 캐시 공유 → 캐시 효율 **극대화**
+- 브랜드명 변경 시 상세 캐시 무효화 누락 **해소**

From 479db25d043a4befd2769912effdfbcc02ae697a Mon Sep 17 00:00:00 2001
From: Hwan0518 <qip0518@naver.com>
Date: Fri, 13 Mar 2026 03:22:44 +0900
Subject: [PATCH 8/9] =?UTF-8?q?docs:=20=EC=A0=84=EC=B2=B4=20=EB=8F=84?=
 =?UTF-8?q?=EB=A9=94=EC=9D=B8=20=EC=9D=B8=EB=8D=B1=EC=8A=A4=20=EB=B0=8F=20?=
 =?UTF-8?q?=EC=BA=90=EC=8B=9C=20=EC=A0=90=EA=B2=80=20=EA=B2=B0=EA=B3=BC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- round5-docs/08-cross-domain-index-and-cache-analysis.md

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
---
 ...8-cross-domain-index-and-cache-analysis.md | 302 ++++++++++++++++++
 1 file changed, 302 insertions(+)
 create mode 100644 round5-docs/08-cross-domain-index-and-cache-analysis.md

diff --git a/round5-docs/08-cross-domain-index-and-cache-analysis.md b/round5-docs/08-cross-domain-index-and-cache-analysis.md
new file mode 100644
index 000000000..aa3a64418
--- /dev/null
+++ b/round5-docs/08-cross-domain-index-and-cache-analysis.md
@@ -0,0 +1,302 @@
+# 08. 전체 도메인 인덱스 추가 및 캐싱 분석
+
+## 1. 배경
+
+상품(Product) 도메인의 Read Model + 복합 인덱스 + Redis 캐시 적용 이후,
+전체 도메인에 대해 인덱스 누락 여부를 점검하고 캐싱 기회를 분석하였다.
+
+---
+
+## 2. ProductReadModelEntity 인덱스 보완
+
+### 2-1. 기존 인덱스의 한계
+
+기존 3개 인덱스는 `(deleted_at, brand_id, {sort_col})` 구조였으나, 두 가지 문제가 있었다:
+
+1. **컬럼 순서**: `deleted_at`(카디널리티 2: NULL/timestamp)이 `brand_id`(카디널리티 수십~수백)보다 앞에 위치 → B-tree fan-out 불균등
+2. **커버리지 부족**: brandId 없는 사용자 쿼리와 관리자 쿼리에서 인덱스 활용 불가
+
+**카디널리티 우선 원칙으로 순서 변경**: `(brand_id, deleted_at, {sort_col})`
+- 두 컬럼 모두 equality 조건이므로 인덱스 탐색 결과(matching rows)는 순서 무관하게 동일
+- 카디널리티가 높은 `brand_id`를 선두에 배치하면 B-tree 첫 레벨의 분기가 더 균등해져 인덱스 페이지 접근 효율 향상
+
+**brandId 없는 사용자 쿼리의 문제:**
+```
+WHERE deleted_at IS NULL ORDER BY created_at DESC
+```
+인덱스 `(brand_id, deleted_at, created_at)`에서 선두 컬럼 `brand_id`가 쿼리에 없으므로 인덱스 활용 불가 → 별도 2-column 인덱스 `(deleted_at, sort_col)` 필요.
+
+**관리자 쿼리의 문제:**
+```
+WHERE brand_id = ? ORDER BY created_at DESC  (또는 필터 없음)
+```
+3-column 인덱스의 `deleted_at`이 쿼리에 없으므로 정렬 컬럼까지 도달 불가 → 별도 2-column 인덱스 `(brand_id, sort_col)` 필요.
+
+### 2-2. 보완된 인덱스 (기존 3 → 총 12개)
+
+| # | 조합 | 인덱스 컬럼 | 상태 |
+|---|------|------------|:----:|
+| 1 | 사용자 + 브랜드 + LATEST | `(brand_id, deleted_at, created_at)` | 기존 (순서 변경) |
+| 2 | 사용자 + 브랜드 + PRICE_ASC | `(brand_id, deleted_at, price)` | 기존 (순서 변경) |
+| 3 | 사용자 + 브랜드 + LIKES_DESC | `(brand_id, deleted_at, like_count)` | 기존 (순서 변경) |
+| 4 | 사용자 + 전체 + LATEST | `(deleted_at, created_at)` | **신규** |
+| 5 | 사용자 + 전체 + PRICE_ASC | `(deleted_at, price)` | **신규** |
+| 6 | 사용자 + 전체 + LIKES_DESC | `(deleted_at, like_count)` | **신규** |
+| 7 | 관리자 + 브랜드 + LATEST | `(brand_id, created_at)` | **신규** |
+| 8 | 관리자 + 브랜드 + PRICE_ASC | `(brand_id, price)` | **신규** |
+| 9 | 관리자 + 브랜드 + LIKES_DESC | `(brand_id, like_count)` | **신규** |
+| 10 | 관리자 + 전체 + LATEST | `(created_at)` | **신규** |
+| 11 | 관리자 + 전체 + PRICE_ASC | `(price)` | **신규** |
+| 12 | 관리자 + 전체 + LIKES_DESC | `(like_count)` | **신규** |
+
+**커버리지:** 사용자/관리자 × 브랜드유무 × 3개 정렬 = **12개 조합 모두 인덱스 커버**.
+
+---
+
+## 3. 타 도메인 인덱스 추가
+
+### 3-1. 추가된 인덱스 요약
+
+| 엔티티 | 테이블 | 인덱스명 | 컬럼 | 대상 쿼리 |
+|--------|--------|---------|------|----------|
+| BrandEntity | `brands` | `idx_brands_deleted_visible` | `(deleted_at, visible_status)` | 브랜드 목록 조회 (사용자/관리자) |
+| OrderEntity | `orders` | `idx_orders_user_created` | `(user_id, created_at)` | 주문 내역 조회 + 기간 필터 |
+| OrderItemEntity | `order_items` | `idx_order_items_order` | `(order_id)` | 주문 상품 조회 |
+| CartItemEntity | `cart_items` | `idx_cart_user_selected` | `(user_id, selected)` | 선택된 장바구니 항목 조회 |
+| CartItemEntity | `cart_items` | `idx_cart_product` | `(product_id)` | 상품 삭제 시 장바구니 정리 (※ 처리 방식 미확정 — 논의 중) |
+| ProductLikeEntity | `likes` | `idx_likes_user_type_created` | `(user_id, target_type, created_at)` | 좋아요 목록 페이지네이션 |
+| ProductLikeEntity | `likes` | `idx_likes_type_target` | `(target_type, target_id)` | 상품/브랜드 삭제 시 좋아요 정리 (※ 즉시 정리 제거 확정 — 배치 잡 정리 시 활용 가능) |
+| IssuedCouponEntity | `issued_coupon` | `idx_issued_coupon_user_created` | `(user_id, created_at)` | 사용자 쿠폰 내역 |
+| IssuedCouponEntity | `issued_coupon` | `idx_issued_coupon_template_created` | `(coupon_template_id, created_at)` | 관리자 쿠폰 발급 내역 |
+| CouponTemplateEntity | `coupon_template` | `idx_coupon_template_deleted` | `(deleted_at)` | 활성 쿠폰 템플릿 목록 |
+
+### 3-2. 엔티티별 상세 분석
+
+#### BrandEntity (`brands`)
+
+**기존 인덱스:** 없음 (PK만 존재)
+
+**쿼리 패턴:**
+- `findAllByDeletedAtIsNull(Pageable)` — 관리자 브랜드 목록
+- `findAllByVisibleStatusAndDeletedAtIsNull(VisibleStatus, Pageable)` — 사용자 브랜드 목록
+
+**추가 인덱스:**
+```
+idx_brands_deleted_visible (deleted_at, visible_status)
+```
+- `deleted_at`이 선두: `findAllByDeletedAtIsNull` 쿼리에서도 인덱스 prefix 활용 가능
+- `visible_status`가 후순위: 사용자 조회 시 추가 필터링
+
+---
+
+#### OrderEntity (`orders`)
+
+**기존 인덱스:** `UNIQUE (user_id, request_id)` — 멱등성 체크용
+
+**쿼리 패턴:**
+- `findByUserId(Pageable)` — 사용자 주문 내역 (ORDER BY created_at DESC)
+- `findByUserIdAndCreatedAtInRange(userId, start, end, Pageable)` — 기간별 주문 내역
+
+**추가 인덱스:**
+```
+idx_orders_user_created (user_id, created_at)
+```
+- `user_id` equality + `created_at` range/sort를 단일 인덱스로 커버
+- 두 쿼리 패턴 모두 지원: 전체 조회(user_id만) + 기간 필터(user_id + created_at range)
+
+---
+
+#### OrderItemEntity (`order_items`)
+
+**기존 인덱스:** 없음 (PK만 존재, FK 인덱스 자동 생성 안 됨)
+
+**쿼리 패턴:**
+- `findByOrderId(orderId)` — 단일 주문의 상품 목록
+- `findByOrderIdIn(orderIds)` — 복수 주문의 상품 목록 (배치)
+
+**추가 인덱스:**
+```
+idx_order_items_order (order_id)
+```
+- `order_id`가 `@ManyToOne`이 아닌 plain Long 필드이므로 FK 인덱스가 자동 생성되지 않음
+- 주문 상세 조회 시 필수적으로 사용되는 쿼리
+
+---
+
+#### CartItemEntity (`cart_items`)
+
+**기존 인덱스:** `UNIQUE (user_id, product_id)` — 동일 상품 중복 방지
+
+**쿼리 패턴:**
+- `findByUserId(userId)` — 장바구니 전체 조회 (UNIQUE prefix로 커버 ✅)
+- `findByUserIdAndProductId(userId, productId)` — UNIQUE 인덱스로 커버 ✅
+- `findByUserIdAndSelectedTrue(userId)` — 선택된 항목만 조회 (**커버 안 됨**)
+- `deleteAllByProductId(productId)` — 상품 삭제 시 장바구니 정리 (**커버 안 됨**)
+
+**추가 인덱스:**
+```
+idx_cart_user_selected (user_id, selected)
+idx_cart_product (product_id)
+```
+
+---
+
+#### ProductLikeEntity / BrandLikeEntity (`likes` 공유 테이블)
+
+**기존 인덱스:** `UNIQUE (user_id, target_type, target_id)` — 중복 좋아요 방지
+
+**쿼리 패턴:**
+- `findByUserIdAndTargetTypeAndTargetId(...)` — UNIQUE로 커버 ✅
+- `existsByUserIdAndTargetTypeAndTargetId(...)` — UNIQUE로 커버 ✅
+- `findByUserIdAndTargetType(userId, targetType, Pageable)` — 좋아요 목록 (**ORDER BY created_at 미커버**)
+- `deleteAllByTargetTypeAndTargetId(targetType, targetId)` — 삭제 시 정리 (**target_type, target_id 조합 미커버**)
+
+**추가 인덱스:**
+```
+idx_likes_user_type_created (user_id, target_type, created_at)
+idx_likes_type_target (target_type, target_id)
+```
+- 두 엔티티가 동일 테이블을 공유하므로 `ProductLikeEntity`에서 한 번만 정의
+- `idx_likes_user_type_created`: 좋아요 목록 페이지네이션 시 filesort 제거
+- `idx_likes_type_target`: 상품/브랜드 삭제 시 관련 좋아요 일괄 삭제 최적화 (※ 즉시 정리 제거 확정 — Soft delete 필터링으로 충분. 인덱스는 향후 배치 잡 정리 시 활용 가능하므로 유지)
+
+---
+
+#### IssuedCouponEntity (`issued_coupon`)
+
+**기존 인덱스:** `UNIQUE (user_id, coupon_template_id)` — 1인 1쿠폰 보장
+
+**쿼리 패턴:**
+- `existsByCouponTemplateIdAndUserId(...)` — UNIQUE로 커버 ✅
+- `findAllByUserIdOrderByCreatedAtDesc(userId)` — 사용자 쿠폰 내역 (**ORDER BY 미커버**)
+- `findAllByCouponTemplateIdOrderByCreatedAtDesc(couponTemplateId)` — 관리자 발급 내역 (**미커버**)
+
+**추가 인덱스:**
+```
+idx_issued_coupon_user_created (user_id, created_at)
+idx_issued_coupon_template_created (coupon_template_id, created_at)
+```
+
+---
+
+#### CouponTemplateEntity (`coupon_template`)
+
+**기존 인덱스:** 없음 (PK만 존재)
+
+**쿼리 패턴:**
+- `findAllByDeletedAtIsNull(Pageable)` — 활성 쿠폰 템플릿 목록 (관리자)
+
+**추가 인덱스:**
+```
+idx_coupon_template_deleted (deleted_at)
+```
+
+---
+
+#### UserEntity (`users`) — 변경 없음
+
+**기존 인덱스:** `UNIQUE active_login_id` (generated column) — 로그인 조회 최적화
+
+**쿼리 패턴:**
+- `findByLoginIdValueAndDeletedAtIsNull(loginId)` — generated column 유니크 인덱스로 커버 ✅
+- `existsByLoginIdValueAndDeletedAtIsNull(loginId)` — 위와 동일 ✅
+
+**추가 인덱스 불필요.**
+
+---
+
+## 4. 캐싱 기회 분석
+
+### 4-1. 높은 우선순위 (HIGH)
+
+#### 브랜드 목록 — `GET /api/v1/brands`
+
+| 항목 | 값 |
+|------|---|
+| 트래픽 | 사용자 대면, 매 페이지 로드마다 호출 |
+| 데이터 특성 | 변경 빈도 매우 낮음 (관리자만 수정) |
+| 쿼리 비용 | 단순 SELECT + pagination |
+| 추천 TTL | **1시간** |
+| 캐시 키 | `brand:visible:page:{page}:{size}` |
+| 무효화 | 브랜드 생성/수정/삭제/노출상태 변경 시 패턴 삭제 |
+
+#### 브랜드 상세 — `GET /api/v1/brands/{brandId}`
+
+| 항목 | 값 |
+|------|---|
+| 트래픽 | 사용자 대면, 상품 상세 진입 시 함께 조회 |
+| 데이터 특성 | 거의 불변 (이름, 설명만 가끔 수정) |
+| 쿼리 비용 | 단건 PK 조회 (저비용이나 빈도가 높음) |
+| 추천 TTL | **2시간** |
+| 캐시 키 | `brand:detail:{brandId}` |
+| 무효화 | 브랜드 수정/삭제 시 개별 키 삭제 |
+
+#### 발급 쿠폰 목록 — `GET /api/v1/users/me/coupons`
+
+| 항목 | 값 |
+|------|---|
+| 트래픽 | 사용자 대면, 쿠폰함 조회 |
+| 데이터 특성 | 변경 빈도 낮음 (발급/사용 시에만 변경) |
+| 쿼리 비용 | **N+1 패턴** — 사용자의 발급 쿠폰 조회 후, 각 쿠폰의 템플릿 정보 개별 조회 |
+| 추천 TTL | **15분** |
+| 캐시 키 | `user:{userId}:issued-coupons` |
+| 무효화 | 쿠폰 발급/사용 시 해당 사용자 키 삭제 |
+
+### 4-2. 중간 우선순위 (MEDIUM)
+
+#### 좋아요 여부 확인 — `GET /api/v1/users/me/product-likes/check`, `brand-likes/check`
+
+| 항목 | 값 |
+|------|---|
+| 트래픽 | 사용자 대면, 상품/브랜드 브라우징마다 호출 |
+| 데이터 특성 | boolean 결과, 좋아요 토글 시에만 변경 |
+| 쿼리 비용 | EXISTS 쿼리 (저비용이나 매우 빈번) |
+| 추천 TTL | **30분** |
+| 캐시 키 | `user:{userId}:liked:product:{targetId}` / `brand:{targetId}` |
+| 무효화 | 좋아요 등록/취소 시 해당 키 삭제 |
+
+#### 좋아요 목록 — `GET /api/v1/users/me/product-likes`, `brand-likes`
+
+| 항목 | 값 |
+|------|---|
+| 트래픽 | 사용자 대면, 마이페이지 접근 시 조회 |
+| 데이터 특성 | 세션 중 비교적 정적 |
+| 쿼리 비용 | 페이지네이션 쿼리 |
+| 추천 TTL | **30분** |
+| 캐시 키 | `user:{userId}:likes:product:page:{page}:{size}` |
+| 무효화 | 좋아요 등록/취소 시 패턴 삭제 |
+
+#### 장바구니 — `GET` (findByUserId)
+
+| 항목 | 값 |
+|------|---|
+| 트래픽 | 사용자 대면, 쇼핑 세션 중 빈번 조회 |
+| 데이터 특성 | 변경 잦음 (수량 변경, 선택/해제, 추가/삭제) |
+| 쿼리 비용 | 단순 SELECT (저비용) |
+| 추천 TTL | **5분** (짧은 TTL 필수) |
+| 캐시 키 | `user:{userId}:cart:items` |
+| 무효화 | 장바구니 항목 변경 시 해당 사용자 키 삭제 |
+
+### 4-3. 낮은 우선순위 (LOW) — 캐싱 미권장
+
+| 대상 | 미권장 사유 |
+|------|-----------|
+| 관리자 쿼리 전반 | 트래픽 미미, 실시간 데이터 필요 |
+| 주문 내역 (`GET /api/v1/orders`) | 날짜 파라미터로 캐시 키 폭발, 주문 상태 변경 빈번 |
+| 주문 상세 (`GET /api/v1/orders/{id}`) | 주문 상태 변경이 잦아 무효화 비용 > 캐싱 이점 |
+| 사용자 인증/정보 (`GET /api/v1/users/me`) | 보안 민감 정보, 비밀번호 변경 등으로 캐싱 부적합 |
+
+---
+
+## 5. 수정 파일 목록
+
+| 파일 | 변경 내용 |
+|------|----------|
+| `ProductReadModelEntity.java` | 9개 복합 인덱스 추가 (총 12개) |
+| `BrandEntity.java` | `idx_brands_deleted_visible` 인덱스 추가 |
+| `OrderEntity.java` | `idx_orders_user_created` 인덱스 추가 |
+| `OrderItemEntity.java` | `idx_order_items_order` 인덱스 추가 |
+| `CartItemEntity.java` | `idx_cart_user_selected`, `idx_cart_product` 인덱스 추가 |
+| `ProductLikeEntity.java` | `idx_likes_user_type_created`, `idx_likes_type_target` 인덱스 추가 |
+| `IssuedCouponEntity.java` | `idx_issued_coupon_user_created`, `idx_issued_coupon_template_created` 인덱스 추가 |
+| `CouponTemplateEntity.java` | `idx_coupon_template_deleted` 인덱스 추가 |

From d31dfd293eaffbcf3802500911e32750d3ae6710 Mon Sep 17 00:00:00 2001
From: Hwan0518 <qip0518@naver.com>
Date: Fri, 13 Mar 2026 11:46:11 +0900
Subject: [PATCH 9/9] =?UTF-8?q?refactor:=20cache=20=ED=8C=A8=ED=82=A4?=
 =?UTF-8?q?=EC=A7=80=20=EA=B5=AC=EC=A1=B0=20=EB=B6=84=EB=A6=AC=20(lock/,?=
 =?UTF-8?q?=20dto/)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- lock/: CacheLock, LocalCacheLock, RedisCacheLock (스탬피드 방지 관심사)
- dto/: ProductCacheDto, IdListCacheEntry (캐시 값 타입)
- ProductCacheManager, ProductCacheConstants는 cache/ 루트 유지
- 전체 import 경로 업데이트 (main + test)

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
---
 .../port/out/query/ProductQueryPort.java      |  4 +-
 .../service/ProductQueryService.java          |  4 +-
 .../infrastructure/cache/LocalCacheLock.java  | 46 -----------
 .../cache/ProductCacheManager.java            |  3 +
 .../cache/{ => dto}/IdListCacheEntry.java     |  2 +-
 .../cache/{ => dto}/ProductCacheDto.java      |  2 +-
 .../cache/{ => lock}/CacheLock.java           |  2 +-
 .../cache/lock/LocalCacheLock.java            | 78 +++++++++++++++++++
 .../cache/{ => lock}/RedisCacheLock.java      |  2 +-
 .../query/ProductQueryPortImpl.java           |  4 +-
 .../querydsl/ProductQuerydslRepository.java   |  4 +-
 .../service/ProductQueryServiceTest.java      |  4 +-
 .../cache/CacheStampedeTest.java              |  6 +-
 .../cache/ProductCacheManagerTest.java        |  2 +
 .../cache/{ => lock}/LocalCacheLockTest.java  | 14 ++--
 .../query/ProductQueryPortImplTest.java       |  4 +-
 16 files changed, 111 insertions(+), 70 deletions(-)
 delete mode 100644 apps/commerce-api/src/main/java/com/loopers/catalog/product/infrastructure/cache/LocalCacheLock.java
 rename apps/commerce-api/src/main/java/com/loopers/catalog/product/infrastructure/cache/{ => dto}/IdListCacheEntry.java (83%)
 rename apps/commerce-api/src/main/java/com/loopers/catalog/product/infrastructure/cache/{ => dto}/ProductCacheDto.java (94%)
 rename apps/commerce-api/src/main/java/com/loopers/catalog/product/infrastructure/cache/{ => lock}/CacheLock.java (83%)
 create mode 100644 apps/commerce-api/src/main/java/com/loopers/catalog/product/infrastructure/cache/lock/LocalCacheLock.java
 rename apps/commerce-api/src/main/java/com/loopers/catalog/product/infrastructure/cache/{ => lock}/RedisCacheLock.java (97%)
 rename apps/commerce-api/src/test/java/com/loopers/catalog/product/infrastructure/cache/{ => lock}/LocalCacheLockTest.java (90%)

diff --git a/apps/commerce-api/src/main/java/com/loopers/catalog/product/application/port/out/query/ProductQueryPort.java b/apps/commerce-api/src/main/java/com/loopers/catalog/product/application/port/out/query/ProductQueryPort.java
index f62fd7612..52dde7dd0 100644
--- a/apps/commerce-api/src/main/java/com/loopers/catalog/product/application/port/out/query/ProductQueryPort.java
+++ b/apps/commerce-api/src/main/java/com/loopers/catalog/product/application/port/out/query/ProductQueryPort.java
@@ -7,8 +7,8 @@
 import com.loopers.catalog.product.application.port.out.query.criteria.ProductSearchCriteria;
 import com.loopers.catalog.product.domain.repository.vo.PageCriteria;
 import com.loopers.catalog.product.domain.repository.vo.PageResult;
-import com.loopers.catalog.product.infrastructure.cache.IdListCacheEntry;
-import com.loopers.catalog.product.infrastructure.cache.ProductCacheDto;
+import com.loopers.catalog.product.infrastructure.cache.dto.IdListCacheEntry;
+import com.loopers.catalog.product.infrastructure.cache.dto.ProductCacheDto;
 
 import java.util.List;
 
diff --git a/apps/commerce-api/src/main/java/com/loopers/catalog/product/application/service/ProductQueryService.java b/apps/commerce-api/src/main/java/com/loopers/catalog/product/application/service/ProductQueryService.java
index 8a164cd1e..a218cf108 100644
--- a/apps/commerce-api/src/main/java/com/loopers/catalog/product/application/service/ProductQueryService.java
+++ b/apps/commerce-api/src/main/java/com/loopers/catalog/product/application/service/ProductQueryService.java
@@ -10,8 +10,8 @@
 import com.loopers.catalog.product.domain.repository.ProductReadModelRepository;
 import com.loopers.catalog.product.domain.repository.vo.PageCriteria;
 import com.loopers.catalog.product.domain.repository.vo.PageResult;
-import com.loopers.catalog.product.infrastructure.cache.IdListCacheEntry;
-import com.loopers.catalog.product.infrastructure.cache.ProductCacheDto;
+import com.loopers.catalog.product.infrastructure.cache.dto.IdListCacheEntry;
+import com.loopers.catalog.product.infrastructure.cache.dto.ProductCacheDto;
 import com.loopers.catalog.product.infrastructure.cache.ProductCacheManager;
 import com.loopers.support.common.error.CoreException;
 import com.loopers.support.common.error.ErrorType;
diff --git a/apps/commerce-api/src/main/java/com/loopers/catalog/product/infrastructure/cache/LocalCacheLock.java b/apps/commerce-api/src/main/java/com/loopers/catalog/product/infrastructure/cache/LocalCacheLock.java
deleted file mode 100644
index 756e20837..000000000
--- a/apps/commerce-api/src/main/java/com/loopers/catalog/product/infrastructure/cache/LocalCacheLock.java
+++ /dev/null
@@ -1,46 +0,0 @@
-package com.loopers.catalog.product.infrastructure.cache;
-
-
-import org.springframework.context.annotation.Primary;
-import org.springframework.stereotype.Component;
-
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.function.Supplier;
-
-
-/**
- * JVM 로컬 key-level 캐시 락
- * - ConcurrentHashMap + synchronized로 같은 key 요청만 직렬화
- * - 다른 key 요청은 병렬 처리 (key 단위 세밀한 락)
- * - 단일 서버 환경에서 사용. 분산 환경 전환 시 RedisCacheLock으로 @Primary 이동
- */
-@Primary
-@Component
-public class LocalCacheLock implements CacheLock {
-
-	private final ConcurrentHashMap<String, Object> locks = new ConcurrentHashMap<>();
-
-
-	/**
-	 * key-level 락 실행
-	 * 1. executeWithLock — 같은 key 요청은 직렬화, 다른 key는 병렬
-	 */
-
-	// 1. executeWithLock
-	@Override
-	public <T> T executeWithLock(String key, Supplier<T> loader) {
-
-		// key별 락 객체 생성 (이미 존재하면 기존 객체 반환)
-		Object lock = locks.computeIfAbsent(key, k -> new Object());
-
-		// 같은 key에 대해 직렬화 실행
-		synchronized (lock) {
-			try {
-				return loader.get();
-			} finally {
-				locks.remove(key);
-			}
-		}
-	}
-
-}
diff --git a/apps/commerce-api/src/main/java/com/loopers/catalog/product/infrastructure/cache/ProductCacheManager.java b/apps/commerce-api/src/main/java/com/loopers/catalog/product/infrastructure/cache/ProductCacheManager.java
index c11acec5e..aa38217c1 100644
--- a/apps/commerce-api/src/main/java/com/loopers/catalog/product/infrastructure/cache/ProductCacheManager.java
+++ b/apps/commerce-api/src/main/java/com/loopers/catalog/product/infrastructure/cache/ProductCacheManager.java
@@ -3,6 +3,9 @@
 
 import com.fasterxml.jackson.core.type.TypeReference;
 import com.fasterxml.jackson.databind.ObjectMapper;
+import com.loopers.catalog.product.infrastructure.cache.dto.IdListCacheEntry;
+import com.loopers.catalog.product.infrastructure.cache.dto.ProductCacheDto;
+import com.loopers.catalog.product.infrastructure.cache.lock.CacheLock;
 import com.loopers.config.redis.RedisConfig;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Qualifier;
diff --git a/apps/commerce-api/src/main/java/com/loopers/catalog/product/infrastructure/cache/IdListCacheEntry.java b/apps/commerce-api/src/main/java/com/loopers/catalog/product/infrastructure/cache/dto/IdListCacheEntry.java
similarity index 83%
rename from apps/commerce-api/src/main/java/com/loopers/catalog/product/infrastructure/cache/IdListCacheEntry.java
rename to apps/commerce-api/src/main/java/com/loopers/catalog/product/infrastructure/cache/dto/IdListCacheEntry.java
index 271b80d2b..060e8fdea 100644
--- a/apps/commerce-api/src/main/java/com/loopers/catalog/product/infrastructure/cache/IdListCacheEntry.java
+++ b/apps/commerce-api/src/main/java/com/loopers/catalog/product/infrastructure/cache/dto/IdListCacheEntry.java
@@ -1,4 +1,4 @@
-package com.loopers.catalog.product.infrastructure.cache;
+package com.loopers.catalog.product.infrastructure.cache.dto;
 
 
 import java.util.List;
diff --git a/apps/commerce-api/src/main/java/com/loopers/catalog/product/infrastructure/cache/ProductCacheDto.java b/apps/commerce-api/src/main/java/com/loopers/catalog/product/infrastructure/cache/dto/ProductCacheDto.java
similarity index 94%
rename from apps/commerce-api/src/main/java/com/loopers/catalog/product/infrastructure/cache/ProductCacheDto.java
rename to apps/commerce-api/src/main/java/com/loopers/catalog/product/infrastructure/cache/dto/ProductCacheDto.java
index 841a25f6a..9d133ac22 100644
--- a/apps/commerce-api/src/main/java/com/loopers/catalog/product/infrastructure/cache/ProductCacheDto.java
+++ b/apps/commerce-api/src/main/java/com/loopers/catalog/product/infrastructure/cache/dto/ProductCacheDto.java
@@ -1,4 +1,4 @@
-package com.loopers.catalog.product.infrastructure.cache;
+package com.loopers.catalog.product.infrastructure.cache.dto;
 
 
 import com.loopers.catalog.product.application.dto.out.ProductDetailOutDto;
diff --git a/apps/commerce-api/src/main/java/com/loopers/catalog/product/infrastructure/cache/CacheLock.java b/apps/commerce-api/src/main/java/com/loopers/catalog/product/infrastructure/cache/lock/CacheLock.java
similarity index 83%
rename from apps/commerce-api/src/main/java/com/loopers/catalog/product/infrastructure/cache/CacheLock.java
rename to apps/commerce-api/src/main/java/com/loopers/catalog/product/infrastructure/cache/lock/CacheLock.java
index f6bcd66dc..0506240ed 100644
--- a/apps/commerce-api/src/main/java/com/loopers/catalog/product/infrastructure/cache/CacheLock.java
+++ b/apps/commerce-api/src/main/java/com/loopers/catalog/product/infrastructure/cache/lock/CacheLock.java
@@ -1,4 +1,4 @@
-package com.loopers.catalog.product.infrastructure.cache;
+package com.loopers.catalog.product.infrastructure.cache.lock;
 
 
 import java.util.function.Supplier;
diff --git a/apps/commerce-api/src/main/java/com/loopers/catalog/product/infrastructure/cache/lock/LocalCacheLock.java b/apps/commerce-api/src/main/java/com/loopers/catalog/product/infrastructure/cache/lock/LocalCacheLock.java
new file mode 100644
index 000000000..b05848af2
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/catalog/product/infrastructure/cache/lock/LocalCacheLock.java
@@ -0,0 +1,78 @@
+package com.loopers.catalog.product.infrastructure.cache.lock;
+
+
+import org.springframework.context.annotation.Primary;
+import org.springframework.stereotype.Component;
+
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.locks.ReentrantLock;
+import java.util.function.Supplier;
+
+
+/**
+ * JVM 로컬 key-level 캐시 락
+ * - ConcurrentHashMap + ref-counted ReentrantLock으로 같은 key 요청만 직렬화
+ * - 다른 key 요청은 병렬 처리 (key 단위 세밀한 락)
+ * - 단일 서버 환경에서 사용. 분산 환경 전환 시 RedisCacheLock으로 @Primary 이동
+ */
+@Primary
+@Component
+public class LocalCacheLock implements CacheLock {
+
+	private final ConcurrentHashMap<String, LockHolder> locks = new ConcurrentHashMap<>();
+
+
+	/**
+	 * key-level 락 실행
+	 * 1. executeWithLock — 같은 key 요청은 직렬화, 다른 key는 병렬
+	 */
+
+	// 1. executeWithLock
+	@Override
+	public <T> T executeWithLock(String key, Supplier<T> loader) {
+		LockHolder holder = locks.compute(key, (ignored, existing) -> {
+			if (existing == null) {
+				return new LockHolder();
+			}
+			existing.retain();
+			return existing;
+		});
+
+		holder.lock();
+		try {
+			return loader.get();
+		} finally {
+			holder.unlock();
+			locks.compute(key, (ignored, existing) -> {
+				if (existing != holder) {
+					return existing;
+				}
+				return holder.release() ? null : holder;
+			});
+		}
+	}
+
+	private static final class LockHolder {
+
+		private final ReentrantLock lock = new ReentrantLock();
+		private final AtomicInteger refCount = new AtomicInteger(1);
+
+		private void retain() {
+			refCount.incrementAndGet();
+		}
+
+		private void lock() {
+			lock.lock();
+		}
+
+		private void unlock() {
+			lock.unlock();
+		}
+
+		private boolean release() {
+			return refCount.decrementAndGet() == 0;
+		}
+	}
+
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/catalog/product/infrastructure/cache/RedisCacheLock.java b/apps/commerce-api/src/main/java/com/loopers/catalog/product/infrastructure/cache/lock/RedisCacheLock.java
similarity index 97%
rename from apps/commerce-api/src/main/java/com/loopers/catalog/product/infrastructure/cache/RedisCacheLock.java
rename to apps/commerce-api/src/main/java/com/loopers/catalog/product/infrastructure/cache/lock/RedisCacheLock.java
index 381adae0f..86dc81037 100644
--- a/apps/commerce-api/src/main/java/com/loopers/catalog/product/infrastructure/cache/RedisCacheLock.java
+++ b/apps/commerce-api/src/main/java/com/loopers/catalog/product/infrastructure/cache/lock/RedisCacheLock.java
@@ -1,4 +1,4 @@
-package com.loopers.catalog.product.infrastructure.cache;
+package com.loopers.catalog.product.infrastructure.cache.lock;
 
 
 import com.loopers.config.redis.RedisConfig;
diff --git a/apps/commerce-api/src/main/java/com/loopers/catalog/product/infrastructure/query/ProductQueryPortImpl.java b/apps/commerce-api/src/main/java/com/loopers/catalog/product/infrastructure/query/ProductQueryPortImpl.java
index bd09bf8bb..cfae1257a 100644
--- a/apps/commerce-api/src/main/java/com/loopers/catalog/product/infrastructure/query/ProductQueryPortImpl.java
+++ b/apps/commerce-api/src/main/java/com/loopers/catalog/product/infrastructure/query/ProductQueryPortImpl.java
@@ -8,8 +8,8 @@
 import com.loopers.catalog.product.application.port.out.query.criteria.ProductSearchCriteria;
 import com.loopers.catalog.product.domain.repository.vo.PageCriteria;
 import com.loopers.catalog.product.domain.repository.vo.PageResult;
-import com.loopers.catalog.product.infrastructure.cache.IdListCacheEntry;
-import com.loopers.catalog.product.infrastructure.cache.ProductCacheDto;
+import com.loopers.catalog.product.infrastructure.cache.dto.IdListCacheEntry;
+import com.loopers.catalog.product.infrastructure.cache.dto.ProductCacheDto;
 import com.loopers.catalog.product.infrastructure.querydsl.ProductQuerydslRepository;
 import lombok.RequiredArgsConstructor;
 import org.springframework.stereotype.Repository;
diff --git a/apps/commerce-api/src/main/java/com/loopers/catalog/product/infrastructure/querydsl/ProductQuerydslRepository.java b/apps/commerce-api/src/main/java/com/loopers/catalog/product/infrastructure/querydsl/ProductQuerydslRepository.java
index 6d85ee2f9..d3cdbe90f 100644
--- a/apps/commerce-api/src/main/java/com/loopers/catalog/product/infrastructure/querydsl/ProductQuerydslRepository.java
+++ b/apps/commerce-api/src/main/java/com/loopers/catalog/product/infrastructure/querydsl/ProductQuerydslRepository.java
@@ -8,8 +8,8 @@
 import com.loopers.catalog.product.domain.model.enums.ProductSortType;
 import com.loopers.catalog.product.domain.repository.vo.PageCriteria;
 import com.loopers.catalog.product.domain.repository.vo.PageResult;
-import com.loopers.catalog.product.infrastructure.cache.IdListCacheEntry;
-import com.loopers.catalog.product.infrastructure.cache.ProductCacheDto;
+import com.loopers.catalog.product.infrastructure.cache.dto.IdListCacheEntry;
+import com.loopers.catalog.product.infrastructure.cache.dto.ProductCacheDto;
 import com.loopers.catalog.product.infrastructure.entity.QProductReadModelEntity;
 import com.querydsl.core.types.OrderSpecifier;
 import com.querydsl.core.types.Projections;
diff --git a/apps/commerce-api/src/test/java/com/loopers/catalog/product/application/service/ProductQueryServiceTest.java b/apps/commerce-api/src/test/java/com/loopers/catalog/product/application/service/ProductQueryServiceTest.java
index f0fc520de..1e11ff65a 100644
--- a/apps/commerce-api/src/test/java/com/loopers/catalog/product/application/service/ProductQueryServiceTest.java
+++ b/apps/commerce-api/src/test/java/com/loopers/catalog/product/application/service/ProductQueryServiceTest.java
@@ -13,8 +13,8 @@
 import com.loopers.catalog.product.domain.repository.ProductReadModelRepository;
 import com.loopers.catalog.product.domain.repository.vo.PageCriteria;
 import com.loopers.catalog.product.domain.repository.vo.PageResult;
-import com.loopers.catalog.product.infrastructure.cache.IdListCacheEntry;
-import com.loopers.catalog.product.infrastructure.cache.ProductCacheDto;
+import com.loopers.catalog.product.infrastructure.cache.dto.IdListCacheEntry;
+import com.loopers.catalog.product.infrastructure.cache.dto.ProductCacheDto;
 import com.loopers.catalog.product.infrastructure.cache.ProductCacheManager;
 import com.loopers.support.common.error.CoreException;
 import com.loopers.support.common.error.ErrorType;
diff --git a/apps/commerce-api/src/test/java/com/loopers/catalog/product/infrastructure/cache/CacheStampedeTest.java b/apps/commerce-api/src/test/java/com/loopers/catalog/product/infrastructure/cache/CacheStampedeTest.java
index 76d82a796..b92de09ff 100644
--- a/apps/commerce-api/src/test/java/com/loopers/catalog/product/infrastructure/cache/CacheStampedeTest.java
+++ b/apps/commerce-api/src/test/java/com/loopers/catalog/product/infrastructure/cache/CacheStampedeTest.java
@@ -48,7 +48,7 @@ void tearDown() {
 	class GetOrLoadStampedeTest {
 
 		@Test
-		@DisplayName("[getOrLoad()] single-key 스탬피드 - 캐시 미스 상태에서 100개 동시 요청 -> loader 호출 최소화 (이상: 1회)")
+		@DisplayName("[getOrLoad()] single-key 스탬피드 - 캐시 미스 상태에서 100개 동시 요청 -> loader 정확히 1회")
 		void singleKeyStampede_loaderMinimized() throws InterruptedException {
 
 			// Arrange
@@ -99,8 +99,8 @@ void singleKeyStampede_loaderMinimized() throws InterruptedException {
 			doneLatch.await();
 			executor.shutdown();
 
-			// Assert — loader 호출 최소화 (이상: 1회, 레이스 컨디션 허용: <= 2)
-			assertThat(loaderCallCount.get()).isLessThanOrEqualTo(2);
+			// Assert — 같은 key miss는 1회만 DB 로드되고 나머지는 double-check로 캐시 재사용
+			assertThat(loaderCallCount.get()).isEqualTo(1);
 		}
 
 
diff --git a/apps/commerce-api/src/test/java/com/loopers/catalog/product/infrastructure/cache/ProductCacheManagerTest.java b/apps/commerce-api/src/test/java/com/loopers/catalog/product/infrastructure/cache/ProductCacheManagerTest.java
index 65eb4cbd0..2c028fc68 100644
--- a/apps/commerce-api/src/test/java/com/loopers/catalog/product/infrastructure/cache/ProductCacheManagerTest.java
+++ b/apps/commerce-api/src/test/java/com/loopers/catalog/product/infrastructure/cache/ProductCacheManagerTest.java
@@ -4,6 +4,8 @@
 import com.loopers.catalog.product.application.dto.out.ProductDetailOutDto;
 import com.loopers.catalog.product.application.dto.out.ProductOutDto;
 import com.loopers.catalog.product.application.dto.out.ProductPageOutDto;
+import com.loopers.catalog.product.infrastructure.cache.dto.IdListCacheEntry;
+import com.loopers.catalog.product.infrastructure.cache.dto.ProductCacheDto;
 import com.loopers.testcontainers.MySqlTestContainersConfig;
 import com.loopers.testcontainers.RedisTestContainersConfig;
 import com.loopers.utils.RedisCleanUp;
diff --git a/apps/commerce-api/src/test/java/com/loopers/catalog/product/infrastructure/cache/LocalCacheLockTest.java b/apps/commerce-api/src/test/java/com/loopers/catalog/product/infrastructure/cache/lock/LocalCacheLockTest.java
similarity index 90%
rename from apps/commerce-api/src/test/java/com/loopers/catalog/product/infrastructure/cache/LocalCacheLockTest.java
rename to apps/commerce-api/src/test/java/com/loopers/catalog/product/infrastructure/cache/lock/LocalCacheLockTest.java
index 6d9665970..e906b0b8e 100644
--- a/apps/commerce-api/src/test/java/com/loopers/catalog/product/infrastructure/cache/LocalCacheLockTest.java
+++ b/apps/commerce-api/src/test/java/com/loopers/catalog/product/infrastructure/cache/lock/LocalCacheLockTest.java
@@ -1,4 +1,4 @@
-package com.loopers.catalog.product.infrastructure.cache;
+package com.loopers.catalog.product.infrastructure.cache.lock;
 
 
 import org.junit.jupiter.api.BeforeEach;
@@ -32,7 +32,7 @@ void setUp() {
 	class ExecuteWithLockTest {
 
 		@Test
-		@DisplayName("[executeWithLock()] 같은 key 100개 동시 요청 -> 직렬 실행으로 loader 100회 호출. 스탬피드 보호는 CacheManager double-check에서 수행")
+		@DisplayName("[executeWithLock()] 같은 key 100개 동시 요청 -> 최대 동시 실행 수 1, 순차 직렬화")
 		void sameKeyConcurrentRequests_loaderCalledOnce() throws InterruptedException {
 
 			// Arrange
@@ -42,6 +42,8 @@ void sameKeyConcurrentRequests_loaderCalledOnce() throws InterruptedException {
 			CountDownLatch startLatch = new CountDownLatch(1);
 			CountDownLatch doneLatch = new CountDownLatch(threadCount);
 			AtomicInteger loaderCallCount = new AtomicInteger(0);
+			AtomicInteger concurrentCount = new AtomicInteger(0);
+			AtomicInteger maxConcurrent = new AtomicInteger(0);
 			String key = "same-key";
 
 			// Act
@@ -52,12 +54,16 @@ void sameKeyConcurrentRequests_loaderCalledOnce() throws InterruptedException {
 						startLatch.await();
 						localCacheLock.executeWithLock(key, () -> {
 							loaderCallCount.incrementAndGet();
+							int current = concurrentCount.incrementAndGet();
+							maxConcurrent.updateAndGet(max -> Math.max(max, current));
 
 							// loader 실행에 시간이 걸리는 상황 시뮬레이션
 							try {
 								Thread.sleep(50);
 							} catch (InterruptedException e) {
 								Thread.currentThread().interrupt();
+							} finally {
+								concurrentCount.decrementAndGet();
 							}
 
 							return "result";
@@ -76,10 +82,8 @@ void sameKeyConcurrentRequests_loaderCalledOnce() throws InterruptedException {
 			doneLatch.await();
 			executor.shutdown();
 
-			// Assert — 락에 의해 loader는 직렬 실행되므로 100회 호출 (대기 후 순차 실행)
-			// LocalCacheLock은 결과 캐싱을 하지 않으므로 각 스레드가 순서대로 loader 호출
-			// 실제 스탬피드 보호는 ProductCacheManager의 double-check 패턴에서 수행
 			assertThat(loaderCallCount.get()).isEqualTo(threadCount);
+			assertThat(maxConcurrent.get()).isEqualTo(1);
 		}
 
 
diff --git a/apps/commerce-api/src/test/java/com/loopers/catalog/product/infrastructure/query/ProductQueryPortImplTest.java b/apps/commerce-api/src/test/java/com/loopers/catalog/product/infrastructure/query/ProductQueryPortImplTest.java
index 60837bfa0..2ebcfe23b 100644
--- a/apps/commerce-api/src/test/java/com/loopers/catalog/product/infrastructure/query/ProductQueryPortImplTest.java
+++ b/apps/commerce-api/src/test/java/com/loopers/catalog/product/infrastructure/query/ProductQueryPortImplTest.java
@@ -8,8 +8,8 @@
 import com.loopers.catalog.product.application.dto.out.AdminProductOutDto;
 import com.loopers.catalog.product.application.dto.out.ProductOutDto;
 import com.loopers.catalog.product.application.port.out.query.ProductQueryPort;
-import com.loopers.catalog.product.infrastructure.cache.IdListCacheEntry;
-import com.loopers.catalog.product.infrastructure.cache.ProductCacheDto;
+import com.loopers.catalog.product.infrastructure.cache.dto.IdListCacheEntry;
+import com.loopers.catalog.product.infrastructure.cache.dto.ProductCacheDto;
 import com.loopers.catalog.product.application.port.out.query.criteria.ProductSearchCriteria;
 import com.loopers.catalog.product.domain.model.Product;
 import com.loopers.catalog.product.domain.model.enums.ProductSortType;