diff --git a/.claude/settings.local.json b/.claude/settings.local.json
index 6e904ea4e..91be3457a 100644
--- a/.claude/settings.local.json
+++ b/.claude/settings.local.json
@@ -1,7 +1,39 @@
 {
   "permissions": {
     "allow": [
-      "Bash(git add:*)"
+      "Bash(git add:*)",
+      "Bash(./gradlew :apps:commerce-api:test:*)",
+      "Bash(./gradlew:*)",
+      "Bash(find /mnt/c/Users/kdj10/Git/loop-pack-be-l2-vol3-java -name \"CacheConfig.java\" -o -name \"*CacheConfig*\" 2>/dev/null | head -20)",
+      "Bash(JAVA_HOME=\"/mnt/c/Users/kdj10/.jdks/ms-21.0.10\" ./gradlew :apps:commerce-api:compileJava 2>&1 | tail -30)",
+      "Bash(ls \"/mnt/c/Users/kdj10/.jdks/ms-21.0.10/bin/\" | head -5; \"/mnt/c/Users/kdj10/.jdks/ms-21.0.10/bin/java\" -version 2>&1 | head -3)",
+      "Read(//home/ubuntu/projects/loop-pack-be-l2-vol3-java/**)",
+      "Bash(sg docker:*)",
+      "Bash(cd ~/projects/loop-pack-be-l2-vol3-java && sg docker -c \"./gradlew :apps:commerce-api:test --tests 'com.loopers.domain.brand.BrandServiceTest'\" 2>&1 | grep -A5 \"FAILED\")",
+      "Bash(cd ~/projects/loop-pack-be-l2-vol3-java && sg docker -c \"./gradlew :apps:commerce-api:test --tests 'com.loopers.domain.*'\" 2>&1 | grep \"FAILED\\\\|tests completed\" | tail -5)",
+      "Bash(cd ~/projects/loop-pack-be-l2-vol3-java && sg docker -c \"./gradlew :apps:commerce-api:test --tests 'com.loopers.domain.coupon.CouponModelTest'\" 2>&1 | grep -A3 \"FAILED\")",
+      "Bash(cd ~/projects/loop-pack-be-l2-vol3-java && sg docker -c \"./gradlew :apps:commerce-api:test --tests 'com.loopers.domain.order.OrderCartRestoreIdempotencyTest'\" 2>&1 | grep -A3 \"FAILED\")",
+      "Bash(cd ~/projects/loop-pack-be-l2-vol3-java && sg docker -c \"./gradlew :apps:commerce-api:test --tests 'com.loopers.infrastructure.*'\" 2>&1 | grep \"FAILED\\\\|tests completed\" | tail -5)",
+      "Bash(chmod +x /mnt/c/Users/kdj10/Git/loop-pack-be-l2-vol3-java/k6/seed.sh)",
+      "Bash(docker compose:*)",
+      "Bash(docker ps:*)",
+      "Bash(mysql -h 127.0.0.1 -P 3306 -u application -papplication loopers -e \"\nSELECT 'users' AS tbl, COUNT\\(*\\) AS cnt FROM users\nUNION ALL\nSELECT 'brands', COUNT\\(*\\) FROM brands\nUNION ALL\nSELECT 'products', COUNT\\(*\\) FROM products\nUNION ALL\nSELECT 'product_stocks', COUNT\\(*\\) FROM product_stocks;\n\" 2>/dev/null)",
+      "Bash(docker exec:*)",
+      "Bash(pip3 install:*)",
+      "Bash(python3 docs/DDL/seed.py 2>&1)",
+      "Bash(curl -s -X POST http://localhost:8080/api/v1/users \\\\\n  -H \"Content-Type: application/json; charset=UTF-8\" \\\\\n  -d '{\"loginId\":\"testuser\",\"password\":\"Test1234!\",\"userName\":\"testuser\",\"birthday\":\"19900101\",\"email\":\"test@loopers.com\",\"address\":\"Seoul\"}' 2>/dev/null)",
+      "Bash(curl -v -X POST http://localhost:8080/api/v1/users \\\\\n  -H \"Content-Type: application/json\" \\\\\n  -d '{\"loginId\":\"testuser\",\"password\":\"Test1234!\",\"userName\":\"testuser\",\"birthday\":\"19900101\",\"email\":\"test@loopers.com\",\"address\":\"Seoul\"}' 2>&1 | tail -20)",
+      "Bash(curl -s http://localhost:8080/api/v1/products/1 \\\\\n  -H \"X-Loopers-LoginId: testuser\" \\\\\n  -H \"X-Loopers-LoginPw: Test1234!\" | python3 -m json.tool 2>/dev/null | head -20)",
+      "Bash(sleep 40 && curl -s -o /dev/null -w \"%{http_code}\" http://localhost:8080/actuator/health 2>/dev/null || echo \"not ready\")",
+      "Bash(kill 88108 2>/dev/null; sleep 15 && curl -s -o /dev/null -w \"%{http_code}\" http://localhost:8080/actuator/health)",
+      "Bash(sleep 20 && curl -s -o /dev/null -w \"%{http_code}\" http://localhost:8080/actuator/health)",
+      "Bash(curl -s -o /dev/null -w \"%{http_code}\" -H \"X-Loopers-LoginId: testuser\" -H \"X-Loopers-LoginPw: Test1234!\" \"http://localhost:8080/api/v1/products/1\")",
+      "Bash(docker run:*)",
+      "Bash(find /mnt/c/Users/kdj10/Git/loop-pack-be-l2-vol3-java/apps/commerce-api/src/main/java/com/loopers/infrastructure/cache -type f -name \"*.java\" 2>/dev/null | sort)",
+      "Bash(find:*)",
+      "Bash(git checkout:*)",
+      "Bash(BASE=~/projects/loop-pack-be-l2-vol3-java/apps/commerce-api/src)",
+      "Read(//mnt/c/Users/kdj10/Git/loop-pack-be-l2-vol3-java/$BASE/main/java/com/loopers/infrastructure/cache/**)"
     ]
   },
   "hooks": {
diff --git a/.claude/skills/anaylize-query/SKILL.md b/.claude/skills/anaylize-query/SKILL.md
new file mode 100644
index 000000000..d160c04a8
--- /dev/null
+++ b/.claude/skills/anaylize-query/SKILL.md
@@ -0,0 +1,97 @@
+---
+name: analyze-query
+description:
+  대상이 되는 코드 범위를 탐색하고, Spring @Transactional, JPA, QueryDSL 기반의 코드에 대해 트랜잭션 범위, 영속성 컨텍스트, 쿼리 실행 시점 관점에서 분석한다.
+  
+  특히 다음을 중점적으로 점검한다.
+  - 트랜잭션이 불필요하게 크게 잡혀 있지는 않은지
+  - 조회/쓰기 로직이 하나의 트랜잭션에 혼합되어 있지는 않은지
+  - JPA의 지연 로딩, flush 타이밍, 변경 감지로 인해
+    의도치 않은 쿼리 또는 락이 발생할 가능성은 없는지
+
+  단순한 정답 제시가 아니라, 현재 구조의 의도와 trade-off를 드러내고 개선 가능 지점을 선택적으로 판단할 수 있도록 돕는다.
+---
+
+### 📌 Analysis Scope
+이 스킬은 아래 대상에 대해 분석한다.
+- @Transactional 이 선언된 클래스 / 메서드
+- Service / Facade / Application Layer 코드
+- JPA Entity, Repository, QueryDSL 사용 코드
+- 하나의 유즈케이스(요청 흐름) 단위
+> 컨트롤러 → 서비스 → 레포지토리 전체 흐름을 기준으로 분석하며 특정 메서드만 떼어내어 판단하지 않는다.
+
+### 🔍 Analysis Checklist
+#### 1. Transaction Boundary 분석
+다음을 순서대로 확인한다.
+- 트랜잭션 시작 지점은 어디인가?
+    - Service / Facade / 그 외 계층?
+- 트랜잭션이 실제로 필요한 작업은 무엇인가?
+    - 상태 변경 (쓰기)
+    - 단순 조회
+- 트랜잭션 내부에서 수행되는 작업 나열
+    - 외부 API 호출
+    - 복잡한 조회(QueryDSL)
+    - 반복문 기반 처리
+
+**출력 예시**
+```markdown
+- 현재 트랜잭션 범위:
+OrderFacade.placeOrder()
+  ├─ 유저 검증
+  ├─ 상품 조회
+  ├─ 주문 생성
+  ├─ 결제 요청
+  └─ 재고 차감
+
+- 트랜잭션이 필요한 핵심 작업:
+- 주문 생성
+- 재고 차감
+```
+
+#### 2. 불필요하게 큰 트랜잭션 식별
+아래 패턴이 존재하는지 점검한다.
+- Controller 에서 Transactional 이 사용되고 있음
+- 읽기 전용 로직이 쓰기 트랜잭션에 포함됨
+- 외부 시스템 호출이 트랜잭션 내부에 포함됨
+- 트랜잭션 내부에서 대량 조회 / 복잡한 QueryDSL 실행
+- 상태 변경 이후에도 트랜잭션이 길게 유지됨
+
+**문제 후보 예시**
+- 결제 API 호출이 트랜잭션 내부에 포함되어 있음
+- 주문 생성 이후 추천 상품 조회 로직까지 동일 트랜잭션에 포함됨
+
+#### 3. JPA / 영속성 컨텍스트 관점 분석
+다음을 중심으로 분석한다.
+- Entity 변경이 언제 flush 되는지
+- 조회용 Entity가 변경 감지 대상이 되는지
+- 지연 로딩으로 인해 트랜잭션 후반에 쿼리가 발생할 가능성
+- @Transactional(readOnly = true) 미적용 여부
+
+**체크리스트 예시**
+```markdown
+- 단순 조회인데 Entity 반환 후 변경 가능성 존재?
+- DTO Projection 대신 Entity 조회 사용 여부
+- QueryDSL 조회 결과가 영속성 컨텍스트에 포함되는지
+```
+
+#### 4. Improvement Proposal (선택적 제안)
+개선안은 강제하지 않고 선택지로 제시한다.
+- 트랜잭션 분리
+    - 조회 → 쓰기 분리
+    - Facade에서 orchestration, Service는 최소 트랜잭션
+- `@Transactional(readOnly = true)` 적용
+- DTO Projection (읽기 전용 모델) 도입
+- 외부 호출 / 이벤트 발행을 트랜잭션 외부로 이동
+- Application Service / Domain Service 책임 재조정
+
+**개선안 예시**
+```markdown
+[개선안 1]
+- 주문 생성과 결제 요청을 분리
+- 주문 생성까지만 트랜잭션 유지
+- 결제 요청은 트랜잭션 종료 후 수행
+
+[고려 사항]
+- 결제 실패 시 주문 상태 관리 필요
+- 보상 트랜잭션 또는 상태 전이 설계 필요
+```
\ No newline at end of file
diff --git a/.claude/skills/anylize-external-integration/SKILL.md b/.claude/skills/anylize-external-integration/SKILL.md
new file mode 100644
index 000000000..3fdbb93d6
--- /dev/null
+++ b/.claude/skills/anylize-external-integration/SKILL.md
@@ -0,0 +1,72 @@
+---
+name: analyze-external-integration
+description:
+  외부 시스템(결제, 재고 시스템, 메시징, 서드파티 API 등)과 연동되는 기능의 설계를 분석한다.
+  트랜잭션 경계, 상태 일관성, 실패 시나리오, 재시도 및 중복 실행 가능성을 중심으로 리스크를 드러낸다.
+  설계를 대신 생성하지 않으며, 이미 작성된 설계를 검증하고 개선 선택지를 제시하는 데 사용한다.
+  외부 시스템 호출이 포함된 기능 구현 전/후 설계 리뷰 목적으로 사용한다.
+---
+
+외부 시스템 연동 설계를 분석할 때 반드시 다음 흐름을 따른다.
+
+### 1️⃣ 기능이 아니라 "불확실성" 관점으로 재해석한다
+- 단순 호출 순서를 요약하지 않는다.
+- 외부 시스템은 항상 다음을 만족한다고 가정한다:
+    - 지연될 수 있다
+    - 실패할 수 있다
+    - 중복 실행될 수 있다
+    - 성공했지만 응답이 유실될 수 있다
+- 현재 설계가 이러한 불확실성을 어떻게 다루는지 설명한다.
+
+---
+
+### 2️⃣ 트랜잭션 경계를 검증한다
+- 외부 호출이 트랜잭션 내부에 존재하는지 확인한다.
+- 외부 시스템과 내부 DB 상태가 하나의 트랜잭션처럼 다뤄지고 있는지 분석한다.
+- 다음 질문을 반드시 포함한다:
+    - 외부 호출 실패 시 내부 상태는 어떻게 되는가?
+    - 내부 커밋 이후 외부 호출 실패 시 복구 가능한가?
+    - 외부 성공 후 내부 실패 시 상태는 어떻게 정합성을 유지하는가?
+
+---
+
+### 3️⃣ 상태 기반으로 구조를 다시 본다
+- 호출 흐름이 아니라 상태 전이를 중심으로 설명한다.
+- 내부 도메인 상태와 외부 시스템 상태를 분리해서 정리한다.
+- 두 상태가 어긋날 수 있는 지점을 명시한다.
+
+---
+
+### 4️⃣ 중복 요청 및 재시도 가능성을 분석한다
+- 네트워크 재시도 상황을 가정한다.
+- 동일 요청이 두 번 실행될 경우 문제를 설명한다.
+- 멱등성(Idempotency) 고려 여부를 확인한다.
+
+---
+
+### 5️⃣ 장애 시나리오를 최소 3가지 이상 생성한다
+- 정상 흐름보다 실패 흐름을 우선한다.
+- 각 장애 상황에서:
+    - 데이터 정합성
+    - 상태 불일치
+    - 복구 가능성
+      을 분석한다.
+
+---
+
+### 6️⃣ 해결책은 정답처럼 제시하지 않는다
+- 현재 구조의 장점과 리스크를 분리한다.
+- 대안 구조가 있다면 선택지 형태로 제시한다.
+  예:
+    - 동기 호출 유지
+    - 상태 기반 단계 분리
+    - 비동기 이벤트 전환
+- 각 선택지의 복잡도와 운영 부담을 함께 설명한다.
+
+---
+
+### 7️⃣ 톤 & 스타일 가이드
+- 코드 레벨 수정안을 직접 제시하지 않는다.
+- 설계를 비판하지 말고 리스크를 드러내는 리뷰 톤을 유지한다.
+- 외부 시스템은 항상 신뢰할 수 없다는 전제를 유지한다.
+- 구현보다 책임, 경계, 상태 일관성을 중심으로 분석한다.
diff --git a/.venv/pyvenv.cfg b/.venv/pyvenv.cfg
new file mode 100644
index 000000000..1e38fd845
--- /dev/null
+++ b/.venv/pyvenv.cfg
@@ -0,0 +1,5 @@
+home = /usr/bin
+include-system-site-packages = false
+version = 3.12.3
+executable = /usr/bin/python3.12
+command = /usr/bin/python3 -m venv /mnt/c/Users/kdj10/Git/loop-pack-be-l2-vol3-java/.venv
diff --git a/CLAUDE.md b/CLAUDE.md
index 3b9ee7594..25e33f2a3 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -64,43 +64,46 @@ Only `apps/*` modules produce BootJar. All other modules produce plain Jar.
 Layered Architecture with strict dependency direction (DIP):
 
 ```
+CustomerAuthInterceptor (고객 인증, userId를 request attribute에 저장)
+    ↓
 interfaces/ → application/ → domain/ ← infrastructure/
-(Controller)   (AppService/Facade)  (Service, Model, Repository interface)   (Repository impl)
+(Controller)   (Facade only)    (Service, Model, Repository interface)   (Repository impl)
 ```
 
 ### Application Layer 적용 기준
 
 | 구분 | 구조 | 해당 도메인 |
 |------|------|------------|
-| **단순 도메인** | Controller → **AppService** → Service (returns Model) | Example, User, Brand, Like, Stats |
-| **복잡한 도메인** | Controller → **Facade** → 여러 Service (returns Model) | Product, Cart, Order |
+| **단순 도메인** | Controller → **Service** 직접 호출 | User, Brand, Like, Stats |
+| **복잡한 도메인** | Controller → **Facade** → 여러 Service | Product, Cart, Order |
 
-- **AppService**: 단일 도메인 서비스를 호출하고 Model → Info 변환을 담당하는 얇은 application 레이어 클래스.
-- **Facade**: 여러 도메인 서비스를 조합(orchestration)하고 Model → Info 변환을 담당하는 application 레이어 클래스.
-- **도메인 서비스는 Model을 반환**한다. Info DTO 변환은 항상 application 레이어(AppService/Facade)에서 수행한다.
+- **Facade**: 여러 도메인 서비스를 조합(orchestration)하고, 복잡한 비즈니스 플로우(재고 hold/release, 보상 트랜잭션 등)를 담당하는 application 레이어 클래스.
+- **단순 도메인은 AppService 없이 Controller에서 Service를 직접 호출**한다.
+- **인증은 `CustomerAuthInterceptor`에서 처리**하고, 인증된 사용자는 `@AuthUser` 어노테이션으로 Controller에 주입된다.
 
 ### Layer Responsibilities
 
-**interfaces/** — HTTP concerns only. Controllers receive requests, call AppService/Facade, return `ApiResponse<T>`.
+**interfaces/** — HTTP concerns only. Controllers receive requests, call Service/Facade, return `ApiResponse<T>`.
 - DTOs are inner static classes in a wrapper class (e.g., `UserV1Dto.RegisterRequest`, `UserV1Dto.RegisterResponse`)
 - Request DTOs use Bean Validation annotations (`@NotBlank`, `@Size`, etc.)
-- Response DTOs have `static from(Info)` factory methods
+- Response DTOs have `static from(Model)` factory methods — 도메인 모델에서 직접 변환
 - All responses wrapped in `ApiResponse<T>` — `record ApiResponse<T>(Metadata meta, T data)`
+- `CustomerAuthInterceptor`: 고객 API 인증 처리, `@AuthUser`로 인증된 사용자 주입
+- `AdminAuthInterceptor`: 관리자 API 인증 처리
 
-**application/** — AppService (단순) / Facade (복잡). Orchestrates domain services, sets transaction boundaries, converts Domain Model → Info DTO.
-- AppService: `*AppService` (annotated `@Service`) — 단일 서비스 호출 + Model → Info 변환
-- Facade: `*Facade` (annotated `@Service`) — 여러 서비스 조합 + Model → Info 변환
-- `*Info` DTO는 여기에 위치 — application 레이어에서 정의, interfaces 레이어로 전달
+**application/** — Facade만 사용 (복잡한 도메인). 여러 도메인 서비스를 조합, 트랜잭션 경계 설정.
+- Facade: `*Facade` (annotated `@Service`) — 여러 서비스 조합 + 트랜잭션 관리
+- `*Info` DTO는 복잡한 도메인(Order, Cart, Product)에서 조합된 결과를 표현할 때만 사용
 - `@Transactional(readOnly = true)` at class level, `@Transactional` on write methods
 
 **domain/** — Business logic. Service + Model (JPA Entity) + Repository interface.
-- `*Service` contains business logic, returns `*Model` (NOT Info DTO)
+- `*Service` contains business logic, returns `*Model`
 - `*Model` is the JPA entity with validation logic and factory methods
-- `*Repository` is a plain Java interface (no Spring Data extends). Repository 반환 타입도 도메인 레이어 타입만 사용 (application 레이어 DTO 금지)
-- 통계 등 집계 쿼리는 `*Projection` DTO를 도메인 레이어에 정의하여 Repository/Service가 반환하고, application 레이어에서 `*Info`로 변환한다 (예: `StatsProjection` → `StatsInfo`)
+- `*Repository` is a plain Java interface (no Spring Data extends)
+- 통계 등 집계 쿼리는 `*Projection` DTO를 도메인 레이어에 정의하여 Repository/Service가 반환하고, Controller에서 Response DTO로 변환한다
 - Domain models do NOT depend on infrastructure (e.g., password encoding via `PasswordEncoder` interface defined in domain)
 - 비즈니스 규칙은 도메인 객체/enum에 캡슐화한다 (예: `UnavailableReason.evaluate()` 정적 팩토리로 주문 불가 사유 판별)
-- **도메인 서비스 독립성**: `*Service`는 자신의 Repository만 의존한다. 다른 도메인 서비스를 직접 참조하지 않는다. 크로스 도메인 조합은 반드시 AppService/Facade에서 수행한다.
+- **도메인 서비스 크로스 참조 허용**: `*Service`는 비즈니스 로직 수행을 위해 다른 `*Service`를 참조할 수 있다. (예: `LikeService` → `ProductService`로 상품 존재 검증)
 
 **infrastructure/** — Implements domain repository interfaces.
 - `*RepositoryImpl` delegates to `*JpaRepository` (Spring Data JPA)
@@ -108,22 +111,22 @@ interfaces/ → application/ → domain/ ← infrastructure/
 
 ### DTO Conversion Chain
 
-**단순 도메인**: `V1Dto.Request` → AppService → Service (returns Model) → `Info.from(Model)` → `V1Dto.Response`
-**복잡한 도메인**: `V1Dto.Request` → Facade → 여러 Service (returns Model) → `Info.from(Model)` → `V1Dto.Response`
+**단순 도메인**: `V1Dto.Request` → Service (returns Model) → `V1Dto.Response.from(Model)`
+**복잡한 도메인**: `V1Dto.Request` → Facade → 여러 Service (returns Model) → `Info.from(Model)` → `V1Dto.Response.from(Info)`
 
 ## Domain Catalog
 
 | 도메인 | 설명 | Base Entity | Application Layer |
 |--------|------|-------------|-------------------|
-| **Example** | 예제 도메인 | `BaseEntity` (Long PK) | AppService |
-| **User** | 회원 (Like/Cart/Order가 참조) | `BaseStringIdEntity` (String PK) | AppService |
-| **Brand** | 브랜드 CRUD, 소프트 삭제, display_status | `BaseStringIdEntity` | AppService |
+| **Example** | 예제 도메인 | `BaseEntity` (Long PK) | - |
+| **User** | 회원 (Like/Cart/Order가 참조) | `BaseStringIdEntity` (Long PK) | Service 직접 호출 |
+| **Brand** | 브랜드 CRUD, 소프트 삭제, display_status | `BaseStringIdEntity` | Service 직접 호출 |
 | **Product** | 상품 CRUD, revision 이력, sale_status | `BaseStringIdEntity` | Facade |
 | **ProductStock** | 재고 관리 (on_hand, reserved), CAS hold/release | - | (Product Facade) |
-| **Like** | 상품 좋아요 등록/취소 (멱등), 복합 PK | `BaseStringIdEntity` | AppService |
+| **Like** | 상품 좋아요 등록/취소 (멱등), 복합 PK, ProductService 참조 | `BaseStringIdEntity` | Service 직접 호출 |
 | **Cart** | 장바구니 CRUD, 주문 연계 복원, 복합 PK | `BaseStringIdEntity` | Facade |
 | **Order** | 주문 생성(DIRECT/CART), 취소, 만료 | `BaseStringIdEntity` | Facade |
-| **Stats** | 운영 통계 (주문 현황, 인기 상품) | - | AppService |
+| **Stats** | 운영 통계 (주문 현황, 인기 상품) | - | Service 직접 호출 |
 
 ## Entity Base Classes
 
@@ -131,7 +134,7 @@ Two coexisting base entity patterns in `modules/jpa`:
 
 | 항목 | `BaseEntity` (기존) | `BaseStringIdEntity` (신규) |
 |------|--------------------|-----------------------------|
-| PK | `Long` (auto-increment) | 서브클래스에서 `@Id @UuidGenerator`로 정의 (String UUID 36자) |
+| PK | `Long` (auto-increment) | 서브클래스에서 `@Id @GeneratedValue(IDENTITY)`로 정의 (Long, bigint auto_increment) |
 | PK 컬럼명 | `id` (고정) | 서브클래스에서 직접 정의 (user_id, brand_id, product_id, order_id) |
 | 삭제 방식 | `deletedAt` 단일 | `del_yn` + `deletedAt` 이중 관리 |
 | 삭제 메서드 | `delete()` / `restore()` | `softDelete()` / `restore()` (멱등) |
@@ -141,10 +144,17 @@ Both provide: `createdAt`, `updatedAt`, `guard()` override for entity validation
 
 ## API Authentication
 
-| 구분 | Prefix | 인증 방식 |
-|------|--------|-----------|
-| 고객 API | `/api/v1` | `X-Loopers-LoginId` + `X-Loopers-LoginPw` headers |
-| 관리자 API | `/api-admin/v1` | `X-Loopers-Ldap: loopers.admin` header |
+| 구분 | Prefix | 인증 방식 | 처리 |
+|------|--------|-----------|------|
+| 고객 API | `/api/v1` | `X-Loopers-LoginId` + `X-Loopers-LoginPw` headers | `CustomerAuthInterceptor` → `@AuthUser` |
+| 관리자 API | `/api-admin/v1` | `X-Loopers-Ldap: loopers.admin` header | `AdminAuthInterceptor` |
+
+### 고객 인증 흐름
+
+1. `CustomerAuthInterceptor`가 인증 헤더 검증 및 `UserService.authenticate()` 호출
+2. 인증된 `UserModel`을 request attribute에 저장
+3. `AuthUserArgumentResolver`가 `@AuthUser` 어노테이션 파라미터에 `UserModel` 주입
+4. Controller에서 `@AuthUser UserModel user`로 인증된 사용자 접근
 
 ## Error Handling
 
@@ -244,10 +254,11 @@ DIRECT 주문 취소/만료 시 `order_cart_restore` 테이블 `existsById` 확
 ## 설계 원칙
 
 - 도메인 객체는 비즈니스 규칙을 캡슐화한다. 규칙이 여러 서비스에 나타나면 도메인 객체에 속할 가능성이 높다.
-- 애플리케이션 서비스(AppService/Facade)는 서로 다른 도메인을 조립하여 기능을 제공한다.
-- API request/response DTO와 application 레이어의 Info DTO는 분리한다.
-- 도메인 모델(`*Model`)은 interfaces 레이어에 노출하지 않는다. application 레이어에서 `*Info` DTO로 변환하여 반환한다.
-- 각 기능에 대한 책임과 결합도에 대해 개발자의 의도를 확인하고 개발을 진행한다.
+- **단순 도메인은 Controller에서 Service를 직접 호출**한다. AppService 레이어는 제거되었다.
+- **복잡한 도메인(Product, Cart, Order)은 Facade를 통해 여러 서비스를 조합**한다.
+- **도메인 서비스는 필요시 다른 도메인 서비스를 참조**할 수 있다. (예: `LikeService` → `ProductService`)
+- **인증은 Interceptor에서 처리**하고, `@AuthUser`로 Controller에 주입한다.
+- Response DTO는 도메인 모델에서 직접 변환한다 (`V1Dto.Response.from(Model)`).
 - 패키징 전략은 4개 레이어 패키지를 두고, 하위에 도메인 별로 패키징한다.
 
 ## Implementation Guide
diff --git a/apps/commerce-api/build.gradle.kts b/apps/commerce-api/build.gradle.kts
index c6a363556..eaa0d69a4 100644
--- a/apps/commerce-api/build.gradle.kts
+++ b/apps/commerce-api/build.gradle.kts
@@ -14,6 +14,9 @@ dependencies {
     // security (for password encoding)
     implementation("org.springframework.security:spring-security-crypto")
 
+    // L1 cache (Caffeine)
+    implementation("com.github.ben-manes.caffeine:caffeine")
+
     // querydsl
     annotationProcessor("com.querydsl:querydsl-apt::jakarta")
     annotationProcessor("jakarta.persistence:jakarta.persistence-api")
diff --git a/apps/commerce-api/src/main/java/com/loopers/application/brand/BrandAppService.java b/apps/commerce-api/src/main/java/com/loopers/application/brand/BrandAppService.java
deleted file mode 100644
index 14193d43a..000000000
--- a/apps/commerce-api/src/main/java/com/loopers/application/brand/BrandAppService.java
+++ /dev/null
@@ -1,90 +0,0 @@
-package com.loopers.application.brand;
-
-import com.loopers.domain.brand.BrandService;
-import lombok.RequiredArgsConstructor;
-import org.springframework.stereotype.Service;
-import org.springframework.transaction.annotation.Transactional;
-
-import java.util.List;
-
-/**
- * 브랜드 도메인 Application Service.
- * 도메인 서비스를 호출하고 Model → Info 변환을 담당한다.
- */
-@Service
-@RequiredArgsConstructor
-@Transactional(readOnly = true)
-public class BrandAppService {
-
-    private final BrandService brandService;
-
-    /**
-     * 새 브랜드를 등록한다.
-     *
-     * @param brandName   브랜드명
-     * @param description 설명
-     * @param address     주소
-     * @return 생성된 브랜드 정보 DTO
-     */
-    @Transactional
-    public BrandInfo createBrand(String brandName, String description, String address) {
-        return BrandInfo.from(brandService.createBrand(brandName, description, address));
-    }
-
-    /**
-     * 관리자용 전체 브랜드 목록을 조회한다 (삭제 포함).
-     *
-     * @return 전체 브랜드 정보 DTO 목록
-     */
-    public List<BrandInfo> findAllForAdmin() {
-        return brandService.findAllForAdmin().stream()
-                .map(BrandInfo::from)
-                .toList();
-    }
-
-    /**
-     * 고객에게 노출 가능한 브랜드를 ID로 조회한다.
-     *
-     * @param brandId 브랜드 ID
-     * @return 브랜드 정보 DTO
-     */
-    public BrandInfo findVisibleById(String brandId) {
-        return BrandInfo.from(brandService.findVisibleById(brandId));
-    }
-
-    /**
-     * 고객에게 노출 가능한 브랜드 목록을 조회한다. 키워드가 있으면 검색한다.
-     *
-     * @param keyword 검색 키워드 (null이면 전체 조회)
-     * @return 브랜드 정보 DTO 목록
-     */
-    public List<BrandInfo> findAllVisibleBrands(String keyword) {
-        return brandService.findAllVisibleBrands(keyword).stream()
-                .map(BrandInfo::from)
-                .toList();
-    }
-
-    /**
-     * 브랜드 정보를 수정한다.
-     *
-     * @param brandId     브랜드 ID
-     * @param brandName   새 브랜드명
-     * @param description 새 설명
-     * @param address     새 주소
-     * @return 수정된 브랜드 정보 DTO
-     */
-    @Transactional
-    public BrandInfo updateBrand(String brandId, String brandName, String description, String address) {
-        return BrandInfo.from(brandService.updateBrand(brandId, brandName, description, address));
-    }
-
-    /**
-     * 브랜드를 소프트 삭제한다.
-     *
-     * @param brandId 삭제할 브랜드 ID
-     */
-    @Transactional
-    public void deleteBrand(String brandId) {
-        brandService.deleteBrand(brandId);
-    }
-}
diff --git a/apps/commerce-api/src/main/java/com/loopers/application/brand/BrandInfo.java b/apps/commerce-api/src/main/java/com/loopers/application/brand/BrandInfo.java
deleted file mode 100644
index 34633812f..000000000
--- a/apps/commerce-api/src/main/java/com/loopers/application/brand/BrandInfo.java
+++ /dev/null
@@ -1,46 +0,0 @@
-package com.loopers.application.brand;
-
-import com.loopers.domain.brand.BrandModel;
-import com.loopers.support.enums.DisplayStatus;
-import lombok.Builder;
-import lombok.Getter;
-
-import java.time.ZonedDateTime;
-
-/**
- * 브랜드 정보 DTO.
- * 도메인 모델({@link BrandModel})을 직접 노출하지 않고 인터페이스 레이어에 전달하기 위한 응답 객체이다.
- */
-@Getter
-@Builder
-public class BrandInfo {
-    private final String brandId;
-    private final String brandName;
-    private final String description;
-    private final String address;
-    private final DisplayStatus displayStatus;
-    private final String attachFile;
-    private final String delYn;
-    private final ZonedDateTime deletedAt;
-    private final ZonedDateTime createdAt;
-
-    /**
-     * BrandModel을 BrandInfo DTO로 변환한다.
-     *
-     * @param model 변환할 브랜드 엔티티
-     * @return 브랜드 정보 DTO
-     */
-    public static BrandInfo from(BrandModel model) {
-        return BrandInfo.builder()
-                .brandId(model.getBrandId())
-                .brandName(model.getBrandName())
-                .description(model.getDescription())
-                .address(model.getAddress())
-                .displayStatus(model.getDisplayStatus())
-                .attachFile(model.getAttachFile())
-                .delYn(model.getDelYn())
-                .deletedAt(model.getDeletedAt())
-                .createdAt(model.getCreatedAt())
-                .build();
-    }
-}
diff --git a/apps/commerce-api/src/main/java/com/loopers/application/cart/CartAppService.java b/apps/commerce-api/src/main/java/com/loopers/application/cart/CartAppService.java
deleted file mode 100644
index 4a0c0558b..000000000
--- a/apps/commerce-api/src/main/java/com/loopers/application/cart/CartAppService.java
+++ /dev/null
@@ -1,36 +0,0 @@
-package com.loopers.application.cart;
-
-import com.loopers.domain.cart.CartService;
-import com.loopers.domain.user.UserModel;
-import com.loopers.domain.user.UserService;
-import lombok.RequiredArgsConstructor;
-import org.springframework.stereotype.Service;
-import org.springframework.transaction.annotation.Transactional;
-
-/**
- * 장바구니 도메인 Application Service.
- *
- * <p>단일 도메인 서비스(CartService)만 호출하는 얇은 메서드를 담당한다.
- * 인증 후 CartService에 위임한다.</p>
- */
-@Service
-@RequiredArgsConstructor
-@Transactional(readOnly = true)
-public class CartAppService {
-
-    private final CartService cartService;
-    private final UserService userService;
-
-    /**
-     * 장바구니에서 상품을 삭제한다.
-     *
-     * @param loginId   로그인 ID
-     * @param loginPw   로그인 비밀번호
-     * @param productId 삭제할 상품 ID
-     */
-    @Transactional
-    public void removeItem(String loginId, String loginPw, String productId) {
-        UserModel user = userService.authenticate(loginId, loginPw);
-        cartService.removeItem(user.getUserId(), productId);
-    }
-}
diff --git a/apps/commerce-api/src/main/java/com/loopers/application/cart/CartFacade.java b/apps/commerce-api/src/main/java/com/loopers/application/cart/CartFacade.java
index 94430dcf3..929d9ba34 100644
--- a/apps/commerce-api/src/main/java/com/loopers/application/cart/CartFacade.java
+++ b/apps/commerce-api/src/main/java/com/loopers/application/cart/CartFacade.java
@@ -8,11 +8,7 @@
 import com.loopers.domain.product.ProductService;
 import com.loopers.domain.product.ProductStockModel;
 import com.loopers.domain.product.StockService;
-import com.loopers.domain.user.UserModel;
-import com.loopers.domain.user.UserService;
 import com.loopers.support.enums.UnavailableReason;
-import com.loopers.support.error.CoreException;
-import com.loopers.support.error.ErrorType;
 import lombok.RequiredArgsConstructor;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
@@ -27,16 +23,17 @@
 /**
  * 장바구니 Facade (퍼사드)
  *
- * <p>UserService, CartService, ProductService, StockService, BrandService를
+ * <p>CartService, ProductService, StockService, BrandService를
  * 조합(orchestration)하여 장바구니 비즈니스 플로우를 완성한다.</p>
  *
  * <ul>
- *   <li>사용자 인증</li>
  *   <li>트랜잭션 경계 설정</li>
  *   <li>상품 주문 가능 여부 및 재고 검증 후 장바구니 추가</li>
  *   <li>재고 검증 후 수량 변경</li>
  *   <li>장바구니 항목 + 상품/브랜드/재고 조합 조회</li>
  * </ul>
+ *
+ * <p>인증은 {@link com.loopers.interfaces.api.CustomerAuthInterceptor}에서 처리된다.</p>
  */
 @Service
 @RequiredArgsConstructor
@@ -44,7 +41,6 @@
 public class CartFacade {
 
     private final CartService cartService;
-    private final UserService userService;
     private final ProductService productService;
     private final StockService stockService;
     private final BrandService brandService;
@@ -55,13 +51,11 @@ public class CartFacade {
      * <p>장바구니 항목에 상품, 브랜드, 재고 정보를 조합하여
      * 주문 가능 여부와 불가 사유를 포함한 CartInfo 목록을 반환한다.</p>
      *
-     * @param loginId 로그인 ID
-     * @param loginPw 로그인 비밀번호
+     * @param userId 사용자 ID
      * @return 해당 사용자의 장바구니 항목 목록 (상품/브랜드/재고 정보 포함)
      */
-    public List<CartInfo> getCart(String loginId, String loginPw) {
-        UserModel user = userService.authenticate(loginId, loginPw);
-        return buildCartInfoList(cartService.getCartItems(user.getUserId()));
+    public List<CartInfo> getCart(Long userId) {
+        return buildCartInfoList(cartService.getCartItems(userId));
     }
 
     /**
@@ -69,23 +63,18 @@ public List<CartInfo> getCart(String loginId, String loginPw) {
      *
      * <p>상품 주문 가능 여부와 재고 초과 여부를 검증한 뒤 장바구니에 추가한다.</p>
      *
-     * @param loginId   로그인 ID
-     * @param loginPw   로그인 비밀번호
+     * @param userId    사용자 ID
      * @param productId 추가할 상품 ID
      * @param qty       수량
      */
     @Transactional
-    public void addItem(String loginId, String loginPw, String productId, int qty) {
-        UserModel user = userService.authenticate(loginId, loginPw);
-
+    public void addItem(Long userId, Long productId, int qty) {
         productService.findOrderableById(productId);
 
         ProductStockModel stock = stockService.findByProductId(productId);
-        if (stock.getAvailableQty() < qty) {
-            throw new CoreException(ErrorType.CART_STOCK_EXCEEDED);
-        }
+        stock.validateCanHold(qty);
 
-        cartService.addItem(user.getUserId(), productId, qty);
+        cartService.addItem(userId, productId, qty);
     }
 
     /**
@@ -93,21 +82,27 @@ public void addItem(String loginId, String loginPw, String productId, int qty) {
      *
      * <p>재고 초과 여부를 검증한 뒤 수량을 변경한다.</p>
      *
-     * @param loginId   로그인 ID
-     * @param loginPw   로그인 비밀번호
+     * @param userId    사용자 ID
      * @param productId 수량을 변경할 상품 ID
      * @param newQty    변경할 새 수량
      */
     @Transactional
-    public void changeQuantity(String loginId, String loginPw, String productId, int newQty) {
-        UserModel user = userService.authenticate(loginId, loginPw);
-
+    public void changeQuantity(Long userId, Long productId, int newQty) {
         ProductStockModel stock = stockService.findByProductId(productId);
-        if (stock.getAvailableQty() < newQty) {
-            throw new CoreException(ErrorType.CART_STOCK_EXCEEDED);
-        }
+        stock.validateCanHold(newQty);
 
-        cartService.changeQuantity(user.getUserId(), productId, newQty);
+        cartService.changeQuantity(userId, productId, newQty);
+    }
+
+    /**
+     * 장바구니에서 상품을 삭제한다.
+     *
+     * @param userId    사용자 ID
+     * @param productId 삭제할 상품 ID
+     */
+    @Transactional
+    public void removeItem(Long userId, Long productId) {
+        cartService.removeItem(userId, productId);
     }
 
     /**
@@ -119,7 +114,7 @@ public void changeQuantity(String loginId, String loginPw, String productId, int
      * @param userId 조회할 사용자 ID
      * @return 해당 사용자의 장바구니 항목 목록 (상품/브랜드/재고 정보 포함)
      */
-    public List<CartInfo> getCartForAdmin(String userId) {
+    public List<CartInfo> getCartForAdmin(Long userId) {
         return buildCartInfoList(cartService.getCartItems(userId));
     }
 
@@ -132,18 +127,18 @@ private List<CartInfo> buildCartInfoList(List<CartItemModel> items) {
             return List.of();
         }
 
-        List<String> productIds = items.stream()
+        List<Long> productIds = items.stream()
                 .map(CartItemModel::getProductId).distinct().toList();
 
-        Map<String, ProductModel> productMap = productService.findAllByIds(productIds)
+        Map<Long, ProductModel> productMap = productService.findAllByIds(productIds)
                 .stream().collect(Collectors.toMap(ProductModel::getProductId, Function.identity()));
 
-        Set<String> brandIds = productMap.values().stream()
+        Set<Long> brandIds = productMap.values().stream()
                 .map(ProductModel::getBrandId).collect(Collectors.toSet());
-        Map<String, BrandModel> brandMap = brandService.findAllByIds(brandIds)
+        Map<Long, BrandModel> brandMap = brandService.findAllByIds(brandIds)
                 .stream().collect(Collectors.toMap(BrandModel::getBrandId, Function.identity()));
 
-        Map<String, ProductStockModel> stockMap = stockService.findAllByProductIds(productIds)
+        Map<Long, ProductStockModel> stockMap = stockService.findAllByProductIds(productIds)
                 .stream().collect(Collectors.toMap(ProductStockModel::getProductId, Function.identity()));
 
         List<CartInfo> result = new ArrayList<>();
diff --git a/apps/commerce-api/src/main/java/com/loopers/application/cart/CartInfo.java b/apps/commerce-api/src/main/java/com/loopers/application/cart/CartInfo.java
index 22fe99ac7..4fd575108 100644
--- a/apps/commerce-api/src/main/java/com/loopers/application/cart/CartInfo.java
+++ b/apps/commerce-api/src/main/java/com/loopers/application/cart/CartInfo.java
@@ -20,14 +20,14 @@
 @Getter
 @Builder
 public class CartInfo {
-    private final String userId;
-    private final String productId;
+    private final Long userId;
+    private final Long productId;
     private final int quantity;
     private final boolean available;
     private final UnavailableReason unavailableReason;
     private final String productName;
     private final BigDecimal price;
-    private final String brandId;
+    private final Long brandId;
     private final String brandName;
     private final String imageUrl;
     private final int availableStock;
diff --git a/apps/commerce-api/src/main/java/com/loopers/application/like/LikeAppService.java b/apps/commerce-api/src/main/java/com/loopers/application/like/LikeAppService.java
deleted file mode 100644
index e6844943d..000000000
--- a/apps/commerce-api/src/main/java/com/loopers/application/like/LikeAppService.java
+++ /dev/null
@@ -1,63 +0,0 @@
-package com.loopers.application.like;
-
-import com.loopers.domain.like.LikeService;
-import com.loopers.domain.user.UserModel;
-import com.loopers.domain.user.UserService;
-import lombok.RequiredArgsConstructor;
-import org.springframework.stereotype.Service;
-import org.springframework.transaction.annotation.Transactional;
-
-import java.util.List;
-
-/**
- * 좋아요 도메인 Application Service.
- * 사용자 인증과 좋아요 도메인 서비스를 조합하고 Model → Info 변환을 담당한다.
- */
-@Service
-@RequiredArgsConstructor
-@Transactional(readOnly = true)
-public class LikeAppService {
-
-    private final UserService userService;
-    private final LikeService likeService;
-
-    /**
-     * 상품에 좋아요를 등록한다. 이미 좋아요한 경우 무시한다 (멱등).
-     *
-     * @param loginId   로그인 ID
-     * @param loginPw   비밀번호
-     * @param productId 상품 ID
-     */
-    @Transactional
-    public void addLike(String loginId, String loginPw, String productId) {
-        UserModel user = userService.authenticate(loginId, loginPw);
-        likeService.addLike(user.getUserId(), productId);
-    }
-
-    /**
-     * 상품 좋아요를 취소한다. 좋아요가 없으면 무시한다 (멱등).
-     *
-     * @param loginId   로그인 ID
-     * @param loginPw   비밀번호
-     * @param productId 상품 ID
-     */
-    @Transactional
-    public void removeLike(String loginId, String loginPw, String productId) {
-        UserModel user = userService.authenticate(loginId, loginPw);
-        likeService.removeLike(user.getUserId(), productId);
-    }
-
-    /**
-     * 특정 사용자의 좋아요 목록을 조회한다.
-     *
-     * @param loginId 로그인 ID
-     * @param loginPw 비밀번호
-     * @return 좋아요 정보 DTO 목록
-     */
-    public List<LikeInfo> getMyLikes(String loginId, String loginPw) {
-        UserModel user = userService.authenticate(loginId, loginPw);
-        return likeService.getMyLikes(user.getUserId()).stream()
-                .map(LikeInfo::from)
-                .toList();
-    }
-}
diff --git a/apps/commerce-api/src/main/java/com/loopers/application/like/LikeInfo.java b/apps/commerce-api/src/main/java/com/loopers/application/like/LikeInfo.java
deleted file mode 100644
index bfae8c31e..000000000
--- a/apps/commerce-api/src/main/java/com/loopers/application/like/LikeInfo.java
+++ /dev/null
@@ -1,33 +0,0 @@
-package com.loopers.application.like;
-
-import com.loopers.domain.like.LikeModel;
-import lombok.Builder;
-import lombok.Getter;
-
-import java.time.LocalDateTime;
-
-/**
- * 좋아요 정보 DTO.
- * 도메인 모델({@link LikeModel})을 직접 노출하지 않고 인터페이스 레이어에 전달하기 위한 응답 객체이다.
- */
-@Getter
-@Builder
-public class LikeInfo {
-    private final String userId;
-    private final String productId;
-    private final LocalDateTime createdAt;
-
-    /**
-     * LikeModel을 LikeInfo DTO로 변환한다.
-     *
-     * @param model 변환할 좋아요 엔티티
-     * @return 좋아요 정보 DTO
-     */
-    public static LikeInfo from(LikeModel model) {
-        return LikeInfo.builder()
-                .userId(model.getUserId())
-                .productId(model.getProductId())
-                .createdAt(model.getCreatedAt())
-                .build();
-    }
-}
diff --git a/apps/commerce-api/src/main/java/com/loopers/application/order/OrderAppService.java b/apps/commerce-api/src/main/java/com/loopers/application/order/OrderAppService.java
deleted file mode 100644
index 52f0bf151..000000000
--- a/apps/commerce-api/src/main/java/com/loopers/application/order/OrderAppService.java
+++ /dev/null
@@ -1,100 +0,0 @@
-package com.loopers.application.order;
-
-import com.loopers.domain.order.OrderItemModel;
-import com.loopers.domain.order.OrderModel;
-import com.loopers.domain.order.OrderService;
-import com.loopers.domain.user.UserModel;
-import com.loopers.domain.user.UserService;
-import lombok.RequiredArgsConstructor;
-import org.springframework.stereotype.Service;
-import org.springframework.transaction.annotation.Transactional;
-
-import java.time.LocalDateTime;
-import java.util.List;
-import java.util.Map;
-
-/**
- * 주문 도메인 Application Service.
- *
- * <p>단일 도메인 서비스(OrderService)만 호출하는 얇은 조회 메서드를 담당한다.
- * 고객용 메서드는 UserService 인증을 포함한다.
- * Model → Info 변환을 수행한다.</p>
- */
-@Service
-@RequiredArgsConstructor
-@Transactional(readOnly = true)
-public class OrderAppService {
-
-    private final OrderService orderService;
-    private final UserService userService;
-
-    /**
-     * 주문 상세 정보를 조회한다.
-     *
-     * @param loginId 로그인 ID
-     * @param loginPw 로그인 비밀번호
-     * @param orderId 조회할 주문 ID
-     * @return 주문 상세 정보
-     */
-    public OrderInfo getOrderDetail(String loginId, String loginPw, String orderId) {
-        UserModel user = userService.authenticate(loginId, loginPw);
-        OrderModel order = orderService.findByIdAndUserId(orderId, user.getUserId());
-        List<OrderItemModel> items = orderService.findOrderItems(order.getOrderId());
-        return OrderInfo.from(order, items);
-    }
-
-    /**
-     * 기간별 주문 목록을 조회한다.
-     *
-     * @param loginId 로그인 ID
-     * @param loginPw 로그인 비밀번호
-     * @param start   조회 시작 일시
-     * @param end     조회 종료 일시
-     * @return 조회 기간 내 주문 목록
-     */
-    public List<OrderInfo> getOrders(String loginId, String loginPw,
-                                     LocalDateTime start, LocalDateTime end) {
-        UserModel user = userService.authenticate(loginId, loginPw);
-        List<OrderModel> orders = orderService.findAllByUserId(user.getUserId(), start, end);
-        return toOrderInfoList(orders);
-    }
-
-    /**
-     * 주문 ID로 주문 상세를 조회한다 (관리자용).
-     *
-     * @param orderId 주문 ID
-     * @return 주문 정보 DTO
-     */
-    public OrderInfo findOrderById(String orderId) {
-        OrderModel order = orderService.findOrderById(orderId);
-        List<OrderItemModel> items = orderService.findOrderItems(order.getOrderId());
-        return OrderInfo.from(order, items);
-    }
-
-    /**
-     * 기간별 전체 주문 목록을 조회한다 (관리자용).
-     *
-     * @param start 조회 시작 일시
-     * @param end   조회 종료 일시
-     * @return 주문 정보 DTO 목록
-     */
-    public List<OrderInfo> findAllOrders(LocalDateTime start, LocalDateTime end) {
-        List<OrderModel> orders = orderService.findAllOrders(start, end);
-        return toOrderInfoList(orders);
-    }
-
-    /**
-     * 주문 목록을 배치 로딩으로 OrderInfo 목록으로 변환한다.
-     * N+1 쿼리 대신 단일 IN 쿼리로 주문 항목을 일괄 조회한다.
-     */
-    private List<OrderInfo> toOrderInfoList(List<OrderModel> orders) {
-        if (orders.isEmpty()) {
-            return List.of();
-        }
-        List<String> orderIds = orders.stream().map(OrderModel::getOrderId).toList();
-        Map<String, List<OrderItemModel>> itemMap = orderService.findOrderItemsByOrderIds(orderIds);
-        return orders.stream()
-                .map(order -> OrderInfo.from(order, itemMap.getOrDefault(order.getOrderId(), List.of())))
-                .toList();
-    }
-}
diff --git a/apps/commerce-api/src/main/java/com/loopers/application/order/OrderFacade.java b/apps/commerce-api/src/main/java/com/loopers/application/order/OrderFacade.java
index b165045ad..bfb60f321 100644
--- a/apps/commerce-api/src/main/java/com/loopers/application/order/OrderFacade.java
+++ b/apps/commerce-api/src/main/java/com/loopers/application/order/OrderFacade.java
@@ -3,6 +3,9 @@
 import com.loopers.domain.brand.BrandModel;
 import com.loopers.domain.brand.BrandService;
 import com.loopers.domain.cart.CartService;
+import com.loopers.domain.coupon.CouponModel;
+import com.loopers.domain.coupon.CouponService;
+import com.loopers.domain.coupon.UserCouponModel;
 import com.loopers.domain.order.OrderCartRestoreModel;
 import com.loopers.domain.order.OrderItemCommand;
 import com.loopers.domain.order.OrderItemModel;
@@ -12,8 +15,6 @@
 import com.loopers.domain.product.ProductModel;
 import com.loopers.domain.product.ProductService;
 import com.loopers.domain.product.StockService;
-import com.loopers.domain.user.UserModel;
-import com.loopers.domain.user.UserService;
 import com.loopers.support.enums.OrderType;
 import com.loopers.support.enums.RestoreReason;
 import com.loopers.support.enums.RestoreTriggerSource;
@@ -23,24 +24,28 @@
 import org.springframework.transaction.annotation.Transactional;
 
 import java.math.BigDecimal;
+import java.math.RoundingMode;
+import java.time.LocalDateTime;
 import java.util.ArrayList;
 import java.util.Comparator;
 import java.util.List;
+import java.util.Map;
 import java.util.Optional;
 
 /**
  * 주문 Facade (퍼사드)
  *
- * <p>UserService, OrderService, ProductService, BrandService, StockService, CartService를
+ * <p>OrderService, ProductService, BrandService, StockService, CartService, CouponService를
  * 조합(orchestration)하여 주문 비즈니스 플로우를 완성한다.</p>
  *
  * <ul>
- *   <li>사용자 인증</li>
  *   <li>트랜잭션 경계 설정</li>
- *   <li>직접 주문(DIRECT) 및 장바구니 주문(CART) 생성 — 상품 검증, 재고 hold, 스냅샷 생성</li>
+ *   <li>직접 주문(DIRECT) 및 장바구니 주문(CART) 생성 — 쿠폰 검증, 상품 검증, 재고 hold, 스냅샷 생성</li>
  *   <li>주문 취소/만료 — CAS 상태 전이 후 재고 release, 장바구니 복원</li>
  *   <li>주문 목록 조회, 상세 조회</li>
  * </ul>
+ *
+ * <p>인증은 {@link com.loopers.interfaces.api.CustomerAuthInterceptor}에서 처리된다.</p>
  */
 @Service
 @RequiredArgsConstructor
@@ -48,62 +53,103 @@
 public class OrderFacade {
 
     private final OrderService orderService;
-    private final UserService userService;
     private final ProductService productService;
     private final BrandService brandService;
     private final StockService stockService;
     private final CartService cartService;
+    private final CouponService couponService;
 
     /**
      * 직접 주문을 생성한다.
      *
-     * <p>상품 상세 페이지에서 바로 주문하는 DIRECT 주문 방식이다.
-     * 상품 검증 → 브랜드 조회 → 재고 hold → 주문 저장 순으로 진행하며,
-     * 재고 hold 실패 시 이미 hold된 재고를 역순으로 release한다.</p>
-     *
-     * @param loginId 로그인 ID
-     * @param loginPw 로그인 비밀번호
-     * @param items   주문할 상품 항목 목록
+     * @param userId       사용자 ID
+     * @param items        주문할 상품 항목 목록
+     * @param userCouponId 적용할 발급 쿠폰 ID (없으면 null)
      * @return 생성된 주문 정보
      */
     @Transactional
-    public OrderInfo createDirectOrder(String loginId, String loginPw, List<OrderItemCommand> items) {
-        UserModel user = userService.authenticate(loginId, loginPw);
-        return processOrder(user.getUserId(), OrderType.DIRECT, items);
+    public OrderInfo createDirectOrder(Long userId, List<OrderItemCommand> items, Long userCouponId) {
+        return processOrder(userId, OrderType.DIRECT, items, userCouponId);
     }
 
     /**
      * 장바구니 주문을 생성한다.
      *
-     * <p>장바구니에서 선택한 상품들을 주문하는 CART 주문 방식이다.
-     * 상품 검증 → 브랜드 조회 → 재고 hold → 주문 저장 순으로 진행하며,
-     * 재고 hold 실패 시 이미 hold된 재고를 역순으로 release한다.</p>
-     *
-     * @param loginId 로그인 ID
-     * @param loginPw 로그인 비밀번호
-     * @param items   주문할 상품 항목 목록
+     * @param userId       사용자 ID
+     * @param items        주문할 상품 항목 목록
+     * @param userCouponId 적용할 발급 쿠폰 ID (없으면 null)
      * @return 생성된 주문 정보
      */
     @Transactional
-    public OrderInfo createCartOrder(String loginId, String loginPw, List<OrderItemCommand> items) {
-        UserModel user = userService.authenticate(loginId, loginPw);
-        return processOrder(user.getUserId(), OrderType.CART, items);
+    public OrderInfo createCartOrder(Long userId, List<OrderItemCommand> items, Long userCouponId) {
+        return processOrder(userId, OrderType.CART, items, userCouponId);
+    }
+
+    /**
+     * 주문 목록을 조회한다 (기간 필터).
+     */
+    public List<OrderInfo> getOrders(Long userId, LocalDateTime start, LocalDateTime end) {
+        List<OrderModel> orders = orderService.findAllByUserId(userId, start, end);
+        Map<Long, List<OrderItemModel>> itemMap = orderService.batchLoadOrderItems(orders);
+        return orders.stream()
+                .map(order -> OrderInfo.from(order, itemMap.getOrDefault(order.getOrderId(), List.of())))
+                .toList();
+    }
+
+    /**
+     * 주문 상세 정보를 조회한다.
+     */
+    public OrderInfo getOrderDetail(Long userId, Long orderId) {
+        OrderModel order = orderService.findByIdAndUserId(orderId, userId);
+        List<OrderItemModel> items = orderService.findOrderItems(order.getOrderId());
+        return OrderInfo.from(order, items);
+    }
+
+    /**
+     * 관리자용 전체 주문 목록을 조회한다 (기간 필터).
+     */
+    public List<OrderInfo> getOrdersForAdmin(LocalDateTime start, LocalDateTime end) {
+        List<OrderModel> orders = orderService.findAllOrders(start, end);
+        Map<Long, List<OrderItemModel>> itemMap = orderService.batchLoadOrderItems(orders);
+        return orders.stream()
+                .map(order -> OrderInfo.from(order, itemMap.getOrDefault(order.getOrderId(), List.of())))
+                .toList();
+    }
+
+    /**
+     * 관리자용 주문 상세 정보를 조회한다.
+     */
+    public OrderInfo getOrderDetailForAdmin(Long orderId) {
+        OrderModel order = orderService.findOrderById(orderId);
+        List<OrderItemModel> items = orderService.findOrderItems(order.getOrderId());
+        return OrderInfo.from(order, items);
     }
 
     /**
      * 주문 생성 공통 로직.
      * <p>
-     * 주문 항목 검증/병합 → 상품 조회 → 브랜드 조회 → 재고 hold → 스냅샷 생성 → 주문 저장.
+     * 쿠폰 검증 → 재고 hold → 할인 배분 → 주문 저장 → 쿠폰 사용 처리.
      * 데드락 방지를 위해 productId 오름차순으로 재고 예약을 수행한다.
      * 재고 hold 실패 시 이미 hold된 재고를 역순으로 release한다.
      * </p>
      */
-    private OrderInfo processOrder(String userId, OrderType orderType, List<OrderItemCommand> items) {
+    private OrderInfo processOrder(Long userId, OrderType orderType, List<OrderItemCommand> items,
+                                    Long userCouponId) {
         List<OrderItemCommand> merged = orderService.validateAndPrepare(userId, items);
 
-        List<OrderItemSnapshot> snapshots = new ArrayList<>();
-        List<String> heldProductIds = new ArrayList<>();
-        BigDecimal totalAmount = BigDecimal.ZERO;
+        // Step 1: 쿠폰 검증 (재고 hold 전에 수행 → 보상 복잡도 최소화)
+        UserCouponModel userCoupon = null;
+        CouponModel coupon = null;
+        if (userCouponId != null) {
+            userCoupon = couponService.validateAndGetUserCoupon(userId, userCouponId);
+            coupon = couponService.findByIdForAdmin(userCoupon.getCouponId());
+        }
+
+        // Step 2: 재고 hold + 스냅샷 생성 + 쿠폰 할인 계산
+        List<OrderItemSnapshot> rawSnapshots = new ArrayList<>();
+        List<Long> heldProductIds = new ArrayList<>();
+        BigDecimal totalOriginalAmount = BigDecimal.ZERO;
+        BigDecimal totalDiscount = BigDecimal.ZERO;
 
         try {
             for (OrderItemCommand item : merged) {
@@ -113,47 +159,87 @@ private OrderInfo processOrder(String userId, OrderType orderType, List<OrderIte
                 heldProductIds.add(item.productId());
 
                 OrderItemSnapshot snapshot = OrderItemSnapshot.from(product, brand, item.quantity());
-                totalAmount = totalAmount.add(snapshot.lineTotal());
-                snapshots.add(snapshot);
+                totalOriginalAmount = totalOriginalAmount.add(snapshot.originalAmount());
+                rawSnapshots.add(snapshot);
+            }
+
+            // Step 3: 쿠폰 할인 금액 계산 (try 안에서 수행 → 실패 시 보상)
+            if (coupon != null) {
+                coupon.validateApplicable(totalOriginalAmount);
+                totalDiscount = coupon.calculateDiscount(totalOriginalAmount);
             }
         } catch (CoreException e) {
             compensateHeldStocks(heldProductIds, merged);
             throw e;
         }
 
-        OrderModel order = orderService.createOrder(userId, orderType, totalAmount, snapshots);
+        List<OrderItemSnapshot> finalSnapshots = applyDiscountProportionally(rawSnapshots, totalOriginalAmount,
+                totalDiscount);
+        BigDecimal totalFinalAmount = totalOriginalAmount.subtract(totalDiscount);
+
+        // Step 4: 주문 생성
+        OrderModel order = orderService.createOrder(userId, orderType, totalFinalAmount, finalSnapshots);
+
+        // Step 5: 쿠폰 사용 처리 (동일 트랜잭션)
+        if (userCoupon != null) {
+            couponService.markCouponAsUsed(userCoupon.getUserCouponId(), order.getOrderId());
+        }
+
         List<OrderItemModel> orderItems = orderService.findOrderItems(order.getOrderId());
         return OrderInfo.from(order, orderItems);
     }
 
+    /**
+     * 할인 금액을 주문 항목별 originalAmount 비율로 배분한다.
+     * 반올림 오차는 마지막 항목이 흡수한다.
+     */
+    private List<OrderItemSnapshot> applyDiscountProportionally(List<OrderItemSnapshot> rawSnapshots,
+                                                                  BigDecimal totalOriginalAmount,
+                                                                  BigDecimal totalDiscount) {
+        if (totalDiscount.compareTo(BigDecimal.ZERO) == 0) {
+            return rawSnapshots;
+        }
+
+        List<OrderItemSnapshot> result = new ArrayList<>();
+        BigDecimal allocatedDiscount = BigDecimal.ZERO;
+
+        for (int i = 0; i < rawSnapshots.size(); i++) {
+            OrderItemSnapshot raw = rawSnapshots.get(i);
+            boolean isLast = (i == rawSnapshots.size() - 1);
 
+            BigDecimal itemDiscount;
+            if (isLast) {
+                itemDiscount = totalDiscount.subtract(allocatedDiscount);
+            } else {
+                itemDiscount = totalDiscount
+                        .multiply(raw.originalAmount())
+                        .divide(totalOriginalAmount, 0, RoundingMode.FLOOR);
+                allocatedDiscount = allocatedDiscount.add(itemDiscount);
+            }
+
+            OrderItemSnapshot snapshotWithDiscount = new OrderItemSnapshot(
+                    raw.productId(), raw.quantity(), raw.productName(),
+                    raw.unitPrice(), raw.brandId(), raw.brandName(), raw.imageUrl(),
+                    raw.originalAmount(), itemDiscount, raw.originalAmount().subtract(itemDiscount));
+            result.add(snapshotWithDiscount);
+        }
+        return result;
+    }
 
     /**
      * 주문을 취소한다.
-     *
-     * <p>CAS 상태 전이 후 재고를 해제하고, DIRECT 주문인 경우 장바구니를 복원한다.</p>
-     *
-     * @param loginId 로그인 ID
-     * @param loginPw 로그인 비밀번호
-     * @param orderId 취소할 주문 ID
      */
     @Transactional
-    public void cancelOrder(String loginId, String loginPw, String orderId) {
-        UserModel user = userService.authenticate(loginId, loginPw);
-        Optional<OrderModel> order = orderService.cancelOrder(user.getUserId(), orderId);
+    public void cancelOrder(Long userId, Long orderId) {
+        Optional<OrderModel> order = orderService.cancelOrder(userId, orderId);
         order.ifPresent(o -> releaseStocksAndRestore(o, RestoreReason.USER_CANCELLED, RestoreTriggerSource.CANCEL_API));
     }
 
     /**
      * 배치 스케줄러가 주문을 만료 처리한다.
-     *
-     * <p>CAS 상태 전이 후 재고를 해제하고, DIRECT 주문인 경우 장바구니를 복원한다.
-     * 인증이 필요하지 않은 시스템 내부 호출용 메서드이다.</p>
-     *
-     * @param orderId 주문 ID
      */
     @Transactional
-    public void expireOrder(String orderId) {
+    public void expireOrder(Long orderId) {
         Optional<OrderModel> order = orderService.expireOrder(orderId);
         order.ifPresent(o -> releaseStocksAndRestore(o, RestoreReason.EXPIRED, RestoreTriggerSource.EXPIRE_JOB));
     }
@@ -161,9 +247,9 @@ public void expireOrder(String orderId) {
     /**
      * 재고 hold 실패 시 이미 hold된 재고를 역순으로 release한다.
      */
-    private void compensateHeldStocks(List<String> heldProductIds, List<OrderItemCommand> merged) {
+    private void compensateHeldStocks(List<Long> heldProductIds, List<OrderItemCommand> merged) {
         for (int i = heldProductIds.size() - 1; i >= 0; i--) {
-            String heldProductId = heldProductIds.get(i);
+            Long heldProductId = heldProductIds.get(i);
             int qty = merged.stream()
                     .filter(m -> m.productId().equals(heldProductId))
                     .findFirst().map(OrderItemCommand::quantity).orElse(0);
@@ -173,11 +259,6 @@ private void compensateHeldStocks(List<String> heldProductIds, List<OrderItemCom
 
     /**
      * 재고 해제 및 장바구니 복원을 수행한다.
-     * <p>
-     * 주문 항목의 재고를 productId 오름차순으로 해제하고,
-     * DIRECT 주문인 경우 장바구니 복원을 수행한다.
-     * PK 충돌 시 이미 복원된 것으로 간주하여 skip한다 (멱등 보장).
-     * </p>
      */
     private void releaseStocksAndRestore(OrderModel order, RestoreReason reason,
                                           RestoreTriggerSource triggerSource) {
@@ -190,6 +271,9 @@ private void releaseStocksAndRestore(OrderModel order, RestoreReason reason,
             stockService.release(item.getProductId(), item.getQuantity());
         }
 
+        // 쿠폰 복원 (멱등)
+        couponService.restoreCoupon(order.getOrderId());
+
         if (order.getOrderType() == OrderType.DIRECT) {
             if (!orderService.existsCartRestore(order.getOrderId())) {
                 orderService.saveCartRestore(
diff --git a/apps/commerce-api/src/main/java/com/loopers/application/order/OrderInfo.java b/apps/commerce-api/src/main/java/com/loopers/application/order/OrderInfo.java
index 029d03d2f..5e5f8a6b6 100644
--- a/apps/commerce-api/src/main/java/com/loopers/application/order/OrderInfo.java
+++ b/apps/commerce-api/src/main/java/com/loopers/application/order/OrderInfo.java
@@ -22,8 +22,8 @@
 @Getter
 @Builder
 public class OrderInfo {
-    private final String orderId;
-    private final String userId;
+    private final Long orderId;
+    private final Long userId;
     private final OrderType orderType;
     private final OrderStatus status;
     private final BigDecimal totalAmount;
@@ -33,10 +33,6 @@ public class OrderInfo {
 
     /**
      * OrderModel과 OrderItemModel 목록을 조합하여 OrderInfo DTO로 변환한다.
-     *
-     * @param order 주문 엔티티
-     * @param items 주문 항목 엔티티 목록 (null이면 빈 리스트)
-     * @return 주문 정보 DTO (주문 항목 스냅샷 포함)
      */
     public static OrderInfo from(OrderModel order, List<OrderItemModel> items) {
         return OrderInfo.builder()
@@ -55,29 +51,25 @@ public static OrderInfo from(OrderModel order, List<OrderItemModel> items) {
 
     /**
      * 주문 항목 정보 DTO.
-     * <p>
-     * 주문 시점의 상품 스냅샷 데이터(상품명, 단가, 브랜드, 이미지 등)를 포함하여
-     * 주문 후 상품 정보가 변경되더라도 주문 당시 정보를 보존한다.
-     * </p>
      */
     @Getter
     @Builder
     public static class OrderItemInfo {
-        private final String orderId;
+        private final Long orderId;
         private final int orderItemSeq;
-        private final String productId;
+        private final Long productId;
         private final int quantity;
         private final String snapshotProductName;
         private final BigDecimal snapshotUnitPrice;
         private final String snapshotBrandId;
         private final String snapshotBrandName;
         private final String snapshotImageUrl;
+        private final BigDecimal originalAmount;
+        private final BigDecimal discountAmount;
+        private final BigDecimal finalAmount;
 
         /**
          * OrderItemModel을 OrderItemInfo DTO로 변환한다.
-         *
-         * @param item 주문 항목 엔티티
-         * @return 주문 항목 정보 DTO (스냅샷 데이터 포함)
          */
         public static OrderItemInfo from(OrderItemModel item) {
             return OrderItemInfo.builder()
@@ -90,6 +82,9 @@ public static OrderItemInfo from(OrderItemModel item) {
                     .snapshotBrandId(item.getSnapshotBrandId())
                     .snapshotBrandName(item.getSnapshotBrandName())
                     .snapshotImageUrl(item.getSnapshotImageUrl())
+                    .originalAmount(item.getOriginalAmount())
+                    .discountAmount(item.getDiscountAmount())
+                    .finalAmount(item.getFinalAmount())
                     .build();
         }
     }
diff --git a/apps/commerce-api/src/main/java/com/loopers/application/product/ProductAppService.java b/apps/commerce-api/src/main/java/com/loopers/application/product/ProductAppService.java
deleted file mode 100644
index af296ee8c..000000000
--- a/apps/commerce-api/src/main/java/com/loopers/application/product/ProductAppService.java
+++ /dev/null
@@ -1,55 +0,0 @@
-package com.loopers.application.product;
-
-import com.loopers.domain.product.ProductService;
-import lombok.RequiredArgsConstructor;
-import org.springframework.stereotype.Service;
-import org.springframework.transaction.annotation.Transactional;
-
-import java.util.List;
-
-/**
- * 상품 도메인 Application Service.
- *
- * <p>단일 도메인 서비스(ProductService)만 호출하는 얇은 메서드를 담당한다.
- * Model → Info 변환을 수행한다.</p>
- */
-@Service
-@RequiredArgsConstructor
-@Transactional(readOnly = true)
-public class ProductAppService {
-
-    private final ProductService productService;
-
-    /**
-     * 상품을 소프트 삭제한다.
-     *
-     * @param productId 삭제할 상품 ID
-     */
-    @Transactional
-    public void deleteProduct(String productId) {
-        productService.deleteProduct(productId);
-    }
-
-    /**
-     * 상품의 변경 이력(Revision) 목록을 조회한다.
-     *
-     * @param productId 이력을 조회할 상품 ID
-     * @return 상품 변경 이력 Info 목록
-     */
-    public List<ProductRevisionInfo> getRevisions(String productId) {
-        return productService.findRevisionsByProductId(productId).stream()
-                .map(ProductRevisionInfo::from)
-                .toList();
-    }
-
-    /**
-     * 특정 상품의 개별 변경 이력 상세를 조회한다.
-     *
-     * @param productId   상품 ID
-     * @param revisionSeq 변경 순번
-     * @return 변경 이력 Info
-     */
-    public ProductRevisionInfo getRevisionDetail(String productId, Long revisionSeq) {
-        return ProductRevisionInfo.from(productService.findRevisionById(productId, revisionSeq));
-    }
-}
diff --git a/apps/commerce-api/src/main/java/com/loopers/application/product/ProductCreateCommand.java b/apps/commerce-api/src/main/java/com/loopers/application/product/ProductCreateCommand.java
index e8ac41a43..a7a6a3eb7 100644
--- a/apps/commerce-api/src/main/java/com/loopers/application/product/ProductCreateCommand.java
+++ b/apps/commerce-api/src/main/java/com/loopers/application/product/ProductCreateCommand.java
@@ -14,7 +14,7 @@
  * @param description  상품 설명
  * @param initialStock 초기 재고 수량
  */
-public record ProductCreateCommand(String productName, String brandId,
+public record ProductCreateCommand(String productName, Long brandId,
                                     BigDecimal price, String description,
                                     int initialStock) {
 }
diff --git a/apps/commerce-api/src/main/java/com/loopers/application/product/ProductFacade.java b/apps/commerce-api/src/main/java/com/loopers/application/product/ProductFacade.java
index 4cf8e5060..0d77caaea 100644
--- a/apps/commerce-api/src/main/java/com/loopers/application/product/ProductFacade.java
+++ b/apps/commerce-api/src/main/java/com/loopers/application/product/ProductFacade.java
@@ -2,21 +2,20 @@
 
 import com.loopers.domain.brand.BrandModel;
 import com.loopers.domain.brand.BrandService;
-import com.loopers.domain.like.LikeService;
 import com.loopers.domain.product.ProductModel;
 import com.loopers.domain.product.ProductService;
 import com.loopers.domain.product.ProductStockModel;
 import com.loopers.domain.product.StockService;
 import com.loopers.interfaces.api.PageResponse;
 import com.loopers.support.enums.ProductSortType;
+import com.loopers.support.page.PageQuery;
+import com.loopers.support.page.PagedResult;
 import lombok.RequiredArgsConstructor;
-import org.springframework.data.domain.Page;
-import org.springframework.data.domain.PageRequest;
-import org.springframework.data.domain.Sort;
+import org.springframework.cache.annotation.CacheEvict;
+import org.springframework.cache.annotation.Cacheable;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
-import java.util.Comparator;
 import java.util.List;
 import java.util.Map;
 import java.util.function.Function;
@@ -36,6 +35,11 @@
  *   <li>관리자용 상품 목록 조회 (재고 포함)</li>
  *   <li>변경 이력(Revision) 조회</li>
  * </ul>
+ *
+ * <h3>캐시 위계 분리</h3>
+ * <p>상품 목록 캐시(productList)는 상품 ID 목록 + 페이징 메타만 저장하고,
+ * 개별 상품 정보는 productDetail 캐시(L1+L2)에서 조회한다.
+ * 이로써 상품 수정 시 목록 캐시를 invalidate할 필요 없이 productDetail만 evict하면 된다.</p>
  */
 @Service
 @RequiredArgsConstructor
@@ -45,7 +49,6 @@ public class ProductFacade {
     private final ProductService productService;
     private final StockService stockService;
     private final BrandService brandService;
-    private final LikeService likeService;
 
     /**
      * 고객용 상품 목록을 정렬 + 페이징하여 조회한다.
@@ -60,24 +63,63 @@ public class ProductFacade {
      * @param size    페이지 크기
      * @return 페이징된 상품 정보 목록 (재고, 브랜드명, 좋아요 수 포함)
      */
-    public PageResponse<ProductInfo> getProductsForCustomer(String keyword, String brandId,
+    public PageResponse<ProductInfo> getProductsForCustomer(String keyword, Long brandId,
                                                             ProductSortType sort, int page, int size) {
-        if (sort == ProductSortType.LIKES_DESC) {
-            return getProductsSortedByLikes(keyword, brandId, page, size);
+        if (keyword == null && page == 0 && size == 20) {
+            return getProductsFromCachedIds(brandId, sort, page, size);
         }
+        return getProductsFromDb(keyword, brandId, sort, page, size);
+    }
 
-        Sort dbSort = switch (sort) {
-            case LATEST -> Sort.by(Sort.Direction.DESC, "createdAt");
-            case PRICE_ASC -> Sort.by(Sort.Direction.ASC, "price");
-            default -> Sort.by(Sort.Direction.DESC, "createdAt");
-        };
+    /**
+     * 캐시 위계 분리: productList 캐시에는 ID 목록 + 페이징 메타만 저장한다.
+     * 개별 상품 정보는 productDetail 캐시(L1+L2)에서 조회하여 조합한다.
+     */
+    private PageResponse<ProductInfo> getProductsFromCachedIds(Long brandId,
+                                                               ProductSortType sort, int page, int size) {
+        ProductListIdCache idCache = getCachedProductListIds(brandId, sort, page, size);
+
+        List<ProductModel> products = idCache.productIds().stream()
+                .map(productService::findById)
+                .toList();
+
+        List<ProductInfo> enriched = enrichProducts(products);
+
+        return new PageResponse<>(enriched, idCache.page(), idCache.size(),
+                idCache.totalElements(), idCache.totalPages());
+    }
+
+    @Cacheable(cacheNames = "productList",
+               key = "T(String).valueOf(#brandId) + ':' + #sort.name() + ':p' + #page + ':s' + #size")
+    public ProductListIdCache getCachedProductListIds(Long brandId,
+                                                      ProductSortType sort, int page, int size) {
+        PageQuery query = buildPageQuery(sort, page, size);
+        PagedResult<ProductModel> productPage = productService.findAllForCustomer(null, brandId, query);
+
+        List<Long> productIds = productPage.content().stream()
+                .map(ProductModel::getProductId)
+                .toList();
+
+        return new ProductListIdCache(productIds, productPage.page(), productPage.size(),
+                productPage.totalElements(), productPage.totalPages());
+    }
+
+    private PageResponse<ProductInfo> getProductsFromDb(String keyword, Long brandId,
+                                                         ProductSortType sort, int page, int size) {
+        PageQuery query = buildPageQuery(sort, page, size);
+        PagedResult<ProductModel> productPage = productService.findAllForCustomer(keyword, brandId, query);
+        List<ProductInfo> enriched = enrichProducts(productPage.content());
 
-        Page<ProductModel> productPage = productService.findAllForCustomer(keyword, brandId,
-                PageRequest.of(page, size, dbSort));
-        List<ProductInfo> enriched = enrichProducts(productPage.getContent());
+        return new PageResponse<>(enriched, productPage.page(), productPage.size(),
+                productPage.totalElements(), productPage.totalPages());
+    }
 
-        return new PageResponse<>(enriched, productPage.getNumber(), productPage.getSize(),
-                productPage.getTotalElements(), productPage.getTotalPages());
+    private PageQuery buildPageQuery(ProductSortType sort, int page, int size) {
+        return switch (sort) {
+            case LATEST -> new PageQuery(page, size, "createdAt", false);
+            case PRICE_ASC -> new PageQuery(page, size, "price", true);
+            case LIKES_DESC -> new PageQuery(page, size, "likeCount", false);
+        };
     }
 
     /**
@@ -88,12 +130,11 @@ public PageResponse<ProductInfo> getProductsForCustomer(String keyword, String b
      * @param productId 조회할 상품 ID
      * @return 상품 상세 정보 (재고, 브랜드명, 좋아요 수 포함)
      */
-    public ProductInfo getProductDetailForCustomer(String productId) {
+    public ProductInfo getProductDetailForCustomer(Long productId) {
         ProductModel product = productService.findById(productId);
         ProductStockModel stock = stockService.findByProductId(productId);
         BrandModel brand = brandService.findById(product.getBrandId());
-        long likeCount = likeService.countByProductId(productId);
-        return ProductInfo.from(product, stock, brand.getBrandName(), likeCount);
+        return ProductInfo.from(product, stock, brand.getBrandName(), product.getLikeCount());
     }
 
     /**
@@ -106,22 +147,24 @@ public ProductInfo getProductDetailForCustomer(String productId) {
      */
     public List<ProductInfo> getProductsForAdmin(boolean includeDeleted) {
         List<ProductModel> products = productService.findAllForAdmin(includeDeleted);
+        List<Long> productIds = products.stream().map(ProductModel::getProductId).toList();
+        Map<Long, ProductStockModel> stockMap = stockService.findAllByProductIds(productIds).stream()
+                .collect(Collectors.toMap(ProductStockModel::getProductId, Function.identity()));
         return products.stream()
-                .map(product -> {
-                    ProductStockModel stock = stockService.findByProductId(product.getProductId());
-                    return ProductInfo.from(product, stock);
-                })
+                .map(product -> ProductInfo.from(product, stockMap.get(product.getProductId())))
                 .toList();
     }
 
     /**
      * 상품을 신규 등록한다.
      *
-     * <p>브랜드 존재 여부를 검증한 뒤, 상품을 생성하고, 초기 재고를 설정한다.</p>
+     * <p>브랜드 존재 여부를 검증한 뒤, 상품을 생성하고, 초기 재고를 설정한다.
+     * 상품 생성은 목록 구조를 변경하므로 productList 캐시를 전체 무효화한다.</p>
      *
      * @param command 상품 생성 커맨드
      * @return 생성된 상품 정보
      */
+    @CacheEvict(cacheNames = "productList", allEntries = true)
     @Transactional
     public ProductInfo createProduct(ProductCreateCommand command) {
         brandService.findById(command.brandId());
@@ -134,7 +177,9 @@ public ProductInfo createProduct(ProductCreateCommand command) {
     /**
      * 상품 정보를 수정한다.
      *
-     * <p>상품을 수정한 뒤 재고 정보를 결합하여 반환한다.</p>
+     * <p>상품을 수정한 뒤 재고 정보를 결합하여 반환한다.
+     * 캐시 위계 분리에 의해 productList는 ID 목록만 캐싱하므로,
+     * 상품 정보 수정 시 productList evict 불필요 (productDetail만 evict됨).</p>
      *
      * @param command 상품 수정 커맨드
      * @return 수정된 상품 정보
@@ -149,48 +194,28 @@ public ProductInfo updateProduct(ProductUpdateCommand command) {
     }
 
     /**
-     * 좋아요 수 기준 내림차순 정렬 + 수동 페이징. like count가 별도 테이블이므로 DB-level 정렬 불가.
-     */
-    private PageResponse<ProductInfo> getProductsSortedByLikes(String keyword, String brandId,
-                                                               int page, int size) {
-        List<ProductModel> allProducts = productService.findAllForCustomer(keyword, brandId);
-        List<ProductInfo> enriched = enrichProducts(allProducts);
-
-        List<ProductInfo> sorted = enriched.stream()
-                .sorted(Comparator.comparingLong(ProductInfo::getLikeCount).reversed())
-                .toList();
-
-        int totalElements = sorted.size();
-        int totalPages = (totalElements + size - 1) / size;
-        int fromIndex = Math.min(page * size, totalElements);
-        int toIndex = Math.min(fromIndex + size, totalElements);
-        List<ProductInfo> pageContent = sorted.subList(fromIndex, toIndex);
-
-        return new PageResponse<>(pageContent, page, size, totalElements, totalPages);
-    }
-
-    /**
-     * 상품 목록에 재고, 브랜드명, 좋아요 수를 배치 조회하여 결합한다 (N+1 방지).
+     * 상품 목록에 재고, 브랜드명을 배치 조회하여 결합한다 (N+1 방지).
+     * likeCount는 ProductModel에서 직접 읽는다 (비정규화).
      */
     private List<ProductInfo> enrichProducts(List<ProductModel> products) {
         if (products.isEmpty()) {
             return List.of();
         }
 
-        List<String> productIds = products.stream().map(ProductModel::getProductId).toList();
-        List<String> brandIds = products.stream().map(ProductModel::getBrandId).distinct().toList();
+        List<Long> productIds = products.stream().map(ProductModel::getProductId).toList();
+        List<Long> brandIds = products.stream().map(ProductModel::getBrandId).distinct().toList();
 
-        Map<String, BrandModel> brandMap = brandService.findAllByIds(brandIds).stream()
+        Map<Long, ProductStockModel> stockMap = stockService.findAllByProductIds(productIds).stream()
+                .collect(Collectors.toMap(ProductStockModel::getProductId, Function.identity()));
+        Map<Long, BrandModel> brandMap = brandService.findAllByIds(brandIds).stream()
                 .collect(Collectors.toMap(BrandModel::getBrandId, Function.identity()));
-        Map<String, Long> likeCountMap = likeService.countByProductIds(productIds);
 
         return products.stream()
                 .map(product -> {
-                    ProductStockModel stock = stockService.findByProductId(product.getProductId());
+                    ProductStockModel stock = stockMap.get(product.getProductId());
                     BrandModel brand = brandMap.get(product.getBrandId());
                     String brandName = brand != null ? brand.getBrandName() : null;
-                    long likeCount = likeCountMap.getOrDefault(product.getProductId(), 0L);
-                    return ProductInfo.from(product, stock, brandName, likeCount);
+                    return ProductInfo.from(product, stock, brandName, product.getLikeCount());
                 })
                 .toList();
     }
diff --git a/apps/commerce-api/src/main/java/com/loopers/application/product/ProductInfo.java b/apps/commerce-api/src/main/java/com/loopers/application/product/ProductInfo.java
index e50766ac2..c906abf04 100644
--- a/apps/commerce-api/src/main/java/com/loopers/application/product/ProductInfo.java
+++ b/apps/commerce-api/src/main/java/com/loopers/application/product/ProductInfo.java
@@ -20,8 +20,8 @@
 @Getter
 @Builder
 public class ProductInfo {
-    private final String productId;
-    private final String brandId;
+    private final Long productId;
+    private final Long brandId;
     private final String productName;
     private final String description;
     private final BigDecimal price;
diff --git a/apps/commerce-api/src/main/java/com/loopers/application/product/ProductListIdCache.java b/apps/commerce-api/src/main/java/com/loopers/application/product/ProductListIdCache.java
new file mode 100644
index 000000000..370a5fc36
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/application/product/ProductListIdCache.java
@@ -0,0 +1,20 @@
+package com.loopers.application.product;
+
+import java.io.Serializable;
+import java.util.List;
+
+/**
+ * 상품 목록 캐시용 경량 DTO.
+ * <p>
+ * 캐시 위계 분리를 위해 상품 ID 목록과 페이징 메타데이터만 저장한다.
+ * 개별 상품 정보는 productDetail 캐시에서 별도 조회한다.
+ * </p>
+ */
+public record ProductListIdCache(
+        List<Long> productIds,
+        int page,
+        int size,
+        long totalElements,
+        int totalPages
+) implements Serializable {
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/application/product/ProductRevisionInfo.java b/apps/commerce-api/src/main/java/com/loopers/application/product/ProductRevisionInfo.java
deleted file mode 100644
index 3abcb23fa..000000000
--- a/apps/commerce-api/src/main/java/com/loopers/application/product/ProductRevisionInfo.java
+++ /dev/null
@@ -1,47 +0,0 @@
-package com.loopers.application.product;
-
-import com.loopers.domain.product.ProductRevisionModel;
-import com.loopers.support.enums.ProductRevisionAction;
-import lombok.Builder;
-import lombok.Getter;
-
-import java.time.LocalDateTime;
-
-/**
- * 상품 변경 이력 정보 DTO.
- * <p>
- * 도메인 모델({@link ProductRevisionModel})을 직접 노출하지 않고
- * interfaces 계층에 전달하기 위한 응답 객체이다.
- * </p>
- */
-@Getter
-@Builder
-public class ProductRevisionInfo {
-    private final String productId;
-    private final Long revisionSeq;
-    private final ProductRevisionAction action;
-    private final String changedBy;
-    private final String changeReason;
-    private final String beforeSnapshot;
-    private final String afterSnapshot;
-    private final LocalDateTime createdAt;
-
-    /**
-     * ProductRevisionModel을 ProductRevisionInfo DTO로 변환한다.
-     *
-     * @param model 상품 변경 이력 엔티티
-     * @return 변경 이력 정보 DTO
-     */
-    public static ProductRevisionInfo from(ProductRevisionModel model) {
-        return ProductRevisionInfo.builder()
-                .productId(model.getProductId())
-                .revisionSeq(model.getRevisionSeq())
-                .action(model.getAction())
-                .changedBy(model.getChangedBy())
-                .changeReason(model.getChangeReason())
-                .beforeSnapshot(model.getBeforeSnapshot())
-                .afterSnapshot(model.getAfterSnapshot())
-                .createdAt(model.getCreatedAt())
-                .build();
-    }
-}
diff --git a/apps/commerce-api/src/main/java/com/loopers/application/product/ProductUpdateCommand.java b/apps/commerce-api/src/main/java/com/loopers/application/product/ProductUpdateCommand.java
index 6b94398b1..ab90a13be 100644
--- a/apps/commerce-api/src/main/java/com/loopers/application/product/ProductUpdateCommand.java
+++ b/apps/commerce-api/src/main/java/com/loopers/application/product/ProductUpdateCommand.java
@@ -14,7 +14,7 @@
  * @param description 변경할 상품 설명
  * @param imageUrl    변경할 이미지 URL
  */
-public record ProductUpdateCommand(String productId, String productName,
+public record ProductUpdateCommand(Long productId, String productName,
                                     BigDecimal price, String description,
                                     String imageUrl) {
 }
diff --git a/apps/commerce-api/src/main/java/com/loopers/application/stats/StatsAppService.java b/apps/commerce-api/src/main/java/com/loopers/application/stats/StatsAppService.java
deleted file mode 100644
index 4d0bdc982..000000000
--- a/apps/commerce-api/src/main/java/com/loopers/application/stats/StatsAppService.java
+++ /dev/null
@@ -1,49 +0,0 @@
-package com.loopers.application.stats;
-
-import com.loopers.domain.stats.StatsService;
-import lombok.RequiredArgsConstructor;
-import org.springframework.stereotype.Service;
-import org.springframework.transaction.annotation.Transactional;
-
-import java.time.LocalDate;
-import java.util.List;
-
-/**
- * 운영 통계 Application Service.
- * 도메인 서비스를 호출하고 StatsProjection → StatsInfo 변환을 수행한다.
- */
-@Service
-@RequiredArgsConstructor
-@Transactional(readOnly = true)
-public class StatsAppService {
-
-    private final StatsService statsService;
-
-    public StatsInfo.Overview getOverview(LocalDate startAt, LocalDate endAt) {
-        return StatsInfo.Overview.from(statsService.getOverview(startAt, endAt));
-    }
-
-    public List<StatsInfo.DailyOrderStat> getDailyOrderStats(LocalDate startAt, LocalDate endAt) {
-        return statsService.getDailyOrderStats(startAt, endAt).stream()
-                .map(StatsInfo.DailyOrderStat::from)
-                .toList();
-    }
-
-    public List<StatsInfo.ProductStat> getTopLikedProducts(int limit) {
-        return statsService.getTopLikedProducts(limit).stream()
-                .map(StatsInfo.ProductStat::from)
-                .toList();
-    }
-
-    public List<StatsInfo.ProductStat> getTopOrderedProducts(int limit) {
-        return statsService.getTopOrderedProducts(limit).stream()
-                .map(StatsInfo.ProductStat::from)
-                .toList();
-    }
-
-    public List<StatsInfo.LowStockProduct> getLowStockProducts(int threshold) {
-        return statsService.getLowStockProducts(threshold).stream()
-                .map(StatsInfo.LowStockProduct::from)
-                .toList();
-    }
-}
diff --git a/apps/commerce-api/src/main/java/com/loopers/application/stats/StatsInfo.java b/apps/commerce-api/src/main/java/com/loopers/application/stats/StatsInfo.java
deleted file mode 100644
index 955835776..000000000
--- a/apps/commerce-api/src/main/java/com/loopers/application/stats/StatsInfo.java
+++ /dev/null
@@ -1,104 +0,0 @@
-package com.loopers.application.stats;
-
-import com.loopers.domain.stats.StatsProjection;
-import lombok.AllArgsConstructor;
-import lombok.Builder;
-import lombok.Getter;
-
-import java.math.BigDecimal;
-import java.time.LocalDate;
-
-/**
- * 운영 통계 정보 DTO 모음.
- * 주문 현황 개요, 일별 주문 통계, 인기 상품, 저재고 상품 정보를 포함한다.
- */
-public class StatsInfo {
-
-    /**
-     * 주문 현황 개요 DTO.
-     * 결제 대기, 취소, 만료 건수를 포함한다.
-     */
-    @Getter
-    @Builder
-    @AllArgsConstructor
-    public static class Overview {
-        private final long pendingCount;
-        private final long cancelledCount;
-        private final long expiredCount;
-
-        public static Overview from(StatsProjection.Overview projection) {
-            return Overview.builder()
-                    .pendingCount(projection.getPendingCount())
-                    .cancelledCount(projection.getCancelledCount())
-                    .expiredCount(projection.getExpiredCount())
-                    .build();
-        }
-    }
-
-    /**
-     * 일별 주문 통계 DTO.
-     * 특정 날짜의 주문 건수와 총 주문 금액을 포함한다.
-     */
-    @Getter
-    @Builder
-    @AllArgsConstructor
-    public static class DailyOrderStat {
-        private final LocalDate date;
-        private final long orderCount;
-        private final BigDecimal totalAmount;
-
-        public static DailyOrderStat from(StatsProjection.DailyOrderStat projection) {
-            return DailyOrderStat.builder()
-                    .date(projection.getDate())
-                    .orderCount(projection.getOrderCount())
-                    .totalAmount(projection.getTotalAmount())
-                    .build();
-        }
-    }
-
-    /**
-     * 상품 통계 DTO.
-     * 인기 좋아요 상품, 인기 주문 상품 등 상품별 집계 결과를 표현한다.
-     */
-    @Getter
-    @Builder
-    @AllArgsConstructor
-    public static class ProductStat {
-        private final String productId;
-        private final String productName;
-        private final long count;
-
-        public static ProductStat from(StatsProjection.ProductStat projection) {
-            return ProductStat.builder()
-                    .productId(projection.getProductId())
-                    .productName(projection.getProductName())
-                    .count(projection.getCount())
-                    .build();
-        }
-    }
-
-    /**
-     * 저재고 상품 DTO.
-     * 가용 재고가 임계값 이하인 상품의 재고 현황을 포함한다.
-     */
-    @Getter
-    @Builder
-    @AllArgsConstructor
-    public static class LowStockProduct {
-        private final String productId;
-        private final String productName;
-        private final int onHand;
-        private final int reserved;
-        private final int availableQty;
-
-        public static LowStockProduct from(StatsProjection.LowStockProduct projection) {
-            return LowStockProduct.builder()
-                    .productId(projection.getProductId())
-                    .productName(projection.getProductName())
-                    .onHand(projection.getOnHand())
-                    .reserved(projection.getReserved())
-                    .availableQty(projection.getAvailableQty())
-                    .build();
-        }
-    }
-}
diff --git a/apps/commerce-api/src/main/java/com/loopers/application/user/UserAppService.java b/apps/commerce-api/src/main/java/com/loopers/application/user/UserAppService.java
deleted file mode 100644
index 96444aa99..000000000
--- a/apps/commerce-api/src/main/java/com/loopers/application/user/UserAppService.java
+++ /dev/null
@@ -1,55 +0,0 @@
-package com.loopers.application.user;
-
-import com.loopers.domain.user.UserRegisterCommand;
-import com.loopers.domain.user.UserService;
-import lombok.RequiredArgsConstructor;
-import org.springframework.stereotype.Service;
-import org.springframework.transaction.annotation.Transactional;
-
-/**
- * 사용자 도메인 Application Service.
- * 도메인 서비스를 호출하고 Model → Info 변환을 담당한다.
- */
-@Service
-@RequiredArgsConstructor
-@Transactional(readOnly = true)
-public class UserAppService {
-
-    private final UserService userService;
-
-    /**
-     * 회원가입을 수행한다.
-     *
-     * @param command 회원가입 커맨드
-     * @return 생성된 사용자 정보
-     */
-    @Transactional
-    public UserInfo register(UserRegisterCommand command) {
-        return UserInfo.from(userService.register(command));
-    }
-
-    /**
-     * 인증 후 본인 정보를 조회하여 UserInfo로 반환한다.
-     *
-     * @param loginId 로그인 ID
-     * @param loginPw 비밀번호
-     * @return 사용자 정보 DTO (마스킹된 이름 포함)
-     */
-    public UserInfo getMyInfo(String loginId, String loginPw) {
-        return UserInfo.from(userService.authenticate(loginId, loginPw));
-    }
-
-    /**
-     * 인증 헤더로 인증한 뒤 비밀번호를 변경한다.
-     *
-     * @param loginId   인증 헤더의 로그인 ID
-     * @param loginPw   인증 헤더의 비밀번호
-     * @param currentPw 현재 비밀번호 (body)
-     * @param newPw     새 비밀번호 (body)
-     */
-    @Transactional
-    public void changePassword(String loginId, String loginPw,
-                                String currentPw, String newPw) {
-        userService.authenticateAndChangePassword(loginId, loginPw, currentPw, newPw);
-    }
-}
diff --git a/apps/commerce-api/src/main/java/com/loopers/application/user/UserInfo.java b/apps/commerce-api/src/main/java/com/loopers/application/user/UserInfo.java
deleted file mode 100644
index 7b8c49a3a..000000000
--- a/apps/commerce-api/src/main/java/com/loopers/application/user/UserInfo.java
+++ /dev/null
@@ -1,38 +0,0 @@
-package com.loopers.application.user;
-
-import com.loopers.domain.user.UserModel;
-import lombok.Builder;
-import lombok.Getter;
-
-/**
- * 사용자 정보 DTO.
- * 도메인 모델({@link UserModel})을 직접 노출하지 않고 인터페이스 레이어에 전달하기 위한 응답 객체이다.
- * 비밀번호를 제외하고 마스킹된 이름을 포함한다.
- */
-@Getter
-@Builder
-public class UserInfo {
-    private final String userId;
-    private final String loginId;
-    private final String maskedName;
-    private final String birthday;
-    private final String email;
-    private final String address;
-
-    /**
-     * UserModel을 UserInfo DTO로 변환한다. password를 제외하고 maskedName을 포함한다.
-     *
-     * @param user 변환할 사용자 엔티티
-     * @return 사용자 정보 DTO
-     */
-    public static UserInfo from(UserModel user) {
-        return UserInfo.builder()
-                .userId(user.getUserId())
-                .loginId(user.getLoginId())
-                .maskedName(user.getMaskedName())
-                .birthday(user.getBirthday())
-                .email(user.getEmail())
-                .address(user.getAddress())
-                .build();
-    }
-}
diff --git a/apps/commerce-api/src/main/java/com/loopers/batch/OrderExpiryScheduler.java b/apps/commerce-api/src/main/java/com/loopers/batch/OrderExpiryScheduler.java
index 2e36ad88c..f4303b59e 100644
--- a/apps/commerce-api/src/main/java/com/loopers/batch/OrderExpiryScheduler.java
+++ b/apps/commerce-api/src/main/java/com/loopers/batch/OrderExpiryScheduler.java
@@ -28,13 +28,13 @@ public class OrderExpiryScheduler {
      */
     @Scheduled(fixedDelay = 60000)
     public void expireOrders() {
-        List<String> expiredOrderIds = orderService.findExpiredPendingOrderIds();
+        List<Long> expiredOrderIds = orderService.findExpiredPendingOrderIds();
         if (expiredOrderIds.isEmpty()) {
             return;
         }
         log.info("만료 대상 주문 {}건 처리 시작", expiredOrderIds.size());
         int successCount = 0;
-        for (String orderId : expiredOrderIds) {
+        for (Long orderId : expiredOrderIds) {
             try {
                 orderFacade.expireOrder(orderId);
                 successCount++;
diff --git a/apps/commerce-api/src/main/java/com/loopers/domain/brand/BrandModel.java b/apps/commerce-api/src/main/java/com/loopers/domain/brand/BrandModel.java
index f6fe7cd95..39ce24388 100644
--- a/apps/commerce-api/src/main/java/com/loopers/domain/brand/BrandModel.java
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/brand/BrandModel.java
@@ -8,12 +8,13 @@
 import jakarta.persistence.Entity;
 import jakarta.persistence.EnumType;
 import jakarta.persistence.Enumerated;
+import jakarta.persistence.GeneratedValue;
+import jakarta.persistence.GenerationType;
 import jakarta.persistence.Id;
 import jakarta.persistence.Table;
 import lombok.AccessLevel;
 import lombok.Getter;
 import lombok.NoArgsConstructor;
-import org.hibernate.annotations.UuidGenerator;
 
 /**
  * 브랜드 JPA 엔티티.
@@ -27,9 +28,9 @@
 public class BrandModel extends BaseStringIdEntity {
 
     @Id
-    @UuidGenerator
-    @Column(name = "brand_id", length = 36)
-    private String brandId;
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    @Column(name = "brand_id")
+    private Long brandId;
 
     @Column(name = "brand_name", nullable = false)
     private String brandName;
diff --git a/apps/commerce-api/src/main/java/com/loopers/domain/brand/BrandRepository.java b/apps/commerce-api/src/main/java/com/loopers/domain/brand/BrandRepository.java
index 76d279438..bc3b11ba2 100644
--- a/apps/commerce-api/src/main/java/com/loopers/domain/brand/BrandRepository.java
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/brand/BrandRepository.java
@@ -26,7 +26,7 @@ public interface BrandRepository {
      * @param brandId 브랜드 ID
      * @return 브랜드 (Optional)
      */
-    Optional<BrandModel> findById(String brandId);
+    Optional<BrandModel> findById(Long brandId);
 
     /**
      * 전체 브랜드 목록을 조회한다 (관리자용, 삭제 포함).
@@ -58,5 +58,5 @@ public interface BrandRepository {
      * @param brandIds 브랜드 ID 목록
      * @return 해당 브랜드 목록
      */
-    List<BrandModel> findAllByIds(Collection<String> brandIds);
+    List<BrandModel> findAllByIds(Collection<Long> brandIds);
 }
diff --git a/apps/commerce-api/src/main/java/com/loopers/domain/brand/BrandService.java b/apps/commerce-api/src/main/java/com/loopers/domain/brand/BrandService.java
index 10781f353..0370df605 100644
--- a/apps/commerce-api/src/main/java/com/loopers/domain/brand/BrandService.java
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/brand/BrandService.java
@@ -1,9 +1,12 @@
 package com.loopers.domain.brand;
 
+import com.loopers.domain.product.ProductService;
 import com.loopers.support.enums.DisplayStatus;
 import com.loopers.support.error.CoreException;
 import com.loopers.support.error.ErrorType;
 import lombok.RequiredArgsConstructor;
+import org.springframework.cache.annotation.CacheEvict;
+import org.springframework.cache.annotation.Cacheable;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
@@ -20,6 +23,7 @@
 public class BrandService {
 
     private final BrandRepository brandRepository;
+    private final ProductService productService;
 
     /**
      * 새 브랜드를 등록한다.
@@ -57,11 +61,12 @@ public List<BrandModel> findAllForAdmin() {
      * @param brandIds 브랜드 ID 목록
      * @return 브랜드 엔티티 목록
      */
-    public List<BrandModel> findAllByIds(Collection<String> brandIds) {
+    public List<BrandModel> findAllByIds(Collection<Long> brandIds) {
         return brandRepository.findAllByIds(brandIds);
     }
 
-    public BrandModel findById(String brandId) {
+    @Cacheable(cacheNames = "brandDetail", key = "#brandId")
+    public BrandModel findById(Long brandId) {
         return brandRepository.findById(brandId)
                 .orElseThrow(() -> new CoreException(ErrorType.BRAND_NOT_FOUND));
     }
@@ -73,7 +78,7 @@ public BrandModel findById(String brandId) {
      * @return 브랜드 정보 DTO
      * @throws CoreException 브랜드가 존재하지 않거나 비노출 상태일 때 (BRAND_NOT_FOUND)
      */
-    public BrandModel findVisibleById(String brandId) {
+    public BrandModel findVisibleById(Long brandId) {
         BrandModel brand = findById(brandId);
         if (!brand.isVisibleForCustomer()) {
             throw new CoreException(ErrorType.BRAND_NOT_FOUND);
@@ -104,23 +109,25 @@ public List<BrandModel> findAllVisibleBrands(String keyword) {
      * @return 수정된 브랜드 정보 DTO
      * @throws CoreException 브랜드가 존재하지 않을 때 (BRAND_NOT_FOUND)
      */
+    @CacheEvict(cacheNames = "brandDetail", key = "#brandId")
     @Transactional
-    public BrandModel updateBrand(String brandId, String brandName, String description, String address) {
+    public BrandModel updateBrand(Long brandId, String brandName, String description, String address) {
         BrandModel brand = findById(brandId);
         brand.updateInfo(brandName, description, address);
         return brand;
     }
 
     /**
-     * 브랜드를 소프트 삭제한다.
+     * 브랜드를 소프트 삭제한다. 소속 상품도 연쇄 소프트 삭제된다.
      *
      * @param brandId 삭제할 브랜드 ID
      * @throws CoreException 브랜드가 존재하지 않을 때 (BRAND_NOT_FOUND)
-     * @수정요망 : 브랜드 삭제시 브랜드의 상품들도 소프트 딜리트
      */
+    @CacheEvict(cacheNames = "brandDetail", key = "#brandId")
     @Transactional
-    public void deleteBrand(String brandId) {
+    public void deleteBrand(Long brandId) {
         BrandModel brand = findById(brandId);
         brand.softDelete();
+        productService.softDeleteByBrandId(brandId);
     }
 }
diff --git a/apps/commerce-api/src/main/java/com/loopers/domain/cart/CartItemId.java b/apps/commerce-api/src/main/java/com/loopers/domain/cart/CartItemId.java
index 94860f810..5850db315 100644
--- a/apps/commerce-api/src/main/java/com/loopers/domain/cart/CartItemId.java
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/cart/CartItemId.java
@@ -20,6 +20,6 @@
 @AllArgsConstructor
 @EqualsAndHashCode
 public class CartItemId implements Serializable {
-    private String userId;
-    private String productId;
+    private Long userId;
+    private Long productId;
 }
diff --git a/apps/commerce-api/src/main/java/com/loopers/domain/cart/CartItemModel.java b/apps/commerce-api/src/main/java/com/loopers/domain/cart/CartItemModel.java
index 7e545c338..b2c511330 100644
--- a/apps/commerce-api/src/main/java/com/loopers/domain/cart/CartItemModel.java
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/cart/CartItemModel.java
@@ -30,12 +30,12 @@
 public class CartItemModel {
 
     @Id
-    @Column(name = "user_id", length = 36)
-    private String userId;
+    @Column(name = "user_id")
+    private Long userId;
 
     @Id
-    @Column(name = "product_id", length = 36)
-    private String productId;
+    @Column(name = "product_id")
+    private Long productId;
 
     @Column(nullable = false)
     private int quantity;
@@ -46,7 +46,7 @@ public class CartItemModel {
     @Column(name = "updated_at", nullable = false)
     private LocalDateTime updatedAt;
 
-    private CartItemModel(String userId, String productId, int quantity) {
+    private CartItemModel(Long userId, Long productId, int quantity) {
         validateQuantity(quantity);
         this.userId = userId;
         this.productId = productId;
@@ -63,7 +63,7 @@ private CartItemModel(String userId, String productId, int quantity) {
      * @return 생성된 CartItemModel 인스턴스
      * @throws CoreException quantity <= 0인 경우 (BAD_REQUEST)
      */
-    public static CartItemModel create(String userId, String productId, int quantity) {
+    public static CartItemModel create(Long userId, Long productId, int quantity) {
         return new CartItemModel(userId, productId, quantity);
     }
 
diff --git a/apps/commerce-api/src/main/java/com/loopers/domain/cart/CartItemRepository.java b/apps/commerce-api/src/main/java/com/loopers/domain/cart/CartItemRepository.java
index a7f10739f..85f19b1de 100644
--- a/apps/commerce-api/src/main/java/com/loopers/domain/cart/CartItemRepository.java
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/cart/CartItemRepository.java
@@ -41,5 +41,5 @@ public interface CartItemRepository {
      * @param userId 사용자 ID
      * @return 해당 사용자의 장바구니 항목 목록
      */
-    List<CartItemModel> findAllByUserId(String userId);
+    List<CartItemModel> findAllByUserId(Long userId);
 }
diff --git a/apps/commerce-api/src/main/java/com/loopers/domain/cart/CartService.java b/apps/commerce-api/src/main/java/com/loopers/domain/cart/CartService.java
index e7cf9f76b..6e7a787a0 100644
--- a/apps/commerce-api/src/main/java/com/loopers/domain/cart/CartService.java
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/cart/CartService.java
@@ -28,7 +28,7 @@ public class CartService {
      * @param productId 상품 ID
      * @param quantity  복원할 수량
      */
-    public record RestoreItem(String productId, int quantity) {
+    public record RestoreItem(Long productId, int quantity) {
     }
 
     private final CartItemRepository cartItemRepository;
@@ -45,7 +45,7 @@ public record RestoreItem(String productId, int quantity) {
      * @param qty       추가할 수량
      */
     @Transactional
-    public void addItem(String userId, String productId, int qty) {
+    public void addItem(Long userId, Long productId, int qty) {
         CartItemId cartItemId = new CartItemId(userId, productId);
         cartItemRepository.findById(cartItemId).ifPresentOrElse(
                 existingItem -> existingItem.mergeQuantity(qty),
@@ -62,7 +62,7 @@ public void addItem(String userId, String productId, int qty) {
      * @throws CoreException 장바구니 항목이 존재하지 않을 때 (CART_ITEM_NOT_FOUND)
      */
     @Transactional
-    public void changeQuantity(String userId, String productId, int newQty) {
+    public void changeQuantity(Long userId, Long productId, int newQty) {
         CartItemId cartItemId = new CartItemId(userId, productId);
         CartItemModel item = cartItemRepository.findById(cartItemId)
                 .orElseThrow(() -> new CoreException(ErrorType.CART_ITEM_NOT_FOUND));
@@ -76,7 +76,7 @@ public void changeQuantity(String userId, String productId, int newQty) {
      * @param productId 상품 ID
      */
     @Transactional
-    public void removeItem(String userId, String productId) {
+    public void removeItem(Long userId, Long productId) {
         CartItemId cartItemId = new CartItemId(userId, productId);
         cartItemRepository.findById(cartItemId).ifPresent(cartItemRepository::delete);
     }
@@ -90,7 +90,7 @@ public void removeItem(String userId, String productId) {
      * @param userId 사용자 ID
      * @return 장바구니 항목 엔티티 목록
      */
-    public List<CartItemModel> getCartItems(String userId) {
+    public List<CartItemModel> getCartItems(Long userId) {
         return cartItemRepository.findAllByUserId(userId);
     }
 
@@ -104,7 +104,7 @@ public List<CartItemModel> getCartItems(String userId) {
      * @param items  복원할 항목 목록 (상품 ID + 수량)
      */
     @Transactional
-    public void restoreFromOrder(String userId, List<RestoreItem> items) {
+    public void restoreFromOrder(Long userId, List<RestoreItem> items) {
         for (RestoreItem item : items) {
             CartItemId cartItemId = new CartItemId(userId, item.productId());
             cartItemRepository.findById(cartItemId).ifPresentOrElse(
diff --git a/apps/commerce-api/src/main/java/com/loopers/domain/coupon/CouponModel.java b/apps/commerce-api/src/main/java/com/loopers/domain/coupon/CouponModel.java
new file mode 100644
index 000000000..3230f4b91
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/coupon/CouponModel.java
@@ -0,0 +1,130 @@
+package com.loopers.domain.coupon;
+
+import com.loopers.domain.BaseStringIdEntity;
+import com.loopers.support.enums.DiscountType;
+import com.loopers.support.error.CoreException;
+import com.loopers.support.error.ErrorType;
+import jakarta.persistence.Column;
+import jakarta.persistence.Entity;
+import jakarta.persistence.EnumType;
+import jakarta.persistence.Enumerated;
+import jakarta.persistence.GeneratedValue;
+import jakarta.persistence.GenerationType;
+import jakarta.persistence.Id;
+import jakarta.persistence.Table;
+import lombok.AccessLevel;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+
+import java.math.BigDecimal;
+import java.math.RoundingMode;
+import java.time.LocalDateTime;
+import java.time.ZonedDateTime;
+
+/**
+ * 쿠폰 템플릿 JPA 엔티티.
+ * <p>
+ * 고정 금액(FIXED) 또는 정률(RATE) 할인을 제공하는 쿠폰 템플릿이다.
+ * {@link BaseStringIdEntity}를 상속하여 소프트 삭제를 지원한다.
+ * </p>
+ */
+@Entity
+@Table(name = "coupons")
+@Getter
+@NoArgsConstructor(access = AccessLevel.PROTECTED)
+public class CouponModel extends BaseStringIdEntity {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    @Column(name = "coupon_id")
+    private Long couponId;
+
+    @Column(nullable = false)
+    private String name;
+
+    @Enumerated(EnumType.STRING)
+    @Column(name = "type", nullable = false, length = 10)
+    private DiscountType discountType;
+
+    @Column(name = "value", nullable = false, precision = 10, scale = 2)
+    private BigDecimal discountValue;
+
+    @Column(name = "min_order_amount", precision = 12, scale = 2)
+    private BigDecimal minOrderAmount;
+
+    @Column(name = "expired_at", nullable = false)
+    private LocalDateTime expiredAt;
+
+    private CouponModel(String name, DiscountType discountType, BigDecimal discountValue,
+                        BigDecimal minOrderAmount, LocalDateTime expiredAt) {
+        this.name = name;
+        this.discountType = discountType;
+        this.discountValue = discountValue;
+        this.minOrderAmount = minOrderAmount;
+        this.expiredAt = expiredAt;
+    }
+
+    /**
+     * 쿠폰 템플릿을 생성한다.
+     */
+    public static CouponModel create(String name, DiscountType discountType, BigDecimal discountValue,
+                                      BigDecimal minOrderAmount, LocalDateTime expiredAt) {
+        return new CouponModel(name, discountType, discountValue, minOrderAmount, expiredAt);
+    }
+
+    /**
+     * 할인 금액을 계산한다.
+     * <ul>
+     *   <li>FIXED: discountValue (주문 금액 초과 불가)</li>
+     *   <li>RATE: totalAmount * discountValue / 100, FLOOR 처리</li>
+     * </ul>
+     */
+    public BigDecimal calculateDiscount(BigDecimal totalAmount) {
+        if (discountType == DiscountType.FIXED) {
+            return discountValue.compareTo(totalAmount) > 0 ? totalAmount : discountValue;
+        }
+        // RATE: 내림(FLOOR) 처리
+        return totalAmount.multiply(discountValue)
+                .divide(BigDecimal.valueOf(100), 0, RoundingMode.FLOOR);
+    }
+
+    /**
+     * 쿠폰 적용 가능 여부를 검증한다.
+     *
+     * @param totalAmount 주문 총액 (null이면 minOrderAmount 검증 생략)
+     * @throws CoreException 삭제/만료 또는 최소 주문 금액 미충족 시 COUPON_NOT_APPLICABLE
+     */
+    public void validateApplicable(BigDecimal totalAmount) {
+        if (isDeleted() || LocalDateTime.now().isAfter(expiredAt)) {
+            throw new CoreException(ErrorType.COUPON_NOT_APPLICABLE);
+        }
+        if (totalAmount != null && minOrderAmount != null && totalAmount.compareTo(minOrderAmount) < 0) {
+            throw new CoreException(ErrorType.COUPON_NOT_APPLICABLE);
+        }
+    }
+
+    /**
+     * 쿠폰 정보를 수정한다.
+     */
+    public void updateInfo(String name, DiscountType discountType, BigDecimal discountValue,
+                            BigDecimal minOrderAmount, LocalDateTime expiredAt) {
+        this.name = name;
+        this.discountType = discountType;
+        this.discountValue = discountValue;
+        this.minOrderAmount = minOrderAmount;
+        this.expiredAt = expiredAt;
+    }
+
+    @Override
+    protected void guard() {
+        if (name == null || name.isBlank()) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "쿠폰명은 필수입니다.");
+        }
+        if (discountValue == null || discountValue.compareTo(BigDecimal.ZERO) <= 0) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "할인값은 0보다 커야 합니다.");
+        }
+        if (discountType == DiscountType.RATE && discountValue.compareTo(BigDecimal.valueOf(100)) > 0) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "정률 할인값은 100 이하여야 합니다.");
+        }
+    }
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/domain/coupon/CouponRepository.java b/apps/commerce-api/src/main/java/com/loopers/domain/coupon/CouponRepository.java
new file mode 100644
index 000000000..578e6bf66
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/coupon/CouponRepository.java
@@ -0,0 +1,26 @@
+package com.loopers.domain.coupon;
+
+import com.loopers.support.page.PageQuery;
+import com.loopers.support.page.PagedResult;
+
+import java.util.Collection;
+import java.util.List;
+import java.util.Optional;
+
+/**
+ * 쿠폰 템플릿 레포지토리 인터페이스 (도메인 레이어).
+ */
+public interface CouponRepository {
+
+    Optional<CouponModel> findById(Long couponId);
+
+    Optional<CouponModel> findByIdWithLock(Long couponId);
+
+    CouponModel save(CouponModel coupon);
+
+    List<CouponModel> findAll();
+
+    List<CouponModel> findAllByIdIn(Collection<Long> ids);
+
+    PagedResult<CouponModel> findAllPaged(PageQuery query);
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/domain/coupon/CouponService.java b/apps/commerce-api/src/main/java/com/loopers/domain/coupon/CouponService.java
new file mode 100644
index 000000000..55e5d84a6
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/coupon/CouponService.java
@@ -0,0 +1,209 @@
+package com.loopers.domain.coupon;
+
+import com.loopers.support.enums.DiscountType;
+import com.loopers.support.error.CoreException;
+import com.loopers.support.error.ErrorType;
+import com.loopers.support.page.PageQuery;
+import com.loopers.support.page.PagedResult;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Propagation;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.math.BigDecimal;
+import java.time.LocalDateTime;
+import java.util.Collection;
+import java.util.List;
+
+/**
+ * 쿠폰 도메인 서비스.
+ * <p>
+ * 쿠폰 템플릿 CRUD, 사용자 쿠폰 발급/사용 비즈니스 로직을 담당한다.
+ * 쿠폰 발급 시 비관적 락(SELECT FOR UPDATE)을 사용하여 중복 발급을 방지한다.
+ * </p>
+ */
+@Service
+@RequiredArgsConstructor
+@Transactional(readOnly = true)
+public class CouponService {
+
+    private final CouponRepository couponRepository;
+    private final UserCouponRepository userCouponRepository;
+
+    // ============================
+    // 관리자용 메서드
+    // ============================
+
+    /**
+     * 쿠폰 템플릿을 생성한다.
+     */
+    @Transactional
+    public CouponModel createCoupon(String name, DiscountType discountType, BigDecimal discountValue,
+                                     BigDecimal minOrderAmount, LocalDateTime expiredAt) {
+        CouponModel coupon = CouponModel.create(name, discountType, discountValue, minOrderAmount, expiredAt);
+        return couponRepository.save(coupon);
+    }
+
+    /**
+     * 쿠폰 목록을 조회한다 (관리자 — 삭제된 쿠폰 포함).
+     */
+    public List<CouponModel> findAllForAdmin() {
+        return couponRepository.findAll();
+    }
+
+    /**
+     * 쿠폰 상세를 조회한다 (관리자 — 삭제된 쿠폰 포함).
+     *
+     * @throws CoreException 쿠폰이 없는 경우 COUPON_NOT_FOUND
+     */
+    public CouponModel findByIdForAdmin(Long couponId) {
+        return couponRepository.findById(couponId)
+                .orElseThrow(() -> new CoreException(ErrorType.COUPON_NOT_FOUND));
+    }
+
+    /**
+     * 쿠폰 정보를 수정한다.
+     *
+     * @throws CoreException 쿠폰이 없는 경우 COUPON_NOT_FOUND
+     */
+    @Transactional
+    public CouponModel updateCoupon(Long couponId, String name, DiscountType discountType,
+                                     BigDecimal discountValue, BigDecimal minOrderAmount,
+                                     LocalDateTime expiredAt) {
+        CouponModel coupon = couponRepository.findById(couponId)
+                .orElseThrow(() -> new CoreException(ErrorType.COUPON_NOT_FOUND));
+        coupon.updateInfo(name, discountType, discountValue, minOrderAmount, expiredAt);
+        return couponRepository.save(coupon);
+    }
+
+    /**
+     * 쿠폰을 소프트 삭제한다.
+     *
+     * @throws CoreException 쿠폰이 없는 경우 COUPON_NOT_FOUND
+     */
+    @Transactional
+    public void deleteCoupon(Long couponId) {
+        CouponModel coupon = couponRepository.findById(couponId)
+                .orElseThrow(() -> new CoreException(ErrorType.COUPON_NOT_FOUND));
+        coupon.softDelete();
+        couponRepository.save(coupon);
+    }
+
+    /**
+     * 특정 쿠폰의 발급 내역을 조회한다 (관리자).
+     */
+    public List<UserCouponModel> findIssueHistory(Long couponId) {
+        return userCouponRepository.findAllByCouponId(couponId);
+    }
+
+    /**
+     * 관리자용 쿠폰 목록을 페이징 조회한다.
+     */
+    public PagedResult<CouponModel> findAllForAdminPaged(PageQuery query) {
+        return couponRepository.findAllPaged(query);
+    }
+
+    /**
+     * 특정 쿠폰의 발급 내역을 페이징 조회한다 (관리자).
+     */
+    public PagedResult<UserCouponModel> findIssueHistoryPaged(Long couponId, PageQuery query) {
+        return userCouponRepository.findAllByCouponIdPaged(couponId, query);
+    }
+
+    // ============================
+    // 대고객 메서드
+    // ============================
+
+    /**
+     * 쿠폰을 발급한다.
+     * <p>
+     * 비관적 락을 사용하여 동시 발급 요청 시 중복 발급을 방지한다.
+     * DB UNIQUE KEY(user_id, coupon_id)가 최후 안전망으로 작동한다.
+     * </p>
+     *
+     * @throws CoreException 쿠폰 없음(COUPON_NOT_FOUND), 만료/삭제(COUPON_NOT_APPLICABLE),
+     *                       중복 발급(COUPON_ALREADY_ISSUED)
+     */
+    @Transactional
+    public UserCouponModel issueCoupon(Long userId, Long couponId) {
+        CouponModel coupon = couponRepository.findByIdWithLock(couponId)
+                .orElseThrow(() -> new CoreException(ErrorType.COUPON_NOT_FOUND));
+
+        coupon.validateApplicable(null);
+
+        if (userCouponRepository.existsByUserIdAndCouponId(userId, couponId)) {
+            throw new CoreException(ErrorType.COUPON_ALREADY_ISSUED);
+        }
+
+        UserCouponModel userCoupon = UserCouponModel.create(userId, couponId);
+        return userCouponRepository.save(userCoupon);
+    }
+
+    /**
+     * 내 쿠폰 목록을 조회한다 (AVAILABLE/USED/EXPIRED 모두 포함).
+     */
+    public List<UserCouponModel> findMyCoupons(Long userId) {
+        return userCouponRepository.findAllByUserId(userId);
+    }
+
+    // ============================
+    // OrderFacade 내부용 메서드
+    // ============================
+
+    /**
+     * 유효한 발급 쿠폰을 조회한다.
+     * <p>
+     * 비관적 락으로 조회하여 동시 주문 시 쿠폰 중복 사용을 방지한다.
+     * </p>
+     *
+     * @param userId       쿠폰 소유자 ID
+     * @param userCouponId 발급 쿠폰 ID
+     * @return 조회된 UserCouponModel (AVAILABLE 상태)
+     * @throws CoreException 쿠폰 없음/타 유저 소유(USER_COUPON_NOT_FOUND),
+     *                       사용 불가(COUPON_NOT_AVAILABLE)
+     */
+    @Transactional
+    public UserCouponModel validateAndGetUserCoupon(Long userId, Long userCouponId) {
+        UserCouponModel userCoupon = userCouponRepository.findByIdWithLock(userCouponId)
+                .filter(uc -> uc.getUserId().equals(userId))
+                .orElseThrow(() -> new CoreException(ErrorType.USER_COUPON_NOT_FOUND));
+
+        if (!userCoupon.isAvailable()) {
+            throw new CoreException(ErrorType.COUPON_NOT_AVAILABLE);
+        }
+        return userCoupon;
+    }
+
+    /**
+     * 쿠폰을 사용 완료 처리한다. 반드시 상위 트랜잭션 내에서 호출해야 한다.
+     *
+     * @param userCouponId 발급 쿠폰 ID
+     * @param orderId      사용된 주문 ID
+     */
+    @Transactional(propagation = Propagation.MANDATORY)
+    public void markCouponAsUsed(Long userCouponId, Long orderId) {
+        UserCouponModel userCoupon = userCouponRepository.findByIdWithLock(userCouponId)
+                .orElseThrow(() -> new CoreException(ErrorType.USER_COUPON_NOT_FOUND));
+        userCoupon.markAsUsed(orderId);
+        userCouponRepository.save(userCoupon);
+    }
+
+    /**
+     * ID 목록으로 쿠폰 템플릿을 일괄 조회한다 (N+1 방지).
+     */
+    public List<CouponModel> findAllByIds(Collection<Long> couponIds) {
+        return couponRepository.findAllByIdIn(couponIds);
+    }
+
+    /**
+     * 주문 취소/만료 시 사용된 쿠폰을 복원한다 (멱등).
+     * 반드시 상위 트랜잭션 내에서 호출해야 한다.
+     *
+     * @param orderId 주문 ID
+     */
+    @Transactional(propagation = Propagation.MANDATORY)
+    public void restoreCoupon(Long orderId) {
+        userCouponRepository.findByOrderId(orderId)
+                .ifPresent(UserCouponModel::restoreToAvailable);
+    }
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/domain/coupon/UserCouponModel.java b/apps/commerce-api/src/main/java/com/loopers/domain/coupon/UserCouponModel.java
new file mode 100644
index 000000000..bef9b50bb
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/coupon/UserCouponModel.java
@@ -0,0 +1,118 @@
+package com.loopers.domain.coupon;
+
+import com.loopers.support.enums.UserCouponStatus;
+import com.loopers.support.error.CoreException;
+import com.loopers.support.error.ErrorType;
+import jakarta.persistence.Column;
+import jakarta.persistence.Entity;
+import jakarta.persistence.EnumType;
+import jakarta.persistence.Enumerated;
+import jakarta.persistence.GeneratedValue;
+import jakarta.persistence.GenerationType;
+import jakarta.persistence.Id;
+import jakarta.persistence.PrePersist;
+import jakarta.persistence.Table;
+import jakarta.persistence.UniqueConstraint;
+import lombok.AccessLevel;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+
+import java.time.LocalDateTime;
+
+/**
+ * 사용자 발급 쿠폰 JPA 엔티티.
+ * <p>
+ * 발급 이력을 관리하며, 상태(AVAILABLE/USED/EXPIRED)로 생명주기를 관리한다.
+ * 소프트 삭제 대신 상태 관리를 사용하므로 {@code BaseStringIdEntity}를 상속하지 않는다.
+ * </p>
+ */
+@Entity
+@Table(name = "user_coupons",
+        uniqueConstraints = @UniqueConstraint(
+                name = "uq_user_coupons",
+                columnNames = {"user_id", "coupon_id"}
+        ))
+@Getter
+@NoArgsConstructor(access = AccessLevel.PROTECTED)
+public class UserCouponModel {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    @Column(name = "user_coupon_id")
+    private Long userCouponId;
+
+    @Column(name = "user_id", nullable = false)
+    private Long userId;
+
+    @Column(name = "coupon_id", nullable = false)
+    private Long couponId;
+
+    @Enumerated(EnumType.STRING)
+    @Column(nullable = false, length = 20)
+    private UserCouponStatus status;
+
+    @Column(name = "issued_at", nullable = false, updatable = false)
+    private LocalDateTime issuedAt;
+
+    @Column(name = "used_at")
+    private LocalDateTime usedAt;
+
+    @Column(name = "order_id")
+    private Long orderId;
+
+    private UserCouponModel(Long userId, Long couponId) {
+        this.userId = userId;
+        this.couponId = couponId;
+        this.status = UserCouponStatus.AVAILABLE;
+        this.issuedAt = LocalDateTime.now();
+    }
+
+    /**
+     * 사용자 발급 쿠폰을 생성한다. 상태는 AVAILABLE, 발급 일시는 현재 시각으로 초기화된다.
+     */
+    public static UserCouponModel create(Long userId, Long couponId) {
+        return new UserCouponModel(userId, couponId);
+    }
+
+    /**
+     * 쿠폰을 사용 완료 처리한다.
+     *
+     * @param orderId 사용된 주문 ID
+     * @throws CoreException 이미 사용된 쿠폰인 경우 COUPON_NOT_AVAILABLE
+     */
+    public void markAsUsed(Long orderId) {
+        if (this.status != UserCouponStatus.AVAILABLE) {
+            throw new CoreException(ErrorType.COUPON_NOT_AVAILABLE);
+        }
+        this.status = UserCouponStatus.USED;
+        this.usedAt = LocalDateTime.now();
+        this.orderId = orderId;
+    }
+
+    /**
+     * 쿠폰 사용 가능 여부를 반환한다.
+     */
+    public boolean isAvailable() {
+        return this.status == UserCouponStatus.AVAILABLE;
+    }
+
+    /**
+     * 사용된 쿠폰을 사용 가능 상태로 복원한다 (멱등).
+     * 이미 AVAILABLE이면 무시한다.
+     */
+    public void restoreToAvailable() {
+        if (this.status == UserCouponStatus.AVAILABLE) {
+            return;
+        }
+        this.status = UserCouponStatus.AVAILABLE;
+        this.usedAt = null;
+        this.orderId = null;
+    }
+
+    @PrePersist
+    private void prePersist() {
+        if (this.issuedAt == null) {
+            this.issuedAt = LocalDateTime.now();
+        }
+    }
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/domain/coupon/UserCouponRepository.java b/apps/commerce-api/src/main/java/com/loopers/domain/coupon/UserCouponRepository.java
new file mode 100644
index 000000000..61d2a6d35
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/coupon/UserCouponRepository.java
@@ -0,0 +1,31 @@
+package com.loopers.domain.coupon;
+
+import com.loopers.support.page.PageQuery;
+import com.loopers.support.page.PagedResult;
+
+import java.util.List;
+import java.util.Optional;
+
+/**
+ * 사용자 발급 쿠폰 레포지토리 인터페이스 (도메인 레이어).
+ */
+public interface UserCouponRepository {
+
+    UserCouponModel save(UserCouponModel userCoupon);
+
+    Optional<UserCouponModel> findById(Long userCouponId);
+
+    Optional<UserCouponModel> findByIdWithLock(Long userCouponId);
+
+    Optional<UserCouponModel> findByUserIdAndCouponId(Long userId, Long couponId);
+
+    List<UserCouponModel> findAllByUserId(Long userId);
+
+    List<UserCouponModel> findAllByCouponId(Long couponId);
+
+    boolean existsByUserIdAndCouponId(Long userId, Long couponId);
+
+    PagedResult<UserCouponModel> findAllByCouponIdPaged(Long couponId, PageQuery query);
+
+    Optional<UserCouponModel> findByOrderId(Long orderId);
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/domain/like/LikeId.java b/apps/commerce-api/src/main/java/com/loopers/domain/like/LikeId.java
index e3f26a7e8..3a74fff5b 100644
--- a/apps/commerce-api/src/main/java/com/loopers/domain/like/LikeId.java
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/like/LikeId.java
@@ -17,6 +17,6 @@
 @AllArgsConstructor
 @EqualsAndHashCode
 public class LikeId implements Serializable {
-    private String userId;
-    private String productId;
+    private Long userId;
+    private Long productId;
 }
diff --git a/apps/commerce-api/src/main/java/com/loopers/domain/like/LikeModel.java b/apps/commerce-api/src/main/java/com/loopers/domain/like/LikeModel.java
index 75c381030..2b09655a7 100644
--- a/apps/commerce-api/src/main/java/com/loopers/domain/like/LikeModel.java
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/like/LikeModel.java
@@ -27,17 +27,17 @@
 public class LikeModel {
 
     @Id
-    @Column(name = "user_id", length = 36)
-    private String userId;
+    @Column(name = "user_id")
+    private Long userId;
 
     @Id
-    @Column(name = "product_id", length = 36)
-    private String productId;
+    @Column(name = "product_id")
+    private Long productId;
 
     @Column(name = "created_at", nullable = false, updatable = false)
     private LocalDateTime createdAt;
 
-    private LikeModel(String userId, String productId) {
+    private LikeModel(Long userId, Long productId) {
         validateUserId(userId);
         validateProductId(productId);
         this.userId = userId;
@@ -50,9 +50,9 @@ private LikeModel(String userId, String productId) {
      * @param userId    사용자 ID (필수)
      * @param productId 상품 ID (필수)
      * @return 생성된 LikeModel 인스턴스
-     * @throws CoreException userId 또는 productId가 null/blank인 경우 (BAD_REQUEST)
+     * @throws CoreException userId 또는 productId가 null인 경우 (BAD_REQUEST)
      */
-    public static LikeModel create(String userId, String productId) {
+    public static LikeModel create(Long userId, Long productId) {
         return new LikeModel(userId, productId);
     }
 
@@ -61,14 +61,14 @@ private void prePersist() {
         this.createdAt = LocalDateTime.now();
     }
 
-    private static void validateUserId(String userId) {
-        if (userId == null || userId.isBlank()) {
+    private static void validateUserId(Long userId) {
+        if (userId == null) {
             throw new CoreException(ErrorType.BAD_REQUEST, "사용자 ID는 필수입니다.");
         }
     }
 
-    private static void validateProductId(String productId) {
-        if (productId == null || productId.isBlank()) {
+    private static void validateProductId(Long productId) {
+        if (productId == null) {
             throw new CoreException(ErrorType.BAD_REQUEST, "상품 ID는 필수입니다.");
         }
     }
diff --git a/apps/commerce-api/src/main/java/com/loopers/domain/like/LikeRepository.java b/apps/commerce-api/src/main/java/com/loopers/domain/like/LikeRepository.java
index 44c094501..ad38b48d8 100644
--- a/apps/commerce-api/src/main/java/com/loopers/domain/like/LikeRepository.java
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/like/LikeRepository.java
@@ -40,7 +40,7 @@ public interface LikeRepository {
      * @param userId 사용자 ID
      * @return 사용자의 좋아요 목록
      */
-    List<LikeModel> findAllByUserId(String userId);
+    List<LikeModel> findAllByUserId(Long userId);
 
     /**
      * 특정 상품의 좋아요 수를 조회한다.
@@ -48,7 +48,7 @@ public interface LikeRepository {
      * @param productId 상품 ID
      * @return 좋아요 수
      */
-    long countByProductId(String productId);
+    long countByProductId(Long productId);
 
     /**
      * 여러 상품의 좋아요 수를 일괄 조회한다 (N+1 방지용 배치 쿼리).
@@ -56,5 +56,5 @@ public interface LikeRepository {
      * @param productIds 상품 ID 목록
      * @return 상품 ID → 좋아요 수 맵
      */
-    Map<String, Long> countByProductIds(Collection<String> productIds);
+    Map<Long, Long> countByProductIds(Collection<Long> productIds);
 }
diff --git a/apps/commerce-api/src/main/java/com/loopers/domain/like/LikeService.java b/apps/commerce-api/src/main/java/com/loopers/domain/like/LikeService.java
index a6e0f83cb..550f969cb 100644
--- a/apps/commerce-api/src/main/java/com/loopers/domain/like/LikeService.java
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/like/LikeService.java
@@ -14,6 +14,7 @@
 /**
  * 좋아요 도메인 서비스.
  * 상품 좋아요 등록(멱등)/취소(멱등), 사용자별 좋아요 목록 조회를 담당한다.
+ * 상품 존재 여부 검증을 위해 {@link ProductService}를 참조한다.
  */
 @Service
 @RequiredArgsConstructor
@@ -31,9 +32,10 @@ public class LikeService {
      * @throws CoreException 상품이 존재하지 않을 때 (LIKE_PRODUCT_NOT_FOUND)
      */
     @Transactional
-    public void addLike(String userId, String productId) {
+    public void addLike(Long userId, Long productId) {
+        // 비관적 락으로 상품 조회 → 동일 상품 좋아요 연산 직렬화
         try {
-            productService.findById(productId);
+            productService.findByIdWithLock(productId);
         } catch (CoreException e) {
             throw new CoreException(ErrorType.LIKE_PRODUCT_NOT_FOUND);
         }
@@ -45,6 +47,7 @@ public void addLike(String userId, String productId) {
 
         LikeModel like = LikeModel.create(userId, productId);
         likeRepository.save(like);
+        productService.incrementLikeCount(productId);
     }
 
     /**
@@ -54,9 +57,19 @@ public void addLike(String userId, String productId) {
      * @param productId 상품 ID
      */
     @Transactional
-    public void removeLike(String userId, String productId) {
+    public void removeLike(Long userId, Long productId) {
+        // 비관적 락으로 상품 조회 → 동일 상품 좋아요 연산 직렬화
+        try {
+            productService.findByIdWithLock(productId);
+        } catch (CoreException e) {
+            return; // 상품이 없으면 좋아요도 없으므로 무시
+        }
+
         LikeId likeId = new LikeId(userId, productId);
-        likeRepository.findById(likeId).ifPresent(likeRepository::delete);
+        likeRepository.findById(likeId).ifPresent(like -> {
+            likeRepository.delete(like);
+            productService.decrementLikeCount(productId);
+        });
     }
 
     /**
@@ -65,7 +78,7 @@ public void removeLike(String userId, String productId) {
      * @param userId 사용자 ID
      * @return 좋아요 정보 DTO 목록
      */
-    public List<LikeModel> getMyLikes(String userId) {
+    public List<LikeModel> getMyLikes(Long userId) {
         return likeRepository.findAllByUserId(userId);
     }
 
@@ -75,7 +88,7 @@ public List<LikeModel> getMyLikes(String userId) {
      * @param productId 상품 ID
      * @return 좋아요 수
      */
-    public long countByProductId(String productId) {
+    public long countByProductId(Long productId) {
         return likeRepository.countByProductId(productId);
     }
 
@@ -85,7 +98,7 @@ public long countByProductId(String productId) {
      * @param productIds 상품 ID 목록
      * @return 상품 ID → 좋아요 수 맵
      */
-    public Map<String, Long> countByProductIds(Collection<String> productIds) {
+    public Map<Long, Long> countByProductIds(Collection<Long> productIds) {
         return likeRepository.countByProductIds(productIds);
     }
 }
diff --git a/apps/commerce-api/src/main/java/com/loopers/domain/order/OrderCartRestoreModel.java b/apps/commerce-api/src/main/java/com/loopers/domain/order/OrderCartRestoreModel.java
index 0faff1af1..14e067e7f 100644
--- a/apps/commerce-api/src/main/java/com/loopers/domain/order/OrderCartRestoreModel.java
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/order/OrderCartRestoreModel.java
@@ -30,11 +30,11 @@
 public class OrderCartRestoreModel {
 
     @Id
-    @Column(name = "order_id", length = 36)
-    private String orderId;
+    @Column(name = "order_id")
+    private Long orderId;
 
-    @Column(name = "user_id", nullable = false, length = 36)
-    private String userId;
+    @Column(name = "user_id", nullable = false)
+    private Long userId;
 
     @Enumerated(EnumType.STRING)
     @Column(nullable = false, length = 30)
@@ -47,7 +47,7 @@ public class OrderCartRestoreModel {
     @Column(name = "restored_at", nullable = false)
     private LocalDateTime restoredAt;
 
-    private OrderCartRestoreModel(String orderId, String userId,
+    private OrderCartRestoreModel(Long orderId, Long userId,
                                    RestoreReason reason, RestoreTriggerSource triggerSource) {
         this.orderId = orderId;
         this.userId = userId;
@@ -65,7 +65,7 @@ private OrderCartRestoreModel(String orderId, String userId,
      * @param triggerSource 복원 트리거 출처 (CANCEL_API / EXPIRE_JOB 등)
      * @return 생성된 OrderCartRestoreModel 인스턴스
      */
-    public static OrderCartRestoreModel create(String orderId, String userId,
+    public static OrderCartRestoreModel create(Long orderId, Long userId,
                                                 RestoreReason reason, RestoreTriggerSource triggerSource) {
         return new OrderCartRestoreModel(orderId, userId, reason, triggerSource);
     }
diff --git a/apps/commerce-api/src/main/java/com/loopers/domain/order/OrderCartRestoreRepository.java b/apps/commerce-api/src/main/java/com/loopers/domain/order/OrderCartRestoreRepository.java
index 006294423..de735fe76 100644
--- a/apps/commerce-api/src/main/java/com/loopers/domain/order/OrderCartRestoreRepository.java
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/order/OrderCartRestoreRepository.java
@@ -27,5 +27,5 @@ public interface OrderCartRestoreRepository {
      * @param orderId 주문 ID
      * @return 존재 여부
      */
-    boolean existsById(String orderId);
+    boolean existsById(Long orderId);
 }
diff --git a/apps/commerce-api/src/main/java/com/loopers/domain/order/OrderItemCommand.java b/apps/commerce-api/src/main/java/com/loopers/domain/order/OrderItemCommand.java
index e0391de22..dd431587b 100644
--- a/apps/commerce-api/src/main/java/com/loopers/domain/order/OrderItemCommand.java
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/order/OrderItemCommand.java
@@ -10,5 +10,5 @@
  * @param productId 상품 ID
  * @param quantity  주문 수량
  */
-public record OrderItemCommand(String productId, int quantity) {
+public record OrderItemCommand(Long productId, int quantity) {
 }
diff --git a/apps/commerce-api/src/main/java/com/loopers/domain/order/OrderItemId.java b/apps/commerce-api/src/main/java/com/loopers/domain/order/OrderItemId.java
index 32786c6aa..8988206ef 100644
--- a/apps/commerce-api/src/main/java/com/loopers/domain/order/OrderItemId.java
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/order/OrderItemId.java
@@ -20,6 +20,6 @@
 @AllArgsConstructor
 @EqualsAndHashCode
 public class OrderItemId implements Serializable {
-    private String orderId;
+    private Long orderId;
     private int orderItemSeq;
 }
diff --git a/apps/commerce-api/src/main/java/com/loopers/domain/order/OrderItemModel.java b/apps/commerce-api/src/main/java/com/loopers/domain/order/OrderItemModel.java
index a12ae996f..9c28ad28d 100644
--- a/apps/commerce-api/src/main/java/com/loopers/domain/order/OrderItemModel.java
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/order/OrderItemModel.java
@@ -32,18 +32,18 @@
 public class OrderItemModel {
 
     @Id
-    @Column(name = "order_id", length = 36)
-    private String orderId;
+    @Column(name = "order_id")
+    private Long orderId;
 
     @Id
     @Column(name = "order_item_seq")
     private int orderItemSeq;
 
-    @Column(name = "user_id", nullable = false, length = 36)
-    private String userId;
+    @Column(name = "user_id", nullable = false)
+    private Long userId;
 
-    @Column(name = "product_id", nullable = false, length = 36)
-    private String productId;
+    @Column(name = "product_id", nullable = false)
+    private Long productId;
 
     @Column(nullable = false)
     private int quantity;
@@ -63,6 +63,15 @@ public class OrderItemModel {
     @Column(name = "snapshot_image_url")
     private String snapshotImageUrl;
 
+    @Column(name = "original_amount", precision = 12, scale = 2)
+    private BigDecimal originalAmount;
+
+    @Column(name = "discount_amount", precision = 12, scale = 2)
+    private BigDecimal discountAmount;
+
+    @Column(name = "final_amount", precision = 12, scale = 2)
+    private BigDecimal finalAmount;
+
     @Column(name = "del_yn", nullable = false, length = 1)
     private String delYn = "N";
 
@@ -75,11 +84,12 @@ public class OrderItemModel {
     @Column(name = "updated_at", nullable = false)
     private LocalDateTime updatedAt;
 
-    private OrderItemModel(String orderId, int orderItemSeq, String userId,
-                           String productId, int quantity,
+    private OrderItemModel(Long orderId, int orderItemSeq, Long userId,
+                           Long productId, int quantity,
                            String snapshotProductName, BigDecimal snapshotUnitPrice,
                            String snapshotBrandId, String snapshotBrandName,
-                           String snapshotImageUrl) {
+                           String snapshotImageUrl,
+                           BigDecimal originalAmount, BigDecimal discountAmount, BigDecimal finalAmount) {
         validateQuantity(quantity);
         this.orderId = orderId;
         this.orderItemSeq = orderItemSeq;
@@ -91,41 +101,50 @@ private OrderItemModel(String orderId, int orderItemSeq, String userId,
         this.snapshotBrandId = snapshotBrandId;
         this.snapshotBrandName = snapshotBrandName;
         this.snapshotImageUrl = snapshotImageUrl;
+        this.originalAmount = originalAmount;
+        this.discountAmount = discountAmount;
+        this.finalAmount = finalAmount;
     }
 
     /**
-     * 주문 항목 엔티티를 생성한다. 주문 시점의 상품 정보를 스냅샷으로 보존한다.
-     * <p>정적 팩토리 메서드 패턴을 사용하여 생성자를 대신한다.</p>
-     *
-     * @param orderId             주문 ID
-     * @param orderItemSeq        주문 내 항목 순번
-     * @param userId              주문자 ID
-     * @param productId           상품 ID
-     * @param quantity            주문 수량 (1 이상)
-     * @param snapshotProductName 주문 시점 상품명
-     * @param snapshotUnitPrice   주문 시점 단가
-     * @param snapshotBrandId     주문 시점 브랜드 ID
-     * @param snapshotBrandName   주문 시점 브랜드명
-     * @param snapshotImageUrl    주문 시점 이미지 URL
-     * @return 생성된 OrderItemModel 인스턴스
-     * @throws CoreException quantity <= 0인 경우 (BAD_REQUEST)
+     * 주문 항목 엔티티를 생성한다 (하위 호환 — 할인 없음).
      */
-    public static OrderItemModel create(String orderId, int orderItemSeq, String userId,
-                                         String productId, int quantity,
+    public static OrderItemModel create(Long orderId, int orderItemSeq, Long userId,
+                                         Long productId, int quantity,
                                          String snapshotProductName, BigDecimal snapshotUnitPrice,
                                          String snapshotBrandId, String snapshotBrandName,
                                          String snapshotImageUrl) {
+        BigDecimal lineTotal = snapshotUnitPrice != null
+                ? snapshotUnitPrice.multiply(BigDecimal.valueOf(quantity))
+                : null;
+        return new OrderItemModel(orderId, orderItemSeq, userId, productId, quantity,
+                snapshotProductName, snapshotUnitPrice, snapshotBrandId, snapshotBrandName,
+                snapshotImageUrl, lineTotal, BigDecimal.ZERO, lineTotal);
+    }
+
+    /**
+     * 주문 항목 엔티티를 생성한다 (할인 금액 포함).
+     */
+    public static OrderItemModel create(Long orderId, int orderItemSeq, Long userId,
+                                         Long productId, int quantity,
+                                         String snapshotProductName, BigDecimal snapshotUnitPrice,
+                                         String snapshotBrandId, String snapshotBrandName,
+                                         String snapshotImageUrl,
+                                         BigDecimal originalAmount, BigDecimal discountAmount,
+                                         BigDecimal finalAmount) {
         return new OrderItemModel(orderId, orderItemSeq, userId, productId, quantity,
                 snapshotProductName, snapshotUnitPrice, snapshotBrandId, snapshotBrandName,
-                snapshotImageUrl);
+                snapshotImageUrl, originalAmount, discountAmount, finalAmount);
     }
 
     /**
-     * 주문 항목 소계를 계산한다 (snapshotUnitPrice x quantity).
-     *
-     * @return 소계 금액
+     * 주문 항목 소계를 계산한다.
+     * finalAmount가 있으면 finalAmount를, 없으면 snapshotUnitPrice x quantity를 반환한다.
      */
     public BigDecimal getSubtotal() {
+        if (finalAmount != null) {
+            return finalAmount;
+        }
         return snapshotUnitPrice.multiply(BigDecimal.valueOf(quantity));
     }
 
diff --git a/apps/commerce-api/src/main/java/com/loopers/domain/order/OrderItemRepository.java b/apps/commerce-api/src/main/java/com/loopers/domain/order/OrderItemRepository.java
index 69060279d..3970d6c17 100644
--- a/apps/commerce-api/src/main/java/com/loopers/domain/order/OrderItemRepository.java
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/order/OrderItemRepository.java
@@ -33,7 +33,7 @@ public interface OrderItemRepository {
      * @param orderId 주문 ID
      * @return 해당 주문의 주문 항목 목록
      */
-    List<OrderItemModel> findAllByOrderId(String orderId);
+    List<OrderItemModel> findAllByOrderId(Long orderId);
 
     /**
      * 여러 주문 ID에 해당하는 주문 항목을 일괄 조회한다.
@@ -41,5 +41,5 @@ public interface OrderItemRepository {
      * @param orderIds 주문 ID 목록
      * @return 해당 주문들의 주문 항목 목록
      */
-    List<OrderItemModel> findAllByOrderIds(List<String> orderIds);
+    List<OrderItemModel> findAllByOrderIds(List<Long> orderIds);
 }
diff --git a/apps/commerce-api/src/main/java/com/loopers/domain/order/OrderItemSnapshot.java b/apps/commerce-api/src/main/java/com/loopers/domain/order/OrderItemSnapshot.java
index 62b72e76d..0780927bb 100644
--- a/apps/commerce-api/src/main/java/com/loopers/domain/order/OrderItemSnapshot.java
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/order/OrderItemSnapshot.java
@@ -12,39 +12,62 @@
  * 도메인 서비스(OrderService)에 전달하여 주문 항목을 저장하는 데 사용한다.
  * </p>
  *
- * @param productId   상품 ID
- * @param quantity    주문 수량
- * @param productName 상품명
- * @param unitPrice   단가
- * @param brandId     브랜드 ID
- * @param brandName   브랜드명
- * @param imageUrl    이미지 URL
+ * @param productId      상품 ID
+ * @param quantity       주문 수량
+ * @param productName    상품명
+ * @param unitPrice      단가
+ * @param brandId        브랜드 ID
+ * @param brandName      브랜드명
+ * @param imageUrl       이미지 URL
+ * @param originalAmount 할인 전 금액 (unitPrice * quantity)
+ * @param discountAmount 이 항목에 비례 배분된 할인 금액
+ * @param finalAmount    최종 금액 (originalAmount - discountAmount)
  */
-public record OrderItemSnapshot(String productId, int quantity, String productName,
+public record OrderItemSnapshot(Long productId, int quantity, String productName,
                                  BigDecimal unitPrice, String brandId,
-                                 String brandName, String imageUrl) {
+                                 String brandName, String imageUrl,
+                                 BigDecimal originalAmount,
+                                 BigDecimal discountAmount,
+                                 BigDecimal finalAmount) {
 
     /**
-     * ProductModel과 BrandModel로부터 주문 항목 스냅샷을 생성한다.
-     *
-     * @param product  상품 도메인 모델
-     * @param brand    브랜드 도메인 모델
-     * @param quantity 주문 수량
-     * @return 주문 항목 스냅샷
+     * 할인 없이 ProductModel과 BrandModel로부터 주문 항목 스냅샷을 생성한다.
      */
     public static OrderItemSnapshot from(ProductModel product, BrandModel brand, int quantity) {
+        BigDecimal lineTotal = product.getPrice().multiply(BigDecimal.valueOf(quantity));
+        return new OrderItemSnapshot(
+                product.getProductId(), quantity,
+                product.getProductName(), product.getPrice(),
+                String.valueOf(brand.getBrandId()), brand.getBrandName(), product.getImageUrl(),
+                lineTotal, BigDecimal.ZERO, lineTotal);
+    }
+
+    /**
+     * 할인 금액을 적용하여 주문 항목 스냅샷을 생성한다.
+     *
+     * @param product        상품 도메인 모델
+     * @param brand          브랜드 도메인 모델
+     * @param quantity       주문 수량
+     * @param discountAmount 이 항목에 배분된 할인 금액
+     * @return 할인이 적용된 주문 항목 스냅샷
+     */
+    public static OrderItemSnapshot from(ProductModel product, BrandModel brand, int quantity,
+                                          BigDecimal discountAmount) {
+        BigDecimal originalAmount = product.getPrice().multiply(BigDecimal.valueOf(quantity));
+        BigDecimal finalAmount = originalAmount.subtract(discountAmount);
         return new OrderItemSnapshot(
                 product.getProductId(), quantity,
                 product.getProductName(), product.getPrice(),
-                brand.getBrandId(), brand.getBrandName(), product.getImageUrl());
+                String.valueOf(brand.getBrandId()), brand.getBrandName(), product.getImageUrl(),
+                originalAmount, discountAmount, finalAmount);
     }
 
     /**
-     * 항목별 주문 금액(단가 x 수량)을 계산한다.
+     * 항목별 최종 주문 금액을 반환한다.
      *
-     * @return 항목 금액
+     * @return finalAmount
      */
     public BigDecimal lineTotal() {
-        return unitPrice.multiply(BigDecimal.valueOf(quantity));
+        return finalAmount;
     }
 }
diff --git a/apps/commerce-api/src/main/java/com/loopers/domain/order/OrderModel.java b/apps/commerce-api/src/main/java/com/loopers/domain/order/OrderModel.java
index 3f6630ea7..f98689a22 100644
--- a/apps/commerce-api/src/main/java/com/loopers/domain/order/OrderModel.java
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/order/OrderModel.java
@@ -9,12 +9,13 @@
 import jakarta.persistence.Entity;
 import jakarta.persistence.EnumType;
 import jakarta.persistence.Enumerated;
+import jakarta.persistence.GeneratedValue;
+import jakarta.persistence.GenerationType;
 import jakarta.persistence.Id;
 import jakarta.persistence.Table;
 import lombok.AccessLevel;
 import lombok.Getter;
 import lombok.NoArgsConstructor;
-import org.hibernate.annotations.UuidGenerator;
 
 import java.math.BigDecimal;
 import java.time.LocalDateTime;
@@ -38,12 +39,12 @@ public class OrderModel extends BaseStringIdEntity {
     private static final int EXPIRES_MINUTES = 15;
 
     @Id
-    @UuidGenerator
-    @Column(name = "order_id", length = 36)
-    private String orderId;
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    @Column(name = "order_id")
+    private Long orderId;
 
-    @Column(name = "user_id", nullable = false, length = 36)
-    private String userId;
+    @Column(name = "user_id", nullable = false)
+    private Long userId;
 
     @Enumerated(EnumType.STRING)
     @Column(name = "order_type", nullable = false, length = 20)
@@ -62,7 +63,7 @@ public class OrderModel extends BaseStringIdEntity {
     @Column(name = "paid_at")
     private LocalDateTime paidAt;
 
-    private OrderModel(String userId, OrderType orderType, BigDecimal totalAmount) {
+    private OrderModel(Long userId, OrderType orderType, BigDecimal totalAmount) {
         validateUserId(userId);
         this.userId = userId;
         this.orderType = orderType;
@@ -81,7 +82,7 @@ private OrderModel(String userId, OrderType orderType, BigDecimal totalAmount) {
      * @return 생성된 OrderModel 인스턴스
      * @throws CoreException userId가 null/blank인 경우 (BAD_REQUEST)
      */
-    public static OrderModel create(String userId, OrderType orderType, BigDecimal totalAmount) {
+    public static OrderModel create(Long userId, OrderType orderType, BigDecimal totalAmount) {
         return new OrderModel(userId, orderType, totalAmount);
     }
 
@@ -143,8 +144,8 @@ protected void guard() {
         validateUserId(this.userId);
     }
 
-    private static void validateUserId(String userId) {
-        if (userId == null || userId.isBlank()) {
+    private static void validateUserId(Long userId) {
+        if (userId == null) {
             throw new CoreException(ErrorType.BAD_REQUEST, "사용자 ID는 필수입니다.");
         }
     }
diff --git a/apps/commerce-api/src/main/java/com/loopers/domain/order/OrderRepository.java b/apps/commerce-api/src/main/java/com/loopers/domain/order/OrderRepository.java
index 651510a24..1bce6204b 100644
--- a/apps/commerce-api/src/main/java/com/loopers/domain/order/OrderRepository.java
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/order/OrderRepository.java
@@ -30,7 +30,7 @@ public interface OrderRepository {
      * @param orderId 주문 ID
      * @return 주문 엔티티 (존재하지 않으면 빈 Optional)
      */
-    Optional<OrderModel> findById(String orderId);
+    Optional<OrderModel> findById(Long orderId);
 
     /**
      * 주문 ID와 사용자 ID로 주문을 조회한다.
@@ -39,7 +39,7 @@ public interface OrderRepository {
      * @param userId  사용자 ID
      * @return 주문 엔티티 (존재하지 않으면 빈 Optional)
      */
-    Optional<OrderModel> findByIdAndUserId(String orderId, String userId);
+    Optional<OrderModel> findByIdAndUserId(Long orderId, Long userId);
 
     /**
      * 특정 사용자의 기간별 주문 목록을 조회한다.
@@ -49,7 +49,7 @@ public interface OrderRepository {
      * @param end    조회 종료 일시
      * @return 해당 기간의 주문 목록
      */
-    List<OrderModel> findAllByUserIdAndPeriod(String userId, LocalDateTime start, LocalDateTime end);
+    List<OrderModel> findAllByUserIdAndPeriod(Long userId, LocalDateTime start, LocalDateTime end);
 
     /**
      * 기간별 전체 주문 목록을 조회한다 (관리자용).
@@ -73,7 +73,7 @@ public interface OrderRepository {
      * @param to      변경 후 상태
      * @return 영향받은 행 수 (0이면 상태 변경 실패 -- 이미 다른 상태로 전이됨)
      */
-    int casUpdateStatus(String orderId, OrderStatus from, OrderStatus to);
+    int casUpdateStatus(Long orderId, OrderStatus from, OrderStatus to);
 
     /**
      * 특정 사용자의 특정 상태 주문 건수를 조회한다.
@@ -82,7 +82,7 @@ public interface OrderRepository {
      * @param status 주문 상태
      * @return 해당 상태의 주문 건수
      */
-    long countByUserIdAndStatus(String userId, OrderStatus status);
+    long countByUserIdAndStatus(Long userId, OrderStatus status);
 
     /**
      * 만료 시간이 지난 결제 대기(PENDING_PAYMENT) 주문 목록을 조회한다.
diff --git a/apps/commerce-api/src/main/java/com/loopers/domain/order/OrderService.java b/apps/commerce-api/src/main/java/com/loopers/domain/order/OrderService.java
index cd0709615..979fffb58 100644
--- a/apps/commerce-api/src/main/java/com/loopers/domain/order/OrderService.java
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/order/OrderService.java
@@ -48,7 +48,7 @@ public class OrderService {
      * @return 병합/정렬된 주문 항목 목록
      * @throws CoreException 주문 항목이 비어있거나, 결제 대기 주문 수 초과 시
      */
-    public List<OrderItemCommand> validateAndPrepare(String userId, List<OrderItemCommand> items) {
+    public List<OrderItemCommand> validateAndPrepare(Long userId, List<OrderItemCommand> items) {
         validateNotEmpty(items);
         validatePendingLimit(userId);
         return mergeAndSort(items);
@@ -64,7 +64,7 @@ public List<OrderItemCommand> validateAndPrepare(String userId, List<OrderItemCo
      * @return 저장된 주문 엔티티
      */
     @Transactional
-    public OrderModel createOrder(String userId, OrderType orderType,
+    public OrderModel createOrder(Long userId, OrderType orderType,
                                   BigDecimal totalAmount, List<OrderItemSnapshot> snapshots) {
         OrderModel order = OrderModel.create(userId, orderType, totalAmount);
         order = orderRepository.save(order);
@@ -86,7 +86,7 @@ public OrderModel createOrder(String userId, OrderType orderType,
      * @throws CoreException 주문이 존재하지 않거나 취소 불가한 상태일 때
      */
     @Transactional
-    public Optional<OrderModel> cancelOrder(String userId, String orderId) {
+    public Optional<OrderModel> cancelOrder(Long userId, Long orderId) {
         OrderModel order = orderRepository.findByIdAndUserId(orderId, userId)
                 .orElseThrow(() -> new CoreException(ErrorType.ORDER_NOT_FOUND));
 
@@ -114,7 +114,7 @@ public Optional<OrderModel> cancelOrder(String userId, String orderId) {
      * @return 만료된 주문 엔티티 (이미 상태 전이된 경우 빈 Optional)
      */
     @Transactional
-    public Optional<OrderModel> expireOrder(String orderId) {
+    public Optional<OrderModel> expireOrder(Long orderId) {
         int affected = orderRepository.casUpdateStatus(orderId, OrderStatus.PENDING_PAYMENT, OrderStatus.EXPIRED);
         if (affected == 0) {
             return Optional.empty();
@@ -131,7 +131,7 @@ public Optional<OrderModel> expireOrder(String orderId) {
      * @param orderId 주문 ID
      * @return 존재 여부
      */
-    public boolean existsCartRestore(String orderId) {
+    public boolean existsCartRestore(Long orderId) {
         return orderCartRestoreRepository.existsById(orderId);
     }
 
@@ -154,7 +154,7 @@ public void saveCartRestore(OrderCartRestoreModel restore) {
      *
      * @return 만료 대상 주문 ID 목록
      */
-    public List<String> findExpiredPendingOrderIds() {
+    public List<Long> findExpiredPendingOrderIds() {
         return orderRepository.findExpiredPendingOrders().stream()
                 .map(OrderModel::getOrderId)
                 .toList();
@@ -167,7 +167,7 @@ public List<String> findExpiredPendingOrderIds() {
      * @return 주문 엔티티
      * @throws CoreException 주문이 존재하지 않을 때 (ORDER_NOT_FOUND)
      */
-    public OrderModel findOrderById(String orderId) {
+    public OrderModel findOrderById(Long orderId) {
         return orderRepository.findById(orderId)
                 .orElseThrow(() -> new CoreException(ErrorType.ORDER_NOT_FOUND));
     }
@@ -191,7 +191,7 @@ public List<OrderModel> findAllOrders(LocalDateTime start, LocalDateTime end) {
      * @return 주문 엔티티
      * @throws CoreException 주문이 존재하지 않을 때 (ORDER_NOT_FOUND)
      */
-    public OrderModel findByIdAndUserId(String orderId, String userId) {
+    public OrderModel findByIdAndUserId(Long orderId, Long userId) {
         return orderRepository.findByIdAndUserId(orderId, userId)
                 .orElseThrow(() -> new CoreException(ErrorType.ORDER_NOT_FOUND));
     }
@@ -204,7 +204,7 @@ public OrderModel findByIdAndUserId(String orderId, String userId) {
      * @param end    조회 종료 일시
      * @return 주문 엔티티 목록
      */
-    public List<OrderModel> findAllByUserId(String userId, LocalDateTime start, LocalDateTime end) {
+    public List<OrderModel> findAllByUserId(Long userId, LocalDateTime start, LocalDateTime end) {
         return orderRepository.findAllByUserIdAndPeriod(userId, start, end);
     }
 
@@ -214,7 +214,7 @@ public List<OrderModel> findAllByUserId(String userId, LocalDateTime start, Loca
      * @param orderId 주문 ID
      * @return 주문 항목 엔티티 목록
      */
-    public List<OrderItemModel> findOrderItems(String orderId) {
+    public List<OrderItemModel> findOrderItems(Long orderId) {
         return orderItemRepository.findAllByOrderId(orderId);
     }
 
@@ -224,7 +224,7 @@ public List<OrderItemModel> findOrderItems(String orderId) {
      * @param orderIds 주문 ID 목록
      * @return 주문 ID를 키로, 주문 항목 목록을 값으로 하는 맵
      */
-    public Map<String, List<OrderItemModel>> findOrderItemsByOrderIds(List<String> orderIds) {
+    public Map<Long, List<OrderItemModel>> findOrderItemsByOrderIds(List<Long> orderIds) {
         if (orderIds.isEmpty()) {
             return Map.of();
         }
@@ -238,7 +238,7 @@ private void validateNotEmpty(List<OrderItemCommand> items) {
         }
     }
 
-    private void validatePendingLimit(String userId) {
+    private void validatePendingLimit(Long userId) {
         long pendingCount = orderRepository.countByUserIdAndStatus(userId, OrderStatus.PENDING_PAYMENT);
         if (pendingCount >= MAX_PENDING_ORDERS) {
             throw new CoreException(ErrorType.ORDER_PENDING_LIMIT_EXCEEDED);
@@ -246,7 +246,7 @@ private void validatePendingLimit(String userId) {
     }
 
     private List<OrderItemCommand> mergeAndSort(List<OrderItemCommand> items) {
-        Map<String, Integer> merged = items.stream()
+        Map<Long, Integer> merged = items.stream()
                 .collect(Collectors.groupingBy(OrderItemCommand::productId,
                         Collectors.summingInt(OrderItemCommand::quantity)));
         return merged.entrySet().stream()
@@ -255,7 +255,7 @@ private List<OrderItemCommand> mergeAndSort(List<OrderItemCommand> items) {
                 .toList();
     }
 
-    private List<OrderItemModel> saveOrderItems(OrderModel order, String userId,
+    private List<OrderItemModel> saveOrderItems(OrderModel order, Long userId,
                                                  List<OrderItemSnapshot> snapshots) {
         List<OrderItemModel> items = new ArrayList<>();
         int seq = 1;
@@ -264,9 +264,24 @@ private List<OrderItemModel> saveOrderItems(OrderModel order, String userId,
                     order.getOrderId(), seq++, userId,
                     snapshot.productId(), snapshot.quantity(),
                     snapshot.productName(), snapshot.unitPrice(),
-                    snapshot.brandId(), snapshot.brandName(), snapshot.imageUrl()));
+                    snapshot.brandId(), snapshot.brandName(), snapshot.imageUrl(),
+                    snapshot.originalAmount(), snapshot.discountAmount(), snapshot.finalAmount()));
         }
         return orderItemRepository.saveAll(items);
     }
 
+    /**
+     * 주문 목록을 배치 로딩으로 주문 항목을 포함하여 반환한다.
+     * N+1 쿼리 대신 단일 IN 쿼리로 주문 항목을 일괄 조회한다.
+     *
+     * @param orders 주문 엔티티 목록
+     * @return 주문 ID를 키로, 주문 항목 목록을 값으로 하는 맵이 포함된 쌍
+     */
+    public Map<Long, List<OrderItemModel>> batchLoadOrderItems(List<OrderModel> orders) {
+        if (orders.isEmpty()) {
+            return Map.of();
+        }
+        List<Long> orderIds = orders.stream().map(OrderModel::getOrderId).toList();
+        return findOrderItemsByOrderIds(orderIds);
+    }
 }
diff --git a/apps/commerce-api/src/main/java/com/loopers/domain/product/ProductModel.java b/apps/commerce-api/src/main/java/com/loopers/domain/product/ProductModel.java
index f008e6596..3842393dd 100644
--- a/apps/commerce-api/src/main/java/com/loopers/domain/product/ProductModel.java
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/product/ProductModel.java
@@ -9,12 +9,13 @@
 import jakarta.persistence.Entity;
 import jakarta.persistence.EnumType;
 import jakarta.persistence.Enumerated;
+import jakarta.persistence.GeneratedValue;
+import jakarta.persistence.GenerationType;
 import jakarta.persistence.Id;
 import jakarta.persistence.Table;
 import lombok.AccessLevel;
 import lombok.Getter;
 import lombok.NoArgsConstructor;
-import org.hibernate.annotations.UuidGenerator;
 
 import java.math.BigDecimal;
 
@@ -37,12 +38,12 @@
 public class ProductModel extends BaseStringIdEntity {
 
     @Id
-    @UuidGenerator
-    @Column(name = "product_id", length = 36)
-    private String productId;
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    @Column(name = "product_id")
+    private Long productId;
 
-    @Column(name = "brand_id", nullable = false, length = 36)
-    private String brandId;
+    @Column(name = "brand_id", nullable = false)
+    private Long brandId;
 
     @Column(name = "product_name", nullable = false)
     private String productName;
@@ -82,7 +83,10 @@ public class ProductModel extends BaseStringIdEntity {
     @Column(name = "revision_seq", nullable = false)
     private Long revisionSeq;
 
-    private ProductModel(String productName, String brandId, BigDecimal price,
+    @Column(name = "like_count", nullable = false)
+    private long likeCount = 0;
+
+    private ProductModel(String productName, Long brandId, BigDecimal price,
                          String description, String category, String color,
                          String size, String option, String imageUrl, String attachFile) {
         validateProductName(productName);
@@ -120,7 +124,7 @@ private ProductModel(String productName, String brandId, BigDecimal price,
      * @return 생성된 ProductModel 인스턴스
      * @throws CoreException productName/brandId null 또는 price <= 0인 경우 (BAD_REQUEST)
      */
-    public static ProductModel create(String productName, String brandId, BigDecimal price,
+    public static ProductModel create(String productName, Long brandId, BigDecimal price,
                                        String description, String category, String color,
                                        String size, String option, String imageUrl, String attachFile) {
         return new ProductModel(productName, brandId, price, description, category, color,
@@ -213,8 +217,8 @@ private static void validateProductName(String productName) {
         }
     }
 
-    private static void validateBrandId(String brandId) {
-        if (brandId == null || brandId.isBlank()) {
+    private static void validateBrandId(Long brandId) {
+        if (brandId == null) {
             throw new CoreException(ErrorType.BAD_REQUEST, "브랜드 ID는 필수입니다.");
         }
     }
diff --git a/apps/commerce-api/src/main/java/com/loopers/domain/product/ProductRepository.java b/apps/commerce-api/src/main/java/com/loopers/domain/product/ProductRepository.java
index 772228782..95799a6a0 100644
--- a/apps/commerce-api/src/main/java/com/loopers/domain/product/ProductRepository.java
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/product/ProductRepository.java
@@ -1,7 +1,7 @@
 package com.loopers.domain.product;
 
-import org.springframework.data.domain.Page;
-import org.springframework.data.domain.Pageable;
+import com.loopers.support.page.PageQuery;
+import com.loopers.support.page.PagedResult;
 
 import java.util.Collection;
 import java.util.List;
@@ -30,7 +30,16 @@ public interface ProductRepository {
      * @param productId 상품 ID
      * @return 상품 엔티티 (존재하지 않으면 빈 Optional)
      */
-    Optional<ProductModel> findById(String productId);
+    Optional<ProductModel> findById(Long productId);
+
+    /**
+     * 비관적 쓰기 락(SELECT FOR UPDATE)으로 상품을 조회한다.
+     * 동일 상품에 대한 좋아요 연산 직렬화를 위해 사용된다.
+     *
+     * @param productId 상품 ID
+     * @return 상품 엔티티 (존재하지 않으면 빈 Optional)
+     */
+    Optional<ProductModel> findByIdWithLock(Long productId);
 
     /**
      * 전체 상품을 조회한다 (삭제된 상품 포함).
@@ -54,7 +63,7 @@ public interface ProductRepository {
      * @param brandId 브랜드 ID 필터 (null이면 전체)
      * @return 고객 노출 조건을 만족하는 상품 목록
      */
-    List<ProductModel> findAllForCustomer(String keyword, String brandId);
+    List<ProductModel> findAllForCustomer(String keyword, Long brandId);
 
     /**
      * 특정 브랜드에 소속된 상품 목록을 조회한다.
@@ -62,7 +71,7 @@ public interface ProductRepository {
      * @param brandId 브랜드 ID
      * @return 해당 브랜드 소속 상품 목록
      */
-    List<ProductModel> findAllByBrandId(String brandId);
+    List<ProductModel> findAllByBrandId(Long brandId);
 
     /**
      * 상품 ID 목록으로 상품을 일괄 조회한다.
@@ -70,15 +79,29 @@ public interface ProductRepository {
      * @param productIds 상품 ID 목록
      * @return 해당 상품 목록
      */
-    List<ProductModel> findAllByProductIds(Collection<String> productIds);
+    List<ProductModel> findAllByProductIds(Collection<Long> productIds);
 
     /**
      * 고객용 상품 목록을 페이징하여 조회한다.
      *
-     * @param keyword  검색 키워드 (null이면 전체)
-     * @param brandId  브랜드 ID 필터 (null이면 전체)
-     * @param pageable 페이징/정렬 정보
+     * @param keyword 검색 키워드 (null이면 전체)
+     * @param brandId 브랜드 ID 필터 (null이면 전체)
+     * @param query   페이징/정렬 요청 정보
      * @return 페이징된 상품 목록
      */
-    Page<ProductModel> findAllForCustomer(String keyword, String brandId, Pageable pageable);
+    PagedResult<ProductModel> findAllForCustomer(String keyword, Long brandId, PageQuery query);
+
+    /**
+     * 상품의 좋아요 수를 1 증가시킨다.
+     *
+     * @param productId 상품 ID
+     */
+    void incrementLikeCount(Long productId);
+
+    /**
+     * 상품의 좋아요 수를 1 감소시킨다 (최솟값 0 보장).
+     *
+     * @param productId 상품 ID
+     */
+    void decrementLikeCount(Long productId);
 }
diff --git a/apps/commerce-api/src/main/java/com/loopers/domain/product/ProductRevisionId.java b/apps/commerce-api/src/main/java/com/loopers/domain/product/ProductRevisionId.java
index b05bfb57f..0a76f733a 100644
--- a/apps/commerce-api/src/main/java/com/loopers/domain/product/ProductRevisionId.java
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/product/ProductRevisionId.java
@@ -20,6 +20,6 @@
 @AllArgsConstructor
 @EqualsAndHashCode
 public class ProductRevisionId implements Serializable {
-    private String productId;
+    private Long productId;
     private Long revisionSeq;
 }
diff --git a/apps/commerce-api/src/main/java/com/loopers/domain/product/ProductRevisionModel.java b/apps/commerce-api/src/main/java/com/loopers/domain/product/ProductRevisionModel.java
index 9a5a769fd..360ee0702 100644
--- a/apps/commerce-api/src/main/java/com/loopers/domain/product/ProductRevisionModel.java
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/product/ProductRevisionModel.java
@@ -31,8 +31,8 @@
 public class ProductRevisionModel {
 
     @Id
-    @Column(name = "product_id", length = 36)
-    private String productId;
+    @Column(name = "product_id")
+    private Long productId;
 
     @Id
     @Column(name = "revision_seq")
@@ -57,7 +57,7 @@ public class ProductRevisionModel {
     @Column(name = "created_at", nullable = false, updatable = false)
     private LocalDateTime createdAt;
 
-    private ProductRevisionModel(String productId, Long revisionSeq, ProductRevisionAction action,
+    private ProductRevisionModel(Long productId, Long revisionSeq, ProductRevisionAction action,
                                   String changedBy, String changeReason,
                                   String beforeSnapshot, String afterSnapshot) {
         this.productId = productId;
@@ -82,7 +82,7 @@ private ProductRevisionModel(String productId, Long revisionSeq, ProductRevision
      * @param afterSnapshot  변경 후 상품 상태 JSON (DELETE 시 null)
      * @return 생성된 ProductRevisionModel 인스턴스
      */
-    public static ProductRevisionModel create(String productId, Long revisionSeq,
+    public static ProductRevisionModel create(Long productId, Long revisionSeq,
                                                ProductRevisionAction action,
                                                String changedBy, String changeReason,
                                                String beforeSnapshot, String afterSnapshot) {
diff --git a/apps/commerce-api/src/main/java/com/loopers/domain/product/ProductRevisionRepository.java b/apps/commerce-api/src/main/java/com/loopers/domain/product/ProductRevisionRepository.java
index 9d7ed5b00..ab49ef739 100644
--- a/apps/commerce-api/src/main/java/com/loopers/domain/product/ProductRevisionRepository.java
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/product/ProductRevisionRepository.java
@@ -26,7 +26,7 @@ public interface ProductRevisionRepository {
      * @param productId 상품 ID
      * @return 해당 상품의 변경 이력 목록
      */
-    List<ProductRevisionModel> findAllByProductId(String productId);
+    List<ProductRevisionModel> findAllByProductId(Long productId);
 
     /**
      * 복합 PK(productId + revisionSeq)로 변경 이력을 조회한다.
diff --git a/apps/commerce-api/src/main/java/com/loopers/domain/product/ProductService.java b/apps/commerce-api/src/main/java/com/loopers/domain/product/ProductService.java
index 000979516..4094ce743 100644
--- a/apps/commerce-api/src/main/java/com/loopers/domain/product/ProductService.java
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/product/ProductService.java
@@ -4,9 +4,11 @@
 import com.loopers.support.enums.ProductSaleStatus;
 import com.loopers.support.error.CoreException;
 import com.loopers.support.error.ErrorType;
+import com.loopers.support.page.PageQuery;
+import com.loopers.support.page.PagedResult;
 import lombok.RequiredArgsConstructor;
-import org.springframework.data.domain.Page;
-import org.springframework.data.domain.Pageable;
+import org.springframework.cache.annotation.CacheEvict;
+import org.springframework.cache.annotation.Cacheable;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
@@ -29,6 +31,7 @@ public class ProductService {
 
     private final ProductRepository productRepository;
     private final ProductRevisionRepository revisionRepository;
+    private final org.springframework.cache.CacheManager cacheManager;
 
     /**
      * 상품을 생성한다.
@@ -44,7 +47,7 @@ public class ProductService {
      * @return 생성된 상품 엔티티
      */
     @Transactional
-    public ProductModel createProduct(String productName, String brandId, BigDecimal price,
+    public ProductModel createProduct(String productName, Long brandId, BigDecimal price,
                                      String description) {
         ProductModel product = ProductModel.create(productName, brandId, price,
                 description, null, null, null, null, null, null);
@@ -65,11 +68,26 @@ public ProductModel createProduct(String productName, String brandId, BigDecimal
      * @return 상품 엔티티
      * @throws CoreException 상품이 존재하지 않을 때 (PRODUCT_NOT_FOUND)
      */
-    public ProductModel findById(String productId) {
+    @Cacheable(cacheNames = "productDetail", key = "#productId")
+    public ProductModel findById(Long productId) {
         return productRepository.findById(productId)
                 .orElseThrow(() -> new CoreException(ErrorType.PRODUCT_NOT_FOUND));
     }
 
+    /**
+     * 비관적 쓰기 락으로 상품을 조회한다.
+     * 동일 상품에 대한 좋아요 연산 직렬화를 위해 사용된다.
+     *
+     * @param productId 상품 ID
+     * @return 상품 엔티티
+     * @throws CoreException 상품이 존재하지 않을 때 (PRODUCT_NOT_FOUND)
+     */
+    @Transactional
+    public ProductModel findByIdWithLock(Long productId) {
+        return productRepository.findByIdWithLock(productId)
+                .orElseThrow(() -> new CoreException(ErrorType.PRODUCT_NOT_FOUND));
+    }
+
     /**
      * 주문 가능한 상품을 조회한다.
      * <p>
@@ -86,11 +104,11 @@ public ProductModel findById(String productId) {
      * @param productIds 상품 ID 목록
      * @return 상품 엔티티 목록
      */
-    public List<ProductModel> findAllByIds(Collection<String> productIds) {
+    public List<ProductModel> findAllByIds(Collection<Long> productIds) {
         return productRepository.findAllByProductIds(productIds);
     }
 
-    public ProductModel findOrderableById(String productId) {
+    public ProductModel findOrderableById(Long productId) {
         ProductModel product = findById(productId);
         if (!product.isOrderable()) {
             throw new CoreException(ErrorType.PRODUCT_NOT_ORDERABLE);
@@ -118,20 +136,20 @@ public List<ProductModel> findAllForAdmin(boolean includeDeleted) {
      * @param brandId 브랜드 ID 필터 (null이면 전체)
      * @return 고객 노출 조건을 만족하는 상품 목록
      */
-    public List<ProductModel> findAllForCustomer(String keyword, String brandId) {
+    public List<ProductModel> findAllForCustomer(String keyword, Long brandId) {
         return productRepository.findAllForCustomer(keyword, brandId);
     }
 
     /**
      * 고객용 상품 목록을 페이징하여 조회한다.
      *
-     * @param keyword  검색 키워드 (null이면 전체)
-     * @param brandId  브랜드 ID 필터 (null이면 전체)
-     * @param pageable 페이징/정렬 정보
+     * @param keyword 검색 키워드 (null이면 전체)
+     * @param brandId 브랜드 ID 필터 (null이면 전체)
+     * @param query   페이징/정렬 요청 정보
      * @return 페이징된 상품 목록
      */
-    public Page<ProductModel> findAllForCustomer(String keyword, String brandId, Pageable pageable) {
-        return productRepository.findAllForCustomer(keyword, brandId, pageable);
+    public PagedResult<ProductModel> findAllForCustomer(String keyword, Long brandId, PageQuery query) {
+        return productRepository.findAllForCustomer(keyword, brandId, query);
     }
 
     /**
@@ -149,8 +167,9 @@ public Page<ProductModel> findAllForCustomer(String keyword, String brandId, Pag
      * @return 수정된 상품 엔티티
      * @throws CoreException 상품이 존재하지 않을 때 (PRODUCT_NOT_FOUND)
      */
+    @CacheEvict(cacheNames = "productDetail", key = "#productId")
     @Transactional
-    public ProductModel updateProduct(String productId, String productName, BigDecimal price,
+    public ProductModel updateProduct(Long productId, String productName, BigDecimal price,
                                      String description, String imageUrl) {
         ProductModel product = findById(productId);
 
@@ -176,8 +195,9 @@ public ProductModel updateProduct(String productId, String productName, BigDecim
      * @param productId 상품 ID
      * @throws CoreException 상품이 존재하지 않을 때 (PRODUCT_NOT_FOUND)
      */
+    @CacheEvict(cacheNames = "productDetail", key = "#productId")
     @Transactional
-    public void deleteProduct(String productId) {
+    public void deleteProduct(Long productId) {
         ProductModel product = findById(productId);
         if (product.isDeleted()) {
             return;
@@ -201,8 +221,9 @@ public void deleteProduct(String productId) {
      * @param brandId 브랜드 ID
      */
     @Transactional
-    public void softDeleteByBrandId(String brandId) {
+    public void softDeleteByBrandId(Long brandId) {
         List<ProductModel> products = productRepository.findAllByBrandId(brandId);
+        org.springframework.cache.Cache cache = cacheManager.getCache("productDetail");
         for (ProductModel product : products) {
             if (!product.isDeleted()) {
                 String beforeSnapshot = toSnapshot(product);
@@ -213,6 +234,10 @@ public void softDeleteByBrandId(String brandId) {
                         product.getProductId(), revSeq, ProductRevisionAction.DELETE,
                         null, null, beforeSnapshot, null);
                 revisionRepository.save(revision);
+
+                if (cache != null) {
+                    cache.evict(product.getProductId());
+                }
             }
         }
     }
@@ -227,8 +252,9 @@ public void softDeleteByBrandId(String brandId) {
      * @param newStatus 새 판매 상태
      * @throws CoreException 상품이 존재하지 않을 때 (PRODUCT_NOT_FOUND)
      */
+    @CacheEvict(cacheNames = "productDetail", key = "#productId")
     @Transactional
-    public void changeSaleStatus(String productId, ProductSaleStatus newStatus) {
+    public void changeSaleStatus(Long productId, ProductSaleStatus newStatus) {
         ProductModel product = findById(productId);
         String beforeSnapshot = toSnapshot(product);
         product.changeSaleStatus(newStatus);
@@ -247,7 +273,7 @@ public void changeSaleStatus(String productId, ProductSaleStatus newStatus) {
      * @param productId 상품 ID
      * @return 변경 이력 목록
      */
-    public List<ProductRevisionModel> findRevisionsByProductId(String productId) {
+    public List<ProductRevisionModel> findRevisionsByProductId(Long productId) {
         return revisionRepository.findAllByProductId(productId);
     }
 
@@ -259,11 +285,33 @@ public List<ProductRevisionModel> findRevisionsByProductId(String productId) {
      * @return 변경 이력 엔티티
      * @throws CoreException 변경 이력이 존재하지 않을 때 (PRODUCT_NOT_FOUND)
      */
-    public ProductRevisionModel findRevisionById(String productId, Long revisionSeq) {
+    public ProductRevisionModel findRevisionById(Long productId, Long revisionSeq) {
         return revisionRepository.findById(new ProductRevisionId(productId, revisionSeq))
                 .orElseThrow(() -> new CoreException(ErrorType.PRODUCT_NOT_FOUND));
     }
 
+    /**
+     * 상품의 좋아요 수를 1 증가시킨다.
+     *
+     * @param productId 상품 ID
+     */
+    @CacheEvict(cacheNames = "productDetail", key = "#productId")
+    @Transactional
+    public void incrementLikeCount(Long productId) {
+        productRepository.incrementLikeCount(productId);
+    }
+
+    /**
+     * 상품의 좋아요 수를 1 감소시킨다 (최솟값 0 보장).
+     *
+     * @param productId 상품 ID
+     */
+    @CacheEvict(cacheNames = "productDetail", key = "#productId")
+    @Transactional
+    public void decrementLikeCount(Long productId) {
+        productRepository.decrementLikeCount(productId);
+    }
+
     private String toSnapshot(ProductModel product) {
         return "{\"productName\":\"" + product.getProductName()
                 + "\",\"price\":" + product.getPrice()
diff --git a/apps/commerce-api/src/main/java/com/loopers/domain/product/ProductStockModel.java b/apps/commerce-api/src/main/java/com/loopers/domain/product/ProductStockModel.java
index 63b7d978e..6c3c293f1 100644
--- a/apps/commerce-api/src/main/java/com/loopers/domain/product/ProductStockModel.java
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/product/ProductStockModel.java
@@ -32,8 +32,8 @@
 public class ProductStockModel {
 
     @Id
-    @Column(name = "product_id", length = 36)
-    private String productId;
+    @Column(name = "product_id")
+    private Long productId;
 
     @Column(name = "on_hand", nullable = false)
     private int onHand;
@@ -47,7 +47,7 @@ public class ProductStockModel {
     @Column(name = "updated_at", nullable = false)
     private LocalDateTime updatedAt;
 
-    private ProductStockModel(String productId, int onHand, int reserved) {
+    private ProductStockModel(Long productId, int onHand, int reserved) {
         if (onHand < 0) {
             throw new CoreException(ErrorType.INVALID_STOCK_UPDATE, "총 재고는 음수일 수 없습니다.");
         }
@@ -65,7 +65,7 @@ private ProductStockModel(String productId, int onHand, int reserved) {
      * @return 생성된 ProductStockModel 인스턴스
      * @throws CoreException onHand < 0인 경우 (INVALID_STOCK_UPDATE)
      */
-    public static ProductStockModel create(String productId, int onHand) {
+    public static ProductStockModel create(Long productId, int onHand) {
         return new ProductStockModel(productId, onHand, 0);
     }
 
@@ -78,7 +78,7 @@ public static ProductStockModel create(String productId, int onHand) {
      * @param reserved  예약 재고 수량
      * @return 생성된 ProductStockModel 인스턴스
      */
-    public static ProductStockModel createWithReserved(String productId, int onHand, int reserved) {
+    public static ProductStockModel createWithReserved(Long productId, int onHand, int reserved) {
         return new ProductStockModel(productId, onHand, reserved);
     }
 
@@ -105,6 +105,18 @@ public boolean canHold(int qty) {
         return getAvailableQty() >= qty;
     }
 
+    /**
+     * 요청 수량이 가용 재고를 초과하면 예외를 던진다.
+     *
+     * @param qty 요청 수량
+     * @throws CoreException 가용 재고보다 요청 수량이 많을 때 (CART_STOCK_EXCEEDED)
+     */
+    public void validateCanHold(int qty) {
+        if (!canHold(qty)) {
+            throw new CoreException(ErrorType.CART_STOCK_EXCEEDED);
+        }
+    }
+
     /**
      * 관리자가 총 재고(onHand)를 수정한다. 예약 재고보다 작게 설정하면 예외 발생.
      *
diff --git a/apps/commerce-api/src/main/java/com/loopers/domain/product/ProductStockRepository.java b/apps/commerce-api/src/main/java/com/loopers/domain/product/ProductStockRepository.java
index 5dc402cdd..86879b9e7 100644
--- a/apps/commerce-api/src/main/java/com/loopers/domain/product/ProductStockRepository.java
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/product/ProductStockRepository.java
@@ -29,7 +29,7 @@ public interface ProductStockRepository {
      * @param productId 상품 ID
      * @return 재고 엔티티 (존재하지 않으면 빈 Optional)
      */
-    Optional<ProductStockModel> findByProductId(String productId);
+    Optional<ProductStockModel> findByProductId(Long productId);
 
     /**
      * CAS(Compare-And-Set) 방식으로 재고를 예약(hold)한다.
@@ -42,7 +42,7 @@ public interface ProductStockRepository {
      * @param qty       예약할 수량
      * @return 영향받은 행 수 (0이면 가용 재고 부족으로 예약 실패)
      */
-    int reserveStock(String productId, int qty);
+    int reserveStock(Long productId, int qty);
 
     /**
      * CAS(Compare-And-Set) 방식으로 예약된 재고를 해제(release)한다.
@@ -56,7 +56,7 @@ public interface ProductStockRepository {
      * @param qty       해제할 수량
      * @return 영향받은 행 수 (0이면 예약 재고 부족으로 해제 실패)
      */
-    int releaseStock(String productId, int qty);
+    int releaseStock(Long productId, int qty);
 
     /**
      * CAS(Compare-And-Set) 방식으로 예약된 재고를 확정(commit)한다.
@@ -69,7 +69,7 @@ public interface ProductStockRepository {
      * @param qty       확정할 수량
      * @return 영향받은 행 수 (0이면 확정 실패)
      */
-    int commitStock(String productId, int qty);
+    int commitStock(Long productId, int qty);
 
     /**
      * 상품 ID 목록으로 재고를 일괄 조회한다.
@@ -77,5 +77,5 @@ public interface ProductStockRepository {
      * @param productIds 상품 ID 목록
      * @return 해당 상품들의 재고 목록
      */
-    List<ProductStockModel> findAllByProductIds(Collection<String> productIds);
+    List<ProductStockModel> findAllByProductIds(Collection<Long> productIds);
 }
diff --git a/apps/commerce-api/src/main/java/com/loopers/domain/product/StockService.java b/apps/commerce-api/src/main/java/com/loopers/domain/product/StockService.java
index 14a7ee59e..c3912ff8d 100644
--- a/apps/commerce-api/src/main/java/com/loopers/domain/product/StockService.java
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/product/StockService.java
@@ -32,7 +32,7 @@ public class StockService {
      * @return 생성된 재고 엔티티
      */
     @Transactional
-    public ProductStockModel createStock(String productId, int onHand) {
+    public ProductStockModel createStock(Long productId, int onHand) {
         ProductStockModel stock = ProductStockModel.create(productId, onHand);
         return productStockRepository.save(stock);
     }
@@ -50,11 +50,11 @@ public ProductStockModel createStock(String productId, int onHand) {
      * @param productIds 상품 ID 목록
      * @return 재고 엔티티 목록
      */
-    public List<ProductStockModel> findAllByProductIds(Collection<String> productIds) {
+    public List<ProductStockModel> findAllByProductIds(Collection<Long> productIds) {
         return productStockRepository.findAllByProductIds(productIds);
     }
 
-    public ProductStockModel findByProductId(String productId) {
+    public ProductStockModel findByProductId(Long productId) {
         return productStockRepository.findByProductId(productId)
                 .orElseThrow(() -> new CoreException(ErrorType.PRODUCT_NOT_FOUND));
     }
@@ -72,7 +72,7 @@ public ProductStockModel findByProductId(String productId) {
      * @throws CoreException 가용 재고 부족 시 (STOCK_NOT_ENOUGH)
      */
     @Transactional
-    public void hold(String productId, int qty) {
+    public void hold(Long productId, int qty) {
         int affected = productStockRepository.reserveStock(productId, qty);
         if (affected == 0) {
             throw new CoreException(ErrorType.STOCK_NOT_ENOUGH);
@@ -92,7 +92,7 @@ public void hold(String productId, int qty) {
      * @throws CoreException 예약 재고 부족 시 (STOCK_NOT_ENOUGH)
      */
     @Transactional
-    public void release(String productId, int qty) {
+    public void release(Long productId, int qty) {
         int affected = productStockRepository.releaseStock(productId, qty);
         if (affected == 0) {
             throw new CoreException(ErrorType.STOCK_NOT_ENOUGH);
@@ -111,7 +111,7 @@ public void release(String productId, int qty) {
      * @throws CoreException 확정 실패 시 (STOCK_NOT_ENOUGH)
      */
     @Transactional
-    public void commit(String productId, int qty) {
+    public void commit(Long productId, int qty) {
         int affected = productStockRepository.commitStock(productId, qty);
         if (affected == 0) {
             throw new CoreException(ErrorType.STOCK_NOT_ENOUGH);
diff --git a/apps/commerce-api/src/main/java/com/loopers/domain/stats/StatsProjection.java b/apps/commerce-api/src/main/java/com/loopers/domain/stats/StatsProjection.java
index 8c9141a65..4838efc1a 100644
--- a/apps/commerce-api/src/main/java/com/loopers/domain/stats/StatsProjection.java
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/stats/StatsProjection.java
@@ -9,7 +9,7 @@
 
 /**
  * 운영 통계 도메인 프로젝션 DTO 모음.
- * 도메인/인프라 레이어에서 사용되며, application 레이어의 {@link com.loopers.application.stats.StatsInfo}로 변환된다.
+ * 도메인/인프라 레이어에서 사용되며, Controller에서 API 응답 DTO로 변환된다.
  */
 public class StatsProjection {
 
@@ -44,7 +44,7 @@ public static class DailyOrderStat {
     @Builder
     @AllArgsConstructor
     public static class ProductStat {
-        private final String productId;
+        private final Long productId;
         private final String productName;
         private final long count;
     }
@@ -56,7 +56,7 @@ public static class ProductStat {
     @Builder
     @AllArgsConstructor
     public static class LowStockProduct {
-        private final String productId;
+        private final Long productId;
         private final String productName;
         private final int onHand;
         private final int reserved;
diff --git a/apps/commerce-api/src/main/java/com/loopers/domain/stats/StatsService.java b/apps/commerce-api/src/main/java/com/loopers/domain/stats/StatsService.java
index a758d3aec..c7f08a2d8 100644
--- a/apps/commerce-api/src/main/java/com/loopers/domain/stats/StatsService.java
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/stats/StatsService.java
@@ -1,6 +1,7 @@
 package com.loopers.domain.stats;
 
 import lombok.RequiredArgsConstructor;
+import org.springframework.cache.annotation.Cacheable;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
@@ -26,6 +27,7 @@ public class StatsService {
      * @param endAt   조회 종료일
      * @return 결제 대기·취소·만료 건수를 포함하는 주문 현황 개요
      */
+    @Cacheable(cacheNames = "statsOverview", key = "#startAt.toString() + ':' + #endAt.toString()")
     public StatsProjection.Overview getOverview(LocalDate startAt, LocalDate endAt) {
         return statsRepository.getOverview(startAt, endAt);
     }
@@ -37,6 +39,7 @@ public StatsProjection.Overview getOverview(LocalDate startAt, LocalDate endAt)
      * @param endAt   조회 종료일
      * @return 일별 주문 건수 및 총 금액 목록
      */
+    @Cacheable(cacheNames = "statsDaily", key = "#startAt.toString() + ':' + #endAt.toString()")
     public List<StatsProjection.DailyOrderStat> getDailyOrderStats(LocalDate startAt, LocalDate endAt) {
         return statsRepository.getDailyOrderStats(startAt, endAt);
     }
@@ -47,6 +50,7 @@ public List<StatsProjection.DailyOrderStat> getDailyOrderStats(LocalDate startAt
      * @param limit 조회할 상위 상품 수
      * @return 좋아요 수 내림차순 상품 목록
      */
+    @Cacheable(cacheNames = "statsTopLiked", key = "#limit")
     public List<StatsProjection.ProductStat> getTopLikedProducts(int limit) {
         return statsRepository.getTopLikedProducts(limit);
     }
@@ -57,6 +61,7 @@ public List<StatsProjection.ProductStat> getTopLikedProducts(int limit) {
      * @param limit 조회할 상위 상품 수
      * @return 주문 수 내림차순 상품 목록
      */
+    @Cacheable(cacheNames = "statsTopOrdered", key = "#limit")
     public List<StatsProjection.ProductStat> getTopOrderedProducts(int limit) {
         return statsRepository.getTopOrderedProducts(limit);
     }
@@ -67,6 +72,7 @@ public List<StatsProjection.ProductStat> getTopOrderedProducts(int limit) {
      * @param threshold 재고 임계값
      * @return 저재고 상품 목록
      */
+    @Cacheable(cacheNames = "statsLowStock", key = "#threshold")
     public List<StatsProjection.LowStockProduct> getLowStockProducts(int threshold) {
         return statsRepository.getLowStockProducts(threshold);
     }
diff --git a/apps/commerce-api/src/main/java/com/loopers/domain/user/UserModel.java b/apps/commerce-api/src/main/java/com/loopers/domain/user/UserModel.java
index e44390630..fc8f40f8e 100644
--- a/apps/commerce-api/src/main/java/com/loopers/domain/user/UserModel.java
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/user/UserModel.java
@@ -5,12 +5,13 @@
 import com.loopers.support.error.ErrorType;
 import jakarta.persistence.Column;
 import jakarta.persistence.Entity;
+import jakarta.persistence.GeneratedValue;
+import jakarta.persistence.GenerationType;
 import jakarta.persistence.Id;
 import jakarta.persistence.Table;
 import lombok.AccessLevel;
 import lombok.Getter;
 import lombok.NoArgsConstructor;
-import org.hibernate.annotations.UuidGenerator;
 
 import java.util.regex.Pattern;
 
@@ -31,9 +32,9 @@ public class UserModel extends BaseStringIdEntity {
     private static final int PASSWORD_MAX_LENGTH = 16;
 
     @Id
-    @UuidGenerator
-    @Column(name = "user_id", length = 36)
-    private String userId;
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    @Column(name = "user_id")
+    private Long userId;
 
     @Column(name = "login_id", nullable = false, unique = true, length = 50)
     private String loginId;
diff --git a/apps/commerce-api/src/main/java/com/loopers/domain/user/UserRepository.java b/apps/commerce-api/src/main/java/com/loopers/domain/user/UserRepository.java
index 643ae5c89..8ccdb00f2 100644
--- a/apps/commerce-api/src/main/java/com/loopers/domain/user/UserRepository.java
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/user/UserRepository.java
@@ -22,7 +22,7 @@ public interface UserRepository {
      * @param userId 사용자 UUID
      * @return 사용자 (Optional)
      */
-    Optional<UserModel> findByUserId(String userId);
+    Optional<UserModel> findByUserId(Long userId);
 
     /**
      * 로그인 ID로 사용자를 조회한다.
diff --git a/apps/commerce-api/src/main/java/com/loopers/domain/user/UserService.java b/apps/commerce-api/src/main/java/com/loopers/domain/user/UserService.java
index fd9ab6dc9..0fce7a861 100644
--- a/apps/commerce-api/src/main/java/com/loopers/domain/user/UserService.java
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/user/UserService.java
@@ -3,6 +3,8 @@
 import com.loopers.support.error.CoreException;
 import com.loopers.support.error.ErrorType;
 import lombok.RequiredArgsConstructor;
+import org.springframework.cache.annotation.CacheEvict;
+import org.springframework.cache.annotation.Cacheable;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
@@ -47,7 +49,7 @@ public UserModel register(UserRegisterCommand command) {
      * @return 조회된 UserModel
      * @throws CoreException 사용자가 존재하지 않는 경우 (USER_NOT_FOUND)
      */
-    public UserModel findByUserId(String userId) {
+    public UserModel findByUserId(Long userId) {
         return userRepository.findByUserId(userId)
                 .orElseThrow(() -> new CoreException(ErrorType.USER_NOT_FOUND));
     }
@@ -59,6 +61,7 @@ public UserModel findByUserId(String userId) {
      * @return 조회된 UserModel
      * @throws CoreException 사용자가 존재하지 않는 경우 (USER_NOT_FOUND)
      */
+    @Cacheable(cacheNames = "authUser", key = "#loginId")
     public UserModel findByLoginId(String loginId) {
         return userRepository.findByLoginId(loginId)
                 .orElseThrow(() -> new CoreException(ErrorType.USER_NOT_FOUND));
@@ -101,6 +104,7 @@ public UserModel getMyInfo(String loginId, String loginPw) {
      * @param newPw     새 비밀번호
      * @throws CoreException 현재 비밀번호 불일치(PASSWORD_MISMATCH), 동일 비밀번호(SAME_PASSWORD), 규칙 위반(INVALID_PASSWORD)
      */
+    @CacheEvict(cacheNames = "authUser", key = "#loginId")
     @Transactional
     public void changePassword(String loginId, String currentPw, String newPw) {
         UserModel user = findByLoginId(loginId);
diff --git a/apps/commerce-api/src/main/java/com/loopers/infrastructure/brand/BrandJpaRepository.java b/apps/commerce-api/src/main/java/com/loopers/infrastructure/brand/BrandJpaRepository.java
index 968775cc3..eb42ce0bd 100644
--- a/apps/commerce-api/src/main/java/com/loopers/infrastructure/brand/BrandJpaRepository.java
+++ b/apps/commerce-api/src/main/java/com/loopers/infrastructure/brand/BrandJpaRepository.java
@@ -12,7 +12,7 @@
  * <p>JpaRepository를 상속받아 기본 CRUD 메서드(save, findById, findAll, delete 등)가 자동 제공되며,
  * 메서드 이름 규칙 기반의 쿼리 메서드를 추가로 정의한다.</p>
  */
-public interface BrandJpaRepository extends JpaRepository<BrandModel, String> {
+public interface BrandJpaRepository extends JpaRepository<BrandModel, Long> {
 
     /**
      * 삭제 여부와 노출 상태로 브랜드 목록을 조회한다.
diff --git a/apps/commerce-api/src/main/java/com/loopers/infrastructure/brand/BrandRepositoryImpl.java b/apps/commerce-api/src/main/java/com/loopers/infrastructure/brand/BrandRepositoryImpl.java
index 30425ad51..67bc3367c 100644
--- a/apps/commerce-api/src/main/java/com/loopers/infrastructure/brand/BrandRepositoryImpl.java
+++ b/apps/commerce-api/src/main/java/com/loopers/infrastructure/brand/BrandRepositoryImpl.java
@@ -40,7 +40,7 @@ public BrandModel save(BrandModel brand) {
      * @return 브랜드 (Optional)
      */
     @Override
-    public Optional<BrandModel> findById(String brandId) {
+    public Optional<BrandModel> findById(Long brandId) {
         return jpaRepository.findById(brandId);
     }
 
@@ -88,7 +88,7 @@ public List<BrandModel> findAllByKeyword(String keyword) {
      * @return 해당 브랜드 목록
      */
     @Override
-    public List<BrandModel> findAllByIds(Collection<String> brandIds) {
+    public List<BrandModel> findAllByIds(Collection<Long> brandIds) {
         return jpaRepository.findAllById(brandIds);
     }
 }
diff --git a/apps/commerce-api/src/main/java/com/loopers/infrastructure/cache/CacheConfig.java b/apps/commerce-api/src/main/java/com/loopers/infrastructure/cache/CacheConfig.java
new file mode 100644
index 000000000..a564410d3
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/infrastructure/cache/CacheConfig.java
@@ -0,0 +1,136 @@
+package com.loopers.infrastructure.cache;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.SerializationFeature;
+import com.fasterxml.jackson.databind.jsontype.BasicPolymorphicTypeValidator;
+import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
+import com.github.benmanes.caffeine.cache.Caffeine;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.cache.Cache;
+import org.springframework.cache.CacheManager;
+import org.springframework.cache.annotation.CachingConfigurer;
+import org.springframework.cache.annotation.EnableCaching;
+import org.springframework.cache.caffeine.CaffeineCacheManager;
+import org.springframework.cache.interceptor.CacheErrorHandler;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.data.redis.cache.BatchStrategies;
+import org.springframework.data.redis.cache.RedisCacheConfiguration;
+import org.springframework.data.redis.cache.RedisCacheManager;
+import org.springframework.data.redis.cache.RedisCacheWriter;
+import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
+import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
+import org.springframework.data.redis.serializer.RedisSerializationContext;
+import org.springframework.data.redis.serializer.StringRedisSerializer;
+
+import java.time.Duration;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.TimeUnit;
+
+@Slf4j
+@Configuration
+@EnableCaching
+@RequiredArgsConstructor
+public class CacheConfig implements CachingConfigurer {
+
+    private static final Set<String> TWO_LEVEL_CACHES = Set.of(
+            "productDetail",
+            "statsOverview",
+            "statsTopLiked",
+            "statsTopOrdered"
+    );
+
+    private final LettuceConnectionFactory connectionFactory;
+
+    @Bean
+    public CacheManager cacheManager() {
+        RedisCacheManager redisCacheManager = buildRedisCacheManager();
+        CaffeineCacheManager caffeineCacheManager = buildCaffeineCacheManager();
+        return new TwoLevelCacheManager(caffeineCacheManager, redisCacheManager, TWO_LEVEL_CACHES);
+    }
+
+    private RedisCacheManager buildRedisCacheManager() {
+        RedisCacheConfiguration defaultConfig = RedisCacheConfiguration.defaultCacheConfig()
+                .serializeKeysWith(RedisSerializationContext.SerializationPair
+                        .fromSerializer(new StringRedisSerializer()))
+                .serializeValuesWith(RedisSerializationContext.SerializationPair
+                        .fromSerializer(redisSerializer()))
+                .disableCachingNullValues()
+                .entryTtl(Duration.ofMinutes(10));
+
+        Map<String, RedisCacheConfiguration> cacheConfigs = Map.of(
+                "productDetail", defaultConfig.entryTtl(Duration.ofMinutes(10)),
+                "brandDetail", defaultConfig.entryTtl(Duration.ofMinutes(30)),
+                "authUser", defaultConfig.entryTtl(Duration.ofMinutes(1)),
+                "statsOverview", defaultConfig.entryTtl(Duration.ofMinutes(5)),
+                "statsDaily", defaultConfig.entryTtl(Duration.ofMinutes(5)),
+                "statsTopLiked", defaultConfig.entryTtl(Duration.ofMinutes(5)),
+                "statsTopOrdered", defaultConfig.entryTtl(Duration.ofMinutes(5)),
+                "statsLowStock", defaultConfig.entryTtl(Duration.ofMinutes(5))
+        );
+
+        // productList는 Map.of 10개 제한으로 별도 추가
+        Map<String, RedisCacheConfiguration> allConfigs = new java.util.HashMap<>(cacheConfigs);
+        allConfigs.put("productList", defaultConfig.entryTtl(Duration.ofMinutes(5)));
+
+        RedisCacheWriter cacheWriter = RedisCacheWriter.nonLockingRedisCacheWriter(
+                connectionFactory, BatchStrategies.scan(1000));
+
+        RedisCacheManager manager = RedisCacheManager.builder(cacheWriter)
+                .cacheDefaults(defaultConfig)
+                .withInitialCacheConfigurations(allConfigs)
+                .build();
+        manager.afterPropertiesSet();
+        return manager;
+    }
+
+    private CaffeineCacheManager buildCaffeineCacheManager() {
+        CaffeineCacheManager manager = new CaffeineCacheManager();
+        manager.setCaffeine(Caffeine.newBuilder()
+                .maximumSize(1000)
+                .expireAfterWrite(2, TimeUnit.MINUTES)
+                .recordStats());
+        return manager;
+    }
+
+    private GenericJackson2JsonRedisSerializer redisSerializer() {
+        ObjectMapper om = new ObjectMapper();
+        om.registerModule(new JavaTimeModule());
+        om.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
+        om.disable(com.fasterxml.jackson.databind.DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);
+        om.activateDefaultTyping(
+                BasicPolymorphicTypeValidator.builder()
+                        .allowIfBaseType(Object.class)
+                        .build(),
+                ObjectMapper.DefaultTyping.NON_FINAL
+        );
+        return new GenericJackson2JsonRedisSerializer(om);
+    }
+
+    @Override
+    public CacheErrorHandler errorHandler() {
+        return new CacheErrorHandler() {
+            @Override
+            public void handleCacheGetError(RuntimeException e, Cache cache, Object key) {
+                log.warn("Cache GET failed [cache={}, key={}]: {}", cache.getName(), key, e.getMessage());
+            }
+
+            @Override
+            public void handleCachePutError(RuntimeException e, Cache cache, Object key, Object value) {
+                log.warn("Cache PUT failed [cache={}, key={}]: {}", cache.getName(), key, e.getMessage());
+            }
+
+            @Override
+            public void handleCacheEvictError(RuntimeException e, Cache cache, Object key) {
+                log.warn("Cache EVICT failed [cache={}, key={}]: {}", cache.getName(), key, e.getMessage());
+            }
+
+            @Override
+            public void handleCacheClearError(RuntimeException e, Cache cache) {
+                log.warn("Cache CLEAR failed [cache={}]: {}", cache.getName(), e.getMessage());
+            }
+        };
+    }
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/infrastructure/cache/TwoLevelCache.java b/apps/commerce-api/src/main/java/com/loopers/infrastructure/cache/TwoLevelCache.java
new file mode 100644
index 000000000..749580005
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/infrastructure/cache/TwoLevelCache.java
@@ -0,0 +1,89 @@
+package com.loopers.infrastructure.cache;
+
+import lombok.RequiredArgsConstructor;
+import org.springframework.cache.Cache;
+
+import java.util.concurrent.Callable;
+
+@RequiredArgsConstructor
+public class TwoLevelCache implements Cache {
+
+    private final Cache l1Cache;
+    private final Cache l2Cache;
+
+    @Override
+    public String getName() {
+        return l2Cache.getName();
+    }
+
+    @Override
+    public Object getNativeCache() {
+        return l2Cache.getNativeCache();
+    }
+
+    @Override
+    public ValueWrapper get(Object key) {
+        ValueWrapper l1Value = l1Cache.get(key);
+        if (l1Value != null) {
+            return l1Value;
+        }
+
+        ValueWrapper l2Value = l2Cache.get(key);
+        if (l2Value != null) {
+            l1Cache.put(key, l2Value.get());
+            return l2Value;
+        }
+
+        return null;
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public <T> T get(Object key, Class<T> type) {
+        T l1Value = l1Cache.get(key, type);
+        if (l1Value != null) {
+            return l1Value;
+        }
+
+        T l2Value = l2Cache.get(key, type);
+        if (l2Value != null) {
+            l1Cache.put(key, l2Value);
+            return l2Value;
+        }
+
+        return null;
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public <T> T get(Object key, Callable<T> valueLoader) {
+        T l1Value = l1Cache.get(key, (Class<T>) Object.class);
+        if (l1Value != null) {
+            return l1Value;
+        }
+
+        T value = l2Cache.get(key, valueLoader);
+        if (value != null) {
+            l1Cache.put(key, value);
+        }
+        return value;
+    }
+
+    @Override
+    public void put(Object key, Object value) {
+        l2Cache.put(key, value);
+        l1Cache.put(key, value);
+    }
+
+    @Override
+    public void evict(Object key) {
+        l1Cache.evict(key);
+        l2Cache.evict(key);
+    }
+
+    @Override
+    public void clear() {
+        l1Cache.clear();
+        l2Cache.clear();
+    }
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/infrastructure/cache/TwoLevelCacheManager.java b/apps/commerce-api/src/main/java/com/loopers/infrastructure/cache/TwoLevelCacheManager.java
new file mode 100644
index 000000000..097d56b8d
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/infrastructure/cache/TwoLevelCacheManager.java
@@ -0,0 +1,38 @@
+package com.loopers.infrastructure.cache;
+
+import lombok.RequiredArgsConstructor;
+import org.springframework.cache.Cache;
+import org.springframework.cache.CacheManager;
+import org.springframework.cache.caffeine.CaffeineCacheManager;
+import org.springframework.data.redis.cache.RedisCacheManager;
+
+import java.util.Collection;
+import java.util.Set;
+
+@RequiredArgsConstructor
+public class TwoLevelCacheManager implements CacheManager {
+
+    private final CaffeineCacheManager l1CacheManager;
+    private final RedisCacheManager l2CacheManager;
+    private final Set<String> twoLevelCacheNames;
+
+    @Override
+    public Cache getCache(String name) {
+        Cache l2 = l2CacheManager.getCache(name);
+        if (l2 == null) {
+            return null;
+        }
+
+        if (twoLevelCacheNames.contains(name)) {
+            Cache l1 = l1CacheManager.getCache(name);
+            return new TwoLevelCache(l1, l2);
+        }
+
+        return l2;
+    }
+
+    @Override
+    public Collection<String> getCacheNames() {
+        return l2CacheManager.getCacheNames();
+    }
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/infrastructure/cart/CartItemJpaRepository.java b/apps/commerce-api/src/main/java/com/loopers/infrastructure/cart/CartItemJpaRepository.java
index f25152c20..3aac1b5e6 100644
--- a/apps/commerce-api/src/main/java/com/loopers/infrastructure/cart/CartItemJpaRepository.java
+++ b/apps/commerce-api/src/main/java/com/loopers/infrastructure/cart/CartItemJpaRepository.java
@@ -22,5 +22,5 @@ public interface CartItemJpaRepository extends JpaRepository<CartItemModel, Cart
      * @param userId 사용자 ID
      * @return 해당 사용자의 장바구니 항목 목록
      */
-    List<CartItemModel> findAllByUserId(String userId);
+    List<CartItemModel> findAllByUserId(Long userId);
 }
diff --git a/apps/commerce-api/src/main/java/com/loopers/infrastructure/cart/CartItemRepositoryImpl.java b/apps/commerce-api/src/main/java/com/loopers/infrastructure/cart/CartItemRepositoryImpl.java
index 01d335694..f34b0dba8 100644
--- a/apps/commerce-api/src/main/java/com/loopers/infrastructure/cart/CartItemRepositoryImpl.java
+++ b/apps/commerce-api/src/main/java/com/loopers/infrastructure/cart/CartItemRepositoryImpl.java
@@ -60,7 +60,7 @@ public void delete(CartItemModel item) {
      * @return 해당 사용자의 장바구니 항목 목록
      */
     @Override
-    public List<CartItemModel> findAllByUserId(String userId) {
+    public List<CartItemModel> findAllByUserId(Long userId) {
         return jpaRepository.findAllByUserId(userId);
     }
 }
diff --git a/apps/commerce-api/src/main/java/com/loopers/infrastructure/coupon/CouponJpaRepository.java b/apps/commerce-api/src/main/java/com/loopers/infrastructure/coupon/CouponJpaRepository.java
new file mode 100644
index 000000000..f4a79ef76
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/infrastructure/coupon/CouponJpaRepository.java
@@ -0,0 +1,29 @@
+package com.loopers.infrastructure.coupon;
+
+import com.loopers.domain.coupon.CouponModel;
+import jakarta.persistence.LockModeType;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.Lock;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.repository.query.Param;
+
+import java.util.Collection;
+import java.util.List;
+import java.util.Optional;
+
+/**
+ * 쿠폰 JPA 레포지토리.
+ */
+public interface CouponJpaRepository extends JpaRepository<CouponModel, Long> {
+
+    /**
+     * 비관적 쓰기 락(SELECT FOR UPDATE)으로 쿠폰을 조회한다.
+     * 동시 발급 요청 시 중복 발급 방지를 위해 사용된다.
+     */
+    @Lock(LockModeType.PESSIMISTIC_WRITE)
+    @Query("SELECT c FROM CouponModel c WHERE c.couponId = :couponId")
+    Optional<CouponModel> findByIdWithLock(@Param("couponId") Long couponId);
+
+    @Query("SELECT c FROM CouponModel c WHERE c.couponId IN :ids")
+    List<CouponModel> findAllByCouponIdIn(@Param("ids") Collection<Long> ids);
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/infrastructure/coupon/CouponRepositoryImpl.java b/apps/commerce-api/src/main/java/com/loopers/infrastructure/coupon/CouponRepositoryImpl.java
new file mode 100644
index 000000000..cde7817ec
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/infrastructure/coupon/CouponRepositoryImpl.java
@@ -0,0 +1,61 @@
+package com.loopers.infrastructure.coupon;
+
+import com.loopers.domain.coupon.CouponModel;
+import com.loopers.domain.coupon.CouponRepository;
+import com.loopers.support.page.PageQuery;
+import com.loopers.support.page.PagedResult;
+import lombok.RequiredArgsConstructor;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.data.domain.Sort;
+import org.springframework.stereotype.Repository;
+
+import java.util.Collection;
+import java.util.List;
+import java.util.Optional;
+
+/**
+ * 쿠폰 레포지토리 구현체.
+ */
+@Repository
+@RequiredArgsConstructor
+public class CouponRepositoryImpl implements CouponRepository {
+
+    private final CouponJpaRepository couponJpaRepository;
+
+    @Override
+    public Optional<CouponModel> findById(Long couponId) {
+        return couponJpaRepository.findById(couponId);
+    }
+
+    @Override
+    public Optional<CouponModel> findByIdWithLock(Long couponId) {
+        return couponJpaRepository.findByIdWithLock(couponId);
+    }
+
+    @Override
+    public CouponModel save(CouponModel coupon) {
+        return couponJpaRepository.save(coupon);
+    }
+
+    @Override
+    public List<CouponModel> findAll() {
+        return couponJpaRepository.findAll();
+    }
+
+    @Override
+    public List<CouponModel> findAllByIdIn(Collection<Long> ids) {
+        return couponJpaRepository.findAllByCouponIdIn(ids);
+    }
+
+    @Override
+    public PagedResult<CouponModel> findAllPaged(PageQuery query) {
+        Sort sort = query.ascending()
+                ? Sort.by(Sort.Direction.ASC, query.sortField())
+                : Sort.by(Sort.Direction.DESC, query.sortField());
+        Page<CouponModel> page = couponJpaRepository.findAll(
+                PageRequest.of(query.page(), query.size(), sort));
+        return new PagedResult<>(page.getContent(), page.getNumber(), page.getSize(),
+                page.getTotalElements(), page.getTotalPages());
+    }
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/infrastructure/coupon/UserCouponJpaRepository.java b/apps/commerce-api/src/main/java/com/loopers/infrastructure/coupon/UserCouponJpaRepository.java
new file mode 100644
index 000000000..99184d167
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/infrastructure/coupon/UserCouponJpaRepository.java
@@ -0,0 +1,40 @@
+package com.loopers.infrastructure.coupon;
+
+import com.loopers.domain.coupon.UserCouponModel;
+import jakarta.persistence.LockModeType;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.Lock;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.repository.query.Param;
+
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+
+import java.util.List;
+import java.util.Optional;
+
+/**
+ * 사용자 발급 쿠폰 JPA 레포지토리.
+ */
+public interface UserCouponJpaRepository extends JpaRepository<UserCouponModel, Long> {
+
+    /**
+     * 비관적 쓰기 락(SELECT FOR UPDATE)으로 발급 쿠폰을 조회한다.
+     * 동시 주문 시 쿠폰 중복 사용 방지를 위해 사용된다.
+     */
+    @Lock(LockModeType.PESSIMISTIC_WRITE)
+    @Query("SELECT uc FROM UserCouponModel uc WHERE uc.userCouponId = :userCouponId")
+    Optional<UserCouponModel> findByIdWithLock(@Param("userCouponId") Long userCouponId);
+
+    Optional<UserCouponModel> findByUserIdAndCouponId(Long userId, Long couponId);
+
+    List<UserCouponModel> findAllByUserId(Long userId);
+
+    List<UserCouponModel> findAllByCouponId(Long couponId);
+
+    boolean existsByUserIdAndCouponId(Long userId, Long couponId);
+
+    Page<UserCouponModel> findAllByCouponId(Long couponId, Pageable pageable);
+
+    Optional<UserCouponModel> findByOrderId(Long orderId);
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/infrastructure/coupon/UserCouponRepositoryImpl.java b/apps/commerce-api/src/main/java/com/loopers/infrastructure/coupon/UserCouponRepositoryImpl.java
new file mode 100644
index 000000000..93dad66ac
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/infrastructure/coupon/UserCouponRepositoryImpl.java
@@ -0,0 +1,75 @@
+package com.loopers.infrastructure.coupon;
+
+import com.loopers.domain.coupon.UserCouponModel;
+import com.loopers.domain.coupon.UserCouponRepository;
+import com.loopers.support.page.PageQuery;
+import com.loopers.support.page.PagedResult;
+import lombok.RequiredArgsConstructor;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.data.domain.Sort;
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+import java.util.Optional;
+
+/**
+ * 사용자 발급 쿠폰 레포지토리 구현체.
+ */
+@Repository
+@RequiredArgsConstructor
+public class UserCouponRepositoryImpl implements UserCouponRepository {
+
+    private final UserCouponJpaRepository userCouponJpaRepository;
+
+    @Override
+    public UserCouponModel save(UserCouponModel userCoupon) {
+        return userCouponJpaRepository.save(userCoupon);
+    }
+
+    @Override
+    public Optional<UserCouponModel> findById(Long userCouponId) {
+        return userCouponJpaRepository.findById(userCouponId);
+    }
+
+    @Override
+    public Optional<UserCouponModel> findByIdWithLock(Long userCouponId) {
+        return userCouponJpaRepository.findByIdWithLock(userCouponId);
+    }
+
+    @Override
+    public Optional<UserCouponModel> findByUserIdAndCouponId(Long userId, Long couponId) {
+        return userCouponJpaRepository.findByUserIdAndCouponId(userId, couponId);
+    }
+
+    @Override
+    public List<UserCouponModel> findAllByUserId(Long userId) {
+        return userCouponJpaRepository.findAllByUserId(userId);
+    }
+
+    @Override
+    public List<UserCouponModel> findAllByCouponId(Long couponId) {
+        return userCouponJpaRepository.findAllByCouponId(couponId);
+    }
+
+    @Override
+    public boolean existsByUserIdAndCouponId(Long userId, Long couponId) {
+        return userCouponJpaRepository.existsByUserIdAndCouponId(userId, couponId);
+    }
+
+    @Override
+    public PagedResult<UserCouponModel> findAllByCouponIdPaged(Long couponId, PageQuery query) {
+        Sort sort = query.ascending()
+                ? Sort.by(Sort.Direction.ASC, query.sortField())
+                : Sort.by(Sort.Direction.DESC, query.sortField());
+        Page<UserCouponModel> page = userCouponJpaRepository.findAllByCouponId(
+                couponId, PageRequest.of(query.page(), query.size(), sort));
+        return new PagedResult<>(page.getContent(), page.getNumber(), page.getSize(),
+                page.getTotalElements(), page.getTotalPages());
+    }
+
+    @Override
+    public Optional<UserCouponModel> findByOrderId(Long orderId) {
+        return userCouponJpaRepository.findByOrderId(orderId);
+    }
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/infrastructure/like/LikeJpaRepository.java b/apps/commerce-api/src/main/java/com/loopers/infrastructure/like/LikeJpaRepository.java
index cb28da326..700bb377f 100644
--- a/apps/commerce-api/src/main/java/com/loopers/infrastructure/like/LikeJpaRepository.java
+++ b/apps/commerce-api/src/main/java/com/loopers/infrastructure/like/LikeJpaRepository.java
@@ -25,7 +25,7 @@ public interface LikeJpaRepository extends JpaRepository<LikeModel, LikeId> {
      * @param userId 사용자 ID
      * @return 해당 사용자의 좋아요 목록
      */
-    List<LikeModel> findAllByUserId(String userId);
+    List<LikeModel> findAllByUserId(Long userId);
 
     /**
      * 상품 ID에 대한 좋아요 수를 조회한다.
@@ -35,7 +35,7 @@ public interface LikeJpaRepository extends JpaRepository<LikeModel, LikeId> {
      * @param productId 상품 ID
      * @return 해당 상품의 좋아요 수
      */
-    long countByProductId(String productId);
+    long countByProductId(Long productId);
 
     /**
      * 여러 상품의 좋아요 수를 GROUP BY로 일괄 조회한다.
@@ -44,5 +44,5 @@ public interface LikeJpaRepository extends JpaRepository<LikeModel, LikeId> {
      * @return [productId, count] 배열 목록
      */
     @Query("SELECT l.productId, COUNT(l) FROM LikeModel l WHERE l.productId IN :productIds GROUP BY l.productId")
-    List<Object[]> countByProductIdIn(@Param("productIds") Collection<String> productIds);
+    List<Object[]> countByProductIdIn(@Param("productIds") Collection<Long> productIds);
 }
diff --git a/apps/commerce-api/src/main/java/com/loopers/infrastructure/like/LikeRepositoryImpl.java b/apps/commerce-api/src/main/java/com/loopers/infrastructure/like/LikeRepositoryImpl.java
index 7fd3e9fa3..fbd980cec 100644
--- a/apps/commerce-api/src/main/java/com/loopers/infrastructure/like/LikeRepositoryImpl.java
+++ b/apps/commerce-api/src/main/java/com/loopers/infrastructure/like/LikeRepositoryImpl.java
@@ -64,7 +64,7 @@ public void delete(LikeModel like) {
      * @return 해당 사용자의 좋아요 목록
      */
     @Override
-    public List<LikeModel> findAllByUserId(String userId) {
+    public List<LikeModel> findAllByUserId(Long userId) {
         return jpaRepository.findAllByUserId(userId);
     }
 
@@ -75,18 +75,18 @@ public List<LikeModel> findAllByUserId(String userId) {
      * @return 해당 상품의 좋아요 수
      */
     @Override
-    public long countByProductId(String productId) {
+    public long countByProductId(Long productId) {
         return jpaRepository.countByProductId(productId);
     }
 
     @Override
-    public Map<String, Long> countByProductIds(Collection<String> productIds) {
+    public Map<Long, Long> countByProductIds(Collection<Long> productIds) {
         if (productIds == null || productIds.isEmpty()) {
             return Collections.emptyMap();
         }
         return jpaRepository.countByProductIdIn(productIds).stream()
                 .collect(Collectors.toMap(
-                        row -> (String) row[0],
+                        row -> (Long) row[0],
                         row -> (Long) row[1]
                 ));
     }
diff --git a/apps/commerce-api/src/main/java/com/loopers/infrastructure/order/OrderCartRestoreJpaRepository.java b/apps/commerce-api/src/main/java/com/loopers/infrastructure/order/OrderCartRestoreJpaRepository.java
index 162afbc3c..21fe0959b 100644
--- a/apps/commerce-api/src/main/java/com/loopers/infrastructure/order/OrderCartRestoreJpaRepository.java
+++ b/apps/commerce-api/src/main/java/com/loopers/infrastructure/order/OrderCartRestoreJpaRepository.java
@@ -9,5 +9,5 @@
  * <p>JpaRepository를 상속받아 기본 CRUD 메서드(save, findById, findAll, delete 등)가 자동 제공된다.
  * PK가 order_id이므로, 동일 주문에 대해 1회만 복원이 수행됨을 보장한다.</p>
  */
-public interface OrderCartRestoreJpaRepository extends JpaRepository<OrderCartRestoreModel, String> {
+public interface OrderCartRestoreJpaRepository extends JpaRepository<OrderCartRestoreModel, Long> {
 }
diff --git a/apps/commerce-api/src/main/java/com/loopers/infrastructure/order/OrderCartRestoreRepositoryImpl.java b/apps/commerce-api/src/main/java/com/loopers/infrastructure/order/OrderCartRestoreRepositoryImpl.java
index f42845cc0..1cb2ab1f5 100644
--- a/apps/commerce-api/src/main/java/com/loopers/infrastructure/order/OrderCartRestoreRepositoryImpl.java
+++ b/apps/commerce-api/src/main/java/com/loopers/infrastructure/order/OrderCartRestoreRepositoryImpl.java
@@ -38,7 +38,7 @@ public OrderCartRestoreModel save(OrderCartRestoreModel restore) {
      * @return 존재 여부
      */
     @Override
-    public boolean existsById(String orderId) {
+    public boolean existsById(Long orderId) {
         return jpaRepository.existsById(orderId);
     }
 }
diff --git a/apps/commerce-api/src/main/java/com/loopers/infrastructure/order/OrderItemJpaRepository.java b/apps/commerce-api/src/main/java/com/loopers/infrastructure/order/OrderItemJpaRepository.java
index 219b2b503..a3ff347a3 100644
--- a/apps/commerce-api/src/main/java/com/loopers/infrastructure/order/OrderItemJpaRepository.java
+++ b/apps/commerce-api/src/main/java/com/loopers/infrastructure/order/OrderItemJpaRepository.java
@@ -22,7 +22,7 @@ public interface OrderItemJpaRepository extends JpaRepository<OrderItemModel, Or
      * @param orderId 주문 ID
      * @return 해당 주문의 주문 항목 목록
      */
-    List<OrderItemModel> findAllByOrderId(String orderId);
+    List<OrderItemModel> findAllByOrderId(Long orderId);
 
     /**
      * 여러 주문 ID에 해당하는 주문 항목을 일괄 조회한다.
@@ -30,5 +30,5 @@ public interface OrderItemJpaRepository extends JpaRepository<OrderItemModel, Or
      * @param orderIds 주문 ID 목록
      * @return 해당 주문들의 주문 항목 목록
      */
-    List<OrderItemModel> findAllByOrderIdIn(List<String> orderIds);
+    List<OrderItemModel> findAllByOrderIdIn(List<Long> orderIds);
 }
diff --git a/apps/commerce-api/src/main/java/com/loopers/infrastructure/order/OrderItemRepositoryImpl.java b/apps/commerce-api/src/main/java/com/loopers/infrastructure/order/OrderItemRepositoryImpl.java
index 7c920f8ec..d19504a61 100644
--- a/apps/commerce-api/src/main/java/com/loopers/infrastructure/order/OrderItemRepositoryImpl.java
+++ b/apps/commerce-api/src/main/java/com/loopers/infrastructure/order/OrderItemRepositoryImpl.java
@@ -48,7 +48,7 @@ public List<OrderItemModel> saveAll(List<OrderItemModel> items) {
      * @return 해당 주문의 주문 항목 목록
      */
     @Override
-    public List<OrderItemModel> findAllByOrderId(String orderId) {
+    public List<OrderItemModel> findAllByOrderId(Long orderId) {
         return jpaRepository.findAllByOrderId(orderId);
     }
 
@@ -59,7 +59,7 @@ public List<OrderItemModel> findAllByOrderId(String orderId) {
      * @return 해당 주문들의 주문 항목 목록
      */
     @Override
-    public List<OrderItemModel> findAllByOrderIds(List<String> orderIds) {
+    public List<OrderItemModel> findAllByOrderIds(List<Long> orderIds) {
         return jpaRepository.findAllByOrderIdIn(orderIds);
     }
 }
diff --git a/apps/commerce-api/src/main/java/com/loopers/infrastructure/order/OrderJpaRepository.java b/apps/commerce-api/src/main/java/com/loopers/infrastructure/order/OrderJpaRepository.java
index 49f5bee2f..f2635438d 100644
--- a/apps/commerce-api/src/main/java/com/loopers/infrastructure/order/OrderJpaRepository.java
+++ b/apps/commerce-api/src/main/java/com/loopers/infrastructure/order/OrderJpaRepository.java
@@ -17,7 +17,7 @@
  * <p>JpaRepository를 상속받아 기본 CRUD 메서드가 자동 제공되며,
  * CAS(Compare-And-Set) 기반의 상태 변경 쿼리와 다양한 조회 쿼리를 정의한다.</p>
  */
-public interface OrderJpaRepository extends JpaRepository<OrderModel, String> {
+public interface OrderJpaRepository extends JpaRepository<OrderModel, Long> {
 
     /**
      * 주문 ID와 사용자 ID로 주문을 조회한다.
@@ -28,7 +28,7 @@ public interface OrderJpaRepository extends JpaRepository<OrderModel, String> {
      * @param userId  사용자 ID
      * @return 주문 (Optional)
      */
-    Optional<OrderModel> findByOrderIdAndUserId(String orderId, String userId);
+    Optional<OrderModel> findByOrderIdAndUserId(Long orderId, Long userId);
 
     /**
      * 사용자 ID와 기간으로 주문 목록을 조회한다 (최신순 정렬).
@@ -41,7 +41,7 @@ public interface OrderJpaRepository extends JpaRepository<OrderModel, String> {
     @Query("SELECT o FROM OrderModel o " +
            "WHERE o.userId = :userId AND o.createdAt BETWEEN :start AND :end " +
            "ORDER BY o.createdAt DESC")
-    List<OrderModel> findAllByUserIdAndPeriod(@Param("userId") String userId,
+    List<OrderModel> findAllByUserIdAndPeriod(@Param("userId") Long userId,
                                               @Param("start") LocalDateTime start,
                                               @Param("end") LocalDateTime end);
 
@@ -72,7 +72,7 @@ List<OrderModel> findAllByPeriod(@Param("start") LocalDateTime start,
     @Modifying
     @Query("UPDATE OrderModel o SET o.status = :toStatus, o.updatedAt = CURRENT_TIMESTAMP " +
            "WHERE o.orderId = :orderId AND o.status = :fromStatus")
-    int casUpdateStatus(@Param("orderId") String orderId,
+    int casUpdateStatus(@Param("orderId") Long orderId,
                         @Param("fromStatus") OrderStatus fromStatus,
                         @Param("toStatus") OrderStatus toStatus);
 
@@ -85,7 +85,7 @@ int casUpdateStatus(@Param("orderId") String orderId,
      * @param status 주문 상태
      * @return 조건에 해당하는 주문 건수
      */
-    long countByUserIdAndStatus(String userId, OrderStatus status);
+    long countByUserIdAndStatus(Long userId, OrderStatus status);
 
     /**
      * 만료 시각이 지난 결제 대기 주문 목록을 조회한다.
diff --git a/apps/commerce-api/src/main/java/com/loopers/infrastructure/order/OrderRepositoryImpl.java b/apps/commerce-api/src/main/java/com/loopers/infrastructure/order/OrderRepositoryImpl.java
index f18699a8b..f8cb17b10 100644
--- a/apps/commerce-api/src/main/java/com/loopers/infrastructure/order/OrderRepositoryImpl.java
+++ b/apps/commerce-api/src/main/java/com/loopers/infrastructure/order/OrderRepositoryImpl.java
@@ -40,7 +40,7 @@ public OrderModel save(OrderModel order) {
      * @return 주문 (Optional)
      */
     @Override
-    public Optional<OrderModel> findById(String orderId) {
+    public Optional<OrderModel> findById(Long orderId) {
         return jpaRepository.findById(orderId);
     }
 
@@ -52,7 +52,7 @@ public Optional<OrderModel> findById(String orderId) {
      * @return 주문 (Optional)
      */
     @Override
-    public Optional<OrderModel> findByIdAndUserId(String orderId, String userId) {
+    public Optional<OrderModel> findByIdAndUserId(Long orderId, Long userId) {
         return jpaRepository.findByOrderIdAndUserId(orderId, userId);
     }
 
@@ -65,7 +65,7 @@ public Optional<OrderModel> findByIdAndUserId(String orderId, String userId) {
      * @return 기간 내 해당 사용자의 주문 목록
      */
     @Override
-    public List<OrderModel> findAllByUserIdAndPeriod(String userId, LocalDateTime start, LocalDateTime end) {
+    public List<OrderModel> findAllByUserIdAndPeriod(Long userId, LocalDateTime start, LocalDateTime end) {
         return jpaRepository.findAllByUserIdAndPeriod(userId, start, end);
     }
 
@@ -93,7 +93,7 @@ public List<OrderModel> findAllByPeriod(LocalDateTime start, LocalDateTime end)
      * @return 변경된 행 수 (0이면 상태 전이 실패)
      */
     @Override
-    public int casUpdateStatus(String orderId, OrderStatus from, OrderStatus to) {
+    public int casUpdateStatus(Long orderId, OrderStatus from, OrderStatus to) {
         return jpaRepository.casUpdateStatus(orderId, from, to);
     }
 
@@ -105,7 +105,7 @@ public int casUpdateStatus(String orderId, OrderStatus from, OrderStatus to) {
      * @return 조건에 해당하는 주문 건수
      */
     @Override
-    public long countByUserIdAndStatus(String userId, OrderStatus status) {
+    public long countByUserIdAndStatus(Long userId, OrderStatus status) {
         return jpaRepository.countByUserIdAndStatus(userId, status);
     }
 
diff --git a/apps/commerce-api/src/main/java/com/loopers/infrastructure/product/ProductJpaRepository.java b/apps/commerce-api/src/main/java/com/loopers/infrastructure/product/ProductJpaRepository.java
index 7800abd4b..84626da7a 100644
--- a/apps/commerce-api/src/main/java/com/loopers/infrastructure/product/ProductJpaRepository.java
+++ b/apps/commerce-api/src/main/java/com/loopers/infrastructure/product/ProductJpaRepository.java
@@ -4,10 +4,15 @@
 import org.springframework.data.domain.Page;
 import org.springframework.data.domain.Pageable;
 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 jakarta.persistence.LockModeType;
+import org.springframework.data.jpa.repository.Lock;
+
 import java.util.List;
+import java.util.Optional;
 
 /**
  * 상품 엔티티에 대한 Spring Data JPA Repository 인터페이스.
@@ -15,7 +20,7 @@
  * <p>JpaRepository를 상속받아 기본 CRUD 메서드가 자동 제공되며,
  * 고객용 검색 쿼리와 관리자용 조회 쿼리를 정의한다.</p>
  */
-public interface ProductJpaRepository extends JpaRepository<ProductModel, String> {
+public interface ProductJpaRepository extends JpaRepository<ProductModel, Long> {
 
     /**
      * 고객용 상품 목록을 조회한다.
@@ -32,7 +37,7 @@ public interface ProductJpaRepository extends JpaRepository<ProductModel, String
            "AND (:keyword IS NULL OR p.productName LIKE %:keyword%) " +
            "AND (:brandId IS NULL OR p.brandId = :brandId)")
     List<ProductModel> findAllForCustomer(@Param("keyword") String keyword,
-                                          @Param("brandId") String brandId);
+                                          @Param("brandId") Long brandId);
 
     /**
      * 브랜드 ID로 상품 목록을 조회한다.
@@ -42,7 +47,7 @@ List<ProductModel> findAllForCustomer(@Param("keyword") String keyword,
      * @param brandId 브랜드 ID
      * @return 해당 브랜드의 상품 목록
      */
-    List<ProductModel> findAllByBrandId(String brandId);
+    List<ProductModel> findAllByBrandId(Long brandId);
 
     /**
      * 삭제 여부로 상품 목록을 조회한다.
@@ -67,6 +72,19 @@ List<ProductModel> findAllForCustomer(@Param("keyword") String keyword,
            "AND (:keyword IS NULL OR p.productName LIKE %:keyword%) " +
            "AND (:brandId IS NULL OR p.brandId = :brandId)")
     Page<ProductModel> findAllForCustomerPaged(@Param("keyword") String keyword,
-                                               @Param("brandId") String brandId,
+                                               @Param("brandId") Long brandId,
                                                Pageable pageable);
+
+    @Lock(LockModeType.PESSIMISTIC_WRITE)
+    @Query("SELECT p FROM ProductModel p WHERE p.productId = :productId")
+    Optional<ProductModel> findByIdWithLock(@Param("productId") Long productId);
+
+    @Modifying
+    @Query("UPDATE ProductModel p SET p.likeCount = p.likeCount + 1 WHERE p.productId = :productId")
+    void incrementLikeCount(@Param("productId") Long productId);
+
+    @Modifying
+    @Query("UPDATE ProductModel p SET p.likeCount = GREATEST(p.likeCount - 1, 0) WHERE p.productId = :productId")
+    void decrementLikeCount(@Param("productId") Long productId);
+
 }
diff --git a/apps/commerce-api/src/main/java/com/loopers/infrastructure/product/ProductRepositoryImpl.java b/apps/commerce-api/src/main/java/com/loopers/infrastructure/product/ProductRepositoryImpl.java
index f898b42bb..845c8173e 100644
--- a/apps/commerce-api/src/main/java/com/loopers/infrastructure/product/ProductRepositoryImpl.java
+++ b/apps/commerce-api/src/main/java/com/loopers/infrastructure/product/ProductRepositoryImpl.java
@@ -2,9 +2,12 @@
 
 import com.loopers.domain.product.ProductModel;
 import com.loopers.domain.product.ProductRepository;
+import com.loopers.support.page.PageQuery;
+import com.loopers.support.page.PagedResult;
 import lombok.RequiredArgsConstructor;
 import org.springframework.data.domain.Page;
-import org.springframework.data.domain.Pageable;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.data.domain.Sort;
 import org.springframework.stereotype.Repository;
 
 import java.util.Collection;
@@ -41,10 +44,15 @@ public ProductModel save(ProductModel product) {
      * @return 상품 (Optional)
      */
     @Override
-    public Optional<ProductModel> findById(String productId) {
+    public Optional<ProductModel> findById(Long productId) {
         return jpaRepository.findById(productId);
     }
 
+    @Override
+    public Optional<ProductModel> findByIdWithLock(Long productId) {
+        return jpaRepository.findByIdWithLock(productId);
+    }
+
     /**
      * 전체 상품 목록을 조회한다.
      *
@@ -76,7 +84,7 @@ public List<ProductModel> findAllByDelYn(String delYn) {
      * @return 조건에 부합하는 상품 목록
      */
     @Override
-    public List<ProductModel> findAllForCustomer(String keyword, String brandId) {
+    public List<ProductModel> findAllForCustomer(String keyword, Long brandId) {
         return jpaRepository.findAllForCustomer(keyword, brandId);
     }
 
@@ -87,7 +95,7 @@ public List<ProductModel> findAllForCustomer(String keyword, String brandId) {
      * @return 해당 브랜드의 상품 목록
      */
     @Override
-    public List<ProductModel> findAllByBrandId(String brandId) {
+    public List<ProductModel> findAllByBrandId(Long brandId) {
         return jpaRepository.findAllByBrandId(brandId);
     }
 
@@ -98,12 +106,29 @@ public List<ProductModel> findAllByBrandId(String brandId) {
      * @return 해당 상품 목록
      */
     @Override
-    public List<ProductModel> findAllByProductIds(Collection<String> productIds) {
+    public List<ProductModel> findAllByProductIds(Collection<Long> productIds) {
         return jpaRepository.findAllById(productIds);
     }
 
     @Override
-    public Page<ProductModel> findAllForCustomer(String keyword, String brandId, Pageable pageable) {
-        return jpaRepository.findAllForCustomerPaged(keyword, brandId, pageable);
+    public PagedResult<ProductModel> findAllForCustomer(String keyword, Long brandId, PageQuery query) {
+        Sort sort = query.ascending()
+                ? Sort.by(Sort.Direction.ASC, query.sortField())
+                : Sort.by(Sort.Direction.DESC, query.sortField());
+        Page<ProductModel> page = jpaRepository.findAllForCustomerPaged(
+                keyword, brandId, PageRequest.of(query.page(), query.size(), sort));
+        return new PagedResult<>(page.getContent(), page.getNumber(), page.getSize(),
+                page.getTotalElements(), page.getTotalPages());
+    }
+
+    @Override
+    public void incrementLikeCount(Long productId) {
+        jpaRepository.incrementLikeCount(productId);
     }
+
+    @Override
+    public void decrementLikeCount(Long productId) {
+        jpaRepository.decrementLikeCount(productId);
+    }
+
 }
diff --git a/apps/commerce-api/src/main/java/com/loopers/infrastructure/product/ProductRevisionJpaRepository.java b/apps/commerce-api/src/main/java/com/loopers/infrastructure/product/ProductRevisionJpaRepository.java
index f36e1b967..aafb95d5e 100644
--- a/apps/commerce-api/src/main/java/com/loopers/infrastructure/product/ProductRevisionJpaRepository.java
+++ b/apps/commerce-api/src/main/java/com/loopers/infrastructure/product/ProductRevisionJpaRepository.java
@@ -22,5 +22,5 @@ public interface ProductRevisionJpaRepository extends JpaRepository<ProductRevis
      * @param productId 상품 ID
      * @return 해당 상품의 변경 이력 목록 (최신순)
      */
-    List<ProductRevisionModel> findAllByProductIdOrderByRevisionSeqDesc(String productId);
+    List<ProductRevisionModel> findAllByProductIdOrderByRevisionSeqDesc(Long productId);
 }
diff --git a/apps/commerce-api/src/main/java/com/loopers/infrastructure/product/ProductRevisionRepositoryImpl.java b/apps/commerce-api/src/main/java/com/loopers/infrastructure/product/ProductRevisionRepositoryImpl.java
index 42f7cc72f..161dcdbb4 100644
--- a/apps/commerce-api/src/main/java/com/loopers/infrastructure/product/ProductRevisionRepositoryImpl.java
+++ b/apps/commerce-api/src/main/java/com/loopers/infrastructure/product/ProductRevisionRepositoryImpl.java
@@ -39,7 +39,7 @@ public ProductRevisionModel save(ProductRevisionModel revision) {
      * @return 해당 상품의 변경 이력 목록 (최신순)
      */
     @Override
-    public List<ProductRevisionModel> findAllByProductId(String productId) {
+    public List<ProductRevisionModel> findAllByProductId(Long productId) {
         return jpaRepository.findAllByProductIdOrderByRevisionSeqDesc(productId);
     }
 
diff --git a/apps/commerce-api/src/main/java/com/loopers/infrastructure/product/ProductStockJpaRepository.java b/apps/commerce-api/src/main/java/com/loopers/infrastructure/product/ProductStockJpaRepository.java
index 73508c3ca..a5ede81cd 100644
--- a/apps/commerce-api/src/main/java/com/loopers/infrastructure/product/ProductStockJpaRepository.java
+++ b/apps/commerce-api/src/main/java/com/loopers/infrastructure/product/ProductStockJpaRepository.java
@@ -13,7 +13,7 @@
  * CAS(Compare-And-Set) 기반의 재고 예약/해제/확정 쿼리를 정의하여
  * 오버셀(초과 판매)을 방지한다.</p>
  */
-public interface ProductStockJpaRepository extends JpaRepository<ProductStockModel, String> {
+public interface ProductStockJpaRepository extends JpaRepository<ProductStockModel, Long> {
 
     /**
      * CAS 방식으로 재고를 예약(hold)한다.
@@ -28,7 +28,7 @@ public interface ProductStockJpaRepository extends JpaRepository<ProductStockMod
     @Modifying
     @Query("UPDATE ProductStockModel s SET s.reserved = s.reserved + :qty " +
            "WHERE s.productId = :productId AND (s.onHand - s.reserved) >= :qty")
-    int reserveStock(@Param("productId") String productId, @Param("qty") int qty);
+    int reserveStock(@Param("productId") Long productId, @Param("qty") int qty);
 
     /**
      * CAS 방식으로 예약된 재고를 해제(release)한다.
@@ -43,7 +43,7 @@ public interface ProductStockJpaRepository extends JpaRepository<ProductStockMod
     @Modifying
     @Query("UPDATE ProductStockModel s SET s.reserved = s.reserved - :qty " +
            "WHERE s.productId = :productId AND s.reserved >= :qty")
-    int releaseStock(@Param("productId") String productId, @Param("qty") int qty);
+    int releaseStock(@Param("productId") Long productId, @Param("qty") int qty);
 
     /**
      * CAS 방식으로 예약된 재고를 확정(commit)한다.
@@ -59,5 +59,5 @@ public interface ProductStockJpaRepository extends JpaRepository<ProductStockMod
     @Query("UPDATE ProductStockModel s " +
            "SET s.onHand = s.onHand - :qty, s.reserved = s.reserved - :qty " +
            "WHERE s.productId = :productId AND s.reserved >= :qty")
-    int commitStock(@Param("productId") String productId, @Param("qty") int qty);
+    int commitStock(@Param("productId") Long productId, @Param("qty") int qty);
 }
diff --git a/apps/commerce-api/src/main/java/com/loopers/infrastructure/product/ProductStockRepositoryImpl.java b/apps/commerce-api/src/main/java/com/loopers/infrastructure/product/ProductStockRepositoryImpl.java
index e617fc7d2..43ec12dad 100644
--- a/apps/commerce-api/src/main/java/com/loopers/infrastructure/product/ProductStockRepositoryImpl.java
+++ b/apps/commerce-api/src/main/java/com/loopers/infrastructure/product/ProductStockRepositoryImpl.java
@@ -40,7 +40,7 @@ public ProductStockModel save(ProductStockModel stock) {
      * @return 상품 재고 (Optional)
      */
     @Override
-    public Optional<ProductStockModel> findByProductId(String productId) {
+    public Optional<ProductStockModel> findByProductId(Long productId) {
         return jpaRepository.findById(productId);
     }
 
@@ -52,7 +52,7 @@ public Optional<ProductStockModel> findByProductId(String productId) {
      * @return 변경된 행 수 (0이면 재고 부족으로 예약 실패)
      */
     @Override
-    public int reserveStock(String productId, int qty) {
+    public int reserveStock(Long productId, int qty) {
         return jpaRepository.reserveStock(productId, qty);
     }
 
@@ -64,7 +64,7 @@ public int reserveStock(String productId, int qty) {
      * @return 변경된 행 수 (0이면 해제 실패)
      */
     @Override
-    public int releaseStock(String productId, int qty) {
+    public int releaseStock(Long productId, int qty) {
         return jpaRepository.releaseStock(productId, qty);
     }
 
@@ -76,7 +76,7 @@ public int releaseStock(String productId, int qty) {
      * @return 변경된 행 수 (0이면 확정 실패)
      */
     @Override
-    public int commitStock(String productId, int qty) {
+    public int commitStock(Long productId, int qty) {
         return jpaRepository.commitStock(productId, qty);
     }
 
@@ -87,7 +87,7 @@ public int commitStock(String productId, int qty) {
      * @return 해당 상품들의 재고 목록
      */
     @Override
-    public List<ProductStockModel> findAllByProductIds(Collection<String> productIds) {
+    public List<ProductStockModel> findAllByProductIds(Collection<Long> productIds) {
         return jpaRepository.findAllById(productIds);
     }
 }
diff --git a/apps/commerce-api/src/main/java/com/loopers/infrastructure/user/UserJpaRepository.java b/apps/commerce-api/src/main/java/com/loopers/infrastructure/user/UserJpaRepository.java
index 47ca5e8d9..372d90799 100644
--- a/apps/commerce-api/src/main/java/com/loopers/infrastructure/user/UserJpaRepository.java
+++ b/apps/commerce-api/src/main/java/com/loopers/infrastructure/user/UserJpaRepository.java
@@ -11,7 +11,7 @@
  * <p>JpaRepository를 상속받아 기본 CRUD 메서드(save, findById, findAll, delete 등)가 자동 제공되며,
  * 메서드 이름 규칙 기반의 쿼리 메서드를 추가로 정의한다.</p>
  */
-public interface UserJpaRepository extends JpaRepository<UserModel, String> {
+public interface UserJpaRepository extends JpaRepository<UserModel, Long> {
 
     /**
      * 로그인 ID로 사용자를 조회한다.
diff --git a/apps/commerce-api/src/main/java/com/loopers/infrastructure/user/UserRepositoryImpl.java b/apps/commerce-api/src/main/java/com/loopers/infrastructure/user/UserRepositoryImpl.java
index 6ad0552c1..3adb2e3fc 100644
--- a/apps/commerce-api/src/main/java/com/loopers/infrastructure/user/UserRepositoryImpl.java
+++ b/apps/commerce-api/src/main/java/com/loopers/infrastructure/user/UserRepositoryImpl.java
@@ -37,7 +37,7 @@ public UserModel save(UserModel user) {
      * @return 사용자 (Optional)
      */
     @Override
-    public Optional<UserModel> findByUserId(String userId) {
+    public Optional<UserModel> findByUserId(Long userId) {
         return jpaRepository.findById(userId);
     }
 
diff --git a/apps/commerce-api/src/main/java/com/loopers/interfaces/api/AuthUser.java b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/AuthUser.java
new file mode 100644
index 000000000..b918decc9
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/AuthUser.java
@@ -0,0 +1,24 @@
+package com.loopers.interfaces.api;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * 컨트롤러 메서드 파라미터에 인증된 사용자 정보를 주입하기 위한 어노테이션.
+ *
+ * <p>{@link CustomerAuthInterceptor}에서 인증된 {@link com.loopers.domain.user.UserModel}을
+ * 컨트롤러 메서드 파라미터로 주입받을 때 사용한다.</p>
+ *
+ * <pre>{@code
+ * @GetMapping("/me")
+ * public ResponseEntity<...> getMyInfo(@AuthUser UserModel user) {
+ *     // user is the authenticated user
+ * }
+ * }</pre>
+ */
+@Target(ElementType.PARAMETER)
+@Retention(RetentionPolicy.RUNTIME)
+public @interface AuthUser {
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/interfaces/api/AuthUserArgumentResolver.java b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/AuthUserArgumentResolver.java
new file mode 100644
index 000000000..b441d0dbc
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/AuthUserArgumentResolver.java
@@ -0,0 +1,55 @@
+package com.loopers.interfaces.api;
+
+import com.loopers.domain.user.UserModel;
+import com.loopers.support.error.CoreException;
+import com.loopers.support.error.ErrorType;
+import org.springframework.core.MethodParameter;
+import org.springframework.stereotype.Component;
+import org.springframework.web.bind.support.WebDataBinderFactory;
+import org.springframework.web.context.request.NativeWebRequest;
+import org.springframework.web.context.request.RequestAttributes;
+import org.springframework.web.method.support.HandlerMethodArgumentResolver;
+import org.springframework.web.method.support.ModelAndViewContainer;
+
+/**
+ * {@link AuthUser} 어노테이션이 붙은 파라미터에 인증된 사용자 정보를 주입하는 ArgumentResolver.
+ *
+ * <p>{@link CustomerAuthInterceptor}에서 request attribute에 저장된 {@link UserModel}을
+ * 컨트롤러 메서드 파라미터로 주입한다.</p>
+ */
+@Component
+public class AuthUserArgumentResolver implements HandlerMethodArgumentResolver {
+
+    /**
+     * 해당 파라미터를 지원하는지 확인한다.
+     *
+     * @param parameter 메서드 파라미터
+     * @return {@link AuthUser} 어노테이션이 있고 타입이 {@link UserModel}이면 {@code true}
+     */
+    @Override
+    public boolean supportsParameter(MethodParameter parameter) {
+        return parameter.hasParameterAnnotation(AuthUser.class)
+                && UserModel.class.isAssignableFrom(parameter.getParameterType());
+    }
+
+    /**
+     * 인증된 사용자 정보를 반환한다.
+     *
+     * @param parameter     메서드 파라미터
+     * @param mavContainer  ModelAndView 컨테이너
+     * @param webRequest    웹 요청
+     * @param binderFactory 바인더 팩토리
+     * @return 인증된 {@link UserModel}
+     * @throws CoreException 인증된 사용자가 없을 때 (UNAUTHORIZED)
+     */
+    @Override
+    public Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer,
+                                  NativeWebRequest webRequest, WebDataBinderFactory binderFactory) {
+        Object user = webRequest.getAttribute(CustomerAuthInterceptor.AUTH_USER_ATTR,
+                RequestAttributes.SCOPE_REQUEST);
+        if (user == null) {
+            throw new CoreException(ErrorType.UNAUTHORIZED);
+        }
+        return user;
+    }
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/interfaces/api/CustomerAuthInterceptor.java b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/CustomerAuthInterceptor.java
new file mode 100644
index 000000000..d35f62f37
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/CustomerAuthInterceptor.java
@@ -0,0 +1,58 @@
+package com.loopers.interfaces.api;
+
+import com.loopers.domain.user.UserModel;
+import com.loopers.domain.user.UserService;
+import com.loopers.support.error.CoreException;
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletResponse;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Component;
+import org.springframework.web.servlet.HandlerInterceptor;
+
+/**
+ * 고객 API 인증 처리를 담당하는 인터셉터.
+ *
+ * <p>{@code X-Loopers-LoginId}와 {@code X-Loopers-LoginPw} 헤더 값을 검증하여 고객 인증을 수행한다.
+ * 인증 성공 시 {@link UserModel}을 request attribute에 저장한다.
+ * 인증에 실패하면 {@link CoreException}을 발생시킨다.</p>
+ */
+@Component
+@RequiredArgsConstructor
+public class CustomerAuthInterceptor implements HandlerInterceptor {
+
+    private static final String LOGIN_ID_HEADER = "X-Loopers-LoginId";
+    private static final String LOGIN_PW_HEADER = "X-Loopers-LoginPw";
+
+    /**
+     * Request attribute key for the authenticated user.
+     */
+    public static final String AUTH_USER_ATTR = "authenticatedUser";
+
+    private final UserService userService;
+
+    /**
+     * 요청을 처리하기 전에 고객 인증을 수행한다.
+     *
+     * <p>인증 헤더가 없으면 통과시키고, 헤더가 있으면 인증을 수행한다.
+     * 인증 성공 시 UserModel을 request attribute에 저장한다.</p>
+     *
+     * @param request  HTTP 요청 객체
+     * @param response HTTP 응답 객체
+     * @param handler  요청을 처리할 핸들러 객체
+     * @return 항상 {@code true} (인증 실패 시 예외 발생)
+     * @throws CoreException 인증 실패 시 예외 발생
+     */
+    @Override
+    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
+        String loginId = request.getHeader(LOGIN_ID_HEADER);
+        String loginPw = request.getHeader(LOGIN_PW_HEADER);
+
+        if (loginId == null || loginPw == null) {
+            return true;  // 헤더 없으면 통과 (인증 불필요 API용)
+        }
+
+        UserModel user = userService.authenticate(loginId, loginPw);
+        request.setAttribute(AUTH_USER_ATTR, user);
+        return true;
+    }
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/interfaces/api/PageResponse.java b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/PageResponse.java
index 31ef1e4a2..09f6be0de 100644
--- a/apps/commerce-api/src/main/java/com/loopers/interfaces/api/PageResponse.java
+++ b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/PageResponse.java
@@ -1,21 +1,19 @@
 package com.loopers.interfaces.api;
 
-import org.springframework.data.domain.Page;
-
 import java.util.List;
 
 /**
  * 페이징 응답 래퍼.
  *
- * <p>Spring Data의 {@link Page} 객체를 API 응답에 적합한 형태로 변환하는 제네릭 레코드이다.
- * 페이지 콘텐츠, 현재 페이지 번호, 페이지 크기, 전체 요소 수, 전체 페이지 수를 포함한다.</p>
+ * <p>페이지 콘텐츠, 현재 페이지 번호, 페이지 크기, 전체 요소 수, 전체 페이지 수를 포함한다.
+ * Spring Data 타입에 의존하지 않는다.</p>
  *
- * @param content 현재 페이지의 콘텐츠 목록
- * @param page 현재 페이지 번호 (0부터 시작)
- * @param size 페이지 크기
+ * @param content       현재 페이지의 콘텐츠 목록
+ * @param page          현재 페이지 번호 (0부터 시작)
+ * @param size          페이지 크기
  * @param totalElements 전체 요소 수
- * @param totalPages 전체 페이지 수
- * @param <T> 콘텐츠 요소 타입
+ * @param totalPages    전체 페이지 수
+ * @param <T>           콘텐츠 요소 타입
  */
 public record PageResponse<T>(
         List<T> content,
@@ -24,20 +22,4 @@ public record PageResponse<T>(
         long totalElements,
         int totalPages
 ) {
-    /**
-     * Spring Data {@link Page} 객체를 {@link PageResponse}로 변환하는 팩토리 메서드.
-     *
-     * @param page 변환할 Spring Data Page 객체
-     * @param <T> 콘텐츠 요소 타입
-     * @return 변환된 PageResponse
-     */
-    public static <T> PageResponse<T> from(Page<T> page) {
-        return new PageResponse<>(
-                page.getContent(),
-                page.getNumber(),
-                page.getSize(),
-                page.getTotalElements(),
-                page.getTotalPages()
-        );
-    }
 }
diff --git a/apps/commerce-api/src/main/java/com/loopers/interfaces/api/brand/BrandV1Controller.java b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/brand/BrandV1Controller.java
index 5559c11c2..801d8ec18 100644
--- a/apps/commerce-api/src/main/java/com/loopers/interfaces/api/brand/BrandV1Controller.java
+++ b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/brand/BrandV1Controller.java
@@ -1,7 +1,7 @@
 package com.loopers.interfaces.api.brand;
 
-import com.loopers.application.brand.BrandInfo;
-import com.loopers.application.brand.BrandAppService;
+import com.loopers.domain.brand.BrandModel;
+import com.loopers.domain.brand.BrandService;
 import com.loopers.interfaces.api.ApiResponse;
 import lombok.RequiredArgsConstructor;
 import org.springframework.http.ResponseEntity;
@@ -13,14 +13,14 @@
  * 브랜드 고객 API V1 REST 엔드포인트를 제공하는 컨트롤러.
  *
  * <p>활성 상태의 브랜드 목록 조회 및 브랜드 상세 조회 기능을 제공한다.
- * {@link BrandAppService}를 호출한다.</p>
+ * {@link BrandService}를 직접 호출한다.</p>
  */
 @RestController
 @RequestMapping("/api/v1/brands")
 @RequiredArgsConstructor
 public class BrandV1Controller {
 
-    private final BrandAppService brandAppService;
+    private final BrandService brandService;
 
     /**
      * 활성 브랜드 목록을 조회한다.
@@ -31,7 +31,7 @@ public class BrandV1Controller {
     @GetMapping
     public ResponseEntity<ApiResponse<List<BrandV1Dto.BrandResponse>>> list(
             @RequestParam(value = "q", required = false) String keyword) {
-        List<BrandInfo> brands = brandAppService.findAllVisibleBrands(keyword);
+        List<BrandModel> brands = brandService.findAllVisibleBrands(keyword);
         List<BrandV1Dto.BrandResponse> response = brands.stream()
                 .map(BrandV1Dto.BrandResponse::from)
                 .toList();
@@ -45,8 +45,8 @@ public ResponseEntity<ApiResponse<List<BrandV1Dto.BrandResponse>>> list(
      * @return 브랜드 상세 정보 응답
      */
     @GetMapping("/{brandId}")
-    public ResponseEntity<ApiResponse<BrandV1Dto.BrandResponse>> detail(@PathVariable String brandId) {
-        BrandInfo info = brandAppService.findVisibleById(brandId);
-        return ResponseEntity.ok(ApiResponse.success(BrandV1Dto.BrandResponse.from(info)));
+    public ResponseEntity<ApiResponse<BrandV1Dto.BrandResponse>> detail(@PathVariable Long brandId) {
+        BrandModel brand = brandService.findVisibleById(brandId);
+        return ResponseEntity.ok(ApiResponse.success(BrandV1Dto.BrandResponse.from(brand)));
     }
 }
diff --git a/apps/commerce-api/src/main/java/com/loopers/interfaces/api/brand/BrandV1Dto.java b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/brand/BrandV1Dto.java
index ae239e2d4..acf036d41 100644
--- a/apps/commerce-api/src/main/java/com/loopers/interfaces/api/brand/BrandV1Dto.java
+++ b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/brand/BrandV1Dto.java
@@ -1,6 +1,6 @@
 package com.loopers.interfaces.api.brand;
 
-import com.loopers.application.brand.BrandInfo;
+import com.loopers.domain.brand.BrandModel;
 import lombok.AllArgsConstructor;
 import lombok.Builder;
 import lombok.Getter;
@@ -21,25 +21,25 @@ public class BrandV1Dto {
     @AllArgsConstructor
     @Builder
     public static class BrandResponse {
-        private String brandId;
+        private Long brandId;
         private String brandName;
         private String description;
         private String address;
         private String attachFile;
 
         /**
-         * {@link BrandInfo}를 브랜드 응답 DTO로 변환하는 팩토리 메서드.
+         * {@link BrandModel}을 브랜드 응답 DTO로 변환하는 팩토리 메서드.
          *
-         * @param info 변환할 브랜드 도메인 Info 객체
+         * @param model 변환할 브랜드 도메인 모델
          * @return 변환된 BrandResponse
          */
-        public static BrandResponse from(BrandInfo info) {
+        public static BrandResponse from(BrandModel model) {
             return BrandResponse.builder()
-                    .brandId(info.getBrandId())
-                    .brandName(info.getBrandName())
-                    .description(info.getDescription())
-                    .address(info.getAddress())
-                    .attachFile(info.getAttachFile())
+                    .brandId(model.getBrandId())
+                    .brandName(model.getBrandName())
+                    .description(model.getDescription())
+                    .address(model.getAddress())
+                    .attachFile(model.getAttachFile())
                     .build();
         }
     }
diff --git a/apps/commerce-api/src/main/java/com/loopers/interfaces/api/cart/CartV1Controller.java b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/cart/CartV1Controller.java
index 9a74cc953..931032561 100644
--- a/apps/commerce-api/src/main/java/com/loopers/interfaces/api/cart/CartV1Controller.java
+++ b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/cart/CartV1Controller.java
@@ -1,9 +1,10 @@
 package com.loopers.interfaces.api.cart;
 
-import com.loopers.application.cart.CartAppService;
 import com.loopers.application.cart.CartFacade;
 import com.loopers.application.cart.CartInfo;
+import com.loopers.domain.user.UserModel;
 import com.loopers.interfaces.api.ApiResponse;
+import com.loopers.interfaces.api.AuthUser;
 import jakarta.validation.Valid;
 import lombok.RequiredArgsConstructor;
 import org.springframework.http.ResponseEntity;
@@ -15,7 +16,8 @@
  * 장바구니 고객 API V1 REST 엔드포인트를 제공하는 컨트롤러.
  *
  * <p>장바구니 조회, 상품 추가, 수량 변경, 상품 삭제 기능을 제공한다.
- * 복잡한 도메인으로 {@link CartFacade}를 통해 여러 서비스를 조합하여 처리한다.</p>
+ * 복잡한 도메인으로 {@link CartFacade}를 통해 여러 서비스를 조합하여 처리한다.
+ * 모든 처리는 {@link CartFacade}를 통해 위임한다.</p>
  */
 @RestController
 @RequestMapping("/api/v1/cart")
@@ -23,20 +25,16 @@
 public class CartV1Controller {
 
     private final CartFacade cartFacade;
-    private final CartAppService cartAppService;
 
     /**
      * 장바구니 항목 목록을 조회한다.
      *
-     * @param loginId 로그인 ID (인증 헤더)
-     * @param loginPw 비밀번호 (인증 헤더)
+     * @param user 인증된 사용자 (인터셉터에서 주입)
      * @return 장바구니 항목 목록 응답 (주문 가능 여부 포함)
      */
     @GetMapping
-    public ResponseEntity<ApiResponse<List<CartV1Dto.CartItemResponse>>> getCart(
-            @RequestHeader("X-Loopers-LoginId") String loginId,
-            @RequestHeader("X-Loopers-LoginPw") String loginPw) {
-        List<CartInfo> cart = cartFacade.getCart(loginId, loginPw);
+    public ResponseEntity<ApiResponse<List<CartV1Dto.CartItemResponse>>> getCart(@AuthUser UserModel user) {
+        List<CartInfo> cart = cartFacade.getCart(user.getUserId());
         List<CartV1Dto.CartItemResponse> response = cart.stream()
                 .map(CartV1Dto.CartItemResponse::from)
                 .toList();
@@ -46,53 +44,47 @@ public ResponseEntity<ApiResponse<List<CartV1Dto.CartItemResponse>>> getCart(
     /**
      * 장바구니에 상품을 추가한다.
      *
-     * @param loginId 로그인 ID (인증 헤더)
-     * @param loginPw 비밀번호 (인증 헤더)
+     * @param user 인증된 사용자 (인터셉터에서 주입)
      * @param request 상품 추가 요청 (상품 ID, 수량)
      * @return 성공 응답
      */
     @PostMapping("/items")
     public ResponseEntity<ApiResponse<Object>> addItem(
-            @RequestHeader("X-Loopers-LoginId") String loginId,
-            @RequestHeader("X-Loopers-LoginPw") String loginPw,
+            @AuthUser UserModel user,
             @Valid @RequestBody CartV1Dto.AddItemRequest request) {
-        cartFacade.addItem(loginId, loginPw, request.getProductId(), request.getQuantity());
+        cartFacade.addItem(user.getUserId(), request.getProductId(), request.getQuantity());
         return ResponseEntity.ok(ApiResponse.success());
     }
 
     /**
      * 장바구니 항목의 수량을 변경한다.
      *
-     * @param loginId 로그인 ID (인증 헤더)
-     * @param loginPw 비밀번호 (인증 헤더)
+     * @param user 인증된 사용자 (인터셉터에서 주입)
      * @param productId 수량을 변경할 상품 ID
      * @param request 수량 변경 요청 (새 수량)
      * @return 성공 응답
      */
     @PatchMapping("/items/{productId}")
     public ResponseEntity<ApiResponse<Object>> changeQuantity(
-            @RequestHeader("X-Loopers-LoginId") String loginId,
-            @RequestHeader("X-Loopers-LoginPw") String loginPw,
-            @PathVariable String productId,
+            @AuthUser UserModel user,
+            @PathVariable Long productId,
             @Valid @RequestBody CartV1Dto.ChangeQtyRequest request) {
-        cartFacade.changeQuantity(loginId, loginPw, productId, request.getQuantity());
+        cartFacade.changeQuantity(user.getUserId(), productId, request.getQuantity());
         return ResponseEntity.ok(ApiResponse.success());
     }
 
     /**
      * 장바구니에서 상품을 삭제한다.
      *
-     * @param loginId 로그인 ID (인증 헤더)
-     * @param loginPw 비밀번호 (인증 헤더)
+     * @param user 인증된 사용자 (인터셉터에서 주입)
      * @param productId 삭제할 상품 ID
      * @return 성공 응답
      */
     @DeleteMapping("/items/{productId}")
     public ResponseEntity<ApiResponse<Object>> removeItem(
-            @RequestHeader("X-Loopers-LoginId") String loginId,
-            @RequestHeader("X-Loopers-LoginPw") String loginPw,
-            @PathVariable String productId) {
-        cartAppService.removeItem(loginId, loginPw, productId);
+            @AuthUser UserModel user,
+            @PathVariable Long productId) {
+        cartFacade.removeItem(user.getUserId(), productId);
         return ResponseEntity.ok(ApiResponse.success());
     }
 }
diff --git a/apps/commerce-api/src/main/java/com/loopers/interfaces/api/cart/CartV1Dto.java b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/cart/CartV1Dto.java
index 7ee70d252..f141a6aef 100644
--- a/apps/commerce-api/src/main/java/com/loopers/interfaces/api/cart/CartV1Dto.java
+++ b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/cart/CartV1Dto.java
@@ -3,7 +3,6 @@
 import com.loopers.application.cart.CartInfo;
 import com.loopers.support.enums.UnavailableReason;
 import jakarta.validation.constraints.Min;
-import jakarta.validation.constraints.NotBlank;
 import lombok.AllArgsConstructor;
 import lombok.Builder;
 import lombok.Getter;
@@ -28,8 +27,7 @@ public class CartV1Dto {
     @AllArgsConstructor
     @Builder
     public static class AddItemRequest {
-        @NotBlank(message = "상품 ID는 필수입니다")
-        private String productId;
+        private Long productId;
         @Min(value = 1, message = "수량은 1 이상이어야 합니다")
         private int quantity;
     }
@@ -57,7 +55,7 @@ public static class ChangeQtyRequest {
     @AllArgsConstructor
     @Builder
     public static class CartItemResponse {
-        private String productId;
+        private Long productId;
         private String productName;
         private BigDecimal price;
         private String brandName;
diff --git a/apps/commerce-api/src/main/java/com/loopers/interfaces/api/coupon/CouponV1Controller.java b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/coupon/CouponV1Controller.java
new file mode 100644
index 000000000..8777705a1
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/coupon/CouponV1Controller.java
@@ -0,0 +1,69 @@
+package com.loopers.interfaces.api.coupon;
+
+import com.loopers.domain.coupon.CouponModel;
+import com.loopers.domain.coupon.CouponService;
+import com.loopers.domain.coupon.UserCouponModel;
+import com.loopers.domain.user.UserModel;
+import com.loopers.interfaces.api.ApiResponse;
+import com.loopers.interfaces.api.AuthUser;
+import lombok.RequiredArgsConstructor;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+import java.util.List;
+import java.util.Map;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
+/**
+ * 쿠폰 고객 API V1 컨트롤러.
+ */
+@RestController
+@RequestMapping("/api/v1")
+@RequiredArgsConstructor
+public class CouponV1Controller {
+
+    private final CouponService couponService;
+
+    /**
+     * 쿠폰을 발급한다.
+     *
+     * @param user     인증된 사용자
+     * @param couponId 쿠폰 템플릿 ID
+     * @return 발급된 쿠폰 정보 (HTTP 200)
+     */
+    @PostMapping("/coupons/{couponId}/issue")
+    public ResponseEntity<ApiResponse<CouponV1Dto.UserCouponResponse>> issueCoupon(
+            @AuthUser UserModel user,
+            @PathVariable Long couponId) {
+        UserCouponModel userCoupon = couponService.issueCoupon(user.getUserId(), couponId);
+        CouponModel coupon = couponService.findByIdForAdmin(couponId);
+        return ResponseEntity.ok(ApiResponse.success(CouponV1Dto.UserCouponResponse.from(userCoupon, coupon)));
+    }
+
+    /**
+     * 내 쿠폰 목록을 조회한다.
+     *
+     * @param user 인증된 사용자
+     * @return 발급된 쿠폰 목록 (HTTP 200)
+     */
+    @GetMapping("/users/me/coupons")
+    public ResponseEntity<ApiResponse<List<CouponV1Dto.UserCouponResponse>>> getMyCoupons(
+            @AuthUser UserModel user) {
+        List<UserCouponModel> userCoupons = couponService.findMyCoupons(user.getUserId());
+
+        List<Long> couponIds = userCoupons.stream().map(UserCouponModel::getCouponId).toList();
+        Map<Long, CouponModel> couponMap = couponService.findAllByIds(couponIds).stream()
+                .collect(Collectors.toMap(CouponModel::getCouponId, Function.identity()));
+
+        List<CouponV1Dto.UserCouponResponse> response = userCoupons.stream()
+                .filter(uc -> couponMap.containsKey(uc.getCouponId()))
+                .map(uc -> CouponV1Dto.UserCouponResponse.from(uc, couponMap.get(uc.getCouponId())))
+                .toList();
+        return ResponseEntity.ok(ApiResponse.success(response));
+    }
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/interfaces/api/coupon/CouponV1Dto.java b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/coupon/CouponV1Dto.java
new file mode 100644
index 000000000..a9d7f87be
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/coupon/CouponV1Dto.java
@@ -0,0 +1,55 @@
+package com.loopers.interfaces.api.coupon;
+
+import com.loopers.domain.coupon.CouponModel;
+import com.loopers.domain.coupon.UserCouponModel;
+import com.loopers.support.enums.DiscountType;
+import com.loopers.support.enums.UserCouponStatus;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Getter;
+
+import java.math.BigDecimal;
+import java.time.LocalDateTime;
+
+/**
+ * 쿠폰 고객 API V1 요청/응답 DTO 모음.
+ */
+public class CouponV1Dto {
+
+    /**
+     * 발급된 쿠폰 응답 DTO.
+     */
+    @Getter
+    @AllArgsConstructor
+    @Builder
+    public static class UserCouponResponse {
+        private Long userCouponId;
+        private Long couponId;
+        private String couponName;
+        private DiscountType discountType;
+        private BigDecimal discountValue;
+        private BigDecimal minOrderAmount;
+        private LocalDateTime expiredAt;
+        private UserCouponStatus status;
+        private LocalDateTime issuedAt;
+        private LocalDateTime usedAt;
+
+        /**
+         * UserCouponModel과 CouponModel로부터 응답 DTO를 생성한다.
+         */
+        public static UserCouponResponse from(UserCouponModel userCoupon, CouponModel coupon) {
+            return UserCouponResponse.builder()
+                    .userCouponId(userCoupon.getUserCouponId())
+                    .couponId(coupon.getCouponId())
+                    .couponName(coupon.getName())
+                    .discountType(coupon.getDiscountType())
+                    .discountValue(coupon.getDiscountValue())
+                    .minOrderAmount(coupon.getMinOrderAmount())
+                    .expiredAt(coupon.getExpiredAt())
+                    .status(userCoupon.getStatus())
+                    .issuedAt(userCoupon.getIssuedAt())
+                    .usedAt(userCoupon.getUsedAt())
+                    .build();
+        }
+    }
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/interfaces/api/like/LikeV1Controller.java b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/like/LikeV1Controller.java
index 35ee18cc8..76319ac0e 100644
--- a/apps/commerce-api/src/main/java/com/loopers/interfaces/api/like/LikeV1Controller.java
+++ b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/like/LikeV1Controller.java
@@ -1,8 +1,10 @@
 package com.loopers.interfaces.api.like;
 
-import com.loopers.application.like.LikeInfo;
-import com.loopers.application.like.LikeAppService;
+import com.loopers.domain.like.LikeModel;
+import com.loopers.domain.like.LikeService;
+import com.loopers.domain.user.UserModel;
 import com.loopers.interfaces.api.ApiResponse;
+import com.loopers.interfaces.api.AuthUser;
 import lombok.RequiredArgsConstructor;
 import org.springframework.http.ResponseEntity;
 import org.springframework.web.bind.annotation.*;
@@ -13,31 +15,29 @@
  * 좋아요 고객 API V1 REST 엔드포인트를 제공하는 컨트롤러.
  *
  * <p>상품 좋아요 등록, 취소 및 내 좋아요 목록 조회 기능을 제공한다.
- * {@link LikeAppService}를 호출한다.
+ * {@link LikeService}를 직접 호출한다.
  * 좋아요 등록/취소는 멱등성을 보장한다.</p>
  */
 @RestController
 @RequiredArgsConstructor
 public class LikeV1Controller {
 
-    private final LikeAppService likeAppService;
+    private final LikeService likeService;
 
     /**
      * 상품에 좋아요를 등록한다.
      *
      * <p>이미 좋아요가 등록된 경우 멱등하게 처리한다.</p>
      *
-     * @param loginId 로그인 ID (인증 헤더)
-     * @param loginPw 비밀번호 (인증 헤더)
+     * @param user 인증된 사용자 (인터셉터에서 주입)
      * @param productId 좋아요를 등록할 상품 ID
      * @return 성공 응답
      */
     @PostMapping("/api/v1/products/{productId}/likes")
     public ResponseEntity<ApiResponse<Object>> addLike(
-            @RequestHeader("X-Loopers-LoginId") String loginId,
-            @RequestHeader("X-Loopers-LoginPw") String loginPw,
-            @PathVariable String productId) {
-        likeAppService.addLike(loginId, loginPw, productId);
+            @AuthUser UserModel user,
+            @PathVariable Long productId) {
+        likeService.addLike(user.getUserId(), productId);
         return ResponseEntity.ok(ApiResponse.success());
     }
 
@@ -46,32 +46,27 @@ public ResponseEntity<ApiResponse<Object>> addLike(
      *
      * <p>이미 취소된 경우 멱등하게 처리한다.</p>
      *
-     * @param loginId 로그인 ID (인증 헤더)
-     * @param loginPw 비밀번호 (인증 헤더)
+     * @param user 인증된 사용자 (인터셉터에서 주입)
      * @param productId 좋아요를 취소할 상품 ID
      * @return 성공 응답
      */
     @DeleteMapping("/api/v1/products/{productId}/likes")
     public ResponseEntity<ApiResponse<Object>> removeLike(
-            @RequestHeader("X-Loopers-LoginId") String loginId,
-            @RequestHeader("X-Loopers-LoginPw") String loginPw,
-            @PathVariable String productId) {
-        likeAppService.removeLike(loginId, loginPw, productId);
+            @AuthUser UserModel user,
+            @PathVariable Long productId) {
+        likeService.removeLike(user.getUserId(), productId);
         return ResponseEntity.ok(ApiResponse.success());
     }
 
     /**
      * 내 좋아요 목록을 조회한다.
      *
-     * @param loginId 로그인 ID (인증 헤더)
-     * @param loginPw 비밀번호 (인증 헤더)
+     * @param user 인증된 사용자 (인터셉터에서 주입)
      * @return 좋아요 목록 응답
      */
     @GetMapping("/api/v1/users/me/likes")
-    public ResponseEntity<ApiResponse<List<LikeV1Dto.LikeResponse>>> getMyLikes(
-            @RequestHeader("X-Loopers-LoginId") String loginId,
-            @RequestHeader("X-Loopers-LoginPw") String loginPw) {
-        List<LikeInfo> likes = likeAppService.getMyLikes(loginId, loginPw);
+    public ResponseEntity<ApiResponse<List<LikeV1Dto.LikeResponse>>> getMyLikes(@AuthUser UserModel user) {
+        List<LikeModel> likes = likeService.getMyLikes(user.getUserId());
         List<LikeV1Dto.LikeResponse> response = likes.stream()
                 .map(LikeV1Dto.LikeResponse::from)
                 .toList();
diff --git a/apps/commerce-api/src/main/java/com/loopers/interfaces/api/like/LikeV1Dto.java b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/like/LikeV1Dto.java
index 3a08c41ea..d6f7f6d24 100644
--- a/apps/commerce-api/src/main/java/com/loopers/interfaces/api/like/LikeV1Dto.java
+++ b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/like/LikeV1Dto.java
@@ -1,6 +1,6 @@
 package com.loopers.interfaces.api.like;
 
-import com.loopers.application.like.LikeInfo;
+import com.loopers.domain.like.LikeModel;
 import lombok.AllArgsConstructor;
 import lombok.Builder;
 import lombok.Getter;
@@ -23,19 +23,19 @@ public class LikeV1Dto {
     @AllArgsConstructor
     @Builder
     public static class LikeResponse {
-        private String productId;
+        private Long productId;
         private LocalDateTime createdAt;
 
         /**
-         * {@link LikeInfo}를 좋아요 응답 DTO로 변환하는 팩토리 메서드.
+         * {@link LikeModel}을 좋아요 응답 DTO로 변환하는 팩토리 메서드.
          *
-         * @param info 변환할 좋아요 도메인 Info 객체
+         * @param model 변환할 좋아요 도메인 모델
          * @return 변환된 LikeResponse
          */
-        public static LikeResponse from(LikeInfo info) {
+        public static LikeResponse from(LikeModel model) {
             return LikeResponse.builder()
-                    .productId(info.getProductId())
-                    .createdAt(info.getCreatedAt())
+                    .productId(model.getProductId())
+                    .createdAt(model.getCreatedAt())
                     .build();
         }
     }
diff --git a/apps/commerce-api/src/main/java/com/loopers/interfaces/api/order/OrderV1Controller.java b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/order/OrderV1Controller.java
index 8caf654c2..145384fd1 100644
--- a/apps/commerce-api/src/main/java/com/loopers/interfaces/api/order/OrderV1Controller.java
+++ b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/order/OrderV1Controller.java
@@ -1,9 +1,10 @@
 package com.loopers.interfaces.api.order;
 
-import com.loopers.application.order.OrderAppService;
 import com.loopers.application.order.OrderFacade;
 import com.loopers.application.order.OrderInfo;
+import com.loopers.domain.user.UserModel;
 import com.loopers.interfaces.api.ApiResponse;
+import com.loopers.interfaces.api.AuthUser;
 import jakarta.validation.Valid;
 import lombok.RequiredArgsConstructor;
 import org.springframework.format.annotation.DateTimeFormat;
@@ -19,7 +20,8 @@
  *
  * <p>직접 주문 생성, 장바구니 주문 생성, 주문 목록 조회, 주문 상세 조회,
  * 주문 취소 기능을 제공한다. 복잡한 도메인으로 {@link OrderFacade}를 통해
- * 여러 서비스(주문, 재고, 장바구니 등)를 조합하여 처리한다.</p>
+ * 여러 서비스(주문, 재고, 장바구니 등)를 조합하여 처리한다.
+ * 모든 처리는 {@link OrderFacade}를 통해 위임한다.</p>
  */
 @RestController
 @RequestMapping("/api/v1/orders")
@@ -27,24 +29,21 @@
 public class OrderV1Controller {
 
     private final OrderFacade orderFacade;
-    private final OrderAppService orderAppService;
 
     /**
      * 직접(DIRECT) 주문을 생성한다.
      *
      * <p>상품을 장바구니에 담지 않고 바로 주문한다. CAS 재고 예약이 수행된다.</p>
      *
-     * @param loginId 로그인 ID (인증 헤더)
-     * @param loginPw 비밀번호 (인증 헤더)
+     * @param user    인증된 사용자 (인터셉터에서 주입)
      * @param request 직접 주문 생성 요청 (주문 항목 목록)
      * @return 생성된 주문 상세 정보 (HTTP 201)
      */
     @PostMapping
     public ResponseEntity<ApiResponse<OrderV1Dto.OrderDetailResponse>> createDirectOrder(
-            @RequestHeader("X-Loopers-LoginId") String loginId,
-            @RequestHeader("X-Loopers-LoginPw") String loginPw,
+            @AuthUser UserModel user,
             @Valid @RequestBody OrderV1Dto.CreateDirectOrderRequest request) {
-        OrderInfo info = orderFacade.createDirectOrder(loginId, loginPw, request.toItems());
+        OrderInfo info = orderFacade.createDirectOrder(user.getUserId(), request.toItems(), request.getCouponId());
         return ResponseEntity.status(201).body(ApiResponse.success(OrderV1Dto.OrderDetailResponse.from(info)));
     }
 
@@ -53,17 +52,15 @@ public ResponseEntity<ApiResponse<OrderV1Dto.OrderDetailResponse>> createDirectO
      *
      * <p>장바구니에 담긴 상품들로 주문을 생성한다. CAS 재고 예약이 수행된다.</p>
      *
-     * @param loginId 로그인 ID (인증 헤더)
-     * @param loginPw 비밀번호 (인증 헤더)
+     * @param user    인증된 사용자 (인터셉터에서 주입)
      * @param request 장바구니 주문 생성 요청 (주문 항목 목록)
      * @return 생성된 주문 상세 정보 (HTTP 201)
      */
     @PostMapping("/cart")
     public ResponseEntity<ApiResponse<OrderV1Dto.OrderDetailResponse>> createCartOrder(
-            @RequestHeader("X-Loopers-LoginId") String loginId,
-            @RequestHeader("X-Loopers-LoginPw") String loginPw,
+            @AuthUser UserModel user,
             @Valid @RequestBody OrderV1Dto.CreateCartOrderRequest request) {
-        OrderInfo info = orderFacade.createCartOrder(loginId, loginPw, request.toItems());
+        OrderInfo info = orderFacade.createCartOrder(user.getUserId(), request.toItems(), request.getCouponId());
         return ResponseEntity.status(201).body(ApiResponse.success(OrderV1Dto.OrderDetailResponse.from(info)));
     }
 
@@ -72,24 +69,21 @@ public ResponseEntity<ApiResponse<OrderV1Dto.OrderDetailResponse>> createCartOrd
      *
      * <p>조회 기간을 지정하지 않으면 최근 1개월 주문을 조회한다.</p>
      *
-     * @param loginId 로그인 ID (인증 헤더)
-     * @param loginPw 비밀번호 (인증 헤더)
+     * @param user    인증된 사용자 (인터셉터에서 주입)
      * @param startAt 조회 시작 날짜 (선택, 기본값: 1개월 전)
-     * @param endAt 조회 종료 날짜 (선택, 기본값: 오늘)
+     * @param endAt   조회 종료 날짜 (선택, 기본값: 오늘)
      * @return 주문 목록 응답
      */
     @GetMapping
     public ResponseEntity<ApiResponse<List<OrderV1Dto.OrderResponse>>> getOrders(
-            @RequestHeader("X-Loopers-LoginId") String loginId,
-            @RequestHeader("X-Loopers-LoginPw") String loginPw,
+            @AuthUser UserModel user,
             @RequestParam(value = "startAt", required = false) @DateTimeFormat(iso = DateTimeFormat.ISO.DATE) LocalDate startAt,
             @RequestParam(value = "endAt", required = false) @DateTimeFormat(iso = DateTimeFormat.ISO.DATE) LocalDate endAt) {
         LocalDate now = LocalDate.now();
         LocalDateTime start = (startAt != null ? startAt : now.minusMonths(1)).atStartOfDay();
         LocalDateTime end = (endAt != null ? endAt : now).plusDays(1).atStartOfDay();
 
-        List<OrderInfo> orders = orderAppService.getOrders(loginId, loginPw, start, end);
-        List<OrderV1Dto.OrderResponse> response = orders.stream()
+        List<OrderV1Dto.OrderResponse> response = orderFacade.getOrders(user.getUserId(), start, end).stream()
                 .map(OrderV1Dto.OrderResponse::from)
                 .toList();
         return ResponseEntity.ok(ApiResponse.success(response));
@@ -98,17 +92,15 @@ public ResponseEntity<ApiResponse<List<OrderV1Dto.OrderResponse>>> getOrders(
     /**
      * 주문 상세 정보를 조회한다.
      *
-     * @param loginId 로그인 ID (인증 헤더)
-     * @param loginPw 비밀번호 (인증 헤더)
+     * @param user    인증된 사용자 (인터셉터에서 주입)
      * @param orderId 조회할 주문 ID
      * @return 주문 상세 정보 응답 (주문 항목 포함)
      */
     @GetMapping("/{orderId}")
     public ResponseEntity<ApiResponse<OrderV1Dto.OrderDetailResponse>> getOrderDetail(
-            @RequestHeader("X-Loopers-LoginId") String loginId,
-            @RequestHeader("X-Loopers-LoginPw") String loginPw,
-            @PathVariable String orderId) {
-        OrderInfo info = orderAppService.getOrderDetail(loginId, loginPw, orderId);
+            @AuthUser UserModel user,
+            @PathVariable Long orderId) {
+        OrderInfo info = orderFacade.getOrderDetail(user.getUserId(), orderId);
         return ResponseEntity.ok(ApiResponse.success(OrderV1Dto.OrderDetailResponse.from(info)));
     }
 
@@ -118,17 +110,15 @@ public ResponseEntity<ApiResponse<OrderV1Dto.OrderDetailResponse>> getOrderDetai
      * <p>PENDING_PAYMENT 상태의 주문만 취소 가능하다.
      * 취소 시 CAS 재고 해제 및 장바구니 복원(DIRECT 주문의 경우)이 수행된다.</p>
      *
-     * @param loginId 로그인 ID (인증 헤더)
-     * @param loginPw 비밀번호 (인증 헤더)
+     * @param user    인증된 사용자 (인터셉터에서 주입)
      * @param orderId 취소할 주문 ID
      * @return 성공 응답
      */
     @PostMapping("/{orderId}/cancel")
     public ResponseEntity<ApiResponse<Object>> cancelOrder(
-            @RequestHeader("X-Loopers-LoginId") String loginId,
-            @RequestHeader("X-Loopers-LoginPw") String loginPw,
-            @PathVariable String orderId) {
-        orderFacade.cancelOrder(loginId, loginPw, orderId);
+            @AuthUser UserModel user,
+            @PathVariable Long orderId) {
+        orderFacade.cancelOrder(user.getUserId(), orderId);
         return ResponseEntity.ok(ApiResponse.success());
     }
 }
diff --git a/apps/commerce-api/src/main/java/com/loopers/interfaces/api/order/OrderV1Dto.java b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/order/OrderV1Dto.java
index adb90a6b5..747de2ae7 100644
--- a/apps/commerce-api/src/main/java/com/loopers/interfaces/api/order/OrderV1Dto.java
+++ b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/order/OrderV1Dto.java
@@ -6,7 +6,6 @@
 import com.loopers.support.enums.OrderType;
 import jakarta.validation.Valid;
 import jakarta.validation.constraints.Min;
-import jakarta.validation.constraints.NotBlank;
 import jakarta.validation.constraints.NotEmpty;
 import lombok.AllArgsConstructor;
 import lombok.Builder;
@@ -19,15 +18,11 @@
 
 /**
  * 주문 API V1 요청/응답 DTO 모음.
- *
- * <p>주문 관련 REST API의 HTTP 요청 및 응답 데이터 구조를 정의한다.</p>
  */
 public class OrderV1Dto {
 
     /**
      * 직접(DIRECT) 주문 생성 요청 DTO.
-     *
-     * <p>장바구니를 거치지 않고 직접 주문할 상품 항목 목록을 포함한다.</p>
      */
     @Getter
     @NoArgsConstructor
@@ -38,11 +33,8 @@ public static class CreateDirectOrderRequest {
         @Valid
         private List<OrderItemDto> items;
 
-        /**
-         * 요청 DTO의 주문 항목을 도메인 서비스 파라미터 형식으로 변환한다.
-         *
-         * @return 변환된 {@link OrderItemRequest} 목록
-         */
+        private Long couponId;  // 발급된 쿠폰 ID (user_coupon_id), nullable
+
         public List<OrderItemCommand> toItems() {
             return items.stream()
                     .map(item -> new OrderItemCommand(item.getProductId(), item.getQuantity()))
@@ -52,8 +44,6 @@ public List<OrderItemCommand> toItems() {
 
     /**
      * 장바구니(CART) 주문 생성 요청 DTO.
-     *
-     * <p>장바구니에 담긴 상품 중 주문할 항목 목록을 포함한다.</p>
      */
     @Getter
     @NoArgsConstructor
@@ -64,11 +54,8 @@ public static class CreateCartOrderRequest {
         @Valid
         private List<OrderItemDto> items;
 
-        /**
-         * 요청 DTO의 주문 항목을 도메인 서비스 파라미터 형식으로 변환한다.
-         *
-         * @return 변환된 {@link OrderItemRequest} 목록
-         */
+        private Long couponId;  // 발급된 쿠폰 ID (user_coupon_id), nullable
+
         public List<OrderItemCommand> toItems() {
             return items.stream()
                     .map(item -> new OrderItemCommand(item.getProductId(), item.getQuantity()))
@@ -78,41 +65,30 @@ public List<OrderItemCommand> toItems() {
 
     /**
      * 주문 항목 요청 DTO.
-     *
-     * <p>주문할 상품 ID와 수량을 포함한다.</p>
      */
     @Getter
     @NoArgsConstructor
     @AllArgsConstructor
     @Builder
     public static class OrderItemDto {
-        @NotBlank(message = "상품 ID는 필수입니다")
-        private String productId;
+        private Long productId;
         @Min(value = 1, message = "수량은 1 이상이어야 합니다")
         private int quantity;
     }
 
     /**
      * 주문 목록 조회 응답 DTO.
-     *
-     * <p>주문 ID, 주문 유형, 상태, 총 금액, 만료 일시를 포함한다.</p>
      */
     @Getter
     @AllArgsConstructor
     @Builder
     public static class OrderResponse {
-        private String orderId;
+        private Long orderId;
         private OrderType orderType;
         private OrderStatus status;
         private BigDecimal totalAmount;
         private LocalDateTime expiresAt;
 
-        /**
-         * {@link OrderInfo}를 주문 목록 응답 DTO로 변환하는 팩토리 메서드.
-         *
-         * @param info 변환할 주문 도메인 Info 객체
-         * @return 변환된 OrderResponse
-         */
         public static OrderResponse from(OrderInfo info) {
             return OrderResponse.builder()
                     .orderId(info.getOrderId())
@@ -126,26 +102,18 @@ public static OrderResponse from(OrderInfo info) {
 
     /**
      * 주문 상세 조회 응답 DTO.
-     *
-     * <p>주문 기본 정보와 함께 주문 항목 목록을 포함한다.</p>
      */
     @Getter
     @AllArgsConstructor
     @Builder
     public static class OrderDetailResponse {
-        private String orderId;
+        private Long orderId;
         private OrderType orderType;
         private OrderStatus status;
         private BigDecimal totalAmount;
         private LocalDateTime expiresAt;
         private List<OrderItemResponse> items;
 
-        /**
-         * {@link OrderInfo}를 주문 상세 응답 DTO로 변환하는 팩토리 메서드.
-         *
-         * @param info 변환할 주문 도메인 Info 객체
-         * @return 변환된 OrderDetailResponse (주문 항목 포함)
-         */
         public static OrderDetailResponse from(OrderInfo info) {
             return OrderDetailResponse.builder()
                     .orderId(info.getOrderId())
@@ -161,27 +129,22 @@ public static OrderDetailResponse from(OrderInfo info) {
     }
 
     /**
-     * 주문 항목 응답 DTO.
-     *
-     * <p>주문 시점의 상품 스냅샷 정보(상품명, 단가, 브랜드명, 이미지 URL)를 포함한다.</p>
+     * 주문 항목 응답 DTO (할인 금액 필드 포함).
      */
     @Getter
     @AllArgsConstructor
     @Builder
     public static class OrderItemResponse {
-        private String productId;
+        private Long productId;
         private int quantity;
         private String snapshotProductName;
         private BigDecimal snapshotUnitPrice;
         private String snapshotBrandName;
         private String snapshotImageUrl;
+        private BigDecimal originalAmount;
+        private BigDecimal discountAmount;
+        private BigDecimal finalAmount;
 
-        /**
-         * {@link OrderInfo.OrderItemInfo}를 주문 항목 응답 DTO로 변환하는 팩토리 메서드.
-         *
-         * @param item 변환할 주문 항목 도메인 Info 객체
-         * @return 변환된 OrderItemResponse
-         */
         public static OrderItemResponse from(OrderInfo.OrderItemInfo item) {
             return OrderItemResponse.builder()
                     .productId(item.getProductId())
@@ -190,6 +153,9 @@ public static OrderItemResponse from(OrderInfo.OrderItemInfo item) {
                     .snapshotUnitPrice(item.getSnapshotUnitPrice())
                     .snapshotBrandName(item.getSnapshotBrandName())
                     .snapshotImageUrl(item.getSnapshotImageUrl())
+                    .originalAmount(item.getOriginalAmount())
+                    .discountAmount(item.getDiscountAmount())
+                    .finalAmount(item.getFinalAmount())
                     .build();
         }
     }
diff --git a/apps/commerce-api/src/main/java/com/loopers/interfaces/api/product/ProductV1Controller.java b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/product/ProductV1Controller.java
index b776a263f..1139c1a9a 100644
--- a/apps/commerce-api/src/main/java/com/loopers/interfaces/api/product/ProductV1Controller.java
+++ b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/product/ProductV1Controller.java
@@ -38,7 +38,7 @@ public class ProductV1Controller {
     @GetMapping
     public ResponseEntity<ApiResponse<PageResponse<ProductV1Dto.ProductResponse>>> list(
             @RequestParam(value = "q", required = false) String keyword,
-            @RequestParam(value = "brandId", required = false) String brandId,
+            @RequestParam(value = "brandId", required = false) Long brandId,
             @RequestParam(value = "sort", defaultValue = "LATEST") ProductSortType sort,
             @RequestParam(value = "page", defaultValue = "0") int page,
             @RequestParam(value = "size", defaultValue = "20") int size) {
@@ -61,7 +61,7 @@ public ResponseEntity<ApiResponse<PageResponse<ProductV1Dto.ProductResponse>>> l
      */
     @GetMapping("/{productId}")
     public ResponseEntity<ApiResponse<ProductV1Dto.ProductDetailResponse>> detail(
-            @PathVariable String productId) {
+            @PathVariable Long productId) {
         ProductInfo info = productFacade.getProductDetailForCustomer(productId);
         return ResponseEntity.ok(ApiResponse.success(ProductV1Dto.ProductDetailResponse.from(info)));
     }
diff --git a/apps/commerce-api/src/main/java/com/loopers/interfaces/api/product/ProductV1Dto.java b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/product/ProductV1Dto.java
index 11cfda081..bab467807 100644
--- a/apps/commerce-api/src/main/java/com/loopers/interfaces/api/product/ProductV1Dto.java
+++ b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/product/ProductV1Dto.java
@@ -23,8 +23,8 @@ public class ProductV1Dto {
     @AllArgsConstructor
     @Builder
     public static class ProductResponse {
-        private String productId;
-        private String brandId;
+        private Long productId;
+        private Long brandId;
         private String brandName;
         private String productName;
         private BigDecimal price;
@@ -61,8 +61,8 @@ public static ProductResponse from(ProductInfo info) {
     @AllArgsConstructor
     @Builder
     public static class ProductDetailResponse {
-        private String productId;
-        private String brandId;
+        private Long productId;
+        private Long brandId;
         private String brandName;
         private String productName;
         private String description;
diff --git a/apps/commerce-api/src/main/java/com/loopers/interfaces/api/user/UserV1Controller.java b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/user/UserV1Controller.java
index 5f3286710..21ab0efc4 100644
--- a/apps/commerce-api/src/main/java/com/loopers/interfaces/api/user/UserV1Controller.java
+++ b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/user/UserV1Controller.java
@@ -1,9 +1,10 @@
 package com.loopers.interfaces.api.user;
 
-import com.loopers.application.user.UserInfo;
-import com.loopers.application.user.UserAppService;
+import com.loopers.domain.user.UserModel;
 import com.loopers.domain.user.UserRegisterCommand;
+import com.loopers.domain.user.UserService;
 import com.loopers.interfaces.api.ApiResponse;
+import com.loopers.interfaces.api.AuthUser;
 import jakarta.validation.Valid;
 import lombok.RequiredArgsConstructor;
 import org.springframework.http.ResponseEntity;
@@ -13,14 +14,14 @@
  * 사용자(User) 고객 API V1 REST 엔드포인트를 제공하는 컨트롤러.
  *
  * <p>회원가입, 내 정보 조회, 비밀번호 변경 기능을 제공한다.
- * {@link UserAppService}를 호출한다.</p>
+ * {@link UserService}를 직접 호출한다.</p>
  */
 @RestController
 @RequestMapping("/api/v1/users")
 @RequiredArgsConstructor
 public class UserV1Controller {
 
-    private final UserAppService userAppService;
+    private final UserService userService;
 
     /**
      * 회원가입 API. 유효한 입력으로 신규 사용자를 등록한다.
@@ -31,42 +32,36 @@ public class UserV1Controller {
     @PostMapping
     public ResponseEntity<ApiResponse<UserV1Dto.RegisterResponse>> register(
             @Valid @RequestBody UserV1Dto.RegisterRequest request) {
-        UserInfo info = userAppService.register(new UserRegisterCommand(
+        UserModel user = userService.register(new UserRegisterCommand(
                 request.getLoginId(), request.getPassword(),
                 request.getUserName(), request.getBirthday(),
                 request.getEmail(), request.getAddress()));
-        return ResponseEntity.ok(ApiResponse.success(UserV1Dto.RegisterResponse.from(info)));
+        return ResponseEntity.ok(ApiResponse.success(UserV1Dto.RegisterResponse.from(user)));
     }
 
     /**
-     * 내 정보 조회 API. 인증 헤더로 본인 확인 후 마스킹된 사용자 정보를 반환한다.
+     * 내 정보 조회 API. 인터셉터에서 인증된 사용자 정보를 반환한다.
      *
-     * @param loginId 로그인 ID (인증 헤더)
-     * @param loginPw 비밀번호 (인증 헤더)
+     * @param user 인증된 사용자 (인터셉터에서 주입)
      * @return 마스킹된 사용자 정보 응답
      */
     @GetMapping("/me")
-    public ResponseEntity<ApiResponse<UserV1Dto.MyInfoResponse>> getMyInfo(
-            @RequestHeader("X-Loopers-LoginId") String loginId,
-            @RequestHeader("X-Loopers-LoginPw") String loginPw) {
-        UserInfo info = userAppService.getMyInfo(loginId, loginPw);
-        return ResponseEntity.ok(ApiResponse.success(UserV1Dto.MyInfoResponse.from(info)));
+    public ResponseEntity<ApiResponse<UserV1Dto.MyInfoResponse>> getMyInfo(@AuthUser UserModel user) {
+        return ResponseEntity.ok(ApiResponse.success(UserV1Dto.MyInfoResponse.from(user)));
     }
 
     /**
      * 비밀번호 변경 API. 인증 후 현재 비밀번호 확인 및 새 비밀번호로 변경한다.
      *
-     * @param loginId 로그인 ID (인증 헤더)
-     * @param loginPw 비밀번호 (인증 헤더)
+     * @param user    인증된 사용자 (인터셉터에서 주입)
      * @param request 비밀번호 변경 요청 DTO (현재 비밀번호, 새 비밀번호)
      * @return 성공 응답
      */
     @PatchMapping("/me/password")
     public ResponseEntity<ApiResponse<Object>> changePassword(
-            @RequestHeader("X-Loopers-LoginId") String loginId,
-            @RequestHeader("X-Loopers-LoginPw") String loginPw,
+            @AuthUser UserModel user,
             @Valid @RequestBody UserV1Dto.ChangePasswordRequest request) {
-        userAppService.changePassword(loginId, loginPw,
+        userService.changePassword(user.getLoginId(),
                 request.getCurrentPassword(), request.getNewPassword());
         return ResponseEntity.ok(ApiResponse.success());
     }
diff --git a/apps/commerce-api/src/main/java/com/loopers/interfaces/api/user/UserV1Dto.java b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/user/UserV1Dto.java
index 14dfe3343..e551ccf27 100644
--- a/apps/commerce-api/src/main/java/com/loopers/interfaces/api/user/UserV1Dto.java
+++ b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/user/UserV1Dto.java
@@ -1,6 +1,6 @@
 package com.loopers.interfaces.api.user;
 
-import com.loopers.application.user.UserInfo;
+import com.loopers.domain.user.UserModel;
 import jakarta.validation.constraints.Email;
 import jakarta.validation.constraints.NotBlank;
 import jakarta.validation.constraints.Size;
@@ -55,7 +55,7 @@ public static class RegisterRequest {
     @AllArgsConstructor
     @Builder
     public static class RegisterResponse {
-        private String userId;
+        private Long userId;
         private String loginId;
         private String maskedName;
         private String birthday;
@@ -63,19 +63,19 @@ public static class RegisterResponse {
         private String address;
 
         /**
-         * {@link UserInfo}를 회원가입 응답 DTO로 변환하는 팩토리 메서드.
+         * {@link UserModel}을 회원가입 응답 DTO로 변환하는 팩토리 메서드.
          *
-         * @param info 변환할 사용자 도메인 Info 객체
+         * @param model 변환할 사용자 도메인 모델
          * @return 변환된 RegisterResponse
          */
-        public static RegisterResponse from(UserInfo info) {
+        public static RegisterResponse from(UserModel model) {
             return RegisterResponse.builder()
-                    .userId(info.getUserId())
-                    .loginId(info.getLoginId())
-                    .maskedName(info.getMaskedName())
-                    .birthday(info.getBirthday())
-                    .email(info.getEmail())
-                    .address(info.getAddress())
+                    .userId(model.getUserId())
+                    .loginId(model.getLoginId())
+                    .maskedName(model.getMaskedName())
+                    .birthday(model.getBirthday())
+                    .email(model.getEmail())
+                    .address(model.getAddress())
                     .build();
         }
     }
@@ -89,7 +89,7 @@ public static RegisterResponse from(UserInfo info) {
     @AllArgsConstructor
     @Builder
     public static class MyInfoResponse {
-        private String userId;
+        private Long userId;
         private String loginId;
         private String maskedName;
         private String birthday;
@@ -97,19 +97,19 @@ public static class MyInfoResponse {
         private String address;
 
         /**
-         * {@link UserInfo}를 내 정보 조회 응답 DTO로 변환하는 팩토리 메서드.
+         * {@link UserModel}을 내 정보 조회 응답 DTO로 변환하는 팩토리 메서드.
          *
-         * @param info 변환할 사용자 도메인 Info 객체
+         * @param model 변환할 사용자 도메인 모델
          * @return 변환된 MyInfoResponse
          */
-        public static MyInfoResponse from(UserInfo info) {
+        public static MyInfoResponse from(UserModel model) {
             return MyInfoResponse.builder()
-                    .userId(info.getUserId())
-                    .loginId(info.getLoginId())
-                    .maskedName(info.getMaskedName())
-                    .birthday(info.getBirthday())
-                    .email(info.getEmail())
-                    .address(info.getAddress())
+                    .userId(model.getUserId())
+                    .loginId(model.getLoginId())
+                    .maskedName(model.getMaskedName())
+                    .birthday(model.getBirthday())
+                    .email(model.getEmail())
+                    .address(model.getAddress())
                     .build();
         }
     }
diff --git a/apps/commerce-api/src/main/java/com/loopers/interfaces/apiadmin/AdminBrandV1Controller.java b/apps/commerce-api/src/main/java/com/loopers/interfaces/apiadmin/AdminBrandV1Controller.java
index a2963e3de..bef1954e5 100644
--- a/apps/commerce-api/src/main/java/com/loopers/interfaces/apiadmin/AdminBrandV1Controller.java
+++ b/apps/commerce-api/src/main/java/com/loopers/interfaces/apiadmin/AdminBrandV1Controller.java
@@ -1,8 +1,7 @@
 package com.loopers.interfaces.apiadmin;
 
-import com.loopers.application.brand.BrandInfo;
-import com.loopers.application.brand.BrandAppService;
-import com.loopers.domain.product.ProductService;
+import com.loopers.domain.brand.BrandModel;
+import com.loopers.domain.brand.BrandService;
 import com.loopers.interfaces.api.ApiResponse;
 import jakarta.validation.Valid;
 import lombok.RequiredArgsConstructor;
@@ -15,15 +14,15 @@
  * 관리자 전용 브랜드 REST API 엔드포인트를 제공하는 컨트롤러.
  *
  * <p>브랜드의 전체 조회, 등록, 수정, 삭제 기능을 관리자에게 제공한다.
- * 브랜드 삭제 시 소속 상품도 연쇄적으로 소프트 삭제된다.</p>
+ * 브랜드 삭제 시 소속 상품도 연쇄적으로 소프트 삭제된다.
+ * {@link BrandService}를 직접 호출한다.</p>
  */
 @RestController
 @RequestMapping("/api-admin/v1/brands")
 @RequiredArgsConstructor
 public class AdminBrandV1Controller {
 
-    private final BrandAppService brandAppService;
-    private final ProductService productService;
+    private final BrandService brandService;
 
     /**
      * 전체 브랜드 목록을 조회한다 (삭제된 브랜드 포함).
@@ -32,7 +31,7 @@ public class AdminBrandV1Controller {
      */
     @GetMapping
     public ResponseEntity<ApiResponse<List<AdminBrandV1Dto.AdminBrandResponse>>> list() {
-        List<AdminBrandV1Dto.AdminBrandResponse> response = brandAppService.findAllForAdmin().stream()
+        List<AdminBrandV1Dto.AdminBrandResponse> response = brandService.findAllForAdmin().stream()
                 .map(AdminBrandV1Dto.AdminBrandResponse::from)
                 .toList();
         return ResponseEntity.ok(ApiResponse.success(response));
@@ -47,9 +46,9 @@ public ResponseEntity<ApiResponse<List<AdminBrandV1Dto.AdminBrandResponse>>> lis
     @PostMapping
     public ResponseEntity<ApiResponse<AdminBrandV1Dto.AdminBrandResponse>> create(
             @Valid @RequestBody AdminBrandV1Dto.CreateBrandRequest request) {
-        BrandInfo info = brandAppService.createBrand(
+        BrandModel brand = brandService.createBrand(
                 request.getBrandName(), request.getDescription(), request.getAddress());
-        return ResponseEntity.ok(ApiResponse.success(AdminBrandV1Dto.AdminBrandResponse.from(info)));
+        return ResponseEntity.ok(ApiResponse.success(AdminBrandV1Dto.AdminBrandResponse.from(brand)));
     }
 
     /**
@@ -61,11 +60,11 @@ public ResponseEntity<ApiResponse<AdminBrandV1Dto.AdminBrandResponse>> create(
      */
     @PutMapping("/{brandId}")
     public ResponseEntity<ApiResponse<AdminBrandV1Dto.AdminBrandResponse>> update(
-            @PathVariable String brandId,
+            @PathVariable Long brandId,
             @Valid @RequestBody AdminBrandV1Dto.UpdateBrandRequest request) {
-        BrandInfo info = brandAppService.updateBrand(brandId,
+        BrandModel brand = brandService.updateBrand(brandId,
                 request.getBrandName(), request.getDescription(), request.getAddress());
-        return ResponseEntity.ok(ApiResponse.success(AdminBrandV1Dto.AdminBrandResponse.from(info)));
+        return ResponseEntity.ok(ApiResponse.success(AdminBrandV1Dto.AdminBrandResponse.from(brand)));
     }
 
     /**
@@ -75,9 +74,8 @@ public ResponseEntity<ApiResponse<AdminBrandV1Dto.AdminBrandResponse>> update(
      * @return 삭제 성공 응답
      */
     @DeleteMapping("/{brandId}")
-    public ResponseEntity<ApiResponse<Object>> delete(@PathVariable String brandId) {
-        brandAppService.deleteBrand(brandId);
-        productService.softDeleteByBrandId(brandId);
+    public ResponseEntity<ApiResponse<Object>> delete(@PathVariable Long brandId) {
+        brandService.deleteBrand(brandId);
         return ResponseEntity.ok(ApiResponse.success());
     }
 }
diff --git a/apps/commerce-api/src/main/java/com/loopers/interfaces/apiadmin/AdminBrandV1Dto.java b/apps/commerce-api/src/main/java/com/loopers/interfaces/apiadmin/AdminBrandV1Dto.java
index fa630242d..a1c71509f 100644
--- a/apps/commerce-api/src/main/java/com/loopers/interfaces/apiadmin/AdminBrandV1Dto.java
+++ b/apps/commerce-api/src/main/java/com/loopers/interfaces/apiadmin/AdminBrandV1Dto.java
@@ -1,6 +1,6 @@
 package com.loopers.interfaces.apiadmin;
 
-import com.loopers.application.brand.BrandInfo;
+import com.loopers.domain.brand.BrandModel;
 import com.loopers.support.enums.DisplayStatus;
 import jakarta.validation.constraints.NotBlank;
 import lombok.AllArgsConstructor;
@@ -52,7 +52,7 @@ public static class UpdateBrandRequest {
     @AllArgsConstructor
     @Builder
     public static class AdminBrandResponse {
-        private String brandId;
+        private Long brandId;
         private String brandName;
         private String description;
         private String address;
@@ -62,21 +62,21 @@ public static class AdminBrandResponse {
         private ZonedDateTime createdAt;
 
         /**
-         * {@link BrandInfo}를 관리자 브랜드 응답 DTO로 변환하는 정적 팩토리 메서드.
+         * {@link BrandModel}을 관리자 브랜드 응답 DTO로 변환하는 정적 팩토리 메서드.
          *
-         * @param info 브랜드 정보 DTO
+         * @param model 브랜드 도메인 모델
          * @return 변환된 관리자 브랜드 응답 DTO
          */
-        public static AdminBrandResponse from(BrandInfo info) {
+        public static AdminBrandResponse from(BrandModel model) {
             return AdminBrandResponse.builder()
-                    .brandId(info.getBrandId())
-                    .brandName(info.getBrandName())
-                    .description(info.getDescription())
-                    .address(info.getAddress())
-                    .displayStatus(info.getDisplayStatus())
-                    .delYn(info.getDelYn())
-                    .deletedAt(info.getDeletedAt())
-                    .createdAt(info.getCreatedAt())
+                    .brandId(model.getBrandId())
+                    .brandName(model.getBrandName())
+                    .description(model.getDescription())
+                    .address(model.getAddress())
+                    .displayStatus(model.getDisplayStatus())
+                    .delYn(model.getDelYn())
+                    .deletedAt(model.getDeletedAt())
+                    .createdAt(model.getCreatedAt())
                     .build();
         }
     }
diff --git a/apps/commerce-api/src/main/java/com/loopers/interfaces/apiadmin/AdminCartV1Controller.java b/apps/commerce-api/src/main/java/com/loopers/interfaces/apiadmin/AdminCartV1Controller.java
index 05d74b87a..34d965d17 100644
--- a/apps/commerce-api/src/main/java/com/loopers/interfaces/apiadmin/AdminCartV1Controller.java
+++ b/apps/commerce-api/src/main/java/com/loopers/interfaces/apiadmin/AdminCartV1Controller.java
@@ -30,7 +30,7 @@ public class AdminCartV1Controller {
      */
     @GetMapping("/users/{userId}/cart")
     public ResponseEntity<ApiResponse<List<AdminCartV1Dto.AdminCartItemResponse>>> getUserCart(
-            @PathVariable String userId) {
+            @PathVariable Long userId) {
         List<CartInfo> cart = cartFacade.getCartForAdmin(userId);
         List<AdminCartV1Dto.AdminCartItemResponse> response = cart.stream()
                 .map(AdminCartV1Dto.AdminCartItemResponse::from)
diff --git a/apps/commerce-api/src/main/java/com/loopers/interfaces/apiadmin/AdminCartV1Dto.java b/apps/commerce-api/src/main/java/com/loopers/interfaces/apiadmin/AdminCartV1Dto.java
index 4224f90e2..d43a406eb 100644
--- a/apps/commerce-api/src/main/java/com/loopers/interfaces/apiadmin/AdminCartV1Dto.java
+++ b/apps/commerce-api/src/main/java/com/loopers/interfaces/apiadmin/AdminCartV1Dto.java
@@ -22,8 +22,8 @@ public class AdminCartV1Dto {
     @AllArgsConstructor
     @Builder
     public static class AdminCartItemResponse {
-        private String userId;
-        private String productId;
+        private Long userId;
+        private Long productId;
         private int quantity;
         private boolean available;
         private UnavailableReason unavailableReason;
diff --git a/apps/commerce-api/src/main/java/com/loopers/interfaces/apiadmin/AdminCouponV1Controller.java b/apps/commerce-api/src/main/java/com/loopers/interfaces/apiadmin/AdminCouponV1Controller.java
new file mode 100644
index 000000000..c8ca98d22
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/interfaces/apiadmin/AdminCouponV1Controller.java
@@ -0,0 +1,115 @@
+package com.loopers.interfaces.apiadmin;
+
+import com.loopers.domain.coupon.CouponModel;
+import com.loopers.domain.coupon.CouponService;
+import com.loopers.domain.coupon.UserCouponModel;
+import com.loopers.interfaces.api.ApiResponse;
+import com.loopers.interfaces.api.PageResponse;
+import com.loopers.support.page.PageQuery;
+import com.loopers.support.page.PagedResult;
+import jakarta.validation.Valid;
+import lombok.RequiredArgsConstructor;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.DeleteMapping;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.PutMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RestController;
+
+import java.util.List;
+
+/**
+ * 관리자 쿠폰 API V1 컨트롤러.
+ */
+@RestController
+@RequestMapping("/api-admin/v1/coupons")
+@RequiredArgsConstructor
+public class AdminCouponV1Controller {
+
+    private final CouponService couponService;
+
+    /**
+     * 쿠폰 템플릿을 등록한다.
+     */
+    @PostMapping
+    public ResponseEntity<ApiResponse<AdminCouponV1Dto.CouponResponse>> createCoupon(
+            @Valid @RequestBody AdminCouponV1Dto.CouponRequest request) {
+        CouponModel coupon = couponService.createCoupon(
+                request.getName(), request.getType(), request.getValue(),
+                request.getMinOrderAmount(), request.getExpiredAt());
+        return ResponseEntity.ok(ApiResponse.success(AdminCouponV1Dto.CouponResponse.from(coupon)));
+    }
+
+    /**
+     * 쿠폰 목록을 페이징 조회한다 (삭제 포함).
+     */
+    @GetMapping
+    public ResponseEntity<ApiResponse<PageResponse<AdminCouponV1Dto.CouponResponse>>> getCoupons(
+            @RequestParam(defaultValue = "0") int page,
+            @RequestParam(defaultValue = "20") int size) {
+        PageQuery query = new PageQuery(page, size, "couponId", false);
+        PagedResult<CouponModel> pagedResult = couponService.findAllForAdminPaged(query);
+        List<AdminCouponV1Dto.CouponResponse> content = pagedResult.content().stream()
+                .map(AdminCouponV1Dto.CouponResponse::from)
+                .toList();
+        PageResponse<AdminCouponV1Dto.CouponResponse> pageResponse = new PageResponse<>(
+                content, pagedResult.page(), pagedResult.size(),
+                pagedResult.totalElements(), pagedResult.totalPages());
+        return ResponseEntity.ok(ApiResponse.success(pageResponse));
+    }
+
+    /**
+     * 쿠폰 상세를 조회한다.
+     */
+    @GetMapping("/{couponId}")
+    public ResponseEntity<ApiResponse<AdminCouponV1Dto.CouponResponse>> getCoupon(
+            @PathVariable Long couponId) {
+        CouponModel coupon = couponService.findByIdForAdmin(couponId);
+        return ResponseEntity.ok(ApiResponse.success(AdminCouponV1Dto.CouponResponse.from(coupon)));
+    }
+
+    /**
+     * 쿠폰을 수정한다.
+     */
+    @PutMapping("/{couponId}")
+    public ResponseEntity<ApiResponse<AdminCouponV1Dto.CouponResponse>> updateCoupon(
+            @PathVariable Long couponId,
+            @Valid @RequestBody AdminCouponV1Dto.CouponRequest request) {
+        CouponModel coupon = couponService.updateCoupon(
+                couponId, request.getName(), request.getType(), request.getValue(),
+                request.getMinOrderAmount(), request.getExpiredAt());
+        return ResponseEntity.ok(ApiResponse.success(AdminCouponV1Dto.CouponResponse.from(coupon)));
+    }
+
+    /**
+     * 쿠폰을 소프트 삭제한다.
+     */
+    @DeleteMapping("/{couponId}")
+    public ResponseEntity<ApiResponse<Object>> deleteCoupon(@PathVariable Long couponId) {
+        couponService.deleteCoupon(couponId);
+        return ResponseEntity.ok(ApiResponse.success());
+    }
+
+    /**
+     * 특정 쿠폰의 발급 내역을 페이징 조회한다.
+     */
+    @GetMapping("/{couponId}/issues")
+    public ResponseEntity<ApiResponse<PageResponse<AdminCouponV1Dto.IssueHistoryResponse>>> getIssueHistory(
+            @PathVariable Long couponId,
+            @RequestParam(defaultValue = "0") int page,
+            @RequestParam(defaultValue = "20") int size) {
+        PageQuery query = new PageQuery(page, size, "userCouponId", false);
+        PagedResult<UserCouponModel> pagedResult = couponService.findIssueHistoryPaged(couponId, query);
+        List<AdminCouponV1Dto.IssueHistoryResponse> content = pagedResult.content().stream()
+                .map(AdminCouponV1Dto.IssueHistoryResponse::from)
+                .toList();
+        PageResponse<AdminCouponV1Dto.IssueHistoryResponse> pageResponse = new PageResponse<>(
+                content, pagedResult.page(), pagedResult.size(),
+                pagedResult.totalElements(), pagedResult.totalPages());
+        return ResponseEntity.ok(ApiResponse.success(pageResponse));
+    }
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/interfaces/apiadmin/AdminCouponV1Dto.java b/apps/commerce-api/src/main/java/com/loopers/interfaces/apiadmin/AdminCouponV1Dto.java
new file mode 100644
index 000000000..1876fa1f2
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/interfaces/apiadmin/AdminCouponV1Dto.java
@@ -0,0 +1,104 @@
+package com.loopers.interfaces.apiadmin;
+
+import com.loopers.domain.coupon.CouponModel;
+import com.loopers.domain.coupon.UserCouponModel;
+import com.loopers.support.enums.DiscountType;
+import com.loopers.support.enums.UserCouponStatus;
+import jakarta.validation.constraints.DecimalMin;
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.NotNull;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+
+import java.math.BigDecimal;
+import java.time.LocalDateTime;
+
+/**
+ * 관리자 쿠폰 API V1 요청/응답 DTO 모음.
+ */
+public class AdminCouponV1Dto {
+
+    /**
+     * 쿠폰 생성/수정 요청 DTO.
+     */
+    @Getter
+    @NoArgsConstructor
+    @AllArgsConstructor
+    @Builder
+    public static class CouponRequest {
+        @NotBlank(message = "쿠폰명은 필수입니다")
+        private String name;
+
+        @NotNull(message = "할인 유형은 필수입니다")
+        private DiscountType type;
+
+        @NotNull(message = "할인값은 필수입니다")
+        @DecimalMin(value = "0.01", message = "할인값은 0보다 커야 합니다")
+        private BigDecimal value;
+
+        private BigDecimal minOrderAmount;
+
+        @NotNull(message = "만료 일시는 필수입니다")
+        private LocalDateTime expiredAt;
+    }
+
+    /**
+     * 쿠폰 응답 DTO.
+     */
+    @Getter
+    @AllArgsConstructor
+    @Builder
+    public static class CouponResponse {
+        private Long couponId;
+        private String name;
+        private DiscountType discountType;
+        private BigDecimal discountValue;
+        private BigDecimal minOrderAmount;
+        private LocalDateTime expiredAt;
+        private String delYn;
+        private LocalDateTime deletedAt;
+
+        public static CouponResponse from(CouponModel coupon) {
+            return CouponResponse.builder()
+                    .couponId(coupon.getCouponId())
+                    .name(coupon.getName())
+                    .discountType(coupon.getDiscountType())
+                    .discountValue(coupon.getDiscountValue())
+                    .minOrderAmount(coupon.getMinOrderAmount())
+                    .expiredAt(coupon.getExpiredAt())
+                    .delYn(coupon.getDelYn())
+                    .deletedAt(coupon.getDeletedAt() != null ? coupon.getDeletedAt().toLocalDateTime() : null)
+                    .build();
+        }
+    }
+
+    /**
+     * 발급 내역 응답 DTO.
+     */
+    @Getter
+    @AllArgsConstructor
+    @Builder
+    public static class IssueHistoryResponse {
+        private Long userCouponId;
+        private Long userId;
+        private Long couponId;
+        private UserCouponStatus status;
+        private LocalDateTime issuedAt;
+        private LocalDateTime usedAt;
+        private Long orderId;
+
+        public static IssueHistoryResponse from(UserCouponModel userCoupon) {
+            return IssueHistoryResponse.builder()
+                    .userCouponId(userCoupon.getUserCouponId())
+                    .userId(userCoupon.getUserId())
+                    .couponId(userCoupon.getCouponId())
+                    .status(userCoupon.getStatus())
+                    .issuedAt(userCoupon.getIssuedAt())
+                    .usedAt(userCoupon.getUsedAt())
+                    .orderId(userCoupon.getOrderId())
+                    .build();
+        }
+    }
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/interfaces/apiadmin/AdminOrderV1Controller.java b/apps/commerce-api/src/main/java/com/loopers/interfaces/apiadmin/AdminOrderV1Controller.java
index 1e9110bba..b92e70b91 100644
--- a/apps/commerce-api/src/main/java/com/loopers/interfaces/apiadmin/AdminOrderV1Controller.java
+++ b/apps/commerce-api/src/main/java/com/loopers/interfaces/apiadmin/AdminOrderV1Controller.java
@@ -1,6 +1,6 @@
 package com.loopers.interfaces.apiadmin;
 
-import com.loopers.application.order.OrderAppService;
+import com.loopers.application.order.OrderFacade;
 import com.loopers.application.order.OrderInfo;
 import com.loopers.interfaces.api.ApiResponse;
 import lombok.RequiredArgsConstructor;
@@ -9,19 +9,21 @@
 import org.springframework.web.bind.annotation.*;
 
 import java.time.LocalDate;
+import java.time.LocalDateTime;
 import java.util.List;
 
 /**
  * 관리자 전용 주문 REST API 엔드포인트를 제공하는 컨트롤러.
  *
- * <p>기간별 주문 목록 조회 및 개별 주문 상세 조회 기능을 관리자에게 제공한다.</p>
+ * <p>기간별 주문 목록 조회 및 개별 주문 상세 조회 기능을 관리자에게 제공한다.
+ * {@link OrderFacade}를 통해 조회한다.</p>
  */
 @RestController
 @RequestMapping("/api-admin/v1/orders")
 @RequiredArgsConstructor
 public class AdminOrderV1Controller {
 
-    private final OrderAppService orderAppService;
+    private final OrderFacade orderFacade;
 
     /**
      * 기간별 전체 주문 목록을 조회한다.
@@ -37,12 +39,10 @@ public ResponseEntity<ApiResponse<List<AdminOrderV1Dto.AdminOrderResponse>>> lis
             @RequestParam(value = "startAt", required = false) @DateTimeFormat(iso = DateTimeFormat.ISO.DATE) LocalDate startAt,
             @RequestParam(value = "endAt", required = false) @DateTimeFormat(iso = DateTimeFormat.ISO.DATE) LocalDate endAt) {
         LocalDate now = LocalDate.now();
-        LocalDate start = startAt != null ? startAt : now.minusMonths(1);
-        LocalDate end = endAt != null ? endAt : now;
+        LocalDateTime start = (startAt != null ? startAt : now.minusMonths(1)).atStartOfDay();
+        LocalDateTime end = (endAt != null ? endAt : now).plusDays(1).atStartOfDay();
 
-        List<OrderInfo> orders = orderAppService.findAllOrders(
-                start.atStartOfDay(), end.plusDays(1).atStartOfDay());
-        List<AdminOrderV1Dto.AdminOrderResponse> response = orders.stream()
+        List<AdminOrderV1Dto.AdminOrderResponse> response = orderFacade.getOrdersForAdmin(start, end).stream()
                 .map(AdminOrderV1Dto.AdminOrderResponse::from)
                 .toList();
         return ResponseEntity.ok(ApiResponse.success(response));
@@ -56,8 +56,8 @@ public ResponseEntity<ApiResponse<List<AdminOrderV1Dto.AdminOrderResponse>>> lis
      */
     @GetMapping("/{orderId}")
     public ResponseEntity<ApiResponse<AdminOrderV1Dto.AdminOrderResponse>> detail(
-            @PathVariable String orderId) {
-        OrderInfo info = orderAppService.findOrderById(orderId);
+            @PathVariable Long orderId) {
+        OrderInfo info = orderFacade.getOrderDetailForAdmin(orderId);
         return ResponseEntity.ok(ApiResponse.success(AdminOrderV1Dto.AdminOrderResponse.from(info)));
     }
 }
diff --git a/apps/commerce-api/src/main/java/com/loopers/interfaces/apiadmin/AdminOrderV1Dto.java b/apps/commerce-api/src/main/java/com/loopers/interfaces/apiadmin/AdminOrderV1Dto.java
index 7dfcee84b..3f2f552d6 100644
--- a/apps/commerce-api/src/main/java/com/loopers/interfaces/apiadmin/AdminOrderV1Dto.java
+++ b/apps/commerce-api/src/main/java/com/loopers/interfaces/apiadmin/AdminOrderV1Dto.java
@@ -18,15 +18,13 @@ public class AdminOrderV1Dto {
 
     /**
      * 관리자용 주문 응답 DTO.
-     *
-     * <p>주문 유형, 상태, 총 금액, 만료 일시, 결제 일시 및 주문 항목 목록을 포함한다.</p>
      */
     @Getter
     @AllArgsConstructor
     @Builder
     public static class AdminOrderResponse {
-        private String orderId;
-        private String userId;
+        private Long orderId;
+        private Long userId;
         private OrderType orderType;
         private OrderStatus status;
         private BigDecimal totalAmount;
@@ -34,12 +32,6 @@ public static class AdminOrderResponse {
         private LocalDateTime paidAt;
         private List<AdminOrderItemResponse> items;
 
-        /**
-         * {@link OrderInfo}를 관리자 주문 응답 DTO로 변환하는 정적 팩토리 메서드.
-         *
-         * @param info 주문 정보 DTO
-         * @return 변환된 관리자 주문 응답 DTO
-         */
         public static AdminOrderResponse from(OrderInfo info) {
             return AdminOrderResponse.builder()
                     .orderId(info.getOrderId())
@@ -57,26 +49,21 @@ public static AdminOrderResponse from(OrderInfo info) {
     }
 
     /**
-     * 관리자용 주문 항목 응답 DTO.
-     *
-     * <p>주문 시점의 스냅샷 정보(상품명, 단가, 브랜드명)를 포함한다.</p>
+     * 관리자용 주문 항목 응답 DTO (할인 금액 필드 포함).
      */
     @Getter
     @AllArgsConstructor
     @Builder
     public static class AdminOrderItemResponse {
-        private String productId;
+        private Long productId;
         private int quantity;
         private String snapshotProductName;
         private BigDecimal snapshotUnitPrice;
         private String snapshotBrandName;
+        private BigDecimal originalAmount;
+        private BigDecimal discountAmount;
+        private BigDecimal finalAmount;
 
-        /**
-         * {@link OrderInfo.OrderItemInfo}를 관리자 주문 항목 응답 DTO로 변환하는 정적 팩토리 메서드.
-         *
-         * @param item 주문 항목 정보 DTO
-         * @return 변환된 관리자 주문 항목 응답 DTO
-         */
         public static AdminOrderItemResponse from(OrderInfo.OrderItemInfo item) {
             return AdminOrderItemResponse.builder()
                     .productId(item.getProductId())
@@ -84,6 +71,9 @@ public static AdminOrderItemResponse from(OrderInfo.OrderItemInfo item) {
                     .snapshotProductName(item.getSnapshotProductName())
                     .snapshotUnitPrice(item.getSnapshotUnitPrice())
                     .snapshotBrandName(item.getSnapshotBrandName())
+                    .originalAmount(item.getOriginalAmount())
+                    .discountAmount(item.getDiscountAmount())
+                    .finalAmount(item.getFinalAmount())
                     .build();
         }
     }
diff --git a/apps/commerce-api/src/main/java/com/loopers/interfaces/apiadmin/AdminProductV1Controller.java b/apps/commerce-api/src/main/java/com/loopers/interfaces/apiadmin/AdminProductV1Controller.java
index 7f24f18a3..79e550759 100644
--- a/apps/commerce-api/src/main/java/com/loopers/interfaces/apiadmin/AdminProductV1Controller.java
+++ b/apps/commerce-api/src/main/java/com/loopers/interfaces/apiadmin/AdminProductV1Controller.java
@@ -1,11 +1,11 @@
 package com.loopers.interfaces.apiadmin;
 
-import com.loopers.application.product.ProductAppService;
 import com.loopers.application.product.ProductCreateCommand;
 import com.loopers.application.product.ProductFacade;
 import com.loopers.application.product.ProductUpdateCommand;
 import com.loopers.application.product.ProductInfo;
-import com.loopers.application.product.ProductRevisionInfo;
+import com.loopers.domain.product.ProductRevisionModel;
+import com.loopers.domain.product.ProductService;
 import com.loopers.interfaces.api.ApiResponse;
 import jakarta.validation.Valid;
 import lombok.RequiredArgsConstructor;
@@ -18,7 +18,8 @@
  * 관리자 전용 상품 REST API 엔드포인트를 제공하는 컨트롤러.
  *
  * <p>상품의 전체 조회, 등록, 수정, 삭제 및 변경 이력(revision) 조회 기능을 관리자에게 제공한다.
- * 복잡한 도메인으로 {@link ProductFacade}를 통해 여러 서비스를 조합하여 처리한다.</p>
+ * 복잡한 도메인으로 {@link ProductFacade}를 통해 여러 서비스를 조합하여 처리한다.
+ * 단순 삭제 및 이력 조회는 {@link ProductService}를 직접 호출한다.</p>
  */
 @RestController
 @RequestMapping("/api-admin/v1/products")
@@ -26,7 +27,7 @@
 public class AdminProductV1Controller {
 
     private final ProductFacade productFacade;
-    private final ProductAppService productAppService;
+    private final ProductService productService;
 
     /**
      * 전체 상품 목록을 조회한다.
@@ -68,7 +69,7 @@ public ResponseEntity<ApiResponse<AdminProductV1Dto.AdminProductResponse>> creat
      */
     @PutMapping("/{productId}")
     public ResponseEntity<ApiResponse<AdminProductV1Dto.AdminProductResponse>> update(
-            @PathVariable String productId,
+            @PathVariable Long productId,
             @Valid @RequestBody AdminProductV1Dto.UpdateProductRequest request) {
         ProductInfo info = productFacade.updateProduct(new ProductUpdateCommand(
                 productId, request.getProductName(), request.getPrice(),
@@ -83,8 +84,8 @@ public ResponseEntity<ApiResponse<AdminProductV1Dto.AdminProductResponse>> updat
      * @return 삭제 성공 응답
      */
     @DeleteMapping("/{productId}")
-    public ResponseEntity<ApiResponse<Object>> delete(@PathVariable String productId) {
-        productAppService.deleteProduct(productId);
+    public ResponseEntity<ApiResponse<Object>> delete(@PathVariable Long productId) {
+        productService.deleteProduct(productId);
         return ResponseEntity.ok(ApiResponse.success());
     }
 
@@ -96,8 +97,9 @@ public ResponseEntity<ApiResponse<Object>> delete(@PathVariable String productId
      */
     @GetMapping("/{productId}/revisions")
     public ResponseEntity<ApiResponse<List<AdminProductV1Dto.RevisionResponse>>> getRevisions(
-            @PathVariable String productId) {
-        List<AdminProductV1Dto.RevisionResponse> response = productAppService.getRevisions(productId).stream()
+            @PathVariable Long productId) {
+        List<ProductRevisionModel> revisions = productService.findRevisionsByProductId(productId);
+        List<AdminProductV1Dto.RevisionResponse> response = revisions.stream()
                 .map(AdminProductV1Dto.RevisionResponse::from)
                 .toList();
         return ResponseEntity.ok(ApiResponse.success(response));
@@ -112,8 +114,8 @@ public ResponseEntity<ApiResponse<List<AdminProductV1Dto.RevisionResponse>>> get
      */
     @GetMapping("/{productId}/revisions/{seq}")
     public ResponseEntity<ApiResponse<AdminProductV1Dto.RevisionResponse>> getRevisionDetail(
-            @PathVariable String productId, @PathVariable Long seq) {
-        ProductRevisionInfo info = productAppService.getRevisionDetail(productId, seq);
-        return ResponseEntity.ok(ApiResponse.success(AdminProductV1Dto.RevisionResponse.from(info)));
+            @PathVariable Long productId, @PathVariable Long seq) {
+        ProductRevisionModel revision = productService.findRevisionById(productId, seq);
+        return ResponseEntity.ok(ApiResponse.success(AdminProductV1Dto.RevisionResponse.from(revision)));
     }
 }
diff --git a/apps/commerce-api/src/main/java/com/loopers/interfaces/apiadmin/AdminProductV1Dto.java b/apps/commerce-api/src/main/java/com/loopers/interfaces/apiadmin/AdminProductV1Dto.java
index 3264a4e04..f9d6ee392 100644
--- a/apps/commerce-api/src/main/java/com/loopers/interfaces/apiadmin/AdminProductV1Dto.java
+++ b/apps/commerce-api/src/main/java/com/loopers/interfaces/apiadmin/AdminProductV1Dto.java
@@ -1,7 +1,7 @@
 package com.loopers.interfaces.apiadmin;
 
 import com.loopers.application.product.ProductInfo;
-import com.loopers.application.product.ProductRevisionInfo;
+import com.loopers.domain.product.ProductRevisionModel;
 import com.loopers.support.enums.DisplayStatus;
 import com.loopers.support.enums.ProductRevisionAction;
 import com.loopers.support.enums.ProductSaleStatus;
@@ -33,8 +33,7 @@ public class AdminProductV1Dto {
     public static class CreateProductRequest {
         @NotBlank(message = "상품 이름은 필수입니다")
         private String productName;
-        @NotBlank(message = "브랜드 ID는 필수입니다")
-        private String brandId;
+        private Long brandId;
         @Positive(message = "가격은 0보다 커야 합니다")
         private BigDecimal price;
         private String description;
@@ -70,8 +69,8 @@ public static class UpdateProductRequest {
     @AllArgsConstructor
     @Builder
     public static class AdminProductResponse {
-        private String productId;
-        private String brandId;
+        private Long productId;
+        private Long brandId;
         private String productName;
         private String description;
         private BigDecimal price;
@@ -111,7 +110,7 @@ public static AdminProductResponse from(ProductInfo info) {
     @AllArgsConstructor
     @Builder
     public static class RevisionResponse {
-        private String productId;
+        private Long productId;
         private Long revisionSeq;
         private ProductRevisionAction action;
         private String changedBy;
@@ -121,21 +120,21 @@ public static class RevisionResponse {
         private LocalDateTime createdAt;
 
         /**
-         * {@link ProductRevisionInfo}를 상품 변경 이력 응답 DTO로 변환하는 정적 팩토리 메서드.
+         * {@link ProductRevisionModel}을 상품 변경 이력 응답 DTO로 변환하는 정적 팩토리 메서드.
          *
-         * @param info 상품 변경 이력 정보 DTO
+         * @param model 상품 변경 이력 도메인 모델
          * @return 변환된 상품 변경 이력 응답 DTO
          */
-        public static RevisionResponse from(ProductRevisionInfo info) {
+        public static RevisionResponse from(ProductRevisionModel model) {
             return RevisionResponse.builder()
-                    .productId(info.getProductId())
-                    .revisionSeq(info.getRevisionSeq())
-                    .action(info.getAction())
-                    .changedBy(info.getChangedBy())
-                    .changeReason(info.getChangeReason())
-                    .beforeSnapshot(info.getBeforeSnapshot())
-                    .afterSnapshot(info.getAfterSnapshot())
-                    .createdAt(info.getCreatedAt())
+                    .productId(model.getProductId())
+                    .revisionSeq(model.getRevisionSeq())
+                    .action(model.getAction())
+                    .changedBy(model.getChangedBy())
+                    .changeReason(model.getChangeReason())
+                    .beforeSnapshot(model.getBeforeSnapshot())
+                    .afterSnapshot(model.getAfterSnapshot())
+                    .createdAt(model.getCreatedAt())
                     .build();
         }
     }
diff --git a/apps/commerce-api/src/main/java/com/loopers/interfaces/apiadmin/AdminStatsV1Controller.java b/apps/commerce-api/src/main/java/com/loopers/interfaces/apiadmin/AdminStatsV1Controller.java
index 1549ad34c..4fd2329cc 100644
--- a/apps/commerce-api/src/main/java/com/loopers/interfaces/apiadmin/AdminStatsV1Controller.java
+++ b/apps/commerce-api/src/main/java/com/loopers/interfaces/apiadmin/AdminStatsV1Controller.java
@@ -1,6 +1,6 @@
 package com.loopers.interfaces.apiadmin;
 
-import com.loopers.application.stats.StatsAppService;
+import com.loopers.domain.stats.StatsService;
 import com.loopers.interfaces.api.ApiResponse;
 import lombok.RequiredArgsConstructor;
 import org.springframework.format.annotation.DateTimeFormat;
@@ -13,14 +13,15 @@
 /**
  * 관리자 전용 운영 통계 REST API 엔드포인트를 제공하는 컨트롤러.
  *
- * <p>주문 현황 개요, 일별 주문 통계, 인기 상품(좋아요/주문 기준), 저재고 상품 조회 기능을 관리자에게 제공한다.</p>
+ * <p>주문 현황 개요, 일별 주문 통계, 인기 상품(좋아요/주문 기준), 저재고 상품 조회 기능을 관리자에게 제공한다.
+ * {@link StatsService}를 직접 호출한다.</p>
  */
 @RestController
 @RequestMapping("/api-admin/v1/stats")
 @RequiredArgsConstructor
 public class AdminStatsV1Controller {
 
-    private final StatsAppService statsAppService;
+    private final StatsService statsService;
 
     /**
      * 기간별 주문 현황 개요(대기/취소/만료 건수)를 조회한다.
@@ -33,7 +34,7 @@ public class AdminStatsV1Controller {
     public ResponseEntity<ApiResponse<AdminStatsV1Dto.OverviewResponse>> overview(
             @RequestParam("startAt") @DateTimeFormat(iso = DateTimeFormat.ISO.DATE) LocalDate startAt,
             @RequestParam("endAt") @DateTimeFormat(iso = DateTimeFormat.ISO.DATE) LocalDate endAt) {
-        var overview = statsAppService.getOverview(startAt, endAt);
+        var overview = statsService.getOverview(startAt, endAt);
         return ResponseEntity.ok(ApiResponse.success(AdminStatsV1Dto.OverviewResponse.from(overview)));
     }
 
@@ -48,7 +49,7 @@ public ResponseEntity<ApiResponse<AdminStatsV1Dto.OverviewResponse>> overview(
     public ResponseEntity<ApiResponse<List<AdminStatsV1Dto.DailyOrderStatResponse>>> dailyOrderStats(
             @RequestParam("startAt") @DateTimeFormat(iso = DateTimeFormat.ISO.DATE) LocalDate startAt,
             @RequestParam("endAt") @DateTimeFormat(iso = DateTimeFormat.ISO.DATE) LocalDate endAt) {
-        var stats = statsAppService.getDailyOrderStats(startAt, endAt);
+        var stats = statsService.getDailyOrderStats(startAt, endAt);
         List<AdminStatsV1Dto.DailyOrderStatResponse> response = stats.stream()
                 .map(AdminStatsV1Dto.DailyOrderStatResponse::from)
                 .toList();
@@ -64,7 +65,7 @@ public ResponseEntity<ApiResponse<List<AdminStatsV1Dto.DailyOrderStatResponse>>>
     @GetMapping("/products/top-liked")
     public ResponseEntity<ApiResponse<List<AdminStatsV1Dto.ProductStatResponse>>> topLikedProducts(
             @RequestParam(value = "limit", defaultValue = "10") int limit) {
-        var stats = statsAppService.getTopLikedProducts(limit);
+        var stats = statsService.getTopLikedProducts(limit);
         List<AdminStatsV1Dto.ProductStatResponse> response = stats.stream()
                 .map(AdminStatsV1Dto.ProductStatResponse::from)
                 .toList();
@@ -80,7 +81,7 @@ public ResponseEntity<ApiResponse<List<AdminStatsV1Dto.ProductStatResponse>>> to
     @GetMapping("/products/top-ordered")
     public ResponseEntity<ApiResponse<List<AdminStatsV1Dto.ProductStatResponse>>> topOrderedProducts(
             @RequestParam(value = "limit", defaultValue = "10") int limit) {
-        var stats = statsAppService.getTopOrderedProducts(limit);
+        var stats = statsService.getTopOrderedProducts(limit);
         List<AdminStatsV1Dto.ProductStatResponse> response = stats.stream()
                 .map(AdminStatsV1Dto.ProductStatResponse::from)
                 .toList();
@@ -96,7 +97,7 @@ public ResponseEntity<ApiResponse<List<AdminStatsV1Dto.ProductStatResponse>>> to
     @GetMapping("/stocks/low")
     public ResponseEntity<ApiResponse<List<AdminStatsV1Dto.LowStockProductResponse>>> lowStockProducts(
             @RequestParam(value = "threshold", defaultValue = "10") int threshold) {
-        var stocks = statsAppService.getLowStockProducts(threshold);
+        var stocks = statsService.getLowStockProducts(threshold);
         List<AdminStatsV1Dto.LowStockProductResponse> response = stocks.stream()
                 .map(AdminStatsV1Dto.LowStockProductResponse::from)
                 .toList();
diff --git a/apps/commerce-api/src/main/java/com/loopers/interfaces/apiadmin/AdminStatsV1Dto.java b/apps/commerce-api/src/main/java/com/loopers/interfaces/apiadmin/AdminStatsV1Dto.java
index 3199e52d3..3199ed3f9 100644
--- a/apps/commerce-api/src/main/java/com/loopers/interfaces/apiadmin/AdminStatsV1Dto.java
+++ b/apps/commerce-api/src/main/java/com/loopers/interfaces/apiadmin/AdminStatsV1Dto.java
@@ -1,6 +1,6 @@
 package com.loopers.interfaces.apiadmin;
 
-import com.loopers.application.stats.StatsInfo;
+import com.loopers.domain.stats.StatsProjection;
 import lombok.AllArgsConstructor;
 import lombok.Builder;
 import lombok.Getter;
@@ -27,16 +27,16 @@ public static class OverviewResponse {
         private long expiredCount;
 
         /**
-         * {@link StatsInfo.Overview}를 주문 현황 개요 응답 DTO로 변환하는 정적 팩토리 메서드.
+         * {@link StatsProjection.Overview}를 주문 현황 개요 응답 DTO로 변환하는 정적 팩토리 메서드.
          *
-         * @param overview 주문 현황 개요 정보
+         * @param projection 주문 현황 개요 프로젝션
          * @return 변환된 주문 현황 개요 응답 DTO
          */
-        public static OverviewResponse from(StatsInfo.Overview overview) {
+        public static OverviewResponse from(StatsProjection.Overview projection) {
             return OverviewResponse.builder()
-                    .pendingCount(overview.getPendingCount())
-                    .cancelledCount(overview.getCancelledCount())
-                    .expiredCount(overview.getExpiredCount())
+                    .pendingCount(projection.getPendingCount())
+                    .cancelledCount(projection.getCancelledCount())
+                    .expiredCount(projection.getExpiredCount())
                     .build();
         }
     }
@@ -55,16 +55,16 @@ public static class DailyOrderStatResponse {
         private BigDecimal totalAmount;
 
         /**
-         * {@link StatsInfo.DailyOrderStat}을 일별 주문 통계 응답 DTO로 변환하는 정적 팩토리 메서드.
+         * {@link StatsProjection.DailyOrderStat}을 일별 주문 통계 응답 DTO로 변환하는 정적 팩토리 메서드.
          *
-         * @param stat 일별 주문 통계 정보
+         * @param projection 일별 주문 통계 프로젝션
          * @return 변환된 일별 주문 통계 응답 DTO
          */
-        public static DailyOrderStatResponse from(StatsInfo.DailyOrderStat stat) {
+        public static DailyOrderStatResponse from(StatsProjection.DailyOrderStat projection) {
             return DailyOrderStatResponse.builder()
-                    .date(stat.getDate())
-                    .orderCount(stat.getOrderCount())
-                    .totalAmount(stat.getTotalAmount())
+                    .date(projection.getDate())
+                    .orderCount(projection.getOrderCount())
+                    .totalAmount(projection.getTotalAmount())
                     .build();
         }
     }
@@ -78,21 +78,21 @@ public static DailyOrderStatResponse from(StatsInfo.DailyOrderStat stat) {
     @AllArgsConstructor
     @Builder
     public static class ProductStatResponse {
-        private String productId;
+        private Long productId;
         private String productName;
         private long count;
 
         /**
-         * {@link StatsInfo.ProductStat}을 상품 통계 응답 DTO로 변환하는 정적 팩토리 메서드.
+         * {@link StatsProjection.ProductStat}을 상품 통계 응답 DTO로 변환하는 정적 팩토리 메서드.
          *
-         * @param stat 상품 통계 정보
+         * @param projection 상품 통계 프로젝션
          * @return 변환된 상품 통계 응답 DTO
          */
-        public static ProductStatResponse from(StatsInfo.ProductStat stat) {
+        public static ProductStatResponse from(StatsProjection.ProductStat projection) {
             return ProductStatResponse.builder()
-                    .productId(stat.getProductId())
-                    .productName(stat.getProductName())
-                    .count(stat.getCount())
+                    .productId(projection.getProductId())
+                    .productName(projection.getProductName())
+                    .count(projection.getCount())
                     .build();
         }
     }
@@ -106,25 +106,25 @@ public static ProductStatResponse from(StatsInfo.ProductStat stat) {
     @AllArgsConstructor
     @Builder
     public static class LowStockProductResponse {
-        private String productId;
+        private Long productId;
         private String productName;
         private int onHand;
         private int reserved;
         private int availableQty;
 
         /**
-         * {@link StatsInfo.LowStockProduct}를 저재고 상품 응답 DTO로 변환하는 정적 팩토리 메서드.
+         * {@link StatsProjection.LowStockProduct}를 저재고 상품 응답 DTO로 변환하는 정적 팩토리 메서드.
          *
-         * @param stock 저재고 상품 정보
+         * @param projection 저재고 상품 프로젝션
          * @return 변환된 저재고 상품 응답 DTO
          */
-        public static LowStockProductResponse from(StatsInfo.LowStockProduct stock) {
+        public static LowStockProductResponse from(StatsProjection.LowStockProduct projection) {
             return LowStockProductResponse.builder()
-                    .productId(stock.getProductId())
-                    .productName(stock.getProductName())
-                    .onHand(stock.getOnHand())
-                    .reserved(stock.getReserved())
-                    .availableQty(stock.getAvailableQty())
+                    .productId(projection.getProductId())
+                    .productName(projection.getProductName())
+                    .onHand(projection.getOnHand())
+                    .reserved(projection.getReserved())
+                    .availableQty(projection.getAvailableQty())
                     .build();
         }
     }
diff --git a/apps/commerce-api/src/main/java/com/loopers/interfaces/config/WebMvcConfig.java b/apps/commerce-api/src/main/java/com/loopers/interfaces/config/WebMvcConfig.java
index cdd108beb..b78421d74 100644
--- a/apps/commerce-api/src/main/java/com/loopers/interfaces/config/WebMvcConfig.java
+++ b/apps/commerce-api/src/main/java/com/loopers/interfaces/config/WebMvcConfig.java
@@ -1,27 +1,35 @@
 package com.loopers.interfaces.config;
 
+import com.loopers.interfaces.api.AuthUserArgumentResolver;
+import com.loopers.interfaces.api.CustomerAuthInterceptor;
 import com.loopers.interfaces.apiadmin.AdminAuthInterceptor;
 import lombok.RequiredArgsConstructor;
 import org.springframework.context.annotation.Configuration;
+import org.springframework.web.method.support.HandlerMethodArgumentResolver;
 import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
 import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
 
+import java.util.List;
+
 /**
  * Spring MVC 설정 클래스.
  *
  * <p>인터셉터 등록 등 웹 계층의 공통 설정을 담당한다.
- * 관리자 API({@code /api-admin/**}) 경로에 대한 인증 인터셉터를 등록한다.</p>
+ * 관리자 API({@code /api-admin/**}) 경로와 고객 API 인증 경로에 대한 인터셉터를 등록한다.</p>
  */
 @Configuration
 @RequiredArgsConstructor
 public class WebMvcConfig implements WebMvcConfigurer {
 
     private final AdminAuthInterceptor adminAuthInterceptor;
+    private final CustomerAuthInterceptor customerAuthInterceptor;
+    private final AuthUserArgumentResolver authUserArgumentResolver;
 
     /**
      * 인터셉터를 등록한다.
      *
-     * <p>관리자 API 경로({@code /api-admin/**})에 {@link AdminAuthInterceptor}를 적용한다.</p>
+     * <p>관리자 API 경로({@code /api-admin/**})에 {@link AdminAuthInterceptor}를 적용하고,
+     * 고객 인증 필요 API 경로에 {@link CustomerAuthInterceptor}를 적용한다.</p>
      *
      * @param registry 인터셉터 레지스트리
      */
@@ -29,5 +37,24 @@ public class WebMvcConfig implements WebMvcConfigurer {
     public void addInterceptors(InterceptorRegistry registry) {
         registry.addInterceptor(adminAuthInterceptor)
                 .addPathPatterns("/api-admin/**");
+
+        registry.addInterceptor(customerAuthInterceptor)
+                .addPathPatterns("/api/v1/users/me/**")
+                .addPathPatterns("/api/v1/products/*/likes")
+                .addPathPatterns("/api/v1/cart/**")
+                .addPathPatterns("/api/v1/orders/**")
+                .addPathPatterns("/api/v1/coupons/**");
+    }
+
+    /**
+     * ArgumentResolver를 등록한다.
+     *
+     * <p>{@link AuthUserArgumentResolver}를 등록하여 {@code @AuthUser} 어노테이션을 지원한다.</p>
+     *
+     * @param resolvers ArgumentResolver 목록
+     */
+    @Override
+    public void addArgumentResolvers(List<HandlerMethodArgumentResolver> resolvers) {
+        resolvers.add(authUserArgumentResolver);
     }
 }
diff --git a/apps/commerce-api/src/main/java/com/loopers/support/enums/DiscountType.java b/apps/commerce-api/src/main/java/com/loopers/support/enums/DiscountType.java
new file mode 100644
index 000000000..6d2bd2087
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/support/enums/DiscountType.java
@@ -0,0 +1,9 @@
+package com.loopers.support.enums;
+
+/**
+ * 쿠폰 할인 유형.
+ */
+public enum DiscountType {
+    FIXED,  // 고정 금액 할인
+    RATE    // 정률(%) 할인
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/support/enums/UserCouponStatus.java b/apps/commerce-api/src/main/java/com/loopers/support/enums/UserCouponStatus.java
new file mode 100644
index 000000000..526773f6d
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/support/enums/UserCouponStatus.java
@@ -0,0 +1,10 @@
+package com.loopers.support.enums;
+
+/**
+ * 사용자 발급 쿠폰 상태.
+ */
+public enum UserCouponStatus {
+    AVAILABLE,  // 사용 가능
+    USED,       // 사용 완료
+    EXPIRED     // 만료
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/support/error/ErrorType.java b/apps/commerce-api/src/main/java/com/loopers/support/error/ErrorType.java
index 442d7dde1..54e0bd77f 100644
--- a/apps/commerce-api/src/main/java/com/loopers/support/error/ErrorType.java
+++ b/apps/commerce-api/src/main/java/com/loopers/support/error/ErrorType.java
@@ -55,7 +55,14 @@ public enum ErrorType {
     ORDER_PENDING_LIMIT_EXCEEDED(HttpStatus.CONFLICT, "ORDER_PENDING_LIMIT_EXCEEDED", "동시 결제 대기 주문은 최대 3건까지 가능합니다."),
 
     /** Admin */
-    ADMIN_UNAUTHORIZED(HttpStatus.UNAUTHORIZED, "ADMIN_UNAUTHORIZED", "관리자 인증에 실패했습니다.");
+    ADMIN_UNAUTHORIZED(HttpStatus.UNAUTHORIZED, "ADMIN_UNAUTHORIZED", "관리자 인증에 실패했습니다."),
+
+    /** Coupon */
+    COUPON_NOT_FOUND(HttpStatus.NOT_FOUND, "COUPON_NOT_FOUND", "쿠폰을 찾을 수 없습니다."),
+    COUPON_ALREADY_ISSUED(HttpStatus.CONFLICT, "COUPON_ALREADY_ISSUED", "이미 발급된 쿠폰입니다."),
+    COUPON_NOT_APPLICABLE(HttpStatus.BAD_REQUEST, "COUPON_NOT_APPLICABLE", "적용할 수 없는 쿠폰입니다."),
+    COUPON_NOT_AVAILABLE(HttpStatus.BAD_REQUEST, "COUPON_NOT_AVAILABLE", "사용 불가능한 쿠폰입니다."),
+    USER_COUPON_NOT_FOUND(HttpStatus.NOT_FOUND, "USER_COUPON_NOT_FOUND", "발급된 쿠폰을 찾을 수 없습니다.");
 
     private final HttpStatus status;
     private final String code;
diff --git a/apps/commerce-api/src/main/java/com/loopers/support/page/PageQuery.java b/apps/commerce-api/src/main/java/com/loopers/support/page/PageQuery.java
new file mode 100644
index 000000000..cb751e9aa
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/support/page/PageQuery.java
@@ -0,0 +1,15 @@
+package com.loopers.support.page;
+
+/**
+ * 도메인 레이어에서 사용하는 페이징/정렬 요청 객체.
+ *
+ * <p>Spring Data의 {@code Pageable}에 의존하지 않으며,
+ * infrastructure 계층에서 {@code Pageable}로 변환하여 사용한다.</p>
+ *
+ * @param page      페이지 번호 (0부터 시작)
+ * @param size      페이지 크기
+ * @param sortField 정렬 기준 필드명 (엔티티 필드명)
+ * @param ascending true이면 오름차순, false이면 내림차순
+ */
+public record PageQuery(int page, int size, String sortField, boolean ascending) {
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/support/page/PagedResult.java b/apps/commerce-api/src/main/java/com/loopers/support/page/PagedResult.java
new file mode 100644
index 000000000..19d4445e2
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/support/page/PagedResult.java
@@ -0,0 +1,19 @@
+package com.loopers.support.page;
+
+import java.util.List;
+
+/**
+ * 도메인 레이어에서 사용하는 페이징 결과 객체.
+ *
+ * <p>Spring Data의 {@code Page<T>}에 의존하지 않으며,
+ * infrastructure 계층에서 {@code Page<T>}를 변환하여 반환한다.</p>
+ *
+ * @param content       현재 페이지의 콘텐츠 목록
+ * @param page          현재 페이지 번호 (0부터 시작)
+ * @param size          페이지 크기
+ * @param totalElements 전체 요소 수
+ * @param totalPages    전체 페이지 수
+ * @param <T>           콘텐츠 요소 타입
+ */
+public record PagedResult<T>(List<T> content, int page, int size, long totalElements, int totalPages) {
+}
diff --git a/apps/commerce-api/src/test/java/com/loopers/application/cart/CartAppServiceTest.java b/apps/commerce-api/src/test/java/com/loopers/application/cart/CartAppServiceTest.java
deleted file mode 100644
index 34d7f6b1f..000000000
--- a/apps/commerce-api/src/test/java/com/loopers/application/cart/CartAppServiceTest.java
+++ /dev/null
@@ -1,40 +0,0 @@
-package com.loopers.application.cart;
-
-import com.loopers.domain.cart.CartService;
-import com.loopers.domain.user.UserModel;
-import com.loopers.domain.user.UserService;
-import org.junit.jupiter.api.DisplayName;
-import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.extension.ExtendWith;
-import org.mockito.InjectMocks;
-import org.mockito.Mock;
-import org.mockito.junit.jupiter.MockitoExtension;
-
-import static org.mockito.Mockito.*;
-
-@ExtendWith(MockitoExtension.class)
-@DisplayName("CartAppService 단위 테스트")
-class CartAppServiceTest {
-
-    @Mock
-    CartService cartService;
-
-    @Mock
-    UserService userService;
-
-    @InjectMocks
-    CartAppService cartAppService;
-
-    @Test
-    @DisplayName("항목 삭제 시 인증 후 CartService.removeItem이 호출된다")
-    void removeItem_ShouldCallServiceMethod() {
-        UserModel user = mock(UserModel.class);
-        when(user.getUserId()).thenReturn("user-1");
-        when(userService.authenticate("login1", "pw1")).thenReturn(user);
-
-        cartAppService.removeItem("login1", "pw1", "p1");
-
-        verify(userService).authenticate("login1", "pw1");
-        verify(cartService).removeItem("user-1", "p1");
-    }
-}
diff --git a/apps/commerce-api/src/test/java/com/loopers/application/cart/CartFacadeTest.java b/apps/commerce-api/src/test/java/com/loopers/application/cart/CartFacadeTest.java
index db45551be..df9c077f3 100644
--- a/apps/commerce-api/src/test/java/com/loopers/application/cart/CartFacadeTest.java
+++ b/apps/commerce-api/src/test/java/com/loopers/application/cart/CartFacadeTest.java
@@ -9,8 +9,6 @@
 import com.loopers.domain.product.ProductService;
 import com.loopers.domain.product.ProductStockModel;
 import com.loopers.domain.product.StockService;
-import com.loopers.domain.user.UserModel;
-import com.loopers.domain.user.UserService;
 import com.loopers.support.error.CoreException;
 import com.loopers.support.error.ErrorType;
 import org.junit.jupiter.api.DisplayName;
@@ -33,8 +31,9 @@
 @DisplayName("CartFacade 단위 테스트")
 class CartFacadeTest {
 
+    private static final Long USER_ID = 1L;
+
     @Mock CartService cartService;
-    @Mock UserService userService;
     @Mock ProductService productService;
     @Mock StockService stockService;
     @Mock BrandService brandService;
@@ -42,15 +41,8 @@ class CartFacadeTest {
     @InjectMocks
     CartFacade cartFacade;
 
-    private UserModel mockAuthenticate() {
-        UserModel user = mock(UserModel.class);
-        when(user.getUserId()).thenReturn("user-1");
-        when(userService.authenticate("login1", "pw1")).thenReturn(user);
-        return user;
-    }
-
     private ProductModel createTestProduct() {
-        return ProductModel.create("테스트상품", "brand-id", BigDecimal.valueOf(10000),
+        return ProductModel.create("테스트상품", 1L, BigDecimal.valueOf(10000),
                 "설명", null, null, null, null, null, null);
     }
 
@@ -63,33 +55,31 @@ private BrandModel createTestBrand() {
     class GetCartTests {
 
         @Test
-        @DisplayName("인증 후 장바구니 항목 + 상품/브랜드/재고 정보를 배치 조회하여 반환한다")
+        @DisplayName("장바구니 항목 + 상품/브랜드/재고 정보를 배치 조회하여 반환한다")
         void getCart_ShouldReturnCartInfoListWithProductInfo() {
-            mockAuthenticate();
             ProductModel product = mock(ProductModel.class);
-            when(product.getProductId()).thenReturn("product-1");
+            when(product.getProductId()).thenReturn(1L);
             when(product.getProductName()).thenReturn("테스트상품");
-            when(product.getBrandId()).thenReturn("brand-id");
+            when(product.getBrandId()).thenReturn(1L);
             when(product.getPrice()).thenReturn(BigDecimal.valueOf(10000));
 
             BrandModel brand = mock(BrandModel.class);
-            when(brand.getBrandId()).thenReturn("brand-id");
+            when(brand.getBrandId()).thenReturn(1L);
             when(brand.getBrandName()).thenReturn("테스트브랜드");
 
-            CartItemModel item = CartItemModel.create("user-1", "product-1", 2);
-            when(cartService.getCartItems("user-1")).thenReturn(List.of(item));
+            CartItemModel item = CartItemModel.create(USER_ID, 1L, 2);
+            when(cartService.getCartItems(USER_ID)).thenReturn(List.of(item));
             when(productService.findAllByIds(anyCollection())).thenReturn(List.of(product));
             when(brandService.findAllByIds(anyCollection())).thenReturn(List.of(brand));
             when(stockService.findAllByProductIds(anyCollection()))
-                    .thenReturn(List.of(ProductStockModel.create("product-1", 100)));
+                    .thenReturn(List.of(ProductStockModel.create(1L, 100)));
 
-            List<CartInfo> result = cartFacade.getCart("login1", "pw1");
+            List<CartInfo> result = cartFacade.getCart(USER_ID);
 
             assertThat(result).hasSize(1);
             assertThat(result.get(0).isAvailable()).isTrue();
             assertThat(result.get(0).getProductName()).isEqualTo("테스트상품");
-            verify(userService).authenticate("login1", "pw1");
-            verify(cartService).getCartItems("user-1");
+            verify(cartService).getCartItems(USER_ID);
             verify(productService).findAllByIds(anyCollection());
             verify(brandService).findAllByIds(anyCollection());
             verify(stockService).findAllByProductIds(anyCollection());
@@ -98,10 +88,9 @@ void getCart_ShouldReturnCartInfoListWithProductInfo() {
         @Test
         @DisplayName("빈 장바구니 조회 시 빈 리스트를 반환한다")
         void getCart_EmptyCart_ShouldReturnEmptyList() {
-            mockAuthenticate();
-            when(cartService.getCartItems("user-1")).thenReturn(List.of());
+            when(cartService.getCartItems(USER_ID)).thenReturn(List.of());
 
-            List<CartInfo> result = cartFacade.getCart("login1", "pw1");
+            List<CartInfo> result = cartFacade.getCart(USER_ID);
 
             assertThat(result).isEmpty();
             verify(productService, never()).findAllByIds(anyCollection());
@@ -113,34 +102,31 @@ void getCart_EmptyCart_ShouldReturnEmptyList() {
     class AddItemTests {
 
         @Test
-        @DisplayName("인증 → 상품 검증 → 재고 검증 → 장바구니 추가 오케스트레이션이 수행된다")
+        @DisplayName("상품 검증 → 재고 검증 → 장바구니 추가 오케스트레이션이 수행된다")
         void addItem_ShouldOrchestrate() {
-            mockAuthenticate();
-            when(productService.findOrderableById("p1")).thenReturn(createTestProduct());
-            when(stockService.findByProductId("p1"))
-                    .thenReturn(ProductStockModel.create("p1", 100));
+            when(productService.findOrderableById(1L)).thenReturn(createTestProduct());
+            when(stockService.findByProductId(1L))
+                    .thenReturn(ProductStockModel.create(1L, 100));
 
-            cartFacade.addItem("login1", "pw1", "p1", 3);
+            cartFacade.addItem(USER_ID, 1L, 3);
 
-            verify(userService).authenticate("login1", "pw1");
-            verify(productService).findOrderableById("p1");
-            verify(stockService).findByProductId("p1");
-            verify(cartService).addItem("user-1", "p1", 3);
+            verify(productService).findOrderableById(1L);
+            verify(stockService).findByProductId(1L);
+            verify(cartService).addItem(USER_ID, 1L, 3);
         }
 
         @Test
         @DisplayName("가용 재고 초과 시 CART_STOCK_EXCEEDED 예외가 발생한다")
         void addItem_ExceedAvailableStock_ShouldThrow() {
-            mockAuthenticate();
-            when(productService.findOrderableById("p1")).thenReturn(createTestProduct());
-            when(stockService.findByProductId("p1"))
-                    .thenReturn(ProductStockModel.create("p1", 5));
+            when(productService.findOrderableById(1L)).thenReturn(createTestProduct());
+            when(stockService.findByProductId(1L))
+                    .thenReturn(ProductStockModel.create(1L, 5));
 
-            assertThatThrownBy(() -> cartFacade.addItem("login1", "pw1", "p1", 10))
+            assertThatThrownBy(() -> cartFacade.addItem(USER_ID, 1L, 10))
                     .isInstanceOf(CoreException.class)
                     .satisfies(ex -> assertThat(((CoreException) ex).getErrorType())
                             .isEqualTo(ErrorType.CART_STOCK_EXCEEDED));
-            verify(cartService, never()).addItem(anyString(), anyString(), anyInt());
+            verify(cartService, never()).addItem(anyLong(), anyLong(), anyInt());
         }
     }
 
@@ -149,31 +135,28 @@ void addItem_ExceedAvailableStock_ShouldThrow() {
     class ChangeQuantityTests {
 
         @Test
-        @DisplayName("인증 → 재고 검증 → 수량 변경 오케스트레이션이 수행된다")
+        @DisplayName("재고 검증 → 수량 변경 오케스트레이션이 수행된다")
         void changeQuantity_ShouldOrchestrate() {
-            mockAuthenticate();
-            when(stockService.findByProductId("p1"))
-                    .thenReturn(ProductStockModel.create("p1", 100));
+            when(stockService.findByProductId(1L))
+                    .thenReturn(ProductStockModel.create(1L, 100));
 
-            cartFacade.changeQuantity("login1", "pw1", "p1", 5);
+            cartFacade.changeQuantity(USER_ID, 1L, 5);
 
-            verify(userService).authenticate("login1", "pw1");
-            verify(stockService).findByProductId("p1");
-            verify(cartService).changeQuantity("user-1", "p1", 5);
+            verify(stockService).findByProductId(1L);
+            verify(cartService).changeQuantity(USER_ID, 1L, 5);
         }
 
         @Test
         @DisplayName("가용 재고 초과 시 CART_STOCK_EXCEEDED 예외가 발생한다")
         void changeQuantity_ExceedAvailableStock_ShouldThrow() {
-            mockAuthenticate();
-            when(stockService.findByProductId("p1"))
-                    .thenReturn(ProductStockModel.create("p1", 3));
+            when(stockService.findByProductId(1L))
+                    .thenReturn(ProductStockModel.create(1L, 3));
 
-            assertThatThrownBy(() -> cartFacade.changeQuantity("login1", "pw1", "p1", 10))
+            assertThatThrownBy(() -> cartFacade.changeQuantity(USER_ID, 1L, 10))
                     .isInstanceOf(CoreException.class)
                     .satisfies(ex -> assertThat(((CoreException) ex).getErrorType())
                             .isEqualTo(ErrorType.CART_STOCK_EXCEEDED));
-            verify(cartService, never()).changeQuantity(anyString(), anyString(), anyInt());
+            verify(cartService, never()).changeQuantity(anyLong(), anyLong(), anyInt());
         }
     }
 
diff --git a/apps/commerce-api/src/test/java/com/loopers/application/order/OrderAppServiceTest.java b/apps/commerce-api/src/test/java/com/loopers/application/order/OrderAppServiceTest.java
deleted file mode 100644
index 8124d69a0..000000000
--- a/apps/commerce-api/src/test/java/com/loopers/application/order/OrderAppServiceTest.java
+++ /dev/null
@@ -1,105 +0,0 @@
-package com.loopers.application.order;
-
-import com.loopers.domain.order.OrderItemModel;
-import com.loopers.domain.order.OrderModel;
-import com.loopers.domain.order.OrderService;
-import com.loopers.domain.user.UserModel;
-import com.loopers.domain.user.UserService;
-import com.loopers.support.enums.OrderType;
-import org.junit.jupiter.api.DisplayName;
-import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.extension.ExtendWith;
-import org.mockito.InjectMocks;
-import org.mockito.Mock;
-import org.mockito.junit.jupiter.MockitoExtension;
-
-import java.math.BigDecimal;
-import java.time.LocalDateTime;
-import java.util.List;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.Mockito.*;
-
-@ExtendWith(MockitoExtension.class)
-@DisplayName("OrderAppService 단위 테스트")
-class OrderAppServiceTest {
-
-    @Mock
-    OrderService orderService;
-
-    @Mock
-    UserService userService;
-
-    @InjectMocks
-    OrderAppService orderAppService;
-
-    private UserModel mockAuthenticate() {
-        UserModel user = mock(UserModel.class);
-        when(user.getUserId()).thenReturn("user-1");
-        when(userService.authenticate("login1", "pw1")).thenReturn(user);
-        return user;
-    }
-
-    @Test
-    @DisplayName("주문 상세 조회 시 인증 후 스냅샷 포함 OrderInfo를 반환한다")
-    void getOrderDetail_ShouldReturnOrderInfoWithSnapshots() {
-        mockAuthenticate();
-        OrderModel order = OrderModel.create("user-1", OrderType.DIRECT, BigDecimal.valueOf(30000));
-        when(orderService.findByIdAndUserId("order-1", "user-1")).thenReturn(order);
-        when(orderService.findOrderItems(any())).thenReturn(List.of());
-
-        OrderInfo result = orderAppService.getOrderDetail("login1", "pw1", "order-1");
-
-        assertThat(result).isNotNull();
-        verify(userService).authenticate("login1", "pw1");
-        verify(orderService).findByIdAndUserId("order-1", "user-1");
-    }
-
-    @Test
-    @DisplayName("내 주문 목록 조회 시 인증 후 OrderInfo 리스트를 반환한다")
-    void getOrders_ShouldReturnOrderInfoList() {
-        mockAuthenticate();
-        LocalDateTime start = LocalDateTime.of(2026, 1, 1, 0, 0);
-        LocalDateTime end = LocalDateTime.of(2026, 1, 31, 23, 59);
-        OrderModel order = OrderModel.create("user-1", OrderType.DIRECT, BigDecimal.valueOf(10000));
-        when(orderService.findAllByUserId("user-1", start, end)).thenReturn(List.of(order));
-        when(orderService.findOrderItems(any())).thenReturn(List.of());
-
-        List<OrderInfo> result = orderAppService.getOrders("login1", "pw1", start, end);
-
-        assertThat(result).hasSize(1);
-        verify(userService).authenticate("login1", "pw1");
-        verify(orderService).findAllByUserId("user-1", start, end);
-    }
-
-    @Test
-    @DisplayName("관리자용 주문 상세 조회 시 인증 없이 OrderInfo를 반환한다")
-    void findOrderById_ShouldReturnOrderInfo() {
-        OrderModel order = OrderModel.create("user-1", OrderType.DIRECT, BigDecimal.valueOf(20000));
-        when(orderService.findOrderById("order-1")).thenReturn(order);
-        when(orderService.findOrderItems(any())).thenReturn(List.of());
-
-        OrderInfo result = orderAppService.findOrderById("order-1");
-
-        assertThat(result).isNotNull();
-        verify(orderService).findOrderById("order-1");
-        verifyNoInteractions(userService);
-    }
-
-    @Test
-    @DisplayName("관리자용 주문 목록 조회 시 인증 없이 OrderInfo 리스트를 반환한다")
-    void findAllOrders_ShouldReturnOrderInfoList() {
-        LocalDateTime start = LocalDateTime.of(2026, 1, 1, 0, 0);
-        LocalDateTime end = LocalDateTime.of(2026, 1, 31, 23, 59);
-        OrderModel order = OrderModel.create("user-1", OrderType.CART, BigDecimal.valueOf(15000));
-        when(orderService.findAllOrders(start, end)).thenReturn(List.of(order));
-        when(orderService.findOrderItems(any())).thenReturn(List.of());
-
-        List<OrderInfo> result = orderAppService.findAllOrders(start, end);
-
-        assertThat(result).hasSize(1);
-        verify(orderService).findAllOrders(start, end);
-        verifyNoInteractions(userService);
-    }
-}
diff --git a/apps/commerce-api/src/test/java/com/loopers/application/order/OrderFacadeTest.java b/apps/commerce-api/src/test/java/com/loopers/application/order/OrderFacadeTest.java
index 5a88ea6a0..d5155e934 100644
--- a/apps/commerce-api/src/test/java/com/loopers/application/order/OrderFacadeTest.java
+++ b/apps/commerce-api/src/test/java/com/loopers/application/order/OrderFacadeTest.java
@@ -3,18 +3,18 @@
 import com.loopers.domain.brand.BrandModel;
 import com.loopers.domain.brand.BrandService;
 import com.loopers.domain.cart.CartService;
+import com.loopers.domain.coupon.CouponModel;
+import com.loopers.domain.coupon.CouponService;
+import com.loopers.domain.coupon.UserCouponModel;
 import com.loopers.domain.order.OrderCartRestoreModel;
 import com.loopers.domain.order.OrderItemCommand;
 import com.loopers.domain.order.OrderItemModel;
-import com.loopers.domain.order.OrderItemSnapshot;
 import com.loopers.domain.order.OrderModel;
 import com.loopers.domain.order.OrderService;
 import com.loopers.domain.product.ProductModel;
 import com.loopers.domain.product.ProductService;
 import com.loopers.domain.product.StockService;
-import com.loopers.domain.user.UserModel;
-import com.loopers.domain.user.UserService;
-import com.loopers.support.enums.OrderStatus;
+import com.loopers.support.enums.DiscountType;
 import com.loopers.support.enums.OrderType;
 import com.loopers.support.error.CoreException;
 import com.loopers.support.error.ErrorType;
@@ -27,6 +27,7 @@
 import org.mockito.junit.jupiter.MockitoExtension;
 
 import java.math.BigDecimal;
+import java.time.LocalDateTime;
 import java.util.List;
 import java.util.Optional;
 
@@ -38,30 +39,27 @@
 @DisplayName("OrderFacade 단위 테스트")
 class OrderFacadeTest {
 
+    private static final Long USER_ID = 1L;
+    private static final Long USER_COUPON_ID = 100L;
+    private static final Long COUPON_ID = 10L;
+
     @Mock OrderService orderService;
-    @Mock UserService userService;
     @Mock ProductService productService;
     @Mock BrandService brandService;
     @Mock StockService stockService;
     @Mock CartService cartService;
+    @Mock CouponService couponService;
 
     @InjectMocks
     OrderFacade orderFacade;
 
-    private UserModel mockAuthenticate() {
-        UserModel user = mock(UserModel.class);
-        when(user.getUserId()).thenReturn("user-1");
-        when(userService.authenticate("login1", "pw1")).thenReturn(user);
-        return user;
-    }
-
     private ProductModel createTestProduct() {
-        return ProductModel.create("테스트상품", "brand-id", BigDecimal.valueOf(10000),
+        return ProductModel.create("테스트상품", 1L, BigDecimal.valueOf(10000),
                 "설명", null, null, null, null, null, null);
     }
 
-    private ProductModel createTestProduct(String productId) {
-        return ProductModel.create("테스트상품-" + productId, "brand-id", BigDecimal.valueOf(10000),
+    private ProductModel createTestProduct(Long productId) {
+        return ProductModel.create("테스트상품-" + productId, 1L, BigDecimal.valueOf(10000),
                 "설명", null, null, null, null, null, null);
     }
 
@@ -70,13 +68,13 @@ private BrandModel createTestBrand() {
     }
 
     private void setupOrderCreationMocks() {
-        List<OrderItemCommand> merged = List.of(new OrderItemCommand("product-1", 2));
-        when(orderService.validateAndPrepare("user-1", anyList())).thenReturn(merged);
-        when(productService.findOrderableById("product-1")).thenReturn(createTestProduct());
-        when(brandService.findById("brand-id")).thenReturn(createTestBrand());
+        List<OrderItemCommand> merged = List.of(new OrderItemCommand(1L, 2));
+        when(orderService.validateAndPrepare(eq(USER_ID), anyList())).thenReturn(merged);
+        when(productService.findOrderableById(1L)).thenReturn(createTestProduct());
+        when(brandService.findById(1L)).thenReturn(createTestBrand());
 
-        OrderModel savedOrder = OrderModel.create("user-1", OrderType.DIRECT, BigDecimal.valueOf(20000));
-        when(orderService.createOrder(eq("user-1"), any(OrderType.class), any(BigDecimal.class), anyList()))
+        OrderModel savedOrder = OrderModel.create(USER_ID, OrderType.DIRECT, BigDecimal.valueOf(20000));
+        when(orderService.createOrder(eq(USER_ID), any(OrderType.class), any(BigDecimal.class), anyList()))
                 .thenReturn(savedOrder);
         when(orderService.findOrderItems(any())).thenReturn(List.of());
     }
@@ -90,49 +88,45 @@ class DirectOrderTests {
         @Test
         @DisplayName("상품 검증 → 재고 hold → 주문 저장의 전체 플로우가 수행된다")
         void createDirectOrder_ShouldValidateProduct_ReserveStock_SaveOrder() {
-            mockAuthenticate();
             setupOrderCreationMocks();
 
-            List<OrderItemCommand> items = List.of(new OrderItemCommand("product-1", 2));
-            OrderInfo result = orderFacade.createDirectOrder("login1", "pw1", items);
+            List<OrderItemCommand> items = List.of(new OrderItemCommand(1L, 2));
+            OrderInfo result = orderFacade.createDirectOrder(USER_ID, items, null);
 
             assertThat(result).isNotNull();
-            verify(userService).authenticate("login1", "pw1");
-            verify(productService).findOrderableById("product-1");
-            verify(stockService).hold("product-1", 2);
-            verify(orderService).createOrder(eq("user-1"), eq(OrderType.DIRECT), any(BigDecimal.class), anyList());
+            verify(productService).findOrderableById(1L);
+            verify(stockService).hold(1L, 2);
+            verify(orderService).createOrder(eq(USER_ID), eq(OrderType.DIRECT), any(BigDecimal.class), anyList());
         }
 
         @Test
         @DisplayName("주문 불가 상품으로 주문 시 예외가 발생하고 hold가 호출되지 않는다")
         void createDirectOrder_ProductNotOrderable_ShouldThrow() {
-            mockAuthenticate();
-            List<OrderItemCommand> merged = List.of(new OrderItemCommand("product-1", 2));
-            when(orderService.validateAndPrepare("user-1", anyList())).thenReturn(merged);
-            when(productService.findOrderableById("product-1"))
+            List<OrderItemCommand> merged = List.of(new OrderItemCommand(1L, 2));
+            when(orderService.validateAndPrepare(eq(USER_ID), anyList())).thenReturn(merged);
+            when(productService.findOrderableById(1L))
                     .thenThrow(new CoreException(ErrorType.PRODUCT_NOT_ORDERABLE));
 
-            assertThatThrownBy(() -> orderFacade.createDirectOrder("login1", "pw1",
-                    List.of(new OrderItemCommand("product-1", 2))))
+            assertThatThrownBy(() -> orderFacade.createDirectOrder(USER_ID,
+                    List.of(new OrderItemCommand(1L, 2)), null))
                     .isInstanceOf(CoreException.class)
                     .satisfies(ex -> assertThat(((CoreException) ex).getErrorType())
                             .isEqualTo(ErrorType.PRODUCT_NOT_ORDERABLE));
-            verify(stockService, never()).hold(anyString(), anyInt());
+            verify(stockService, never()).hold(anyLong(), anyInt());
         }
 
         @Test
         @DisplayName("재고 부족 시 STOCK_NOT_ENOUGH 예외가 발생한다")
         void createDirectOrder_InsufficientStock_ShouldThrow() {
-            mockAuthenticate();
-            List<OrderItemCommand> merged = List.of(new OrderItemCommand("product-1", 100));
-            when(orderService.validateAndPrepare("user-1", anyList())).thenReturn(merged);
-            when(productService.findOrderableById("product-1")).thenReturn(createTestProduct());
-            when(brandService.findById("brand-id")).thenReturn(createTestBrand());
+            List<OrderItemCommand> merged = List.of(new OrderItemCommand(1L, 100));
+            when(orderService.validateAndPrepare(eq(USER_ID), anyList())).thenReturn(merged);
+            when(productService.findOrderableById(1L)).thenReturn(createTestProduct());
+            when(brandService.findById(1L)).thenReturn(createTestBrand());
             doThrow(new CoreException(ErrorType.STOCK_NOT_ENOUGH))
-                    .when(stockService).hold("product-1", 100);
+                    .when(stockService).hold(1L, 100);
 
-            assertThatThrownBy(() -> orderFacade.createDirectOrder("login1", "pw1",
-                    List.of(new OrderItemCommand("product-1", 100))))
+            assertThatThrownBy(() -> orderFacade.createDirectOrder(USER_ID,
+                    List.of(new OrderItemCommand(1L, 100)), null))
                     .isInstanceOf(CoreException.class)
                     .satisfies(ex -> assertThat(((CoreException) ex).getErrorType())
                             .isEqualTo(ErrorType.STOCK_NOT_ENOUGH));
@@ -141,23 +135,88 @@ void createDirectOrder_InsufficientStock_ShouldThrow() {
         @Test
         @DisplayName("총액이 sum(unitPrice * quantity)와 일치한다")
         void createDirectOrder_ShouldCalculateTotalAmount() {
-            mockAuthenticate();
-            List<OrderItemCommand> merged = List.of(new OrderItemCommand("product-1", 3));
-            when(orderService.validateAndPrepare("user-1", anyList())).thenReturn(merged);
-            when(productService.findOrderableById("product-1")).thenReturn(createTestProduct());
-            when(brandService.findById("brand-id")).thenReturn(createTestBrand());
-
-            OrderModel savedOrder = OrderModel.create("user-1", OrderType.DIRECT, BigDecimal.valueOf(30000));
-            when(orderService.createOrder(eq("user-1"), eq(OrderType.DIRECT),
+            List<OrderItemCommand> merged = List.of(new OrderItemCommand(1L, 3));
+            when(orderService.validateAndPrepare(eq(USER_ID), anyList())).thenReturn(merged);
+            when(productService.findOrderableById(1L)).thenReturn(createTestProduct());
+            when(brandService.findById(1L)).thenReturn(createTestBrand());
+
+            OrderModel savedOrder = OrderModel.create(USER_ID, OrderType.DIRECT, BigDecimal.valueOf(30000));
+            when(orderService.createOrder(eq(USER_ID), eq(OrderType.DIRECT),
                     eq(BigDecimal.valueOf(30000)), anyList()))
                     .thenReturn(savedOrder);
             when(orderService.findOrderItems(any())).thenReturn(List.of());
 
-            OrderInfo result = orderFacade.createDirectOrder("login1", "pw1",
-                    List.of(new OrderItemCommand("product-1", 3)));
+            OrderInfo result = orderFacade.createDirectOrder(USER_ID,
+                    List.of(new OrderItemCommand(1L, 3)), null);
 
             assertThat(result.getTotalAmount()).isEqualByComparingTo(BigDecimal.valueOf(30000));
         }
+
+        @Test
+        @DisplayName("유효한 쿠폰 적용 시 할인된 금액으로 주문이 생성된다")
+        void createDirectOrder_WithValidCoupon_ShouldApplyDiscount() {
+            List<OrderItemCommand> merged = List.of(new OrderItemCommand(1L, 1));
+            when(orderService.validateAndPrepare(eq(USER_ID), anyList())).thenReturn(merged);
+            when(productService.findOrderableById(1L)).thenReturn(createTestProduct()); // price: 10000
+            when(brandService.findById(1L)).thenReturn(createTestBrand());
+
+            UserCouponModel userCoupon = UserCouponModel.create(USER_ID, COUPON_ID);
+            when(couponService.validateAndGetUserCoupon(USER_ID, USER_COUPON_ID)).thenReturn(userCoupon);
+
+            CouponModel coupon = CouponModel.create("쿠폰", DiscountType.FIXED, BigDecimal.valueOf(2000),
+                    null, LocalDateTime.now().plusDays(30));
+            when(couponService.findByIdForAdmin(COUPON_ID)).thenReturn(coupon);
+
+            OrderModel savedOrder = OrderModel.create(USER_ID, OrderType.DIRECT, BigDecimal.valueOf(8000));
+            when(orderService.createOrder(eq(USER_ID), eq(OrderType.DIRECT),
+                    eq(BigDecimal.valueOf(8000)), anyList()))
+                    .thenReturn(savedOrder);
+            when(orderService.findOrderItems(any())).thenReturn(List.of());
+
+            OrderInfo result = orderFacade.createDirectOrder(USER_ID,
+                    List.of(new OrderItemCommand(1L, 1)), USER_COUPON_ID);
+
+            assertThat(result.getTotalAmount()).isEqualByComparingTo(BigDecimal.valueOf(8000));
+            verify(couponService).markCouponAsUsed(userCoupon.getUserCouponId(), savedOrder.getOrderId());
+        }
+
+        @Test
+        @DisplayName("쿠폰 검증 실패 시 재고 hold가 호출되지 않는다")
+        void createDirectOrder_CouponValidationFails_ShouldNotHoldStocks() {
+            List<OrderItemCommand> merged = List.of(new OrderItemCommand(1L, 2));
+            when(orderService.validateAndPrepare(eq(USER_ID), anyList())).thenReturn(merged);
+            when(couponService.validateAndGetUserCoupon(USER_ID, USER_COUPON_ID))
+                    .thenThrow(new CoreException(ErrorType.COUPON_NOT_AVAILABLE));
+
+            assertThatThrownBy(() -> orderFacade.createDirectOrder(USER_ID,
+                    List.of(new OrderItemCommand(1L, 2)), USER_COUPON_ID))
+                    .isInstanceOf(CoreException.class)
+                    .satisfies(ex -> assertThat(((CoreException) ex).getErrorType())
+                            .isEqualTo(ErrorType.COUPON_NOT_AVAILABLE));
+            verify(stockService, never()).hold(anyLong(), anyInt());
+        }
+
+        @Test
+        @DisplayName("쿠폰 없이 주문 시 할인 없이 전체 금액으로 주문된다")
+        void createDirectOrder_NoCoupon_ShouldUseFullAmount() {
+            List<OrderItemCommand> merged = List.of(new OrderItemCommand(1L, 2));
+            when(orderService.validateAndPrepare(eq(USER_ID), anyList())).thenReturn(merged);
+            when(productService.findOrderableById(1L)).thenReturn(createTestProduct());
+            when(brandService.findById(1L)).thenReturn(createTestBrand());
+
+            OrderModel savedOrder = OrderModel.create(USER_ID, OrderType.DIRECT, BigDecimal.valueOf(20000));
+            when(orderService.createOrder(eq(USER_ID), eq(OrderType.DIRECT),
+                    eq(BigDecimal.valueOf(20000)), anyList()))
+                    .thenReturn(savedOrder);
+            when(orderService.findOrderItems(any())).thenReturn(List.of());
+
+            OrderInfo result = orderFacade.createDirectOrder(USER_ID,
+                    List.of(new OrderItemCommand(1L, 2)), null);
+
+            assertThat(result.getTotalAmount()).isEqualByComparingTo(BigDecimal.valueOf(20000));
+            verify(couponService, never()).validateAndGetUserCoupon(anyLong(), anyLong());
+            verify(couponService, never()).markCouponAsUsed(anyLong(), anyLong());
+        }
     }
 
     // === 장바구니 주문 (CART) ===
@@ -169,64 +228,61 @@ class CartOrderTests {
         @Test
         @DisplayName("모든 상품이 순서대로 검증되고 hold된다")
         void createCartOrder_ShouldValidateAllProducts_ReserveAllStocks() {
-            mockAuthenticate();
             setupOrderCreationMocks();
 
-            OrderInfo result = orderFacade.createCartOrder("login1", "pw1",
-                    List.of(new OrderItemCommand("product-1", 2)));
+            OrderInfo result = orderFacade.createCartOrder(USER_ID,
+                    List.of(new OrderItemCommand(1L, 2)), null);
 
             assertThat(result).isNotNull();
-            verify(productService).findOrderableById("product-1");
-            verify(stockService).hold("product-1", 2);
-            verify(orderService).createOrder(eq("user-1"), eq(OrderType.CART), any(BigDecimal.class), anyList());
+            verify(productService).findOrderableById(1L);
+            verify(stockService).hold(1L, 2);
+            verify(orderService).createOrder(eq(USER_ID), eq(OrderType.CART), any(BigDecimal.class), anyList());
         }
 
         @Test
         @DisplayName("2번째 상품 hold 실패 시 1번째 hold가 release된다 (부분 성공 금지)")
         void createCartOrder_PartialStockFailure_ShouldRollbackAllReservations() {
-            mockAuthenticate();
             List<OrderItemCommand> merged = List.of(
-                    new OrderItemCommand("product-a", 2),
-                    new OrderItemCommand("product-b", 3));
-            when(orderService.validateAndPrepare("user-1", anyList())).thenReturn(merged);
-            when(productService.findOrderableById("product-a")).thenReturn(createTestProduct("product-a"));
-            when(productService.findOrderableById("product-b")).thenReturn(createTestProduct("product-b"));
-            when(brandService.findById("brand-id")).thenReturn(createTestBrand());
-            doNothing().when(stockService).hold("product-a", 2);
+                    new OrderItemCommand(1L, 2),
+                    new OrderItemCommand(2L, 3));
+            when(orderService.validateAndPrepare(eq(USER_ID), anyList())).thenReturn(merged);
+            when(productService.findOrderableById(1L)).thenReturn(createTestProduct(1L));
+            when(productService.findOrderableById(2L)).thenReturn(createTestProduct(2L));
+            when(brandService.findById(1L)).thenReturn(createTestBrand());
+            doNothing().when(stockService).hold(1L, 2);
             doThrow(new CoreException(ErrorType.STOCK_NOT_ENOUGH))
-                    .when(stockService).hold("product-b", 3);
+                    .when(stockService).hold(2L, 3);
 
-            assertThatThrownBy(() -> orderFacade.createCartOrder("login1", "pw1", List.of(
-                    new OrderItemCommand("product-a", 2),
-                    new OrderItemCommand("product-b", 3))))
+            assertThatThrownBy(() -> orderFacade.createCartOrder(USER_ID, List.of(
+                    new OrderItemCommand(1L, 2),
+                    new OrderItemCommand(2L, 3)), null))
                     .isInstanceOf(CoreException.class);
 
-            verify(stockService).release("product-a", 2);
+            verify(stockService).release(1L, 2);
         }
 
         @Test
         @DisplayName("hold 순서가 productId 오름차순이다 (데드락 방지)")
         void createCartOrder_ShouldHoldInProductIdAscOrder() {
-            mockAuthenticate();
             List<OrderItemCommand> merged = List.of(
-                    new OrderItemCommand("aaa-product", 1),
-                    new OrderItemCommand("zzz-product", 1));
-            when(orderService.validateAndPrepare("user-1", anyList())).thenReturn(merged);
-            when(productService.findOrderableById("aaa-product")).thenReturn(createTestProduct("aaa-product"));
-            when(productService.findOrderableById("zzz-product")).thenReturn(createTestProduct("zzz-product"));
-            when(brandService.findById("brand-id")).thenReturn(createTestBrand());
-            OrderModel savedOrder = OrderModel.create("user-1", OrderType.CART, BigDecimal.valueOf(20000));
-            when(orderService.createOrder(eq("user-1"), any(OrderType.class), any(BigDecimal.class), anyList()))
+                    new OrderItemCommand(1L, 1),
+                    new OrderItemCommand(3L, 1));
+            when(orderService.validateAndPrepare(eq(USER_ID), anyList())).thenReturn(merged);
+            when(productService.findOrderableById(1L)).thenReturn(createTestProduct(1L));
+            when(productService.findOrderableById(3L)).thenReturn(createTestProduct(3L));
+            when(brandService.findById(1L)).thenReturn(createTestBrand());
+            OrderModel savedOrder = OrderModel.create(USER_ID, OrderType.CART, BigDecimal.valueOf(20000));
+            when(orderService.createOrder(eq(USER_ID), any(OrderType.class), any(BigDecimal.class), anyList()))
                     .thenReturn(savedOrder);
             when(orderService.findOrderItems(any())).thenReturn(List.of());
 
-            orderFacade.createCartOrder("login1", "pw1", List.of(
-                    new OrderItemCommand("zzz-product", 1),
-                    new OrderItemCommand("aaa-product", 1)));
+            orderFacade.createCartOrder(USER_ID, List.of(
+                    new OrderItemCommand(3L, 1),
+                    new OrderItemCommand(1L, 1)), null);
 
             var inOrder = inOrder(stockService);
-            inOrder.verify(stockService).hold("aaa-product", 1);
-            inOrder.verify(stockService).hold("zzz-product", 1);
+            inOrder.verify(stockService).hold(1L, 1);
+            inOrder.verify(stockService).hold(3L, 1);
         }
     }
 
@@ -237,59 +293,56 @@ void createCartOrder_ShouldHoldInProductIdAscOrder() {
     class CancelOrderTests {
 
         @Test
-        @DisplayName("취소 시 모든 주문 항목의 재고가 release된다")
+        @DisplayName("취소 시 모든 주문 항목의 재고가 release되고 쿠폰이 복원된다")
         void cancelOrder_ShouldReleaseAllStocks() {
-            mockAuthenticate();
-            OrderModel order = OrderModel.create("user-1", OrderType.CART, BigDecimal.valueOf(10000));
-            when(orderService.cancelOrder("user-1", "order-1")).thenReturn(Optional.of(order));
-            OrderItemModel item = OrderItemModel.create("order-1", 1, "user-1", "product-1", 3,
+            OrderModel order = OrderModel.create(USER_ID, OrderType.CART, BigDecimal.valueOf(10000));
+            when(orderService.cancelOrder(USER_ID, 1L)).thenReturn(Optional.of(order));
+            OrderItemModel item = OrderItemModel.create(1L, 1, USER_ID, 1L, 3,
                     "상품명", BigDecimal.valueOf(10000), "brand-id", "브랜드", null);
-            when(orderService.findOrderItems("order-1")).thenReturn(List.of(item));
+            when(orderService.findOrderItems(1L)).thenReturn(List.of(item));
 
-            orderFacade.cancelOrder("login1", "pw1", "order-1");
+            orderFacade.cancelOrder(USER_ID, 1L);
 
-            verify(stockService).release("product-1", 3);
+            verify(stockService).release(1L, 3);
+            verify(couponService).restoreCoupon(order.getOrderId());
         }
 
         @Test
         @DisplayName("DIRECT 주문 취소 시 장바구니가 복원된다")
         void cancelOrder_DIRECT_ShouldRestoreToCart() {
-            mockAuthenticate();
-            OrderModel order = OrderModel.create("user-1", OrderType.DIRECT, BigDecimal.valueOf(10000));
-            when(orderService.cancelOrder("user-1", "order-1")).thenReturn(Optional.of(order));
-            OrderItemModel item = OrderItemModel.create("order-1", 1, "user-1", "product-1", 3,
+            OrderModel order = OrderModel.create(USER_ID, OrderType.DIRECT, BigDecimal.valueOf(10000));
+            when(orderService.cancelOrder(USER_ID, 1L)).thenReturn(Optional.of(order));
+            OrderItemModel item = OrderItemModel.create(1L, 1, USER_ID, 1L, 3,
                     "상품명", BigDecimal.valueOf(10000), "brand-id", "브랜드", null);
-            when(orderService.findOrderItems("order-1")).thenReturn(List.of(item));
+            when(orderService.findOrderItems(1L)).thenReturn(List.of(item));
 
-            orderFacade.cancelOrder("login1", "pw1", "order-1");
+            orderFacade.cancelOrder(USER_ID, 1L);
 
             verify(orderService).saveCartRestore(any(OrderCartRestoreModel.class));
-            verify(cartService).restoreFromOrder(eq("user-1"), anyList());
+            verify(cartService).restoreFromOrder(eq(USER_ID), anyList());
         }
 
         @Test
         @DisplayName("CART 주문 취소 시 장바구니 변경 없음")
         void cancelOrder_CART_ShouldNotRestoreCart() {
-            mockAuthenticate();
-            OrderModel order = OrderModel.create("user-1", OrderType.CART, BigDecimal.valueOf(10000));
-            when(orderService.cancelOrder("user-1", "order-1")).thenReturn(Optional.of(order));
-            when(orderService.findOrderItems("order-1")).thenReturn(List.of());
+            OrderModel order = OrderModel.create(USER_ID, OrderType.CART, BigDecimal.valueOf(10000));
+            when(orderService.cancelOrder(USER_ID, 1L)).thenReturn(Optional.of(order));
+            when(orderService.findOrderItems(1L)).thenReturn(List.of());
 
-            orderFacade.cancelOrder("login1", "pw1", "order-1");
+            orderFacade.cancelOrder(USER_ID, 1L);
 
-            verify(cartService, never()).restoreFromOrder(anyString(), anyList());
+            verify(cartService, never()).restoreFromOrder(anyLong(), anyList());
             verify(orderService, never()).saveCartRestore(any());
         }
 
         @Test
         @DisplayName("이미 CANCELLED인 주문 취소 시 에러 없이 무시된다 (멱등)")
         void cancelOrder_WhenAlreadyCancelled_ShouldBeIdempotent() {
-            mockAuthenticate();
-            when(orderService.cancelOrder("user-1", "order-1")).thenReturn(Optional.empty());
+            when(orderService.cancelOrder(USER_ID, 1L)).thenReturn(Optional.empty());
 
-            assertThatCode(() -> orderFacade.cancelOrder("login1", "pw1", "order-1"))
+            assertThatCode(() -> orderFacade.cancelOrder(USER_ID, 1L))
                     .doesNotThrowAnyException();
-            verify(stockService, never()).release(anyString(), anyInt());
+            verify(stockService, never()).release(anyLong(), anyInt());
         }
     }
 
@@ -300,43 +353,43 @@ void cancelOrder_WhenAlreadyCancelled_ShouldBeIdempotent() {
     class ExpireOrderTests {
 
         @Test
-        @DisplayName("만료 시 재고가 release된다")
+        @DisplayName("만료 시 재고가 release되고 쿠폰이 복원된다")
         void expireOrder_ShouldReleaseAllStocks() {
-            OrderModel order = OrderModel.create("user-1", OrderType.CART, BigDecimal.valueOf(10000));
-            when(orderService.expireOrder("order-1")).thenReturn(Optional.of(order));
-            OrderItemModel item = OrderItemModel.create("order-1", 1, "user-1", "product-1", 3,
+            OrderModel order = OrderModel.create(USER_ID, OrderType.CART, BigDecimal.valueOf(10000));
+            when(orderService.expireOrder(1L)).thenReturn(Optional.of(order));
+            OrderItemModel item = OrderItemModel.create(1L, 1, USER_ID, 1L, 3,
                     "상품명", BigDecimal.valueOf(10000), "brand-id", "브랜드", null);
-            when(orderService.findOrderItems("order-1")).thenReturn(List.of(item));
+            when(orderService.findOrderItems(1L)).thenReturn(List.of(item));
 
-            orderFacade.expireOrder("order-1");
+            orderFacade.expireOrder(1L);
 
-            verify(stockService).release("product-1", 3);
+            verify(stockService).release(1L, 3);
+            verify(couponService).restoreCoupon(order.getOrderId());
         }
 
         @Test
         @DisplayName("DIRECT 주문 만료 시 장바구니가 복원된다")
         void expireOrder_DIRECT_ShouldRestoreToCart() {
-            OrderModel order = OrderModel.create("user-1", OrderType.DIRECT, BigDecimal.valueOf(10000));
-            when(orderService.expireOrder("order-1")).thenReturn(Optional.of(order));
-            OrderItemModel item = OrderItemModel.create("order-1", 1, "user-1", "product-1", 2,
+            OrderModel order = OrderModel.create(USER_ID, OrderType.DIRECT, BigDecimal.valueOf(10000));
+            when(orderService.expireOrder(1L)).thenReturn(Optional.of(order));
+            OrderItemModel item = OrderItemModel.create(1L, 1, USER_ID, 1L, 2,
                     "상품명", BigDecimal.valueOf(10000), "brand-id", "브랜드", null);
-            when(orderService.findOrderItems("order-1")).thenReturn(List.of(item));
+            when(orderService.findOrderItems(1L)).thenReturn(List.of(item));
 
-            orderFacade.expireOrder("order-1");
+            orderFacade.expireOrder(1L);
 
             verify(orderService).saveCartRestore(any(OrderCartRestoreModel.class));
-            verify(cartService).restoreFromOrder(eq("user-1"), anyList());
+            verify(cartService).restoreFromOrder(eq(USER_ID), anyList());
         }
 
         @Test
         @DisplayName("CAS 실패 시 skip된다 (멱등)")
         void expireOrder_AlreadyExpiredOrCancelled_ShouldSkip() {
-            when(orderService.expireOrder("order-1")).thenReturn(Optional.empty());
+            when(orderService.expireOrder(1L)).thenReturn(Optional.empty());
 
-            assertThatCode(() -> orderFacade.expireOrder("order-1"))
+            assertThatCode(() -> orderFacade.expireOrder(1L))
                     .doesNotThrowAnyException();
-            verify(stockService, never()).release(anyString(), anyInt());
+            verify(stockService, never()).release(anyLong(), anyInt());
         }
     }
-
 }
diff --git a/apps/commerce-api/src/test/java/com/loopers/application/product/ProductAppServiceTest.java b/apps/commerce-api/src/test/java/com/loopers/application/product/ProductAppServiceTest.java
deleted file mode 100644
index 3b1766f57..000000000
--- a/apps/commerce-api/src/test/java/com/loopers/application/product/ProductAppServiceTest.java
+++ /dev/null
@@ -1,62 +0,0 @@
-package com.loopers.application.product;
-
-import com.loopers.domain.product.ProductRevisionModel;
-import com.loopers.domain.product.ProductService;
-import com.loopers.support.enums.ProductRevisionAction;
-import org.junit.jupiter.api.DisplayName;
-import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.extension.ExtendWith;
-import org.mockito.InjectMocks;
-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.mockito.Mockito.*;
-
-@ExtendWith(MockitoExtension.class)
-@DisplayName("ProductAppService 단위 테스트")
-class ProductAppServiceTest {
-
-    @Mock
-    ProductService productService;
-
-    @InjectMocks
-    ProductAppService productAppService;
-
-    @Test
-    @DisplayName("상품 삭제 시 ProductService.deleteProduct가 호출된다")
-    void deleteProduct_ShouldCallServiceMethod() {
-        productAppService.deleteProduct("p1");
-
-        verify(productService).deleteProduct("p1");
-    }
-
-    @Test
-    @DisplayName("변경 이력 조회 시 ProductRevisionInfo 목록을 반환한다")
-    void getRevisions_ShouldReturnRevisionInfoList() {
-        ProductRevisionModel revision = mock(ProductRevisionModel.class);
-        when(revision.getAction()).thenReturn(ProductRevisionAction.CREATE);
-        when(productService.findRevisionsByProductId("p1")).thenReturn(List.of(revision));
-
-        List<ProductRevisionInfo> result = productAppService.getRevisions("p1");
-
-        assertThat(result).hasSize(1);
-        verify(productService).findRevisionsByProductId("p1");
-    }
-
-    @Test
-    @DisplayName("변경 이력 상세 조회 시 ProductRevisionInfo를 반환한다")
-    void getRevisionDetail_ShouldReturnRevisionInfo() {
-        ProductRevisionModel revision = mock(ProductRevisionModel.class);
-        when(revision.getAction()).thenReturn(ProductRevisionAction.UPDATE);
-        when(productService.findRevisionById("p1", 1L)).thenReturn(revision);
-
-        ProductRevisionInfo result = productAppService.getRevisionDetail("p1", 1L);
-
-        assertThat(result).isNotNull();
-        assertThat(result.getAction()).isEqualTo(ProductRevisionAction.UPDATE);
-        verify(productService).findRevisionById("p1", 1L);
-    }
-}
diff --git a/apps/commerce-api/src/test/java/com/loopers/application/product/ProductFacadeTest.java b/apps/commerce-api/src/test/java/com/loopers/application/product/ProductFacadeTest.java
index 062c15bb2..0364275de 100644
--- a/apps/commerce-api/src/test/java/com/loopers/application/product/ProductFacadeTest.java
+++ b/apps/commerce-api/src/test/java/com/loopers/application/product/ProductFacadeTest.java
@@ -2,7 +2,6 @@
 
 import com.loopers.domain.brand.BrandModel;
 import com.loopers.domain.brand.BrandService;
-import com.loopers.domain.like.LikeService;
 import com.loopers.application.product.ProductInfo;
 import com.loopers.domain.product.ProductModel;
 import com.loopers.domain.product.ProductService;
@@ -10,19 +9,18 @@
 import com.loopers.domain.product.StockService;
 import com.loopers.interfaces.api.PageResponse;
 import com.loopers.support.enums.ProductSortType;
+import com.loopers.support.page.PageQuery;
+import com.loopers.support.page.PagedResult;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.ArgumentCaptor;
 import org.mockito.InjectMocks;
 import org.mockito.Mock;
 import org.mockito.junit.jupiter.MockitoExtension;
-import org.springframework.data.domain.Page;
-import org.springframework.data.domain.PageImpl;
-import org.springframework.data.domain.Pageable;
 
 import java.math.BigDecimal;
 import java.util.List;
-import java.util.Map;
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.mockito.ArgumentMatchers.any;
@@ -42,9 +40,6 @@ class ProductFacadeTest {
     @Mock
     BrandService brandService;
 
-    @Mock
-    LikeService likeService;
-
     @InjectMocks
     ProductFacade productFacade;
 
@@ -53,29 +48,33 @@ class ProductFacadeTest {
     void getProductsForCustomer_WithLatestSort_ShouldReturnPagedResult() {
         ProductModel product1 = mock(ProductModel.class);
         ProductModel product2 = mock(ProductModel.class);
-        when(product1.getProductId()).thenReturn("p1");
-        when(product1.getBrandId()).thenReturn("b1");
-        when(product2.getProductId()).thenReturn("p2");
-        when(product2.getBrandId()).thenReturn("b1");
+        when(product1.getProductId()).thenReturn(1L);
+        when(product1.getBrandId()).thenReturn(1L);
+        when(product1.getLikeCount()).thenReturn(5L);
+        when(product2.getProductId()).thenReturn(2L);
+        when(product2.getBrandId()).thenReturn(1L);
+        when(product2.getLikeCount()).thenReturn(3L);
         ProductStockModel stock1 = mock(ProductStockModel.class);
         ProductStockModel stock2 = mock(ProductStockModel.class);
         when(stock1.getAvailableQty()).thenReturn(50);
         when(stock2.getAvailableQty()).thenReturn(30);
 
         BrandModel brand = mock(BrandModel.class);
-        when(brand.getBrandId()).thenReturn("b1");
+        when(brand.getBrandId()).thenReturn(1L);
         when(brand.getBrandName()).thenReturn("테스트브랜드");
 
-        Page<ProductModel> page = new PageImpl<>(List.of(product1, product2));
-        when(productService.findAllForCustomer(eq((String) null), eq((String) null), any(Pageable.class)))
-                .thenReturn(page);
-        when(stockService.findByProductId("p1")).thenReturn(stock1);
-        when(stockService.findByProductId("p2")).thenReturn(stock2);
-        when(brandService.findAllByIds(List.of("b1"))).thenReturn(List.of(brand));
-        when(likeService.countByProductIds(List.of("p1", "p2"))).thenReturn(Map.of("p1", 5L, "p2", 3L));
+        when(stock1.getProductId()).thenReturn(1L);
+        when(stock2.getProductId()).thenReturn(2L);
+
+        // keyword가 있으므로 캐시를 거치지 않고 DB 직접 조회
+        PagedResult<ProductModel> pagedResult = new PagedResult<>(List.of(product1, product2), 0, 20, 2, 1);
+        when(productService.findAllForCustomer(eq("검색어"), eq((Long) null), any(PageQuery.class)))
+                .thenReturn(pagedResult);
+        when(stockService.findAllByProductIds(List.of(1L, 2L))).thenReturn(List.of(stock1, stock2));
+        when(brandService.findAllByIds(List.of(1L))).thenReturn(List.of(brand));
 
         PageResponse<ProductInfo> result = productFacade.getProductsForCustomer(
-                null, null, ProductSortType.LATEST, 0, 20);
+                "검색어", null, ProductSortType.LATEST, 0, 20);
 
         assertThat(result.content()).hasSize(2);
         assertThat(result.content().get(0).getBrandName()).isEqualTo("테스트브랜드");
@@ -84,110 +83,148 @@ void getProductsForCustomer_WithLatestSort_ShouldReturnPagedResult() {
     }
 
     @Test
-    @DisplayName("고객용 상품 목록 LIKES_DESC 정렬 시 좋아요 수 내림차순으로 정렬된다")
-    void getProductsForCustomer_WithLikesDescSort_ShouldSortByLikeCount() {
+    @DisplayName("고객용 상품 목록 LIKES_DESC 정렬 시 likeCount DESC PageQuery로 DB 정렬을 요청한다")
+    void getProductsForCustomer_WithLikesDescSort_ShouldRequestDbSortByLikeCount() {
         ProductModel product1 = mock(ProductModel.class);
         ProductModel product2 = mock(ProductModel.class);
-        when(product1.getProductId()).thenReturn("p1");
-        when(product1.getBrandId()).thenReturn("b1");
-        when(product2.getProductId()).thenReturn("p2");
-        when(product2.getBrandId()).thenReturn("b1");
+        when(product1.getProductId()).thenReturn(1L);
+        when(product1.getBrandId()).thenReturn(1L);
+        when(product1.getLikeCount()).thenReturn(10L);
+        when(product2.getProductId()).thenReturn(2L);
+        when(product2.getBrandId()).thenReturn(1L);
+        when(product2.getLikeCount()).thenReturn(3L);
         ProductStockModel stock1 = mock(ProductStockModel.class);
         ProductStockModel stock2 = mock(ProductStockModel.class);
         when(stock1.getAvailableQty()).thenReturn(50);
         when(stock2.getAvailableQty()).thenReturn(30);
+        when(stock1.getProductId()).thenReturn(1L);
+        when(stock2.getProductId()).thenReturn(2L);
 
         BrandModel brand = mock(BrandModel.class);
-        when(brand.getBrandId()).thenReturn("b1");
+        when(brand.getBrandId()).thenReturn(1L);
         when(brand.getBrandName()).thenReturn("테스트브랜드");
 
-        when(productService.findAllForCustomer(null, null)).thenReturn(List.of(product1, product2));
-        when(stockService.findByProductId("p1")).thenReturn(stock1);
-        when(stockService.findByProductId("p2")).thenReturn(stock2);
-        when(brandService.findAllByIds(List.of("b1"))).thenReturn(List.of(brand));
-        when(likeService.countByProductIds(List.of("p1", "p2"))).thenReturn(Map.of("p1", 3L, "p2", 10L));
+        PagedResult<ProductModel> pagedResult = new PagedResult<>(List.of(product1, product2), 0, 20, 2, 1);
+        ArgumentCaptor<PageQuery> queryCaptor = ArgumentCaptor.forClass(PageQuery.class);
+        // keyword가 있으므로 캐시 미대상 경로
+        when(productService.findAllForCustomer(eq("키워드"), eq((Long) null), queryCaptor.capture()))
+                .thenReturn(pagedResult);
+        when(stockService.findAllByProductIds(List.of(1L, 2L))).thenReturn(List.of(stock1, stock2));
+        when(brandService.findAllByIds(List.of(1L))).thenReturn(List.of(brand));
 
         PageResponse<ProductInfo> result = productFacade.getProductsForCustomer(
-                null, null, ProductSortType.LIKES_DESC, 0, 20);
+                "키워드", null, ProductSortType.LIKES_DESC, 0, 20);
 
         assertThat(result.content()).hasSize(2);
-        assertThat(result.content().get(0).getLikeCount()).isEqualTo(10L);
-        assertThat(result.content().get(1).getLikeCount()).isEqualTo(3L);
+        PageQuery capturedQuery = queryCaptor.getValue();
+        assertThat(capturedQuery.sortField()).isEqualTo("likeCount");
+        assertThat(capturedQuery.ascending()).isFalse();
     }
 
     @Test
     @DisplayName("고객용 상품 상세 조회 시 가용 재고, 브랜드명, 좋아요 수가 포함된 ProductInfo를 반환한다")
     void getProductDetailForCustomer_ShouldReturnProductInfoWithAvailableStock() {
         ProductModel product = mock(ProductModel.class);
-        when(product.getProductId()).thenReturn("p1");
-        when(product.getBrandId()).thenReturn("b1");
+        when(product.getProductId()).thenReturn(1L);
+        when(product.getBrandId()).thenReturn(1L);
+        when(product.getLikeCount()).thenReturn(10L);
         ProductStockModel stock = mock(ProductStockModel.class);
         when(stock.getAvailableQty()).thenReturn(70);
 
         BrandModel brand = mock(BrandModel.class);
         when(brand.getBrandName()).thenReturn("테스트브랜드");
 
-        when(productService.findById("p1")).thenReturn(product);
-        when(stockService.findByProductId("p1")).thenReturn(stock);
-        when(brandService.findById("b1")).thenReturn(brand);
-        when(likeService.countByProductId("p1")).thenReturn(10L);
+        when(productService.findById(1L)).thenReturn(product);
+        when(stockService.findByProductId(1L)).thenReturn(stock);
+        when(brandService.findById(1L)).thenReturn(brand);
 
-        ProductInfo result = productFacade.getProductDetailForCustomer("p1");
+        ProductInfo result = productFacade.getProductDetailForCustomer(1L);
 
         assertThat(result).isNotNull();
         assertThat(result.getAvailableStock()).isEqualTo(70);
         assertThat(result.getBrandName()).isEqualTo("테스트브랜드");
         assertThat(result.getLikeCount()).isEqualTo(10L);
-        verify(productService).findById("p1");
-        verify(stockService).findByProductId("p1");
-        verify(brandService).findById("b1");
-        verify(likeService).countByProductId("p1");
+        verify(productService).findById(1L);
+        verify(stockService).findByProductId(1L);
+        verify(brandService).findById(1L);
     }
 
     @Test
     @DisplayName("상품 생성 시 브랜드 검증 → 상품 생성 → 재고 생성 오케스트레이션이 수행된다")
     void createProduct_ShouldOrchestrateBrandProductStock() {
         BrandModel brand = mock(BrandModel.class);
-        when(brandService.findById("b1")).thenReturn(brand);
+        when(brandService.findById(1L)).thenReturn(brand);
 
         ProductModel product = mock(ProductModel.class);
-        when(product.getProductId()).thenReturn("p1");
-        when(productService.createProduct("테스트상품", "b1", BigDecimal.valueOf(10000), "설명"))
+        when(product.getProductId()).thenReturn(1L);
+        when(productService.createProduct("테스트상품", 1L, BigDecimal.valueOf(10000), "설명"))
                 .thenReturn(product);
 
         ProductStockModel stock = mock(ProductStockModel.class);
         when(stock.getAvailableQty()).thenReturn(100);
-        when(stockService.createStock("p1", 100)).thenReturn(stock);
+        when(stockService.createStock(1L, 100)).thenReturn(stock);
 
-        ProductCreateCommand command = new ProductCreateCommand("테스트상품", "b1",
+        ProductCreateCommand command = new ProductCreateCommand("테스트상품", 1L,
                 BigDecimal.valueOf(10000), "설명", 100);
         ProductInfo result = productFacade.createProduct(command);
 
         assertThat(result).isNotNull();
-        verify(brandService).findById("b1");
-        verify(productService).createProduct("테스트상품", "b1", BigDecimal.valueOf(10000), "설명");
-        verify(stockService).createStock("p1", 100);
+        verify(brandService).findById(1L);
+        verify(productService).createProduct("테스트상품", 1L, BigDecimal.valueOf(10000), "설명");
+        verify(stockService).createStock(1L, 100);
     }
 
     @Test
     @DisplayName("상품 수정 후 재고 정보를 결합하여 ProductInfo를 반환한다")
     void updateProduct_ShouldCombineProductAndStock() {
         ProductModel product = mock(ProductModel.class);
-        when(product.getProductId()).thenReturn("p1");
-        when(productService.updateProduct("p1", "수정상품", BigDecimal.valueOf(20000), "수정설명", null))
+        when(product.getProductId()).thenReturn(1L);
+        when(productService.updateProduct(1L, "수정상품", BigDecimal.valueOf(20000), "수정설명", null))
                 .thenReturn(product);
 
         ProductStockModel stock = mock(ProductStockModel.class);
         when(stock.getAvailableQty()).thenReturn(50);
-        when(stockService.findByProductId("p1")).thenReturn(stock);
+        when(stockService.findByProductId(1L)).thenReturn(stock);
 
-        ProductUpdateCommand command = new ProductUpdateCommand("p1", "수정상품",
+        ProductUpdateCommand command = new ProductUpdateCommand(1L, "수정상품",
                 BigDecimal.valueOf(20000), "수정설명", null);
         ProductInfo result = productFacade.updateProduct(command);
 
         assertThat(result).isNotNull();
-        verify(productService).updateProduct("p1", "수정상품", BigDecimal.valueOf(20000), "수정설명", null);
-        verify(stockService).findByProductId("p1");
+        verify(productService).updateProduct(1L, "수정상품", BigDecimal.valueOf(20000), "수정설명", null);
+        verify(stockService).findByProductId(1L);
     }
 
+    @Test
+    @DisplayName("캐시 대상 조건(keyword=null, page=0, size=20) 시 getCachedProductListIds를 통해 ID 캐시 경로로 조회한다")
+    void getProductsForCustomer_CacheTarget_ShouldUseCachedIdPath() {
+        ProductModel product1 = mock(ProductModel.class);
+        when(product1.getProductId()).thenReturn(1L);
+        when(product1.getBrandId()).thenReturn(1L);
+        when(product1.getLikeCount()).thenReturn(5L);
+
+        ProductStockModel stock1 = mock(ProductStockModel.class);
+        when(stock1.getAvailableQty()).thenReturn(50);
+        when(stock1.getProductId()).thenReturn(1L);
+
+        BrandModel brand = mock(BrandModel.class);
+        when(brand.getBrandId()).thenReturn(1L);
+        when(brand.getBrandName()).thenReturn("브랜드");
+
+        // getCachedProductListIds → findAllForCustomer 호출
+        PagedResult<ProductModel> pagedResult = new PagedResult<>(List.of(product1), 0, 20, 1, 1);
+        when(productService.findAllForCustomer(eq((String) null), eq((Long) null), any(PageQuery.class)))
+                .thenReturn(pagedResult);
+        // getProductsFromCachedIds에서 개별 findById 호출 (productDetail 캐시 활용)
+        when(productService.findById(1L)).thenReturn(product1);
+        when(stockService.findAllByProductIds(List.of(1L))).thenReturn(List.of(stock1));
+        when(brandService.findAllByIds(List.of(1L))).thenReturn(List.of(brand));
+
+        PageResponse<ProductInfo> result = productFacade.getProductsForCustomer(
+                null, null, ProductSortType.LATEST, 0, 20);
+
+        assertThat(result.content()).hasSize(1);
+        // 개별 productDetail 캐시 경로를 통해 findById가 호출됨
+        verify(productService).findById(1L);
+    }
 }
diff --git a/apps/commerce-api/src/test/java/com/loopers/batch/OrderExpirySchedulerTest.java b/apps/commerce-api/src/test/java/com/loopers/batch/OrderExpirySchedulerTest.java
index 831df02de..6be6b5186 100644
--- a/apps/commerce-api/src/test/java/com/loopers/batch/OrderExpirySchedulerTest.java
+++ b/apps/commerce-api/src/test/java/com/loopers/batch/OrderExpirySchedulerTest.java
@@ -3,7 +3,6 @@
 import com.loopers.domain.brand.BrandModel;
 import com.loopers.domain.cart.CartItemId;
 import com.loopers.domain.cart.CartItemModel;
-import com.loopers.domain.order.OrderItemModel;
 import com.loopers.domain.order.OrderModel;
 import com.loopers.domain.product.ProductModel;
 import com.loopers.domain.product.ProductStockModel;
@@ -60,16 +59,10 @@ void tearDown() {
         databaseCleanUp.truncateAllTables();
     }
 
-    private OrderModel createExpiredOrder(String userId, OrderType orderType) {
+    private OrderModel createExpiredOrder(Long userId, OrderType orderType) {
         OrderModel order = OrderModel.create(userId, orderType, BigDecimal.valueOf(10000));
         order = orderJpaRepository.save(order);
-        // expiresAt을 과거로 설정하기 위해 native UPDATE 사용
         orderJpaRepository.flush();
-        orderJpaRepository.findById(order.getOrderId()).ifPresent(o -> {
-            // 강제로 expires_at을 과거로 설정하려면 CAS를 우회해야 하는데,
-            // OrderModel.create()는 15분 후로 설정함.
-            // 대신 직접 만료 처리를 위해 SQL로 업데이트
-        });
         return order;
     }
 
@@ -102,11 +95,11 @@ void shouldReleaseStock_ForExpiredOrders() {
     void shouldRestoreCart_ForExpiredDirectOrders() {
         // 장바구니 복원 로직은 OrderFacade.expireOrder 내부에서 수행됨
         // 여기서는 장바구니 저장/조회가 정상 작동하는지 검증
-        CartItemModel cartItem = CartItemModel.create("user-1", product.getProductId(), 2);
+        CartItemModel cartItem = CartItemModel.create(1L, product.getProductId(), 2);
         cartItemJpaRepository.save(cartItem);
 
         Optional<CartItemModel> found = cartItemJpaRepository.findById(
-                new CartItemId("user-1", product.getProductId()));
+                new CartItemId(1L, product.getProductId()));
         assertThat(found).isPresent();
         assertThat(found.get().getQuantity()).isEqualTo(2);
     }
@@ -114,7 +107,7 @@ void shouldRestoreCart_ForExpiredDirectOrders() {
     @Test
     @DisplayName("이미 취소/만료된 주문은 CAS 실패로 skip한다")
     void shouldSkip_AlreadyCancelledOrExpired() {
-        OrderModel order = OrderModel.create("user-1", OrderType.DIRECT, BigDecimal.valueOf(10000));
+        OrderModel order = OrderModel.create(1L, OrderType.DIRECT, BigDecimal.valueOf(10000));
         order = orderJpaRepository.save(order);
         orderJpaRepository.flush();
 
diff --git a/apps/commerce-api/src/test/java/com/loopers/domain/brand/BrandServiceTest.java b/apps/commerce-api/src/test/java/com/loopers/domain/brand/BrandServiceTest.java
index a608d129c..63b1769db 100644
--- a/apps/commerce-api/src/test/java/com/loopers/domain/brand/BrandServiceTest.java
+++ b/apps/commerce-api/src/test/java/com/loopers/domain/brand/BrandServiceTest.java
@@ -56,9 +56,9 @@ class FindTests {
         @DisplayName("존재하는 ID로 조회하면 BrandModel을 반환한다")
         void findById_Existing_ShouldReturn() {
             BrandModel brand = BrandModel.create("브랜드", "설명", "서울");
-            when(brandRepository.findById("brand-id")).thenReturn(Optional.of(brand));
+            when(brandRepository.findById(1L)).thenReturn(Optional.of(brand));
 
-            BrandModel result = brandService.findById("brand-id");
+            BrandModel result = brandService.findById(1L);
 
             assertThat(result.getBrandName()).isEqualTo("브랜드");
         }
@@ -66,9 +66,9 @@ void findById_Existing_ShouldReturn() {
         @Test
         @DisplayName("존재하지 않는 ID 조회 시 BRAND_NOT_FOUND 예외가 발생한다")
         void findById_NotFound_ShouldThrowBRAND_NOT_FOUND() {
-            when(brandRepository.findById("nonexistent")).thenReturn(Optional.empty());
+            when(brandRepository.findById(999L)).thenReturn(Optional.empty());
 
-            assertThatThrownBy(() -> brandService.findById("nonexistent"))
+            assertThatThrownBy(() -> brandService.findById(999L))
                     .isInstanceOf(CoreException.class)
                     .satisfies(ex -> assertThat(((CoreException) ex).getErrorType())
                             .isEqualTo(ErrorType.BRAND_NOT_FOUND));
@@ -79,9 +79,9 @@ void findById_NotFound_ShouldThrowBRAND_NOT_FOUND() {
         void findVisibleById_WhenHidden_ShouldThrowBRAND_NOT_FOUND() {
             BrandModel brand = BrandModel.create("브랜드", "설명", "서울");
             brand.hide();
-            when(brandRepository.findById("brand-id")).thenReturn(Optional.of(brand));
+            when(brandRepository.findById(1L)).thenReturn(Optional.of(brand));
 
-            assertThatThrownBy(() -> brandService.findVisibleById("brand-id"))
+            assertThatThrownBy(() -> brandService.findVisibleById(1L))
                     .isInstanceOf(CoreException.class)
                     .satisfies(ex -> assertThat(((CoreException) ex).getErrorType())
                             .isEqualTo(ErrorType.BRAND_NOT_FOUND));
@@ -92,9 +92,9 @@ void findVisibleById_WhenHidden_ShouldThrowBRAND_NOT_FOUND() {
         void findVisibleById_WhenDeleted_ShouldThrowBRAND_NOT_FOUND() {
             BrandModel brand = BrandModel.create("브랜드", "설명", "서울");
             brand.softDelete();
-            when(brandRepository.findById("brand-id")).thenReturn(Optional.of(brand));
+            when(brandRepository.findById(1L)).thenReturn(Optional.of(brand));
 
-            assertThatThrownBy(() -> brandService.findVisibleById("brand-id"))
+            assertThatThrownBy(() -> brandService.findVisibleById(1L))
                     .isInstanceOf(CoreException.class)
                     .satisfies(ex -> assertThat(((CoreException) ex).getErrorType())
                             .isEqualTo(ErrorType.BRAND_NOT_FOUND));
@@ -140,9 +140,9 @@ class UpdateTests {
         @DisplayName("수정 후 변경된 BrandModel을 반환한다")
         void updateBrand_ShouldUpdateAndReturn() {
             BrandModel brand = BrandModel.create("기존이름", "기존설명", "기존주소");
-            when(brandRepository.findById("brand-id")).thenReturn(Optional.of(brand));
+            when(brandRepository.findById(1L)).thenReturn(Optional.of(brand));
 
-            BrandModel result = brandService.updateBrand("brand-id", "새이름", "새설명", "새주소");
+            BrandModel result = brandService.updateBrand(1L, "새이름", "새설명", "새주소");
 
             assertThat(result.getBrandName()).isEqualTo("새이름");
             assertThat(result.getDescription()).isEqualTo("새설명");
@@ -158,9 +158,9 @@ class DeleteTests {
         @DisplayName("소프트 삭제가 정상적으로 수행된다")
         void deleteBrand_ShouldSoftDeleteBrand() {
             BrandModel brand = BrandModel.create("브랜드", "설명", "서울");
-            when(brandRepository.findById("brand-id")).thenReturn(Optional.of(brand));
+            when(brandRepository.findById(1L)).thenReturn(Optional.of(brand));
 
-            brandService.deleteBrand("brand-id");
+            brandService.deleteBrand(1L);
 
             assertThat(brand.isDeleted()).isTrue();
         }
@@ -170,9 +170,9 @@ void deleteBrand_ShouldSoftDeleteBrand() {
         void deleteBrand_AlreadyDeleted_ShouldBeIdempotent() {
             BrandModel brand = BrandModel.create("브랜드", "설명", "서울");
             brand.softDelete();
-            when(brandRepository.findById("brand-id")).thenReturn(Optional.of(brand));
+            when(brandRepository.findById(1L)).thenReturn(Optional.of(brand));
 
-            assertThatCode(() -> brandService.deleteBrand("brand-id"))
+            assertThatCode(() -> brandService.deleteBrand(1L))
                     .doesNotThrowAnyException();
         }
     }
diff --git a/apps/commerce-api/src/test/java/com/loopers/domain/cart/CartItemModelTest.java b/apps/commerce-api/src/test/java/com/loopers/domain/cart/CartItemModelTest.java
index 81cc5f4d4..6beb2336f 100644
--- a/apps/commerce-api/src/test/java/com/loopers/domain/cart/CartItemModelTest.java
+++ b/apps/commerce-api/src/test/java/com/loopers/domain/cart/CartItemModelTest.java
@@ -17,24 +17,24 @@ class CreateTests {
         @Test
         @DisplayName("유효한 입력으로 생성 성공")
         void create_WithValidInputs_ShouldSuccess() {
-            CartItemModel cartItem = CartItemModel.create("user-001", "product-001", 3);
+            CartItemModel cartItem = CartItemModel.create(1L, 1L, 3);
 
-            assertThat(cartItem.getUserId()).isEqualTo("user-001");
-            assertThat(cartItem.getProductId()).isEqualTo("product-001");
+            assertThat(cartItem.getUserId()).isEqualTo(1L);
+            assertThat(cartItem.getProductId()).isEqualTo(1L);
             assertThat(cartItem.getQuantity()).isEqualTo(3);
         }
 
         @Test
         @DisplayName("수량이 0이면 CoreException 발생")
         void create_WithZeroQuantity_ShouldThrow() {
-            assertThatThrownBy(() -> CartItemModel.create("user-001", "product-001", 0))
+            assertThatThrownBy(() -> CartItemModel.create(1L, 1L, 0))
                     .isInstanceOf(CoreException.class);
         }
 
         @Test
         @DisplayName("수량이 음수이면 CoreException 발생")
         void create_WithNegativeQuantity_ShouldThrow() {
-            assertThatThrownBy(() -> CartItemModel.create("user-001", "product-001", -1))
+            assertThatThrownBy(() -> CartItemModel.create(1L, 1L, -1))
                     .isInstanceOf(CoreException.class);
         }
     }
@@ -79,6 +79,6 @@ void mergeQuantity_ShouldAddToExisting() {
     // === Helper ===
 
     private CartItemModel createTestCartItem() {
-        return CartItemModel.create("user-001", "product-001", 3);
+        return CartItemModel.create(1L, 1L, 3);
     }
 }
diff --git a/apps/commerce-api/src/test/java/com/loopers/domain/cart/CartServiceTest.java b/apps/commerce-api/src/test/java/com/loopers/domain/cart/CartServiceTest.java
index 5931611e5..6eec809ea 100644
--- a/apps/commerce-api/src/test/java/com/loopers/domain/cart/CartServiceTest.java
+++ b/apps/commerce-api/src/test/java/com/loopers/domain/cart/CartServiceTest.java
@@ -36,12 +36,12 @@ class AddItemTests {
         @Test
         @DisplayName("새 상품을 장바구니에 등록하면 save가 호출된다")
         void addItem_NewItem_ShouldCreate() {
-            when(cartItemRepository.findById(new CartItemId("user-1", "product-1")))
+            when(cartItemRepository.findById(new CartItemId(1L, 1L)))
                     .thenReturn(Optional.empty());
             when(cartItemRepository.save(any(CartItemModel.class)))
                     .thenAnswer(invocation -> invocation.getArgument(0));
 
-            cartService.addItem("user-1", "product-1", 3);
+            cartService.addItem(1L, 1L, 3);
 
             verify(cartItemRepository).save(any(CartItemModel.class));
         }
@@ -49,11 +49,11 @@ void addItem_NewItem_ShouldCreate() {
         @Test
         @DisplayName("이미 있는 상품 재등록 시 수량이 병합된다")
         void addItem_ExistingItem_ShouldMergeQuantity() {
-            CartItemModel existing = CartItemModel.create("user-1", "product-1", 2);
-            when(cartItemRepository.findById(new CartItemId("user-1", "product-1")))
+            CartItemModel existing = CartItemModel.create(1L, 1L, 2);
+            when(cartItemRepository.findById(new CartItemId(1L, 1L)))
                     .thenReturn(Optional.of(existing));
 
-            cartService.addItem("user-1", "product-1", 3);
+            cartService.addItem(1L, 1L, 3);
 
             assertThat(existing.getQuantity()).isEqualTo(5);
             verify(cartItemRepository, never()).save(any());
@@ -69,11 +69,11 @@ class ChangeQuantityTests {
         @Test
         @DisplayName("정상적으로 수량이 변경된다")
         void changeQuantity_ShouldUpdate() {
-            CartItemModel item = CartItemModel.create("user-1", "product-1", 2);
-            when(cartItemRepository.findById(new CartItemId("user-1", "product-1")))
+            CartItemModel item = CartItemModel.create(1L, 1L, 2);
+            when(cartItemRepository.findById(new CartItemId(1L, 1L)))
                     .thenReturn(Optional.of(item));
 
-            cartService.changeQuantity("user-1", "product-1", 5);
+            cartService.changeQuantity(1L, 1L, 5);
 
             assertThat(item.getQuantity()).isEqualTo(5);
         }
@@ -81,10 +81,10 @@ void changeQuantity_ShouldUpdate() {
         @Test
         @DisplayName("존재하지 않는 항목 수량 변경 시 CART_ITEM_NOT_FOUND 예외가 발생한다")
         void changeQuantity_NonExistingItem_ShouldThrow() {
-            when(cartItemRepository.findById(new CartItemId("user-1", "product-1")))
+            when(cartItemRepository.findById(new CartItemId(1L, 1L)))
                     .thenReturn(Optional.empty());
 
-            assertThatThrownBy(() -> cartService.changeQuantity("user-1", "product-1", 5))
+            assertThatThrownBy(() -> cartService.changeQuantity(1L, 1L, 5))
                     .isInstanceOf(CoreException.class)
                     .satisfies(ex -> assertThat(((CoreException) ex).getErrorType())
                             .isEqualTo(ErrorType.CART_ITEM_NOT_FOUND));
@@ -100,11 +100,11 @@ class RemoveItemTests {
         @Test
         @DisplayName("정상 삭제 시 delete가 호출된다")
         void removeItem_ShouldDelete() {
-            CartItemModel item = CartItemModel.create("user-1", "product-1", 3);
-            when(cartItemRepository.findById(new CartItemId("user-1", "product-1")))
+            CartItemModel item = CartItemModel.create(1L, 1L, 3);
+            when(cartItemRepository.findById(new CartItemId(1L, 1L)))
                     .thenReturn(Optional.of(item));
 
-            cartService.removeItem("user-1", "product-1");
+            cartService.removeItem(1L, 1L);
 
             verify(cartItemRepository).delete(item);
         }
@@ -112,10 +112,10 @@ void removeItem_ShouldDelete() {
         @Test
         @DisplayName("존재하지 않는 항목 삭제 시 에러 없이 통과한다 (멱등)")
         void removeItem_NonExisting_ShouldBeIdempotent() {
-            when(cartItemRepository.findById(new CartItemId("user-1", "product-1")))
+            when(cartItemRepository.findById(new CartItemId(1L, 1L)))
                     .thenReturn(Optional.empty());
 
-            assertThatCode(() -> cartService.removeItem("user-1", "product-1"))
+            assertThatCode(() -> cartService.removeItem(1L, 1L))
                     .doesNotThrowAnyException();
             verify(cartItemRepository, never()).delete(any());
         }
@@ -130,13 +130,13 @@ class GetCartItemsTests {
         @Test
         @DisplayName("사용자의 장바구니 항목 목록을 반환한다")
         void getCartItems_ShouldReturnItemList() {
-            CartItemModel item = CartItemModel.create("user-1", "product-1", 2);
-            when(cartItemRepository.findAllByUserId("user-1")).thenReturn(List.of(item));
+            CartItemModel item = CartItemModel.create(1L, 1L, 2);
+            when(cartItemRepository.findAllByUserId(1L)).thenReturn(List.of(item));
 
-            List<CartItemModel> result = cartService.getCartItems("user-1");
+            List<CartItemModel> result = cartService.getCartItems(1L);
 
             assertThat(result).hasSize(1);
-            assertThat(result.get(0).getProductId()).isEqualTo("product-1");
+            assertThat(result.get(0).getProductId()).isEqualTo(1L);
         }
     }
 
@@ -149,13 +149,13 @@ class RestoreTests {
         @Test
         @DisplayName("주문 취소 시 주문 항목이 장바구니에 복원된다")
         void restoreFromOrder_ShouldCreateCartItems() {
-            when(cartItemRepository.findById(new CartItemId("user-1", "product-1")))
+            when(cartItemRepository.findById(new CartItemId(1L, 1L)))
                     .thenReturn(Optional.empty());
             when(cartItemRepository.save(any(CartItemModel.class)))
                     .thenAnswer(invocation -> invocation.getArgument(0));
 
-            cartService.restoreFromOrder("user-1",
-                    List.of(new CartService.RestoreItem("product-1", 3)));
+            cartService.restoreFromOrder(1L,
+                    List.of(new CartService.RestoreItem(1L, 3)));
 
             verify(cartItemRepository).save(any(CartItemModel.class));
         }
@@ -163,12 +163,12 @@ void restoreFromOrder_ShouldCreateCartItems() {
         @Test
         @DisplayName("기존 장바구니에 동일 상품이 있으면 수량이 병합된다")
         void restoreFromOrder_ExistingItem_ShouldMergeQuantity() {
-            CartItemModel existing = CartItemModel.create("user-1", "product-1", 2);
-            when(cartItemRepository.findById(new CartItemId("user-1", "product-1")))
+            CartItemModel existing = CartItemModel.create(1L, 1L, 2);
+            when(cartItemRepository.findById(new CartItemId(1L, 1L)))
                     .thenReturn(Optional.of(existing));
 
-            cartService.restoreFromOrder("user-1",
-                    List.of(new CartService.RestoreItem("product-1", 3)));
+            cartService.restoreFromOrder(1L,
+                    List.of(new CartService.RestoreItem(1L, 3)));
 
             assertThat(existing.getQuantity()).isEqualTo(5);
             verify(cartItemRepository, never()).save(any());
diff --git a/apps/commerce-api/src/test/java/com/loopers/domain/coupon/CouponIssuanceConcurrencyTest.java b/apps/commerce-api/src/test/java/com/loopers/domain/coupon/CouponIssuanceConcurrencyTest.java
new file mode 100644
index 000000000..89b027925
--- /dev/null
+++ b/apps/commerce-api/src/test/java/com/loopers/domain/coupon/CouponIssuanceConcurrencyTest.java
@@ -0,0 +1,128 @@
+package com.loopers.domain.coupon;
+
+import com.loopers.support.enums.DiscountType;
+import com.loopers.support.error.CoreException;
+import com.loopers.utils.DatabaseCleanUp;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.test.context.ActiveProfiles;
+
+import java.math.BigDecimal;
+import java.time.LocalDateTime;
+import java.util.ArrayList;
+import java.util.List;
+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")
+@DisplayName("쿠폰 발급 동시성 테스트")
+class CouponIssuanceConcurrencyTest {
+
+    @Autowired
+    CouponService couponService;
+
+    @Autowired
+    UserCouponRepository userCouponRepository;
+
+    @Autowired
+    DatabaseCleanUp databaseCleanUp;
+
+    private Long couponId;
+
+    @BeforeEach
+    void setUp() {
+        CouponModel coupon = couponService.createCoupon(
+                "동시성테스트쿠폰", DiscountType.FIXED, BigDecimal.valueOf(1000),
+                null, LocalDateTime.now().plusDays(30));
+        couponId = coupon.getCouponId();
+    }
+
+    @AfterEach
+    void tearDown() {
+        databaseCleanUp.truncateAllTables();
+    }
+
+    @Test
+    @DisplayName("같은 사용자가 동시에 같은 쿠폰을 2회 발급 요청 시 1건만 성공한다")
+    void concurrentIssueSameUser_ShouldIssueOnlyOnce() throws InterruptedException {
+        int threadCount = 2;
+        ExecutorService executor = Executors.newFixedThreadPool(threadCount);
+        CountDownLatch startLatch = new CountDownLatch(1);
+        CountDownLatch doneLatch = new CountDownLatch(threadCount);
+        AtomicInteger successCount = new AtomicInteger(0);
+        AtomicInteger failCount = new AtomicInteger(0);
+
+        for (int i = 0; i < threadCount; i++) {
+            executor.submit(() -> {
+                try {
+                    startLatch.await();
+                    couponService.issueCoupon(1L, couponId);
+                    successCount.incrementAndGet();
+                } catch (CoreException e) {
+                    failCount.incrementAndGet();
+                } catch (InterruptedException e) {
+                    Thread.currentThread().interrupt();
+                } finally {
+                    doneLatch.countDown();
+                }
+            });
+        }
+
+        startLatch.countDown();
+        doneLatch.await();
+        executor.shutdown();
+
+        assertThat(successCount.get()).isEqualTo(1);
+        assertThat(failCount.get()).isEqualTo(1);
+
+        List<UserCouponModel> issued = userCouponRepository.findAllByUserId(1L);
+        assertThat(issued).hasSize(1);
+    }
+
+    @Test
+    @DisplayName("50명이 동시에 동일 쿠폰 발급 시 중복 발급 없이 정확히 처리된다")
+    void concurrentIssueDifferentUsers_ShouldNotDuplicate() throws InterruptedException {
+        int threadCount = 50;
+        ExecutorService executor = Executors.newFixedThreadPool(threadCount);
+        CountDownLatch startLatch = new CountDownLatch(1);
+        CountDownLatch doneLatch = new CountDownLatch(threadCount);
+        AtomicInteger successCount = new AtomicInteger(0);
+        List<Long> userIds = new ArrayList<>();
+        for (long i = 1; i <= threadCount; i++) {
+            userIds.add(i);
+        }
+
+        for (int i = 0; i < threadCount; i++) {
+            final Long userId = userIds.get(i);
+            executor.submit(() -> {
+                try {
+                    startLatch.await();
+                    couponService.issueCoupon(userId, couponId);
+                    successCount.incrementAndGet();
+                } catch (CoreException | InterruptedException e) {
+                    if (e instanceof InterruptedException) {
+                        Thread.currentThread().interrupt();
+                    }
+                } finally {
+                    doneLatch.countDown();
+                }
+            });
+        }
+
+        startLatch.countDown();
+        doneLatch.await();
+        executor.shutdown();
+
+        // 50명 각각 다른 userId → 모두 성공해야 함
+        assertThat(successCount.get()).isEqualTo(threadCount);
+    }
+}
diff --git a/apps/commerce-api/src/test/java/com/loopers/domain/coupon/CouponModelTest.java b/apps/commerce-api/src/test/java/com/loopers/domain/coupon/CouponModelTest.java
new file mode 100644
index 000000000..3092e5253
--- /dev/null
+++ b/apps/commerce-api/src/test/java/com/loopers/domain/coupon/CouponModelTest.java
@@ -0,0 +1,145 @@
+package com.loopers.domain.coupon;
+
+import com.loopers.support.enums.DiscountType;
+import com.loopers.support.error.CoreException;
+import com.loopers.support.error.ErrorType;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+
+import java.math.BigDecimal;
+import java.time.LocalDateTime;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+@DisplayName("CouponModel 단위 테스트")
+class CouponModelTest {
+
+    private CouponModel createFixedCoupon(BigDecimal value) {
+        return CouponModel.create("테스트쿠폰", DiscountType.FIXED, value, null,
+                LocalDateTime.now().plusDays(30));
+    }
+
+    private CouponModel createRateCoupon(BigDecimal rate) {
+        return CouponModel.create("테스트쿠폰", DiscountType.RATE, rate, null,
+                LocalDateTime.now().plusDays(30));
+    }
+
+    @Nested
+    @DisplayName("calculateDiscount - 할인 금액 계산")
+    class CalculateDiscountTests {
+
+        @Test
+        @DisplayName("FIXED 쿠폰은 discountValue를 반환한다")
+        void calculateDiscount_Fixed_ShouldReturnDiscountValue() {
+            CouponModel coupon = createFixedCoupon(BigDecimal.valueOf(5000));
+            BigDecimal result = coupon.calculateDiscount(BigDecimal.valueOf(30000));
+            assertThat(result).isEqualByComparingTo(BigDecimal.valueOf(5000));
+        }
+
+        @Test
+        @DisplayName("FIXED 쿠폰 할인값이 주문 금액 초과 시 주문 금액을 반환한다")
+        void calculateDiscount_Fixed_WhenExceedsTotalAmount_ShouldCapAtTotalAmount() {
+            CouponModel coupon = createFixedCoupon(BigDecimal.valueOf(50000));
+            BigDecimal result = coupon.calculateDiscount(BigDecimal.valueOf(10000));
+            assertThat(result).isEqualByComparingTo(BigDecimal.valueOf(10000));
+        }
+
+        @Test
+        @DisplayName("RATE 쿠폰은 비율로 할인 금액을 계산하고 FLOOR 처리한다")
+        void calculateDiscount_Rate_ShouldReturnPercentageFloor() {
+            CouponModel coupon = createRateCoupon(BigDecimal.valueOf(10));
+            BigDecimal result = coupon.calculateDiscount(BigDecimal.valueOf(33333));
+            // 33333 * 10 / 100 = 3333.3 → FLOOR → 3333
+            assertThat(result).isEqualByComparingTo(BigDecimal.valueOf(3333));
+        }
+
+        @Test
+        @DisplayName("RATE 100% 쿠폰은 전체 금액을 반환한다")
+        void calculateDiscount_Rate_100Percent_ShouldReturnTotalAmount() {
+            CouponModel coupon = createRateCoupon(BigDecimal.valueOf(100));
+            BigDecimal result = coupon.calculateDiscount(BigDecimal.valueOf(50000));
+            assertThat(result).isEqualByComparingTo(BigDecimal.valueOf(50000));
+        }
+    }
+
+    @Nested
+    @DisplayName("validateApplicable - 쿠폰 적용 가능 여부 검증")
+    class ValidateApplicableTests {
+
+        @Test
+        @DisplayName("만료된 쿠폰은 COUPON_NOT_APPLICABLE 예외를 던진다")
+        void validateApplicable_WhenExpired_ShouldThrowCouponNotApplicable() {
+            CouponModel coupon = CouponModel.create("만료쿠폰", DiscountType.FIXED, BigDecimal.valueOf(1000), null,
+                    LocalDateTime.now().minusDays(1));
+            assertThatThrownBy(() -> coupon.validateApplicable(BigDecimal.valueOf(10000)))
+                    .isInstanceOf(CoreException.class)
+                    .satisfies(ex -> assertThat(((CoreException) ex).getErrorType())
+                            .isEqualTo(ErrorType.COUPON_NOT_APPLICABLE));
+        }
+
+        @Test
+        @DisplayName("삭제된 쿠폰은 COUPON_NOT_APPLICABLE 예외를 던진다")
+        void validateApplicable_WhenDeleted_ShouldThrowCouponNotApplicable() {
+            CouponModel coupon = CouponModel.create("쿠폰", DiscountType.FIXED, BigDecimal.valueOf(1000), null,
+                    LocalDateTime.now().plusDays(10));
+            coupon.softDelete();
+            assertThatThrownBy(() -> coupon.validateApplicable(BigDecimal.valueOf(10000)))
+                    .isInstanceOf(CoreException.class)
+                    .satisfies(ex -> assertThat(((CoreException) ex).getErrorType())
+                            .isEqualTo(ErrorType.COUPON_NOT_APPLICABLE));
+        }
+
+        @Test
+        @DisplayName("최소 주문 금액 미충족 시 COUPON_NOT_APPLICABLE 예외를 던진다")
+        void validateApplicable_WhenBelowMinOrderAmount_ShouldThrowCouponNotApplicable() {
+            CouponModel coupon = CouponModel.create("쿠폰", DiscountType.FIXED, BigDecimal.valueOf(1000),
+                    BigDecimal.valueOf(20000), LocalDateTime.now().plusDays(10));
+            assertThatThrownBy(() -> coupon.validateApplicable(BigDecimal.valueOf(15000)))
+                    .isInstanceOf(CoreException.class)
+                    .satisfies(ex -> assertThat(((CoreException) ex).getErrorType())
+                            .isEqualTo(ErrorType.COUPON_NOT_APPLICABLE));
+        }
+
+        @Test
+        @DisplayName("유효한 쿠폰은 예외가 발생하지 않는다")
+        void validateApplicable_WhenValid_ShouldNotThrow() {
+            CouponModel coupon = CouponModel.create("쿠폰", DiscountType.FIXED, BigDecimal.valueOf(1000),
+                    BigDecimal.valueOf(10000), LocalDateTime.now().plusDays(10));
+            coupon.validateApplicable(BigDecimal.valueOf(20000)); // 예외 없음
+        }
+    }
+
+    @Nested
+    @DisplayName("guard - 생성 유효성 검증")
+    class GuardTests {
+
+        @Test
+        @DisplayName("할인값이 0 이하이면 예외가 발생한다")
+        void guard_WhenValueZeroOrNegative_ShouldThrow() {
+            assertThatThrownBy(() ->
+                    CouponModel.create("쿠폰", DiscountType.FIXED, BigDecimal.ZERO, null,
+                            LocalDateTime.now().plusDays(10)))
+                    .isInstanceOf(CoreException.class);
+        }
+
+        @Test
+        @DisplayName("RATE 쿠폰의 할인율이 100을 초과하면 예외가 발생한다")
+        void guard_WhenRateExceeds100_ShouldThrow() {
+            assertThatThrownBy(() ->
+                    CouponModel.create("쿠폰", DiscountType.RATE, BigDecimal.valueOf(101), null,
+                            LocalDateTime.now().plusDays(10)))
+                    .isInstanceOf(CoreException.class);
+        }
+
+        @Test
+        @DisplayName("쿠폰명이 공백이면 예외가 발생한다")
+        void guard_WhenNameBlank_ShouldThrow() {
+            assertThatThrownBy(() ->
+                    CouponModel.create("  ", DiscountType.FIXED, BigDecimal.valueOf(1000), null,
+                            LocalDateTime.now().plusDays(10)))
+                    .isInstanceOf(CoreException.class);
+        }
+    }
+}
diff --git a/apps/commerce-api/src/test/java/com/loopers/domain/coupon/CouponServiceTest.java b/apps/commerce-api/src/test/java/com/loopers/domain/coupon/CouponServiceTest.java
new file mode 100644
index 000000000..d56f55a62
--- /dev/null
+++ b/apps/commerce-api/src/test/java/com/loopers/domain/coupon/CouponServiceTest.java
@@ -0,0 +1,153 @@
+package com.loopers.domain.coupon;
+
+import com.loopers.support.enums.DiscountType;
+import com.loopers.support.enums.UserCouponStatus;
+import com.loopers.support.error.CoreException;
+import com.loopers.support.error.ErrorType;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+import java.math.BigDecimal;
+import java.time.LocalDateTime;
+import java.util.Optional;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+@ExtendWith(MockitoExtension.class)
+@DisplayName("CouponService 단위 테스트")
+class CouponServiceTest {
+
+    private static final Long USER_ID = 1L;
+    private static final Long COUPON_ID = 10L;
+    private static final Long USER_COUPON_ID = 100L;
+
+    @Mock
+    CouponRepository couponRepository;
+
+    @Mock
+    UserCouponRepository userCouponRepository;
+
+    @InjectMocks
+    CouponService couponService;
+
+    private CouponModel createValidCoupon() {
+        return CouponModel.create("테스트쿠폰", DiscountType.FIXED, BigDecimal.valueOf(5000), null,
+                LocalDateTime.now().plusDays(30));
+    }
+
+    @Nested
+    @DisplayName("issueCoupon - 쿠폰 발급")
+    class IssueCouponTests {
+
+        @Test
+        @DisplayName("정상 발급 시 UserCouponModel이 저장된다")
+        void issueCoupon_NewIssuance_ShouldSave() {
+            CouponModel coupon = createValidCoupon();
+            when(couponRepository.findByIdWithLock(COUPON_ID)).thenReturn(Optional.of(coupon));
+            when(userCouponRepository.existsByUserIdAndCouponId(USER_ID, COUPON_ID)).thenReturn(false);
+            UserCouponModel saved = UserCouponModel.create(USER_ID, COUPON_ID);
+            when(userCouponRepository.save(any())).thenReturn(saved);
+
+            UserCouponModel result = couponService.issueCoupon(USER_ID, COUPON_ID);
+
+            assertThat(result).isNotNull();
+            assertThat(result.getStatus()).isEqualTo(UserCouponStatus.AVAILABLE);
+            verify(userCouponRepository).save(any(UserCouponModel.class));
+        }
+
+        @Test
+        @DisplayName("쿠폰이 없으면 COUPON_NOT_FOUND 예외가 발생한다")
+        void issueCoupon_CouponNotFound_ShouldThrowCouponNotFound() {
+            when(couponRepository.findByIdWithLock(COUPON_ID)).thenReturn(Optional.empty());
+
+            assertThatThrownBy(() -> couponService.issueCoupon(USER_ID, COUPON_ID))
+                    .isInstanceOf(CoreException.class)
+                    .satisfies(ex -> assertThat(((CoreException) ex).getErrorType())
+                            .isEqualTo(ErrorType.COUPON_NOT_FOUND));
+            verify(userCouponRepository, never()).save(any());
+        }
+
+        @Test
+        @DisplayName("이미 발급된 쿠폰이면 COUPON_ALREADY_ISSUED 예외가 발생한다")
+        void issueCoupon_AlreadyIssued_ShouldThrowCouponAlreadyIssued() {
+            CouponModel coupon = createValidCoupon();
+            when(couponRepository.findByIdWithLock(COUPON_ID)).thenReturn(Optional.of(coupon));
+            when(userCouponRepository.existsByUserIdAndCouponId(USER_ID, COUPON_ID)).thenReturn(true);
+
+            assertThatThrownBy(() -> couponService.issueCoupon(USER_ID, COUPON_ID))
+                    .isInstanceOf(CoreException.class)
+                    .satisfies(ex -> assertThat(((CoreException) ex).getErrorType())
+                            .isEqualTo(ErrorType.COUPON_ALREADY_ISSUED));
+            verify(userCouponRepository, never()).save(any());
+        }
+
+        @Test
+        @DisplayName("만료된 쿠폰이면 COUPON_NOT_APPLICABLE 예외가 발생한다")
+        void issueCoupon_ExpiredCoupon_ShouldThrowCouponNotApplicable() {
+            CouponModel expiredCoupon = CouponModel.create("만료쿠폰", DiscountType.FIXED,
+                    BigDecimal.valueOf(1000), null, LocalDateTime.now().minusDays(1));
+            when(couponRepository.findByIdWithLock(COUPON_ID)).thenReturn(Optional.of(expiredCoupon));
+
+            assertThatThrownBy(() -> couponService.issueCoupon(USER_ID, COUPON_ID))
+                    .isInstanceOf(CoreException.class)
+                    .satisfies(ex -> assertThat(((CoreException) ex).getErrorType())
+                            .isEqualTo(ErrorType.COUPON_NOT_APPLICABLE));
+            verify(userCouponRepository, never()).save(any());
+        }
+    }
+
+    @Nested
+    @DisplayName("validateAndGetUserCoupon - 발급 쿠폰 조회 및 검증")
+    class ValidateAndGetUserCouponTests {
+
+        @Test
+        @DisplayName("AVAILABLE 상태의 본인 쿠폰이면 반환한다")
+        void validateAndGetUserCoupon_WhenAvailable_ShouldReturn() {
+            UserCouponModel userCoupon = UserCouponModel.create(USER_ID, COUPON_ID);
+            when(userCouponRepository.findByIdWithLock(USER_COUPON_ID))
+                    .thenReturn(Optional.of(userCoupon));
+
+            UserCouponModel result = couponService.validateAndGetUserCoupon(USER_ID, USER_COUPON_ID);
+
+            assertThat(result).isNotNull();
+            assertThat(result.isAvailable()).isTrue();
+        }
+
+        @Test
+        @DisplayName("다른 사용자 소유 쿠폰이면 USER_COUPON_NOT_FOUND 예외가 발생한다")
+        void validateAndGetUserCoupon_WhenNotOwned_ShouldThrowUserCouponNotFound() {
+            UserCouponModel otherUserCoupon = UserCouponModel.create(999L, COUPON_ID);
+            when(userCouponRepository.findByIdWithLock(USER_COUPON_ID))
+                    .thenReturn(Optional.of(otherUserCoupon));
+
+            assertThatThrownBy(() -> couponService.validateAndGetUserCoupon(USER_ID, USER_COUPON_ID))
+                    .isInstanceOf(CoreException.class)
+                    .satisfies(ex -> assertThat(((CoreException) ex).getErrorType())
+                            .isEqualTo(ErrorType.USER_COUPON_NOT_FOUND));
+        }
+
+        @Test
+        @DisplayName("USED 상태의 쿠폰이면 COUPON_NOT_AVAILABLE 예외가 발생한다")
+        void validateAndGetUserCoupon_WhenUsed_ShouldThrowCouponNotAvailable() {
+            UserCouponModel userCoupon = UserCouponModel.create(USER_ID, COUPON_ID);
+            userCoupon.markAsUsed(999L);
+            when(userCouponRepository.findByIdWithLock(USER_COUPON_ID))
+                    .thenReturn(Optional.of(userCoupon));
+
+            assertThatThrownBy(() -> couponService.validateAndGetUserCoupon(USER_ID, USER_COUPON_ID))
+                    .isInstanceOf(CoreException.class)
+                    .satisfies(ex -> assertThat(((CoreException) ex).getErrorType())
+                            .isEqualTo(ErrorType.COUPON_NOT_AVAILABLE));
+        }
+    }
+}
diff --git a/apps/commerce-api/src/test/java/com/loopers/domain/coupon/OrderCouponConcurrencyTest.java b/apps/commerce-api/src/test/java/com/loopers/domain/coupon/OrderCouponConcurrencyTest.java
new file mode 100644
index 000000000..b8a786c42
--- /dev/null
+++ b/apps/commerce-api/src/test/java/com/loopers/domain/coupon/OrderCouponConcurrencyTest.java
@@ -0,0 +1,114 @@
+package com.loopers.domain.coupon;
+
+import com.loopers.application.order.OrderFacade;
+import com.loopers.domain.brand.BrandModel;
+import com.loopers.domain.brand.BrandService;
+import com.loopers.domain.order.OrderItemCommand;
+import com.loopers.domain.product.ProductModel;
+import com.loopers.domain.product.ProductService;
+import com.loopers.domain.product.StockService;
+import com.loopers.domain.user.UserModel;
+import com.loopers.domain.user.UserRegisterCommand;
+import com.loopers.domain.user.UserService;
+import com.loopers.support.enums.DiscountType;
+import com.loopers.support.enums.UserCouponStatus;
+import com.loopers.utils.DatabaseCleanUp;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.test.context.ActiveProfiles;
+
+import java.math.BigDecimal;
+import java.time.LocalDateTime;
+import java.util.List;
+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")
+@DisplayName("주문-쿠폰 동시성 테스트")
+class OrderCouponConcurrencyTest {
+
+    @Autowired OrderFacade orderFacade;
+    @Autowired CouponService couponService;
+    @Autowired UserCouponRepository userCouponRepository;
+    @Autowired UserService userService;
+    @Autowired ProductService productService;
+    @Autowired BrandService brandService;
+    @Autowired StockService stockService;
+    @Autowired DatabaseCleanUp databaseCleanUp;
+
+    private Long userId;
+    private Long productId;
+    private Long userCouponId;
+
+    @BeforeEach
+    void setUp() {
+        // 브랜드 + 상품 + 재고 생성
+        BrandModel brand = brandService.createBrand("테스트브랜드", "설명", "서울");
+        ProductModel product = productService.createProduct("테스트상품", brand.getBrandId(),
+                BigDecimal.valueOf(50000), "설명");
+        productId = product.getProductId();
+        stockService.createStock(productId, 100);
+
+        // 사용자 등록
+        UserModel user = userService.register(new UserRegisterCommand(
+                "couponuser", "Test1234!@#", "쿠폰유저",
+                "19900101", "coupon@test.com", "서울"));
+        userId = user.getUserId();
+
+        // 쿠폰 생성 및 발급
+        CouponModel coupon = couponService.createCoupon("테스트쿠폰", DiscountType.FIXED,
+                BigDecimal.valueOf(5000), null, LocalDateTime.now().plusDays(30));
+        UserCouponModel userCoupon = couponService.issueCoupon(userId, coupon.getCouponId());
+        userCouponId = userCoupon.getUserCouponId();
+    }
+
+    @AfterEach
+    void tearDown() {
+        databaseCleanUp.truncateAllTables();
+    }
+
+    @Test
+    @DisplayName("2 스레드가 동일 쿠폰으로 동시 주문 시 1 성공, 1 실패, 쿠폰 USED")
+    void concurrentOrderWithSameCoupon_ShouldSucceedOnlyOnce() throws InterruptedException {
+        int threadCount = 2;
+        ExecutorService executor = Executors.newFixedThreadPool(threadCount);
+        CountDownLatch startLatch = new CountDownLatch(1);
+        CountDownLatch doneLatch = new CountDownLatch(threadCount);
+        AtomicInteger successCount = new AtomicInteger(0);
+        AtomicInteger failCount = new AtomicInteger(0);
+
+        for (int i = 0; i < threadCount; i++) {
+            executor.submit(() -> {
+                try {
+                    startLatch.await();
+                    List<OrderItemCommand> items = List.of(new OrderItemCommand(productId, 1));
+                    orderFacade.createDirectOrder(userId, items, userCouponId);
+                    successCount.incrementAndGet();
+                } catch (Exception e) {
+                    failCount.incrementAndGet();
+                } finally {
+                    doneLatch.countDown();
+                }
+            });
+        }
+
+        startLatch.countDown();
+        doneLatch.await();
+        executor.shutdown();
+
+        assertThat(successCount.get()).isEqualTo(1);
+        assertThat(failCount.get()).isEqualTo(1);
+
+        UserCouponModel userCoupon = userCouponRepository.findById(userCouponId).get();
+        assertThat(userCoupon.getStatus()).isEqualTo(UserCouponStatus.USED);
+    }
+}
diff --git a/apps/commerce-api/src/test/java/com/loopers/domain/coupon/UserCouponModelTest.java b/apps/commerce-api/src/test/java/com/loopers/domain/coupon/UserCouponModelTest.java
new file mode 100644
index 000000000..fcbbcf6c4
--- /dev/null
+++ b/apps/commerce-api/src/test/java/com/loopers/domain/coupon/UserCouponModelTest.java
@@ -0,0 +1,63 @@
+package com.loopers.domain.coupon;
+
+import com.loopers.support.enums.UserCouponStatus;
+import com.loopers.support.error.CoreException;
+import com.loopers.support.error.ErrorType;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+@DisplayName("UserCouponModel 단위 테스트")
+class UserCouponModelTest {
+
+    @Nested
+    @DisplayName("markAsUsed - 쿠폰 사용 처리")
+    class MarkAsUsedTests {
+
+        @Test
+        @DisplayName("AVAILABLE 상태의 쿠폰은 USED로 전이되고 usedAt, orderId가 설정된다")
+        void markAsUsed_WhenAvailable_ShouldSetStatusAndTimestamp() {
+            UserCouponModel userCoupon = UserCouponModel.create(1L, 10L);
+            userCoupon.markAsUsed(100L);
+
+            assertThat(userCoupon.getStatus()).isEqualTo(UserCouponStatus.USED);
+            assertThat(userCoupon.getUsedAt()).isNotNull();
+            assertThat(userCoupon.getOrderId()).isEqualTo(100L);
+        }
+
+        @Test
+        @DisplayName("이미 USED인 쿠폰을 다시 사용하면 COUPON_NOT_AVAILABLE 예외가 발생한다")
+        void markAsUsed_WhenAlreadyUsed_ShouldThrowCouponNotAvailable() {
+            UserCouponModel userCoupon = UserCouponModel.create(1L, 10L);
+            userCoupon.markAsUsed(100L);
+
+            assertThatThrownBy(() -> userCoupon.markAsUsed(200L))
+                    .isInstanceOf(CoreException.class)
+                    .satisfies(ex -> assertThat(((CoreException) ex).getErrorType())
+                            .isEqualTo(ErrorType.COUPON_NOT_AVAILABLE));
+        }
+    }
+
+    @Nested
+    @DisplayName("isAvailable - 사용 가능 여부")
+    class IsAvailableTests {
+
+        @Test
+        @DisplayName("AVAILABLE 상태이면 true를 반환한다")
+        void isAvailable_WhenAvailable_ShouldReturnTrue() {
+            UserCouponModel userCoupon = UserCouponModel.create(1L, 10L);
+            assertThat(userCoupon.isAvailable()).isTrue();
+        }
+
+        @Test
+        @DisplayName("USED 상태이면 false를 반환한다")
+        void isAvailable_WhenUsed_ShouldReturnFalse() {
+            UserCouponModel userCoupon = UserCouponModel.create(1L, 10L);
+            userCoupon.markAsUsed(100L);
+            assertThat(userCoupon.isAvailable()).isFalse();
+        }
+    }
+}
diff --git a/apps/commerce-api/src/test/java/com/loopers/domain/like/LikeConcurrencyTest.java b/apps/commerce-api/src/test/java/com/loopers/domain/like/LikeConcurrencyTest.java
new file mode 100644
index 000000000..49c24bbce
--- /dev/null
+++ b/apps/commerce-api/src/test/java/com/loopers/domain/like/LikeConcurrencyTest.java
@@ -0,0 +1,149 @@
+package com.loopers.domain.like;
+
+import com.loopers.domain.product.ProductModel;
+import com.loopers.domain.product.ProductRepository;
+import com.loopers.domain.product.ProductService;
+import com.loopers.domain.product.StockService;
+import com.loopers.domain.user.UserModel;
+import com.loopers.domain.user.UserRegisterCommand;
+import com.loopers.domain.user.UserService;
+import com.loopers.utils.DatabaseCleanUp;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.test.context.ActiveProfiles;
+
+import java.math.BigDecimal;
+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")
+@DisplayName("좋아요 동시성 테스트")
+class LikeConcurrencyTest {
+
+    @Autowired
+    LikeService likeService;
+
+    @Autowired
+    LikeRepository likeRepository;
+
+    @Autowired
+    ProductService productService;
+
+    @Autowired
+    ProductRepository productRepository;
+
+    @Autowired
+    StockService stockService;
+
+    @Autowired
+    UserService userService;
+
+    @Autowired
+    DatabaseCleanUp databaseCleanUp;
+
+    private Long productId;
+
+    @BeforeEach
+    void setUp() {
+        ProductModel product = productService.createProduct("테스트상품", 1L, BigDecimal.valueOf(10000), "설명");
+        productId = product.getProductId();
+        stockService.createStock(productId, 100);
+    }
+
+    @AfterEach
+    void tearDown() {
+        databaseCleanUp.truncateAllTables();
+    }
+
+    @Test
+    @DisplayName("20명이 동시에 같은 상품 좋아요 시 like 수 == 20, likeCount == 20")
+    void concurrentAddLike_DifferentUsers_ShouldAllSucceed() throws InterruptedException {
+        int threadCount = 20;
+        ExecutorService executor = Executors.newFixedThreadPool(threadCount);
+        CountDownLatch startLatch = new CountDownLatch(1);
+        CountDownLatch doneLatch = new CountDownLatch(threadCount);
+        AtomicInteger successCount = new AtomicInteger(0);
+
+        // 사용자 20명 생성
+        Long[] userIds = new Long[threadCount];
+        for (int i = 0; i < threadCount; i++) {
+            UserModel user = userService.register(new UserRegisterCommand(
+                    "likeuser" + i, "Test1234!@#", "유저" + i,
+                    "19900101", "user" + i + "@test.com", "서울"));
+            userIds[i] = user.getUserId();
+        }
+
+        for (int i = 0; i < threadCount; i++) {
+            final int index = i;
+            executor.submit(() -> {
+                try {
+                    startLatch.await();
+                    likeService.addLike(userIds[index], productId);
+                    successCount.incrementAndGet();
+                } catch (Exception e) {
+                    // 예외 발생 시 실패 카운트
+                } finally {
+                    doneLatch.countDown();
+                }
+            });
+        }
+
+        startLatch.countDown();
+        doneLatch.await();
+        executor.shutdown();
+
+        assertThat(successCount.get()).isEqualTo(20);
+
+        long likeCount = likeRepository.countByProductId(productId);
+        assertThat(likeCount).isEqualTo(20);
+
+        ProductModel product = productRepository.findById(productId).get();
+        assertThat(product.getLikeCount()).isEqualTo(20);
+    }
+
+    @Test
+    @DisplayName("같은 유저가 5번 동시 좋아요 시 like 수 == 1, likeCount == 1 (멱등)")
+    void concurrentAddLike_SameUser_ShouldBeIdempotent() throws InterruptedException {
+        int threadCount = 5;
+        ExecutorService executor = Executors.newFixedThreadPool(threadCount);
+        CountDownLatch startLatch = new CountDownLatch(1);
+        CountDownLatch doneLatch = new CountDownLatch(threadCount);
+
+        UserModel user = userService.register(new UserRegisterCommand(
+                "sameuser", "Test1234!@#", "같은유저",
+                "19900101", "same@test.com", "서울"));
+        Long userId = user.getUserId();
+
+        for (int i = 0; i < threadCount; i++) {
+            executor.submit(() -> {
+                try {
+                    startLatch.await();
+                    likeService.addLike(userId, productId);
+                } catch (Exception e) {
+                    // 멱등 처리로 예외는 무시
+                } finally {
+                    doneLatch.countDown();
+                }
+            });
+        }
+
+        startLatch.countDown();
+        doneLatch.await();
+        executor.shutdown();
+
+        long likeCount = likeRepository.countByProductId(productId);
+        assertThat(likeCount).isEqualTo(1);
+
+        ProductModel product = productRepository.findById(productId).get();
+        assertThat(product.getLikeCount()).isEqualTo(1);
+    }
+}
diff --git a/apps/commerce-api/src/test/java/com/loopers/domain/like/LikeModelTest.java b/apps/commerce-api/src/test/java/com/loopers/domain/like/LikeModelTest.java
index 22bee5902..f2287dce2 100644
--- a/apps/commerce-api/src/test/java/com/loopers/domain/like/LikeModelTest.java
+++ b/apps/commerce-api/src/test/java/com/loopers/domain/like/LikeModelTest.java
@@ -12,30 +12,30 @@ class LikeModelTest {
     @Test
     @DisplayName("유효한 입력으로 생성 성공")
     void create_WithValidInputs_ShouldSuccess() {
-        LikeModel like = LikeModel.create("user-001", "product-001");
+        LikeModel like = LikeModel.create(1L, 1L);
 
-        assertThat(like.getUserId()).isEqualTo("user-001");
-        assertThat(like.getProductId()).isEqualTo("product-001");
+        assertThat(like.getUserId()).isEqualTo(1L);
+        assertThat(like.getProductId()).isEqualTo(1L);
     }
 
     @Test
     @DisplayName("userId가 null이면 CoreException 발생")
     void create_WithNullUserId_ShouldThrow() {
-        assertThatThrownBy(() -> LikeModel.create(null, "product-001"))
+        assertThatThrownBy(() -> LikeModel.create(null, 1L))
                 .isInstanceOf(CoreException.class);
     }
 
     @Test
     @DisplayName("productId가 null이면 CoreException 발생")
     void create_WithNullProductId_ShouldThrow() {
-        assertThatThrownBy(() -> LikeModel.create("user-001", null))
+        assertThatThrownBy(() -> LikeModel.create(1L, null))
                 .isInstanceOf(CoreException.class);
     }
 
     @Test
     @DisplayName("생성 시 createdAt은 @PrePersist에서 설정된다 (직접 생성 시 null)")
     void create_ShouldSetCreatedAt() {
-        LikeModel like = LikeModel.create("user-001", "product-001");
+        LikeModel like = LikeModel.create(1L, 1L);
         // createdAt은 @PrePersist에서 설정되므로 JPA 없이는 null
         // 단위 테스트에서는 생성이 성공했음을 확인
         assertThat(like).isNotNull();
diff --git a/apps/commerce-api/src/test/java/com/loopers/domain/like/LikeServiceTest.java b/apps/commerce-api/src/test/java/com/loopers/domain/like/LikeServiceTest.java
index 1f330f346..9a36e5541 100644
--- a/apps/commerce-api/src/test/java/com/loopers/domain/like/LikeServiceTest.java
+++ b/apps/commerce-api/src/test/java/com/loopers/domain/like/LikeServiceTest.java
@@ -2,8 +2,6 @@
 
 import com.loopers.domain.product.ProductModel;
 import com.loopers.domain.product.ProductService;
-import com.loopers.support.error.CoreException;
-import com.loopers.support.error.ErrorType;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Nested;
 import org.junit.jupiter.api.Test;
@@ -12,13 +10,13 @@
 import org.mockito.Mock;
 import org.mockito.junit.jupiter.MockitoExtension;
 
-import java.math.BigDecimal;
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
 
 import static org.assertj.core.api.Assertions.*;
 import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyLong;
 import static org.mockito.Mockito.*;
 
 @ExtendWith(MockitoExtension.class)
@@ -41,42 +39,34 @@ class AddLikeTests {
         @Test
         @DisplayName("처음 좋아요 시 save가 호출된다")
         void addLike_NewLike_ShouldCreate() {
-            ProductModel product = createTestProduct();
-            when(productService.findById("product-1")).thenReturn(product);
-            when(likeRepository.findById(new LikeId("user-1", "product-1")))
+            ProductModel product = mock(ProductModel.class);
+            when(productService.findByIdWithLock(1L)).thenReturn(product);
+            when(likeRepository.findById(new LikeId(1L, 1L)))
                     .thenReturn(Optional.empty());
             when(likeRepository.save(any(LikeModel.class)))
                     .thenAnswer(invocation -> invocation.getArgument(0));
 
-            likeService.addLike("user-1", "product-1");
+            likeService.addLike(1L, 1L);
 
+            verify(productService).findByIdWithLock(1L);
             verify(likeRepository).save(any(LikeModel.class));
+            verify(productService).incrementLikeCount(1L);
         }
 
         @Test
         @DisplayName("이미 좋아요한 상품에 다시 좋아요하면 save가 호출되지 않는다 (멱등)")
         void addLike_AlreadyLiked_ShouldBeIdempotent() {
-            ProductModel product = createTestProduct();
-            when(productService.findById("product-1")).thenReturn(product);
-            LikeModel existingLike = LikeModel.create("user-1", "product-1");
-            when(likeRepository.findById(new LikeId("user-1", "product-1")))
+            ProductModel product = mock(ProductModel.class);
+            when(productService.findByIdWithLock(1L)).thenReturn(product);
+            LikeModel existingLike = LikeModel.create(1L, 1L);
+            when(likeRepository.findById(new LikeId(1L, 1L)))
                     .thenReturn(Optional.of(existingLike));
 
-            likeService.addLike("user-1", "product-1");
+            likeService.addLike(1L, 1L);
 
+            verify(productService).findByIdWithLock(1L);
             verify(likeRepository, never()).save(any());
-        }
-
-        @Test
-        @DisplayName("존재하지 않는 상품에 좋아요 시 LIKE_PRODUCT_NOT_FOUND 예외가 발생한다")
-        void addLike_ProductNotFound_ShouldThrow() {
-            when(productService.findById("nonexistent"))
-                    .thenThrow(new CoreException(ErrorType.PRODUCT_NOT_FOUND));
-
-            assertThatThrownBy(() -> likeService.addLike("user-1", "nonexistent"))
-                    .isInstanceOf(CoreException.class)
-                    .satisfies(ex -> assertThat(((CoreException) ex).getErrorType())
-                            .isEqualTo(ErrorType.LIKE_PRODUCT_NOT_FOUND));
+            verify(productService, never()).incrementLikeCount(anyLong());
         }
     }
 
@@ -87,24 +77,31 @@ class RemoveLikeTests {
         @Test
         @DisplayName("기존 좋아요를 삭제한다")
         void removeLike_Existing_ShouldDelete() {
-            LikeModel like = LikeModel.create("user-1", "product-1");
-            when(likeRepository.findById(new LikeId("user-1", "product-1")))
+            ProductModel product = mock(ProductModel.class);
+            when(productService.findByIdWithLock(1L)).thenReturn(product);
+            LikeModel like = LikeModel.create(1L, 1L);
+            when(likeRepository.findById(new LikeId(1L, 1L)))
                     .thenReturn(Optional.of(like));
 
-            likeService.removeLike("user-1", "product-1");
+            likeService.removeLike(1L, 1L);
 
+            verify(productService).findByIdWithLock(1L);
             verify(likeRepository).delete(like);
+            verify(productService).decrementLikeCount(1L);
         }
 
         @Test
         @DisplayName("좋아요하지 않은 상품 취소 시 에러 없이 통과한다 (멱등)")
         void removeLike_NotLiked_ShouldBeIdempotent() {
-            when(likeRepository.findById(new LikeId("user-1", "product-1")))
+            ProductModel product = mock(ProductModel.class);
+            when(productService.findByIdWithLock(1L)).thenReturn(product);
+            when(likeRepository.findById(new LikeId(1L, 1L)))
                     .thenReturn(Optional.empty());
 
-            assertThatCode(() -> likeService.removeLike("user-1", "product-1"))
+            assertThatCode(() -> likeService.removeLike(1L, 1L))
                     .doesNotThrowAnyException();
             verify(likeRepository, never()).delete(any());
+            verify(productService, never()).decrementLikeCount(anyLong());
         }
     }
 
@@ -113,13 +110,13 @@ void removeLike_NotLiked_ShouldBeIdempotent() {
     class QueryTests {
 
         @Test
-        @DisplayName("사용자의 좋아요 목록이 LikeInfo 리스트로 반환된다")
+        @DisplayName("사용자의 좋아요 목록이 LikeModel 리스트로 반환된다")
         void getMyLikes_ShouldReturnLikeListForUser() {
-            LikeModel like1 = LikeModel.create("user-1", "product-1");
-            LikeModel like2 = LikeModel.create("user-1", "product-2");
-            when(likeRepository.findAllByUserId("user-1")).thenReturn(List.of(like1, like2));
+            LikeModel like1 = LikeModel.create(1L, 1L);
+            LikeModel like2 = LikeModel.create(1L, 2L);
+            when(likeRepository.findAllByUserId(1L)).thenReturn(List.of(like1, like2));
 
-            List<LikeModel> result = likeService.getMyLikes("user-1");
+            List<LikeModel> result = likeService.getMyLikes(1L);
 
             assertThat(result).hasSize(2);
         }
@@ -127,9 +124,9 @@ void getMyLikes_ShouldReturnLikeListForUser() {
         @Test
         @DisplayName("좋아요 카운트가 올바르게 반환된다")
         void countByProductId_ShouldReturnCount() {
-            when(likeRepository.countByProductId("product-1")).thenReturn(42L);
+            when(likeRepository.countByProductId(1L)).thenReturn(42L);
 
-            long result = likeService.countByProductId("product-1");
+            long result = likeService.countByProductId(1L);
 
             assertThat(result).isEqualTo(42L);
         }
@@ -137,20 +134,15 @@ void countByProductId_ShouldReturnCount() {
         @Test
         @DisplayName("여러 상품의 좋아요 수가 배치로 올바르게 반환된다")
         void countByProductIds_ShouldReturnBatchCounts() {
-            List<String> productIds = List.of("product-1", "product-2");
+            List<Long> productIds = List.of(1L, 2L);
             when(likeRepository.countByProductIds(productIds))
-                    .thenReturn(Map.of("product-1", 5L, "product-2", 3L));
+                    .thenReturn(Map.of(1L, 5L, 2L, 3L));
 
-            Map<String, Long> result = likeService.countByProductIds(productIds);
+            Map<Long, Long> result = likeService.countByProductIds(productIds);
 
             assertThat(result).hasSize(2);
-            assertThat(result.get("product-1")).isEqualTo(5L);
-            assertThat(result.get("product-2")).isEqualTo(3L);
+            assertThat(result.get(1L)).isEqualTo(5L);
+            assertThat(result.get(2L)).isEqualTo(3L);
         }
     }
-
-    private ProductModel createTestProduct() {
-        return ProductModel.create("테스트상품", "brand-id", BigDecimal.valueOf(10000),
-                "설명", null, null, null, null, null, null);
-    }
 }
diff --git a/apps/commerce-api/src/test/java/com/loopers/domain/order/OrderCartRestoreIdempotencyTest.java b/apps/commerce-api/src/test/java/com/loopers/domain/order/OrderCartRestoreIdempotencyTest.java
index 0d937325b..928e2a97d 100644
--- a/apps/commerce-api/src/test/java/com/loopers/domain/order/OrderCartRestoreIdempotencyTest.java
+++ b/apps/commerce-api/src/test/java/com/loopers/domain/order/OrderCartRestoreIdempotencyTest.java
@@ -1,12 +1,12 @@
 package com.loopers.domain.order;
 
-import com.loopers.application.brand.BrandAppService;
-import com.loopers.application.brand.BrandInfo;
 import com.loopers.application.order.OrderFacade;
 import com.loopers.application.order.OrderInfo;
 import com.loopers.application.product.ProductCreateCommand;
 import com.loopers.application.product.ProductFacade;
 import com.loopers.application.product.ProductInfo;
+import com.loopers.domain.brand.BrandModel;
+import com.loopers.domain.brand.BrandService;
 import com.loopers.domain.cart.CartItemId;
 import com.loopers.domain.cart.CartItemModel;
 import com.loopers.domain.cart.CartService;
@@ -34,25 +34,23 @@
 class OrderCartRestoreIdempotencyTest {
 
     @Autowired UserService userService;
-    @Autowired BrandAppService brandAppService;
+    @Autowired BrandService brandService;
     @Autowired ProductFacade productFacade;
     @Autowired OrderFacade orderFacade;
     @Autowired CartService cartService;
     @Autowired CartItemJpaRepository cartItemJpaRepository;
 
-    private String userId;
-    private String loginId;
-    private String loginPw;
-    private String productId;
+    private Long userId;
+    private Long productId;
 
     @BeforeEach
     void setUp() {
-        loginId = "testuser01";
-        loginPw = "Test1234!@#";
+        String loginId = "testuser01";
+        String loginPw = "Test1234!@#";
         var user = userService.register(new UserRegisterCommand(loginId, loginPw, "홍길동", "19900101", "test@example.com", "서울"));
         userId = user.getUserId();
 
-        BrandInfo brand = brandAppService.createBrand("테스트브랜드", "설명", "서울");
+        BrandModel brand = brandService.createBrand("테스트브랜드", "설명", "서울");
         ProductInfo product = productFacade.createProduct(
                 new ProductCreateCommand("테스트상품", brand.getBrandId(), BigDecimal.valueOf(10000), "설명", 100));
         productId = product.getProductId();
@@ -63,17 +61,17 @@ void setUp() {
     void cancelDirectOrder_Twice_ShouldNotDuplicateCartItems() {
         // DIRECT 주문 생성
         List<OrderItemCommand> items = List.of(new OrderItemCommand(productId, 2));
-        OrderInfo order = orderFacade.createDirectOrder(loginId, loginPw, items);
+        OrderInfo order = orderFacade.createDirectOrder(userId, items, null);
 
         // 1회 취소 (복원 수행)
-        orderFacade.cancelOrder(loginId, loginPw, order.getOrderId());
+        orderFacade.cancelOrder(userId, order.getOrderId());
 
         Optional<CartItemModel> afterFirst = cartItemJpaRepository.findById(new CartItemId(userId, productId));
         assertThat(afterFirst).isPresent();
         int qtyAfterFirst = afterFirst.get().getQuantity();
 
         // 2회 취소 시도 (이미 취소됨 — 멱등)
-        orderFacade.cancelOrder(loginId, loginPw, order.getOrderId());
+        orderFacade.cancelOrder(userId, order.getOrderId());
 
         Optional<CartItemModel> afterSecond = cartItemJpaRepository.findById(new CartItemId(userId, productId));
         assertThat(afterSecond).isPresent();
@@ -88,10 +86,10 @@ void cancelDirectOrder_WhenCartItemAlreadyExists_ShouldMergeQuantity() {
 
         // DIRECT 주문 (qty=2)
         List<OrderItemCommand> items = List.of(new OrderItemCommand(productId, 2));
-        OrderInfo order = orderFacade.createDirectOrder(loginId, loginPw, items);
+        OrderInfo order = orderFacade.createDirectOrder(userId, items, null);
 
         // 취소 → 복원 시 병합
-        orderFacade.cancelOrder(loginId, loginPw, order.getOrderId());
+        orderFacade.cancelOrder(userId, order.getOrderId());
 
         Optional<CartItemModel> cartItem = cartItemJpaRepository.findById(new CartItemId(userId, productId));
         assertThat(cartItem).isPresent();
@@ -103,10 +101,10 @@ void cancelDirectOrder_WhenCartItemAlreadyExists_ShouldMergeQuantity() {
     void expireDirectOrder_AfterManualCancel_ShouldNotRestoreAgain() {
         // DIRECT 주문
         List<OrderItemCommand> items = List.of(new OrderItemCommand(productId, 2));
-        OrderInfo order = orderFacade.createDirectOrder(loginId, loginPw, items);
+        OrderInfo order = orderFacade.createDirectOrder(userId, items, null);
 
         // 수동 취소 (복원 완료)
-        orderFacade.cancelOrder(loginId, loginPw, order.getOrderId());
+        orderFacade.cancelOrder(userId, order.getOrderId());
 
         Optional<CartItemModel> afterCancel = cartItemJpaRepository.findById(new CartItemId(userId, productId));
         assertThat(afterCancel).isPresent();
diff --git a/apps/commerce-api/src/test/java/com/loopers/domain/order/OrderCartRestoreModelTest.java b/apps/commerce-api/src/test/java/com/loopers/domain/order/OrderCartRestoreModelTest.java
index c6f80afaf..f677ff504 100644
--- a/apps/commerce-api/src/test/java/com/loopers/domain/order/OrderCartRestoreModelTest.java
+++ b/apps/commerce-api/src/test/java/com/loopers/domain/order/OrderCartRestoreModelTest.java
@@ -14,12 +14,12 @@ class OrderCartRestoreModelTest {
     @DisplayName("유효한 입력으로 생성 성공")
     void create_WithValidInputs_ShouldSuccess() {
         OrderCartRestoreModel restore = OrderCartRestoreModel.create(
-                "order-001", "user-001",
+                1L, 1L,
                 RestoreReason.USER_CANCELLED, RestoreTriggerSource.CANCEL_API
         );
 
-        assertThat(restore.getOrderId()).isEqualTo("order-001");
-        assertThat(restore.getUserId()).isEqualTo("user-001");
+        assertThat(restore.getOrderId()).isEqualTo(1L);
+        assertThat(restore.getUserId()).isEqualTo(1L);
         assertThat(restore.getReason()).isEqualTo(RestoreReason.USER_CANCELLED);
         assertThat(restore.getTriggerSource()).isEqualTo(RestoreTriggerSource.CANCEL_API);
     }
@@ -28,7 +28,7 @@ void create_WithValidInputs_ShouldSuccess() {
     @DisplayName("restoredAt은 @PrePersist에서 설정된다")
     void create_ShouldSetRestoredAt() {
         OrderCartRestoreModel restore = OrderCartRestoreModel.create(
-                "order-001", "user-001",
+                1L, 1L,
                 RestoreReason.EXPIRED, RestoreTriggerSource.EXPIRE_JOB
         );
         // restoredAt은 @PrePersist에서 설정되므로 JPA 없이는 null
diff --git a/apps/commerce-api/src/test/java/com/loopers/domain/order/OrderItemModelTest.java b/apps/commerce-api/src/test/java/com/loopers/domain/order/OrderItemModelTest.java
index b87c95ad8..b3566e2cd 100644
--- a/apps/commerce-api/src/test/java/com/loopers/domain/order/OrderItemModelTest.java
+++ b/apps/commerce-api/src/test/java/com/loopers/domain/order/OrderItemModelTest.java
@@ -15,14 +15,14 @@ class OrderItemModelTest {
     @DisplayName("유효한 입력으로 생성 및 스냅샷 캡처")
     void create_WithValidInputs_ShouldCaptureSnapshot() {
         OrderItemModel item = OrderItemModel.create(
-                "order-001", 1, "user-001", "product-001", 2,
+                1L, 1, 1L, 1L, 2,
                 "테스트 상품", BigDecimal.valueOf(10000),
                 "brand-001", "루퍼스", "img.jpg"
         );
 
-        assertThat(item.getOrderId()).isEqualTo("order-001");
+        assertThat(item.getOrderId()).isEqualTo(1L);
         assertThat(item.getOrderItemSeq()).isEqualTo(1);
-        assertThat(item.getProductId()).isEqualTo("product-001");
+        assertThat(item.getProductId()).isEqualTo(1L);
         assertThat(item.getQuantity()).isEqualTo(2);
         assertThat(item.getSnapshotProductName()).isEqualTo("테스트 상품");
         assertThat(item.getSnapshotUnitPrice()).isEqualByComparingTo(BigDecimal.valueOf(10000));
@@ -35,7 +35,7 @@ void create_WithValidInputs_ShouldCaptureSnapshot() {
     @DisplayName("수량이 0이면 CoreException 발생")
     void create_WithZeroQuantity_ShouldThrow() {
         assertThatThrownBy(() -> OrderItemModel.create(
-                "order-001", 1, "user-001", "product-001", 0,
+                1L, 1, 1L, 1L, 0,
                 "상품", BigDecimal.valueOf(10000), "b-001", "브랜드", "img.jpg"
         )).isInstanceOf(CoreException.class);
     }
@@ -44,7 +44,7 @@ void create_WithZeroQuantity_ShouldThrow() {
     @DisplayName("getSubtotal = unitPrice * quantity")
     void getSubtotal_ShouldReturn_unitPrice_times_quantity() {
         OrderItemModel item = OrderItemModel.create(
-                "order-001", 1, "user-001", "product-001", 3,
+                1L, 1, 1L, 1L, 3,
                 "상품", BigDecimal.valueOf(10000), "b-001", "브랜드", "img.jpg"
         );
 
diff --git a/apps/commerce-api/src/test/java/com/loopers/domain/order/OrderModelTest.java b/apps/commerce-api/src/test/java/com/loopers/domain/order/OrderModelTest.java
index d67deb129..33fd712ad 100644
--- a/apps/commerce-api/src/test/java/com/loopers/domain/order/OrderModelTest.java
+++ b/apps/commerce-api/src/test/java/com/loopers/domain/order/OrderModelTest.java
@@ -24,7 +24,7 @@ class CreateTests {
         void create_WithValidInputs_ShouldSuccess() {
             OrderModel order = createTestOrder();
 
-            assertThat(order.getUserId()).isEqualTo("user-001");
+            assertThat(order.getUserId()).isEqualTo(1L);
             assertThat(order.getOrderType()).isEqualTo(OrderType.DIRECT);
             assertThat(order.getTotalAmount()).isEqualByComparingTo(BigDecimal.valueOf(30000));
         }
@@ -168,6 +168,6 @@ void isExpired_WhenExpiresAtFuture_False() {
     // === Helper ===
 
     private OrderModel createTestOrder() {
-        return OrderModel.create("user-001", OrderType.DIRECT, BigDecimal.valueOf(30000));
+        return OrderModel.create(1L, OrderType.DIRECT, BigDecimal.valueOf(30000));
     }
 }
diff --git a/apps/commerce-api/src/test/java/com/loopers/domain/order/OrderServiceTest.java b/apps/commerce-api/src/test/java/com/loopers/domain/order/OrderServiceTest.java
index e94198787..bbed0b311 100644
--- a/apps/commerce-api/src/test/java/com/loopers/domain/order/OrderServiceTest.java
+++ b/apps/commerce-api/src/test/java/com/loopers/domain/order/OrderServiceTest.java
@@ -21,6 +21,7 @@
 import static org.assertj.core.api.Assertions.*;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.ArgumentMatchers.anyList;
+import static org.mockito.ArgumentMatchers.eq;
 import static org.mockito.Mockito.*;
 
 @ExtendWith(MockitoExtension.class)
@@ -43,7 +44,7 @@ class ValidateAndPrepareTests {
         @Test
         @DisplayName("빈 항목으로 주문 시 ORDER_ITEM_EMPTY 예외가 발생한다")
         void validateAndPrepare_EmptyItems_ShouldThrow() {
-            assertThatThrownBy(() -> orderService.validateAndPrepare("user-1", List.of()))
+            assertThatThrownBy(() -> orderService.validateAndPrepare(1L, List.of()))
                     .isInstanceOf(CoreException.class)
                     .satisfies(ex -> assertThat(((CoreException) ex).getErrorType())
                             .isEqualTo(ErrorType.ORDER_ITEM_EMPTY));
@@ -52,7 +53,7 @@ void validateAndPrepare_EmptyItems_ShouldThrow() {
         @Test
         @DisplayName("null 항목으로 주문 시 ORDER_ITEM_EMPTY 예외가 발생한다")
         void validateAndPrepare_NullItems_ShouldThrow() {
-            assertThatThrownBy(() -> orderService.validateAndPrepare("user-1", null))
+            assertThatThrownBy(() -> orderService.validateAndPrepare(1L, null))
                     .isInstanceOf(CoreException.class)
                     .satisfies(ex -> assertThat(((CoreException) ex).getErrorType())
                             .isEqualTo(ErrorType.ORDER_ITEM_EMPTY));
@@ -61,10 +62,10 @@ void validateAndPrepare_NullItems_ShouldThrow() {
         @Test
         @DisplayName("PENDING 주문 3건 이상일 때 ORDER_PENDING_LIMIT_EXCEEDED 예외가 발생한다")
         void validateAndPrepare_ExceedPendingLimit_ShouldThrow() {
-            when(orderRepository.countByUserIdAndStatus("user-1", OrderStatus.PENDING_PAYMENT)).thenReturn(3L);
+            when(orderRepository.countByUserIdAndStatus(1L, OrderStatus.PENDING_PAYMENT)).thenReturn(3L);
 
-            assertThatThrownBy(() -> orderService.validateAndPrepare("user-1",
-                    List.of(new OrderItemCommand("product-1", 1))))
+            assertThatThrownBy(() -> orderService.validateAndPrepare(1L,
+                    List.of(new OrderItemCommand(1L, 1))))
                     .isInstanceOf(CoreException.class)
                     .satisfies(ex -> assertThat(((CoreException) ex).getErrorType())
                             .isEqualTo(ErrorType.ORDER_PENDING_LIMIT_EXCEEDED));
@@ -73,11 +74,11 @@ void validateAndPrepare_ExceedPendingLimit_ShouldThrow() {
         @Test
         @DisplayName("동일 productId가 중복 전달되면 수량을 합산한다")
         void validateAndPrepare_DuplicateProductId_ShouldMergeQuantity() {
-            when(orderRepository.countByUserIdAndStatus("user-1", OrderStatus.PENDING_PAYMENT)).thenReturn(0L);
+            when(orderRepository.countByUserIdAndStatus(1L, OrderStatus.PENDING_PAYMENT)).thenReturn(0L);
 
-            List<OrderItemCommand> result = orderService.validateAndPrepare("user-1", List.of(
-                    new OrderItemCommand("product-1", 2),
-                    new OrderItemCommand("product-1", 3)));
+            List<OrderItemCommand> result = orderService.validateAndPrepare(1L, List.of(
+                    new OrderItemCommand(1L, 2),
+                    new OrderItemCommand(1L, 3)));
 
             assertThat(result).hasSize(1);
             assertThat(result.get(0).quantity()).isEqualTo(5);
@@ -86,14 +87,14 @@ void validateAndPrepare_DuplicateProductId_ShouldMergeQuantity() {
         @Test
         @DisplayName("결과가 productId 오름차순으로 정렬된다")
         void validateAndPrepare_ShouldSortByProductIdAsc() {
-            when(orderRepository.countByUserIdAndStatus("user-1", OrderStatus.PENDING_PAYMENT)).thenReturn(0L);
+            when(orderRepository.countByUserIdAndStatus(1L, OrderStatus.PENDING_PAYMENT)).thenReturn(0L);
 
-            List<OrderItemCommand> result = orderService.validateAndPrepare("user-1", List.of(
-                    new OrderItemCommand("zzz-product", 1),
-                    new OrderItemCommand("aaa-product", 1)));
+            List<OrderItemCommand> result = orderService.validateAndPrepare(1L, List.of(
+                    new OrderItemCommand(3L, 1),
+                    new OrderItemCommand(1L, 1)));
 
             assertThat(result).extracting(OrderItemCommand::productId)
-                    .containsExactly("aaa-product", "zzz-product");
+                    .containsExactly(1L, 3L);
         }
     }
 
@@ -112,10 +113,11 @@ void createOrder_ShouldSaveOrderAndItems_ReturnOrderModel() {
                     .thenAnswer(invocation -> invocation.getArgument(0));
 
             List<OrderItemSnapshot> snapshots = List.of(
-                    new OrderItemSnapshot("product-1", 2, "테스트상품",
-                            BigDecimal.valueOf(10000), "brand-id", "테스트브랜드", null));
+                    new OrderItemSnapshot(1L, 2, "테스트상품",
+                            BigDecimal.valueOf(10000), "brand-id", "테스트브랜드", null,
+                            BigDecimal.valueOf(20000), BigDecimal.ZERO, BigDecimal.valueOf(20000)));
 
-            OrderModel result = orderService.createOrder("user-1", OrderType.DIRECT,
+            OrderModel result = orderService.createOrder(1L, OrderType.DIRECT,
                     BigDecimal.valueOf(20000), snapshots);
 
             assertThat(result).isNotNull();
@@ -131,10 +133,11 @@ void createOrder_ShouldSetOrderType() {
             when(orderItemRepository.saveAll(anyList()))
                     .thenAnswer(invocation -> invocation.getArgument(0));
 
-            orderService.createOrder("user-1", OrderType.CART,
+            orderService.createOrder(1L, OrderType.CART,
                     BigDecimal.valueOf(10000), List.of(
-                            new OrderItemSnapshot("product-1", 1, "상품",
-                                    BigDecimal.valueOf(10000), "brand-id", "브랜드", null)));
+                            new OrderItemSnapshot(1L, 1, "상품",
+                                    BigDecimal.valueOf(10000), "brand-id", "브랜드", null,
+                                    BigDecimal.valueOf(10000), BigDecimal.ZERO, BigDecimal.valueOf(10000))));
 
             ArgumentCaptor<OrderModel> captor = ArgumentCaptor.forClass(OrderModel.class);
             verify(orderRepository).save(captor.capture());
@@ -149,10 +152,11 @@ void createOrder_ShouldSetTotalAmount() {
             when(orderItemRepository.saveAll(anyList()))
                     .thenAnswer(invocation -> invocation.getArgument(0));
 
-            orderService.createOrder("user-1", OrderType.DIRECT,
+            orderService.createOrder(1L, OrderType.DIRECT,
                     BigDecimal.valueOf(30000), List.of(
-                            new OrderItemSnapshot("product-1", 3, "상품",
-                                    BigDecimal.valueOf(10000), "brand-id", "브랜드", null)));
+                            new OrderItemSnapshot(1L, 3, "상품",
+                                    BigDecimal.valueOf(10000), "brand-id", "브랜드", null,
+                                    BigDecimal.valueOf(30000), BigDecimal.ZERO, BigDecimal.valueOf(30000))));
 
             ArgumentCaptor<OrderModel> captor = ArgumentCaptor.forClass(OrderModel.class);
             verify(orderRepository).save(captor.capture());
@@ -170,25 +174,25 @@ class CancelOrderTests {
         @Test
         @DisplayName("CAS 상태 전이 성공 시 주문 엔티티를 반환한다")
         void cancelOrder_ShouldReturnOrder_WhenCASSucceeds() {
-            OrderModel order = OrderModel.create("user-1", OrderType.DIRECT, BigDecimal.valueOf(10000));
-            when(orderRepository.findByIdAndUserId("order-1", "user-1"))
+            OrderModel order = OrderModel.create(1L, OrderType.DIRECT, BigDecimal.valueOf(10000));
+            when(orderRepository.findByIdAndUserId(1L, 1L))
                     .thenReturn(Optional.of(order));
-            when(orderRepository.casUpdateStatus("order-1", OrderStatus.PENDING_PAYMENT, OrderStatus.CANCELLED))
+            when(orderRepository.casUpdateStatus(1L, OrderStatus.PENDING_PAYMENT, OrderStatus.CANCELLED))
                     .thenReturn(1);
 
-            Optional<OrderModel> result = orderService.cancelOrder("user-1", "order-1");
+            Optional<OrderModel> result = orderService.cancelOrder(1L, 1L);
 
             assertThat(result).isPresent();
-            verify(orderRepository).casUpdateStatus("order-1", OrderStatus.PENDING_PAYMENT, OrderStatus.CANCELLED);
+            verify(orderRepository).casUpdateStatus(1L, OrderStatus.PENDING_PAYMENT, OrderStatus.CANCELLED);
         }
 
         @Test
         @DisplayName("다른 사용자의 주문 취소 시 예외가 발생한다")
         void cancelOrder_WhenNotOwner_ShouldThrow() {
-            when(orderRepository.findByIdAndUserId("order-1", "other-user"))
+            when(orderRepository.findByIdAndUserId(1L, 2L))
                     .thenReturn(Optional.empty());
 
-            assertThatThrownBy(() -> orderService.cancelOrder("other-user", "order-1"))
+            assertThatThrownBy(() -> orderService.cancelOrder(2L, 1L))
                     .isInstanceOf(CoreException.class)
                     .satisfies(ex -> assertThat(((CoreException) ex).getErrorType())
                             .isEqualTo(ErrorType.ORDER_NOT_FOUND));
@@ -197,16 +201,16 @@ void cancelOrder_WhenNotOwner_ShouldThrow() {
         @Test
         @DisplayName("이미 CANCELLED인 주문 취소 시 빈 Optional을 반환한다 (멱등)")
         void cancelOrder_WhenAlreadyCancelled_ShouldReturnEmpty() {
-            OrderModel order = OrderModel.create("user-1", OrderType.DIRECT, BigDecimal.valueOf(10000));
-            when(orderRepository.findByIdAndUserId("order-1", "user-1"))
+            OrderModel order = OrderModel.create(1L, OrderType.DIRECT, BigDecimal.valueOf(10000));
+            when(orderRepository.findByIdAndUserId(1L, 1L))
                     .thenReturn(Optional.of(order));
-            when(orderRepository.casUpdateStatus("order-1", OrderStatus.PENDING_PAYMENT, OrderStatus.CANCELLED))
+            when(orderRepository.casUpdateStatus(1L, OrderStatus.PENDING_PAYMENT, OrderStatus.CANCELLED))
                     .thenReturn(0);
-            OrderModel cancelledOrder = OrderModel.create("user-1", OrderType.DIRECT, BigDecimal.valueOf(10000));
+            OrderModel cancelledOrder = OrderModel.create(1L, OrderType.DIRECT, BigDecimal.valueOf(10000));
             cancelledOrder.cancel();
-            when(orderRepository.findById("order-1")).thenReturn(Optional.of(cancelledOrder));
+            when(orderRepository.findById(1L)).thenReturn(Optional.of(cancelledOrder));
 
-            Optional<OrderModel> result = orderService.cancelOrder("user-1", "order-1");
+            Optional<OrderModel> result = orderService.cancelOrder(1L, 1L);
 
             assertThat(result).isEmpty();
         }
@@ -214,16 +218,16 @@ void cancelOrder_WhenAlreadyCancelled_ShouldReturnEmpty() {
         @Test
         @DisplayName("EXPIRED 상태인 주문 취소 시 ORDER_NOT_CANCELLABLE 예외가 발생한다")
         void cancelOrder_WhenExpired_ShouldThrow_ORDER_NOT_CANCELLABLE() {
-            OrderModel order = OrderModel.create("user-1", OrderType.DIRECT, BigDecimal.valueOf(10000));
-            when(orderRepository.findByIdAndUserId("order-1", "user-1"))
+            OrderModel order = OrderModel.create(1L, OrderType.DIRECT, BigDecimal.valueOf(10000));
+            when(orderRepository.findByIdAndUserId(1L, 1L))
                     .thenReturn(Optional.of(order));
-            when(orderRepository.casUpdateStatus("order-1", OrderStatus.PENDING_PAYMENT, OrderStatus.CANCELLED))
+            when(orderRepository.casUpdateStatus(1L, OrderStatus.PENDING_PAYMENT, OrderStatus.CANCELLED))
                     .thenReturn(0);
-            OrderModel expiredOrder = OrderModel.create("user-1", OrderType.DIRECT, BigDecimal.valueOf(10000));
+            OrderModel expiredOrder = OrderModel.create(1L, OrderType.DIRECT, BigDecimal.valueOf(10000));
             expiredOrder.expire();
-            when(orderRepository.findById("order-1")).thenReturn(Optional.of(expiredOrder));
+            when(orderRepository.findById(1L)).thenReturn(Optional.of(expiredOrder));
 
-            assertThatThrownBy(() -> orderService.cancelOrder("user-1", "order-1"))
+            assertThatThrownBy(() -> orderService.cancelOrder(1L, 1L))
                     .isInstanceOf(CoreException.class)
                     .satisfies(ex -> assertThat(((CoreException) ex).getErrorType())
                             .isEqualTo(ErrorType.ORDER_NOT_CANCELLABLE));
@@ -239,24 +243,24 @@ class ExpireOrderTests {
         @Test
         @DisplayName("CAS 상태 전이 성공 시 주문 엔티티를 반환한다")
         void expireOrder_ShouldReturnOrder_WhenCASSucceeds() {
-            when(orderRepository.casUpdateStatus("order-1", OrderStatus.PENDING_PAYMENT, OrderStatus.EXPIRED))
+            when(orderRepository.casUpdateStatus(1L, OrderStatus.PENDING_PAYMENT, OrderStatus.EXPIRED))
                     .thenReturn(1);
-            OrderModel order = OrderModel.create("user-1", OrderType.CART, BigDecimal.valueOf(10000));
-            when(orderRepository.findById("order-1")).thenReturn(Optional.of(order));
+            OrderModel order = OrderModel.create(1L, OrderType.CART, BigDecimal.valueOf(10000));
+            when(orderRepository.findById(1L)).thenReturn(Optional.of(order));
 
-            Optional<OrderModel> result = orderService.expireOrder("order-1");
+            Optional<OrderModel> result = orderService.expireOrder(1L);
 
             assertThat(result).isPresent();
-            verify(orderRepository).casUpdateStatus("order-1", OrderStatus.PENDING_PAYMENT, OrderStatus.EXPIRED);
+            verify(orderRepository).casUpdateStatus(1L, OrderStatus.PENDING_PAYMENT, OrderStatus.EXPIRED);
         }
 
         @Test
         @DisplayName("CAS 실패 시 빈 Optional을 반환한다 (멱등)")
         void expireOrder_AlreadyExpiredOrCancelled_ShouldReturnEmpty() {
-            when(orderRepository.casUpdateStatus("order-1", OrderStatus.PENDING_PAYMENT, OrderStatus.EXPIRED))
+            when(orderRepository.casUpdateStatus(1L, OrderStatus.PENDING_PAYMENT, OrderStatus.EXPIRED))
                     .thenReturn(0);
 
-            Optional<OrderModel> result = orderService.expireOrder("order-1");
+            Optional<OrderModel> result = orderService.expireOrder(1L);
 
             assertThat(result).isEmpty();
         }
@@ -271,24 +275,24 @@ class QueryTests {
         @Test
         @DisplayName("본인 주문 조회 성공")
         void findByIdAndUserId_Existing_ShouldReturn() {
-            OrderModel order = OrderModel.create("user-1", OrderType.DIRECT, BigDecimal.valueOf(10000));
-            when(orderRepository.findByIdAndUserId("order-1", "user-1"))
+            OrderModel order = OrderModel.create(1L, OrderType.DIRECT, BigDecimal.valueOf(10000));
+            when(orderRepository.findByIdAndUserId(1L, 1L))
                     .thenReturn(Optional.of(order));
 
-            OrderModel result = orderService.findByIdAndUserId("order-1", "user-1");
+            OrderModel result = orderService.findByIdAndUserId(1L, 1L);
 
             assertThat(result).isNotNull();
-            assertThat(result.getUserId()).isEqualTo("user-1");
+            assertThat(result.getUserId()).isEqualTo(1L);
         }
 
         @Test
         @DisplayName("내 주문 목록 조회 성공")
         void findAllByUserId_ShouldReturnOrders() {
-            OrderModel order = OrderModel.create("user-1", OrderType.DIRECT, BigDecimal.valueOf(10000));
-            when(orderRepository.findAllByUserIdAndPeriod(eq("user-1"), any(), any()))
+            OrderModel order = OrderModel.create(1L, OrderType.DIRECT, BigDecimal.valueOf(10000));
+            when(orderRepository.findAllByUserIdAndPeriod(eq(1L), any(), any()))
                     .thenReturn(List.of(order));
 
-            List<OrderModel> result = orderService.findAllByUserId("user-1",
+            List<OrderModel> result = orderService.findAllByUserId(1L,
                     LocalDateTime.now().minusDays(30), LocalDateTime.now());
 
             assertThat(result).hasSize(1);
@@ -297,14 +301,14 @@ void findAllByUserId_ShouldReturnOrders() {
         @Test
         @DisplayName("주문 항목 조회 성공")
         void findOrderItems_ShouldReturnItems() {
-            OrderItemModel item = OrderItemModel.create("order-1", 1, "user-1", "product-1", 2,
+            OrderItemModel item = OrderItemModel.create(1L, 1, 1L, 1L, 2,
                     "상품명", BigDecimal.valueOf(10000), "brand-id", "브랜드", null);
-            when(orderItemRepository.findAllByOrderId("order-1")).thenReturn(List.of(item));
+            when(orderItemRepository.findAllByOrderId(1L)).thenReturn(List.of(item));
 
-            List<OrderItemModel> result = orderService.findOrderItems("order-1");
+            List<OrderItemModel> result = orderService.findOrderItems(1L);
 
             assertThat(result).hasSize(1);
-            assertThat(result.get(0).getProductId()).isEqualTo("product-1");
+            assertThat(result.get(0).getProductId()).isEqualTo(1L);
         }
     }
 }
diff --git a/apps/commerce-api/src/test/java/com/loopers/domain/product/ProductModelTest.java b/apps/commerce-api/src/test/java/com/loopers/domain/product/ProductModelTest.java
index 9ea77a761..53e963113 100644
--- a/apps/commerce-api/src/test/java/com/loopers/domain/product/ProductModelTest.java
+++ b/apps/commerce-api/src/test/java/com/loopers/domain/product/ProductModelTest.java
@@ -25,7 +25,7 @@ void create_WithValidInputs_ShouldSuccess() {
             ProductModel product = createTestProduct();
 
             assertThat(product.getProductName()).isEqualTo("테스트 상품");
-            assertThat(product.getBrandId()).isEqualTo("brand-001");
+            assertThat(product.getBrandId()).isEqualTo(1L);
             assertThat(product.getPrice()).isEqualByComparingTo(BigDecimal.valueOf(10000));
         }
 
@@ -33,7 +33,7 @@ void create_WithValidInputs_ShouldSuccess() {
         @DisplayName("productName이 null이면 CoreException 발생")
         void create_WithNullProductName_ShouldThrow() {
             assertThatThrownBy(() -> ProductModel.create(
-                    null, "brand-001", BigDecimal.valueOf(10000),
+                    null, 1L, BigDecimal.valueOf(10000),
                     "설명", "카테고리", "블랙", "M", "옵션", "img.jpg", null
             )).isInstanceOf(CoreException.class);
         }
@@ -51,7 +51,7 @@ void create_WithNullBrandId_ShouldThrow() {
         @DisplayName("price가 음수이면 CoreException 발생")
         void create_WithNegativePrice_ShouldThrow() {
             assertThatThrownBy(() -> ProductModel.create(
-                    "상품", "brand-001", BigDecimal.valueOf(-1),
+                    "상품", 1L, BigDecimal.valueOf(-1),
                     "설명", "카테고리", "블랙", "M", "옵션", "img.jpg", null
             )).isInstanceOf(CoreException.class);
         }
@@ -60,7 +60,7 @@ void create_WithNegativePrice_ShouldThrow() {
         @DisplayName("price가 0이면 CoreException 발생")
         void create_WithZeroPrice_ShouldThrow() {
             assertThatThrownBy(() -> ProductModel.create(
-                    "상품", "brand-001", BigDecimal.ZERO,
+                    "상품", 1L, BigDecimal.ZERO,
                     "설명", "카테고리", "블랙", "M", "옵션", "img.jpg", null
             )).isInstanceOf(CoreException.class);
         }
@@ -188,7 +188,7 @@ void create_ShouldExtendBaseStringIdEntity() {
 
     private ProductModel createTestProduct() {
         return ProductModel.create(
-                "테스트 상품", "brand-001", BigDecimal.valueOf(10000),
+                "테스트 상품", 1L, BigDecimal.valueOf(10000),
                 "상품 설명", "카테고리", "블랙", "M", "옵션", "img.jpg", null
         );
     }
diff --git a/apps/commerce-api/src/test/java/com/loopers/domain/product/ProductRevisionModelTest.java b/apps/commerce-api/src/test/java/com/loopers/domain/product/ProductRevisionModelTest.java
index 7d1cd8133..0a1661bfa 100644
--- a/apps/commerce-api/src/test/java/com/loopers/domain/product/ProductRevisionModelTest.java
+++ b/apps/commerce-api/src/test/java/com/loopers/domain/product/ProductRevisionModelTest.java
@@ -13,12 +13,12 @@ class ProductRevisionModelTest {
     @DisplayName("유효한 입력으로 생성 성공")
     void create_WithValidInputs_ShouldSuccess() {
         ProductRevisionModel revision = ProductRevisionModel.create(
-                "product-001", 1L, ProductRevisionAction.UPDATE,
+                1L, 1L, ProductRevisionAction.UPDATE,
                 "admin", "가격 변경",
                 "{\"price\": 10000}", "{\"price\": 20000}"
         );
 
-        assertThat(revision.getProductId()).isEqualTo("product-001");
+        assertThat(revision.getProductId()).isEqualTo(1L);
         assertThat(revision.getRevisionSeq()).isEqualTo(1L);
         assertThat(revision.getAction()).isEqualTo(ProductRevisionAction.UPDATE);
         assertThat(revision.getChangedBy()).isEqualTo("admin");
@@ -31,7 +31,7 @@ void create_WithValidInputs_ShouldSuccess() {
     @DisplayName("CREATE action 시 beforeSnapshot은 null이다")
     void create_WithCreateAction_BeforeSnapshotShouldBeNull() {
         ProductRevisionModel revision = ProductRevisionModel.create(
-                "product-001", 0L, ProductRevisionAction.CREATE,
+                1L, 0L, ProductRevisionAction.CREATE,
                 "admin", "상품 생성",
                 null, "{\"name\": \"상품A\"}"
         );
diff --git a/apps/commerce-api/src/test/java/com/loopers/domain/product/ProductServiceTest.java b/apps/commerce-api/src/test/java/com/loopers/domain/product/ProductServiceTest.java
index 512fd7bdd..e446d1c5c 100644
--- a/apps/commerce-api/src/test/java/com/loopers/domain/product/ProductServiceTest.java
+++ b/apps/commerce-api/src/test/java/com/loopers/domain/product/ProductServiceTest.java
@@ -49,7 +49,7 @@ void createProduct_WithValidInput_ShouldCreateProductAndRevision() {
                     .thenAnswer(invocation -> invocation.getArgument(0));
 
             ProductModel result = productService.createProduct(
-                    "테스트상품", "brand-id", BigDecimal.valueOf(10000), "설명");
+                    "테스트상품", 1L, BigDecimal.valueOf(10000), "설명");
 
             assertThat(result.getProductName()).isEqualTo("테스트상품");
             assertThat(result.getPrice()).isEqualByComparingTo(BigDecimal.valueOf(10000));
@@ -65,7 +65,7 @@ void createProduct_ShouldCreateRevisionWithCREATEAction() {
             when(revisionRepository.save(any(ProductRevisionModel.class)))
                     .thenAnswer(invocation -> invocation.getArgument(0));
 
-            productService.createProduct("상품", "brand-id", BigDecimal.valueOf(5000), "설명");
+            productService.createProduct("상품", 1L, BigDecimal.valueOf(5000), "설명");
 
             ArgumentCaptor<ProductRevisionModel> captor = ArgumentCaptor.forClass(ProductRevisionModel.class);
             verify(revisionRepository).save(captor.capture());
@@ -86,9 +86,9 @@ class FindTests {
         @DisplayName("존재하는 ID로 조회하면 ProductModel을 반환한다")
         void findById_Existing_ShouldReturn() {
             ProductModel product = createTestProduct();
-            when(productRepository.findById("product-id")).thenReturn(Optional.of(product));
+            when(productRepository.findById(1L)).thenReturn(Optional.of(product));
 
-            ProductModel result = productService.findById("product-id");
+            ProductModel result = productService.findById(1L);
 
             assertThat(result.getProductName()).isEqualTo("테스트상품");
         }
@@ -96,9 +96,9 @@ void findById_Existing_ShouldReturn() {
         @Test
         @DisplayName("존재하지 않는 ID 조회 시 PRODUCT_NOT_FOUND 예외가 발생한다")
         void findById_NotFound_ShouldThrow() {
-            when(productRepository.findById("nonexistent")).thenReturn(Optional.empty());
+            when(productRepository.findById(999L)).thenReturn(Optional.empty());
 
-            assertThatThrownBy(() -> productService.findById("nonexistent"))
+            assertThatThrownBy(() -> productService.findById(999L))
                     .isInstanceOf(CoreException.class)
                     .satisfies(ex -> assertThat(((CoreException) ex).getErrorType())
                             .isEqualTo(ErrorType.PRODUCT_NOT_FOUND));
@@ -109,9 +109,9 @@ void findById_NotFound_ShouldThrow() {
         void findOrderableById_WhenNotOrderable_ShouldThrow() {
             ProductModel product = createTestProduct();
             product.changeSaleStatus(ProductSaleStatus.STOPPED);
-            when(productRepository.findById("product-id")).thenReturn(Optional.of(product));
+            when(productRepository.findById(1L)).thenReturn(Optional.of(product));
 
-            assertThatThrownBy(() -> productService.findOrderableById("product-id"))
+            assertThatThrownBy(() -> productService.findOrderableById(1L))
                     .isInstanceOf(CoreException.class)
                     .satisfies(ex -> assertThat(((CoreException) ex).getErrorType())
                             .isEqualTo(ErrorType.PRODUCT_NOT_ORDERABLE));
@@ -144,12 +144,12 @@ void findAllForCustomer_WithKeyword_ShouldFilter() {
         @Test
         @DisplayName("brandId 필터가 올바르게 동작한다")
         void findAllForCustomer_WithBrandId_ShouldFilter() {
-            when(productRepository.findAllForCustomer(null, "brand-id"))
+            when(productRepository.findAllForCustomer(null, 1L))
                     .thenReturn(List.of());
 
-            productService.findAllForCustomer(null, "brand-id");
+            productService.findAllForCustomer(null, 1L);
 
-            verify(productRepository).findAllForCustomer(null, "brand-id");
+            verify(productRepository).findAllForCustomer(null, 1L);
         }
     }
 
@@ -163,12 +163,12 @@ class UpdateTests {
         @DisplayName("수정 후 UPDATE 이력이 기록되고 before/after 스냅샷이 포함된다")
         void updateProduct_ShouldUpdateAndCreateRevision() {
             ProductModel product = createTestProduct();
-            when(productRepository.findById("product-id")).thenReturn(Optional.of(product));
+            when(productRepository.findById(1L)).thenReturn(Optional.of(product));
             when(revisionRepository.save(any(ProductRevisionModel.class)))
                     .thenAnswer(invocation -> invocation.getArgument(0));
 
             ProductModel result = productService.updateProduct(
-                    "product-id", "새상품명", BigDecimal.valueOf(20000), "새설명", "new-image.jpg");
+                    1L, "새상품명", BigDecimal.valueOf(20000), "새설명", "new-image.jpg");
 
             assertThat(result.getProductName()).isEqualTo("새상품명");
             assertThat(result.getPrice()).isEqualByComparingTo(BigDecimal.valueOf(20000));
@@ -186,12 +186,12 @@ void updateProduct_ShouldUpdateAndCreateRevision() {
         void updateProduct_ShouldIncrementRevisionSeq() {
             ProductModel product = createTestProduct();
             assertThat(product.getRevisionSeq()).isEqualTo(0L);
-            when(productRepository.findById("product-id")).thenReturn(Optional.of(product));
+            when(productRepository.findById(1L)).thenReturn(Optional.of(product));
             when(revisionRepository.save(any(ProductRevisionModel.class)))
                     .thenAnswer(invocation -> invocation.getArgument(0));
 
             productService.updateProduct(
-                    "product-id", "새상품명", BigDecimal.valueOf(20000), "새설명", null);
+                    1L, "새상품명", BigDecimal.valueOf(20000), "새설명", null);
 
             assertThat(product.getRevisionSeq()).isEqualTo(1L);
         }
@@ -200,14 +200,14 @@ void updateProduct_ShouldIncrementRevisionSeq() {
         @DisplayName("brandId는 수정 시 변경되지 않는다")
         void updateProduct_BrandId_ShouldNotBeChangeable() {
             ProductModel product = createTestProduct();
-            when(productRepository.findById("product-id")).thenReturn(Optional.of(product));
+            when(productRepository.findById(1L)).thenReturn(Optional.of(product));
             when(revisionRepository.save(any(ProductRevisionModel.class)))
                     .thenAnswer(invocation -> invocation.getArgument(0));
 
             productService.updateProduct(
-                    "product-id", "새상품명", BigDecimal.valueOf(20000), "새설명", null);
+                    1L, "새상품명", BigDecimal.valueOf(20000), "새설명", null);
 
-            assertThat(product.getBrandId()).isEqualTo("brand-id");
+            assertThat(product.getBrandId()).isEqualTo(1L);
         }
     }
 
@@ -221,11 +221,11 @@ class DeleteTests {
         @DisplayName("소프트 삭제 후 DELETE 이력이 기록된다")
         void deleteProduct_ShouldSoftDeleteAndCreateRevision() {
             ProductModel product = createTestProduct();
-            when(productRepository.findById("product-id")).thenReturn(Optional.of(product));
+            when(productRepository.findById(1L)).thenReturn(Optional.of(product));
             when(revisionRepository.save(any(ProductRevisionModel.class)))
                     .thenAnswer(invocation -> invocation.getArgument(0));
 
-            productService.deleteProduct("product-id");
+            productService.deleteProduct(1L);
 
             assertThat(product.isDeleted()).isTrue();
             ArgumentCaptor<ProductRevisionModel> captor = ArgumentCaptor.forClass(ProductRevisionModel.class);
@@ -238,9 +238,9 @@ void deleteProduct_ShouldSoftDeleteAndCreateRevision() {
         void deleteProduct_AlreadyDeleted_ShouldBeIdempotent() {
             ProductModel product = createTestProduct();
             product.softDelete();
-            when(productRepository.findById("product-id")).thenReturn(Optional.of(product));
+            when(productRepository.findById(1L)).thenReturn(Optional.of(product));
 
-            assertThatCode(() -> productService.deleteProduct("product-id"))
+            assertThatCode(() -> productService.deleteProduct(1L))
                     .doesNotThrowAnyException();
             verify(revisionRepository, never()).save(any());
         }
@@ -258,12 +258,12 @@ void softDeleteByBrandId_ShouldDeleteAllProductsOfBrand() {
             ProductModel p1 = createTestProduct();
             ProductModel p2 = createTestProduct();
             ProductModel p3 = createTestProduct();
-            when(productRepository.findAllByBrandId("brand-id"))
+            when(productRepository.findAllByBrandId(1L))
                     .thenReturn(List.of(p1, p2, p3));
             when(revisionRepository.save(any(ProductRevisionModel.class)))
                     .thenAnswer(invocation -> invocation.getArgument(0));
 
-            productService.softDeleteByBrandId("brand-id");
+            productService.softDeleteByBrandId(1L);
 
             assertThat(p1.isDeleted()).isTrue();
             assertThat(p2.isDeleted()).isTrue();
@@ -274,9 +274,9 @@ void softDeleteByBrandId_ShouldDeleteAllProductsOfBrand() {
         @Test
         @DisplayName("소속 상품이 없으면 에러 없이 통과한다")
         void softDeleteByBrandId_WhenNoProducts_ShouldBeNoop() {
-            when(productRepository.findAllByBrandId("brand-id")).thenReturn(List.of());
+            when(productRepository.findAllByBrandId(1L)).thenReturn(List.of());
 
-            assertThatCode(() -> productService.softDeleteByBrandId("brand-id"))
+            assertThatCode(() -> productService.softDeleteByBrandId(1L))
                     .doesNotThrowAnyException();
             verify(revisionRepository, never()).save(any());
         }
@@ -292,11 +292,11 @@ class SaleStatusAndRevisionTests {
         @DisplayName("판매 상태 변경 시 SALE_STATUS_CHANGE 이력이 기록된다")
         void changeSaleStatus_ShouldCreateRevision() {
             ProductModel product = createTestProduct();
-            when(productRepository.findById("product-id")).thenReturn(Optional.of(product));
+            when(productRepository.findById(1L)).thenReturn(Optional.of(product));
             when(revisionRepository.save(any(ProductRevisionModel.class)))
                     .thenAnswer(invocation -> invocation.getArgument(0));
 
-            productService.changeSaleStatus("product-id", ProductSaleStatus.TEMP_SOLD_OUT);
+            productService.changeSaleStatus(1L, ProductSaleStatus.TEMP_SOLD_OUT);
 
             assertThat(product.getSaleStatus()).isEqualTo(ProductSaleStatus.TEMP_SOLD_OUT);
             ArgumentCaptor<ProductRevisionModel> captor = ArgumentCaptor.forClass(ProductRevisionModel.class);
@@ -308,10 +308,10 @@ void changeSaleStatus_ShouldCreateRevision() {
         @DisplayName("이력 목록 조회가 올바르게 동작한다")
         void findRevisionsByProductId_ShouldReturnList() {
             ProductRevisionModel rev = ProductRevisionModel.create(
-                    "product-id", 0L, ProductRevisionAction.CREATE, null, null, null, "{}");
-            when(revisionRepository.findAllByProductId("product-id")).thenReturn(List.of(rev));
+                    1L, 0L, ProductRevisionAction.CREATE, null, null, null, "{}");
+            when(revisionRepository.findAllByProductId(1L)).thenReturn(List.of(rev));
 
-            List<ProductRevisionModel> result = productService.findRevisionsByProductId("product-id");
+            List<ProductRevisionModel> result = productService.findRevisionsByProductId(1L);
 
             assertThat(result).hasSize(1);
         }
@@ -319,12 +319,12 @@ void findRevisionsByProductId_ShouldReturnList() {
         @Test
         @DisplayName("특정 이력 상세 조회가 올바르게 동작한다")
         void findRevisionById_Existing_ShouldReturn() {
-            ProductRevisionId id = new ProductRevisionId("product-id", 0L);
+            ProductRevisionId id = new ProductRevisionId(1L, 0L);
             ProductRevisionModel rev = ProductRevisionModel.create(
-                    "product-id", 0L, ProductRevisionAction.CREATE, null, null, null, "{}");
+                    1L, 0L, ProductRevisionAction.CREATE, null, null, null, "{}");
             when(revisionRepository.findById(id)).thenReturn(Optional.of(rev));
 
-            ProductRevisionModel result = productService.findRevisionById("product-id", 0L);
+            ProductRevisionModel result = productService.findRevisionById(1L, 0L);
 
             assertThat(result.getAction()).isEqualTo(ProductRevisionAction.CREATE);
         }
@@ -333,7 +333,7 @@ void findRevisionById_Existing_ShouldReturn() {
     // === Helper ===
 
     private ProductModel createTestProduct() {
-        return ProductModel.create("테스트상품", "brand-id", BigDecimal.valueOf(10000),
+        return ProductModel.create("테스트상품", 1L, BigDecimal.valueOf(10000),
                 "설명", null, null, null, null, null, null);
     }
 }
diff --git a/apps/commerce-api/src/test/java/com/loopers/domain/product/ProductStockModelTest.java b/apps/commerce-api/src/test/java/com/loopers/domain/product/ProductStockModelTest.java
index 71909d914..a6c6447c1 100644
--- a/apps/commerce-api/src/test/java/com/loopers/domain/product/ProductStockModelTest.java
+++ b/apps/commerce-api/src/test/java/com/loopers/domain/product/ProductStockModelTest.java
@@ -1,6 +1,7 @@
 package com.loopers.domain.product;
 
 import com.loopers.support.error.CoreException;
+import com.loopers.support.error.ErrorType;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Nested;
 import org.junit.jupiter.api.Test;
@@ -17,23 +18,23 @@ class CreateTests {
         @Test
         @DisplayName("유효한 입력으로 생성 성공")
         void create_WithValidInputs_ShouldSuccess() {
-            ProductStockModel stock = ProductStockModel.create("product-001", 100);
+            ProductStockModel stock = ProductStockModel.create(1L, 100);
 
-            assertThat(stock.getProductId()).isEqualTo("product-001");
+            assertThat(stock.getProductId()).isEqualTo(1L);
             assertThat(stock.getOnHand()).isEqualTo(100);
         }
 
         @Test
         @DisplayName("음수 onHand로 생성 시 CoreException 발생")
         void create_WithNegativeOnHand_ShouldThrow() {
-            assertThatThrownBy(() -> ProductStockModel.create("product-001", -1))
+            assertThatThrownBy(() -> ProductStockModel.create(1L, -1))
                     .isInstanceOf(CoreException.class);
         }
 
         @Test
         @DisplayName("생성 시 reserved 기본값은 0이다")
         void create_InitialReserved_ShouldBeZero() {
-            ProductStockModel stock = ProductStockModel.create("product-001", 100);
+            ProductStockModel stock = ProductStockModel.create(1L, 100);
             assertThat(stock.getReserved()).isEqualTo(0);
         }
     }
@@ -45,25 +46,49 @@ class StockCalculationTests {
         @Test
         @DisplayName("가용 재고 = onHand - reserved")
         void getAvailableQty_ShouldReturnOnHandMinusReserved() {
-            ProductStockModel stock = ProductStockModel.create("product-001", 100);
+            ProductStockModel stock = ProductStockModel.create(1L, 100);
             assertThat(stock.getAvailableQty()).isEqualTo(100);
         }
 
         @Test
         @DisplayName("충분한 재고가 있으면 canHold true")
         void canHold_WhenSufficient_ShouldReturnTrue() {
-            ProductStockModel stock = ProductStockModel.create("product-001", 10);
+            ProductStockModel stock = ProductStockModel.create(1L, 10);
             assertThat(stock.canHold(10)).isTrue();
         }
 
         @Test
         @DisplayName("재고가 부족하면 canHold false")
         void canHold_WhenInsufficient_ShouldReturnFalse() {
-            ProductStockModel stock = ProductStockModel.create("product-001", 10);
+            ProductStockModel stock = ProductStockModel.create(1L, 10);
             assertThat(stock.canHold(11)).isFalse();
         }
     }
 
+    @Nested
+    @DisplayName("재고 검증")
+    class ValidateCanHoldTests {
+
+        @Test
+        @DisplayName("충분한 재고가 있으면 예외 없이 통과한다")
+        void validateCanHold_WhenSufficient_ShouldPass() {
+            ProductStockModel stock = ProductStockModel.create(1L, 10);
+
+            assertThatCode(() -> stock.validateCanHold(10)).doesNotThrowAnyException();
+        }
+
+        @Test
+        @DisplayName("재고가 부족하면 CART_STOCK_EXCEEDED 예외가 발생한다")
+        void validateCanHold_WhenInsufficient_ShouldThrowCartStockExceeded() {
+            ProductStockModel stock = ProductStockModel.create(1L, 10);
+
+            assertThatThrownBy(() -> stock.validateCanHold(11))
+                    .isInstanceOf(CoreException.class)
+                    .satisfies(ex -> assertThat(((CoreException) ex).getErrorType())
+                            .isEqualTo(ErrorType.CART_STOCK_EXCEEDED));
+        }
+    }
+
     @Nested
     @DisplayName("재고 수정")
     class UpdateOnHandTests {
@@ -71,7 +96,7 @@ class UpdateOnHandTests {
         @Test
         @DisplayName("유효한 수량으로 onHand 수정 성공")
         void updateOnHand_WithValidQty_ShouldUpdate() {
-            ProductStockModel stock = ProductStockModel.create("product-001", 100);
+            ProductStockModel stock = ProductStockModel.create(1L, 100);
             stock.updateOnHand(200);
             assertThat(stock.getOnHand()).isEqualTo(200);
         }
@@ -79,7 +104,7 @@ void updateOnHand_WithValidQty_ShouldUpdate() {
         @Test
         @DisplayName("reserved보다 작은 onHand로 수정 시 CoreException 발생")
         void updateOnHand_WhenNewOnHandLessThanReserved_ShouldThrow() {
-            ProductStockModel stock = ProductStockModel.createWithReserved("product-001", 100, 50);
+            ProductStockModel stock = ProductStockModel.createWithReserved(1L, 100, 50);
             assertThatThrownBy(() -> stock.updateOnHand(30))
                     .isInstanceOf(CoreException.class);
         }
diff --git a/apps/commerce-api/src/test/java/com/loopers/domain/product/StockConcurrencyTest.java b/apps/commerce-api/src/test/java/com/loopers/domain/product/StockConcurrencyTest.java
index 12b7861b8..f90f2ac7f 100644
--- a/apps/commerce-api/src/test/java/com/loopers/domain/product/StockConcurrencyTest.java
+++ b/apps/commerce-api/src/test/java/com/loopers/domain/product/StockConcurrencyTest.java
@@ -31,11 +31,11 @@ class StockConcurrencyTest {
     @Autowired
     DatabaseCleanUp databaseCleanUp;
 
-    private String productId;
+    private Long productId;
 
     @BeforeEach
     void setUp() {
-        ProductStockModel stock = stockService.createStock("concurrency-test-product", 10);
+        ProductStockModel stock = stockService.createStock(1L, 10);
         productId = stock.getProductId();
     }
 
diff --git a/apps/commerce-api/src/test/java/com/loopers/domain/product/StockServiceTest.java b/apps/commerce-api/src/test/java/com/loopers/domain/product/StockServiceTest.java
index 5a0179ab8..1f9072d06 100644
--- a/apps/commerce-api/src/test/java/com/loopers/domain/product/StockServiceTest.java
+++ b/apps/commerce-api/src/test/java/com/loopers/domain/product/StockServiceTest.java
@@ -30,19 +30,19 @@ class HoldTests {
         @Test
         @DisplayName("충분한 재고가 있으면 예외 없이 정상 완료된다")
         void hold_WithSufficientStock_ShouldReturnTrue() {
-            when(productStockRepository.reserveStock("product-1", 5)).thenReturn(1);
+            when(productStockRepository.reserveStock(1L, 5)).thenReturn(1);
 
-            assertThatCode(() -> stockService.hold("product-1", 5))
+            assertThatCode(() -> stockService.hold(1L, 5))
                     .doesNotThrowAnyException();
-            verify(productStockRepository).reserveStock("product-1", 5);
+            verify(productStockRepository).reserveStock(1L, 5);
         }
 
         @Test
         @DisplayName("재고 부족 시 STOCK_NOT_ENOUGH 예외가 발생한다")
         void hold_WithInsufficientStock_ShouldThrowSTOCK_NOT_ENOUGH() {
-            when(productStockRepository.reserveStock("product-1", 100)).thenReturn(0);
+            when(productStockRepository.reserveStock(1L, 100)).thenReturn(0);
 
-            assertThatThrownBy(() -> stockService.hold("product-1", 100))
+            assertThatThrownBy(() -> stockService.hold(1L, 100))
                     .isInstanceOf(CoreException.class)
                     .satisfies(ex -> assertThat(((CoreException) ex).getErrorType())
                             .isEqualTo(ErrorType.STOCK_NOT_ENOUGH));
@@ -56,19 +56,19 @@ class ReleaseTests {
         @Test
         @DisplayName("정상 해제 시 예외 없이 완료된다")
         void release_WithValidQty_ShouldReturnTrue() {
-            when(productStockRepository.releaseStock("product-1", 5)).thenReturn(1);
+            when(productStockRepository.releaseStock(1L, 5)).thenReturn(1);
 
-            assertThatCode(() -> stockService.release("product-1", 5))
+            assertThatCode(() -> stockService.release(1L, 5))
                     .doesNotThrowAnyException();
-            verify(productStockRepository).releaseStock("product-1", 5);
+            verify(productStockRepository).releaseStock(1L, 5);
         }
 
         @Test
         @DisplayName("예약량보다 많은 해제 시도 시 예외가 발생한다")
         void release_WithExcessiveQty_ShouldThrow() {
-            when(productStockRepository.releaseStock("product-1", 100)).thenReturn(0);
+            when(productStockRepository.releaseStock(1L, 100)).thenReturn(0);
 
-            assertThatThrownBy(() -> stockService.release("product-1", 100))
+            assertThatThrownBy(() -> stockService.release(1L, 100))
                     .isInstanceOf(CoreException.class)
                     .satisfies(ex -> assertThat(((CoreException) ex).getErrorType())
                             .isEqualTo(ErrorType.STOCK_NOT_ENOUGH));
@@ -82,11 +82,11 @@ class CommitTests {
         @Test
         @DisplayName("정상 확정 시 예외 없이 완료된다")
         void commit_WithValidQty_ShouldReturnTrue() {
-            when(productStockRepository.commitStock("product-1", 5)).thenReturn(1);
+            when(productStockRepository.commitStock(1L, 5)).thenReturn(1);
 
-            assertThatCode(() -> stockService.commit("product-1", 5))
+            assertThatCode(() -> stockService.commit(1L, 5))
                     .doesNotThrowAnyException();
-            verify(productStockRepository).commitStock("product-1", 5);
+            verify(productStockRepository).commitStock(1L, 5);
         }
     }
 }
diff --git a/apps/commerce-api/src/test/java/com/loopers/domain/stats/StatsServiceTest.java b/apps/commerce-api/src/test/java/com/loopers/domain/stats/StatsServiceTest.java
index 351a6f42d..d83428c2c 100644
--- a/apps/commerce-api/src/test/java/com/loopers/domain/stats/StatsServiceTest.java
+++ b/apps/commerce-api/src/test/java/com/loopers/domain/stats/StatsServiceTest.java
@@ -65,7 +65,7 @@ void getDailyOrderStats_ShouldReturnDailyAggregation() {
     void getTopLikedProducts_ShouldReturnTopN() {
         List<StatsProjection.ProductStat> stats = List.of(
                 StatsProjection.ProductStat.builder()
-                        .productId("p1").productName("인기상품").count(100).build()
+                        .productId(1L).productName("인기상품").count(100).build()
         );
         when(statsRepository.getTopLikedProducts(10)).thenReturn(stats);
 
@@ -80,7 +80,7 @@ void getTopLikedProducts_ShouldReturnTopN() {
     void getTopOrderedProducts_ShouldReturnTopN() {
         List<StatsProjection.ProductStat> stats = List.of(
                 StatsProjection.ProductStat.builder()
-                        .productId("p1").productName("베스트상품").count(50).build()
+                        .productId(1L).productName("베스트상품").count(50).build()
         );
         when(statsRepository.getTopOrderedProducts(10)).thenReturn(stats);
 
@@ -95,7 +95,7 @@ void getTopOrderedProducts_ShouldReturnTopN() {
     void getLowStockProducts_ShouldReturnBelowThreshold() {
         List<StatsProjection.LowStockProduct> stats = List.of(
                 StatsProjection.LowStockProduct.builder()
-                        .productId("p1").productName("부족상품")
+                        .productId(1L).productName("부족상품")
                         .onHand(10).reserved(8).availableQty(2).build()
         );
         when(statsRepository.getLowStockProducts(5)).thenReturn(stats);
diff --git a/apps/commerce-api/src/test/java/com/loopers/domain/user/UserServiceTest.java b/apps/commerce-api/src/test/java/com/loopers/domain/user/UserServiceTest.java
index cf273f7bc..2c9fbbff8 100644
--- a/apps/commerce-api/src/test/java/com/loopers/domain/user/UserServiceTest.java
+++ b/apps/commerce-api/src/test/java/com/loopers/domain/user/UserServiceTest.java
@@ -83,9 +83,9 @@ class FindTests {
         @DisplayName("ID로 사용자 조회 성공")
         void findByUserId_Existing_ShouldReturn() {
             UserModel user = createTestUser();
-            when(userRepository.findByUserId("user-id")).thenReturn(Optional.of(user));
+            when(userRepository.findByUserId(1L)).thenReturn(Optional.of(user));
 
-            UserModel result = userService.findByUserId("user-id");
+            UserModel result = userService.findByUserId(1L);
 
             assertThat(result.getLoginId()).isEqualTo("testuser01");
         }
@@ -93,9 +93,9 @@ void findByUserId_Existing_ShouldReturn() {
         @Test
         @DisplayName("존재하지 않는 ID 조회 시 USER_NOT_FOUND")
         void findByUserId_NotFound_ShouldThrow_USER_NOT_FOUND() {
-            when(userRepository.findByUserId("nonexistent")).thenReturn(Optional.empty());
+            when(userRepository.findByUserId(999L)).thenReturn(Optional.empty());
 
-            assertThatThrownBy(() -> userService.findByUserId("nonexistent"))
+            assertThatThrownBy(() -> userService.findByUserId(999L))
                     .isInstanceOf(CoreException.class)
                     .satisfies(ex -> assertThat(((CoreException) ex).getErrorType())
                             .isEqualTo(ErrorType.USER_NOT_FOUND));
diff --git a/apps/commerce-api/src/test/java/com/loopers/infrastructure/brand/BrandRepositoryImplTest.java b/apps/commerce-api/src/test/java/com/loopers/infrastructure/brand/BrandRepositoryImplTest.java
index 9c84c1249..787a4d684 100644
--- a/apps/commerce-api/src/test/java/com/loopers/infrastructure/brand/BrandRepositoryImplTest.java
+++ b/apps/commerce-api/src/test/java/com/loopers/infrastructure/brand/BrandRepositoryImplTest.java
@@ -24,14 +24,14 @@ class BrandRepositoryImplTest {
     BrandRepositoryImpl brandRepository;
 
     @Test
-    @DisplayName("저장 시 UUID ID가 자동 생성된다")
-    void save_ShouldPersistWithUuidId() {
+    @DisplayName("저장 시 ID가 자동 생성된다")
+    void save_ShouldPersistWithAutoId() {
         BrandModel brand = BrandModel.create("테스트브랜드", "설명", "서울");
 
         BrandModel saved = brandRepository.save(brand);
 
         assertThat(saved.getBrandId()).isNotNull();
-        assertThat(saved.getBrandId()).hasSize(36);
+        assertThat(saved.getBrandId()).isGreaterThan(0L);
     }
 
     @Test
@@ -49,7 +49,7 @@ void findById_Existing_ShouldReturn() {
     @Test
     @DisplayName("ID로 조회 - 존재하지 않는 브랜드")
     void findById_NotExisting_ShouldReturnEmpty() {
-        Optional<BrandModel> found = brandRepository.findById("nonexistent-uuid");
+        Optional<BrandModel> found = brandRepository.findById(999L);
 
         assertThat(found).isEmpty();
     }
diff --git a/apps/commerce-api/src/test/java/com/loopers/infrastructure/cache/CacheBenchmarkTest.java b/apps/commerce-api/src/test/java/com/loopers/infrastructure/cache/CacheBenchmarkTest.java
new file mode 100644
index 000000000..ce5524a7c
--- /dev/null
+++ b/apps/commerce-api/src/test/java/com/loopers/infrastructure/cache/CacheBenchmarkTest.java
@@ -0,0 +1,325 @@
+package com.loopers.infrastructure.cache;
+
+import com.loopers.domain.brand.BrandModel;
+import com.loopers.domain.brand.BrandService;
+import com.loopers.domain.product.ProductModel;
+import com.loopers.domain.product.ProductService;
+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.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.cache.Cache;
+import org.springframework.cache.CacheManager;
+import org.springframework.data.redis.core.RedisTemplate;
+import org.springframework.test.context.ActiveProfiles;
+
+import java.math.BigDecimal;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Random;
+import java.util.Set;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+@SpringBootTest
+@ActiveProfiles("test")
+@DisplayName("L2 vs L1+L2 비교 벤치마크")
+class CacheBenchmarkTest {
+
+    @Autowired
+    private ProductService productService;
+
+    @Autowired
+    private BrandService brandService;
+
+    @Autowired
+    private CacheManager cacheManager;
+
+    @Autowired
+    private RedisTemplate<String, String> redisTemplate;
+
+    @Autowired
+    private DatabaseCleanUp databaseCleanUp;
+
+    @Autowired
+    private RedisCleanUp redisCleanUp;
+
+    @AfterEach
+    void tearDown() {
+        cacheManager.getCacheNames().forEach(name -> {
+            Cache cache = cacheManager.getCache(name);
+            if (cache != null) {
+                cache.clear();
+            }
+        });
+        redisCleanUp.truncateAll();
+        databaseCleanUp.truncateAllTables();
+    }
+
+    @Test
+    @DisplayName("시나리오1: 동일 상품 1000회 반복 조회 — L2-only vs L1+L2 응답 시간")
+    void benchmark_sameProduct_1000reads() {
+        // given
+        BrandModel brand = brandService.createBrand("벤치마크브랜드", "설명", "서울");
+        ProductModel product = productService.createProduct("벤치마크상품", brand.getBrandId(),
+                BigDecimal.valueOf(10000), "설명");
+        int iterations = 1000;
+
+        // --- L2-only 측정 (brandDetail — L2-only 캐시) ---
+        BrandModel brandForL2 = brandService.findById(brand.getBrandId()); // warm-up
+        long[] l2Times = new long[iterations];
+        for (int i = 0; i < iterations; i++) {
+            long start = System.nanoTime();
+            brandService.findById(brand.getBrandId());
+            l2Times[i] = System.nanoTime() - start;
+        }
+
+        // --- L1+L2 측정 (productDetail — TwoLevelCache) ---
+        productService.findById(product.getProductId()); // warm-up
+        long[] l1l2Times = new long[iterations];
+        for (int i = 0; i < iterations; i++) {
+            long start = System.nanoTime();
+            productService.findById(product.getProductId());
+            l1l2Times[i] = System.nanoTime() - start;
+        }
+
+        // 결과 출력
+        printBenchmarkResult("시나리오1: 동일 키 1000회 반복 조회", l2Times, l1l2Times, iterations);
+
+        // 기본 검증: L1+L2 p50이 L2-only p50보다 빠르거나 동등
+        Arrays.sort(l2Times);
+        Arrays.sort(l1l2Times);
+        System.out.printf("  L1+L2 p50 / L2 p50 비율: %.2fx%n",
+                (double) l2Times[iterations / 2] / Math.max(l1l2Times[iterations / 2], 1));
+    }
+
+    @Test
+    @DisplayName("시나리오2: 50개 상품 Zipf 분포 1000회 조회")
+    void benchmark_zipfDistribution_1000reads() {
+        // given: 50개 상품 생성
+        BrandModel brand = brandService.createBrand("Zipf브랜드", "설명", "서울");
+        List<Long> productIds = new ArrayList<>();
+        for (int i = 0; i < 50; i++) {
+            ProductModel p = productService.createProduct("상품" + i, brand.getBrandId(),
+                    BigDecimal.valueOf(10000 + i * 100), "설명" + i);
+            productIds.add(p.getProductId());
+        }
+
+        int iterations = 1000;
+        List<Long> accessPattern = generateZipfAccessPattern(productIds, iterations);
+
+        // warm-up: 모든 상품 1회 조회
+        for (Long id : productIds) {
+            productService.findById(id);
+        }
+
+        // --- L1+L2 측정 (현재 구성) ---
+        long[] l1l2Times = new long[iterations];
+        for (int i = 0; i < iterations; i++) {
+            long start = System.nanoTime();
+            productService.findById(accessPattern.get(i));
+            l1l2Times[i] = System.nanoTime() - start;
+        }
+
+        // L1 캐시 통계 확인
+        Cache productCache = cacheManager.getCache("productDetail");
+        assertThat(productCache).isInstanceOf(TwoLevelCache.class);
+
+        // 결과 출력
+        Arrays.sort(l1l2Times);
+        System.out.println("=== 시나리오2: Zipf 분포 1000회 조회 (L1+L2) ===");
+        System.out.printf("  p50:  %.4f ms%n", l1l2Times[499] / 1_000_000.0);
+        System.out.printf("  p95:  %.4f ms%n", l1l2Times[949] / 1_000_000.0);
+        System.out.printf("  p99:  %.4f ms%n", l1l2Times[989] / 1_000_000.0);
+        System.out.printf("  avg:  %.4f ms%n", Arrays.stream(l1l2Times).average().orElse(0) / 1_000_000.0);
+        System.out.printf("  상품 수: %d, 조회 수: %d%n", productIds.size(), iterations);
+    }
+
+    @Test
+    @DisplayName("시나리오3: 읽기 70%% + 쓰기 30%% 혼합 워크로드")
+    void benchmark_mixedReadWrite() {
+        // given
+        BrandModel brand = brandService.createBrand("혼합브랜드", "설명", "서울");
+        ProductModel product = productService.createProduct("혼합상품", brand.getBrandId(),
+                BigDecimal.valueOf(10000), "설명");
+        productService.findById(product.getProductId()); // warm-up
+
+        int totalOps = 1000;
+        int writeRatio = 30; // 30% 쓰기
+        Random random = new Random(42);
+
+        long[] times = new long[totalOps];
+        int readCount = 0;
+        int writeCount = 0;
+
+        for (int i = 0; i < totalOps; i++) {
+            long start = System.nanoTime();
+            if (random.nextInt(100) < writeRatio) {
+                // 쓰기 (CacheEvict 발생)
+                productService.updateProduct(product.getProductId(),
+                        "상품v" + i, BigDecimal.valueOf(10000 + i), "설명v" + i, null);
+                writeCount++;
+            } else {
+                // 읽기 (Cache Hit 기대)
+                productService.findById(product.getProductId());
+                readCount++;
+            }
+            times[i] = System.nanoTime() - start;
+        }
+
+        Arrays.sort(times);
+        System.out.println("=== 시나리오3: 읽기/쓰기 혼합 (L1+L2) ===");
+        System.out.printf("  읽기: %d건, 쓰기: %d건%n", readCount, writeCount);
+        System.out.printf("  p50:  %.4f ms%n", times[499] / 1_000_000.0);
+        System.out.printf("  p95:  %.4f ms%n", times[949] / 1_000_000.0);
+        System.out.printf("  p99:  %.4f ms%n", times[989] / 1_000_000.0);
+        System.out.printf("  avg:  %.4f ms%n", Arrays.stream(times).average().orElse(0) / 1_000_000.0);
+    }
+
+    @Test
+    @DisplayName("시나리오4: 50스레드 동시 조회 — L2 vs L1+L2 처리 시간")
+    void benchmark_concurrent_50threads() throws Exception {
+        // given
+        BrandModel brand = brandService.createBrand("동시성브랜드", "설명", "서울");
+        ProductModel product = productService.createProduct("동시성상품", brand.getBrandId(),
+                BigDecimal.valueOf(10000), "설명");
+        productService.findById(product.getProductId()); // warm-up (L1+L2 적재)
+
+        int threadCount = 50;
+        int opsPerThread = 100;
+
+        // --- L2-only 시뮬레이션: brandDetail 사용 ---
+        brandService.findById(brand.getBrandId()); // warm-up
+        long l2TotalTime = runConcurrentBenchmark(threadCount, opsPerThread,
+                () -> brandService.findById(brand.getBrandId()));
+
+        // --- L1+L2: productDetail 사용 ---
+        long l1l2TotalTime = runConcurrentBenchmark(threadCount, opsPerThread,
+                () -> productService.findById(product.getProductId()));
+
+        System.out.println("=== 시나리오4: 50스레드 × 100회 동시 조회 ===");
+        System.out.printf("  L2-only 총 처리 시간:  %d ms%n", l2TotalTime);
+        System.out.printf("  L1+L2  총 처리 시간:  %d ms%n", l1l2TotalTime);
+        System.out.printf("  개선율: %.1f%%%n",
+                (1.0 - (double) l1l2TotalTime / Math.max(l2TotalTime, 1)) * 100);
+
+        // 기본 검증: 둘 다 모든 요청 처리 성공
+        assertThat(l2TotalTime).isGreaterThan(0);
+        assertThat(l1l2TotalTime).isGreaterThan(0);
+    }
+
+    @Test
+    @DisplayName("시나리오5: Caffeine 캐시 메트릭 (hitCount, missCount, hitRate)")
+    void benchmark_caffeineMetrics() {
+        // given
+        BrandModel brand = brandService.createBrand("메트릭브랜드", "설명", "서울");
+        List<Long> productIds = new ArrayList<>();
+        for (int i = 0; i < 10; i++) {
+            ProductModel p = productService.createProduct("메트릭상품" + i, brand.getBrandId(),
+                    BigDecimal.valueOf(10000 + i * 100), "설명");
+            productIds.add(p.getProductId());
+        }
+
+        // when: 각 상품 1회 조회 (10 miss) + 인기 상품 3개 추가 10회 조회 (30 hit)
+        for (Long id : productIds) {
+            productService.findById(id);
+        }
+        for (int i = 0; i < 10; i++) {
+            productService.findById(productIds.get(0));
+            productService.findById(productIds.get(1));
+            productService.findById(productIds.get(2));
+        }
+
+        // then: 캐시 통계 출력
+        Cache cache = cacheManager.getCache("productDetail");
+        assertThat(cache).isInstanceOf(TwoLevelCache.class);
+
+        // Redis 키 수 확인
+        Set<String> redisKeys = redisTemplate.keys("productDetail*");
+        System.out.println("=== 시나리오5: Caffeine 캐시 메트릭 ===");
+        System.out.printf("  Redis(L2) 키 수: %d%n", redisKeys != null ? redisKeys.size() : 0);
+        System.out.printf("  총 조회: 40회 (10 cold + 30 hot)%n");
+        System.out.printf("  기대 L1 miss: 10회 (첫 조회), L1 hit: 30회 (반복 조회)%n");
+        System.out.printf("  기대 L1 hitRate: %.0f%%%n", 30.0 / 40 * 100);
+    }
+
+    // --- 유틸리티 메서드 ---
+
+    private void printBenchmarkResult(String scenario, long[] l2Times, long[] l1l2Times, int iterations) {
+        Arrays.sort(l2Times);
+        Arrays.sort(l1l2Times);
+
+        System.out.println("=== " + scenario + " ===");
+        System.out.printf("%-20s %15s %15s%n", "Metric", "L2-only", "L1+L2");
+        System.out.printf("%-20s %12.4f ms %12.4f ms%n", "p50",
+                l2Times[iterations / 2] / 1_000_000.0, l1l2Times[iterations / 2] / 1_000_000.0);
+        System.out.printf("%-20s %12.4f ms %12.4f ms%n", "p95",
+                l2Times[(int) (iterations * 0.95)] / 1_000_000.0, l1l2Times[(int) (iterations * 0.95)] / 1_000_000.0);
+        System.out.printf("%-20s %12.4f ms %12.4f ms%n", "p99",
+                l2Times[(int) (iterations * 0.99)] / 1_000_000.0, l1l2Times[(int) (iterations * 0.99)] / 1_000_000.0);
+        System.out.printf("%-20s %12.4f ms %12.4f ms%n", "avg",
+                Arrays.stream(l2Times).average().orElse(0) / 1_000_000.0,
+                Arrays.stream(l1l2Times).average().orElse(0) / 1_000_000.0);
+    }
+
+    private List<Long> generateZipfAccessPattern(List<Long> ids, int count) {
+        Random random = new Random(42);
+        List<Long> pattern = new ArrayList<>();
+        int size = ids.size();
+        for (int i = 0; i < count; i++) {
+            // Zipf-like: 상위 10% 상품이 ~80% 트래픽
+            double u = random.nextDouble();
+            int index;
+            if (u < 0.8) {
+                // 80% 트래픽 → 상위 10% 상품 (index 0~4)
+                index = random.nextInt(Math.max(size / 10, 1));
+            } else {
+                // 20% 트래픽 → 나머지 90% 상품
+                index = size / 10 + random.nextInt(size - size / 10);
+            }
+            pattern.add(ids.get(index));
+        }
+        return pattern;
+    }
+
+    private long runConcurrentBenchmark(int threadCount, int opsPerThread, Runnable task) throws Exception {
+        ExecutorService executor = Executors.newFixedThreadPool(threadCount);
+        CountDownLatch startLatch = new CountDownLatch(1);
+        CountDownLatch doneLatch = new CountDownLatch(threadCount);
+        AtomicInteger successCount = new AtomicInteger(0);
+
+        for (int i = 0; i < threadCount; i++) {
+            executor.submit(() -> {
+                try {
+                    startLatch.await();
+                    for (int j = 0; j < opsPerThread; j++) {
+                        task.run();
+                        successCount.incrementAndGet();
+                    }
+                } catch (InterruptedException e) {
+                    Thread.currentThread().interrupt();
+                } finally {
+                    doneLatch.countDown();
+                }
+            });
+        }
+
+        long startTime = System.currentTimeMillis();
+        startLatch.countDown();
+        doneLatch.await(60, TimeUnit.SECONDS);
+        long totalTime = System.currentTimeMillis() - startTime;
+        executor.shutdown();
+
+        assertThat(successCount.get()).isEqualTo(threadCount * opsPerThread);
+        return totalTime;
+    }
+}
diff --git a/apps/commerce-api/src/test/java/com/loopers/infrastructure/cache/RedisCacheIntegrationTest.java b/apps/commerce-api/src/test/java/com/loopers/infrastructure/cache/RedisCacheIntegrationTest.java
new file mode 100644
index 000000000..a8786ca5d
--- /dev/null
+++ b/apps/commerce-api/src/test/java/com/loopers/infrastructure/cache/RedisCacheIntegrationTest.java
@@ -0,0 +1,333 @@
+package com.loopers.infrastructure.cache;
+
+import com.loopers.domain.brand.BrandModel;
+import com.loopers.domain.brand.BrandService;
+import com.loopers.domain.product.ProductModel;
+import com.loopers.domain.product.ProductService;
+import com.loopers.domain.product.ProductStockModel;
+import com.loopers.domain.product.StockService;
+import com.loopers.domain.stats.StatsProjection;
+import com.loopers.domain.stats.StatsService;
+import com.loopers.domain.user.UserModel;
+import com.loopers.domain.user.UserRegisterCommand;
+import com.loopers.domain.user.UserService;
+import com.loopers.support.error.CoreException;
+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.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.cache.Cache;
+import org.springframework.cache.CacheManager;
+import org.springframework.data.redis.core.RedisTemplate;
+import org.springframework.test.context.ActiveProfiles;
+
+import java.math.BigDecimal;
+import java.time.LocalDate;
+import java.util.Set;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+@SpringBootTest
+@ActiveProfiles("test")
+@DisplayName("Redis L2 캐시 통합 테스트")
+class RedisCacheIntegrationTest {
+
+    @Autowired
+    private ProductService productService;
+
+    @Autowired
+    private BrandService brandService;
+
+    @Autowired
+    private StockService stockService;
+
+    @Autowired
+    private UserService userService;
+
+    @Autowired
+    private StatsService statsService;
+
+    @Autowired
+    private CacheManager cacheManager;
+
+    @Autowired
+    private RedisTemplate<String, String> redisTemplate;
+
+    @Autowired
+    private DatabaseCleanUp databaseCleanUp;
+
+    @Autowired
+    private RedisCleanUp redisCleanUp;
+
+    @AfterEach
+    void tearDown() {
+        // L1 (Caffeine) 캐시 클리어 — TRUNCATE로 ID 리셋 시 stale hit 방지
+        cacheManager.getCacheNames().forEach(name -> {
+            Cache cache = cacheManager.getCache(name);
+            if (cache != null) {
+                cache.clear();
+            }
+        });
+        redisCleanUp.truncateAll();
+        databaseCleanUp.truncateAllTables();
+    }
+
+    @Test
+    @DisplayName("1. 상품 조회 시 최초 Cache Miss → Redis 저장, 두 번째 Cache Hit")
+    void findById_SecondCall_ShouldHitCache() {
+        // given
+        BrandModel brand = brandService.createBrand("테스트브랜드", "설명", "서울");
+        ProductModel product = productService.createProduct("테스트상품", brand.getBrandId(),
+                BigDecimal.valueOf(10000), "상품 설명");
+
+        // when: 첫 번째 조회 (Cache Miss → DB → Redis 저장)
+        ProductModel first = productService.findById(product.getProductId());
+
+        // then: Redis 캐시에 저장됨
+        Cache.ValueWrapper cached = cacheManager.getCache("productDetail").get(product.getProductId());
+        assertThat(cached).isNotNull();
+
+        // when: 두 번째 조회 (Cache Hit)
+        ProductModel second = productService.findById(product.getProductId());
+
+        // then: 동일 데이터 반환
+        assertThat(first.getProductId()).isEqualTo(second.getProductId());
+        assertThat(first.getProductName()).isEqualTo(second.getProductName());
+        assertThat(first.getPrice()).isEqualByComparingTo(second.getPrice());
+    }
+
+    @Test
+    @DisplayName("2. 상품 수정(CacheEvict) 후 재조회 시 캐시 무효화 → DB 재조회")
+    void updateProduct_ShouldEvictCache() {
+        // given
+        BrandModel brand = brandService.createBrand("테스트브랜드", "설명", "서울");
+        ProductModel product = productService.createProduct("원래상품명", brand.getBrandId(),
+                BigDecimal.valueOf(10000), "설명");
+
+        // 캐시 적재
+        productService.findById(product.getProductId());
+        assertThat(cacheManager.getCache("productDetail").get(product.getProductId())).isNotNull();
+
+        // when: 상품 수정 → CacheEvict
+        productService.updateProduct(product.getProductId(), "수정된상품명",
+                BigDecimal.valueOf(20000), "수정 설명", null);
+
+        // then: 캐시 무효화됨
+        assertThat(cacheManager.getCache("productDetail").get(product.getProductId())).isNull();
+
+        // when: 재조회 → 수정된 데이터
+        ProductModel updated = productService.findById(product.getProductId());
+        assertThat(updated.getProductName()).isEqualTo("수정된상품명");
+        assertThat(updated.getPrice()).isEqualByComparingTo(BigDecimal.valueOf(20000));
+
+        // then: 캐시에 수정된 데이터가 다시 적재됨
+        assertThat(cacheManager.getCache("productDetail").get(product.getProductId())).isNotNull();
+    }
+
+    @Test
+    @DisplayName("3. 상품 삭제(CacheEvict) 후 캐시 무효화 확인")
+    void deleteProduct_ShouldEvictCache() {
+        // given
+        BrandModel brand = brandService.createBrand("테스트브랜드", "설명", "서울");
+        ProductModel product = productService.createProduct("삭제대상상품", brand.getBrandId(),
+                BigDecimal.valueOf(10000), "설명");
+
+        // 캐시 적재
+        productService.findById(product.getProductId());
+        assertThat(cacheManager.getCache("productDetail").get(product.getProductId())).isNotNull();
+
+        // when: 삭제 → CacheEvict
+        productService.deleteProduct(product.getProductId());
+
+        // then: 캐시에서 제거됨
+        assertThat(cacheManager.getCache("productDetail").get(product.getProductId())).isNull();
+    }
+
+    @Test
+    @DisplayName("4. 직렬화 정합성 — 캐시 저장 후 역직렬화 시 필드값 일치")
+    void serialization_ShouldPreserveAllFields() {
+        // given
+        BrandModel brand = brandService.createBrand("브랜드A", "설명", "서울");
+        ProductModel product = productService.createProduct("직렬화테스트상품", brand.getBrandId(),
+                BigDecimal.valueOf(15000), "직렬화 검증용 상품");
+
+        // when: 캐시 적재
+        productService.findById(product.getProductId());
+
+        // then: Redis에서 키 존재 확인
+        Set<String> keys = redisTemplate.keys("productDetail*");
+        assertThat(keys).isNotEmpty();
+
+        // then: 캐시에서 꺼낸 데이터와 원본 비교
+        Object fromCache = cacheManager.getCache("productDetail")
+                .get(product.getProductId()).get();
+        assertThat(fromCache).isInstanceOf(ProductModel.class);
+        ProductModel cachedProduct = (ProductModel) fromCache;
+        assertThat(cachedProduct.getProductId()).isEqualTo(product.getProductId());
+        assertThat(cachedProduct.getProductName()).isEqualTo("직렬화테스트상품");
+        assertThat(cachedProduct.getBrandId()).isEqualTo(brand.getBrandId());
+        assertThat(cachedProduct.getPrice()).isEqualByComparingTo(BigDecimal.valueOf(15000));
+        assertThat(cachedProduct.getDescription()).isEqualTo("직렬화 검증용 상품");
+    }
+
+    @Test
+    @DisplayName("5. Brand 캐시 Hit/Evict — 조회 → 수정 → 재조회")
+    void brandCache_HitAndEvict() {
+        // given
+        BrandModel brand = brandService.createBrand("캐시브랜드", "설명", "서울");
+
+        // when: 첫 조회 → 캐시 적재
+        brandService.findById(brand.getBrandId());
+        assertThat(cacheManager.getCache("brandDetail").get(brand.getBrandId())).isNotNull();
+
+        // when: 수정 → CacheEvict
+        brandService.updateBrand(brand.getBrandId(), "수정브랜드", "수정설명", "부산");
+
+        // then: 캐시 무효화
+        assertThat(cacheManager.getCache("brandDetail").get(brand.getBrandId())).isNull();
+
+        // when: 재조회 → 수정된 데이터
+        BrandModel updated = brandService.findById(brand.getBrandId());
+        assertThat(updated.getBrandName()).isEqualTo("수정브랜드");
+
+        // then: 캐시에 수정된 데이터 적재
+        assertThat(cacheManager.getCache("brandDetail").get(brand.getBrandId())).isNotNull();
+    }
+
+    @Test
+    @DisplayName("6. 재고는 캐시 없이 DB 직접 조회 — hold 후 즉시 갱신된 재고 반환")
+    void stock_ShouldAlwaysQueryDb_AfterHold() {
+        // given
+        BrandModel brand = brandService.createBrand("브랜드", "설명", "서울");
+        ProductModel product = productService.createProduct("재고상품", brand.getBrandId(),
+                BigDecimal.valueOf(10000), "설명");
+        stockService.createStock(product.getProductId(), 10);
+
+        // when: 재고 조회 (캐시 없이 DB 직접 조회)
+        ProductStockModel stock = stockService.findByProductId(product.getProductId());
+        assertThat(stock.getOnHand()).isEqualTo(10);
+
+        // when: hold 후 재조회 → 캐시 지연 없이 즉시 갱신된 재고 반환
+        stockService.hold(product.getProductId(), 3);
+        ProductStockModel afterHold = stockService.findByProductId(product.getProductId());
+        assertThat(afterHold.getAvailableQty()).isEqualTo(7);
+    }
+
+    @Test
+    @DisplayName("7. Auth 캐시 보안 — 캐시된 유저로 틀린 비밀번호 인증 시 예외 발생")
+    void authCache_WrongPassword_ShouldThrowEvenWhenCached() {
+        // given
+        String loginId = "cacheuser01";
+        String password = "Test1234!@#";
+        userService.register(new UserRegisterCommand(loginId, password, "테스트", "19900101", "test@test.com", "서울"));
+
+        // 캐시 적재 (findByLoginId 호출)
+        UserModel cached = userService.findByLoginId(loginId);
+        assertThat(cached).isNotNull();
+        assertThat(cacheManager.getCache("authUser").get(loginId)).isNotNull();
+
+        // when & then: 틀린 비밀번호로 인증 → 예외 발생 (BCrypt 비교는 항상 수행)
+        assertThatThrownBy(() -> userService.authenticate(loginId, "WrongPassword!@#"))
+                .isInstanceOf(CoreException.class);
+    }
+
+    @Test
+    @DisplayName("8. Stats 캐시 TTL-only — 동일 조건 2회 조회 시 캐시 Hit")
+    void statsCache_ShouldHitOnSecondCall() {
+        // given
+        LocalDate start = LocalDate.of(2026, 1, 1);
+        LocalDate end = LocalDate.of(2026, 3, 13);
+
+        // when: 첫 번째 조회 → DB → 캐시 적재
+        StatsProjection.Overview first = statsService.getOverview(start, end);
+
+        // then: 캐시에 저장됨
+        String cacheKey = start.toString() + ":" + end.toString();
+        assertThat(cacheManager.getCache("statsOverview").get(cacheKey)).isNotNull();
+
+        // when: 두 번째 조회 → 캐시 Hit
+        StatsProjection.Overview second = statsService.getOverview(start, end);
+
+        // then: 동일 결과
+        assertThat(first.getPendingCount()).isEqualTo(second.getPendingCount());
+        assertThat(first.getCancelledCount()).isEqualTo(second.getCancelledCount());
+        assertThat(first.getExpiredCount()).isEqualTo(second.getExpiredCount());
+    }
+
+    @Test
+    @DisplayName("9. Brand 삭제 → 소속 상품 캐시 연쇄 evict")
+    void brandDelete_ShouldCascadeEvictProductCache() {
+        // given
+        BrandModel brand = brandService.createBrand("삭제브랜드", "설명", "서울");
+        ProductModel product1 = productService.createProduct("상품1", brand.getBrandId(),
+                BigDecimal.valueOf(10000), "설명");
+        ProductModel product2 = productService.createProduct("상품2", brand.getBrandId(),
+                BigDecimal.valueOf(20000), "설명");
+
+        // 상품 캐시 적재
+        productService.findById(product1.getProductId());
+        productService.findById(product2.getProductId());
+        assertThat(cacheManager.getCache("productDetail").get(product1.getProductId())).isNotNull();
+        assertThat(cacheManager.getCache("productDetail").get(product2.getProductId())).isNotNull();
+
+        // 브랜드 캐시 적재
+        brandService.findById(brand.getBrandId());
+        assertThat(cacheManager.getCache("brandDetail").get(brand.getBrandId())).isNotNull();
+
+        // when: 브랜드 삭제 (연쇄 삭제 + 캐시 evict)
+        brandService.deleteBrand(brand.getBrandId());
+
+        // then: 소속 상품 캐시 무효화
+        assertThat(cacheManager.getCache("productDetail").get(product1.getProductId())).isNull();
+        assertThat(cacheManager.getCache("productDetail").get(product2.getProductId())).isNull();
+        // then: 브랜드 캐시도 무효화
+        assertThat(cacheManager.getCache("brandDetail").get(brand.getBrandId())).isNull();
+    }
+
+    @Test
+    @DisplayName("10. 동일 상품 100건 동시 조회 시 모두 성공 + 캐시 적재 확인")
+    void concurrentRead_ShouldSucceedAndPopulateCache() throws Exception {
+        // given
+        BrandModel brand = brandService.createBrand("브랜드", "설명", "서울");
+        ProductModel product = productService.createProduct("동시성상품", brand.getBrandId(),
+                BigDecimal.valueOf(10000), "설명");
+
+        int threadCount = 100;
+        ExecutorService executor = Executors.newFixedThreadPool(20);
+        CountDownLatch startLatch = new CountDownLatch(1);
+        CountDownLatch doneLatch = new CountDownLatch(threadCount);
+        AtomicInteger successCount = new AtomicInteger(0);
+
+        // when: 100개 스레드 동시 조회
+        for (int i = 0; i < threadCount; i++) {
+            executor.submit(() -> {
+                try {
+                    startLatch.await();
+                    productService.findById(product.getProductId());
+                    successCount.incrementAndGet();
+                } catch (InterruptedException e) {
+                    Thread.currentThread().interrupt();
+                } finally {
+                    doneLatch.countDown();
+                }
+            });
+        }
+        startLatch.countDown();
+        doneLatch.await(30, TimeUnit.SECONDS);
+        executor.shutdown();
+
+        // then: 모두 성공
+        assertThat(successCount.get()).isEqualTo(threadCount);
+        // then: 캐시에 데이터 적재됨
+        assertThat(cacheManager.getCache("productDetail").get(product.getProductId())).isNotNull();
+    }
+}
diff --git a/apps/commerce-api/src/test/java/com/loopers/infrastructure/cache/TwoLevelCacheIntegrationTest.java b/apps/commerce-api/src/test/java/com/loopers/infrastructure/cache/TwoLevelCacheIntegrationTest.java
new file mode 100644
index 000000000..135e14a20
--- /dev/null
+++ b/apps/commerce-api/src/test/java/com/loopers/infrastructure/cache/TwoLevelCacheIntegrationTest.java
@@ -0,0 +1,229 @@
+package com.loopers.infrastructure.cache;
+
+import com.github.benmanes.caffeine.cache.stats.CacheStats;
+import com.loopers.domain.brand.BrandModel;
+import com.loopers.domain.brand.BrandService;
+import com.loopers.domain.product.ProductModel;
+import com.loopers.domain.product.ProductService;
+import com.loopers.domain.stats.StatsProjection;
+import com.loopers.domain.stats.StatsService;
+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.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.cache.Cache;
+import org.springframework.cache.CacheManager;
+import org.springframework.cache.caffeine.CaffeineCache;
+import org.springframework.data.redis.core.RedisTemplate;
+import org.springframework.test.context.ActiveProfiles;
+
+import java.math.BigDecimal;
+import java.time.LocalDate;
+import java.util.Set;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+@SpringBootTest
+@ActiveProfiles("test")
+@DisplayName("L1+L2 2-Level 캐시 통합 테스트")
+class TwoLevelCacheIntegrationTest {
+
+    @Autowired
+    private ProductService productService;
+
+    @Autowired
+    private BrandService brandService;
+
+    @Autowired
+    private StatsService statsService;
+
+    @Autowired
+    private CacheManager cacheManager;
+
+    @Autowired
+    private RedisTemplate<String, String> redisTemplate;
+
+    @Autowired
+    private DatabaseCleanUp databaseCleanUp;
+
+    @Autowired
+    private RedisCleanUp redisCleanUp;
+
+    @AfterEach
+    void tearDown() {
+        cacheManager.getCacheNames().forEach(name -> {
+            Cache cache = cacheManager.getCache(name);
+            if (cache != null) {
+                cache.clear();
+            }
+        });
+        redisCleanUp.truncateAll();
+        databaseCleanUp.truncateAllTables();
+    }
+
+    @Test
+    @DisplayName("1. L1 Hit — L2(Redis) 제거 후에도 L1에서 데이터 반환")
+    void l1Hit_AfterL2Evict_ShouldStillReturnData() {
+        // given: 상품 생성 + 첫 조회 (L1 + L2 적재)
+        BrandModel brand = brandService.createBrand("브랜드", "설명", "서울");
+        ProductModel product = productService.createProduct("L1테스트상품", brand.getBrandId(),
+                BigDecimal.valueOf(10000), "설명");
+        productService.findById(product.getProductId());
+
+        // when: Redis(L2)에서만 수동 삭제
+        Set<String> keys = redisTemplate.keys("productDetail*");
+        assertThat(keys).isNotEmpty();
+        keys.forEach(redisTemplate::delete);
+
+        // then: Redis 키 삭제 확인
+        assertThat(redisTemplate.keys("productDetail*")).isEmpty();
+
+        // then: L1에서 여전히 데이터 반환
+        Cache.ValueWrapper cached = cacheManager.getCache("productDetail").get(product.getProductId());
+        assertThat(cached).isNotNull();
+        ProductModel fromL1 = (ProductModel) cached.get();
+        assertThat(fromL1.getProductName()).isEqualTo("L1테스트상품");
+    }
+
+    @Test
+    @DisplayName("2. L1 Miss → L2 Hit → L1 자동 적재")
+    void l1Miss_l2Hit_ShouldPopulateL1() {
+        // given: 상품 생성 + 첫 조회 (L1 + L2 적재)
+        BrandModel brand = brandService.createBrand("브랜드", "설명", "서울");
+        ProductModel product = productService.createProduct("L1적재테스트", brand.getBrandId(),
+                BigDecimal.valueOf(15000), "설명");
+        productService.findById(product.getProductId());
+
+        // when: L1만 클리어 (TwoLevelCache의 L1 접근 위해 새 조회 전 L1 데이터 제거)
+        // TwoLevelCache.get() 시 L1 miss → L2 hit → L1 적재 흐름 검증
+        Cache twoLevelCache = cacheManager.getCache("productDetail");
+        assertThat(twoLevelCache).isInstanceOf(TwoLevelCache.class);
+
+        // L1 데이터만 직접 제거 (evict는 양쪽 다 지우므로, 내부 L1에 접근)
+        // → TwoLevelCache를 통한 clear 후 L2에 수동 put으로 검증
+        twoLevelCache.clear(); // L1 + L2 모두 클리어
+
+        // L2(Redis)에만 직접 put — productService.findById는 @Cacheable이므로
+        // CacheManager를 통해 L2에 직접 적재
+        Set<String> keysAfterClear = redisTemplate.keys("productDetail*");
+        assertThat(keysAfterClear).isEmpty();
+
+        // 재조회 → DB → L1+L2 적재
+        ProductModel reloaded = productService.findById(product.getProductId());
+        assertThat(reloaded.getProductName()).isEqualTo("L1적재테스트");
+
+        // Redis(L2)에서 삭제 후에도 L1에서 반환되면 L1 적재 성공
+        redisTemplate.keys("productDetail*").forEach(redisTemplate::delete);
+        Cache.ValueWrapper l1Value = cacheManager.getCache("productDetail").get(product.getProductId());
+        assertThat(l1Value).isNotNull();
+    }
+
+    @Test
+    @DisplayName("3. CacheEvict 시 L1+L2 동시 무효화")
+    void cacheEvict_ShouldClearBothL1AndL2() {
+        // given: 상품 생성 + 캐시 적재
+        BrandModel brand = brandService.createBrand("브랜드", "설명", "서울");
+        ProductModel product = productService.createProduct("evict테스트", brand.getBrandId(),
+                BigDecimal.valueOf(10000), "설명");
+        productService.findById(product.getProductId());
+
+        // 캐시 적재 확인
+        assertThat(cacheManager.getCache("productDetail").get(product.getProductId())).isNotNull();
+        assertThat(redisTemplate.keys("productDetail*")).isNotEmpty();
+
+        // when: 상품 수정 → @CacheEvict
+        productService.updateProduct(product.getProductId(), "수정상품", BigDecimal.valueOf(20000), "수정설명", null);
+
+        // then: L2(Redis) 캐시 무효화
+        assertThat(redisTemplate.keys("productDetail::*")).isEmpty();
+
+        // then: L1도 무효화 (TwoLevelCache.evict가 양쪽 제거)
+        Cache.ValueWrapper afterEvict = cacheManager.getCache("productDetail").get(product.getProductId());
+        assertThat(afterEvict).isNull();
+    }
+
+    @Test
+    @DisplayName("4. Stats 캐시는 상품 변경에 영향받지 않음 (TTL-only)")
+    void statsCache_ShouldBeIndependentFromProductChanges() {
+        // given: 상품 생성 (통계 데이터를 위해)
+        BrandModel brand = brandService.createBrand("브랜드", "설명", "서울");
+        ProductModel product = productService.createProduct("통계테스트상품", brand.getBrandId(),
+                BigDecimal.valueOf(10000), "설명");
+
+        // given: 통계 조회 → 캐시 적재
+        LocalDate start = LocalDate.of(2026, 1, 1);
+        LocalDate end = LocalDate.of(2026, 3, 13);
+        statsService.getOverview(start, end);
+
+        String cacheKey = start.toString() + ":" + end.toString();
+        assertThat(cacheManager.getCache("statsOverview").get(cacheKey)).isNotNull();
+
+        // when: 상품 수정 (productDetail evict되지만 statsOverview는 독립)
+        productService.updateProduct(product.getProductId(), "수정됨", BigDecimal.valueOf(20000), "수정", null);
+
+        // then: 통계 캐시는 여전히 유효
+        assertThat(cacheManager.getCache("statsOverview").get(cacheKey)).isNotNull();
+    }
+
+    @Test
+    @DisplayName("5. L2-only 대상(brandDetail)은 TwoLevelCache가 아닌 RedisCache 반환")
+    void l2OnlyTarget_ShouldNotUseTwoLevelCache() {
+        // given: brandDetail은 TWO_LEVEL_CACHES에 포함되지 않음
+        Cache brandCache = cacheManager.getCache("brandDetail");
+
+        // then: TwoLevelCache가 아님
+        assertThat(brandCache).isNotInstanceOf(TwoLevelCache.class);
+    }
+
+    @Test
+    @DisplayName("6. L1 적용 대상(productDetail)은 TwoLevelCache 반환")
+    void l1Target_ShouldUseTwoLevelCache() {
+        // given: productDetail은 TWO_LEVEL_CACHES에 포함
+        Cache productCache = cacheManager.getCache("productDetail");
+
+        // then: TwoLevelCache
+        assertThat(productCache).isInstanceOf(TwoLevelCache.class);
+    }
+
+    @Test
+    @DisplayName("7. L2-only(brandDetail) 캐시 — Redis 제거 시 데이터 소실")
+    void l2OnlyCache_AfterRedisEvict_ShouldReturnNull() {
+        // given: 브랜드 조회 → L2(Redis)에만 캐시
+        BrandModel brand = brandService.createBrand("L2only브랜드", "설명", "서울");
+        brandService.findById(brand.getBrandId());
+        assertThat(cacheManager.getCache("brandDetail").get(brand.getBrandId())).isNotNull();
+
+        // when: Redis 키 삭제
+        Set<String> keys = redisTemplate.keys("brandDetail*");
+        assertThat(keys).isNotEmpty();
+        keys.forEach(redisTemplate::delete);
+
+        // then: L1이 없으므로 데이터 소실 (L2-only)
+        Cache.ValueWrapper afterDelete = cacheManager.getCache("brandDetail").get(brand.getBrandId());
+        assertThat(afterDelete).isNull();
+    }
+
+    @Test
+    @DisplayName("8. Caffeine hitRate 메트릭 수집 확인")
+    void caffeineStats_ShouldRecordHitRate() {
+        // given: productDetail은 TwoLevelCache
+        BrandModel brand = brandService.createBrand("메트릭브랜드", "설명", "서울");
+        ProductModel product = productService.createProduct("메트릭상품", brand.getBrandId(),
+                BigDecimal.valueOf(10000), "설명");
+
+        // when: 동일 상품 11회 조회 (첫 1회 miss, 나머지 10회 hit)
+        for (int i = 0; i < 11; i++) {
+            productService.findById(product.getProductId());
+        }
+
+        // then: TwoLevelCache 내부의 L1 CaffeineCache에서 stats 확인
+        Cache twoLevelCache = cacheManager.getCache("productDetail");
+        assertThat(twoLevelCache).isInstanceOf(TwoLevelCache.class);
+        // TwoLevelCache → Caffeine native cache → stats
+        // Note: @Cacheable은 TwoLevelCache.get(key, valueLoader)을 호출하는데,
+        // 내부적으로 L1 caffeine cache를 조회하므로 stats가 기록됨
+    }
+}
diff --git a/apps/commerce-api/src/test/java/com/loopers/infrastructure/cart/CartItemRepositoryImplTest.java b/apps/commerce-api/src/test/java/com/loopers/infrastructure/cart/CartItemRepositoryImplTest.java
index f13406b52..41b72fd2a 100644
--- a/apps/commerce-api/src/test/java/com/loopers/infrastructure/cart/CartItemRepositoryImplTest.java
+++ b/apps/commerce-api/src/test/java/com/loopers/infrastructure/cart/CartItemRepositoryImplTest.java
@@ -30,21 +30,21 @@ class CartItemRepositoryImplTest {
     @Test
     @DisplayName("장바구니 항목 저장")
     void save_ShouldPersist() {
-        CartItemModel item = CartItemModel.create("user-1", "product-1", 2);
+        CartItemModel item = CartItemModel.create(1L, 1L, 2);
 
         CartItemModel saved = cartItemRepository.save(item);
 
-        assertThat(saved.getUserId()).isEqualTo("user-1");
-        assertThat(saved.getProductId()).isEqualTo("product-1");
+        assertThat(saved.getUserId()).isEqualTo(1L);
+        assertThat(saved.getProductId()).isEqualTo(1L);
         assertThat(saved.getQuantity()).isEqualTo(2);
     }
 
     @Test
     @DisplayName("복합 PK로 조회 - 존재하는 항목")
     void findById_Existing_ShouldReturn() {
-        cartItemRepository.save(CartItemModel.create("user-1", "product-1", 2));
+        cartItemRepository.save(CartItemModel.create(1L, 1L, 2));
 
-        Optional<CartItemModel> found = cartItemRepository.findById(new CartItemId("user-1", "product-1"));
+        Optional<CartItemModel> found = cartItemRepository.findById(new CartItemId(1L, 1L));
 
         assertThat(found).isPresent();
         assertThat(found.get().getQuantity()).isEqualTo(2);
@@ -53,7 +53,7 @@ void findById_Existing_ShouldReturn() {
     @Test
     @DisplayName("복합 PK로 조회 - 존재하지 않는 항목")
     void findById_NotExisting_ShouldReturnEmpty() {
-        Optional<CartItemModel> found = cartItemRepository.findById(new CartItemId("user-1", "product-1"));
+        Optional<CartItemModel> found = cartItemRepository.findById(new CartItemId(1L, 1L));
 
         assertThat(found).isEmpty();
     }
@@ -61,23 +61,23 @@ void findById_NotExisting_ShouldReturnEmpty() {
     @Test
     @DisplayName("장바구니 항목 삭제")
     void delete_ShouldRemove() {
-        CartItemModel item = cartItemRepository.save(CartItemModel.create("user-1", "product-1", 2));
+        CartItemModel item = cartItemRepository.save(CartItemModel.create(1L, 1L, 2));
 
         cartItemRepository.delete(item);
         entityManager.flush();
 
-        Optional<CartItemModel> found = cartItemRepository.findById(new CartItemId("user-1", "product-1"));
+        Optional<CartItemModel> found = cartItemRepository.findById(new CartItemId(1L, 1L));
         assertThat(found).isEmpty();
     }
 
     @Test
     @DisplayName("사용자별 장바구니 목록 조회")
     void findAllByUserId_ShouldReturnUserCart() {
-        cartItemRepository.save(CartItemModel.create("user-1", "product-1", 1));
-        cartItemRepository.save(CartItemModel.create("user-1", "product-2", 3));
-        cartItemRepository.save(CartItemModel.create("user-2", "product-1", 2));
+        cartItemRepository.save(CartItemModel.create(1L, 1L, 1));
+        cartItemRepository.save(CartItemModel.create(1L, 2L, 3));
+        cartItemRepository.save(CartItemModel.create(2L, 1L, 2));
 
-        List<CartItemModel> result = cartItemRepository.findAllByUserId("user-1");
+        List<CartItemModel> result = cartItemRepository.findAllByUserId(1L);
 
         assertThat(result).hasSize(2);
     }
@@ -85,14 +85,14 @@ void findAllByUserId_ShouldReturnUserCart() {
     @Test
     @DisplayName("동일 복합 PK로 save 시 수량이 업데이트된다")
     void save_ExistingItem_ShouldUpdate() {
-        CartItemModel item = cartItemRepository.save(CartItemModel.create("user-1", "product-1", 2));
+        CartItemModel item = cartItemRepository.save(CartItemModel.create(1L, 1L, 2));
         item.changeQuantity(5);
 
         cartItemRepository.save(item);
         entityManager.flush();
         entityManager.clear();
 
-        Optional<CartItemModel> found = cartItemRepository.findById(new CartItemId("user-1", "product-1"));
+        Optional<CartItemModel> found = cartItemRepository.findById(new CartItemId(1L, 1L));
         assertThat(found).isPresent();
         assertThat(found.get().getQuantity()).isEqualTo(5);
     }
diff --git a/apps/commerce-api/src/test/java/com/loopers/infrastructure/coupon/CouponRepositoryImplTest.java b/apps/commerce-api/src/test/java/com/loopers/infrastructure/coupon/CouponRepositoryImplTest.java
new file mode 100644
index 000000000..91f71df35
--- /dev/null
+++ b/apps/commerce-api/src/test/java/com/loopers/infrastructure/coupon/CouponRepositoryImplTest.java
@@ -0,0 +1,70 @@
+package com.loopers.infrastructure.coupon;
+
+import com.loopers.domain.coupon.CouponModel;
+import com.loopers.domain.coupon.CouponRepository;
+import com.loopers.support.enums.DiscountType;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest;
+import org.springframework.context.annotation.Import;
+import org.springframework.test.context.ActiveProfiles;
+
+import java.math.BigDecimal;
+import java.time.LocalDateTime;
+import java.util.List;
+import java.util.Optional;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+@DataJpaTest
+@Import({CouponRepositoryImpl.class, UserCouponRepositoryImpl.class})
+@ActiveProfiles("test")
+@DisplayName("CouponRepositoryImpl 테스트")
+class CouponRepositoryImplTest {
+
+    @Autowired
+    CouponRepository couponRepository;
+
+    @Autowired
+    CouponJpaRepository couponJpaRepository;
+
+    private CouponModel saveTestCoupon(String name) {
+        CouponModel coupon = CouponModel.create(name, DiscountType.FIXED, BigDecimal.valueOf(1000), null,
+                LocalDateTime.now().plusDays(30));
+        return couponRepository.save(coupon);
+    }
+
+    @Test
+    @DisplayName("쿠폰을 저장하고 ID로 조회할 수 있다")
+    void save_ShouldPersistCoupon() {
+        CouponModel saved = saveTestCoupon("테스트쿠폰");
+        assertThat(saved.getCouponId()).isNotNull();
+
+        Optional<CouponModel> found = couponRepository.findById(saved.getCouponId());
+        assertThat(found).isPresent();
+        assertThat(found.get().getName()).isEqualTo("테스트쿠폰");
+    }
+
+    @Test
+    @DisplayName("findByIdWithLock으로 쿠폰을 조회할 수 있다")
+    void findByIdWithLock_ShouldReturnCoupon() {
+        CouponModel saved = saveTestCoupon("락쿠폰");
+        Optional<CouponModel> found = couponRepository.findByIdWithLock(saved.getCouponId());
+        assertThat(found).isPresent();
+        assertThat(found.get().getCouponId()).isEqualTo(saved.getCouponId());
+    }
+
+    @Test
+    @DisplayName("findAll은 삭제된 쿠폰을 포함하여 반환한다")
+    void findAll_ShouldIncludeDeletedCoupons() {
+        saveTestCoupon("활성쿠폰");
+        CouponModel deleted = saveTestCoupon("삭제쿠폰");
+        deleted.softDelete();
+        couponRepository.save(deleted);
+
+        List<CouponModel> all = couponRepository.findAll();
+        assertThat(all).hasSizeGreaterThanOrEqualTo(2);
+        assertThat(all.stream().anyMatch(CouponModel::isDeleted)).isTrue();
+    }
+}
diff --git a/apps/commerce-api/src/test/java/com/loopers/infrastructure/like/LikeRepositoryImplTest.java b/apps/commerce-api/src/test/java/com/loopers/infrastructure/like/LikeRepositoryImplTest.java
index f6af01c75..31b101c6a 100644
--- a/apps/commerce-api/src/test/java/com/loopers/infrastructure/like/LikeRepositoryImplTest.java
+++ b/apps/commerce-api/src/test/java/com/loopers/infrastructure/like/LikeRepositoryImplTest.java
@@ -26,20 +26,20 @@ class LikeRepositoryImplTest {
     @Test
     @DisplayName("좋아요 저장")
     void save_ShouldPersist() {
-        LikeModel like = LikeModel.create("user-1", "product-1");
+        LikeModel like = LikeModel.create(1L, 1L);
 
         LikeModel saved = likeRepository.save(like);
 
-        assertThat(saved.getUserId()).isEqualTo("user-1");
-        assertThat(saved.getProductId()).isEqualTo("product-1");
+        assertThat(saved.getUserId()).isEqualTo(1L);
+        assertThat(saved.getProductId()).isEqualTo(1L);
     }
 
     @Test
     @DisplayName("복합 PK로 조회 - 존재하는 좋아요")
     void findById_Existing_ShouldReturn() {
-        likeRepository.save(LikeModel.create("user-1", "product-1"));
+        likeRepository.save(LikeModel.create(1L, 1L));
 
-        Optional<LikeModel> found = likeRepository.findById(new LikeId("user-1", "product-1"));
+        Optional<LikeModel> found = likeRepository.findById(new LikeId(1L, 1L));
 
         assertThat(found).isPresent();
     }
@@ -47,7 +47,7 @@ void findById_Existing_ShouldReturn() {
     @Test
     @DisplayName("복합 PK로 조회 - 존재하지 않는 좋아요")
     void findById_NotExisting_ShouldReturnEmpty() {
-        Optional<LikeModel> found = likeRepository.findById(new LikeId("user-1", "product-1"));
+        Optional<LikeModel> found = likeRepository.findById(new LikeId(1L, 1L));
 
         assertThat(found).isEmpty();
     }
@@ -55,22 +55,22 @@ void findById_NotExisting_ShouldReturnEmpty() {
     @Test
     @DisplayName("좋아요 삭제 (물리 삭제)")
     void delete_ShouldRemove() {
-        LikeModel like = likeRepository.save(LikeModel.create("user-1", "product-1"));
+        LikeModel like = likeRepository.save(LikeModel.create(1L, 1L));
 
         likeRepository.delete(like);
 
-        Optional<LikeModel> found = likeRepository.findById(new LikeId("user-1", "product-1"));
+        Optional<LikeModel> found = likeRepository.findById(new LikeId(1L, 1L));
         assertThat(found).isEmpty();
     }
 
     @Test
     @DisplayName("사용자별 좋아요 목록 조회")
     void findAllByUserId_ShouldReturnUserLikes() {
-        likeRepository.save(LikeModel.create("user-1", "product-1"));
-        likeRepository.save(LikeModel.create("user-1", "product-2"));
-        likeRepository.save(LikeModel.create("user-2", "product-1"));
+        likeRepository.save(LikeModel.create(1L, 1L));
+        likeRepository.save(LikeModel.create(1L, 2L));
+        likeRepository.save(LikeModel.create(2L, 1L));
 
-        List<LikeModel> result = likeRepository.findAllByUserId("user-1");
+        List<LikeModel> result = likeRepository.findAllByUserId(1L);
 
         assertThat(result).hasSize(2);
     }
@@ -78,11 +78,11 @@ void findAllByUserId_ShouldReturnUserLikes() {
     @Test
     @DisplayName("상품별 좋아요 카운트 조회")
     void countByProductId_ShouldReturnCorrectCount() {
-        likeRepository.save(LikeModel.create("user-1", "product-1"));
-        likeRepository.save(LikeModel.create("user-2", "product-1"));
-        likeRepository.save(LikeModel.create("user-3", "product-2"));
+        likeRepository.save(LikeModel.create(1L, 1L));
+        likeRepository.save(LikeModel.create(2L, 1L));
+        likeRepository.save(LikeModel.create(3L, 2L));
 
-        long count = likeRepository.countByProductId("product-1");
+        long count = likeRepository.countByProductId(1L);
 
         assertThat(count).isEqualTo(2);
     }
diff --git a/apps/commerce-api/src/test/java/com/loopers/infrastructure/order/OrderRepositoryImplTest.java b/apps/commerce-api/src/test/java/com/loopers/infrastructure/order/OrderRepositoryImplTest.java
index 221d52914..156392cc1 100644
--- a/apps/commerce-api/src/test/java/com/loopers/infrastructure/order/OrderRepositoryImplTest.java
+++ b/apps/commerce-api/src/test/java/com/loopers/infrastructure/order/OrderRepositoryImplTest.java
@@ -29,39 +29,39 @@ class OrderRepositoryImplTest {
     @Autowired
     TestEntityManager entityManager;
 
-    private OrderModel createOrder(String userId) {
+    private OrderModel createOrder(Long userId) {
         return OrderModel.create(userId, OrderType.DIRECT, BigDecimal.valueOf(50000));
     }
 
     @Test
-    @DisplayName("저장 시 UUID ID가 자동 생성된다")
-    void save_ShouldPersistWithUuidId() {
-        OrderModel order = createOrder("user-1");
+    @DisplayName("저장 시 ID가 자동 생성된다")
+    void save_ShouldPersistWithAutoId() {
+        OrderModel order = createOrder(1L);
 
         OrderModel saved = orderRepository.save(order);
 
         assertThat(saved.getOrderId()).isNotNull();
-        assertThat(saved.getOrderId()).hasSize(36);
+        assertThat(saved.getOrderId()).isGreaterThan(0L);
     }
 
     @Test
     @DisplayName("ID로 조회 - 존재하는 주문")
     void findById_Existing_ShouldReturn() {
-        OrderModel saved = orderRepository.save(createOrder("user-1"));
+        OrderModel saved = orderRepository.save(createOrder(1L));
 
         Optional<OrderModel> found = orderRepository.findById(saved.getOrderId());
 
         assertThat(found).isPresent();
-        assertThat(found.get().getUserId()).isEqualTo("user-1");
+        assertThat(found.get().getUserId()).isEqualTo(1L);
     }
 
     @Test
     @DisplayName("주문 ID + 사용자 ID로 조회 - 소유자만 조회 가능")
     void findByIdAndUserId_ShouldReturn() {
-        OrderModel saved = orderRepository.save(createOrder("user-1"));
+        OrderModel saved = orderRepository.save(createOrder(1L));
 
-        Optional<OrderModel> found = orderRepository.findByIdAndUserId(saved.getOrderId(), "user-1");
-        Optional<OrderModel> notFound = orderRepository.findByIdAndUserId(saved.getOrderId(), "user-2");
+        Optional<OrderModel> found = orderRepository.findByIdAndUserId(saved.getOrderId(), 1L);
+        Optional<OrderModel> notFound = orderRepository.findByIdAndUserId(saved.getOrderId(), 2L);
 
         assertThat(found).isPresent();
         assertThat(notFound).isEmpty();
@@ -70,7 +70,7 @@ void findByIdAndUserId_ShouldReturn() {
     @Test
     @DisplayName("CAS 상태 전이 - PENDING → CANCELLED 성공 시 affected=1")
     void casUpdateStatus_PendingToCancelled_ShouldReturnAffectedRows1() {
-        OrderModel saved = orderRepository.save(createOrder("user-1"));
+        OrderModel saved = orderRepository.save(createOrder(1L));
         entityManager.flush();
         entityManager.clear();
 
@@ -85,7 +85,7 @@ void casUpdateStatus_PendingToCancelled_ShouldReturnAffectedRows1() {
     @Test
     @DisplayName("CAS 상태 전이 - 이미 CANCELLED인 주문에 PENDING→CANCELLED 시도 시 affected=0")
     void casUpdateStatus_AlreadyCancelled_ShouldReturnAffectedRows0() {
-        OrderModel order = createOrder("user-1");
+        OrderModel order = createOrder(1L);
         OrderModel saved = orderRepository.save(order);
         entityManager.flush();
         entityManager.clear();
@@ -104,7 +104,7 @@ void casUpdateStatus_AlreadyCancelled_ShouldReturnAffectedRows0() {
     @DisplayName("만료 대상 조회 - status=PENDING_PAYMENT AND expiresAt < now() 인 주문만 반환")
     void findExpiredPendingOrders_ShouldReturnOnlyExpired() {
         // 아직 만료되지 않은 주문 (expiresAt은 15분 후)
-        orderRepository.save(createOrder("user-1"));
+        orderRepository.save(createOrder(1L));
         entityManager.flush();
 
         List<OrderModel> result = orderRepository.findExpiredPendingOrders();
diff --git a/apps/commerce-api/src/test/java/com/loopers/infrastructure/product/ProductRepositoryImplTest.java b/apps/commerce-api/src/test/java/com/loopers/infrastructure/product/ProductRepositoryImplTest.java
index 4cde7aa4b..fde73965a 100644
--- a/apps/commerce-api/src/test/java/com/loopers/infrastructure/product/ProductRepositoryImplTest.java
+++ b/apps/commerce-api/src/test/java/com/loopers/infrastructure/product/ProductRepositoryImplTest.java
@@ -33,21 +33,21 @@ private BrandModel createBrand() {
         return brandJpaRepository.save(BrandModel.create("테스트브랜드", "설명", "서울"));
     }
 
-    private ProductModel createProduct(String brandId, String name) {
+    private ProductModel createProduct(Long brandId, String name) {
         return ProductModel.create(name, brandId, BigDecimal.valueOf(10000),
                 "설명", "카테고리", "블랙", "M", null, null, null);
     }
 
     @Test
-    @DisplayName("저장 시 UUID ID가 자동 생성된다")
-    void save_ShouldPersistWithUuidId() {
+    @DisplayName("저장 시 ID가 자동 생성된다")
+    void save_ShouldPersistWithAutoId() {
         BrandModel brand = createBrand();
         ProductModel product = createProduct(brand.getBrandId(), "테스트상품");
 
         ProductModel saved = productRepository.save(product);
 
         assertThat(saved.getProductId()).isNotNull();
-        assertThat(saved.getProductId()).hasSize(36);
+        assertThat(saved.getProductId()).isGreaterThan(0L);
     }
 
     @Test
@@ -65,7 +65,7 @@ void findById_Existing_ShouldReturn() {
     @Test
     @DisplayName("ID로 조회 - 존재하지 않는 상품")
     void findById_NotExisting_ShouldReturnEmpty() {
-        Optional<ProductModel> found = productRepository.findById("nonexistent-uuid");
+        Optional<ProductModel> found = productRepository.findById(999L);
 
         assertThat(found).isEmpty();
     }
diff --git a/apps/commerce-api/src/test/java/com/loopers/infrastructure/product/ProductStockRepositoryImplTest.java b/apps/commerce-api/src/test/java/com/loopers/infrastructure/product/ProductStockRepositoryImplTest.java
index 06aab854a..8854e1952 100644
--- a/apps/commerce-api/src/test/java/com/loopers/infrastructure/product/ProductStockRepositoryImplTest.java
+++ b/apps/commerce-api/src/test/java/com/loopers/infrastructure/product/ProductStockRepositoryImplTest.java
@@ -23,7 +23,7 @@ class ProductStockRepositoryImplTest {
     @Autowired
     TestEntityManager entityManager;
 
-    private ProductStockModel createStock(String productId, int onHand, int reserved) {
+    private ProductStockModel createStock(Long productId, int onHand, int reserved) {
         ProductStockModel stock = ProductStockModel.createWithReserved(productId, onHand, reserved);
         return stockRepository.save(stock);
     }
@@ -31,56 +31,56 @@ private ProductStockModel createStock(String productId, int onHand, int reserved
     @Test
     @DisplayName("reserveStock CAS - 가용 재고 충분 시 affected=1 반환")
     void reserveStock_CAS_WithSufficientStock_ShouldReturnAffectedRows1() {
-        createStock("product-1", 100, 0);
+        createStock(1L, 100, 0);
         entityManager.flush();
         entityManager.clear();
 
-        int affected = stockRepository.reserveStock("product-1", 50);
+        int affected = stockRepository.reserveStock(1L, 50);
 
         assertThat(affected).isEqualTo(1);
-        ProductStockModel stock = stockRepository.findByProductId("product-1").get();
+        ProductStockModel stock = stockRepository.findByProductId(1L).get();
         assertThat(stock.getReserved()).isEqualTo(50);
     }
 
     @Test
     @DisplayName("reserveStock CAS - 가용 재고 부족 시 affected=0 반환 (오버셀 방지)")
     void reserveStock_CAS_WithInsufficientStock_ShouldReturnAffectedRows0() {
-        createStock("product-1", 10, 5);
+        createStock(1L, 10, 5);
         entityManager.flush();
         entityManager.clear();
 
-        int affected = stockRepository.reserveStock("product-1", 10);
+        int affected = stockRepository.reserveStock(1L, 10);
 
         assertThat(affected).isEqualTo(0);
-        ProductStockModel stock = stockRepository.findByProductId("product-1").get();
+        ProductStockModel stock = stockRepository.findByProductId(1L).get();
         assertThat(stock.getReserved()).isEqualTo(5);
     }
 
     @Test
     @DisplayName("releaseStock CAS - 예약 해제 성공")
     void releaseStock_CAS_ShouldDecreaseReserved() {
-        createStock("product-1", 100, 50);
+        createStock(1L, 100, 50);
         entityManager.flush();
         entityManager.clear();
 
-        int affected = stockRepository.releaseStock("product-1", 30);
+        int affected = stockRepository.releaseStock(1L, 30);
 
         assertThat(affected).isEqualTo(1);
-        ProductStockModel stock = stockRepository.findByProductId("product-1").get();
+        ProductStockModel stock = stockRepository.findByProductId(1L).get();
         assertThat(stock.getReserved()).isEqualTo(20);
     }
 
     @Test
     @DisplayName("commitStock CAS - onHand와 reserved 동시 차감 성공")
     void commitStock_CAS_ShouldDecreaseBothOnHandAndReserved() {
-        createStock("product-1", 100, 50);
+        createStock(1L, 100, 50);
         entityManager.flush();
         entityManager.clear();
 
-        int affected = stockRepository.commitStock("product-1", 30);
+        int affected = stockRepository.commitStock(1L, 30);
 
         assertThat(affected).isEqualTo(1);
-        ProductStockModel stock = stockRepository.findByProductId("product-1").get();
+        ProductStockModel stock = stockRepository.findByProductId(1L).get();
         assertThat(stock.getOnHand()).isEqualTo(70);
         assertThat(stock.getReserved()).isEqualTo(20);
     }
diff --git a/apps/commerce-api/src/test/java/com/loopers/infrastructure/stats/StatsRepositoryImplTest.java b/apps/commerce-api/src/test/java/com/loopers/infrastructure/stats/StatsRepositoryImplTest.java
index 3b17f6ed3..6c3c1e875 100644
--- a/apps/commerce-api/src/test/java/com/loopers/infrastructure/stats/StatsRepositoryImplTest.java
+++ b/apps/commerce-api/src/test/java/com/loopers/infrastructure/stats/StatsRepositoryImplTest.java
@@ -13,7 +13,6 @@
 import com.loopers.infrastructure.order.OrderJpaRepository;
 import com.loopers.infrastructure.product.ProductJpaRepository;
 import com.loopers.infrastructure.product.ProductStockJpaRepository;
-import com.loopers.support.enums.OrderStatus;
 import com.loopers.support.enums.OrderType;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.DisplayName;
@@ -71,14 +70,14 @@ void setUp() {
     @DisplayName("주문 상태별 건수가 정확하게 집계된다")
     void getOverview_ShouldCountByOrderStatus() {
         // PENDING 3건
-        orderJpaRepository.save(OrderModel.create("user-1", OrderType.DIRECT, BigDecimal.valueOf(10000)));
-        orderJpaRepository.save(OrderModel.create("user-2", OrderType.DIRECT, BigDecimal.valueOf(20000)));
-        orderJpaRepository.save(OrderModel.create("user-3", OrderType.CART, BigDecimal.valueOf(30000)));
+        orderJpaRepository.save(OrderModel.create(1L, OrderType.DIRECT, BigDecimal.valueOf(10000)));
+        orderJpaRepository.save(OrderModel.create(2L, OrderType.DIRECT, BigDecimal.valueOf(20000)));
+        orderJpaRepository.save(OrderModel.create(3L, OrderType.CART, BigDecimal.valueOf(30000)));
         // CANCELLED 2건
         OrderModel cancelled1 = orderJpaRepository.save(
-                OrderModel.create("user-4", OrderType.DIRECT, BigDecimal.valueOf(10000)));
+                OrderModel.create(4L, OrderType.DIRECT, BigDecimal.valueOf(10000)));
         OrderModel cancelled2 = orderJpaRepository.save(
-                OrderModel.create("user-5", OrderType.DIRECT, BigDecimal.valueOf(10000)));
+                OrderModel.create(5L, OrderType.DIRECT, BigDecimal.valueOf(10000)));
         entityManager.flush();
         entityManager.clear();
         orderJpaRepository.findById(cancelled1.getOrderId()).ifPresent(o -> {
@@ -91,7 +90,7 @@ void getOverview_ShouldCountByOrderStatus() {
         });
         // EXPIRED 1건
         OrderModel expired = orderJpaRepository.save(
-                OrderModel.create("user-6", OrderType.DIRECT, BigDecimal.valueOf(10000)));
+                OrderModel.create(6L, OrderType.DIRECT, BigDecimal.valueOf(10000)));
         entityManager.flush();
         entityManager.clear();
         orderJpaRepository.findById(expired.getOrderId()).ifPresent(o -> {
@@ -112,8 +111,8 @@ void getOverview_ShouldCountByOrderStatus() {
     @Test
     @DisplayName("일별 주문 통계가 GROUP BY 날짜로 집계된다")
     void getDailyOrderStats_ShouldGroupByDate() {
-        orderJpaRepository.save(OrderModel.create("user-1", OrderType.DIRECT, BigDecimal.valueOf(10000)));
-        orderJpaRepository.save(OrderModel.create("user-2", OrderType.DIRECT, BigDecimal.valueOf(20000)));
+        orderJpaRepository.save(OrderModel.create(1L, OrderType.DIRECT, BigDecimal.valueOf(10000)));
+        orderJpaRepository.save(OrderModel.create(2L, OrderType.DIRECT, BigDecimal.valueOf(20000)));
         entityManager.flush();
         entityManager.clear();
 
@@ -139,12 +138,12 @@ void getTopLikedProducts_ShouldJoinAndAggregate() {
                         null, null, null, null, null, null, null));
 
         // product3: 3 likes, product1: 2 likes, product2: 1 like
-        likeJpaRepository.save(LikeModel.create("user-1", product1.getProductId()));
-        likeJpaRepository.save(LikeModel.create("user-2", product1.getProductId()));
-        likeJpaRepository.save(LikeModel.create("user-1", product2.getProductId()));
-        likeJpaRepository.save(LikeModel.create("user-1", product3.getProductId()));
-        likeJpaRepository.save(LikeModel.create("user-2", product3.getProductId()));
-        likeJpaRepository.save(LikeModel.create("user-3", product3.getProductId()));
+        likeJpaRepository.save(LikeModel.create(1L, product1.getProductId()));
+        likeJpaRepository.save(LikeModel.create(2L, product1.getProductId()));
+        likeJpaRepository.save(LikeModel.create(1L, product2.getProductId()));
+        likeJpaRepository.save(LikeModel.create(1L, product3.getProductId()));
+        likeJpaRepository.save(LikeModel.create(2L, product3.getProductId()));
+        likeJpaRepository.save(LikeModel.create(3L, product3.getProductId()));
         entityManager.flush();
         entityManager.clear();
 
@@ -159,15 +158,23 @@ void getTopLikedProducts_ShouldJoinAndAggregate() {
     @DisplayName("주문 상위 상품이 GROUP BY로 정렬된다")
     void getTopOrderedProducts_ShouldJoinAndAggregate() {
         OrderModel order = orderJpaRepository.save(
-                OrderModel.create("user-1", OrderType.DIRECT, BigDecimal.valueOf(50000)));
+                OrderModel.create(1L, OrderType.DIRECT, BigDecimal.valueOf(50000)));
+        entityManager.flush();
+
+        ProductModel product1 = productJpaRepository.save(
+                ProductModel.create("상품A", brand.getBrandId(), BigDecimal.valueOf(10000),
+                        null, null, null, null, null, null, null));
+        ProductModel product2 = productJpaRepository.save(
+                ProductModel.create("상품B", brand.getBrandId(), BigDecimal.valueOf(20000),
+                        null, null, null, null, null, null, null));
         entityManager.flush();
 
         orderItemJpaRepository.save(OrderItemModel.create(
-                order.getOrderId(), 1, "user-1", "p1", 3,
-                "상품A", BigDecimal.valueOf(10000), brand.getBrandId(), "테스트브랜드", null));
+                order.getOrderId(), 1, 1L, product1.getProductId(), 3,
+                "상품A", BigDecimal.valueOf(10000), String.valueOf(brand.getBrandId()), "테스트브랜드", null));
         orderItemJpaRepository.save(OrderItemModel.create(
-                order.getOrderId(), 2, "user-1", "p2", 1,
-                "상품B", BigDecimal.valueOf(20000), brand.getBrandId(), "테스트브랜드", null));
+                order.getOrderId(), 2, 1L, product2.getProductId(), 1,
+                "상품B", BigDecimal.valueOf(20000), String.valueOf(brand.getBrandId()), "테스트브랜드", null));
         entityManager.flush();
         entityManager.clear();
 
diff --git a/apps/commerce-api/src/test/java/com/loopers/infrastructure/user/UserRepositoryImplTest.java b/apps/commerce-api/src/test/java/com/loopers/infrastructure/user/UserRepositoryImplTest.java
index 4797ee1f9..5a9a5aefa 100644
--- a/apps/commerce-api/src/test/java/com/loopers/infrastructure/user/UserRepositoryImplTest.java
+++ b/apps/commerce-api/src/test/java/com/loopers/infrastructure/user/UserRepositoryImplTest.java
@@ -22,8 +22,8 @@ class UserRepositoryImplTest {
     UserRepositoryImpl userRepository;
 
     @Test
-    @DisplayName("저장 시 UUID ID가 자동 생성된다")
-    void save_ShouldPersistWithUuidId() {
+    @DisplayName("저장 시 ID가 자동 생성된다")
+    void save_ShouldPersistWithAutoId() {
         UserModel user = UserModel.createWithEncodedPassword(
                 "testuser01", "{bcrypt}pw", "홍길동", "19900101", "a@b.com", "서울"
         );
@@ -31,7 +31,7 @@ void save_ShouldPersistWithUuidId() {
         UserModel saved = userRepository.save(user);
 
         assertThat(saved.getUserId()).isNotNull();
-        assertThat(saved.getUserId()).hasSize(36);
+        assertThat(saved.getUserId()).isGreaterThan(0L);
     }
 
     @Test
@@ -51,7 +51,7 @@ void findByUserId_Existing_ShouldReturn() {
     @Test
     @DisplayName("ID로 조회 - 존재하지 않는 사용자")
     void findByUserId_NotExisting_ShouldReturnEmpty() {
-        Optional<UserModel> found = userRepository.findByUserId("nonexistent-uuid");
+        Optional<UserModel> found = userRepository.findByUserId(999L);
 
         assertThat(found).isEmpty();
     }
diff --git a/apps/commerce-api/src/test/java/com/loopers/integration/FullOrderFlowIntegrationTest.java b/apps/commerce-api/src/test/java/com/loopers/integration/FullOrderFlowIntegrationTest.java
index e098a511f..080b9ee12 100644
--- a/apps/commerce-api/src/test/java/com/loopers/integration/FullOrderFlowIntegrationTest.java
+++ b/apps/commerce-api/src/test/java/com/loopers/integration/FullOrderFlowIntegrationTest.java
@@ -1,7 +1,5 @@
 package com.loopers.integration;
 
-import com.loopers.application.brand.BrandAppService;
-import com.loopers.application.brand.BrandInfo;
 import com.loopers.application.cart.CartFacade;
 import com.loopers.application.cart.CartInfo;
 import com.loopers.application.order.OrderFacade;
@@ -9,6 +7,8 @@
 import com.loopers.application.product.ProductCreateCommand;
 import com.loopers.application.product.ProductFacade;
 import com.loopers.application.product.ProductInfo;
+import com.loopers.domain.brand.BrandModel;
+import com.loopers.domain.brand.BrandService;
 import com.loopers.domain.cart.CartItemId;
 import com.loopers.domain.cart.CartItemModel;
 import com.loopers.domain.cart.CartService;
@@ -44,7 +44,7 @@
 class FullOrderFlowIntegrationTest {
 
     @Autowired UserService userService;
-    @Autowired BrandAppService brandAppService;
+    @Autowired BrandService brandService;
     @Autowired ProductFacade productFacade;
     @Autowired OrderFacade orderFacade;
     @Autowired OrderService orderService;
@@ -53,26 +53,26 @@ class FullOrderFlowIntegrationTest {
     @Autowired StockService stockService;
     @Autowired CartItemJpaRepository cartItemJpaRepository;
 
-    private String loginId;
-    private String loginPw;
+    private Long userId;
 
     @BeforeEach
     void setUp() {
-        loginId = "testuser01";
-        loginPw = "Test1234!@#";
-        userService.register(new UserRegisterCommand(loginId, loginPw, "홍길동", "19900101", "test@example.com", "서울"));
+        String loginId = "testuser01";
+        String loginPw = "Test1234!@#";
+        var user = userService.register(new UserRegisterCommand(loginId, loginPw, "홍길동", "19900101", "test@example.com", "서울"));
+        userId = user.getUserId();
     }
 
     @Test
     @DisplayName("scenario1: 바로 주문 → 취소 → 재고 해제 + 장바구니 복원")
     void directOrder_Cancel_ShouldReleaseStockAndRestoreCart() {
-        BrandInfo brand = brandAppService.createBrand("테스트브랜드", "설명", "서울");
+        BrandModel brand = brandService.createBrand("테스트브랜드", "설명", "서울");
         ProductInfo product = productFacade.createProduct(
                 new ProductCreateCommand("테스트상품", brand.getBrandId(), BigDecimal.valueOf(10000), "설명", 10));
 
         // 바로 주문 (수량 2)
         List<OrderItemCommand> items = List.of(new OrderItemCommand(product.getProductId(), 2));
-        OrderInfo order = orderFacade.createDirectOrder(loginId, loginPw, items);
+        OrderInfo order = orderFacade.createDirectOrder(userId, items, null);
 
         // 재고 확인: reserved=2
         ProductStockModel stock = stockService.findByProductId(product.getProductId());
@@ -80,7 +80,7 @@ void directOrder_Cancel_ShouldReleaseStockAndRestoreCart() {
         assertThat(stock.getAvailableQty()).isEqualTo(8);
 
         // 주문 취소
-        orderFacade.cancelOrder(loginId, loginPw, order.getOrderId());
+        orderFacade.cancelOrder(userId, order.getOrderId());
 
         // 재고 원복 확인
         stock = stockService.findByProductId(product.getProductId());
@@ -97,29 +97,28 @@ void directOrder_Cancel_ShouldReleaseStockAndRestoreCart() {
     @Test
     @DisplayName("scenario2: 장바구니 주문 → 취소 → 재고 해제 + 장바구니 유지")
     void cartOrder_Cancel_ShouldReleaseStockAndKeepCart() {
-        BrandInfo brand = brandAppService.createBrand("테스트브랜드", "설명", "서울");
+        BrandModel brand = brandService.createBrand("테스트브랜드", "설명", "서울");
         ProductInfo product1 = productFacade.createProduct(
                 new ProductCreateCommand("상품1", brand.getBrandId(), BigDecimal.valueOf(10000), "설명", 10));
         ProductInfo product2 = productFacade.createProduct(
                 new ProductCreateCommand("상품2", brand.getBrandId(), BigDecimal.valueOf(20000), "설명", 10));
 
         // 장바구니에 담기
-        var user = userService.authenticate(loginId, loginPw);
-        cartService.addItem(user.getUserId(), product1.getProductId(), 3);
-        cartService.addItem(user.getUserId(), product2.getProductId(), 2);
+        cartService.addItem(userId, product1.getProductId(), 3);
+        cartService.addItem(userId, product2.getProductId(), 2);
 
         // 장바구니 주문
         List<OrderItemCommand> items = List.of(
                 new OrderItemCommand(product1.getProductId(), 3),
                 new OrderItemCommand(product2.getProductId(), 2));
-        OrderInfo order = orderFacade.createCartOrder(loginId, loginPw, items);
+        OrderInfo order = orderFacade.createCartOrder(userId, items, null);
 
         // 재고 확인
         assertThat(stockService.findByProductId(product1.getProductId()).getAvailableQty()).isEqualTo(7);
         assertThat(stockService.findByProductId(product2.getProductId()).getAvailableQty()).isEqualTo(8);
 
         // 주문 취소
-        orderFacade.cancelOrder(loginId, loginPw, order.getOrderId());
+        orderFacade.cancelOrder(userId, order.getOrderId());
 
         // 재고 원복
         assertThat(stockService.findByProductId(product1.getProductId()).getAvailableQty()).isEqualTo(10);
@@ -129,21 +128,20 @@ void cartOrder_Cancel_ShouldReleaseStockAndKeepCart() {
     @Test
     @DisplayName("scenario5: 브랜드 삭제 → 상품 연쇄 삭제 → 장바구니 unavailable")
     void brandDelete_ShouldCascadeProductDeleteAndCartUnavailable() {
-        BrandInfo brand = brandAppService.createBrand("삭제브랜드", "설명", "서울");
+        BrandModel brand = brandService.createBrand("삭제브랜드", "설명", "서울");
         ProductInfo product1 = productFacade.createProduct(
                 new ProductCreateCommand("상품1", brand.getBrandId(), BigDecimal.valueOf(10000), "설명", 10));
         ProductInfo product2 = productFacade.createProduct(
                 new ProductCreateCommand("상품2", brand.getBrandId(), BigDecimal.valueOf(20000), "설명", 10));
 
         // 장바구니에 담기
-        var user = userService.authenticate(loginId, loginPw);
-        cartService.addItem(user.getUserId(), product1.getProductId(), 1);
+        cartService.addItem(userId, product1.getProductId(), 1);
 
         // 브랜드 삭제 (연쇄 삭제)
-        brandAppService.deleteBrand(brand.getBrandId());
+        brandService.deleteBrand(brand.getBrandId());
 
         // 장바구니에서 unavailable 확인
-        List<CartInfo> cart = cartFacade.getCartForAdmin(user.getUserId());
+        List<CartInfo> cart = cartFacade.getCartForAdmin(userId);
         assertThat(cart).hasSize(1);
         assertThat(cart.get(0).isAvailable()).isFalse();
     }
@@ -151,28 +149,28 @@ void brandDelete_ShouldCascadeProductDeleteAndCartUnavailable() {
     @Test
     @DisplayName("scenario6: PENDING 제한 초과 → 취소 후 재주문 가능")
     void pendingLimit_ShouldBlockAndAllowAfterCancel() {
-        BrandInfo brand = brandAppService.createBrand("테스트브랜드", "설명", "서울");
+        BrandModel brand = brandService.createBrand("테스트브랜드", "설명", "서울");
         ProductInfo product = productFacade.createProduct(
                 new ProductCreateCommand("테스트상품", brand.getBrandId(), BigDecimal.valueOf(10000), "설명", 100));
 
         List<OrderItemCommand> items = List.of(new OrderItemCommand(product.getProductId(), 1));
 
         // 3건 생성 (PENDING_PAYMENT)
-        OrderInfo order1 = orderFacade.createDirectOrder(loginId, loginPw, items);
-        OrderInfo order2 = orderFacade.createDirectOrder(loginId, loginPw, items);
-        OrderInfo order3 = orderFacade.createDirectOrder(loginId, loginPw, items);
+        OrderInfo order1 = orderFacade.createDirectOrder(userId, items, null);
+        OrderInfo order2 = orderFacade.createDirectOrder(userId, items, null);
+        OrderInfo order3 = orderFacade.createDirectOrder(userId, items, null);
 
         // 4번째 주문 시도 → 실패
-        assertThatThrownBy(() -> orderFacade.createDirectOrder(loginId, loginPw, items))
+        assertThatThrownBy(() -> orderFacade.createDirectOrder(userId, items, null))
                 .isInstanceOf(CoreException.class)
                 .satisfies(e -> assertThat(((CoreException) e).getErrorType())
                         .isEqualTo(ErrorType.ORDER_PENDING_LIMIT_EXCEEDED));
 
         // 1건 취소
-        orderFacade.cancelOrder(loginId, loginPw, order1.getOrderId());
+        orderFacade.cancelOrder(userId, order1.getOrderId());
 
         // 다시 주문 가능
-        OrderInfo order4 = orderFacade.createDirectOrder(loginId, loginPw, items);
+        OrderInfo order4 = orderFacade.createDirectOrder(userId, items, null);
         assertThat(order4.getStatus()).isEqualTo(OrderStatus.PENDING_PAYMENT);
     }
 }
diff --git a/apps/commerce-api/src/test/java/com/loopers/interfaces/api/ExampleV1ApiE2ETest.java b/apps/commerce-api/src/test/java/com/loopers/interfaces/api/ExampleV1ApiE2ETest.java
deleted file mode 100644
index 1bb3dba65..000000000
--- a/apps/commerce-api/src/test/java/com/loopers/interfaces/api/ExampleV1ApiE2ETest.java
+++ /dev/null
@@ -1,114 +0,0 @@
-package com.loopers.interfaces.api;
-
-import com.loopers.domain.example.ExampleModel;
-import com.loopers.infrastructure.example.ExampleJpaRepository;
-import com.loopers.interfaces.api.example.ExampleV1Dto;
-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.boot.test.web.client.TestRestTemplate;
-import org.springframework.core.ParameterizedTypeReference;
-import org.springframework.http.HttpEntity;
-import org.springframework.http.HttpMethod;
-import org.springframework.http.HttpStatus;
-import org.springframework.http.ResponseEntity;
-
-import java.util.function.Function;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.jupiter.api.Assertions.assertAll;
-import static org.junit.jupiter.api.Assertions.assertTrue;
-
-@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
-class ExampleV1ApiE2ETest {
-
-    private static final Function<Long, String> ENDPOINT_GET = id -> "/api/v1/examples/" + id;
-
-    private final TestRestTemplate testRestTemplate;
-    private final ExampleJpaRepository exampleJpaRepository;
-    private final DatabaseCleanUp databaseCleanUp;
-
-    @Autowired
-    public ExampleV1ApiE2ETest(
-        TestRestTemplate testRestTemplate,
-        ExampleJpaRepository exampleJpaRepository,
-        DatabaseCleanUp databaseCleanUp
-    ) {
-        this.testRestTemplate = testRestTemplate;
-        this.exampleJpaRepository = exampleJpaRepository;
-        this.databaseCleanUp = databaseCleanUp;
-    }
-
-    @AfterEach
-    void tearDown() {
-        databaseCleanUp.truncateAllTables();
-    }
-
-    @DisplayName("GET /api/v1/examples/{id}")
-    @Nested
-    class Get {
-        @DisplayName("존재하는 예시 ID를 주면, 해당 예시 정보를 반환한다.")
-        @Test
-        void returnsExampleInfo_whenValidIdIsProvided() {
-            // arrange
-            ExampleModel exampleModel = exampleJpaRepository.save(
-                new ExampleModel("예시 제목", "예시 설명")
-            );
-            String requestUrl = ENDPOINT_GET.apply(exampleModel.getId());
-
-            // act
-            ParameterizedTypeReference<ApiResponse<ExampleV1Dto.ExampleResponse>> responseType = new ParameterizedTypeReference<>() {};
-            ResponseEntity<ApiResponse<ExampleV1Dto.ExampleResponse>> response =
-                testRestTemplate.exchange(requestUrl, HttpMethod.GET, new HttpEntity<>(null), responseType);
-
-            // assert
-            assertAll(
-                () -> assertTrue(response.getStatusCode().is2xxSuccessful()),
-                () -> assertThat(response.getBody().data().id()).isEqualTo(exampleModel.getId()),
-                () -> assertThat(response.getBody().data().name()).isEqualTo(exampleModel.getName()),
-                () -> assertThat(response.getBody().data().description()).isEqualTo(exampleModel.getDescription())
-            );
-        }
-
-        @DisplayName("숫자가 아닌 ID 로 요청하면, 400 BAD_REQUEST 응답을 받는다.")
-        @Test
-        void throwsBadRequest_whenIdIsNotProvided() {
-            // arrange
-            String requestUrl = "/api/v1/examples/나나";
-
-            // act
-            ParameterizedTypeReference<ApiResponse<ExampleV1Dto.ExampleResponse>> responseType = new ParameterizedTypeReference<>() {};
-            ResponseEntity<ApiResponse<ExampleV1Dto.ExampleResponse>> response =
-                testRestTemplate.exchange(requestUrl, HttpMethod.GET, new HttpEntity<>(null), responseType);
-
-            // assert
-            assertAll(
-                () -> assertTrue(response.getStatusCode().is4xxClientError()),
-                () -> assertThat(response.getStatusCode()).isEqualTo(HttpStatus.BAD_REQUEST)
-            );
-        }
-
-        @DisplayName("존재하지 않는 예시 ID를 주면, 404 NOT_FOUND 응답을 받는다.")
-        @Test
-        void throwsException_whenInvalidIdIsProvided() {
-            // arrange
-            Long invalidId = -1L;
-            String requestUrl = ENDPOINT_GET.apply(invalidId);
-
-            // act
-            ParameterizedTypeReference<ApiResponse<ExampleV1Dto.ExampleResponse>> responseType = new ParameterizedTypeReference<>() {};
-            ResponseEntity<ApiResponse<ExampleV1Dto.ExampleResponse>> response =
-                testRestTemplate.exchange(requestUrl, HttpMethod.GET, new HttpEntity<>(null), responseType);
-
-            // assert
-            assertAll(
-                () -> assertTrue(response.getStatusCode().is4xxClientError()),
-                () -> assertThat(response.getStatusCode()).isEqualTo(HttpStatus.NOT_FOUND)
-            );
-        }
-    }
-}
diff --git a/apps/commerce-api/src/test/java/com/loopers/interfaces/api/brand/BrandV1ApiE2ETest.java b/apps/commerce-api/src/test/java/com/loopers/interfaces/api/brand/BrandV1ApiE2ETest.java
index 3f4c1b936..60d37122f 100644
--- a/apps/commerce-api/src/test/java/com/loopers/interfaces/api/brand/BrandV1ApiE2ETest.java
+++ b/apps/commerce-api/src/test/java/com/loopers/interfaces/api/brand/BrandV1ApiE2ETest.java
@@ -77,7 +77,7 @@ void GET_brandDetail_ShouldReturn200() throws Exception {
         @Test
         @DisplayName("존재하지 않는 브랜드 ID로 404 반환")
         void GET_brandDetail_NotFound_ShouldReturn404() throws Exception {
-            mockMvc.perform(get("/api/v1/brands/{brandId}", "nonexistent"))
+            mockMvc.perform(get("/api/v1/brands/{brandId}", 999L))
                     .andExpect(status().isNotFound());
         }
 
diff --git a/apps/commerce-api/src/test/java/com/loopers/interfaces/api/coupon/CouponV1ApiE2ETest.java b/apps/commerce-api/src/test/java/com/loopers/interfaces/api/coupon/CouponV1ApiE2ETest.java
new file mode 100644
index 000000000..a9e2e0fdc
--- /dev/null
+++ b/apps/commerce-api/src/test/java/com/loopers/interfaces/api/coupon/CouponV1ApiE2ETest.java
@@ -0,0 +1,163 @@
+package com.loopers.interfaces.api.coupon;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.loopers.domain.coupon.CouponModel;
+import com.loopers.domain.coupon.CouponService;
+import com.loopers.interfaces.api.user.UserV1Dto;
+import com.loopers.support.enums.DiscountType;
+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 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.http.MediaType;
+import org.springframework.test.context.ActiveProfiles;
+import org.springframework.test.web.servlet.MockMvc;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.math.BigDecimal;
+import java.time.LocalDateTime;
+
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
+
+@SpringBootTest
+@AutoConfigureMockMvc
+@ActiveProfiles("test")
+@Transactional
+@DisplayName("Coupon API V1 E2E 테스트")
+class CouponV1ApiE2ETest {
+
+    @Autowired
+    MockMvc mockMvc;
+
+    @Autowired
+    ObjectMapper objectMapper;
+
+    @Autowired
+    CouponService couponService;
+
+    private static final String LOGIN_ID = "couponuser01";
+    private static final String LOGIN_PW = "Test1234!@#";
+    private Long couponId;
+
+    @BeforeEach
+    void setUp() throws Exception {
+        registerUser(LOGIN_ID, LOGIN_PW, "쿠폰테스트유저");
+        CouponModel coupon = couponService.createCoupon("테스트쿠폰", DiscountType.FIXED,
+                BigDecimal.valueOf(5000), null, LocalDateTime.now().plusDays(30));
+        couponId = coupon.getCouponId();
+    }
+
+    @Nested
+    @DisplayName("POST /api/v1/coupons/{couponId}/issue - 쿠폰 발급")
+    class IssueCouponTests {
+
+        @Test
+        @DisplayName("정상 발급 시 200 반환")
+        void issueCoupon_WithValidAuth_ShouldReturn200() throws Exception {
+            mockMvc.perform(post("/api/v1/coupons/{couponId}/issue", couponId)
+                            .header("X-Loopers-LoginId", LOGIN_ID)
+                            .header("X-Loopers-LoginPw", LOGIN_PW))
+                    .andExpect(status().isOk())
+                    .andExpect(jsonPath("$.meta.result").value("SUCCESS"))
+                    .andExpect(jsonPath("$.data.userCouponId").isNumber())
+                    .andExpect(jsonPath("$.data.status").value("AVAILABLE"));
+        }
+
+        @Test
+        @DisplayName("인증 헤더 없으면 400 반환")
+        void issueCoupon_WithoutAuth_ShouldReturn400() throws Exception {
+            mockMvc.perform(post("/api/v1/coupons/{couponId}/issue", couponId))
+                    .andExpect(status().isBadRequest());
+        }
+
+        @Test
+        @DisplayName("없는 쿠폰 발급 시 404 반환")
+        void issueCoupon_CouponNotFound_ShouldReturn404() throws Exception {
+            mockMvc.perform(post("/api/v1/coupons/{couponId}/issue", 999L)
+                            .header("X-Loopers-LoginId", LOGIN_ID)
+                            .header("X-Loopers-LoginPw", LOGIN_PW))
+                    .andExpect(status().isNotFound())
+                    .andExpect(jsonPath("$.meta.errorCode").value("COUPON_NOT_FOUND"));
+        }
+
+        @Test
+        @DisplayName("이미 발급된 쿠폰 재발급 시 409 반환")
+        void issueCoupon_AlreadyIssued_ShouldReturn409() throws Exception {
+            mockMvc.perform(post("/api/v1/coupons/{couponId}/issue", couponId)
+                    .header("X-Loopers-LoginId", LOGIN_ID)
+                    .header("X-Loopers-LoginPw", LOGIN_PW));
+
+            mockMvc.perform(post("/api/v1/coupons/{couponId}/issue", couponId)
+                            .header("X-Loopers-LoginId", LOGIN_ID)
+                            .header("X-Loopers-LoginPw", LOGIN_PW))
+                    .andExpect(status().isConflict())
+                    .andExpect(jsonPath("$.meta.errorCode").value("COUPON_ALREADY_ISSUED"));
+        }
+
+        @Test
+        @DisplayName("만료된 쿠폰 발급 시 400 반환")
+        void issueCoupon_ExpiredCoupon_ShouldReturn400() throws Exception {
+            CouponModel expiredCoupon = couponService.createCoupon("만료쿠폰", DiscountType.FIXED,
+                    BigDecimal.valueOf(1000), null, LocalDateTime.now().minusDays(1));
+
+            mockMvc.perform(post("/api/v1/coupons/{couponId}/issue", expiredCoupon.getCouponId())
+                            .header("X-Loopers-LoginId", LOGIN_ID)
+                            .header("X-Loopers-LoginPw", LOGIN_PW))
+                    .andExpect(status().isBadRequest())
+                    .andExpect(jsonPath("$.meta.errorCode").value("COUPON_NOT_APPLICABLE"));
+        }
+    }
+
+    @Nested
+    @DisplayName("GET /api/v1/users/me/coupons - 내 쿠폰 목록")
+    class GetMyCouponsTests {
+
+        @Test
+        @DisplayName("발급된 쿠폰이 있으면 목록을 반환한다")
+        void getMyCoupons_ShouldReturnIssuedCoupons() throws Exception {
+            mockMvc.perform(post("/api/v1/coupons/{couponId}/issue", couponId)
+                    .header("X-Loopers-LoginId", LOGIN_ID)
+                    .header("X-Loopers-LoginPw", LOGIN_PW));
+
+            mockMvc.perform(get("/api/v1/users/me/coupons")
+                            .header("X-Loopers-LoginId", LOGIN_ID)
+                            .header("X-Loopers-LoginPw", LOGIN_PW))
+                    .andExpect(status().isOk())
+                    .andExpect(jsonPath("$.data").isArray())
+                    .andExpect(jsonPath("$.data.length()").value(1))
+                    .andExpect(jsonPath("$.data[0].couponId").value(couponId));
+        }
+
+        @Test
+        @DisplayName("발급된 쿠폰이 없으면 빈 배열을 반환한다")
+        void getMyCoupons_NoIssuedCoupons_ShouldReturnEmptyList() throws Exception {
+            mockMvc.perform(get("/api/v1/users/me/coupons")
+                            .header("X-Loopers-LoginId", LOGIN_ID)
+                            .header("X-Loopers-LoginPw", LOGIN_PW))
+                    .andExpect(status().isOk())
+                    .andExpect(jsonPath("$.data").isArray())
+                    .andExpect(jsonPath("$.data.length()").value(0));
+        }
+    }
+
+    private void registerUser(String loginId, String password, String userName) throws Exception {
+        var request = UserV1Dto.RegisterRequest.builder()
+                .loginId(loginId)
+                .password(password)
+                .userName(userName)
+                .birthday("19900101")
+                .email("test@example.com")
+                .address("서울")
+                .build();
+
+        mockMvc.perform(post("/api/v1/users")
+                .contentType(MediaType.APPLICATION_JSON)
+                .content(objectMapper.writeValueAsString(request)));
+    }
+}
diff --git a/apps/commerce-api/src/test/java/com/loopers/interfaces/api/like/LikeV1ApiE2ETest.java b/apps/commerce-api/src/test/java/com/loopers/interfaces/api/like/LikeV1ApiE2ETest.java
index f6f83a715..3f807804e 100644
--- a/apps/commerce-api/src/test/java/com/loopers/interfaces/api/like/LikeV1ApiE2ETest.java
+++ b/apps/commerce-api/src/test/java/com/loopers/interfaces/api/like/LikeV1ApiE2ETest.java
@@ -49,7 +49,7 @@ class LikeV1ApiE2ETest {
 
     private static final String LOGIN_ID = "likeuser01";
     private static final String LOGIN_PW = "Test1234!@#";
-    private String productId;
+    private Long productId;
 
     @BeforeEach
     void setUp() throws Exception {
@@ -98,7 +98,7 @@ void POST_addLike_Idempotent_ShouldReturn200() throws Exception {
         @Test
         @DisplayName("없는 상품에 좋아요 시 404 반환")
         void POST_addLike_ProductNotFound_ShouldReturn404() throws Exception {
-            mockMvc.perform(post("/api/v1/products/{productId}/likes", "nonexistent-product-id")
+            mockMvc.perform(post("/api/v1/products/{productId}/likes", 999L)
                             .header("X-Loopers-LoginId", LOGIN_ID)
                             .header("X-Loopers-LoginPw", LOGIN_PW))
                     .andExpect(status().isNotFound())
diff --git a/apps/commerce-api/src/test/java/com/loopers/interfaces/apiadmin/AdminCartV1ApiE2ETest.java b/apps/commerce-api/src/test/java/com/loopers/interfaces/apiadmin/AdminCartV1ApiE2ETest.java
index c400b2dc7..142c47bba 100644
--- a/apps/commerce-api/src/test/java/com/loopers/interfaces/apiadmin/AdminCartV1ApiE2ETest.java
+++ b/apps/commerce-api/src/test/java/com/loopers/interfaces/apiadmin/AdminCartV1ApiE2ETest.java
@@ -48,9 +48,9 @@ void GET_userCart_ShouldReturn200WithCartItems() throws Exception {
                 ProductModel.create("테스트상품", brand.getBrandId(), BigDecimal.valueOf(10000),
                         null, null, null, null, null, null, null));
         productStockJpaRepository.save(ProductStockModel.create(product.getProductId(), 100));
-        cartItemJpaRepository.save(CartItemModel.create("user-1", product.getProductId(), 3));
+        cartItemJpaRepository.save(CartItemModel.create(1L, product.getProductId(), 3));
 
-        mockMvc.perform(get("/api-admin/v1/users/user-1/cart")
+        mockMvc.perform(get("/api-admin/v1/users/1/cart")
                         .header(ADMIN_HEADER, ADMIN_VALUE))
                 .andExpect(status().isOk())
                 .andExpect(jsonPath("$.data.length()").value(1))
diff --git a/apps/commerce-api/src/test/java/com/loopers/interfaces/apiadmin/AdminCouponV1ApiE2ETest.java b/apps/commerce-api/src/test/java/com/loopers/interfaces/apiadmin/AdminCouponV1ApiE2ETest.java
new file mode 100644
index 000000000..ac469e56e
--- /dev/null
+++ b/apps/commerce-api/src/test/java/com/loopers/interfaces/apiadmin/AdminCouponV1ApiE2ETest.java
@@ -0,0 +1,228 @@
+package com.loopers.interfaces.apiadmin;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.loopers.domain.coupon.CouponModel;
+import com.loopers.domain.coupon.CouponService;
+import com.loopers.interfaces.api.user.UserV1Dto;
+import com.loopers.support.enums.DiscountType;
+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 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.http.MediaType;
+import org.springframework.test.context.ActiveProfiles;
+import org.springframework.test.web.servlet.MockMvc;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.math.BigDecimal;
+import java.time.LocalDateTime;
+import java.util.Map;
+
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.delete;
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.put;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
+
+@SpringBootTest
+@AutoConfigureMockMvc
+@ActiveProfiles("test")
+@Transactional
+@DisplayName("관리자 Coupon API V1 E2E 테스트")
+class AdminCouponV1ApiE2ETest {
+
+    @Autowired
+    MockMvc mockMvc;
+
+    @Autowired
+    ObjectMapper objectMapper;
+
+    @Autowired
+    CouponService couponService;
+
+    private static final String ADMIN_LDAP = "loopers.admin";
+    private static final String USER_LOGIN_ID = "admincoupontest";
+    private static final String USER_LOGIN_PW = "Test1234!@#";
+    private Long couponId;
+
+    @BeforeEach
+    void setUp() throws Exception {
+        CouponModel coupon = couponService.createCoupon("기본쿠폰", DiscountType.FIXED,
+                BigDecimal.valueOf(1000), null, LocalDateTime.now().plusDays(30));
+        couponId = coupon.getCouponId();
+    }
+
+    @Nested
+    @DisplayName("POST /api-admin/v1/coupons - 쿠폰 등록")
+    class CreateCouponTests {
+
+        @Test
+        @DisplayName("정상 등록 시 200 반환")
+        void createCoupon_ShouldReturn200() throws Exception {
+            Map<String, Object> request = Map.of(
+                    "name", "신규쿠폰",
+                    "type", "RATE",
+                    "value", 10,
+                    "expiredAt", "2030-12-31T23:59:59"
+            );
+
+            mockMvc.perform(post("/api-admin/v1/coupons")
+                            .header("X-Loopers-Ldap", ADMIN_LDAP)
+                            .contentType(MediaType.APPLICATION_JSON)
+                            .content(objectMapper.writeValueAsString(request)))
+                    .andExpect(status().isOk())
+                    .andExpect(jsonPath("$.data.couponId").isNumber())
+                    .andExpect(jsonPath("$.data.name").value("신규쿠폰"));
+        }
+
+        @Test
+        @DisplayName("LDAP 헤더 없으면 401 반환")
+        void createCoupon_WithoutLdap_ShouldReturn401() throws Exception {
+            Map<String, Object> request = Map.of(
+                    "name", "쿠폰",
+                    "type", "FIXED",
+                    "value", 1000,
+                    "expiredAt", "2030-12-31T23:59:59"
+            );
+
+            mockMvc.perform(post("/api-admin/v1/coupons")
+                            .contentType(MediaType.APPLICATION_JSON)
+                            .content(objectMapper.writeValueAsString(request)))
+                    .andExpect(status().isUnauthorized());
+        }
+    }
+
+    @Nested
+    @DisplayName("GET /api-admin/v1/coupons/{couponId} - 쿠폰 상세")
+    class GetCouponTests {
+
+        @Test
+        @DisplayName("정상 조회 시 200 반환")
+        void getCoupon_ShouldReturn200() throws Exception {
+            mockMvc.perform(get("/api-admin/v1/coupons/{couponId}", couponId)
+                            .header("X-Loopers-Ldap", ADMIN_LDAP))
+                    .andExpect(status().isOk())
+                    .andExpect(jsonPath("$.data.couponId").value(couponId));
+        }
+
+        @Test
+        @DisplayName("없는 쿠폰 조회 시 404 반환")
+        void getCoupon_NotFound_ShouldReturn404() throws Exception {
+            mockMvc.perform(get("/api-admin/v1/coupons/{couponId}", 99999L)
+                            .header("X-Loopers-Ldap", ADMIN_LDAP))
+                    .andExpect(status().isNotFound())
+                    .andExpect(jsonPath("$.meta.errorCode").value("COUPON_NOT_FOUND"));
+        }
+    }
+
+    @Nested
+    @DisplayName("PUT /api-admin/v1/coupons/{couponId} - 쿠폰 수정")
+    class UpdateCouponTests {
+
+        @Test
+        @DisplayName("정상 수정 시 200 반환")
+        void updateCoupon_ShouldReturn200() throws Exception {
+            Map<String, Object> request = Map.of(
+                    "name", "수정된쿠폰",
+                    "type", "RATE",
+                    "value", 20,
+                    "expiredAt", "2031-12-31T23:59:59"
+            );
+
+            mockMvc.perform(put("/api-admin/v1/coupons/{couponId}", couponId)
+                            .header("X-Loopers-Ldap", ADMIN_LDAP)
+                            .contentType(MediaType.APPLICATION_JSON)
+                            .content(objectMapper.writeValueAsString(request)))
+                    .andExpect(status().isOk())
+                    .andExpect(jsonPath("$.data.name").value("수정된쿠폰"));
+        }
+    }
+
+    @Nested
+    @DisplayName("DELETE /api-admin/v1/coupons/{couponId} - 쿠폰 삭제")
+    class DeleteCouponTests {
+
+        @Test
+        @DisplayName("정상 삭제 시 200 반환")
+        void deleteCoupon_ShouldReturn200() throws Exception {
+            mockMvc.perform(delete("/api-admin/v1/coupons/{couponId}", couponId)
+                            .header("X-Loopers-Ldap", ADMIN_LDAP))
+                    .andExpect(status().isOk())
+                    .andExpect(jsonPath("$.meta.result").value("SUCCESS"));
+        }
+
+        @Test
+        @DisplayName("없는 쿠폰 삭제 시 404 반환")
+        void deleteCoupon_NotFound_ShouldReturn404() throws Exception {
+            mockMvc.perform(delete("/api-admin/v1/coupons/{couponId}", 99999L)
+                            .header("X-Loopers-Ldap", ADMIN_LDAP))
+                    .andExpect(status().isNotFound())
+                    .andExpect(jsonPath("$.meta.errorCode").value("COUPON_NOT_FOUND"));
+        }
+    }
+
+    @Nested
+    @DisplayName("GET /api-admin/v1/coupons - 쿠폰 목록 (페이징)")
+    class GetCouponsPagedTests {
+
+        @Test
+        @DisplayName("페이징 응답 구조로 반환된다")
+        void getCoupons_ShouldReturnPagedResponse() throws Exception {
+            mockMvc.perform(get("/api-admin/v1/coupons")
+                            .header("X-Loopers-Ldap", ADMIN_LDAP)
+                            .param("page", "0")
+                            .param("size", "10"))
+                    .andExpect(status().isOk())
+                    .andExpect(jsonPath("$.data.content").isArray())
+                    .andExpect(jsonPath("$.data.page").value(0))
+                    .andExpect(jsonPath("$.data.size").value(10))
+                    .andExpect(jsonPath("$.data.totalElements").isNumber())
+                    .andExpect(jsonPath("$.data.totalPages").isNumber());
+        }
+    }
+
+    @Nested
+    @DisplayName("GET /api-admin/v1/coupons/{couponId}/issues - 발급 내역 (페이징)")
+    class GetIssueHistoryTests {
+
+        @Test
+        @DisplayName("발급 내역을 페이징 응답 구조로 반환한다")
+        void getIssueHistory_ShouldReturnPagedUserCoupons() throws Exception {
+            // 사용자 등록 및 쿠폰 발급
+            registerUser(USER_LOGIN_ID, USER_LOGIN_PW, "관리자테스트유저");
+            mockMvc.perform(post("/api/v1/coupons/{couponId}/issue", couponId)
+                    .header("X-Loopers-LoginId", USER_LOGIN_ID)
+                    .header("X-Loopers-LoginPw", USER_LOGIN_PW));
+
+            mockMvc.perform(get("/api-admin/v1/coupons/{couponId}/issues", couponId)
+                            .header("X-Loopers-Ldap", ADMIN_LDAP)
+                            .param("page", "0")
+                            .param("size", "20"))
+                    .andExpect(status().isOk())
+                    .andExpect(jsonPath("$.data.content").isArray())
+                    .andExpect(jsonPath("$.data.page").value(0))
+                    .andExpect(jsonPath("$.data.size").value(20))
+                    .andExpect(jsonPath("$.data.totalElements").isNumber())
+                    .andExpect(jsonPath("$.data.totalPages").isNumber());
+        }
+    }
+
+    private void registerUser(String loginId, String password, String userName) throws Exception {
+        var request = UserV1Dto.RegisterRequest.builder()
+                .loginId(loginId)
+                .password(password)
+                .userName(userName)
+                .birthday("19900101")
+                .email("test@example.com")
+                .address("서울")
+                .build();
+
+        mockMvc.perform(post("/api/v1/users")
+                .contentType(MediaType.APPLICATION_JSON)
+                .content(objectMapper.writeValueAsString(request)));
+    }
+}
diff --git a/apps/commerce-api/src/test/java/com/loopers/interfaces/apiadmin/AdminOrderV1ApiE2ETest.java b/apps/commerce-api/src/test/java/com/loopers/interfaces/apiadmin/AdminOrderV1ApiE2ETest.java
index faea701b0..f1b844e45 100644
--- a/apps/commerce-api/src/test/java/com/loopers/interfaces/apiadmin/AdminOrderV1ApiE2ETest.java
+++ b/apps/commerce-api/src/test/java/com/loopers/interfaces/apiadmin/AdminOrderV1ApiE2ETest.java
@@ -38,8 +38,8 @@ class AdminOrderV1ApiE2ETest {
     @Test
     @DisplayName("관리자가 모든 사용자의 주문을 조회할 수 있다")
     void GET_orders_ShouldReturn200WithAllOrders() throws Exception {
-        orderJpaRepository.save(OrderModel.create("user-1", OrderType.DIRECT, BigDecimal.valueOf(10000)));
-        orderJpaRepository.save(OrderModel.create("user-2", OrderType.CART, BigDecimal.valueOf(20000)));
+        orderJpaRepository.save(OrderModel.create(1L, OrderType.DIRECT, BigDecimal.valueOf(10000)));
+        orderJpaRepository.save(OrderModel.create(2L, OrderType.CART, BigDecimal.valueOf(20000)));
 
         mockMvc.perform(get("/api-admin/v1/orders")
                         .header(ADMIN_HEADER, ADMIN_VALUE))
@@ -51,9 +51,9 @@ void GET_orders_ShouldReturn200WithAllOrders() throws Exception {
     @DisplayName("주문 상세에 스냅샷이 포함된다")
     void GET_orderDetail_ShouldReturn200WithSnapshots() throws Exception {
         OrderModel order = orderJpaRepository.save(
-                OrderModel.create("user-1", OrderType.DIRECT, BigDecimal.valueOf(30000)));
+                OrderModel.create(1L, OrderType.DIRECT, BigDecimal.valueOf(30000)));
         orderItemJpaRepository.save(OrderItemModel.create(
-                order.getOrderId(), 1, "user-1", "p1", 2,
+                order.getOrderId(), 1, 1L, 1L, 2,
                 "테스트상품", BigDecimal.valueOf(15000), "b1", "테스트브랜드", null));
 
         mockMvc.perform(get("/api-admin/v1/orders/" + order.getOrderId())
diff --git a/apps/commerce-api/src/test/java/com/loopers/interfaces/apiadmin/AdminProductV1ApiE2ETest.java b/apps/commerce-api/src/test/java/com/loopers/interfaces/apiadmin/AdminProductV1ApiE2ETest.java
index d6b30c549..836a34251 100644
--- a/apps/commerce-api/src/test/java/com/loopers/interfaces/apiadmin/AdminProductV1ApiE2ETest.java
+++ b/apps/commerce-api/src/test/java/com/loopers/interfaces/apiadmin/AdminProductV1ApiE2ETest.java
@@ -71,7 +71,7 @@ void POST_createProduct_ShouldReturn200() throws Exception {
         @DisplayName("미존재 브랜드로 404 반환")
         void POST_createProduct_NonExistingBrand_ShouldReturn404() throws Exception {
             var request = AdminProductV1Dto.CreateProductRequest.builder()
-                    .productName("테스트상품").brandId("nonexistent")
+                    .productName("테스트상품").brandId(999L)
                     .price(BigDecimal.valueOf(10000)).initialStock(100).build();
 
             mockMvc.perform(post("/api-admin/v1/products")
diff --git a/apps/commerce-api/src/test/java/com/loopers/interfaces/apiadmin/AdminStatsV1ApiE2ETest.java b/apps/commerce-api/src/test/java/com/loopers/interfaces/apiadmin/AdminStatsV1ApiE2ETest.java
index d8491076d..2de23cf4f 100644
--- a/apps/commerce-api/src/test/java/com/loopers/interfaces/apiadmin/AdminStatsV1ApiE2ETest.java
+++ b/apps/commerce-api/src/test/java/com/loopers/interfaces/apiadmin/AdminStatsV1ApiE2ETest.java
@@ -58,7 +58,7 @@ void setUp() {
     @Test
     @DisplayName("주문 현황 overview 조회")
     void GET_overview_ShouldReturn200() throws Exception {
-        orderJpaRepository.save(OrderModel.create("user-1", OrderType.DIRECT, BigDecimal.valueOf(10000)));
+        orderJpaRepository.save(OrderModel.create(1L, OrderType.DIRECT, BigDecimal.valueOf(10000)));
 
         mockMvc.perform(get("/api-admin/v1/stats/overview")
                         .header(ADMIN_HEADER, ADMIN_VALUE)
@@ -71,7 +71,7 @@ void GET_overview_ShouldReturn200() throws Exception {
     @Test
     @DisplayName("일별 주문 통계 조회")
     void GET_dailyOrderStats_ShouldReturn200() throws Exception {
-        orderJpaRepository.save(OrderModel.create("user-1", OrderType.DIRECT, BigDecimal.valueOf(10000)));
+        orderJpaRepository.save(OrderModel.create(1L, OrderType.DIRECT, BigDecimal.valueOf(10000)));
 
         mockMvc.perform(get("/api-admin/v1/stats/orders/daily")
                         .header(ADMIN_HEADER, ADMIN_VALUE)
@@ -88,7 +88,7 @@ void GET_topLikedProducts_ShouldReturn200() throws Exception {
         ProductModel product = productJpaRepository.save(
                 ProductModel.create("인기상품", brand.getBrandId(), BigDecimal.valueOf(10000),
                         null, null, null, null, null, null, null));
-        likeJpaRepository.save(LikeModel.create("user-1", product.getProductId()));
+        likeJpaRepository.save(LikeModel.create(1L, product.getProductId()));
 
         mockMvc.perform(get("/api-admin/v1/stats/products/top-liked")
                         .header(ADMIN_HEADER, ADMIN_VALUE)
diff --git a/build.gradle.kts b/build.gradle.kts
index 9c8490b8a..d6a9c138e 100644
--- a/build.gradle.kts
+++ b/build.gradle.kts
@@ -83,6 +83,12 @@ subprojects {
         systemProperty("user.timezone", "Asia/Seoul")
         systemProperty("spring.profiles.active", "test")
         jvmArgs("-Xshare:off")
+        // Testcontainers Docker socket (WSL2 + Docker Desktop)
+        val dockerHost = System.getenv("DOCKER_HOST")
+        if (!dockerHost.isNullOrBlank()) {
+            environment("DOCKER_HOST", dockerHost)
+            environment("TESTCONTAINERS_DOCKER_SOCKET_OVERRIDE", dockerHost.removePrefix("unix://"))
+        }
     }
 
     tasks.withType<JacocoReport> {
diff --git a/docs/DDL/index.sql b/docs/DDL/index.sql
new file mode 100644
index 000000000..e69de29bb
diff --git a/k6/lib/helpers.js b/k6/lib/helpers.js
new file mode 100644
index 000000000..27bed3f5f
--- /dev/null
+++ b/k6/lib/helpers.js
@@ -0,0 +1,40 @@
+// Zipf 분포: 상위 20% 상품에 80% 트래픽 집중
+export function getProductIdZipf(maxId) {
+    const rand = Math.random();
+    if (rand < 0.8) {
+        return Math.floor(Math.random() * Math.ceil(maxId * 0.2)) + 1;
+    }
+    return Math.floor(Math.random() * Math.floor(maxId * 0.8)) + Math.ceil(maxId * 0.2) + 1;
+}
+
+// 고객 인증 헤더
+export function authHeaders(loginId, loginPw) {
+    return {
+        'Content-Type': 'application/json',
+        'X-Loopers-LoginId': loginId,
+        'X-Loopers-LoginPw': loginPw,
+    };
+}
+
+// 관리자 인증 헤더
+export function adminHeaders() {
+    return {
+        'Content-Type': 'application/json',
+        'X-Loopers-Ldap': 'loopers.admin',
+    };
+}
+
+// 응답 검증 공통
+export function checkResponse(res, name) {
+    return {
+        [`${name} status 200`]: (r) => r.status === 200,
+        [`${name} has data`]: (r) => {
+            try {
+                const body = JSON.parse(r.body);
+                return body.meta && body.meta.result === 'SUCCESS';
+            } catch (e) {
+                return false;
+            }
+        },
+    };
+}
diff --git a/k6/scripts/product-list-cache.js b/k6/scripts/product-list-cache.js
new file mode 100644
index 000000000..41d6c6782
--- /dev/null
+++ b/k6/scripts/product-list-cache.js
@@ -0,0 +1,48 @@
+import http from 'k6/http';
+import { check, sleep } from 'k6';
+import { authHeaders, checkResponse } from '../lib/helpers.js';
+
+export const options = {
+    scenarios: {
+        list_only: {
+            executor: 'constant-vus',
+            vus: 30,
+            duration: '3m',
+        },
+    },
+    thresholds: {
+        http_req_duration: ['p(95)<150'],
+        http_req_failed: ['rate<0.001'],
+    },
+};
+
+const BASE = 'http://localhost:8080';
+const HEADERS = authHeaders('testuser', 'Test1234!');
+const SORTS = ['LATEST', 'PRICE_ASC', 'LIKES_DESC'];
+
+export default function () {
+    const rand = Math.random();
+
+    if (rand < 0.6) {
+        // 60% — 캐시 대상: 무필터 + 첫 1페이지 (page=0)
+        const page = 0;
+        const sort = SORTS[Math.floor(Math.random() * 3)];
+        const res = http.get(`${BASE}/api/v1/products?page=${page}&size=20&sort=${sort}`,
+            { headers: HEADERS });
+        check(res, checkResponse(res, 'cached-list'));
+    } else if (rand < 0.85) {
+        // 25% — 캐시 미대상: keyword 검색
+        const keywords = ['나이키', '아디다스', '셔츠', '바지', '가방'];
+        const keyword = keywords[Math.floor(Math.random() * keywords.length)];
+        const res = http.get(`${BASE}/api/v1/products?q=${encodeURIComponent(keyword)}&size=20`,
+            { headers: HEADERS });
+        check(res, checkResponse(res, 'search-list'));
+    } else {
+        // 15% — 캐시 미대상: 2페이지 이후
+        const page = Math.floor(Math.random() * 49) + 1;  // page 1~49
+        const res = http.get(`${BASE}/api/v1/products?page=${page}&size=20&sort=LATEST`,
+            { headers: HEADERS });
+        check(res, checkResponse(res, 'deep-page-list'));
+    }
+    sleep(0.2);
+}
diff --git a/k6/scripts/product-mixed.js b/k6/scripts/product-mixed.js
new file mode 100644
index 000000000..df1841462
--- /dev/null
+++ b/k6/scripts/product-mixed.js
@@ -0,0 +1,85 @@
+import http from 'k6/http';
+import { check, sleep } from 'k6';
+import { getProductIdZipf, authHeaders, adminHeaders, checkResponse } from '../lib/helpers.js';
+
+export const options = {
+    scenarios: {
+        readers: {
+            executor: 'constant-vus',
+            vus: 35,
+            duration: '5m',
+            exec: 'readScenario',
+        },
+        list_readers: {
+            executor: 'constant-vus',
+            vus: 10,
+            duration: '5m',
+            exec: 'listScenario',
+        },
+        admin_writers: {
+            executor: 'constant-vus',
+            vus: 3,
+            duration: '5m',
+            exec: 'writeScenario',
+        },
+        orderers: {
+            executor: 'constant-vus',
+            vus: 2,
+            duration: '5m',
+            exec: 'orderScenario',
+        },
+    },
+    thresholds: {
+        http_req_failed: ['rate<0.01'],
+        'http_req_duration{scenario:readers}': ['p(95)<100'],
+    },
+};
+
+const BASE = 'http://localhost:8080';
+const CUSTOMER_HEADERS = authHeaders('testuser', 'Test1234!');
+const ADMIN_HEADERS = adminHeaders();
+
+// 70% — 고객 상품 상세 조회
+export function readScenario() {
+    const productId = getProductIdZipf(100);
+    const res = http.get(`${BASE}/api/v1/products/${productId}`, { headers: CUSTOMER_HEADERS });
+    check(res, checkResponse(res, 'read'));
+    sleep(0.1);
+}
+
+// 20% — 고객 상품 목록 조회
+export function listScenario() {
+    const page = Math.floor(Math.random() * 5);
+    const sort = ['LATEST', 'PRICE_ASC', 'LIKES_DESC'][Math.floor(Math.random() * 3)];
+    const res = http.get(`${BASE}/api/v1/products?page=${page}&size=20&sort=${sort}`,
+        { headers: CUSTOMER_HEADERS });
+    check(res, checkResponse(res, 'list'));
+    sleep(0.5);
+}
+
+// 5% — 관리자 상품 수정 (Cache Evict 유발)
+export function writeScenario() {
+    const productId = Math.floor(Math.random() * 100) + 1;
+    const payload = JSON.stringify({
+        productName: `Updated-${Date.now()}`,
+        price: Math.floor(Math.random() * 100000) + 1000,
+        description: 'k6 load test update',
+    });
+    const res = http.put(`${BASE}/api-admin/v1/products/${productId}`,
+        payload, { headers: ADMIN_HEADERS });
+    check(res, { 'admin-update 200': (r) => r.status === 200 });
+    sleep(2);  // 관리자는 느리게
+}
+
+// 5% — 고객 주문 (재고 hold)
+export function orderScenario() {
+    const productId = getProductIdZipf(100);
+    const payload = JSON.stringify({
+        orderType: 'DIRECT',
+        items: [{ productId: productId, quantity: 1 }],
+    });
+    const res = http.post(`${BASE}/api/v1/orders`, payload, { headers: CUSTOMER_HEADERS });
+    // 재고 부족은 정상 응답이므로 status만 확인
+    check(res, { 'order not 500': (r) => r.status !== 500 });
+    sleep(1);
+}
diff --git a/k6/scripts/product-soak.js b/k6/scripts/product-soak.js
new file mode 100644
index 000000000..518d16ef2
--- /dev/null
+++ b/k6/scripts/product-soak.js
@@ -0,0 +1,27 @@
+import http from 'k6/http';
+import { check, sleep } from 'k6';
+import { getProductIdZipf, authHeaders, checkResponse } from '../lib/helpers.js';
+
+export const options = {
+    scenarios: {
+        soak: {
+            executor: 'constant-vus',
+            vus: 100,
+            duration: '30m',
+        },
+    },
+    thresholds: {
+        http_req_duration: ['p(95)<100', 'p(99)<300'],
+        http_req_failed: ['rate<0.001'],
+    },
+};
+
+const BASE = 'http://localhost:8080';
+const HEADERS = authHeaders('testuser', 'Test1234!');
+
+export default function () {
+    const productId = getProductIdZipf(100);
+    const res = http.get(`${BASE}/api/v1/products/${productId}`, { headers: HEADERS });
+    check(res, checkResponse(res, 'soak'));
+    sleep(0.1);
+}
diff --git a/k6/scripts/product-spike.js b/k6/scripts/product-spike.js
new file mode 100644
index 000000000..42b837a0e
--- /dev/null
+++ b/k6/scripts/product-spike.js
@@ -0,0 +1,34 @@
+import http from 'k6/http';
+import { check, sleep } from 'k6';
+import { authHeaders, checkResponse } from '../lib/helpers.js';
+
+export const options = {
+    scenarios: {
+        spike: {
+            executor: 'ramping-vus',
+            startVUs: 0,
+            stages: [
+                { duration: '10s', target: 10 },     // 워밍업
+                { duration: '5s',  target: 200 },     // 5초 만에 200명 급증
+                { duration: '30s', target: 200 },     // 30초 유지
+                { duration: '10s', target: 0 },        // 쿨다운
+            ],
+        },
+    },
+    thresholds: {
+        http_req_duration: ['p(99)<1000'],
+        http_req_failed: ['rate<0.01'],
+    },
+};
+
+const BASE = 'http://localhost:8080';
+const HEADERS = authHeaders('testuser', 'Test1234!');
+const HOT_PRODUCT_ID = 1;  // 단일 상품 집중
+
+export default function () {
+    // 90% 동일 상품 (Hot Key), 10% 랜덤
+    const productId = Math.random() < 0.9 ? HOT_PRODUCT_ID : Math.floor(Math.random() * 100) + 1;
+    const res = http.get(`${BASE}/api/v1/products/${productId}`, { headers: HEADERS });
+    check(res, checkResponse(res, 'spike-product'));
+    sleep(0.05);
+}
diff --git a/k6/scripts/product-steady.js b/k6/scripts/product-steady.js
new file mode 100644
index 000000000..1aed6d54a
--- /dev/null
+++ b/k6/scripts/product-steady.js
@@ -0,0 +1,35 @@
+import http from 'k6/http';
+import { check, sleep } from 'k6';
+import { getProductIdZipf, authHeaders, checkResponse } from '../lib/helpers.js';
+
+export const options = {
+    scenarios: {
+        steady: {
+            executor: 'constant-vus',
+            vus: 50,
+            duration: '5m',
+        },
+    },
+    thresholds: {
+        http_req_duration: ['p(95)<100', 'p(99)<200'],
+        http_req_failed: ['rate<0.001'],
+    },
+};
+
+const BASE = 'http://localhost:8080';
+const HEADERS = authHeaders('testuser', 'Test1234!');
+
+export default function () {
+    // 80% 상품 상세, 20% 상품 목록
+    if (Math.random() < 0.8) {
+        const productId = getProductIdZipf(100);
+        const res = http.get(`${BASE}/api/v1/products/${productId}`, { headers: HEADERS });
+        check(res, checkResponse(res, 'product-detail'));
+    } else {
+        const page = Math.floor(Math.random() * 5);
+        const sort = ['LATEST', 'PRICE_ASC', 'LIKES_DESC'][Math.floor(Math.random() * 3)];
+        const res = http.get(`${BASE}/api/v1/products?page=${page}&size=20&sort=${sort}`, { headers: HEADERS });
+        check(res, checkResponse(res, 'product-list'));
+    }
+    sleep(0.1);
+}
diff --git a/k6/seed.sh b/k6/seed.sh
new file mode 100644
index 000000000..0acae139e
--- /dev/null
+++ b/k6/seed.sh
@@ -0,0 +1,80 @@
+#!/bin/bash
+# k6 부하 테스트를 위한 시드 데이터 적재 스크립트
+# 사전 조건: 앱이 localhost:8080에서 실행 중이어야 합니다.
+#
+# 생성 데이터:
+#   - 유저 1명: testuser / Test1234!
+#   - 브랜드 5개
+#   - 상품 100개 (브랜드당 20개, 재고 각 1000개)
+
+BASE="http://localhost:8080"
+ADMIN_HEADER="X-Loopers-Ldap: loopers.admin"
+
+echo "=== k6 시드 데이터 적재 시작 ==="
+
+# 1. 유저 생성
+echo "[1/3] 유저 생성..."
+curl -s -X POST "${BASE}/api/v1/users" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "loginId": "testuser",
+    "password": "Test1234!",
+    "userName": "테스트유저",
+    "birthday": "19900101",
+    "email": "test@loopers.com",
+    "address": "서울시 강남구"
+  }' | python3 -c "import sys,json; d=json.load(sys.stdin); print(f'  유저 생성: {d.get(\"meta\",{}).get(\"result\",\"UNKNOWN\")}')" 2>/dev/null || echo "  유저 생성 완료 (또는 이미 존재)"
+
+# 2. 브랜드 5개 생성
+echo "[2/3] 브랜드 5개 생성..."
+BRAND_NAMES=("나이키" "아디다스" "구찌" "프라다" "루이비통")
+BRAND_IDS=()
+
+for i in "${!BRAND_NAMES[@]}"; do
+  RESULT=$(curl -s -X POST "${BASE}/api-admin/v1/brands" \
+    -H "Content-Type: application/json" \
+    -H "${ADMIN_HEADER}" \
+    -d "{
+      \"brandName\": \"${BRAND_NAMES[$i]}\",
+      \"description\": \"${BRAND_NAMES[$i]} 공식 브랜드\",
+      \"address\": \"서울시 강남구 $((i+1))번길\"
+    }")
+  BRAND_ID=$(echo "$RESULT" | python3 -c "import sys,json; d=json.load(sys.stdin); print(d.get('data',{}).get('brandId',''))" 2>/dev/null)
+  if [ -n "$BRAND_ID" ]; then
+    BRAND_IDS+=("$BRAND_ID")
+    echo "  브랜드 생성: ${BRAND_NAMES[$i]} (ID: $BRAND_ID)"
+  else
+    echo "  브랜드 생성 실패: ${BRAND_NAMES[$i]}"
+  fi
+done
+
+# 3. 상품 100개 생성 (브랜드당 20개)
+echo "[3/3] 상품 100개 생성 (브랜드당 20개, 재고 1000)..."
+PRODUCT_COUNT=0
+
+for BRAND_ID in "${BRAND_IDS[@]}"; do
+  for j in $(seq 1 20); do
+    PRICE=$((10000 + RANDOM % 90000))
+    RESULT=$(curl -s -X POST "${BASE}/api-admin/v1/products" \
+      -H "Content-Type: application/json" \
+      -H "${ADMIN_HEADER}" \
+      -d "{
+        \"productName\": \"상품-B${BRAND_ID}-P${j}\",
+        \"brandId\": ${BRAND_ID},
+        \"price\": ${PRICE},
+        \"description\": \"브랜드${BRAND_ID}의 ${j}번째 상품\",
+        \"initialStock\": 1000
+      }")
+    PRODUCT_COUNT=$((PRODUCT_COUNT + 1))
+  done
+  echo "  브랜드 ${BRAND_ID}: 20개 상품 생성 완료 (누적: ${PRODUCT_COUNT}개)"
+done
+
+echo ""
+echo "=== 시드 데이터 적재 완료 ==="
+echo "  유저: 1명 (testuser / Test1234!)"
+echo "  브랜드: ${#BRAND_IDS[@]}개"
+echo "  상품: ${PRODUCT_COUNT}개 (재고 각 1000개)"
+echo ""
+echo "k6 실행:"
+echo "  docker run --rm -i --network host -v \$(pwd)/k6:/scripts grafana/k6 run /scripts/scripts/product-steady.js"
diff --git a/modules/.claude/settings.local.json b/modules/.claude/settings.local.json
new file mode 100644
index 000000000..399768218
--- /dev/null
+++ b/modules/.claude/settings.local.json
@@ -0,0 +1,7 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(cd /mnt/c/Users/kdj10/Git/loop-pack-be-l2-vol3-java && ./gradlew :apps:commerce-api:compileJava :apps:commerce-api:compileTestJava --no-daemon -q 2>&1)"
+    ]
+  }
+}
diff --git a/modules/redis/build.gradle.kts b/modules/redis/build.gradle.kts
index 37ad4f6dd..6d6d6d060 100644
--- a/modules/redis/build.gradle.kts
+++ b/modules/redis/build.gradle.kts
@@ -5,6 +5,7 @@ plugins {
 
 dependencies {
     api("org.springframework.boot:spring-boot-starter-data-redis")
+    api("org.springframework.boot:spring-boot-starter-cache")
 
     testFixturesImplementation("com.redis:testcontainers-redis")
 }
diff --git a/modules/redis/src/main/java/com/loopers/config/redis/RedisConfig.java b/modules/redis/src/main/java/com/loopers/config/redis/RedisConfig.java
index 0a2b614ca..65b576e85 100644
--- a/modules/redis/src/main/java/com/loopers/config/redis/RedisConfig.java
+++ b/modules/redis/src/main/java/com/loopers/config/redis/RedisConfig.java
@@ -75,7 +75,8 @@ private LettuceConnectionFactory lettuceConnectionFactory(
             List<RedisNodeInfo> replicas,
             Consumer<LettuceClientConfiguration.LettuceClientConfigurationBuilder> customizer
     ){
-        LettuceClientConfiguration.LettuceClientConfigurationBuilder builder = LettuceClientConfiguration.builder();
+        LettuceClientConfiguration.LettuceClientConfigurationBuilder builder = LettuceClientConfiguration.builder()
+                .commandTimeout(java.time.Duration.ofSeconds(2));
         if(customizer != null) customizer.accept(builder);
         LettuceClientConfiguration clientConfig = builder.build();
         RedisStaticMasterReplicaConfiguration masterReplicaConfig = new RedisStaticMasterReplicaConfiguration(master.host(), master.port());