diff --git a/.codeguide/loopers-1-week.md b/.codeguide/loopers-1-week.md
deleted file mode 100644
index a8ace53e5..000000000
--- a/.codeguide/loopers-1-week.md
+++ /dev/null
@@ -1,45 +0,0 @@
-## 🧪 Implementation Quest
-
-> 지정된 **단위 테스트 / 통합 테스트 / E2E 테스트 케이스**를 필수로 구현하고, 모든 테스트를 통과시키는 것을 목표로 합니다.
-
-### 회원 가입
-
-**🧱 단위 테스트**
-
-- [ ]  ID 가 `영문 및 숫자 10자 이내` 형식에 맞지 않으면, User 객체 생성에 실패한다.
-- [ ]  이메일이 `xx@yy.zz` 형식에 맞지 않으면, User 객체 생성에 실패한다.
-- [ ]  생년월일이 `yyyy-MM-dd` 형식에 맞지 않으면, User 객체 생성에 실패한다.
-
-**🔗 통합 테스트**
-
-- [ ]  회원 가입시 User 저장이 수행된다. ( spy 검증 )
-- [ ]  이미 가입된 ID 로 회원가입 시도 시, 실패한다.
-
-**🌐 E2E 테스트**
-
-- [ ]  회원 가입이 성공할 경우, 생성된 유저 정보를 응답으로 반환한다.
-- [ ]  회원 가입 시에 성별이 없을 경우, `400 Bad Request` 응답을 반환한다.
-
-### 내 정보 조회
-
-**🔗 통합 테스트**
-
-- [ ]  해당 ID 의 회원이 존재할 경우, 회원 정보가 반환된다.
-- [ ]  해당 ID 의 회원이 존재하지 않을 경우, null 이 반환된다.
-
-**🌐 E2E 테스트**
-
-- [ ]  내 정보 조회에 성공할 경우, 해당하는 유저 정보를 응답으로 반환한다.
-- [ ]  존재하지 않는 ID 로 조회할 경우, `404 Not Found` 응답을 반환한다.
-
-### 포인트 조회
-
-**🔗 통합 테스트**
-
-- [ ]  해당 ID 의 회원이 존재할 경우, 보유 포인트가 반환된다.
-- [ ]  해당 ID 의 회원이 존재하지 않을 경우, null 이 반환된다.
-
-**🌐 E2E 테스트**
-
-- [ ]  포인트 조회에 성공할 경우, 보유 포인트를 응답으로 반환한다.
-- [ ]  `X-USER-ID` 헤더가 없을 경우, `400 Bad Request` 응답을 반환한다.
diff --git a/.cursor/rules/domain-coupon.mdc b/.cursor/rules/domain-coupon.mdc
new file mode 100644
index 000000000..e54c033c8
--- /dev/null
+++ b/.cursor/rules/domain-coupon.mdc
@@ -0,0 +1,37 @@
+---
+description: Coupon 도메인 작업 시 적용. 쿠폰 템플릿, 발급 쿠폰, 주문 할인 관련.
+globs: ["**/domain/coupon/**", "**/application/coupon/**", "**/infrastructure/coupon/**", "**/interfaces/api/coupon/**"]
+alwaysApply: false
+---
+
+# Coupon 도메인 규칙
+
+- `domain/coupon/README.md`, `CLAUDE.md` 참조
+
+## 도메인 모델
+
+- **CouponTemplate**: Admin이 생성하는 쿠폰 종류 정의 (정액 FIXED / 정률 RATE)
+- **IssuedCoupon**: 사용자에게 발급된 개별 쿠폰. 상태 관리 (AVAILABLE → USED)
+- CouponTemplate과 IssuedCoupon은 ID 참조 관계 (JPA 연관관계 X)
+
+## 핵심 규칙
+
+- 쿠폰은 1회만 사용 가능. `IssuedCoupon.use()`로 상태 전이
+- 쿠폰 사용 시 반드시 **비관적 락**(`findByIdForUpdate`) 사용
+- 쿠폰 소유자 검증: `validateOwnership(memberId)`
+- 쿠폰 만료 검증: `CouponTemplate.isExpired()`
+- 최소 주문 금액 검증: `CouponTemplate.validateMinOrderAmount()`
+- 할인 계산: `CouponTemplate.calculateDiscount(orderAmount)`
+  - FIXED: min(value, orderAmount)
+  - RATE: orderAmount * value / 100
+
+## 주문과의 관계
+
+- 쿠폰은 Order 도메인과 다른 도메인. 조합은 `OrderService`(Application Layer)에서 담당
+- Order 엔티티에 `couponId`, `originalAmount`, `discountAmount` 스냅샷 저장
+- 주문 실패 시 트랜잭션 롤백으로 쿠폰 사용도 함께 롤백
+
+## 동시성
+
+- IssuedCoupon: `PESSIMISTIC_WRITE` 락으로 동시 사용 방지
+- 동일 쿠폰으로 동시 주문 시 1건만 성공, 나머지 실패
diff --git a/CLAUDE.md b/CLAUDE.md
new file mode 100644
index 000000000..daad56c7c
--- /dev/null
+++ b/CLAUDE.md
@@ -0,0 +1,187 @@
+# CLAUDE.md
+
+AI 어시스턴트가 본 프로젝트의 코딩 규칙, 아키텍처, 도메인 설계 전략을 준수하도록 안내하는 문서입니다.
+
+---
+
+## 객체지향 & 도메인 모델링 규칙
+
+### 핵심 원칙
+
+- **도메인 객체는 비즈니스 규칙을 캡슐화**한다. 데이터 저장소가 아닌, 규칙과 행위를 가진 객체로 설계한다.
+- **애플리케이션 서비스**는 서로 다른 도메인을 조립하고, 도메인 로직을 조정하여 기능을 제공한다. 비즈니스 규칙을 직접 구현하지 않는다.
+- **규칙이 여러 서비스에 반복되면** 도메인 객체(Entity, VO, Domain Service)로 옮길 가능성이 높다.
+- 각 기능의 **책임과 결합도**를 명확히 하고, 개발 의도에 맞게 설계한다.
+
+### Entity 설계
+
+- **고유 식별자(ID)**를 가지며, 자신의 상태를 변경하는 **행위 메서드**를 제공한다.
+- `changePassword()`, `cancelOrder()`, `decreaseStock()`처럼 **의도가 드러나는 메서드명**을 사용한다.
+- **무분별한 Setter 사용을 금지**한다. 상태 변경은 반드시 도메인 메서드를 통해 이루어진다.
+- 생성자와 비즈니스 메서드 내부에서 **필수 검증**을 수행한다.
+
+### Value Object (VO) 설계
+
+- **식별자가 없는** 값 객체이다.
+- **불변(Immutable)**으로 설계하고, 생성 시점에 **자체 검증 로직**을 포함한다.
+- `Money`, `Quantity`, `LoginId`, `Email`처럼 의미 있는 단위로 분리한다.
+- 동일성은 **값의 동등성**으로 판단한다.
+
+### Domain Service 설계
+
+- **특정 엔티티에 두기 어려운** 여러 엔티티 간 조율이나 복잡한 도메인 정책을 처리한다.
+- **무상태(Stateless)**로 설계한다.
+- **동일한 도메인 경계 내**의 도메인 객체 협력에 집중한다.
+- 도메인 내부 규칙은 Domain Service에 두고, Application Layer는 조합만 담당한다.
+
+### 빈약한 도메인 모델 지양
+
+- 비즈니스 로직을 Application Service에 두지 말고, **Entity와 VO 내부에 응집**시킨다.
+- Getter/Setter만 있는 데이터 클래스는 지양하고, **행위가 드러나는 메서드**를 우선한다.
+
+---
+
+## 아키텍처 전략 & 패키지 구성
+
+### 레이어드 아키텍처 + DIP
+
+- 본 프로젝트는 **레이어드 아키텍처**를 따르며, **DIP(의존성 역전 원칙)**를 준수한다.
+- 의존성 방향: **Infrastructure → Domain ← Application**
+- **Domain Layer**는 외부 기술(JPA, Spring 등)에 의존하지 않는다.
+
+### 계층 구조
+
+```
+Application  ──→  Domain  ←──  Infrastructure
+     │                │              │
+     │                │              └── Repository 구현체, JPA Entity, Mapper
+     │                └── Entity, VO, Domain Service, Repository Interface
+     └── Service, Facade (도메인 조합, 흐름 제어)
+```
+
+- **Interfaces (Presentation)**: HTTP 요청/응답, Request/Response DTO, 입력 검증. 비즈니스 로직 없음.
+- **Application**: 트랜잭션 관리, 도메인 조합, 흐름 제어. 로직은 도메인에 위임.
+- **Domain**: 순수 도메인 객체, Repository Interface. 외부 의존성 0%.
+- **Infrastructure**: Repository 구현체, JPA Entity, DB/Redis 등 기술 구현.
+
+### DTO 분리
+
+- **API Request/Response DTO**와 **Application Layer DTO**는 분리해 작성한다.
+- API DTO는 `interfaces.api.*`에, Application DTO는 `application.*`에 위치한다.
+
+### 패키지 구성
+
+4개 레이어 패키지를 두고, 하위에 **도메인별**로 패키징한다.
+
+```
+/interfaces/api/{domain}     # Presentation - API Controller, API DTO
+/application/{domain}       # Application - Service, Facade, Application DTO
+/domain/{domain}            # Domain - Entity, VO, Domain Service, Repository Interface
+/infrastructure/{domain}    # Infrastructure - Repository 구현체, JPA Entity, Mapper
+```
+
+**예시**
+
+```
+com.loopers
+├── interfaces
+│   └── api
+│       ├── product
+│       ├── order
+│       └── like
+├── application
+│   ├── product
+│   │   ├── ProductFacade
+│   │   └── ProductInfo
+│   └── order
+│       └── OrderService
+├── domain
+│   ├── product
+│   │   ├── Product
+│   │   ├── Brand
+│   │   ├── Stock
+│   │   └── ProductRepository
+│   ├── like
+│   │   ├── Like
+│   │   └── LikeRepository
+│   └── order
+│       ├── Order
+│       ├── OrderLine
+│       └── OrderRepository
+└── infrastructure
+    ├── product
+    │   ├── ProductRepositoryImpl
+    │   └── ProductJpaRepository
+    └── order
+        └── OrderRepositoryImpl
+```
+
+### Service vs Facade
+
+- **Service**: 트랜잭션 관리, **상태 변경**이 있는 복잡한 비즈니스 흐름. 도메인 객체에 위임.
+- **Facade**: **상태 변경 없이** 여러 도메인의 데이터를 조회·조합(Aggregation)하여 반환.
+
+---
+
+## 도메인 설계 가이드 (Product, Brand, Like, Order)
+
+### Product / Brand
+
+- 상품 정보는 **브랜드 정보**, **좋아요 수**를 포함한다.
+- 상품 정렬 조건(`latest`, `price_asc`, `likes_desc`)은 **조회 시점**에 적용한다.
+- 상품은 **재고(Stock)**를 가지며, 주문 시 **도메인 레벨**에서 차감한다.
+- **재고 음수 방지**는 Entity 또는 Domain Service에서 처리한다.
+
+### Like
+
+- 좋아요는 **유저와 상품 간 관계**로 별도 도메인으로 분리한다.
+- 상품의 좋아요 수는 **조회 시점에 집계**하여 상품 상세/목록에 함께 제공한다.
+- 상품이 좋아요 수를 **직접 관리하지 않는다**. Like 도메인이 집계를 담당한다.
+
+### Order
+
+- 주문은 **여러 상품**을 포함하며, 각 상품의 **수량**을 명시한다.
+- 주문 시 **상품 재고 차감**을 수행한다. 재고 부족 시 예외 처리한다.
+- Order, Product, Stock 간 협력은 **Domain Service**에서 조율한다.
+
+---
+
+## Feature Suggestions (설계 의사결정 가이드)
+
+### Q1. 상품이 좋아요 수를 직접 관리해야 할까?
+
+**아니오.** 좋아요 수는 Like 도메인에서 집계한다. Product는 `likeCount`를 필드로 가지지 않고, 조회 시점에 Application Layer 또는 Facade에서 Product + Like를 조합해 제공한다. 이렇게 하면 좋아요 등록/취소 시 Product를 수정할 필요가 없고, Like 도메인이 단일 책임을 가진다.
+
+### Q2. 상품 상세에서 브랜드를 함께 제공하려면 누가 조합해야 할까?
+
+**Application Layer (ProductFacade)**가 조합한다. `ProductFacade.getProductDetail(productId)`에서 Product, Brand, Like를 조회해 하나의 DTO로 조합한다. Domain Layer는 각자 자신의 책임만 수행하고, 조합은 Application의 역할이다.
+
+### Q3. VO를 도입한 이유는 무엇이며, 어느 시점에서 유리하게 작용했는가?
+
+- **검증 로직 응집**: `Money`, `Quantity`처럼 생성 시점에 유효성 검증을 캡슐화한다.
+- **불변성 보장**: 값이 변경되지 않아 부작용을 줄인다.
+- **의미 표현**: `Price price`가 `long price`보다 의도를 잘 드러낸다.
+- **재사용**: 여러 Entity에서 동일한 VO를 사용해 일관된 규칙을 적용한다.
+
+### Q4. Order, Product, User 중 누가 어떤 책임을 갖는 것이 자연스러웠나?
+
+- **Order**: 주문 생성, 주문 라인 관리, 주문 상태 변경. "주문한다"는 Order의 책임.
+- **Product**: 상품 정보, 재고 차감(`decreaseStock()`). "재고를 줄인다"는 Product(또는 Stock)의 책임.
+- **User/Member**: 회원 정보, 인증. 주문 시에는 식별자만 참조한다.
+- **Domain Service**: Order와 Product 간 재고 차감·검증 등 **여러 엔티티 협력**은 Domain Service가 조율한다.
+
+### Q5. Repository Interface를 Domain Layer에 두는 이유는?
+
+**DIP 적용**을 위해서다. Application/Domain은 "저장·조회" 인터페이스만 알고, 실제 구현(JDBC, JPA 등)은 Infrastructure에 둔다. Domain이 Infrastructure에 의존하지 않도록 인터페이스를 Domain에 두고, 구현체가 이를 따른다.
+
+### Q6. 처음엔 도메인에 두려 했지만, 결국 Application Layer로 옮긴 이유는?
+
+- **트랜잭션 경계**: `@Transactional`은 Application Layer에서 관리하는 것이 자연스럽다.
+- **여러 도메인 조합**: Product + Brand + Like 조합은 단일 도메인 책임을 넘어서므로 Application(Facade)에 둔다.
+- **외부 의존성**: Domain은 Spring, JPA 등에 의존하지 않아야 하므로, 트랜잭션 어노테이션을 쓰는 클래스는 Application에 둔다.
+
+### Q7. 테스트 가능한 구조를 만들기 위해 가장 먼저 고려한 건 무엇이었나?
+
+- **Repository Interface 분리**: Domain에 인터페이스를 두고, 단위 테스트에서는 **Fake/Stub 구현체**를 주입한다.
+- **도메인 로직 순수성**: Entity, VO, Domain Service가 외부 의존 없이 동작하도록 설계해, **단위 테스트만으로** 비즈니스 규칙을 검증한다.
+- **의존성 주입**: Service가 Repository 인터페이스에 의존하도록 해, 테스트 시 Mock/Fake로 대체 가능하게 한다.
diff --git a/SKILLS.md b/SKILLS.md
new file mode 100644
index 000000000..7ab588e47
--- /dev/null
+++ b/SKILLS.md
@@ -0,0 +1,97 @@
+# 4주차: 동시성과 락 (Concurrency & Locking)
+
+> 부트캠프 4주차 학습 로드맵
+
+---
+
+## 학습 목표
+
+재고 차감 시 발생할 수 있는 **동시성 문제**를 이해하고, 다양한 **락(Lock) 전략**을 직접 구현해본다.
+
+---
+
+## 학습 단계
+
+### Phase 1: 문제 인식
+- [ ] **Step 1.1** - 동시성 문제란 무엇인가?
+- [ ] **Step 1.2** - 현재 코드에서 문제가 발생하는 시나리오 이해
+- [ ] **Step 1.3** - 동시성 테스트 코드 작성 (문제 재현)
+
+### Phase 2: 데이터베이스 락
+- [ ] **Step 2.1** - 비관적 락 (Pessimistic Lock) 이해
+- [ ] **Step 2.2** - 비관적 락 구현
+- [ ] **Step 2.3** - 비관적 락 테스트
+
+- [ ] **Step 2.4** - 낙관적 락 (Optimistic Lock) 이해
+- [ ] **Step 2.5** - 낙관적 락 구현
+- [ ] **Step 2.6** - 낙관적 락 테스트
+
+### Phase 3: 분산 락
+- [ ] **Step 3.1** - 분산 락이 필요한 이유
+- [ ] **Step 3.2** - Redis 분산 락 구현
+- [ ] **Step 3.3** - 분산 락 테스트
+
+### Phase 4: 비교 및 정리
+- [ ] **Step 4.1** - 각 방식 성능 비교
+- [ ] **Step 4.2** - 상황별 선택 기준 정리
+- [ ] **Step 4.3** - 면접 대비 정리
+
+---
+
+## 현재 진행 상황
+
+**현재 단계**: Step 1.1 - 동시성 문제란 무엇인가?
+
+---
+
+## Step 1.1 - 동시성 문제란 무엇인가?
+
+### 핵심 개념
+
+**동시성 문제 (Concurrency Problem)**
+- 여러 스레드/요청이 **동시에 같은 데이터**를 수정할 때 발생
+- 예상과 다른 결과가 나오는 현상
+
+### 대표적인 문제: Lost Update (갱신 손실)
+
+```
+[상황] 재고 10개인 상품에 2명이 동시에 1개씩 주문
+
+[기대 결과] 재고 = 8개
+
+[실제 발생할 수 있는 결과]
+  시간  |  User A          |  User B          |  DB 재고
+  ──────────────────────────────────────────────────────
+  T1   |  재고 조회 (10)   |                   |  10
+  T2   |                   |  재고 조회 (10)   |  10
+  T3   |  재고 = 10-1 = 9  |                   |  10
+  T4   |  저장 (9)         |                   |  9
+  T5   |                   |  재고 = 10-1 = 9  |  9
+  T6   |                   |  저장 (9)         |  9  ← 문제!
+
+[결과] 재고 = 9개 (1개 손실!)
+```
+
+### 현재 우리 코드의 문제점
+
+```java
+// OrderDomainService.java
+public Order placeOrder(Long memberId, List<OrderLineRequest> items) {
+    for (OrderLineRequest item : items) {
+        Product product = productRepository.findById(item.productId());  // ① 조회
+        product.decreaseStock(item.quantity());  // ② 차감 (메모리에서)
+        // ③ 트랜잭션 종료 시 저장 → 이 사이에 다른 요청이 끼어들 수 있음!
+    }
+    ...
+}
+```
+
+**① ~ ③ 사이에 다른 요청이 같은 상품을 조회하면?** → Lost Update 발생!
+
+---
+
+## 다음 단계
+
+Step 1.2에서는 이 문제를 **직접 테스트 코드로 재현**해봅니다.
+
+준비되면 말씀해주세요!
diff --git a/apps/commerce-api/build.gradle.kts b/apps/commerce-api/build.gradle.kts
index 03ce68f02..cb54a44be 100644
--- a/apps/commerce-api/build.gradle.kts
+++ b/apps/commerce-api/build.gradle.kts
@@ -8,6 +8,7 @@ dependencies {
 
     // web
     implementation("org.springframework.boot:spring-boot-starter-web")
+    implementation("org.springframework.security:spring-security-crypto")
     implementation("org.springframework.boot:spring-boot-starter-actuator")
     implementation("org.springdoc:springdoc-openapi-starter-webmvc-ui:${project.properties["springDocOpenApiVersion"]}")
 
diff --git a/apps/commerce-api/docs/README.md b/apps/commerce-api/docs/README.md
new file mode 100644
index 000000000..04099d0bd
--- /dev/null
+++ b/apps/commerce-api/docs/README.md
@@ -0,0 +1,28 @@
+# Commerce API 문서
+
+Claude Code / AI 어시스턴트 작업 시 참고할 도메인별 문서입니다.
+
+## 문서 위치
+
+각 구현체(도메인, Application Layer) 폴더에 README.md가 있습니다.
+
+| 영역 | 경로 |
+|------|------|
+| Product/Brand 도메인 | `src/main/java/com/loopers/domain/product/README.md` |
+| Like 도메인 | `src/main/java/com/loopers/domain/like/README.md` |
+| Order 도메인 | `src/main/java/com/loopers/domain/order/README.md` |
+| Product Application | `src/main/java/com/loopers/application/product/README.md` |
+| Like Application | `src/main/java/com/loopers/application/like/README.md` |
+| Order Application | `src/main/java/com/loopers/application/order/README.md` |
+
+## Cursor Rules
+
+`.cursor/rules/`에 도메인별 규칙이 등록되어 있습니다. 해당 경로의 파일을 편집할 때 자동으로 적용됩니다.
+
+- `domain-product.mdc` — Product, Brand 관련
+- `domain-like.mdc` — Like 관련
+- `domain-order.mdc` — Order 관련
+
+## 전체 아키텍처
+
+프로젝트 루트의 `CLAUDE.md`를 참고하세요.
diff --git a/apps/commerce-api/src/main/java/com/loopers/application/coupon/CouponAdminService.java b/apps/commerce-api/src/main/java/com/loopers/application/coupon/CouponAdminService.java
new file mode 100644
index 000000000..10c0cd3a1
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/application/coupon/CouponAdminService.java
@@ -0,0 +1,78 @@
+package com.loopers.application.coupon;
+
+import com.loopers.domain.coupon.CouponTemplate;
+import com.loopers.domain.coupon.CouponTemplateRepository;
+import com.loopers.domain.coupon.CouponType;
+import com.loopers.domain.coupon.IssuedCoupon;
+import com.loopers.domain.coupon.IssuedCouponRepository;
+import com.loopers.support.error.CoreException;
+import com.loopers.support.error.ErrorType;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.time.ZonedDateTime;
+import java.util.List;
+
+@RequiredArgsConstructor
+@Component
+public class CouponAdminService {
+
+    private final CouponTemplateRepository couponTemplateRepository;
+    private final IssuedCouponRepository issuedCouponRepository;
+
+    @Transactional
+    public CouponInfo.CouponTemplateInfo create(String name, CouponType type, long value,
+                                                 Long minOrderAmount, ZonedDateTime expiredAt) {
+        CouponTemplate template = new CouponTemplate(name, type, value, minOrderAmount, expiredAt);
+        CouponTemplate saved = couponTemplateRepository.save(template);
+        return CouponInfo.CouponTemplateInfo.from(saved);
+    }
+
+    @Transactional(readOnly = true)
+    public CouponInfo.CouponTemplateInfo getTemplate(Long couponId) {
+        CouponTemplate template = couponTemplateRepository.findById(couponId)
+            .orElseThrow(() -> new CoreException(ErrorType.COUPON_NOT_FOUND));
+        return CouponInfo.CouponTemplateInfo.from(template);
+    }
+
+    @Transactional(readOnly = true)
+    public List<CouponInfo.CouponTemplateInfo> getTemplates(int page, int size) {
+        return couponTemplateRepository.findAll(page, size).stream()
+            .map(CouponInfo.CouponTemplateInfo::from)
+            .toList();
+    }
+
+    @Transactional(readOnly = true)
+    public long getTemplateCount() {
+        return couponTemplateRepository.count();
+    }
+
+    @Transactional
+    public CouponInfo.CouponTemplateInfo update(Long couponId, String name, CouponType type, long value,
+                                                 Long minOrderAmount, ZonedDateTime expiredAt) {
+        CouponTemplate template = couponTemplateRepository.findById(couponId)
+            .orElseThrow(() -> new CoreException(ErrorType.COUPON_NOT_FOUND));
+        template.update(name, type, value, minOrderAmount, expiredAt);
+        return CouponInfo.CouponTemplateInfo.from(template);
+    }
+
+    @Transactional
+    public void delete(Long couponId) {
+        CouponTemplate template = couponTemplateRepository.findById(couponId)
+            .orElseThrow(() -> new CoreException(ErrorType.COUPON_NOT_FOUND));
+        template.delete();
+    }
+
+    @Transactional(readOnly = true)
+    public List<CouponInfo.IssuedCouponDetailInfo> getIssuedCoupons(Long couponId, int page, int size) {
+        return issuedCouponRepository.findByCouponTemplateId(couponId, page, size).stream()
+            .map(CouponInfo.IssuedCouponDetailInfo::from)
+            .toList();
+    }
+
+    @Transactional(readOnly = true)
+    public long getIssuedCouponCount(Long couponId) {
+        return issuedCouponRepository.countByCouponTemplateId(couponId);
+    }
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/application/coupon/CouponFacade.java b/apps/commerce-api/src/main/java/com/loopers/application/coupon/CouponFacade.java
new file mode 100644
index 000000000..923e0a0fd
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/application/coupon/CouponFacade.java
@@ -0,0 +1,31 @@
+package com.loopers.application.coupon;
+
+import com.loopers.domain.coupon.CouponTemplate;
+import com.loopers.domain.coupon.CouponTemplateRepository;
+import com.loopers.domain.coupon.IssuedCoupon;
+import com.loopers.domain.coupon.IssuedCouponRepository;
+import com.loopers.support.error.CoreException;
+import com.loopers.support.error.ErrorType;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Component;
+
+import java.util.List;
+
+@RequiredArgsConstructor
+@Component
+public class CouponFacade {
+
+    private final IssuedCouponRepository issuedCouponRepository;
+    private final CouponTemplateRepository couponTemplateRepository;
+
+    public List<CouponInfo.IssuedCouponInfo> getMyCoupons(Long memberId) {
+        List<IssuedCoupon> issuedCoupons = issuedCouponRepository.findByMemberId(memberId);
+        return issuedCoupons.stream()
+            .map(issued -> {
+                CouponTemplate template = couponTemplateRepository.findById(issued.getCouponTemplateId())
+                    .orElseThrow(() -> new CoreException(ErrorType.COUPON_NOT_FOUND));
+                return CouponInfo.IssuedCouponInfo.of(issued, template);
+            })
+            .toList();
+    }
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/application/coupon/CouponInfo.java b/apps/commerce-api/src/main/java/com/loopers/application/coupon/CouponInfo.java
new file mode 100644
index 000000000..06504c0c4
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/application/coupon/CouponInfo.java
@@ -0,0 +1,81 @@
+package com.loopers.application.coupon;
+
+import com.loopers.domain.coupon.CouponStatus;
+import com.loopers.domain.coupon.CouponTemplate;
+import com.loopers.domain.coupon.CouponType;
+import com.loopers.domain.coupon.IssuedCoupon;
+
+import java.time.ZonedDateTime;
+
+public class CouponInfo {
+
+    public record IssuedCouponInfo(
+        Long issuedCouponId,
+        Long couponTemplateId,
+        String name,
+        CouponType type,
+        long value,
+        Long minOrderAmount,
+        CouponStatus status,
+        ZonedDateTime expiredAt,
+        ZonedDateTime usedAt
+    ) {
+        public static IssuedCouponInfo of(IssuedCoupon issued, CouponTemplate template) {
+            CouponStatus effectiveStatus = issued.getStatus();
+            if (effectiveStatus == CouponStatus.AVAILABLE && template.isExpired()) {
+                effectiveStatus = CouponStatus.EXPIRED;
+            }
+            return new IssuedCouponInfo(
+                issued.getId(),
+                template.getId(),
+                template.getName(),
+                template.getType(),
+                template.getValue(),
+                template.getMinOrderAmount(),
+                effectiveStatus,
+                template.getExpiredAt(),
+                issued.getUsedAt()
+            );
+        }
+    }
+
+    public record CouponTemplateInfo(
+        Long id,
+        String name,
+        CouponType type,
+        long value,
+        Long minOrderAmount,
+        ZonedDateTime expiredAt,
+        ZonedDateTime createdAt
+    ) {
+        public static CouponTemplateInfo from(CouponTemplate template) {
+            return new CouponTemplateInfo(
+                template.getId(),
+                template.getName(),
+                template.getType(),
+                template.getValue(),
+                template.getMinOrderAmount(),
+                template.getExpiredAt(),
+                template.getCreatedAt()
+            );
+        }
+    }
+
+    public record IssuedCouponDetailInfo(
+        Long issuedCouponId,
+        Long memberId,
+        CouponStatus status,
+        ZonedDateTime usedAt,
+        ZonedDateTime createdAt
+    ) {
+        public static IssuedCouponDetailInfo from(IssuedCoupon issued) {
+            return new IssuedCouponDetailInfo(
+                issued.getId(),
+                issued.getMemberId(),
+                issued.getStatus(),
+                issued.getUsedAt(),
+                issued.getCreatedAt()
+            );
+        }
+    }
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/application/coupon/CouponService.java b/apps/commerce-api/src/main/java/com/loopers/application/coupon/CouponService.java
new file mode 100644
index 000000000..95fbd73a9
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/application/coupon/CouponService.java
@@ -0,0 +1,36 @@
+package com.loopers.application.coupon;
+
+import com.loopers.domain.coupon.CouponTemplate;
+import com.loopers.domain.coupon.CouponTemplateRepository;
+import com.loopers.domain.coupon.IssuedCoupon;
+import com.loopers.domain.coupon.IssuedCouponRepository;
+import com.loopers.support.error.CoreException;
+import com.loopers.support.error.ErrorType;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+
+@RequiredArgsConstructor
+@Component
+public class CouponService {
+
+    private final CouponTemplateRepository couponTemplateRepository;
+    private final IssuedCouponRepository issuedCouponRepository;
+
+    @Transactional
+    public CouponInfo.IssuedCouponInfo issue(Long memberId, Long couponTemplateId) {
+        CouponTemplate template = couponTemplateRepository.findById(couponTemplateId)
+            .orElseThrow(() -> new CoreException(ErrorType.COUPON_NOT_FOUND));
+
+        if (template.isExpired()) {
+            throw new CoreException(ErrorType.COUPON_EXPIRED);
+        }
+
+        if (issuedCouponRepository.existsByMemberIdAndCouponTemplateId(memberId, couponTemplateId)) {
+            throw new CoreException(ErrorType.COUPON_ALREADY_ISSUED);
+        }
+
+        IssuedCoupon issuedCoupon = issuedCouponRepository.save(new IssuedCoupon(couponTemplateId, memberId));
+        return CouponInfo.IssuedCouponInfo.of(issuedCoupon, template);
+    }
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/application/like/LikeService.java b/apps/commerce-api/src/main/java/com/loopers/application/like/LikeService.java
new file mode 100644
index 000000000..4bb889d4d
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/application/like/LikeService.java
@@ -0,0 +1,33 @@
+package com.loopers.application.like;
+
+import com.loopers.domain.like.Like;
+import com.loopers.domain.like.LikeRepository;
+import com.loopers.domain.product.ProductRepository;
+import com.loopers.support.error.CoreException;
+import com.loopers.support.error.ErrorType;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+
+@RequiredArgsConstructor
+@Component
+public class LikeService {
+
+    private final LikeRepository likeRepository;
+    private final ProductRepository productRepository;
+
+    @Transactional
+    public void like(Long memberId, Long productId) {
+        if (likeRepository.existsByMemberIdAndProductId(memberId, productId)) {
+            return;
+        }
+        productRepository.findById(productId)
+            .orElseThrow(() -> new CoreException(ErrorType.NOT_FOUND, "[id = " + productId + "] 상품을 찾을 수 없습니다."));
+        likeRepository.save(new Like(memberId, productId));
+    }
+
+    @Transactional
+    public void unlike(Long memberId, Long productId) {
+        likeRepository.deleteByMemberIdAndProductId(memberId, productId);
+    }
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/application/like/README.md b/apps/commerce-api/src/main/java/com/loopers/application/like/README.md
new file mode 100644
index 000000000..e500a78d5
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/application/like/README.md
@@ -0,0 +1,29 @@
+# Like Application Layer
+
+> Claude Code 작업 시 이 영역의 설계 의도와 규칙을 참고하세요.
+
+## 책임
+
+- **LikeService**: 좋아요 등록/취소. 트랜잭션 관리, 도메인에 위임.
+
+## 설계 규칙
+
+1. **Service = 트랜잭션 + 흐름 제어**  
+   비즈니스 로직은 Like, Product 도메인에 위임.
+
+2. **멱등성**  
+   `like()` — 이미 존재하면 무시. `unlike()` — 없어도 예외 없음.
+
+3. **Product 존재 검증**  
+   좋아요 등록 전 `productRepository.findById()`로 상품 존재 확인.
+
+## 주요 클래스
+
+| 클래스 | 역할 |
+|--------|------|
+| LikeService | like(), unlike() |
+
+## 참조
+
+- [domain/like README](../../domain/like/README.md) — Like 도메인 규칙
+- [CLAUDE.md](/CLAUDE.md) — 전체 아키텍처 규칙
diff --git a/apps/commerce-api/src/main/java/com/loopers/application/order/OrderService.java b/apps/commerce-api/src/main/java/com/loopers/application/order/OrderService.java
new file mode 100644
index 000000000..20bf8e98d
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/application/order/OrderService.java
@@ -0,0 +1,138 @@
+package com.loopers.application.order;
+
+import com.loopers.domain.coupon.CouponTemplate;
+import com.loopers.domain.coupon.CouponTemplateRepository;
+import com.loopers.domain.coupon.IssuedCoupon;
+import com.loopers.domain.coupon.IssuedCouponRepository;
+import com.loopers.domain.order.Order;
+import com.loopers.domain.order.OrderDomainService;
+import com.loopers.domain.order.OrderDomainService.OrderLineRequest;
+import com.loopers.domain.order.OrderLine;
+import com.loopers.support.error.CoreException;
+import com.loopers.support.error.ErrorType;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+@RequiredArgsConstructor
+@Component
+public class OrderService {
+
+    private final OrderDomainService orderDomainService;
+    private final IssuedCouponRepository issuedCouponRepository;
+    private final CouponTemplateRepository couponTemplateRepository;
+
+    /**
+     * 주문 처리: 쿠폰 검증 → 재고 차감 → 주문 생성을 하나의 트랜잭션으로 묶는다.
+     *
+     * ─── 트랜잭션 범위 설계 ────────────────────────────────────────────────────
+     * 트랜잭션 범위를 크게 잡으면 락 보유 시간이 길어져 처리량(throughput)이 낮아진다.
+     * 트랜잭션 범위를 작게 잡으면 원자성이 깨질 수 있다.
+     *
+     * 이 메서드가 트랜잭션 경계를 담당하는 이유:
+     * 1. 재고 차감, 쿠폰 사용, 주문 생성은 하나라도 실패하면 모두 롤백해야 한다.
+     *    → 세 작업이 반드시 같은 트랜잭션 안에 있어야 한다.
+     * 2. 단순 검증(쿠폰 만료 여부, 소유자 확인)은 상태를 변경하지 않는다.
+     *    → 가능하면 락 획득 전 또는 트랜잭션 시작 직후에 처리해 락 보유 시간을 줄인다.
+     *
+     * ─── 락 획득 순서와 데드락 방지 ──────────────────────────────────────────
+     * 쿠폰 락과 재고 락이 동시에 필요할 때, 획득 순서가 일정하지 않으면 데드락 발생 가능.
+     *
+     * 설계 원칙: 쿠폰 락 → 상품 락 순서를 항상 유지한다.
+     *   - 쿠폰은 1건이므로 먼저 획득한다.
+     *   - 상품은 여러 개일 수 있으므로, productId 오름차순으로 순차 획득한다.
+     *     (OrderDomainService.prepareOrderLines 내부에서 처리)
+     *
+     * 이 순서를 모든 트랜잭션에서 동일하게 유지하면, 순환 대기 조건이 성립하지 않아
+     * 데드락이 발생하지 않는다.
+     *
+     * ─── 쿠폰: 비관적 락 선택 근거 ──────────────────────────────────────────
+     * 쿠폰은 "단 1회만 사용 가능"이라는 엄격한 제약이 있다.
+     * 같은 쿠폰으로 여러 기기에서 동시에 주문을 시도하면 Lost Update 문제가 발생한다:
+     *   Thread 1: coupon 조회(status=AVAILABLE) → Thread 2: coupon 조회(status=AVAILABLE)
+     *   → 둘 다 사용 가능하다고 판단 → 둘 다 USED로 변경 → 중복 사용
+     *
+     * findByIdForUpdate로 조회 시 DB 레벨 행 잠금 획득.
+     * Thread 2는 Thread 1의 트랜잭션이 끝날 때까지 대기하고,
+     * Thread 1 커밋 후 Thread 2가 읽으면 status=USED → 예외 발생 → 중복 사용 방지.
+     *
+     * 낙관적 락(@Version) 고려:
+     * 가능은 하지만, 쿠폰 중복 사용은 "실패"보다 "방지"가 우선이다.
+     * OptimisticLockException 후 재시도 시 사용 가능한 쿠폰이 없으면 결국 실패이므로
+     * 비관적 락이 더 명확한 의도를 드러낸다.
+     */
+    @Transactional
+    public OrderResult placeOrder(Long memberId, List<OrderLineRequest> items, Long couponId) {
+        IssuedCoupon issuedCoupon = null;
+        CouponTemplate couponTemplate = null;
+
+        if (couponId != null) {
+            // 1단계: 쿠폰 비관적 락 획득 (SELECT FOR UPDATE)
+            //        이 시점 이후로 다른 트랜잭션은 같은 쿠폰 행 수정 불가
+            issuedCoupon = issuedCouponRepository.findByIdForUpdate(couponId)
+                .orElseThrow(() -> new CoreException(ErrorType.COUPON_NOT_FOUND));
+
+            // 소유자 검증: 도메인 메서드에 위임 (비즈니스 규칙 캡슐화)
+            issuedCoupon.validateOwnership(memberId);
+
+            // 사용 가능 상태 확인: USED 또는 EXPIRED면 주문 거부
+            if (!issuedCoupon.isUsable()) {
+                throw new CoreException(ErrorType.COUPON_UNAVAILABLE);
+            }
+
+            // 쿠폰 템플릿 조회: 할인 계산에 필요 (락 불필요 - 읽기 전용)
+            couponTemplate = couponTemplateRepository.findById(issuedCoupon.getCouponTemplateId())
+                .orElseThrow(() -> new CoreException(ErrorType.COUPON_NOT_FOUND));
+
+            if (couponTemplate.isExpired()) {
+                throw new CoreException(ErrorType.COUPON_EXPIRED);
+            }
+        }
+
+        // 2단계: 재고 차감 (productId 오름차순 비관적 락 획득)
+        //        데드락 방지를 위해 OrderDomainService 내부에서 정렬 후 처리
+        List<OrderLine> orderLines = orderDomainService.prepareOrderLines(items);
+
+        // 3단계: 할인 계산 및 주문 생성
+        //        쿠폰 실제 사용 처리(use())는 주문 생성과 함께 묶어서 원자성 보장
+        //        최소 주문 금액 검증도 이 시점에 실행
+        long originalAmount = orderLines.stream().mapToLong(OrderLine::getTotalPrice).sum();
+
+        Order order;
+        if (issuedCoupon != null) {
+            couponTemplate.validateMinOrderAmount(originalAmount);
+            long discountAmount = couponTemplate.calculateDiscount(originalAmount);
+            order = orderDomainService.createOrderWithCoupon(memberId, orderLines, couponId, discountAmount);
+
+            // 쿠폰 상태 변경: dirty checking으로 트랜잭션 커밋 시 자동 UPDATE
+            // 이 시점에 issuedCoupon은 영속성 컨텍스트에 존재하므로 별도 save() 불필요
+            issuedCoupon.use();
+        } else {
+            order = orderDomainService.createOrder(memberId, orderLines);
+        }
+
+        List<OrderLineInfo> resultLines = order.getOrderLines().stream()
+            .map(ol -> new OrderLineInfo(ol.getProductId(), ol.getQuantity(), ol.getUnitPrice()))
+            .collect(Collectors.toList());
+
+        return new OrderResult(
+            order.getId(), order.getStatus(),
+            order.getOriginalAmount(), order.getDiscountAmount(), order.getTotalAmount(),
+            resultLines
+        );
+    }
+
+    public record OrderResult(
+        Long orderId,
+        String status,
+        long originalAmount,
+        long discountAmount,
+        long totalAmount,
+        List<OrderLineInfo> orderLines
+    ) {}
+
+    public record OrderLineInfo(Long productId, int quantity, long unitPrice) {}
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/application/order/README.md b/apps/commerce-api/src/main/java/com/loopers/application/order/README.md
new file mode 100644
index 000000000..8149cb557
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/application/order/README.md
@@ -0,0 +1,28 @@
+# Order Application Layer
+
+> Claude Code 작업 시 이 영역의 설계 의도와 규칙을 참고하세요.
+
+## 책임
+
+- **OrderService**: 주문 생성. 트랜잭션 관리, OrderDomainService에 위임.
+
+## 설계 규칙
+
+1. **Service = 트랜잭션 + 위임**  
+   `placeOrder()` → `orderDomainService.placeOrder()` 호출.  
+   도메인 로직은 OrderDomainService, Product, Order에 위임.
+
+2. **OrderResult 변환**  
+   Order 엔티티 → OrderResult (orderId, status, totalAmount, orderLines) → API DTO.
+
+## 주요 클래스
+
+| 클래스 | 역할 |
+|--------|------|
+| OrderService | placeOrder() |
+| OrderResult, OrderLineInfo | Application DTO |
+
+## 참조
+
+- [domain/order README](../../domain/order/README.md) — Order 도메인 규칙
+- [CLAUDE.md](/CLAUDE.md) — 전체 아키텍처 규칙
diff --git a/apps/commerce-api/src/main/java/com/loopers/application/product/ProductDetailInfo.java b/apps/commerce-api/src/main/java/com/loopers/application/product/ProductDetailInfo.java
new file mode 100644
index 000000000..b43abe96f
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/application/product/ProductDetailInfo.java
@@ -0,0 +1,27 @@
+package com.loopers.application.product;
+
+import com.loopers.domain.product.Brand;
+import com.loopers.domain.product.Product;
+
+public record ProductDetailInfo(
+    Long id,
+    String name,
+    Long price,
+    int stockQuantity,
+    BrandInfo brand,
+    long likeCount
+) {
+    public record BrandInfo(Long id, String name) {}
+
+    public static ProductDetailInfo of(Product product, Brand brand, long likeCount) {
+        BrandInfo brandInfo = brand != null ? new BrandInfo(brand.getId(), brand.getName()) : null;
+        return new ProductDetailInfo(
+            product.getId(),
+            product.getName(),
+            product.getPrice(),
+            product.getStockQuantity(),
+            brandInfo,
+            likeCount
+        );
+    }
+}
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
new file mode 100644
index 000000000..771d85bd4
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/application/product/ProductFacade.java
@@ -0,0 +1,59 @@
+package com.loopers.application.product;
+
+import com.loopers.domain.product.Brand;
+import com.loopers.domain.product.Product;
+import com.loopers.domain.product.ProductRepository;
+import com.loopers.domain.product.SortCondition;
+import com.loopers.domain.like.LikeRepository;
+import com.loopers.domain.product.BrandRepository;
+import com.loopers.support.error.CoreException;
+import com.loopers.support.error.ErrorType;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Component;
+
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+@RequiredArgsConstructor
+@Component
+public class ProductFacade {
+
+    private final ProductRepository productRepository;
+    private final BrandRepository brandRepository;
+    private final LikeRepository likeRepository;
+
+    public ProductDetailInfo getProductDetail(Long productId) {
+        Product product = productRepository.findById(productId)
+            .orElseThrow(() -> new CoreException(ErrorType.NOT_FOUND, "[id = " + productId + "] 상품을 찾을 수 없습니다."));
+        Brand brand = product.getBrandId() != null
+            ? brandRepository.findById(product.getBrandId())
+                .orElseThrow(() -> new CoreException(ErrorType.NOT_FOUND, "브랜드를 찾을 수 없습니다."))
+            : null;
+        long likeCount = likeRepository.countByProductId(productId);
+        return ProductDetailInfo.of(product, brand, likeCount);
+    }
+
+    public List<ProductListInfo> getProductList(SortCondition sort) {
+        List<Product> products = productRepository.findAll(sort);
+        if (products.isEmpty()) {
+            return List.of();
+        }
+
+        List<Long> brandIds = products.stream()
+            .map(Product::getBrandId)
+            .filter(id -> id != null)
+            .distinct()
+            .toList();
+        Map<Long, Brand> brandMap = brandIds.stream()
+            .flatMap(id -> brandRepository.findById(id).stream())
+            .collect(Collectors.toMap(Brand::getId, b -> b));
+
+        List<Long> productIds = products.stream().map(Product::getId).toList();
+        Map<Long, Long> likeCountMap = likeRepository.countByProductIds(productIds);
+
+        return products.stream()
+            .map(p -> ProductListInfo.of(p, brandMap, likeCountMap))
+            .toList();
+    }
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/application/product/ProductListInfo.java b/apps/commerce-api/src/main/java/com/loopers/application/product/ProductListInfo.java
new file mode 100644
index 000000000..0bc57d49a
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/application/product/ProductListInfo.java
@@ -0,0 +1,31 @@
+package com.loopers.application.product;
+
+import com.loopers.domain.product.Brand;
+import com.loopers.domain.product.Product;
+
+import java.util.Map;
+
+public record ProductListInfo(
+    Long id,
+    String name,
+    Long price,
+    String brandName,
+    long likeCount
+) {
+    public static ProductListInfo of(Product product, Brand brand, long likeCount) {
+        String brandName = brand != null ? brand.getName() : "";
+        return new ProductListInfo(
+            product.getId(),
+            product.getName(),
+            product.getPrice(),
+            brandName,
+            likeCount
+        );
+    }
+
+    public static ProductListInfo of(Product product, Map<Long, Brand> brandMap, Map<Long, Long> likeCountMap) {
+        Brand brand = product.getBrandId() != null ? brandMap.get(product.getBrandId()) : null;
+        long likeCount = likeCountMap.getOrDefault(product.getId(), 0L);
+        return of(product, brand, likeCount);
+    }
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/application/product/README.md b/apps/commerce-api/src/main/java/com/loopers/application/product/README.md
new file mode 100644
index 000000000..32709364b
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/application/product/README.md
@@ -0,0 +1,35 @@
+# Product Application Layer
+
+> Claude Code 작업 시 이 영역의 설계 의도와 규칙을 참고하세요.
+
+## 책임
+
+- **ProductFacade**: 상태 변경 없이 Product + Brand + Like를 조회·조합하여 반환.
+- **ProductDetailInfo, ProductListInfo**: Application DTO (API DTO와 분리).
+
+## 설계 규칙
+
+1. **Facade = 조합 전용**  
+   비즈니스 로직 없음. Domain Repository에서 조회 후 DTO로 변환.
+
+2. **상품 상세 조합**  
+   `getProductDetail(productId)` → Product + Brand + likeCount 조합.
+
+3. **상품 목록 조합**  
+   `getProductList(sort)` → ProductRepository.findAll(sort) + Brand 맵 + Like 집계 맵 → ProductListInfo 리스트.
+
+4. **정렬**  
+   `latest`, `price_asc`, `likes_desc` — ProductRepository에 위임.
+
+## 주요 클래스
+
+| 클래스 | 역할 |
+|--------|------|
+| ProductFacade | getProductDetail, getProductList |
+| ProductDetailInfo | 상세 조회용 DTO |
+| ProductListInfo | 목록 조회용 DTO |
+
+## 참조
+
+- [domain/product README](../../domain/product/README.md) — Product 도메인 규칙
+- [CLAUDE.md](/CLAUDE.md) — 전체 아키텍처 규칙
diff --git a/apps/commerce-api/src/main/java/com/loopers/config/PasswordEncoderConfig.java b/apps/commerce-api/src/main/java/com/loopers/config/PasswordEncoderConfig.java
new file mode 100644
index 000000000..d42feb176
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/config/PasswordEncoderConfig.java
@@ -0,0 +1,15 @@
+package com.loopers.config;
+
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
+import org.springframework.security.crypto.password.PasswordEncoder;
+
+@Configuration
+public class PasswordEncoderConfig {
+
+    @Bean
+    public PasswordEncoder passwordEncoder() {
+        return new BCryptPasswordEncoder();
+    }
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/domain/coupon/CouponStatus.java b/apps/commerce-api/src/main/java/com/loopers/domain/coupon/CouponStatus.java
new file mode 100644
index 000000000..6924faf8e
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/coupon/CouponStatus.java
@@ -0,0 +1,7 @@
+package com.loopers.domain.coupon;
+
+public enum CouponStatus {
+    AVAILABLE,
+    USED,
+    EXPIRED
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/domain/coupon/CouponTemplate.java b/apps/commerce-api/src/main/java/com/loopers/domain/coupon/CouponTemplate.java
new file mode 100644
index 000000000..b0f727e4b
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/coupon/CouponTemplate.java
@@ -0,0 +1,109 @@
+package com.loopers.domain.coupon;
+
+import com.loopers.domain.BaseEntity;
+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.Table;
+
+import java.time.ZonedDateTime;
+
+@Entity
+@Table(name = "coupon_template")
+public class CouponTemplate extends BaseEntity {
+
+    @Column(nullable = false)
+    private String name;
+
+    @Enumerated(EnumType.STRING)
+    @Column(nullable = false)
+    private CouponType type;
+
+    @Column(nullable = false)
+    private long value;
+
+    private Long minOrderAmount;
+
+    @Column(nullable = false)
+    private ZonedDateTime expiredAt;
+
+    protected CouponTemplate() {}
+
+    public CouponTemplate(String name, CouponType type, long value, Long minOrderAmount, ZonedDateTime expiredAt) {
+        validateName(name);
+        validateType(type);
+        validateValue(type, value);
+        validateExpiredAt(expiredAt);
+        this.name = name;
+        this.type = type;
+        this.value = value;
+        this.minOrderAmount = minOrderAmount;
+        this.expiredAt = expiredAt;
+    }
+
+    private void validateName(String name) {
+        if (name == null || name.isBlank()) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "쿠폰 이름은 필수입니다.");
+        }
+    }
+
+    private void validateType(CouponType type) {
+        if (type == null) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "쿠폰 타입은 필수입니다.");
+        }
+    }
+
+    private void validateValue(CouponType type, long value) {
+        if (value <= 0) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "쿠폰 값은 0보다 커야 합니다.");
+        }
+        if (type == CouponType.RATE && value > 100) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "정률 쿠폰의 할인율은 100%를 초과할 수 없습니다.");
+        }
+    }
+
+    private void validateExpiredAt(ZonedDateTime expiredAt) {
+        if (expiredAt == null) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "쿠폰 만료일은 필수입니다.");
+        }
+    }
+
+    public long calculateDiscount(long orderAmount) {
+        if (type == CouponType.FIXED) {
+            return Math.min(value, orderAmount);
+        }
+        return orderAmount * value / 100;
+    }
+
+    public boolean isExpired() {
+        return ZonedDateTime.now().isAfter(expiredAt);
+    }
+
+    public void validateMinOrderAmount(long orderAmount) {
+        if (minOrderAmount != null && orderAmount < minOrderAmount) {
+            throw new CoreException(ErrorType.COUPON_MIN_ORDER_AMOUNT,
+                "최소 주문 금액 " + minOrderAmount + "원 이상이어야 합니다.");
+        }
+    }
+
+    public void update(String name, CouponType type, long value, Long minOrderAmount, ZonedDateTime expiredAt) {
+        validateName(name);
+        validateType(type);
+        validateValue(type, value);
+        validateExpiredAt(expiredAt);
+        this.name = name;
+        this.type = type;
+        this.value = value;
+        this.minOrderAmount = minOrderAmount;
+        this.expiredAt = expiredAt;
+    }
+
+    public String getName() { return name; }
+    public CouponType getType() { return type; }
+    public long getValue() { return value; }
+    public Long getMinOrderAmount() { return minOrderAmount; }
+    public ZonedDateTime getExpiredAt() { return expiredAt; }
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/domain/coupon/CouponTemplateRepository.java b/apps/commerce-api/src/main/java/com/loopers/domain/coupon/CouponTemplateRepository.java
new file mode 100644
index 000000000..a97266a2a
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/coupon/CouponTemplateRepository.java
@@ -0,0 +1,15 @@
+package com.loopers.domain.coupon;
+
+import java.util.List;
+import java.util.Optional;
+
+public interface CouponTemplateRepository {
+
+    CouponTemplate save(CouponTemplate couponTemplate);
+
+    Optional<CouponTemplate> findById(Long id);
+
+    List<CouponTemplate> findAll(int page, int size);
+
+    long count();
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/domain/coupon/CouponType.java b/apps/commerce-api/src/main/java/com/loopers/domain/coupon/CouponType.java
new file mode 100644
index 000000000..ed11e42f5
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/coupon/CouponType.java
@@ -0,0 +1,6 @@
+package com.loopers.domain.coupon;
+
+public enum CouponType {
+    FIXED,
+    RATE
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/domain/coupon/IssuedCoupon.java b/apps/commerce-api/src/main/java/com/loopers/domain/coupon/IssuedCoupon.java
new file mode 100644
index 000000000..3435eb4fe
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/coupon/IssuedCoupon.java
@@ -0,0 +1,81 @@
+package com.loopers.domain.coupon;
+
+import com.loopers.domain.BaseEntity;
+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.Table;
+import jakarta.persistence.UniqueConstraint;
+
+import java.time.ZonedDateTime;
+
+@Entity
+@Table(name = "issued_coupon", uniqueConstraints = {
+    @UniqueConstraint(columnNames = {"member_id", "coupon_template_id"})
+})
+public class IssuedCoupon extends BaseEntity {
+
+    @Column(name = "coupon_template_id", nullable = false)
+    private Long couponTemplateId;
+
+    @Column(name = "member_id", nullable = false)
+    private Long memberId;
+
+    @Enumerated(EnumType.STRING)
+    @Column(nullable = false)
+    private CouponStatus status;
+
+    @Column(name = "used_at")
+    private ZonedDateTime usedAt;
+
+    protected IssuedCoupon() {}
+
+    public IssuedCoupon(Long couponTemplateId, Long memberId) {
+        validateCouponTemplateId(couponTemplateId);
+        validateMemberId(memberId);
+        this.couponTemplateId = couponTemplateId;
+        this.memberId = memberId;
+        this.status = CouponStatus.AVAILABLE;
+    }
+
+    private void validateCouponTemplateId(Long couponTemplateId) {
+        if (couponTemplateId == null) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "쿠폰 템플릿 ID는 필수입니다.");
+        }
+    }
+
+    private void validateMemberId(Long memberId) {
+        if (memberId == null) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "회원 ID는 필수입니다.");
+        }
+    }
+
+    public void use() {
+        if (status == CouponStatus.USED) {
+            throw new CoreException(ErrorType.COUPON_ALREADY_USED);
+        }
+        if (status == CouponStatus.EXPIRED) {
+            throw new CoreException(ErrorType.COUPON_EXPIRED);
+        }
+        this.status = CouponStatus.USED;
+        this.usedAt = ZonedDateTime.now();
+    }
+
+    public boolean isUsable() {
+        return status == CouponStatus.AVAILABLE;
+    }
+
+    public void validateOwnership(Long requestMemberId) {
+        if (!this.memberId.equals(requestMemberId)) {
+            throw new CoreException(ErrorType.COUPON_NOT_OWNED);
+        }
+    }
+
+    public Long getCouponTemplateId() { return couponTemplateId; }
+    public Long getMemberId() { return memberId; }
+    public CouponStatus getStatus() { return status; }
+    public ZonedDateTime getUsedAt() { return usedAt; }
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/domain/coupon/IssuedCouponRepository.java b/apps/commerce-api/src/main/java/com/loopers/domain/coupon/IssuedCouponRepository.java
new file mode 100644
index 000000000..2ac91bf21
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/coupon/IssuedCouponRepository.java
@@ -0,0 +1,21 @@
+package com.loopers.domain.coupon;
+
+import java.util.List;
+import java.util.Optional;
+
+public interface IssuedCouponRepository {
+
+    IssuedCoupon save(IssuedCoupon issuedCoupon);
+
+    Optional<IssuedCoupon> findById(Long id);
+
+    Optional<IssuedCoupon> findByIdForUpdate(Long id);
+
+    List<IssuedCoupon> findByMemberId(Long memberId);
+
+    boolean existsByMemberIdAndCouponTemplateId(Long memberId, Long couponTemplateId);
+
+    List<IssuedCoupon> findByCouponTemplateId(Long couponTemplateId, int page, int size);
+
+    long countByCouponTemplateId(Long couponTemplateId);
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/domain/like/Like.java b/apps/commerce-api/src/main/java/com/loopers/domain/like/Like.java
new file mode 100644
index 000000000..e62fd686b
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/like/Like.java
@@ -0,0 +1,47 @@
+package com.loopers.domain.like;
+
+import com.loopers.domain.BaseEntity;
+import com.loopers.support.error.CoreException;
+import com.loopers.support.error.ErrorType;
+import jakarta.persistence.Entity;
+import jakarta.persistence.Table;
+import jakarta.persistence.UniqueConstraint;
+
+@Entity
+@Table(name = "product_like", uniqueConstraints = {
+    @UniqueConstraint(columnNames = {"member_id", "product_id"})
+})
+public class Like extends BaseEntity {
+
+    private Long memberId;
+    private Long productId;
+
+    protected Like() {}
+
+    public Like(Long memberId, Long productId) {
+        validateMemberId(memberId);
+        validateProductId(productId);
+        this.memberId = memberId;
+        this.productId = productId;
+    }
+
+    private void validateMemberId(Long memberId) {
+        if (memberId == null) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "회원 ID는 필수입니다.");
+        }
+    }
+
+    private void validateProductId(Long productId) {
+        if (productId == null) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "상품 ID는 필수입니다.");
+        }
+    }
+
+    public Long getMemberId() {
+        return memberId;
+    }
+
+    public Long getProductId() {
+        return productId;
+    }
+}
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
new file mode 100644
index 000000000..6d4cacfd2
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/like/LikeRepository.java
@@ -0,0 +1,17 @@
+package com.loopers.domain.like;
+
+import java.util.List;
+import java.util.Map;
+
+public interface LikeRepository {
+
+    Like save(Like like);
+
+    void deleteByMemberIdAndProductId(Long memberId, Long productId);
+
+    boolean existsByMemberIdAndProductId(Long memberId, Long productId);
+
+    long countByProductId(Long productId);
+
+    Map<Long, Long> countByProductIds(List<Long> productIds);
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/domain/like/README.md b/apps/commerce-api/src/main/java/com/loopers/domain/like/README.md
new file mode 100644
index 000000000..9ddd1844d
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/like/README.md
@@ -0,0 +1,35 @@
+# Like 도메인
+
+> Claude Code 작업 시 이 도메인의 설계 의도와 규칙을 참고하세요.
+
+## 책임
+
+- **Like**: 회원(Member)과 상품(Product) 간의 좋아요 관계.
+- 별도 도메인으로 분리하여 Product가 좋아요 수를 직접 관리하지 않음.
+
+## 설계 규칙
+
+1. **(member_id, product_id) UNIQUE**  
+   한 회원이 한 상품에 한 번만 좋아요 가능.
+
+2. **좋아요 수 집계**  
+   `LikeRepository.countByProductId()`, `countByProductIds()` — 조회 시점에 집계.
+
+3. **Product와 분리**  
+   Product 엔티티에 likeCount 필드 없음. Application Layer에서 조합.
+
+## 주요 클래스
+
+| 클래스 | 역할 |
+|--------|------|
+| Like | 좋아요 엔티티 (memberId, productId) |
+| LikeRepository | 저장, 삭제, 존재 여부, 집계 |
+
+## API 흐름
+
+- **등록**: `LikeService.like()` → 중복 시 멱등, Product 존재 검증 후 저장
+- **취소**: `LikeService.unlike()` → `deleteByMemberIdAndProductId()`
+
+## 참조
+
+- [CLAUDE.md](/CLAUDE.md) — 프로젝트 루트의 전체 아키텍처 규칙
diff --git a/apps/commerce-api/src/main/java/com/loopers/domain/member/Member.java b/apps/commerce-api/src/main/java/com/loopers/domain/member/Member.java
new file mode 100644
index 000000000..7e6c17b88
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/member/Member.java
@@ -0,0 +1,81 @@
+package com.loopers.domain.member;
+
+import com.loopers.domain.BaseEntity;
+import com.loopers.support.error.CoreException;
+import com.loopers.support.error.ErrorType;
+import jakarta.persistence.Entity;
+import jakarta.persistence.Table;
+
+@Entity
+@Table(name = "member")
+public class Member extends BaseEntity {
+    
+    private String loginId;
+    private String encryptedPassword;
+    private String name;
+    private String birthDate;
+    private String email;
+    
+    protected Member() {}
+    
+    public Member(String loginId, String encryptedPassword, String name,
+                  String birthDate, String email) {
+        validateLoginId(loginId);
+        validatePassword(encryptedPassword);
+        validateName(name);
+        validateBirthDate(birthDate);
+        validateEmail(email);
+
+        this.loginId = loginId;
+        this.encryptedPassword = encryptedPassword;
+        this.name = name;
+        this.birthDate = birthDate;
+        this.email = email;
+    }
+    
+    private void validateLoginId(String loginId) {
+        if (loginId == null || loginId.isBlank()) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "로그인ID는 필수입니다");
+        }
+    }
+    
+    private void validatePassword(String password) {
+        if (password == null || password.isBlank()) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "비밀번호는 필수입니다");
+        }
+    }
+    
+    private void validateName(String name) {
+        if (name == null || name.isBlank()) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "이름은 필수입니다");
+        }
+    }
+    
+    private void validateBirthDate(String birthDate) {
+        if (birthDate == null || birthDate.isBlank()) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "생년월일은 필수입니다");
+        }
+    }
+    
+    private void validateEmail(String email) {
+        if (email == null || email.isBlank()) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "이메일은 필수입니다");
+        }
+    }
+    
+    public String getLoginId() {
+        return loginId;
+    }
+    
+    public String getName() {
+        return name;
+    }
+    
+    public String getBirthDate() {
+        return birthDate;
+    }
+    
+    public String getEmail() {
+        return email;
+    }
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/domain/member/MemberRepository.java b/apps/commerce-api/src/main/java/com/loopers/domain/member/MemberRepository.java
new file mode 100644
index 000000000..f06cecd27
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/member/MemberRepository.java
@@ -0,0 +1,12 @@
+package com.loopers.domain.member;
+
+import java.util.Optional;
+
+public interface MemberRepository {
+
+    Member save(Member member);
+
+    Optional<Member> findByLoginId(String loginId);
+
+    boolean existsByLoginId(String loginId);
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/domain/member/MemberService.java b/apps/commerce-api/src/main/java/com/loopers/domain/member/MemberService.java
new file mode 100644
index 000000000..cf76b7e5f
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/member/MemberService.java
@@ -0,0 +1,27 @@
+package com.loopers.domain.member;
+
+import com.loopers.support.error.CoreException;
+import com.loopers.support.error.ErrorType;
+import lombok.RequiredArgsConstructor;
+import org.springframework.security.crypto.password.PasswordEncoder;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+
+@RequiredArgsConstructor
+@Component
+public class MemberService {
+
+    private final MemberRepository memberRepository;
+    private final PasswordEncoder passwordEncoder;
+
+    @Transactional
+    public Member signUp(String loginId, String rawPassword, String name, String birthDate, String email) {
+        if (memberRepository.existsByLoginId(loginId)) {
+            throw new CoreException(ErrorType.CONFLICT, "이미 사용 중인 로그인ID입니다.");
+        }
+
+        String encryptedPassword = passwordEncoder.encode(rawPassword);
+        Member member = new Member(loginId, encryptedPassword, name, birthDate, email);
+        return memberRepository.save(member);
+    }
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/domain/order/Order.java b/apps/commerce-api/src/main/java/com/loopers/domain/order/Order.java
new file mode 100644
index 000000000..175173e24
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/order/Order.java
@@ -0,0 +1,129 @@
+package com.loopers.domain.order;
+
+import com.loopers.domain.BaseEntity;
+import com.loopers.support.error.CoreException;
+import com.loopers.support.error.ErrorType;
+import jakarta.persistence.CascadeType;
+import jakarta.persistence.Column;
+import jakarta.persistence.Entity;
+import jakarta.persistence.OneToMany;
+import jakarta.persistence.Table;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+@Entity
+@Table(name = "orders")
+public class Order extends BaseEntity {
+
+    private static final String STATUS_ORDERED = "ORDERED";
+
+    private Long memberId;
+    private String status;
+
+    @Column(name = "coupon_id")
+    private Long couponId;
+
+    @Column(name = "original_amount", nullable = false)
+    private long originalAmount;
+
+    @Column(name = "discount_amount", nullable = false)
+    private long discountAmount;
+
+    @OneToMany(mappedBy = "order", cascade = CascadeType.ALL, orphanRemoval = true)
+    private List<OrderLineEntity> orderLines = new ArrayList<>();
+
+    protected Order() {}
+
+    private Order(Long memberId, List<OrderLine> orderLines, Long couponId, long discountAmount) {
+        validateMemberId(memberId);
+        validateOrderLines(orderLines);
+        this.memberId = memberId;
+        this.status = STATUS_ORDERED;
+        this.couponId = couponId;
+        for (OrderLine line : orderLines) {
+            this.orderLines.add(new OrderLineEntity(this, line.productId(), line.quantity(), line.unitPrice()));
+        }
+        this.originalAmount = calculateOriginalAmount();
+        this.discountAmount = Math.min(discountAmount, this.originalAmount);
+    }
+
+    public static Order create(Long memberId, List<OrderLine> orderLines) {
+        return new Order(memberId, orderLines, null, 0);
+    }
+
+    public static Order createWithCoupon(Long memberId, List<OrderLine> orderLines, Long couponId, long discountAmount) {
+        return new Order(memberId, orderLines, couponId, discountAmount);
+    }
+
+    private void validateMemberId(Long memberId) {
+        if (memberId == null) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "회원 ID는 필수입니다.");
+        }
+    }
+
+    private void validateOrderLines(List<OrderLine> orderLines) {
+        if (orderLines == null || orderLines.isEmpty()) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "주문 항목이 비어있을 수 없습니다.");
+        }
+    }
+
+    private long calculateOriginalAmount() {
+        return orderLines.stream()
+            .mapToLong(OrderLineEntity::getTotalPrice)
+            .sum();
+    }
+
+    public Long getMemberId() { return memberId; }
+    public String getStatus() { return status; }
+    public Long getCouponId() { return couponId; }
+    public long getOriginalAmount() { return originalAmount; }
+    public long getDiscountAmount() { return discountAmount; }
+
+    public long getTotalAmount() {
+        return originalAmount - discountAmount;
+    }
+
+    public List<OrderLineEntity> getOrderLines() {
+        return Collections.unmodifiableList(orderLines);
+    }
+
+    @jakarta.persistence.Entity
+    @jakarta.persistence.Table(name = "order_line")
+    public static class OrderLineEntity {
+        @jakarta.persistence.Id
+        @jakarta.persistence.GeneratedValue(strategy = jakarta.persistence.GenerationType.IDENTITY)
+        private Long id;
+
+        @jakarta.persistence.ManyToOne(fetch = jakarta.persistence.FetchType.LAZY)
+        @jakarta.persistence.JoinColumn(name = "order_id", nullable = false)
+        private Order order;
+
+        @jakarta.persistence.Column(name = "product_id", nullable = false)
+        private Long productId;
+
+        @jakarta.persistence.Column(nullable = false)
+        private int quantity;
+
+        @jakarta.persistence.Column(name = "unit_price", nullable = false)
+        private long unitPrice;
+
+        protected OrderLineEntity() {}
+
+        OrderLineEntity(Order order, Long productId, int quantity, long unitPrice) {
+            this.order = order;
+            this.productId = productId;
+            this.quantity = quantity;
+            this.unitPrice = unitPrice;
+        }
+
+        public long getTotalPrice() {
+            return (long) quantity * unitPrice;
+        }
+
+        public Long getProductId() { return productId; }
+        public int getQuantity() { return quantity; }
+        public long getUnitPrice() { return unitPrice; }
+    }
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/domain/order/OrderDomainService.java b/apps/commerce-api/src/main/java/com/loopers/domain/order/OrderDomainService.java
new file mode 100644
index 000000000..2375e8a9d
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/order/OrderDomainService.java
@@ -0,0 +1,81 @@
+package com.loopers.domain.order;
+
+import com.loopers.domain.product.Product;
+import com.loopers.domain.product.ProductRepository;
+import com.loopers.support.error.CoreException;
+import com.loopers.support.error.ErrorType;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Component;
+
+import java.util.ArrayList;
+import java.util.List;
+
+@RequiredArgsConstructor
+@Component
+public class OrderDomainService {
+
+    private final ProductRepository productRepository;
+    private final OrderRepository orderRepository;
+
+    /**
+     * 재고를 차감하고 주문 라인 목록을 반환한다.
+     *
+     * ─── 비관적 락(Pessimistic Lock) 선택 근거 ───────────────────────────────
+     * 재고 차감은 "읽기 → 조건 확인 → 쓰기"가 하나의 원자 단위여야 한다.
+     *
+     * 낙관적 락(@Version)은 "일단 읽고, 커밋 시점에 충돌을 감지"하는 방식이다.
+     * 재고처럼 동시 경합이 높은 상황에서 낙관적 락을 사용하면:
+     *   - 여러 스레드가 동시에 같은 stock 값을 읽어 조건을 통과한다.
+     *   - 커밋 시점에 OptimisticLockException이 발생해 롤백된다.
+     *   - Application Layer에서 재시도 로직이 필요해 복잡도가 높아진다.
+     *   - 재고 10개인 상품에 10명이 동시 주문하면 대부분 실패 → 재시도 지옥
+     *
+     * 비관적 락(SELECT ... FOR UPDATE)은 조회 시점에 DB 행 잠금을 획득해
+     * 다른 트랜잭션이 커밋 전까지 해당 행을 수정하지 못하게 막는다.
+     * 충돌이 잦은 경우 재시도 없이도 순차 처리가 보장된다.
+     *
+     * ─── 데드락(Deadlock) 방지 전략 ──────────────────────────────────────────
+     * 여러 상품을 한 번에 주문할 때, 트랜잭션 간 락 획득 순서가 다르면 데드락이 발생한다.
+     *
+     * 시나리오 예시:
+     *   Thread A: product(id=1) 락 획득 → product(id=2) 락 대기
+     *   Thread B: product(id=2) 락 획득 → product(id=1) 락 대기
+     *   → 서로를 기다리는 순환 대기 → 데드락 발생
+     *
+     * 해결책: 모든 트랜잭션이 productId 오름차순으로 락을 획득하도록 강제한다.
+     * 락 요청 순서가 전역적으로 일치하면 순환 대기 조건이 성립하지 않는다.
+     */
+    public List<OrderLine> prepareOrderLines(List<OrderLineRequest> items) {
+        // 데드락 방지: productId 오름차순으로 정렬 후 순차적으로 락 획득
+        List<OrderLineRequest> sorted = items.stream()
+            .sorted((a, b) -> Long.compare(a.productId(), b.productId()))
+            .toList();
+
+        List<OrderLine> orderLines = new ArrayList<>();
+        for (OrderLineRequest item : sorted) {
+            // SELECT ... FOR UPDATE: 해당 상품 행에 독점 락 획득
+            // 락을 보유한 트랜잭션이 커밋 또는 롤백할 때까지 다른 트랜잭션은 대기
+            Product product = productRepository.findByIdForUpdate(item.productId())
+                .orElseThrow(() -> new CoreException(ErrorType.NOT_FOUND,
+                    "[id = " + item.productId() + "] 상품을 찾을 수 없습니다."));
+
+            // 재고 음수 방지 검증은 Product 도메인 내부에 캡슐화
+            // Application Layer가 재고 규칙을 직접 알지 않아도 된다.
+            product.decreaseStock(item.quantity());
+            orderLines.add(new OrderLine(item.productId(), item.quantity(), product.getPrice()));
+        }
+        return orderLines;
+    }
+
+    public Order createOrder(Long memberId, List<OrderLine> orderLines) {
+        Order order = Order.create(memberId, orderLines);
+        return orderRepository.save(order);
+    }
+
+    public Order createOrderWithCoupon(Long memberId, List<OrderLine> orderLines, Long couponId, long discountAmount) {
+        Order order = Order.createWithCoupon(memberId, orderLines, couponId, discountAmount);
+        return orderRepository.save(order);
+    }
+
+    public record OrderLineRequest(Long productId, int quantity) {}
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/domain/order/OrderLine.java b/apps/commerce-api/src/main/java/com/loopers/domain/order/OrderLine.java
new file mode 100644
index 000000000..622b7464e
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/order/OrderLine.java
@@ -0,0 +1,23 @@
+package com.loopers.domain.order;
+
+import com.loopers.support.error.CoreException;
+import com.loopers.support.error.ErrorType;
+
+public record OrderLine(Long productId, int quantity, long unitPrice) {
+
+    public OrderLine {
+        if (productId == null) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "상품 ID는 필수입니다.");
+        }
+        if (quantity <= 0) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "수량은 1 이상이어야 합니다.");
+        }
+        if (unitPrice < 0) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "단가는 0 이상이어야 합니다.");
+        }
+    }
+
+    public long getTotalPrice() {
+        return (long) quantity * unitPrice;
+    }
+}
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
new file mode 100644
index 000000000..cfd052c8a
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/order/OrderRepository.java
@@ -0,0 +1,10 @@
+package com.loopers.domain.order;
+
+import java.util.Optional;
+
+public interface OrderRepository {
+
+    Order save(Order order);
+
+    Optional<Order> findById(Long id);
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/domain/order/README.md b/apps/commerce-api/src/main/java/com/loopers/domain/order/README.md
new file mode 100644
index 000000000..04037e6b9
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/order/README.md
@@ -0,0 +1,42 @@
+# Order 도메인
+
+> Claude Code 작업 시 이 도메인의 설계 의도와 규칙을 참고하세요.
+
+## 책임
+
+- **Order**: 주문 엔티티. 여러 OrderLine 포함.
+- **OrderLine**: 주문 항목 VO (productId, quantity, unitPrice 스냅샷).
+- **OrderDomainService**: Order와 Product 간 재고 차감·주문 생성 조율.
+
+## 설계 규칙
+
+1. **주문 시 재고 차감**  
+   `OrderDomainService.placeOrder()`에서 각 Product에 `decreaseStock()` 호출.  
+   재고 부족 시 예외 → Order 미생성 (트랜잭션 롤백).
+
+2. **가격 스냅샷**  
+   OrderLine에 주문 시점 `unitPrice` 저장. 이후 Product 가격 변경과 무관.
+
+3. **도메인 서비스**  
+   Order, Product 간 협력은 `OrderDomainService`에서 처리.  
+   Application Layer(OrderService)는 트랜잭션만 관리.
+
+## 주요 클래스
+
+| 클래스 | 역할 |
+|--------|------|
+| Order | 주문 엔티티, `Order.create()` 정적 팩토리 |
+| OrderLine | 주문 항목 VO (불변) |
+| OrderDomainService | placeOrder — 재고 차감 + Order 생성 |
+| OrderRepository | 주문 저장/조회 인터페이스 |
+
+## 주문 흐름
+
+1. Product 조회 및 재고 검증
+2. `product.decreaseStock(quantity)` — 재고 부족 시 예외
+3. `Order.create(memberId, orderLines)` — Order + OrderLine 생성
+4. `orderRepository.save(order)`
+
+## 참조
+
+- [CLAUDE.md](/CLAUDE.md) — 프로젝트 루트의 전체 아키텍처 규칙
diff --git a/apps/commerce-api/src/main/java/com/loopers/domain/product/Brand.java b/apps/commerce-api/src/main/java/com/loopers/domain/product/Brand.java
new file mode 100644
index 000000000..687015ea8
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/product/Brand.java
@@ -0,0 +1,31 @@
+package com.loopers.domain.product;
+
+import com.loopers.domain.BaseEntity;
+import com.loopers.support.error.CoreException;
+import com.loopers.support.error.ErrorType;
+import jakarta.persistence.Entity;
+import jakarta.persistence.Table;
+
+@Entity
+@Table(name = "brand")
+public class Brand extends BaseEntity {
+
+    private String name;
+
+    protected Brand() {}
+
+    public Brand(String name) {
+        validateName(name);
+        this.name = name;
+    }
+
+    private void validateName(String name) {
+        if (name == null || name.isBlank()) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "브랜드명은 필수입니다.");
+        }
+    }
+
+    public String getName() {
+        return name;
+    }
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/domain/product/BrandRepository.java b/apps/commerce-api/src/main/java/com/loopers/domain/product/BrandRepository.java
new file mode 100644
index 000000000..3491f67d4
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/product/BrandRepository.java
@@ -0,0 +1,10 @@
+package com.loopers.domain.product;
+
+import java.util.Optional;
+
+public interface BrandRepository {
+
+    Brand save(Brand brand);
+
+    Optional<Brand> findById(Long id);
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/domain/product/Product.java b/apps/commerce-api/src/main/java/com/loopers/domain/product/Product.java
new file mode 100644
index 000000000..a0c55b125
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/product/Product.java
@@ -0,0 +1,81 @@
+package com.loopers.domain.product;
+
+import com.loopers.domain.BaseEntity;
+import com.loopers.support.error.CoreException;
+import com.loopers.support.error.ErrorType;
+import jakarta.persistence.Entity;
+import jakarta.persistence.Table;
+
+@Entity
+@Table(name = "product")
+public class Product extends BaseEntity {
+
+    private Long brandId;
+    private String name;
+    private Long price;
+    private int stockQuantity;
+
+    protected Product() {}
+
+    public Product(Long brandId, String name, Long price, int stockQuantity) {
+        validateBrandId(brandId);
+        validateName(name);
+        validatePrice(price);
+        validateStockQuantity(stockQuantity);
+
+        this.brandId = brandId;
+        this.name = name;
+        this.price = price;
+        this.stockQuantity = stockQuantity;
+    }
+
+    private void validateBrandId(Long brandId) {
+        if (brandId == null) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "브랜드 ID는 필수입니다.");
+        }
+    }
+
+    private void validateName(String name) {
+        if (name == null || name.isBlank()) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "상품명은 필수입니다.");
+        }
+    }
+
+    private void validatePrice(Long price) {
+        if (price == null || price < 0) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "가격은 0 이상이어야 합니다.");
+        }
+    }
+
+    private void validateStockQuantity(int stockQuantity) {
+        if (stockQuantity < 0) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "재고는 0 이상이어야 합니다.");
+        }
+    }
+
+    public void decreaseStock(int quantity) {
+        if (quantity <= 0) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "차감 수량은 1 이상이어야 합니다.");
+        }
+        if (stockQuantity < quantity) {
+            throw new CoreException(ErrorType.INSUFFICIENT_STOCK, "재고가 부족합니다.");
+        }
+        this.stockQuantity -= quantity;
+    }
+
+    public Long getBrandId() {
+        return brandId;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public Long getPrice() {
+        return price;
+    }
+
+    public int getStockQuantity() {
+        return stockQuantity;
+    }
+}
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
new file mode 100644
index 000000000..9c2219f70
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/product/ProductRepository.java
@@ -0,0 +1,15 @@
+package com.loopers.domain.product;
+
+import java.util.List;
+import java.util.Optional;
+
+public interface ProductRepository {
+
+    Product save(Product product);
+
+    Optional<Product> findById(Long id);
+
+    Optional<Product> findByIdForUpdate(Long id);
+
+    List<Product> findAll(SortCondition sort);
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/domain/product/README.md b/apps/commerce-api/src/main/java/com/loopers/domain/product/README.md
new file mode 100644
index 000000000..c6a0f561a
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/product/README.md
@@ -0,0 +1,37 @@
+# Product / Brand 도메인
+
+> Claude Code 작업 시 이 도메인의 설계 의도와 규칙을 참고하세요.
+
+## 책임
+
+- **Product**: 상품 정보, 재고 관리. `decreaseStock()`으로 주문 시 재고 차감.
+- **Brand**: 브랜드 정보. Product가 `brandId`로 참조.
+
+## 설계 규칙
+
+1. **Product는 likeCount를 직접 가지지 않음**  
+   좋아요 수는 Like 도메인에서 집계하며, 조회 시점에 Application Layer에서 조합.
+
+2. **재고 차감은 도메인 레벨에서 처리**  
+   `Product.decreaseStock(quantity)` 내부에서 음수 방지.  
+   재고 부족 시 `CoreException(ErrorType.INSUFFICIENT_STOCK)` 발생.
+
+3. **행위 메서드 사용**  
+   Setter 금지. `decreaseStock()` 등 의도가 드러나는 메서드 사용.
+
+4. **정렬 조건 (SortCondition)**  
+   `latest`, `price_asc`, `likes_desc` — Infrastructure에서 구현.
+
+## 주요 클래스
+
+| 클래스 | 역할 |
+|--------|------|
+| Product | 상품 엔티티, `decreaseStock()` |
+| Brand | 브랜드 엔티티 |
+| ProductRepository | 상품 저장/조회 인터페이스 |
+| BrandRepository | 브랜드 저장/조회 인터페이스 |
+| SortCondition | 정렬 조건 enum |
+
+## 참조
+
+- [CLAUDE.md](/CLAUDE.md) — 프로젝트 루트의 전체 아키텍처 규칙
diff --git a/apps/commerce-api/src/main/java/com/loopers/domain/product/SortCondition.java b/apps/commerce-api/src/main/java/com/loopers/domain/product/SortCondition.java
new file mode 100644
index 000000000..4d71bddb4
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/product/SortCondition.java
@@ -0,0 +1,7 @@
+package com.loopers.domain.product;
+
+public enum SortCondition {
+    latest,
+    price_asc,
+    likes_desc
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/infrastructure/coupon/CouponTemplateJpaRepository.java b/apps/commerce-api/src/main/java/com/loopers/infrastructure/coupon/CouponTemplateJpaRepository.java
new file mode 100644
index 000000000..a7491c867
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/infrastructure/coupon/CouponTemplateJpaRepository.java
@@ -0,0 +1,7 @@
+package com.loopers.infrastructure.coupon;
+
+import com.loopers.domain.coupon.CouponTemplate;
+import org.springframework.data.jpa.repository.JpaRepository;
+
+public interface CouponTemplateJpaRepository extends JpaRepository<CouponTemplate, Long> {
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/infrastructure/coupon/CouponTemplateRepositoryImpl.java b/apps/commerce-api/src/main/java/com/loopers/infrastructure/coupon/CouponTemplateRepositoryImpl.java
new file mode 100644
index 000000000..f301ca162
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/infrastructure/coupon/CouponTemplateRepositoryImpl.java
@@ -0,0 +1,39 @@
+package com.loopers.infrastructure.coupon;
+
+import com.loopers.domain.coupon.CouponTemplate;
+import com.loopers.domain.coupon.CouponTemplateRepository;
+import lombok.RequiredArgsConstructor;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.data.domain.Sort;
+import org.springframework.stereotype.Component;
+
+import java.util.List;
+import java.util.Optional;
+
+@RequiredArgsConstructor
+@Component
+public class CouponTemplateRepositoryImpl implements CouponTemplateRepository {
+
+    private final CouponTemplateJpaRepository couponTemplateJpaRepository;
+
+    @Override
+    public CouponTemplate save(CouponTemplate couponTemplate) {
+        return couponTemplateJpaRepository.save(couponTemplate);
+    }
+
+    @Override
+    public Optional<CouponTemplate> findById(Long id) {
+        return couponTemplateJpaRepository.findById(id);
+    }
+
+    @Override
+    public List<CouponTemplate> findAll(int page, int size) {
+        PageRequest pageRequest = PageRequest.of(page, size, Sort.by(Sort.Direction.DESC, "createdAt"));
+        return couponTemplateJpaRepository.findAll(pageRequest).getContent();
+    }
+
+    @Override
+    public long count() {
+        return couponTemplateJpaRepository.count();
+    }
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/infrastructure/coupon/IssuedCouponJpaRepository.java b/apps/commerce-api/src/main/java/com/loopers/infrastructure/coupon/IssuedCouponJpaRepository.java
new file mode 100644
index 000000000..a541c8b79
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/infrastructure/coupon/IssuedCouponJpaRepository.java
@@ -0,0 +1,54 @@
+package com.loopers.infrastructure.coupon;
+
+import com.loopers.domain.coupon.IssuedCoupon;
+import jakarta.persistence.LockModeType;
+import org.springframework.data.domain.Pageable;
+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.List;
+import java.util.Optional;
+
+public interface IssuedCouponJpaRepository extends JpaRepository<IssuedCoupon, Long> {
+
+    /**
+     * 비관적 쓰기 락(PESSIMISTIC_WRITE)으로 발급 쿠폰을 조회한다.
+     * → 내부적으로 SELECT ... FOR UPDATE 쿼리가 실행된다.
+     *
+     * ─── 쿠폰에 비관적 락을 적용한 이유 ─────────────────────────────────────
+     * 쿠폰은 "단 1회만 사용 가능"이라는 엄격한 제약을 가진다.
+     * 이 제약을 애플리케이션 레벨(코드)만으로 보장하면 Lost Update 문제가 발생한다.
+     *
+     * 시나리오 (락 없을 때):
+     *   T1: SELECT → status=AVAILABLE (사용 가능 확인)
+     *   T2: SELECT → status=AVAILABLE (동시에 사용 가능 확인)
+     *   T1: UPDATE status=USED (쿠폰 사용)
+     *   T2: UPDATE status=USED (이미 사용된 쿠폰을 또 사용 → 중복!)
+     *
+     * 비관적 락 적용 후:
+     *   T1: SELECT FOR UPDATE → 행 잠금 획득
+     *   T2: SELECT FOR UPDATE → T1 종료까지 대기
+     *   T1: UPDATE status=USED, COMMIT → 잠금 해제
+     *   T2: 락 획득 후 SELECT → status=USED → 예외 발생 → 중복 사용 방지
+     *
+     * ─── 낙관적 락(@Version) 대신 비관적 락을 선택한 이유 ────────────────────
+     * 낙관적 락도 중복 사용을 막을 수 있다. 그러나:
+     * - 쿠폰 중복 사용은 "실패 감지"보다 "사전 차단"이 중요하다.
+     * - 낙관적 락은 커밋 시점에 실패를 알게 되므로 DB 작업(재고 차감 등)을 이미 수행한 후다.
+     * - 비관적 락은 조회 시점에 독점권을 확보하므로 불필요한 작업 수행 자체를 막는다.
+     * - 쿠폰 1건에 대한 동시 요청 빈도는 높지 않아 대기 비용이 크지 않다.
+     */
+    @Lock(LockModeType.PESSIMISTIC_WRITE)
+    @Query("SELECT c FROM IssuedCoupon c WHERE c.id = :id")
+    Optional<IssuedCoupon> findByIdForUpdate(@Param("id") Long id);
+
+    List<IssuedCoupon> findByMemberId(Long memberId);
+
+    boolean existsByMemberIdAndCouponTemplateId(Long memberId, Long couponTemplateId);
+
+    List<IssuedCoupon> findByCouponTemplateId(Long couponTemplateId, Pageable pageable);
+
+    long countByCouponTemplateId(Long couponTemplateId);
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/infrastructure/coupon/IssuedCouponRepositoryImpl.java b/apps/commerce-api/src/main/java/com/loopers/infrastructure/coupon/IssuedCouponRepositoryImpl.java
new file mode 100644
index 000000000..35a73841c
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/infrastructure/coupon/IssuedCouponRepositoryImpl.java
@@ -0,0 +1,54 @@
+package com.loopers.infrastructure.coupon;
+
+import com.loopers.domain.coupon.IssuedCoupon;
+import com.loopers.domain.coupon.IssuedCouponRepository;
+import lombok.RequiredArgsConstructor;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.data.domain.Sort;
+import org.springframework.stereotype.Component;
+
+import java.util.List;
+import java.util.Optional;
+
+@RequiredArgsConstructor
+@Component
+public class IssuedCouponRepositoryImpl implements IssuedCouponRepository {
+
+    private final IssuedCouponJpaRepository issuedCouponJpaRepository;
+
+    @Override
+    public IssuedCoupon save(IssuedCoupon issuedCoupon) {
+        return issuedCouponJpaRepository.save(issuedCoupon);
+    }
+
+    @Override
+    public Optional<IssuedCoupon> findById(Long id) {
+        return issuedCouponJpaRepository.findById(id);
+    }
+
+    @Override
+    public Optional<IssuedCoupon> findByIdForUpdate(Long id) {
+        return issuedCouponJpaRepository.findByIdForUpdate(id);
+    }
+
+    @Override
+    public List<IssuedCoupon> findByMemberId(Long memberId) {
+        return issuedCouponJpaRepository.findByMemberId(memberId);
+    }
+
+    @Override
+    public boolean existsByMemberIdAndCouponTemplateId(Long memberId, Long couponTemplateId) {
+        return issuedCouponJpaRepository.existsByMemberIdAndCouponTemplateId(memberId, couponTemplateId);
+    }
+
+    @Override
+    public List<IssuedCoupon> findByCouponTemplateId(Long couponTemplateId, int page, int size) {
+        PageRequest pageRequest = PageRequest.of(page, size, Sort.by(Sort.Direction.DESC, "createdAt"));
+        return issuedCouponJpaRepository.findByCouponTemplateId(couponTemplateId, pageRequest);
+    }
+
+    @Override
+    public long countByCouponTemplateId(Long couponTemplateId) {
+        return issuedCouponJpaRepository.countByCouponTemplateId(couponTemplateId);
+    }
+}
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
new file mode 100644
index 000000000..530964b3e
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/infrastructure/like/LikeJpaRepository.java
@@ -0,0 +1,23 @@
+package com.loopers.infrastructure.like;
+
+import com.loopers.domain.like.Like;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.Modifying;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.repository.query.Param;
+
+import java.util.List;
+
+public interface LikeJpaRepository extends JpaRepository<Like, Long> {
+
+    boolean existsByMemberIdAndProductId(Long memberId, Long productId);
+
+    long countByProductId(Long productId);
+
+    @Modifying
+    @Query("DELETE FROM Like l WHERE l.memberId = :memberId AND l.productId = :productId")
+    void deleteByMemberIdAndProductId(@Param("memberId") Long memberId, @Param("productId") Long productId);
+
+    @Query("SELECT l.productId, COUNT(l) FROM Like l WHERE l.productId IN :productIds GROUP BY l.productId")
+    List<Object[]> countByProductIdsGroupByProductId(@Param("productIds") List<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
new file mode 100644
index 000000000..64bdd7d19
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/infrastructure/like/LikeRepositoryImpl.java
@@ -0,0 +1,54 @@
+package com.loopers.infrastructure.like;
+
+import com.loopers.domain.like.Like;
+import com.loopers.domain.like.LikeRepository;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Component;
+
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+@RequiredArgsConstructor
+@Component
+public class LikeRepositoryImpl implements LikeRepository {
+
+    private final LikeJpaRepository likeJpaRepository;
+
+    @Override
+    public Like save(Like like) {
+        return likeJpaRepository.save(like);
+    }
+
+    @Override
+    public void deleteByMemberIdAndProductId(Long memberId, Long productId) {
+        likeJpaRepository.deleteByMemberIdAndProductId(memberId, productId);
+    }
+
+    @Override
+    public boolean existsByMemberIdAndProductId(Long memberId, Long productId) {
+        return likeJpaRepository.existsByMemberIdAndProductId(memberId, productId);
+    }
+
+    @Override
+    public long countByProductId(Long productId) {
+        return likeJpaRepository.countByProductId(productId);
+    }
+
+    @Override
+    public Map<Long, Long> countByProductIds(List<Long> productIds) {
+        if (productIds == null || productIds.isEmpty()) {
+            return Map.of();
+        }
+        List<Object[]> results = likeJpaRepository.countByProductIdsGroupByProductId(productIds);
+        Map<Long, Long> map = results.stream()
+            .collect(Collectors.toMap(
+                row -> (Long) row[0],
+                row -> ((Number) row[1]).longValue()
+            ));
+        for (Long productId : productIds) {
+            map.putIfAbsent(productId, 0L);
+        }
+        return map;
+    }
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/infrastructure/member/MemberJpaRepository.java b/apps/commerce-api/src/main/java/com/loopers/infrastructure/member/MemberJpaRepository.java
new file mode 100644
index 000000000..beebc4eca
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/infrastructure/member/MemberJpaRepository.java
@@ -0,0 +1,13 @@
+package com.loopers.infrastructure.member;
+
+import com.loopers.domain.member.Member;
+import org.springframework.data.jpa.repository.JpaRepository;
+
+import java.util.Optional;
+
+public interface MemberJpaRepository extends JpaRepository<Member, Long> {
+
+    Optional<Member> findByLoginId(String loginId);
+
+    boolean existsByLoginId(String loginId);
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/infrastructure/member/MemberRepositoryImpl.java b/apps/commerce-api/src/main/java/com/loopers/infrastructure/member/MemberRepositoryImpl.java
new file mode 100644
index 000000000..6116d454e
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/infrastructure/member/MemberRepositoryImpl.java
@@ -0,0 +1,30 @@
+package com.loopers.infrastructure.member;
+
+import com.loopers.domain.member.Member;
+import com.loopers.domain.member.MemberRepository;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Component;
+
+import java.util.Optional;
+
+@RequiredArgsConstructor
+@Component
+public class MemberRepositoryImpl implements MemberRepository {
+
+    private final MemberJpaRepository memberJpaRepository;
+
+    @Override
+    public Member save(Member member) {
+        return memberJpaRepository.save(member);
+    }
+
+    @Override
+    public Optional<Member> findByLoginId(String loginId) {
+        return memberJpaRepository.findByLoginId(loginId);
+    }
+
+    @Override
+    public boolean existsByLoginId(String loginId) {
+        return memberJpaRepository.existsByLoginId(loginId);
+    }
+}
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
new file mode 100644
index 000000000..f2ee62050
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/infrastructure/order/OrderJpaRepository.java
@@ -0,0 +1,7 @@
+package com.loopers.infrastructure.order;
+
+import com.loopers.domain.order.Order;
+import org.springframework.data.jpa.repository.JpaRepository;
+
+public interface OrderJpaRepository extends JpaRepository<Order, Long> {
+}
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
new file mode 100644
index 000000000..309265e06
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/infrastructure/order/OrderRepositoryImpl.java
@@ -0,0 +1,25 @@
+package com.loopers.infrastructure.order;
+
+import com.loopers.domain.order.Order;
+import com.loopers.domain.order.OrderRepository;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Component;
+
+import java.util.Optional;
+
+@RequiredArgsConstructor
+@Component
+public class OrderRepositoryImpl implements OrderRepository {
+
+    private final OrderJpaRepository orderJpaRepository;
+
+    @Override
+    public Order save(Order order) {
+        return orderJpaRepository.save(order);
+    }
+
+    @Override
+    public Optional<Order> findById(Long id) {
+        return orderJpaRepository.findById(id);
+    }
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/infrastructure/product/BrandJpaRepository.java b/apps/commerce-api/src/main/java/com/loopers/infrastructure/product/BrandJpaRepository.java
new file mode 100644
index 000000000..d532f2d35
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/infrastructure/product/BrandJpaRepository.java
@@ -0,0 +1,7 @@
+package com.loopers.infrastructure.product;
+
+import com.loopers.domain.product.Brand;
+import org.springframework.data.jpa.repository.JpaRepository;
+
+public interface BrandJpaRepository extends JpaRepository<Brand, Long> {
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/infrastructure/product/BrandRepositoryImpl.java b/apps/commerce-api/src/main/java/com/loopers/infrastructure/product/BrandRepositoryImpl.java
new file mode 100644
index 000000000..ff9fedafc
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/infrastructure/product/BrandRepositoryImpl.java
@@ -0,0 +1,25 @@
+package com.loopers.infrastructure.product;
+
+import com.loopers.domain.product.Brand;
+import com.loopers.domain.product.BrandRepository;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Component;
+
+import java.util.Optional;
+
+@RequiredArgsConstructor
+@Component
+public class BrandRepositoryImpl implements BrandRepository {
+
+    private final BrandJpaRepository brandJpaRepository;
+
+    @Override
+    public Brand save(Brand brand) {
+        return brandJpaRepository.save(brand);
+    }
+
+    @Override
+    public Optional<Brand> findById(Long id) {
+        return brandJpaRepository.findById(id);
+    }
+}
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
new file mode 100644
index 000000000..d244c2d5c
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/infrastructure/product/ProductJpaRepository.java
@@ -0,0 +1,45 @@
+package com.loopers.infrastructure.product;
+
+import com.loopers.domain.product.Product;
+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.List;
+import java.util.Optional;
+
+public interface ProductJpaRepository extends JpaRepository<Product, Long> {
+
+    /**
+     * 비관적 쓰기 락(PESSIMISTIC_WRITE)으로 상품을 조회한다.
+     * → 내부적으로 SELECT ... FOR UPDATE 쿼리가 실행된다.
+     *
+     * ─── 낙관적 락 vs 비관적 락 선택 기준 ────────────────────────────────────
+     * [낙관적 락 - @Version 기반]
+     *   - 읽기 시 락을 잡지 않고, 커밋 시 version 값을 비교해 충돌을 감지
+     *   - 충돌이 드물고, 충돌 발생 시 재시도가 저렴한 경우 유리
+     *   - 충돌 발생 → OptimisticLockException → 롤백 → 재시도 필요
+     *   - 재고처럼 동시 요청이 많으면 대부분 실패 후 재시도 → 성능 저하
+     *
+     * [비관적 락 - SELECT FOR UPDATE]
+     *   - 조회 시점에 DB 행 잠금 획득 → 다른 트랜잭션은 트랜잭션 종료까지 대기
+     *   - 충돌이 잦고, 실패 비용(사용자 재주문)이 높은 경우 유리
+     *   - 재고 차감처럼 "줄어드는 자원"은 경합이 높을수록 낙관적 락의 재시도 비용이 커짐
+     *
+     * 결론: 재고는 비관적 락이 더 예측 가능하고 구현이 단순하다.
+     *
+     * ─── 데드락 위험과 대응 ───────────────────────────────────────────────────
+     * SELECT FOR UPDATE를 여러 행에 걸쳐 사용할 경우 락 획득 순서가 다르면 데드락 발생.
+     * 이 쿼리를 호출하는 OrderDomainService.prepareOrderLines()에서
+     * productId 오름차순 정렬 후 호출하여 락 순서를 전역적으로 통일한다.
+     */
+    @Lock(LockModeType.PESSIMISTIC_WRITE)
+    @Query("SELECT p FROM Product p WHERE p.id = :id")
+    Optional<Product> findByIdForUpdate(@Param("id") Long id);
+
+    @Query("SELECT p FROM Product p LEFT JOIN com.loopers.domain.like.Like l ON l.productId = p.id " +
+           "WHERE p.deletedAt IS NULL GROUP BY p ORDER BY COUNT(l) DESC")
+    List<Product> findAllOrderByLikesDesc();
+}
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
new file mode 100644
index 000000000..bada6fe34
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/infrastructure/product/ProductRepositoryImpl.java
@@ -0,0 +1,42 @@
+package com.loopers.infrastructure.product;
+
+import com.loopers.domain.product.Product;
+import com.loopers.domain.product.ProductRepository;
+import com.loopers.domain.product.SortCondition;
+import lombok.RequiredArgsConstructor;
+import org.springframework.data.domain.Sort;
+import org.springframework.stereotype.Component;
+
+import java.util.List;
+import java.util.Optional;
+
+@RequiredArgsConstructor
+@Component
+public class ProductRepositoryImpl implements ProductRepository {
+
+    private final ProductJpaRepository productJpaRepository;
+
+    @Override
+    public Product save(Product product) {
+        return productJpaRepository.save(product);
+    }
+
+    @Override
+    public Optional<Product> findById(Long id) {
+        return productJpaRepository.findById(id);
+    }
+
+    @Override
+    public Optional<Product> findByIdForUpdate(Long id) {
+        return productJpaRepository.findByIdForUpdate(id);
+    }
+
+    @Override
+    public List<Product> findAll(SortCondition sort) {
+        return switch (sort) {
+            case latest -> productJpaRepository.findAll(Sort.by(Sort.Direction.DESC, "createdAt"));
+            case price_asc -> productJpaRepository.findAll(Sort.by(Sort.Direction.ASC, "price"));
+            case likes_desc -> productJpaRepository.findAllOrderByLikesDesc();
+        };
+    }
+}
\ No newline at end of file
diff --git a/apps/commerce-api/src/main/java/com/loopers/interfaces/api/ApiResponse.java b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/ApiResponse.java
index 33b77b529..6eeab16da 100644
--- a/apps/commerce-api/src/main/java/com/loopers/interfaces/api/ApiResponse.java
+++ b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/ApiResponse.java
@@ -15,8 +15,9 @@ public static Metadata fail(String errorCode, String errorMessage) {
         }
     }
 
-    public static ApiResponse<Object> success() {
-        return new ApiResponse<>(Metadata.success(), null);
+    @SuppressWarnings("unchecked")
+    public static <T> ApiResponse<T> success() {
+        return (ApiResponse<T>) new ApiResponse<>(Metadata.success(), null);
     }
 
     public static <T> ApiResponse<T> success(T data) {
diff --git a/apps/commerce-api/src/main/java/com/loopers/interfaces/api/coupon/CouponAdminV1ApiSpec.java b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/coupon/CouponAdminV1ApiSpec.java
new file mode 100644
index 000000000..ff6ba8df7
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/coupon/CouponAdminV1ApiSpec.java
@@ -0,0 +1,27 @@
+package com.loopers.interfaces.api.coupon;
+
+import com.loopers.interfaces.api.ApiResponse;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.tags.Tag;
+
+@Tag(name = "Coupon Admin V1 API", description = "쿠폰 관리자 API")
+public interface CouponAdminV1ApiSpec {
+
+    @Operation(summary = "쿠폰 템플릿 목록 조회")
+    ApiResponse<CouponAdminV1Dto.CouponTemplateListResponse> getTemplates(int page, int size);
+
+    @Operation(summary = "쿠폰 템플릿 상세 조회")
+    ApiResponse<CouponAdminV1Dto.CouponTemplateResponse> getTemplate(Long couponId);
+
+    @Operation(summary = "쿠폰 템플릿 등록")
+    ApiResponse<CouponAdminV1Dto.CouponTemplateResponse> createTemplate(CouponAdminV1Dto.CreateRequest request);
+
+    @Operation(summary = "쿠폰 템플릿 수정")
+    ApiResponse<CouponAdminV1Dto.CouponTemplateResponse> updateTemplate(Long couponId, CouponAdminV1Dto.UpdateRequest request);
+
+    @Operation(summary = "쿠폰 템플릿 삭제")
+    ApiResponse<Object> deleteTemplate(Long couponId);
+
+    @Operation(summary = "쿠폰 발급 내역 조회")
+    ApiResponse<CouponAdminV1Dto.IssuedCouponListResponse> getIssuedCoupons(Long couponId, int page, int size);
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/interfaces/api/coupon/CouponAdminV1Controller.java b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/coupon/CouponAdminV1Controller.java
new file mode 100644
index 000000000..e3519ad39
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/coupon/CouponAdminV1Controller.java
@@ -0,0 +1,92 @@
+package com.loopers.interfaces.api.coupon;
+
+import com.loopers.application.coupon.CouponAdminService;
+import com.loopers.application.coupon.CouponInfo;
+import com.loopers.interfaces.api.ApiResponse;
+import jakarta.validation.Valid;
+import lombok.RequiredArgsConstructor;
+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;
+
+@RequiredArgsConstructor
+@RestController
+@RequestMapping("/api-admin/v1/coupons")
+public class CouponAdminV1Controller implements CouponAdminV1ApiSpec {
+
+    private final CouponAdminService couponAdminService;
+
+    @GetMapping
+    @Override
+    public ApiResponse<CouponAdminV1Dto.CouponTemplateListResponse> getTemplates(
+        @RequestParam(defaultValue = "0") int page,
+        @RequestParam(defaultValue = "20") int size
+    ) {
+        List<CouponAdminV1Dto.CouponTemplateResponse> coupons = couponAdminService.getTemplates(page, size).stream()
+            .map(CouponAdminV1Dto.CouponTemplateResponse::from)
+            .toList();
+        long totalCount = couponAdminService.getTemplateCount();
+        return ApiResponse.success(new CouponAdminV1Dto.CouponTemplateListResponse(coupons, totalCount, page, size));
+    }
+
+    @GetMapping("/{couponId}")
+    @Override
+    public ApiResponse<CouponAdminV1Dto.CouponTemplateResponse> getTemplate(@PathVariable Long couponId) {
+        CouponInfo.CouponTemplateInfo info = couponAdminService.getTemplate(couponId);
+        return ApiResponse.success(CouponAdminV1Dto.CouponTemplateResponse.from(info));
+    }
+
+    @PostMapping
+    @Override
+    public ApiResponse<CouponAdminV1Dto.CouponTemplateResponse> createTemplate(
+        @Valid @RequestBody CouponAdminV1Dto.CreateRequest request
+    ) {
+        CouponInfo.CouponTemplateInfo info = couponAdminService.create(
+            request.name(), request.type(), request.value(),
+            request.minOrderAmount(), request.expiredAt()
+        );
+        return ApiResponse.success(CouponAdminV1Dto.CouponTemplateResponse.from(info));
+    }
+
+    @PutMapping("/{couponId}")
+    @Override
+    public ApiResponse<CouponAdminV1Dto.CouponTemplateResponse> updateTemplate(
+        @PathVariable Long couponId,
+        @Valid @RequestBody CouponAdminV1Dto.UpdateRequest request
+    ) {
+        CouponInfo.CouponTemplateInfo info = couponAdminService.update(
+            couponId, request.name(), request.type(), request.value(),
+            request.minOrderAmount(), request.expiredAt()
+        );
+        return ApiResponse.success(CouponAdminV1Dto.CouponTemplateResponse.from(info));
+    }
+
+    @DeleteMapping("/{couponId}")
+    @Override
+    public ApiResponse<Object> deleteTemplate(@PathVariable Long couponId) {
+        couponAdminService.delete(couponId);
+        return ApiResponse.success();
+    }
+
+    @GetMapping("/{couponId}/issues")
+    @Override
+    public ApiResponse<CouponAdminV1Dto.IssuedCouponListResponse> getIssuedCoupons(
+        @PathVariable Long couponId,
+        @RequestParam(defaultValue = "0") int page,
+        @RequestParam(defaultValue = "20") int size
+    ) {
+        List<CouponAdminV1Dto.IssuedCouponResponse> issues = couponAdminService.getIssuedCoupons(couponId, page, size).stream()
+            .map(CouponAdminV1Dto.IssuedCouponResponse::from)
+            .toList();
+        long totalCount = couponAdminService.getIssuedCouponCount(couponId);
+        return ApiResponse.success(new CouponAdminV1Dto.IssuedCouponListResponse(issues, totalCount, page, size));
+    }
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/interfaces/api/coupon/CouponAdminV1Dto.java b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/coupon/CouponAdminV1Dto.java
new file mode 100644
index 000000000..f7041c1be
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/coupon/CouponAdminV1Dto.java
@@ -0,0 +1,94 @@
+package com.loopers.interfaces.api.coupon;
+
+import com.loopers.application.coupon.CouponInfo;
+import com.loopers.domain.coupon.CouponStatus;
+import com.loopers.domain.coupon.CouponType;
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.NotNull;
+import jakarta.validation.constraints.Positive;
+
+import java.time.ZonedDateTime;
+import java.util.List;
+
+public class CouponAdminV1Dto {
+
+    public record CreateRequest(
+        @NotBlank(message = "쿠폰 이름은 필수입니다")
+        String name,
+
+        @NotNull(message = "쿠폰 타입은 필수입니다")
+        CouponType type,
+
+        @NotNull(message = "쿠폰 값은 필수입니다")
+        @Positive(message = "쿠폰 값은 0보다 커야 합니다")
+        Long value,
+
+        Long minOrderAmount,
+
+        @NotNull(message = "만료일은 필수입니다")
+        ZonedDateTime expiredAt
+    ) {}
+
+    public record UpdateRequest(
+        @NotBlank(message = "쿠폰 이름은 필수입니다")
+        String name,
+
+        @NotNull(message = "쿠폰 타입은 필수입니다")
+        CouponType type,
+
+        @NotNull(message = "쿠폰 값은 필수입니다")
+        @Positive(message = "쿠폰 값은 0보다 커야 합니다")
+        Long value,
+
+        Long minOrderAmount,
+
+        @NotNull(message = "만료일은 필수입니다")
+        ZonedDateTime expiredAt
+    ) {}
+
+    public record CouponTemplateResponse(
+        Long id,
+        String name,
+        CouponType type,
+        long value,
+        Long minOrderAmount,
+        ZonedDateTime expiredAt,
+        ZonedDateTime createdAt
+    ) {
+        public static CouponTemplateResponse from(CouponInfo.CouponTemplateInfo info) {
+            return new CouponTemplateResponse(
+                info.id(), info.name(), info.type(), info.value(),
+                info.minOrderAmount(), info.expiredAt(), info.createdAt()
+            );
+        }
+    }
+
+    public record CouponTemplateListResponse(
+        List<CouponTemplateResponse> coupons,
+        long totalCount,
+        int page,
+        int size
+    ) {}
+
+    public record IssuedCouponResponse(
+        Long issuedCouponId,
+        Long memberId,
+        CouponStatus status,
+        ZonedDateTime usedAt,
+        ZonedDateTime createdAt
+    ) {
+        public static IssuedCouponResponse from(CouponInfo.IssuedCouponDetailInfo info) {
+            return new IssuedCouponResponse(
+                info.issuedCouponId(), info.memberId(), info.status(),
+                info.usedAt(), info.createdAt()
+            );
+        }
+    }
+
+    public record IssuedCouponListResponse(
+        List<IssuedCouponResponse> issues,
+        long totalCount,
+        int page,
+        int size
+    ) {}
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/interfaces/api/coupon/CouponV1ApiSpec.java b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/coupon/CouponV1ApiSpec.java
new file mode 100644
index 000000000..82d7a7322
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/coupon/CouponV1ApiSpec.java
@@ -0,0 +1,15 @@
+package com.loopers.interfaces.api.coupon;
+
+import com.loopers.interfaces.api.ApiResponse;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.tags.Tag;
+
+@Tag(name = "Coupon V1 API", description = "쿠폰 사용자 API")
+public interface CouponV1ApiSpec {
+
+    @Operation(summary = "쿠폰 발급", description = "사용자에게 쿠폰을 발급합니다.")
+    ApiResponse<CouponV1Dto.IssuedCouponResponse> issueCoupon(Long memberId, Long couponId);
+
+    @Operation(summary = "내 쿠폰 목록 조회", description = "사용자의 쿠폰 목록을 조회합니다.")
+    ApiResponse<CouponV1Dto.MyCouponsResponse> getMyCoupons(Long memberId);
+}
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..1dedc843d
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/coupon/CouponV1Controller.java
@@ -0,0 +1,39 @@
+package com.loopers.interfaces.api.coupon;
+
+import com.loopers.application.coupon.CouponFacade;
+import com.loopers.application.coupon.CouponInfo;
+import com.loopers.application.coupon.CouponService;
+import com.loopers.interfaces.api.ApiResponse;
+import lombok.RequiredArgsConstructor;
+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.RequestParam;
+import org.springframework.web.bind.annotation.RestController;
+
+import java.util.List;
+
+@RequiredArgsConstructor
+@RestController
+public class CouponV1Controller implements CouponV1ApiSpec {
+
+    private final CouponService couponService;
+    private final CouponFacade couponFacade;
+
+    @PostMapping("/api/v1/coupons/{couponId}/issue")
+    @Override
+    public ApiResponse<CouponV1Dto.IssuedCouponResponse> issueCoupon(
+        @RequestParam Long memberId,
+        @PathVariable Long couponId
+    ) {
+        CouponInfo.IssuedCouponInfo info = couponService.issue(memberId, couponId);
+        return ApiResponse.success(CouponV1Dto.IssuedCouponResponse.from(info));
+    }
+
+    @GetMapping("/api/v1/users/me/coupons")
+    @Override
+    public ApiResponse<CouponV1Dto.MyCouponsResponse> getMyCoupons(@RequestParam Long memberId) {
+        List<CouponInfo.IssuedCouponInfo> infos = couponFacade.getMyCoupons(memberId);
+        return ApiResponse.success(CouponV1Dto.MyCouponsResponse.from(infos));
+    }
+}
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..75c781c1f
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/coupon/CouponV1Dto.java
@@ -0,0 +1,45 @@
+package com.loopers.interfaces.api.coupon;
+
+import com.loopers.application.coupon.CouponInfo;
+import com.loopers.domain.coupon.CouponStatus;
+import com.loopers.domain.coupon.CouponType;
+
+import java.time.ZonedDateTime;
+import java.util.List;
+
+public class CouponV1Dto {
+
+    public record IssuedCouponResponse(
+        Long issuedCouponId,
+        Long couponTemplateId,
+        String name,
+        CouponType type,
+        long value,
+        Long minOrderAmount,
+        CouponStatus status,
+        ZonedDateTime expiredAt,
+        ZonedDateTime usedAt
+    ) {
+        public static IssuedCouponResponse from(CouponInfo.IssuedCouponInfo info) {
+            return new IssuedCouponResponse(
+                info.issuedCouponId(),
+                info.couponTemplateId(),
+                info.name(),
+                info.type(),
+                info.value(),
+                info.minOrderAmount(),
+                info.status(),
+                info.expiredAt(),
+                info.usedAt()
+            );
+        }
+    }
+
+    public record MyCouponsResponse(List<IssuedCouponResponse> coupons) {
+        public static MyCouponsResponse from(List<CouponInfo.IssuedCouponInfo> infos) {
+            return new MyCouponsResponse(
+                infos.stream().map(IssuedCouponResponse::from).toList()
+            );
+        }
+    }
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/interfaces/api/like/LikeV1ApiSpec.java b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/like/LikeV1ApiSpec.java
new file mode 100644
index 000000000..b689957af
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/like/LikeV1ApiSpec.java
@@ -0,0 +1,25 @@
+package com.loopers.interfaces.api.like;
+
+import com.loopers.interfaces.api.ApiResponse;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import jakarta.validation.Valid;
+import org.springframework.web.bind.annotation.DeleteMapping;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+
+@Tag(name = "Like V1 API", description = "좋아요 API")
+@RequestMapping("/api/v1/likes")
+public interface LikeV1ApiSpec {
+
+    @Operation(summary = "좋아요 등록", description = "상품에 좋아요를 등록합니다.")
+    ApiResponse<Void> like(@Valid @RequestBody LikeV1Dto.LikeRequest request);
+
+    @Operation(summary = "좋아요 취소", description = "상품 좋아요를 취소합니다.")
+    ApiResponse<Void> unlike(
+        @RequestParam Long memberId,
+        @RequestParam Long productId
+    );
+}
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
new file mode 100644
index 000000000..2bc2fbcad
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/like/LikeV1Controller.java
@@ -0,0 +1,37 @@
+package com.loopers.interfaces.api.like;
+
+import com.loopers.application.like.LikeService;
+import com.loopers.interfaces.api.ApiResponse;
+import jakarta.validation.Valid;
+import lombok.RequiredArgsConstructor;
+import org.springframework.web.bind.annotation.DeleteMapping;
+import org.springframework.web.bind.annotation.PostMapping;
+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;
+
+@RequiredArgsConstructor
+@RestController
+@RequestMapping("/api/v1/likes")
+public class LikeV1Controller implements LikeV1ApiSpec {
+
+    private final LikeService likeService;
+
+    @PostMapping
+    @Override
+    public ApiResponse<Void> like(@Valid @RequestBody LikeV1Dto.LikeRequest request) {
+        likeService.like(request.memberId(), request.productId());
+        return ApiResponse.success();
+    }
+
+    @DeleteMapping
+    @Override
+    public ApiResponse<Void> unlike(
+        @RequestParam Long memberId,
+        @RequestParam Long productId
+    ) {
+        likeService.unlike(memberId, productId);
+        return ApiResponse.success();
+    }
+}
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
new file mode 100644
index 000000000..0b7432bd8
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/like/LikeV1Dto.java
@@ -0,0 +1,14 @@
+package com.loopers.interfaces.api.like;
+
+import jakarta.validation.constraints.NotNull;
+
+public class LikeV1Dto {
+
+    public record LikeRequest(
+        @NotNull(message = "회원 ID는 필수입니다")
+        Long memberId,
+
+        @NotNull(message = "상품 ID는 필수입니다")
+        Long productId
+    ) {}
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/interfaces/api/member/MemberV1ApiSpec.java b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/member/MemberV1ApiSpec.java
new file mode 100644
index 000000000..c93074ef0
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/member/MemberV1ApiSpec.java
@@ -0,0 +1,17 @@
+package com.loopers.interfaces.api.member;
+
+import com.loopers.interfaces.api.ApiResponse;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import jakarta.validation.Valid;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+
+@Tag(name = "Member V1 API", description = "회원 API")
+@RequestMapping("/api/v1/members")
+public interface MemberV1ApiSpec {
+
+    @Operation(summary = "회원가입", description = "새 회원을 등록합니다.")
+    ApiResponse<MemberV1Dto.SignUpResponse> signUp(@Valid @RequestBody MemberV1Dto.SignUpRequest request);
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/interfaces/api/member/MemberV1Controller.java b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/member/MemberV1Controller.java
new file mode 100644
index 000000000..e71ec02d2
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/member/MemberV1Controller.java
@@ -0,0 +1,32 @@
+package com.loopers.interfaces.api.member;
+
+import com.loopers.domain.member.Member;
+import com.loopers.domain.member.MemberService;
+import com.loopers.interfaces.api.ApiResponse;
+import jakarta.validation.Valid;
+import lombok.RequiredArgsConstructor;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+@RequiredArgsConstructor
+@RestController
+@RequestMapping("/api/v1/members")
+public class MemberV1Controller implements MemberV1ApiSpec {
+
+    private final MemberService memberService;
+
+    @PostMapping("/signup")
+    @Override
+    public ApiResponse<MemberV1Dto.SignUpResponse> signUp(@Valid @RequestBody MemberV1Dto.SignUpRequest request) {
+        Member member = memberService.signUp(
+            request.loginId(),
+            request.password(),
+            request.name(),
+            request.birthDate(),
+            request.email()
+        );
+        return ApiResponse.success(MemberV1Dto.SignUpResponse.from(member));
+    }
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/interfaces/api/member/MemberV1Dto.java b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/member/MemberV1Dto.java
new file mode 100644
index 000000000..ca2906884
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/member/MemberV1Dto.java
@@ -0,0 +1,38 @@
+package com.loopers.interfaces.api.member;
+
+import com.loopers.domain.member.Member;
+import jakarta.validation.constraints.Email;
+import jakarta.validation.constraints.NotBlank;
+
+public class MemberV1Dto {
+
+    public record SignUpRequest(
+        @NotBlank(message = "로그인ID는 필수입니다")
+        String loginId,
+
+        @NotBlank(message = "비밀번호는 필수입니다")
+        String password,
+
+        @NotBlank(message = "이름은 필수입니다")
+        String name,
+
+        @NotBlank(message = "생년월일은 필수입니다")
+        String birthDate,
+
+        @NotBlank(message = "이메일은 필수입니다")
+        @Email(message = "올바른 이메일 형식이 아닙니다")
+        String email
+    ) {}
+
+    public record SignUpResponse(Long id, String loginId, String name, String birthDate, String email) {
+        public static SignUpResponse from(Member member) {
+            return new SignUpResponse(
+                member.getId(),
+                member.getLoginId(),
+                member.getName(),
+                member.getBirthDate(),
+                member.getEmail()
+            );
+        }
+    }
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/interfaces/api/order/OrderV1ApiSpec.java b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/order/OrderV1ApiSpec.java
new file mode 100644
index 000000000..5d6a0e31f
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/order/OrderV1ApiSpec.java
@@ -0,0 +1,17 @@
+package com.loopers.interfaces.api.order;
+
+import com.loopers.interfaces.api.ApiResponse;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import jakarta.validation.Valid;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+
+@Tag(name = "Order V1 API", description = "주문 API")
+@RequestMapping("/api/v1/orders")
+public interface OrderV1ApiSpec {
+
+    @Operation(summary = "주문 생성", description = "상품을 주문합니다.")
+    ApiResponse<OrderV1Dto.OrderCreateResponse> createOrder(@Valid @RequestBody OrderV1Dto.OrderCreateRequest request);
+}
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
new file mode 100644
index 000000000..257b70296
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/order/OrderV1Controller.java
@@ -0,0 +1,32 @@
+package com.loopers.interfaces.api.order;
+
+import com.loopers.application.order.OrderService;
+import com.loopers.domain.order.OrderDomainService;
+import com.loopers.interfaces.api.ApiResponse;
+import jakarta.validation.Valid;
+import lombok.RequiredArgsConstructor;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+@RequiredArgsConstructor
+@RestController
+@RequestMapping("/api/v1/orders")
+public class OrderV1Controller implements OrderV1ApiSpec {
+
+    private final OrderService orderService;
+
+    @PostMapping
+    @Override
+    public ApiResponse<OrderV1Dto.OrderCreateResponse> createOrder(@Valid @RequestBody OrderV1Dto.OrderCreateRequest request) {
+        List<OrderDomainService.OrderLineRequest> items = request.items().stream()
+            .map(item -> new OrderDomainService.OrderLineRequest(item.productId(), item.quantity()))
+            .collect(Collectors.toList());
+        OrderService.OrderResult result = orderService.placeOrder(request.memberId(), items, request.couponId());
+        return ApiResponse.success(OrderV1Dto.OrderCreateResponse.from(result));
+    }
+}
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
new file mode 100644
index 000000000..5b0d7955d
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/order/OrderV1Dto.java
@@ -0,0 +1,56 @@
+package com.loopers.interfaces.api.order;
+
+import com.loopers.application.order.OrderService;
+import jakarta.validation.Valid;
+import jakarta.validation.constraints.Min;
+import jakarta.validation.constraints.NotNull;
+
+import java.util.List;
+
+public class OrderV1Dto {
+
+    public record OrderCreateRequest(
+        @NotNull(message = "회원 ID는 필수입니다")
+        Long memberId,
+
+        @Valid
+        @NotNull(message = "주문 항목은 필수입니다")
+        List<OrderLineRequest> items,
+
+        Long couponId
+    ) {}
+
+    public record OrderLineRequest(
+        @NotNull(message = "상품 ID는 필수입니다")
+        Long productId,
+
+        @NotNull(message = "수량은 필수입니다")
+        @Min(value = 1, message = "수량은 1 이상이어야 합니다")
+        Integer quantity
+    ) {}
+
+    public record OrderCreateResponse(
+        Long orderId,
+        String status,
+        long originalAmount,
+        long discountAmount,
+        long totalAmount,
+        List<OrderLineResponse> orderLines
+    ) {
+        public static OrderCreateResponse from(OrderService.OrderResult result) {
+            List<OrderLineResponse> lines = result.orderLines().stream()
+                .map(ol -> new OrderLineResponse(ol.productId(), ol.quantity(), ol.unitPrice()))
+                .toList();
+            return new OrderCreateResponse(
+                result.orderId(),
+                result.status(),
+                result.originalAmount(),
+                result.discountAmount(),
+                result.totalAmount(),
+                lines
+            );
+        }
+    }
+
+    public record OrderLineResponse(Long productId, int quantity, long unitPrice) {}
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/interfaces/api/product/ProductV1ApiSpec.java b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/product/ProductV1ApiSpec.java
new file mode 100644
index 000000000..6f2e0e75d
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/product/ProductV1ApiSpec.java
@@ -0,0 +1,21 @@
+package com.loopers.interfaces.api.product;
+
+import com.loopers.domain.product.SortCondition;
+import com.loopers.interfaces.api.ApiResponse;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.Parameter;
+import io.swagger.v3.oas.annotations.tags.Tag;
+
+import java.util.List;
+
+@Tag(name = "Product V1 API", description = "상품 API")
+public interface ProductV1ApiSpec {
+
+    @Operation(summary = "상품 목록 조회", description = "정렬 조건에 따라 상품 목록을 조회합니다.")
+    ApiResponse<List<ProductV1Dto.ProductListResponse>> getProductList(
+        @Parameter(description = "정렬 조건: latest, price_asc, likes_desc") SortCondition sort
+    );
+
+    @Operation(summary = "상품 상세 조회", description = "ID로 상품 상세 정보를 조회합니다.")
+    ApiResponse<ProductV1Dto.ProductDetailResponse> getProductDetail(Long productId);
+}
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
new file mode 100644
index 000000000..842a57626
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/product/ProductV1Controller.java
@@ -0,0 +1,44 @@
+package com.loopers.interfaces.api.product;
+
+import com.loopers.application.product.ProductDetailInfo;
+import com.loopers.application.product.ProductFacade;
+import com.loopers.application.product.ProductListInfo;
+import com.loopers.domain.product.SortCondition;
+import com.loopers.interfaces.api.ApiResponse;
+import lombok.RequiredArgsConstructor;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PathVariable;
+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;
+
+@RequiredArgsConstructor
+@RestController
+@RequestMapping("/api/v1/products")
+public class ProductV1Controller implements ProductV1ApiSpec {
+
+    private final ProductFacade productFacade;
+
+    @GetMapping
+    @Override
+    public ApiResponse<List<ProductV1Dto.ProductListResponse>> getProductList(
+        @RequestParam(defaultValue = "latest") SortCondition sort
+    ) {
+        List<ProductListInfo> productList = productFacade.getProductList(sort);
+        List<ProductV1Dto.ProductListResponse> response = productList.stream()
+            .map(ProductV1Dto.ProductListResponse::from)
+            .toList();
+        return ApiResponse.success(response);
+    }
+
+    @GetMapping("/{productId}")
+    @Override
+    public ApiResponse<ProductV1Dto.ProductDetailResponse> getProductDetail(
+        @PathVariable Long productId
+    ) {
+        ProductDetailInfo info = productFacade.getProductDetail(productId);
+        return 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
new file mode 100644
index 000000000..16a4b8a31
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/product/ProductV1Dto.java
@@ -0,0 +1,50 @@
+package com.loopers.interfaces.api.product;
+
+import com.loopers.application.product.ProductDetailInfo;
+import com.loopers.application.product.ProductListInfo;
+
+public class ProductV1Dto {
+
+    public record ProductDetailResponse(
+        Long id,
+        String name,
+        Long price,
+        int stockQuantity,
+        BrandResponse brand,
+        long likeCount
+    ) {
+        public static ProductDetailResponse from(ProductDetailInfo info) {
+            BrandResponse brandResponse = info.brand() != null
+                ? new BrandResponse(info.brand().id(), info.brand().name())
+                : null;
+            return new ProductDetailResponse(
+                info.id(),
+                info.name(),
+                info.price(),
+                info.stockQuantity(),
+                brandResponse,
+                info.likeCount()
+            );
+        }
+    }
+
+    public record BrandResponse(Long id, String name) {}
+
+    public record ProductListResponse(
+        Long id,
+        String name,
+        Long price,
+        String brandName,
+        long likeCount
+    ) {
+        public static ProductListResponse from(ProductListInfo info) {
+            return new ProductListResponse(
+                info.id(),
+                info.name(),
+                info.price(),
+                info.brandName(),
+                info.likeCount()
+            );
+        }
+    }
+}
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 5d142efbf..8d57ce252 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
@@ -11,7 +11,17 @@ public enum ErrorType {
     INTERNAL_ERROR(HttpStatus.INTERNAL_SERVER_ERROR, HttpStatus.INTERNAL_SERVER_ERROR.getReasonPhrase(), "일시적인 오류가 발생했습니다."),
     BAD_REQUEST(HttpStatus.BAD_REQUEST, HttpStatus.BAD_REQUEST.getReasonPhrase(), "잘못된 요청입니다."),
     NOT_FOUND(HttpStatus.NOT_FOUND, HttpStatus.NOT_FOUND.getReasonPhrase(), "존재하지 않는 요청입니다."),
-    CONFLICT(HttpStatus.CONFLICT, HttpStatus.CONFLICT.getReasonPhrase(), "이미 존재하는 리소스입니다.");
+    CONFLICT(HttpStatus.CONFLICT, HttpStatus.CONFLICT.getReasonPhrase(), "이미 존재하는 리소스입니다."),
+    FORBIDDEN(HttpStatus.FORBIDDEN, HttpStatus.FORBIDDEN.getReasonPhrase(), "접근이 거부되었습니다."),
+    INSUFFICIENT_STOCK(HttpStatus.BAD_REQUEST, "INSUFFICIENT_STOCK", "재고가 부족합니다."),
+
+    COUPON_NOT_FOUND(HttpStatus.NOT_FOUND, "COUPON_NOT_FOUND", "쿠폰을 찾을 수 없습니다."),
+    COUPON_ALREADY_USED(HttpStatus.BAD_REQUEST, "COUPON_ALREADY_USED", "이미 사용된 쿠폰입니다."),
+    COUPON_EXPIRED(HttpStatus.BAD_REQUEST, "COUPON_EXPIRED", "만료된 쿠폰입니다."),
+    COUPON_NOT_OWNED(HttpStatus.FORBIDDEN, "COUPON_NOT_OWNED", "본인의 쿠폰만 사용할 수 있습니다."),
+    COUPON_MIN_ORDER_AMOUNT(HttpStatus.BAD_REQUEST, "COUPON_MIN_ORDER_AMOUNT", "최소 주문 금액을 충족하지 않습니다."),
+    COUPON_ALREADY_ISSUED(HttpStatus.CONFLICT, "COUPON_ALREADY_ISSUED", "이미 발급받은 쿠폰입니다."),
+    COUPON_UNAVAILABLE(HttpStatus.BAD_REQUEST, "COUPON_UNAVAILABLE", "사용할 수 없는 쿠폰입니다.");
 
     private final HttpStatus status;
     private final String code;
diff --git a/apps/commerce-api/src/test/java/com/loopers/application/like/LikeServiceTest.java b/apps/commerce-api/src/test/java/com/loopers/application/like/LikeServiceTest.java
new file mode 100644
index 000000000..d16d693eb
--- /dev/null
+++ b/apps/commerce-api/src/test/java/com/loopers/application/like/LikeServiceTest.java
@@ -0,0 +1,175 @@
+package com.loopers.application.like;
+
+import com.loopers.domain.like.Like;
+import com.loopers.domain.like.LikeRepository;
+import com.loopers.domain.product.Product;
+import com.loopers.domain.product.ProductRepository;
+import com.loopers.support.error.CoreException;
+import com.loopers.support.error.ErrorType;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.concurrent.ConcurrentHashMap;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+class LikeServiceTest {
+
+    private LikeService likeService;
+    private FakeLikeRepository fakeLikeRepository;
+    private FakeProductRepository fakeProductRepository;
+
+    @BeforeEach
+    void setUp() {
+        fakeLikeRepository = new FakeLikeRepository();
+        fakeProductRepository = new FakeProductRepository();
+        likeService = new LikeService(fakeLikeRepository, fakeProductRepository);
+    }
+
+    @DisplayName("좋아요 등록")
+    @Nested
+    class LikeTest {
+
+        @DisplayName("존재하는 상품에 좋아요를 등록하면 성공한다")
+        @Test
+        void success() {
+            Long memberId = 1L;
+            fakeProductRepository.save(new Product(1L, "상품", 10_000L, 10));
+            Long productId = 1L;
+
+            likeService.like(memberId, productId);
+
+            assertThat(fakeLikeRepository.existsByMemberIdAndProductId(memberId, productId)).isTrue();
+        }
+
+        @DisplayName("이미 좋아요한 상품에 다시 좋아요해도 멱등하게 동작한다")
+        @Test
+        void idempotent() {
+            Long memberId = 1L;
+            fakeProductRepository.save(new Product(1L, "상품", 10_000L, 10));
+            Long productId = 1L;
+
+            likeService.like(memberId, productId);
+            likeService.like(memberId, productId);
+
+            assertThat(fakeLikeRepository.countByProductId(productId)).isEqualTo(1);
+        }
+
+        @DisplayName("존재하지 않는 상품에 좋아요하면 NOT_FOUND 예외가 발생한다")
+        @Test
+        void failsWhenProductNotFound() {
+            Long memberId = 1L;
+            Long nonExistentProductId = 999L;
+
+            assertThatThrownBy(() -> likeService.like(memberId, nonExistentProductId))
+                .isInstanceOf(CoreException.class)
+                .hasFieldOrPropertyWithValue("errorType", ErrorType.NOT_FOUND);
+        }
+    }
+
+    @DisplayName("좋아요 취소")
+    @Nested
+    class Unlike {
+
+        @DisplayName("좋아요한 상품의 좋아요를 취소하면 성공한다")
+        @Test
+        void success() {
+            Long memberId = 1L;
+            fakeProductRepository.save(new Product(1L, "상품", 10_000L, 10));
+            Long productId = 1L;
+            fakeLikeRepository.save(new Like(memberId, productId));
+
+            likeService.unlike(memberId, productId);
+
+            assertThat(fakeLikeRepository.existsByMemberIdAndProductId(memberId, productId)).isFalse();
+        }
+
+        @DisplayName("좋아요하지 않은 상품의 좋아요를 취소해도 예외 없이 동작한다")
+        @Test
+        void idempotent() {
+            Long memberId = 1L;
+            Long productId = 100L;
+
+            likeService.unlike(memberId, productId);
+
+            assertThat(fakeLikeRepository.countByProductId(productId)).isEqualTo(0);
+        }
+    }
+
+    static class FakeProductRepository implements ProductRepository {
+        private final Map<Long, Product> store = new ConcurrentHashMap<>();
+        private long nextId = 1;
+
+        @Override
+        public Product save(Product product) {
+            Product toSave = new Product(
+                product.getBrandId(),
+                product.getName(),
+                product.getPrice(),
+                product.getStockQuantity()
+            );
+            long id = nextId++;
+            store.put(id, toSave);
+            return toSave;
+        }
+
+        @Override
+        public Optional<Product> findById(Long id) {
+            return Optional.ofNullable(store.get(id));
+        }
+
+        @Override
+        public Optional<Product> findByIdForUpdate(Long id) {
+            return findById(id);
+        }
+
+        @Override
+        public java.util.List<Product> findAll(com.loopers.domain.product.SortCondition sort) {
+            return new ArrayList<>(store.values());
+        }
+    }
+
+    static class FakeLikeRepository implements LikeRepository {
+        private final List<Like> store = new ArrayList<>();
+        private long id = 1;
+
+        @Override
+        public Like save(Like like) {
+            Like toSave = new Like(like.getMemberId(), like.getProductId());
+            store.add(toSave);
+            id++;
+            return toSave;
+        }
+
+        @Override
+        public void deleteByMemberIdAndProductId(Long memberId, Long productId) {
+            store.removeIf(l -> l.getMemberId().equals(memberId) && l.getProductId().equals(productId));
+        }
+
+        @Override
+        public boolean existsByMemberIdAndProductId(Long memberId, Long productId) {
+            return store.stream()
+                .anyMatch(l -> l.getMemberId().equals(memberId) && l.getProductId().equals(productId));
+        }
+
+        @Override
+        public long countByProductId(Long productId) {
+            return store.stream()
+                .filter(l -> l.getProductId().equals(productId))
+                .count();
+        }
+
+        @Override
+        public Map<Long, Long> countByProductIds(List<Long> productIds) {
+            return productIds.stream()
+                .collect(java.util.stream.Collectors.toMap(id -> id, this::countByProductId));
+        }
+    }
+}
diff --git a/apps/commerce-api/src/test/java/com/loopers/application/order/OrderServiceTest.java b/apps/commerce-api/src/test/java/com/loopers/application/order/OrderServiceTest.java
new file mode 100644
index 000000000..89e06ca6a
--- /dev/null
+++ b/apps/commerce-api/src/test/java/com/loopers/application/order/OrderServiceTest.java
@@ -0,0 +1,278 @@
+package com.loopers.application.order;
+
+import com.loopers.domain.coupon.CouponTemplate;
+import com.loopers.domain.coupon.CouponTemplateRepository;
+import com.loopers.domain.coupon.CouponType;
+import com.loopers.domain.coupon.IssuedCoupon;
+import com.loopers.domain.coupon.IssuedCouponRepository;
+import com.loopers.domain.order.Order;
+import com.loopers.domain.order.OrderDomainService;
+import com.loopers.domain.order.OrderRepository;
+import com.loopers.domain.product.Product;
+import com.loopers.domain.product.ProductRepository;
+import com.loopers.domain.product.SortCondition;
+import com.loopers.support.error.CoreException;
+import com.loopers.support.error.ErrorType;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+
+import java.time.ZonedDateTime;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.concurrent.ConcurrentHashMap;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+class OrderServiceTest {
+
+    private OrderService orderService;
+    private FakeProductRepository fakeProductRepository;
+    private FakeOrderRepository fakeOrderRepository;
+    private FakeIssuedCouponRepository fakeIssuedCouponRepository;
+    private FakeCouponTemplateRepository fakeCouponTemplateRepository;
+
+    @BeforeEach
+    void setUp() {
+        fakeProductRepository = new FakeProductRepository();
+        fakeOrderRepository = new FakeOrderRepository();
+        fakeIssuedCouponRepository = new FakeIssuedCouponRepository();
+        fakeCouponTemplateRepository = new FakeCouponTemplateRepository();
+        OrderDomainService orderDomainService = new OrderDomainService(fakeProductRepository, fakeOrderRepository);
+        orderService = new OrderService(orderDomainService, fakeIssuedCouponRepository, fakeCouponTemplateRepository);
+    }
+
+    @DisplayName("주문 생성")
+    @Nested
+    class PlaceOrder {
+
+        @DisplayName("재고가 충분하면 주문이 성공한다")
+        @Test
+        void success() {
+            Long memberId = 1L;
+            fakeProductRepository.save(new Product(1L, "상품", 10_000L, 10));
+            List<OrderDomainService.OrderLineRequest> items = List.of(
+                new OrderDomainService.OrderLineRequest(1L, 3)
+            );
+
+            OrderService.OrderResult result = orderService.placeOrder(memberId, items, null);
+
+            assertThat(result.orderId()).isNotNull();
+            assertThat(result.status()).isEqualTo("ORDERED");
+            assertThat(result.totalAmount()).isEqualTo(30_000L);
+            assertThat(result.originalAmount()).isEqualTo(30_000L);
+            assertThat(result.discountAmount()).isEqualTo(0L);
+            assertThat(result.orderLines()).hasSize(1);
+        }
+
+        @DisplayName("재고가 부족하면 예외가 발생한다")
+        @Test
+        void failsWhenInsufficientStock() {
+            Long memberId = 1L;
+            fakeProductRepository.save(new Product(1L, "상품", 10_000L, 2));
+
+            assertThatThrownBy(() -> orderService.placeOrder(memberId, List.of(
+                new OrderDomainService.OrderLineRequest(1L, 5)
+            ), null))
+                .isInstanceOf(CoreException.class)
+                .hasFieldOrPropertyWithValue("errorType", ErrorType.INSUFFICIENT_STOCK);
+        }
+    }
+
+    @DisplayName("쿠폰 적용 주문")
+    @Nested
+    class PlaceOrderWithCoupon {
+
+        @DisplayName("정액 쿠폰 적용 시 할인이 반영된다")
+        @Test
+        void fixedCouponDiscount() {
+            Long memberId = 1L;
+            fakeProductRepository.save(new Product(1L, "상품", 10_000L, 10));
+
+            CouponTemplate template = fakeCouponTemplateRepository.save(
+                new CouponTemplate("1000원 할인", CouponType.FIXED, 1000, null, ZonedDateTime.now().plusDays(30))
+            );
+            IssuedCoupon issued = fakeIssuedCouponRepository.save(new IssuedCoupon(1L, memberId));
+
+            OrderService.OrderResult result = orderService.placeOrder(memberId, List.of(
+                new OrderDomainService.OrderLineRequest(1L, 3)
+            ), 1L);
+
+            assertThat(result.originalAmount()).isEqualTo(30_000L);
+            assertThat(result.discountAmount()).isEqualTo(1_000L);
+            assertThat(result.totalAmount()).isEqualTo(29_000L);
+        }
+
+        @DisplayName("정률 쿠폰 적용 시 할인이 반영된다")
+        @Test
+        void rateCouponDiscount() {
+            Long memberId = 1L;
+            fakeProductRepository.save(new Product(1L, "상품", 10_000L, 10));
+
+            fakeCouponTemplateRepository.save(
+                new CouponTemplate("10% 할인", CouponType.RATE, 10, null, ZonedDateTime.now().plusDays(30))
+            );
+            fakeIssuedCouponRepository.save(new IssuedCoupon(1L, memberId));
+
+            OrderService.OrderResult result = orderService.placeOrder(memberId, List.of(
+                new OrderDomainService.OrderLineRequest(1L, 3)
+            ), 1L);
+
+            assertThat(result.originalAmount()).isEqualTo(30_000L);
+            assertThat(result.discountAmount()).isEqualTo(3_000L);
+            assertThat(result.totalAmount()).isEqualTo(27_000L);
+        }
+
+        @DisplayName("이미 사용된 쿠폰은 사용할 수 없다")
+        @Test
+        void failsWhenCouponAlreadyUsed() {
+            Long memberId = 1L;
+            fakeProductRepository.save(new Product(1L, "상품", 10_000L, 10));
+            fakeCouponTemplateRepository.save(
+                new CouponTemplate("할인", CouponType.FIXED, 1000, null, ZonedDateTime.now().plusDays(30))
+            );
+            IssuedCoupon issued = fakeIssuedCouponRepository.save(new IssuedCoupon(1L, memberId));
+            issued.use();
+
+            assertThatThrownBy(() -> orderService.placeOrder(memberId, List.of(
+                new OrderDomainService.OrderLineRequest(1L, 1)
+            ), 1L))
+                .isInstanceOf(CoreException.class)
+                .hasFieldOrPropertyWithValue("errorType", ErrorType.COUPON_UNAVAILABLE);
+        }
+
+        @DisplayName("타인 쿠폰은 사용할 수 없다")
+        @Test
+        void failsWhenNotOwned() {
+            Long memberId = 1L;
+            Long otherMemberId = 2L;
+            fakeProductRepository.save(new Product(1L, "상품", 10_000L, 10));
+            fakeCouponTemplateRepository.save(
+                new CouponTemplate("할인", CouponType.FIXED, 1000, null, ZonedDateTime.now().plusDays(30))
+            );
+            fakeIssuedCouponRepository.save(new IssuedCoupon(1L, otherMemberId));
+
+            assertThatThrownBy(() -> orderService.placeOrder(memberId, List.of(
+                new OrderDomainService.OrderLineRequest(1L, 1)
+            ), 1L))
+                .isInstanceOf(CoreException.class)
+                .hasFieldOrPropertyWithValue("errorType", ErrorType.COUPON_NOT_OWNED);
+        }
+    }
+
+    static class FakeProductRepository implements ProductRepository {
+        private final Map<Long, Product> store = new ConcurrentHashMap<>();
+        private long nextId = 1;
+
+        @Override
+        public Product save(Product product) {
+            long id = nextId++;
+            store.put(id, product);
+            return product;
+        }
+
+        @Override
+        public Optional<Product> findById(Long id) {
+            return Optional.ofNullable(store.get(id));
+        }
+
+        @Override
+        public Optional<Product> findByIdForUpdate(Long id) {
+            return findById(id);
+        }
+
+        @Override
+        public List<Product> findAll(SortCondition sort) {
+            return new ArrayList<>(store.values());
+        }
+    }
+
+    static class FakeOrderRepository implements OrderRepository {
+        private final List<Order> store = new ArrayList<>();
+
+        @Override
+        public Order save(Order order) {
+            store.add(order);
+            return order;
+        }
+
+        @Override
+        public Optional<Order> findById(Long id) {
+            return Optional.empty();
+        }
+    }
+
+    static class FakeIssuedCouponRepository implements IssuedCouponRepository {
+        private final Map<Long, IssuedCoupon> store = new ConcurrentHashMap<>();
+        private long nextId = 1;
+
+        @Override
+        public IssuedCoupon save(IssuedCoupon issuedCoupon) {
+            long id = nextId++;
+            store.put(id, issuedCoupon);
+            return issuedCoupon;
+        }
+
+        @Override
+        public Optional<IssuedCoupon> findById(Long id) {
+            return Optional.ofNullable(store.get(id));
+        }
+
+        @Override
+        public Optional<IssuedCoupon> findByIdForUpdate(Long id) {
+            return findById(id);
+        }
+
+        @Override
+        public List<IssuedCoupon> findByMemberId(Long memberId) {
+            return store.values().stream().filter(c -> c.getMemberId().equals(memberId)).toList();
+        }
+
+        @Override
+        public boolean existsByMemberIdAndCouponTemplateId(Long memberId, Long couponTemplateId) {
+            return store.values().stream()
+                .anyMatch(c -> c.getMemberId().equals(memberId) && c.getCouponTemplateId().equals(couponTemplateId));
+        }
+
+        @Override
+        public List<IssuedCoupon> findByCouponTemplateId(Long couponTemplateId, int page, int size) {
+            return store.values().stream().filter(c -> c.getCouponTemplateId().equals(couponTemplateId)).toList();
+        }
+
+        @Override
+        public long countByCouponTemplateId(Long couponTemplateId) {
+            return store.values().stream().filter(c -> c.getCouponTemplateId().equals(couponTemplateId)).count();
+        }
+    }
+
+    static class FakeCouponTemplateRepository implements CouponTemplateRepository {
+        private final Map<Long, CouponTemplate> store = new ConcurrentHashMap<>();
+        private long nextId = 1;
+
+        @Override
+        public CouponTemplate save(CouponTemplate couponTemplate) {
+            long id = nextId++;
+            store.put(id, couponTemplate);
+            return couponTemplate;
+        }
+
+        @Override
+        public Optional<CouponTemplate> findById(Long id) {
+            return Optional.ofNullable(store.get(id));
+        }
+
+        @Override
+        public List<CouponTemplate> findAll(int page, int size) {
+            return new ArrayList<>(store.values());
+        }
+
+        @Override
+        public long count() {
+            return store.size();
+        }
+    }
+}
diff --git a/apps/commerce-api/src/test/java/com/loopers/concurrency/CouponConcurrencyTest.java b/apps/commerce-api/src/test/java/com/loopers/concurrency/CouponConcurrencyTest.java
new file mode 100644
index 000000000..ef454e75e
--- /dev/null
+++ b/apps/commerce-api/src/test/java/com/loopers/concurrency/CouponConcurrencyTest.java
@@ -0,0 +1,108 @@
+package com.loopers.concurrency;
+
+import com.loopers.application.order.OrderService;
+import com.loopers.domain.coupon.CouponStatus;
+import com.loopers.domain.coupon.CouponTemplate;
+import com.loopers.domain.coupon.CouponTemplateRepository;
+import com.loopers.domain.coupon.CouponType;
+import com.loopers.domain.coupon.IssuedCoupon;
+import com.loopers.domain.coupon.IssuedCouponRepository;
+import com.loopers.domain.member.Member;
+import com.loopers.domain.member.MemberRepository;
+import com.loopers.domain.order.OrderDomainService;
+import com.loopers.domain.product.Brand;
+import com.loopers.domain.product.BrandRepository;
+import com.loopers.domain.product.Product;
+import com.loopers.domain.product.ProductRepository;
+import com.loopers.utils.DatabaseCleanUp;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+
+import java.time.ZonedDateTime;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+@SpringBootTest
+class CouponConcurrencyTest {
+
+    @Autowired
+    private OrderService orderService;
+
+    @Autowired
+    private ProductRepository productRepository;
+
+    @Autowired
+    private BrandRepository brandRepository;
+
+    @Autowired
+    private MemberRepository memberRepository;
+
+    @Autowired
+    private CouponTemplateRepository couponTemplateRepository;
+
+    @Autowired
+    private IssuedCouponRepository issuedCouponRepository;
+
+    @Autowired
+    private DatabaseCleanUp databaseCleanUp;
+
+    @AfterEach
+    void tearDown() {
+        databaseCleanUp.truncateAllTables();
+    }
+
+    @DisplayName("동일한 쿠폰으로 5개 스레드가 동시에 주문해도 쿠폰은 단 1번만 사용된다")
+    @Test
+    void concurrentCouponUse_onlyOneSucceeds() throws InterruptedException {
+        Brand brand = brandRepository.save(new Brand("브랜드"));
+        Product product = productRepository.save(new Product(brand.getId(), "상품", 10_000L, 100));
+        Long productId = product.getId();
+
+        Member member = memberRepository.save(new Member("user1", "password", "사용자", "2000-01-01", "user@test.com"));
+        Long memberId = member.getId();
+
+        CouponTemplate template = couponTemplateRepository.save(
+            new CouponTemplate("1000원 할인", CouponType.FIXED, 1000, null, ZonedDateTime.now().plusDays(30))
+        );
+        IssuedCoupon issuedCoupon = issuedCouponRepository.save(new IssuedCoupon(template.getId(), memberId));
+        Long couponId = issuedCoupon.getId();
+
+        int threadCount = 5;
+        ExecutorService executorService = Executors.newFixedThreadPool(threadCount);
+        CountDownLatch latch = new CountDownLatch(threadCount);
+        List<Boolean> results = Collections.synchronizedList(new ArrayList<>());
+
+        for (int i = 0; i < threadCount; i++) {
+            executorService.submit(() -> {
+                try {
+                    orderService.placeOrder(memberId, List.of(
+                        new OrderDomainService.OrderLineRequest(productId, 1)
+                    ), couponId);
+                    results.add(true);
+                } catch (Exception e) {
+                    results.add(false);
+                } finally {
+                    latch.countDown();
+                }
+            });
+        }
+
+        latch.await();
+        executorService.shutdown();
+
+        long successCount = results.stream().filter(r -> r).count();
+        assertThat(successCount).isEqualTo(1);
+
+        IssuedCoupon updatedCoupon = issuedCouponRepository.findById(couponId).orElseThrow();
+        assertThat(updatedCoupon.getStatus()).isEqualTo(CouponStatus.USED);
+    }
+}
diff --git a/apps/commerce-api/src/test/java/com/loopers/concurrency/LikeConcurrencyTest.java b/apps/commerce-api/src/test/java/com/loopers/concurrency/LikeConcurrencyTest.java
new file mode 100644
index 000000000..75c456b07
--- /dev/null
+++ b/apps/commerce-api/src/test/java/com/loopers/concurrency/LikeConcurrencyTest.java
@@ -0,0 +1,139 @@
+package com.loopers.concurrency;
+
+import com.loopers.application.like.LikeService;
+import com.loopers.domain.like.LikeRepository;
+import com.loopers.domain.member.Member;
+import com.loopers.domain.member.MemberRepository;
+import com.loopers.domain.product.Brand;
+import com.loopers.domain.product.BrandRepository;
+import com.loopers.domain.product.Product;
+import com.loopers.domain.product.ProductRepository;
+import com.loopers.utils.DatabaseCleanUp;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+@SpringBootTest
+class LikeConcurrencyTest {
+
+    @Autowired
+    private LikeService likeService;
+
+    @Autowired
+    private LikeRepository likeRepository;
+
+    @Autowired
+    private ProductRepository productRepository;
+
+    @Autowired
+    private BrandRepository brandRepository;
+
+    @Autowired
+    private MemberRepository memberRepository;
+
+    @Autowired
+    private DatabaseCleanUp databaseCleanUp;
+
+    @AfterEach
+    void tearDown() {
+        databaseCleanUp.truncateAllTables();
+    }
+
+    @DisplayName("100명이 동시에 같은 상품에 좋아요하면 좋아요 수가 100이 된다")
+    @Test
+    void concurrentLikes() throws InterruptedException {
+        Brand brand = brandRepository.save(new Brand("브랜드"));
+        Product product = productRepository.save(new Product(brand.getId(), "상품", 10_000L, 100));
+        Long productId = product.getId();
+
+        int threadCount = 100;
+        ExecutorService executorService = Executors.newFixedThreadPool(20);
+        CountDownLatch latch = new CountDownLatch(threadCount);
+        List<Boolean> results = Collections.synchronizedList(new ArrayList<>());
+
+        for (int i = 0; i < threadCount; i++) {
+            final long memberId = i + 1;
+            memberRepository.save(new Member("user" + memberId, "password", "사용자" + memberId, "2000-01-01", "user" + memberId + "@test.com"));
+            executorService.submit(() -> {
+                try {
+                    likeService.like(memberId, productId);
+                    results.add(true);
+                } catch (Exception e) {
+                    results.add(false);
+                } finally {
+                    latch.countDown();
+                }
+            });
+        }
+
+        latch.await();
+        executorService.shutdown();
+
+        long likeCount = likeRepository.countByProductId(productId);
+        assertThat(likeCount).isEqualTo(100);
+    }
+
+    @DisplayName("50명이 좋아요하고 다른 50명이 좋아요 후 취소하면 좋아요 수가 50이 된다")
+    @Test
+    void concurrentLikesAndUnlikes() throws InterruptedException {
+        Brand brand = brandRepository.save(new Brand("브랜드"));
+        Product product = productRepository.save(new Product(brand.getId(), "상품", 10_000L, 100));
+        Long productId = product.getId();
+
+        for (int i = 51; i <= 100; i++) {
+            final long memberId = i;
+            memberRepository.save(new Member("user" + memberId, "password", "사용자" + memberId, "2000-01-01", "user" + memberId + "@test.com"));
+            likeService.like(memberId, productId);
+        }
+
+        int threadCount = 100;
+        ExecutorService executorService = Executors.newFixedThreadPool(20);
+        CountDownLatch latch = new CountDownLatch(threadCount);
+
+        for (int i = 1; i <= 50; i++) {
+            final long memberId = i;
+            memberRepository.save(new Member("newuser" + memberId, "password", "신규" + memberId, "2000-01-01", "new" + memberId + "@test.com"));
+        }
+
+        for (int i = 1; i <= 50; i++) {
+            final long newMemberId = 100 + i;
+            final long existingMemberId = 50 + i;
+
+            executorService.submit(() -> {
+                try {
+                    Member newMember = memberRepository.findByLoginId("newuser" + (newMemberId - 100)).orElseThrow();
+                    likeService.like(newMember.getId(), productId);
+                } catch (Exception ignored) {
+                } finally {
+                    latch.countDown();
+                }
+            });
+
+            executorService.submit(() -> {
+                try {
+                    likeService.unlike(existingMemberId, productId);
+                } catch (Exception ignored) {
+                } finally {
+                    latch.countDown();
+                }
+            });
+        }
+
+        latch.await();
+        executorService.shutdown();
+
+        long likeCount = likeRepository.countByProductId(productId);
+        assertThat(likeCount).isEqualTo(50);
+    }
+}
diff --git a/apps/commerce-api/src/test/java/com/loopers/concurrency/StockConcurrencyTest.java b/apps/commerce-api/src/test/java/com/loopers/concurrency/StockConcurrencyTest.java
new file mode 100644
index 000000000..c99515e76
--- /dev/null
+++ b/apps/commerce-api/src/test/java/com/loopers/concurrency/StockConcurrencyTest.java
@@ -0,0 +1,129 @@
+package com.loopers.concurrency;
+
+import com.loopers.application.order.OrderService;
+import com.loopers.domain.member.Member;
+import com.loopers.domain.member.MemberRepository;
+import com.loopers.domain.order.OrderDomainService;
+import com.loopers.domain.product.Brand;
+import com.loopers.domain.product.BrandRepository;
+import com.loopers.domain.product.Product;
+import com.loopers.domain.product.ProductRepository;
+import com.loopers.utils.DatabaseCleanUp;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+@SpringBootTest
+class StockConcurrencyTest {
+
+    @Autowired
+    private OrderService orderService;
+
+    @Autowired
+    private ProductRepository productRepository;
+
+    @Autowired
+    private BrandRepository brandRepository;
+
+    @Autowired
+    private MemberRepository memberRepository;
+
+    @Autowired
+    private DatabaseCleanUp databaseCleanUp;
+
+    @AfterEach
+    void tearDown() {
+        databaseCleanUp.truncateAllTables();
+    }
+
+    @DisplayName("재고 10개인 상품에 10명이 동시에 1개씩 주문하면 재고가 0이 된다")
+    @Test
+    void concurrentStockDecrease_allSucceed() throws InterruptedException {
+        Brand brand = brandRepository.save(new Brand("테스트 브랜드"));
+        Product product = productRepository.save(new Product(brand.getId(), "상품", 10_000L, 10));
+        Long productId = product.getId();
+
+        int threadCount = 10;
+        ExecutorService executorService = Executors.newFixedThreadPool(threadCount);
+        CountDownLatch latch = new CountDownLatch(threadCount);
+        List<Boolean> results = Collections.synchronizedList(new ArrayList<>());
+
+        for (int i = 0; i < threadCount; i++) {
+            final long memberId = i + 1;
+            memberRepository.save(new Member("user" + memberId, "password", "사용자" + memberId, "2000-01-01", "user" + memberId + "@test.com"));
+            executorService.submit(() -> {
+                try {
+                    orderService.placeOrder(memberId, List.of(
+                        new OrderDomainService.OrderLineRequest(productId, 1)
+                    ), null);
+                    results.add(true);
+                } catch (Exception e) {
+                    results.add(false);
+                } finally {
+                    latch.countDown();
+                }
+            });
+        }
+
+        latch.await();
+        executorService.shutdown();
+
+        long successCount = results.stream().filter(r -> r).count();
+        assertThat(successCount).isEqualTo(10);
+
+        Product updated = productRepository.findById(productId).orElseThrow();
+        assertThat(updated.getStockQuantity()).isEqualTo(0);
+    }
+
+    @DisplayName("재고 5개인 상품에 10명이 동시에 1개씩 주문하면 5건만 성공하고 재고가 0이 된다")
+    @Test
+    void concurrentStockDecrease_partialSuccess() throws InterruptedException {
+        Brand brand = brandRepository.save(new Brand("테스트 브랜드"));
+        Product product = productRepository.save(new Product(brand.getId(), "상품", 10_000L, 5));
+        Long productId = product.getId();
+
+        int threadCount = 10;
+        ExecutorService executorService = Executors.newFixedThreadPool(threadCount);
+        CountDownLatch latch = new CountDownLatch(threadCount);
+        List<Boolean> results = Collections.synchronizedList(new ArrayList<>());
+
+        for (int i = 0; i < threadCount; i++) {
+            final long memberId = i + 1;
+            memberRepository.save(new Member("user" + memberId, "password", "사용자" + memberId, "2000-01-01", "user" + memberId + "@test.com"));
+            executorService.submit(() -> {
+                try {
+                    orderService.placeOrder(memberId, List.of(
+                        new OrderDomainService.OrderLineRequest(productId, 1)
+                    ), null);
+                    results.add(true);
+                } catch (Exception e) {
+                    results.add(false);
+                } finally {
+                    latch.countDown();
+                }
+            });
+        }
+
+        latch.await();
+        executorService.shutdown();
+
+        long successCount = results.stream().filter(r -> r).count();
+        long failCount = results.stream().filter(r -> !r).count();
+        assertThat(successCount).isEqualTo(5);
+        assertThat(failCount).isEqualTo(5);
+
+        Product updated = productRepository.findById(productId).orElseThrow();
+        assertThat(updated.getStockQuantity()).isEqualTo(0);
+    }
+}
diff --git a/apps/commerce-api/src/test/java/com/loopers/domain/coupon/CouponTemplateTest.java b/apps/commerce-api/src/test/java/com/loopers/domain/coupon/CouponTemplateTest.java
new file mode 100644
index 000000000..dacdab7d5
--- /dev/null
+++ b/apps/commerce-api/src/test/java/com/loopers/domain/coupon/CouponTemplateTest.java
@@ -0,0 +1,177 @@
+package com.loopers.domain.coupon;
+
+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.time.ZonedDateTime;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.junit.jupiter.api.Assertions.assertAll;
+
+class CouponTemplateTest {
+
+    @DisplayName("쿠폰 템플릿 생성")
+    @Nested
+    class Create {
+
+        @DisplayName("유효한 정액 쿠폰 템플릿을 생성할 수 있다")
+        @Test
+        void fixedCoupon() {
+            CouponTemplate template = new CouponTemplate(
+                "1000원 할인", CouponType.FIXED, 1000, 10000L, ZonedDateTime.now().plusDays(30)
+            );
+
+            assertAll(
+                () -> assertThat(template.getName()).isEqualTo("1000원 할인"),
+                () -> assertThat(template.getType()).isEqualTo(CouponType.FIXED),
+                () -> assertThat(template.getValue()).isEqualTo(1000),
+                () -> assertThat(template.getMinOrderAmount()).isEqualTo(10000L)
+            );
+        }
+
+        @DisplayName("유효한 정률 쿠폰 템플릿을 생성할 수 있다")
+        @Test
+        void rateCoupon() {
+            CouponTemplate template = new CouponTemplate(
+                "10% 할인", CouponType.RATE, 10, null, ZonedDateTime.now().plusDays(30)
+            );
+
+            assertAll(
+                () -> assertThat(template.getType()).isEqualTo(CouponType.RATE),
+                () -> assertThat(template.getValue()).isEqualTo(10),
+                () -> assertThat(template.getMinOrderAmount()).isNull()
+            );
+        }
+
+        @DisplayName("이름이 없으면 예외가 발생한다")
+        @Test
+        void failsWhenNameIsBlank() {
+            assertThatThrownBy(() -> new CouponTemplate("", CouponType.FIXED, 1000, null, ZonedDateTime.now().plusDays(30)))
+                .isInstanceOf(CoreException.class)
+                .hasFieldOrPropertyWithValue("errorType", ErrorType.BAD_REQUEST);
+        }
+
+        @DisplayName("타입이 없으면 예외가 발생한다")
+        @Test
+        void failsWhenTypeIsNull() {
+            assertThatThrownBy(() -> new CouponTemplate("할인", null, 1000, null, ZonedDateTime.now().plusDays(30)))
+                .isInstanceOf(CoreException.class)
+                .hasFieldOrPropertyWithValue("errorType", ErrorType.BAD_REQUEST);
+        }
+
+        @DisplayName("값이 0 이하이면 예외가 발생한다")
+        @Test
+        void failsWhenValueIsZero() {
+            assertThatThrownBy(() -> new CouponTemplate("할인", CouponType.FIXED, 0, null, ZonedDateTime.now().plusDays(30)))
+                .isInstanceOf(CoreException.class)
+                .hasFieldOrPropertyWithValue("errorType", ErrorType.BAD_REQUEST);
+        }
+
+        @DisplayName("정률 쿠폰이 100%를 초과하면 예외가 발생한다")
+        @Test
+        void failsWhenRateExceeds100() {
+            assertThatThrownBy(() -> new CouponTemplate("할인", CouponType.RATE, 101, null, ZonedDateTime.now().plusDays(30)))
+                .isInstanceOf(CoreException.class)
+                .hasFieldOrPropertyWithValue("errorType", ErrorType.BAD_REQUEST);
+        }
+
+        @DisplayName("만료일이 없으면 예외가 발생한다")
+        @Test
+        void failsWhenExpiredAtIsNull() {
+            assertThatThrownBy(() -> new CouponTemplate("할인", CouponType.FIXED, 1000, null, null))
+                .isInstanceOf(CoreException.class)
+                .hasFieldOrPropertyWithValue("errorType", ErrorType.BAD_REQUEST);
+        }
+    }
+
+    @DisplayName("할인 금액 계산")
+    @Nested
+    class CalculateDiscount {
+
+        @DisplayName("정액 쿠폰은 고정 금액을 할인한다")
+        @Test
+        void fixedDiscount() {
+            CouponTemplate template = new CouponTemplate(
+                "3000원 할인", CouponType.FIXED, 3000, null, ZonedDateTime.now().plusDays(30)
+            );
+
+            assertThat(template.calculateDiscount(10_000)).isEqualTo(3_000);
+        }
+
+        @DisplayName("정액 쿠폰의 할인은 주문 금액을 초과할 수 없다")
+        @Test
+        void fixedDiscountCappedByOrderAmount() {
+            CouponTemplate template = new CouponTemplate(
+                "5000원 할인", CouponType.FIXED, 5000, null, ZonedDateTime.now().plusDays(30)
+            );
+
+            assertThat(template.calculateDiscount(3_000)).isEqualTo(3_000);
+        }
+
+        @DisplayName("정률 쿠폰은 비율만큼 할인한다")
+        @Test
+        void rateDiscount() {
+            CouponTemplate template = new CouponTemplate(
+                "10% 할인", CouponType.RATE, 10, null, ZonedDateTime.now().plusDays(30)
+            );
+
+            assertThat(template.calculateDiscount(30_000)).isEqualTo(3_000);
+        }
+    }
+
+    @DisplayName("만료 확인")
+    @Nested
+    class Expiry {
+
+        @DisplayName("만료일이 지났으면 true")
+        @Test
+        void expired() {
+            CouponTemplate template = new CouponTemplate(
+                "할인", CouponType.FIXED, 1000, null, ZonedDateTime.now().minusDays(1)
+            );
+
+            assertThat(template.isExpired()).isTrue();
+        }
+
+        @DisplayName("만료일이 지나지 않았으면 false")
+        @Test
+        void notExpired() {
+            CouponTemplate template = new CouponTemplate(
+                "할인", CouponType.FIXED, 1000, null, ZonedDateTime.now().plusDays(30)
+            );
+
+            assertThat(template.isExpired()).isFalse();
+        }
+    }
+
+    @DisplayName("최소 주문 금액 검증")
+    @Nested
+    class MinOrderAmount {
+
+        @DisplayName("주문 금액이 최소 주문 금액 미만이면 예외가 발생한다")
+        @Test
+        void failsWhenBelowMinimum() {
+            CouponTemplate template = new CouponTemplate(
+                "할인", CouponType.FIXED, 1000, 10_000L, ZonedDateTime.now().plusDays(30)
+            );
+
+            assertThatThrownBy(() -> template.validateMinOrderAmount(5_000))
+                .isInstanceOf(CoreException.class)
+                .hasFieldOrPropertyWithValue("errorType", ErrorType.COUPON_MIN_ORDER_AMOUNT);
+        }
+
+        @DisplayName("최소 주문 금액이 없으면 어떤 금액이든 통과한다")
+        @Test
+        void noMinOrderAmount() {
+            CouponTemplate template = new CouponTemplate(
+                "할인", CouponType.FIXED, 1000, null, ZonedDateTime.now().plusDays(30)
+            );
+
+            template.validateMinOrderAmount(100);
+        }
+    }
+}
diff --git a/apps/commerce-api/src/test/java/com/loopers/domain/coupon/IssuedCouponTest.java b/apps/commerce-api/src/test/java/com/loopers/domain/coupon/IssuedCouponTest.java
new file mode 100644
index 000000000..f04668674
--- /dev/null
+++ b/apps/commerce-api/src/test/java/com/loopers/domain/coupon/IssuedCouponTest.java
@@ -0,0 +1,122 @@
+package com.loopers.domain.coupon;
+
+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;
+import static org.junit.jupiter.api.Assertions.assertAll;
+
+class IssuedCouponTest {
+
+    @DisplayName("발급 쿠폰 생성")
+    @Nested
+    class Create {
+
+        @DisplayName("유효한 쿠폰을 발급할 수 있다")
+        @Test
+        void success() {
+            IssuedCoupon coupon = new IssuedCoupon(1L, 100L);
+
+            assertAll(
+                () -> assertThat(coupon.getCouponTemplateId()).isEqualTo(1L),
+                () -> assertThat(coupon.getMemberId()).isEqualTo(100L),
+                () -> assertThat(coupon.getStatus()).isEqualTo(CouponStatus.AVAILABLE),
+                () -> assertThat(coupon.getUsedAt()).isNull()
+            );
+        }
+
+        @DisplayName("템플릿 ID가 null이면 예외가 발생한다")
+        @Test
+        void failsWhenTemplateIdIsNull() {
+            assertThatThrownBy(() -> new IssuedCoupon(null, 100L))
+                .isInstanceOf(CoreException.class)
+                .hasFieldOrPropertyWithValue("errorType", ErrorType.BAD_REQUEST);
+        }
+
+        @DisplayName("회원 ID가 null이면 예외가 발생한다")
+        @Test
+        void failsWhenMemberIdIsNull() {
+            assertThatThrownBy(() -> new IssuedCoupon(1L, null))
+                .isInstanceOf(CoreException.class)
+                .hasFieldOrPropertyWithValue("errorType", ErrorType.BAD_REQUEST);
+        }
+    }
+
+    @DisplayName("쿠폰 사용")
+    @Nested
+    class Use {
+
+        @DisplayName("AVAILABLE 상태의 쿠폰을 사용하면 USED로 변경된다")
+        @Test
+        void success() {
+            IssuedCoupon coupon = new IssuedCoupon(1L, 100L);
+
+            coupon.use();
+
+            assertAll(
+                () -> assertThat(coupon.getStatus()).isEqualTo(CouponStatus.USED),
+                () -> assertThat(coupon.getUsedAt()).isNotNull()
+            );
+        }
+
+        @DisplayName("이미 사용된 쿠폰을 사용하면 예외가 발생한다")
+        @Test
+        void failsWhenAlreadyUsed() {
+            IssuedCoupon coupon = new IssuedCoupon(1L, 100L);
+            coupon.use();
+
+            assertThatThrownBy(coupon::use)
+                .isInstanceOf(CoreException.class)
+                .hasFieldOrPropertyWithValue("errorType", ErrorType.COUPON_ALREADY_USED);
+        }
+    }
+
+    @DisplayName("사용 가능 여부 확인")
+    @Nested
+    class IsUsable {
+
+        @DisplayName("AVAILABLE이면 사용 가능하다")
+        @Test
+        void available() {
+            IssuedCoupon coupon = new IssuedCoupon(1L, 100L);
+
+            assertThat(coupon.isUsable()).isTrue();
+        }
+
+        @DisplayName("USED이면 사용 불가하다")
+        @Test
+        void used() {
+            IssuedCoupon coupon = new IssuedCoupon(1L, 100L);
+            coupon.use();
+
+            assertThat(coupon.isUsable()).isFalse();
+        }
+    }
+
+    @DisplayName("소유자 검증")
+    @Nested
+    class ValidateOwnership {
+
+        @DisplayName("소유자가 맞으면 예외 없이 통과한다")
+        @Test
+        void success() {
+            IssuedCoupon coupon = new IssuedCoupon(1L, 100L);
+
+            coupon.validateOwnership(100L);
+        }
+
+        @DisplayName("소유자가 다르면 예외가 발생한다")
+        @Test
+        void failsWhenNotOwner() {
+            IssuedCoupon coupon = new IssuedCoupon(1L, 100L);
+
+            assertThatThrownBy(() -> coupon.validateOwnership(200L))
+                .isInstanceOf(CoreException.class)
+                .hasFieldOrPropertyWithValue("errorType", ErrorType.COUPON_NOT_OWNED);
+        }
+    }
+}
diff --git a/apps/commerce-api/src/test/java/com/loopers/domain/like/LikeTest.java b/apps/commerce-api/src/test/java/com/loopers/domain/like/LikeTest.java
new file mode 100644
index 000000000..cc803461e
--- /dev/null
+++ b/apps/commerce-api/src/test/java/com/loopers/domain/like/LikeTest.java
@@ -0,0 +1,49 @@
+package com.loopers.domain.like;
+
+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;
+import static org.junit.jupiter.api.Assertions.assertAll;
+
+class LikeTest {
+
+    @DisplayName("좋아요를 생성할 때")
+    @Nested
+    class Create {
+
+        @DisplayName("유효한 회원ID와 상품ID가 주어지면 성공한다")
+        @Test
+        void success() {
+            Long memberId = 1L;
+            Long productId = 100L;
+
+            Like like = new Like(memberId, productId);
+
+            assertAll(
+                () -> assertThat(like.getMemberId()).isEqualTo(memberId),
+                () -> assertThat(like.getProductId()).isEqualTo(productId)
+            );
+        }
+
+        @DisplayName("회원ID가 null이면 예외가 발생한다")
+        @Test
+        void failsWhenMemberIdIsNull() {
+            assertThatThrownBy(() -> new Like(null, 1L))
+                .isInstanceOf(CoreException.class)
+                .hasFieldOrPropertyWithValue("errorType", ErrorType.BAD_REQUEST);
+        }
+
+        @DisplayName("상품ID가 null이면 예외가 발생한다")
+        @Test
+        void failsWhenProductIdIsNull() {
+            assertThatThrownBy(() -> new Like(1L, null))
+                .isInstanceOf(CoreException.class)
+                .hasFieldOrPropertyWithValue("errorType", ErrorType.BAD_REQUEST);
+        }
+    }
+}
diff --git a/apps/commerce-api/src/test/java/com/loopers/domain/member/MemberRepositoryTest.java b/apps/commerce-api/src/test/java/com/loopers/domain/member/MemberRepositoryTest.java
new file mode 100644
index 000000000..88792c22b
--- /dev/null
+++ b/apps/commerce-api/src/test/java/com/loopers/domain/member/MemberRepositoryTest.java
@@ -0,0 +1,118 @@
+package com.loopers.domain.member;
+
+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 java.util.Optional;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertAll;
+
+@SpringBootTest
+class MemberRepositoryTest {
+    
+    @Autowired
+    private MemberRepository memberRepository;
+    
+    @Autowired
+    private DatabaseCleanUp databaseCleanUp;
+    
+    @AfterEach
+    void tearDown() {
+        databaseCleanUp.truncateAllTables();
+    }
+    
+    @DisplayName("회원을 저장할 때")
+    @Nested
+    class Save {
+        
+        @DisplayName("유효한 회원 정보를 저장하면 성공한다")
+        @Test
+        void saveMember() {
+            Member member = new Member(
+                "ymcho",
+                "ymcho123",
+                "조용민",
+                "1991-07-03",
+                "ymcho@example.com"
+            );
+            
+            Member saved = memberRepository.save(member);
+            
+            assertAll(
+                () -> assertThat(saved.getId()).isNotNull(),
+                () -> assertThat(saved.getLoginId()).isEqualTo("ymcho"),
+                () -> assertThat(saved.getName()).isEqualTo("조용민")
+            );
+        }
+    }
+    
+    @DisplayName("로그인ID로 회원을 조회할 때")
+    @Nested
+    class FindByLoginId {
+        
+        @DisplayName("존재하는 로그인ID로 조회하면 회원을 반환한다")
+        @Test
+        void findExistingMember() {
+            Member member = new Member(
+                "ymcho",
+                "ymcho123",
+                "조용민",
+                "1991-07-03",
+                "ymcho@example.com"
+            );
+            memberRepository.save(member);
+            
+            Optional<Member> found = memberRepository.findByLoginId("ymcho");
+            
+            assertAll(
+                () -> assertThat(found).isPresent(),
+                () -> assertThat(found.get().getLoginId()).isEqualTo("ymcho"),
+                () -> assertThat(found.get().getName()).isEqualTo("조용민")
+            );
+        }
+        
+        @DisplayName("존재하지 않는 로그인ID로 조회하면 빈 값을 반환한다")
+        @Test
+        void findNonExistingMember() {
+            Optional<Member> found = memberRepository.findByLoginId("nonexistent");
+            
+            assertThat(found).isEmpty();
+        }
+    }
+    
+    @DisplayName("로그인ID 중복을 확인할 때")
+    @Nested
+    class ExistsByLoginId {
+        
+        @DisplayName("이미 존재하는 로그인ID면 true를 반환한다")
+        @Test
+        void existingLoginId() {
+            Member member = new Member(
+                "ymcho",
+                "ymcho123",
+                "조용민",
+                "1991-07-03",
+                "ymcho@example.com"
+            );
+            memberRepository.save(member);
+            
+            boolean exists = memberRepository.existsByLoginId("ymcho");
+            
+            assertThat(exists).isTrue();
+        }
+        
+        @DisplayName("존재하지 않는 로그인ID면 false를 반환한다")
+        @Test
+        void nonExistingLoginId() {
+            boolean exists = memberRepository.existsByLoginId("nonexistent");
+            
+            assertThat(exists).isFalse();
+        }
+    }
+}
diff --git a/apps/commerce-api/src/test/java/com/loopers/domain/member/MemberTest.java b/apps/commerce-api/src/test/java/com/loopers/domain/member/MemberTest.java
new file mode 100644
index 000000000..8ec239ca7
--- /dev/null
+++ b/apps/commerce-api/src/test/java/com/loopers/domain/member/MemberTest.java
@@ -0,0 +1,92 @@
+package com.loopers.domain.member;
+
+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.*;
+import static org.junit.jupiter.api.Assertions.assertAll;
+
+class MemberTest {
+    
+    @DisplayName("회원을 생성할 때")
+    @Nested
+    class Create {
+        
+        @DisplayName("유효한 정보가 주어지면 성공한다")
+        @Test
+        void success() {
+            String loginId = "ymcho";
+            String password = "ymcho123";
+            String name = "조용민";
+            String birthDate = "1991-07-03";
+            String email = "ymcho@example.com";
+            
+            Member member = new Member(loginId, password, name, birthDate, email);
+            
+            assertAll(
+                () -> assertThat(member.getLoginId()).isEqualTo(loginId),
+                () -> assertThat(member.getName()).isEqualTo(name),
+                () -> assertThat(member.getBirthDate()).isEqualTo(birthDate),
+                () -> assertThat(member.getEmail()).isEqualTo(email)
+            );
+        }
+        
+        @DisplayName("로그인ID가 null이면 예외가 발생한다")
+        @Test
+        void failsWhenLoginIdIsNull() {
+            assertThatThrownBy(() -> 
+                new Member(null, "ymcho123", "조용민", "1991-07-03", "ymcho@example.com")
+            )
+            .isInstanceOf(CoreException.class)
+            .hasFieldOrPropertyWithValue("errorType", ErrorType.BAD_REQUEST);
+        }
+        
+        @DisplayName("로그인ID가 빈 문자열이면 예외가 발생한다")
+        @Test
+        void failsWhenLoginIdIsBlank() {
+            assertThatThrownBy(() -> 
+                new Member("  ", "ymcho123", "조용민", "1991-07-03", "ymcho@example.com")
+            )
+            .isInstanceOf(CoreException.class);
+        }
+        
+        @DisplayName("비밀번호가 null이면 예외가 발생한다")
+        @Test
+        void failsWhenPasswordIsNull() {
+            assertThatThrownBy(() -> 
+                new Member("ymcho", null, "조용민", "1991-07-03", "ymcho@example.com")
+            )
+            .isInstanceOf(CoreException.class);
+        }
+        
+        @DisplayName("이름이 null이면 예외가 발생한다")
+        @Test
+        void failsWhenNameIsNull() {
+            assertThatThrownBy(() -> 
+                new Member("ymcho", "ymcho123", null, "1991-07-03", "ymcho@example.com")
+            )
+            .isInstanceOf(CoreException.class);
+        }
+        
+        @DisplayName("생년월일이 null이면 예외가 발생한다")
+        @Test
+        void failsWhenBirthDateIsNull() {
+            assertThatThrownBy(() -> 
+                new Member("ymcho", "ymcho123", "조용민", null, "ymcho@example.com")
+            )
+            .isInstanceOf(CoreException.class);
+        }
+        
+        @DisplayName("이메일이 null이면 예외가 발생한다")
+        @Test
+        void failsWhenEmailIsNull() {
+            assertThatThrownBy(() -> 
+                new Member("ymcho", "ymcho123", "조용민", "1991-07-03", null)
+            )
+            .isInstanceOf(CoreException.class);
+        }
+    }
+}
diff --git a/apps/commerce-api/src/test/java/com/loopers/domain/order/OrderDomainServiceTest.java b/apps/commerce-api/src/test/java/com/loopers/domain/order/OrderDomainServiceTest.java
new file mode 100644
index 000000000..18340fb0d
--- /dev/null
+++ b/apps/commerce-api/src/test/java/com/loopers/domain/order/OrderDomainServiceTest.java
@@ -0,0 +1,139 @@
+package com.loopers.domain.order;
+
+import com.loopers.domain.product.Product;
+import com.loopers.domain.product.ProductRepository;
+import com.loopers.domain.product.SortCondition;
+import com.loopers.support.error.CoreException;
+import com.loopers.support.error.ErrorType;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.concurrent.ConcurrentHashMap;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+class OrderDomainServiceTest {
+
+    private OrderDomainService orderDomainService;
+    private FakeProductRepository fakeProductRepository;
+    private FakeOrderRepository fakeOrderRepository;
+
+    @BeforeEach
+    void setUp() {
+        fakeProductRepository = new FakeProductRepository();
+        fakeOrderRepository = new FakeOrderRepository();
+        orderDomainService = new OrderDomainService(fakeProductRepository, fakeOrderRepository);
+    }
+
+    @DisplayName("주문 생성")
+    @Nested
+    class PlaceOrder {
+
+        @DisplayName("재고가 충분하면 주문이 성공하고 재고가 차감된다")
+        @Test
+        void success() {
+            Long memberId = 1L;
+            fakeProductRepository.save(new Product(1L, "상품", 10_000L, 10));
+            Long productId = 1L;
+
+            List<OrderLine> orderLines = orderDomainService.prepareOrderLines(List.of(
+                new OrderDomainService.OrderLineRequest(productId, 3)
+            ));
+            Order order = orderDomainService.createOrder(memberId, orderLines);
+
+            assertThat(order.getMemberId()).isEqualTo(memberId);
+            assertThat(order.getOrderLines()).hasSize(1);
+            assertThat(order.getTotalAmount()).isEqualTo(30_000L);
+
+            Product updatedProduct = fakeProductRepository.findById(productId).orElseThrow();
+            assertThat(updatedProduct.getStockQuantity()).isEqualTo(7);
+        }
+
+        @DisplayName("재고가 부족하면 INSUFFICIENT_STOCK 예외가 발생하고 주문이 생성되지 않는다")
+        @Test
+        void failsWhenInsufficientStock() {
+            Long memberId = 1L;
+            fakeProductRepository.save(new Product(1L, "상품", 10_000L, 5));
+            Long productId = 1L;
+
+            assertThatThrownBy(() -> orderDomainService.prepareOrderLines(List.of(
+                new OrderDomainService.OrderLineRequest(productId, 10)
+            )))
+                .isInstanceOf(CoreException.class)
+                .hasFieldOrPropertyWithValue("errorType", ErrorType.INSUFFICIENT_STOCK);
+
+            assertThat(fakeOrderRepository.count()).isEqualTo(0);
+        }
+
+        @DisplayName("존재하지 않는 상품이 포함되면 NOT_FOUND 예외가 발생한다")
+        @Test
+        void failsWhenProductNotFound() {
+            Long nonExistentProductId = 999L;
+
+            assertThatThrownBy(() -> orderDomainService.prepareOrderLines(List.of(
+                new OrderDomainService.OrderLineRequest(nonExistentProductId, 1)
+            )))
+                .isInstanceOf(CoreException.class)
+                .hasFieldOrPropertyWithValue("errorType", ErrorType.NOT_FOUND);
+        }
+    }
+
+    static class FakeProductRepository implements ProductRepository {
+        private final Map<Long, Product> store = new ConcurrentHashMap<>();
+        private long nextId = 1;
+
+        @Override
+        public Product save(Product product) {
+            Product toSave = new Product(
+                product.getBrandId(),
+                product.getName(),
+                product.getPrice(),
+                product.getStockQuantity()
+            );
+            long id = nextId++;
+            store.put(id, toSave);
+            return toSave;
+        }
+
+        @Override
+        public Optional<Product> findById(Long id) {
+            return Optional.ofNullable(store.get(id));
+        }
+
+        @Override
+        public Optional<Product> findByIdForUpdate(Long id) {
+            return findById(id);
+        }
+
+        @Override
+        public List<Product> findAll(SortCondition sort) {
+            return new ArrayList<>(store.values());
+        }
+    }
+
+    static class FakeOrderRepository implements OrderRepository {
+        private final List<Order> store = new ArrayList<>();
+
+        @Override
+        public Order save(Order order) {
+            store.add(order);
+            return order;
+        }
+
+        @Override
+        public Optional<Order> findById(Long id) {
+            return Optional.empty();
+        }
+
+        int count() {
+            return store.size();
+        }
+    }
+}
diff --git a/apps/commerce-api/src/test/java/com/loopers/domain/order/OrderLineTest.java b/apps/commerce-api/src/test/java/com/loopers/domain/order/OrderLineTest.java
new file mode 100644
index 000000000..cc80f4fe6
--- /dev/null
+++ b/apps/commerce-api/src/test/java/com/loopers/domain/order/OrderLineTest.java
@@ -0,0 +1,41 @@
+package com.loopers.domain.order;
+
+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;
+
+class OrderLineTest {
+
+    @DisplayName("OrderLine을 생성할 때")
+    @Nested
+    class Create {
+
+        @DisplayName("유효한 값이 주어지면 성공한다")
+        @Test
+        void success() {
+            OrderLine orderLine = new OrderLine(1L, 2, 10_000L);
+
+            assertThat(orderLine.getTotalPrice()).isEqualTo(20_000L);
+        }
+
+        @DisplayName("상품ID가 null이면 예외가 발생한다")
+        @Test
+        void failsWhenProductIdIsNull() {
+            assertThatThrownBy(() -> new OrderLine(null, 1, 10_000L))
+                .isInstanceOf(CoreException.class)
+                .hasFieldOrPropertyWithValue("errorType", ErrorType.BAD_REQUEST);
+        }
+
+        @DisplayName("수량이 0 이하면 예외가 발생한다")
+        @Test
+        void failsWhenQuantityIsZeroOrNegative() {
+            assertThatThrownBy(() -> new OrderLine(1L, 0, 10_000L))
+                .isInstanceOf(CoreException.class);
+        }
+    }
+}
diff --git a/apps/commerce-api/src/test/java/com/loopers/domain/order/OrderTest.java b/apps/commerce-api/src/test/java/com/loopers/domain/order/OrderTest.java
new file mode 100644
index 000000000..20fd0813d
--- /dev/null
+++ b/apps/commerce-api/src/test/java/com/loopers/domain/order/OrderTest.java
@@ -0,0 +1,58 @@
+package com.loopers.domain.order;
+
+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.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.junit.jupiter.api.Assertions.assertAll;
+
+class OrderTest {
+
+    @DisplayName("주문을 생성할 때")
+    @Nested
+    class Create {
+
+        @DisplayName("유효한 회원ID와 주문 항목이 주어지면 성공한다")
+        @Test
+        void success() {
+            Long memberId = 1L;
+            List<OrderLine> orderLines = List.of(
+                new OrderLine(1L, 2, 10_000L),
+                new OrderLine(2L, 1, 5_000L)
+            );
+
+            Order order = Order.create(memberId, orderLines);
+
+            assertAll(
+                () -> assertThat(order.getMemberId()).isEqualTo(memberId),
+                () -> assertThat(order.getStatus()).isEqualTo("ORDERED"),
+                () -> assertThat(order.getOrderLines()).hasSize(2),
+                () -> assertThat(order.getTotalAmount()).isEqualTo(25_000L)
+            );
+        }
+
+        @DisplayName("회원ID가 null이면 예외가 발생한다")
+        @Test
+        void failsWhenMemberIdIsNull() {
+            List<OrderLine> orderLines = List.of(new OrderLine(1L, 1, 10_000L));
+
+            assertThatThrownBy(() -> Order.create(null, orderLines))
+                .isInstanceOf(CoreException.class)
+                .hasFieldOrPropertyWithValue("errorType", ErrorType.BAD_REQUEST);
+        }
+
+        @DisplayName("주문 항목이 비어있으면 예외가 발생한다")
+        @Test
+        void failsWhenOrderLinesIsEmpty() {
+            assertThatThrownBy(() -> Order.create(1L, List.of()))
+                .isInstanceOf(CoreException.class)
+                .hasFieldOrPropertyWithValue("errorType", ErrorType.BAD_REQUEST);
+        }
+    }
+}
diff --git a/apps/commerce-api/src/test/java/com/loopers/domain/product/BrandTest.java b/apps/commerce-api/src/test/java/com/loopers/domain/product/BrandTest.java
new file mode 100644
index 000000000..144e7e308
--- /dev/null
+++ b/apps/commerce-api/src/test/java/com/loopers/domain/product/BrandTest.java
@@ -0,0 +1,47 @@
+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;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.junit.jupiter.api.Assertions.assertAll;
+
+class BrandTest {
+
+    @DisplayName("브랜드를 생성할 때")
+    @Nested
+    class Create {
+
+        @DisplayName("유효한 이름이 주어지면 성공한다")
+        @Test
+        void success() {
+            String name = "나이키";
+
+            Brand brand = new Brand(name);
+
+            assertAll(
+                () -> assertThat(brand.getName()).isEqualTo(name)
+            );
+        }
+
+        @DisplayName("이름이 null이면 예외가 발생한다")
+        @Test
+        void failsWhenNameIsNull() {
+            assertThatThrownBy(() -> new Brand(null))
+                .isInstanceOf(CoreException.class)
+                .hasFieldOrPropertyWithValue("errorType", ErrorType.BAD_REQUEST);
+        }
+
+        @DisplayName("이름이 빈 문자열이면 예외가 발생한다")
+        @Test
+        void failsWhenNameIsBlank() {
+            assertThatThrownBy(() -> new Brand("   "))
+                .isInstanceOf(CoreException.class)
+                .hasFieldOrPropertyWithValue("errorType", ErrorType.BAD_REQUEST);
+        }
+    }
+}
diff --git a/apps/commerce-api/src/test/java/com/loopers/domain/product/ProductTest.java b/apps/commerce-api/src/test/java/com/loopers/domain/product/ProductTest.java
new file mode 100644
index 000000000..9e4a99085
--- /dev/null
+++ b/apps/commerce-api/src/test/java/com/loopers/domain/product/ProductTest.java
@@ -0,0 +1,116 @@
+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;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.junit.jupiter.api.Assertions.assertAll;
+
+class ProductTest {
+
+    @DisplayName("상품을 생성할 때")
+    @Nested
+    class Create {
+
+        @DisplayName("유효한 정보가 주어지면 성공한다")
+        @Test
+        void success() {
+            Long brandId = 1L;
+            String name = "에어맥스";
+            Long price = 150_000L;
+            int stockQuantity = 10;
+
+            Product product = new Product(brandId, name, price, stockQuantity);
+
+            assertAll(
+                () -> assertThat(product.getBrandId()).isEqualTo(brandId),
+                () -> assertThat(product.getName()).isEqualTo(name),
+                () -> assertThat(product.getPrice()).isEqualTo(price),
+                () -> assertThat(product.getStockQuantity()).isEqualTo(stockQuantity)
+            );
+        }
+
+        @DisplayName("상품명이 비어있으면 예외가 발생한다")
+        @Test
+        void failsWhenNameIsBlank() {
+            assertThatThrownBy(() -> new Product(1L, "  ", 1000L, 5))
+                .isInstanceOf(CoreException.class)
+                .hasFieldOrPropertyWithValue("errorType", ErrorType.BAD_REQUEST);
+        }
+
+        @DisplayName("가격이 음수이면 예외가 발생한다")
+        @Test
+        void failsWhenPriceIsNegative() {
+            assertThatThrownBy(() -> new Product(1L, "상품", -1L, 5))
+                .isInstanceOf(CoreException.class)
+                .hasFieldOrPropertyWithValue("errorType", ErrorType.BAD_REQUEST);
+        }
+
+        @DisplayName("재고가 음수이면 예외가 발생한다")
+        @Test
+        void failsWhenStockQuantityIsNegative() {
+            assertThatThrownBy(() -> new Product(1L, "상품", 1000L, -1))
+                .isInstanceOf(CoreException.class)
+                .hasFieldOrPropertyWithValue("errorType", ErrorType.BAD_REQUEST);
+        }
+    }
+
+    @DisplayName("재고를 차감할 때")
+    @Nested
+    class DecreaseStock {
+
+        @DisplayName("재고가 충분하면 정상 차감된다")
+        @Test
+        void success() {
+            Product product = new Product(1L, "상품", 10_000L, 10);
+
+            product.decreaseStock(3);
+
+            assertThat(product.getStockQuantity()).isEqualTo(7);
+        }
+
+        @DisplayName("재고와 동일한 수량을 차감하면 0이 된다")
+        @Test
+        void successWhenExactStock() {
+            Product product = new Product(1L, "상품", 10_000L, 5);
+
+            product.decreaseStock(5);
+
+            assertThat(product.getStockQuantity()).isEqualTo(0);
+        }
+
+        @DisplayName("재고가 부족하면 INSUFFICIENT_STOCK 예외가 발생한다")
+        @Test
+        void failsWhenInsufficientStock() {
+            Product product = new Product(1L, "상품", 10_000L, 5);
+
+            assertThatThrownBy(() -> product.decreaseStock(10))
+                .isInstanceOf(CoreException.class)
+                .hasFieldOrPropertyWithValue("errorType", ErrorType.INSUFFICIENT_STOCK);
+        }
+
+        @DisplayName("차감 수량이 0이면 예외가 발생한다")
+        @Test
+        void failsWhenQuantityIsZero() {
+            Product product = new Product(1L, "상품", 10_000L, 10);
+
+            assertThatThrownBy(() -> product.decreaseStock(0))
+                .isInstanceOf(CoreException.class)
+                .hasFieldOrPropertyWithValue("errorType", ErrorType.BAD_REQUEST);
+        }
+
+        @DisplayName("차감 수량이 음수이면 예외가 발생한다")
+        @Test
+        void failsWhenQuantityIsNegative() {
+            Product product = new Product(1L, "상품", 10_000L, 10);
+
+            assertThatThrownBy(() -> product.decreaseStock(-1))
+                .isInstanceOf(CoreException.class)
+                .hasFieldOrPropertyWithValue("errorType", ErrorType.BAD_REQUEST);
+        }
+    }
+}
diff --git a/build.gradle.kts b/build.gradle.kts
index 9c8490b8a..dc167f2e7 100644
--- a/build.gradle.kts
+++ b/build.gradle.kts
@@ -42,6 +42,7 @@ subprojects {
     dependencyManagement {
         imports {
             mavenBom("org.springframework.cloud:spring-cloud-dependencies:${project.properties["springCloudDependenciesVersion"]}")
+            mavenBom("org.testcontainers:testcontainers-bom:${project.properties["testcontainersVersion"]}")
         }
     }
 
diff --git a/gradle.properties b/gradle.properties
index 142d7120f..5ae37ac99 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -10,6 +10,7 @@ springBootVersion=3.4.4
 springDependencyManagementVersion=1.1.7
 springCloudDependenciesVersion=2024.0.1
 ### Library versions ###
+testcontainersVersion=2.0.2
 springDocOpenApiVersion=2.7.0
 springMockkVersion=4.0.2
 mockitoVersion=5.14.0