diff --git a/apps/commerce-api/src/main/java/com/loopers/application/admin/product/AdminProductAppService.java b/apps/commerce-api/src/main/java/com/loopers/application/admin/product/AdminProductAppService.java
index 0a46ed576..4b9822016 100644
--- a/apps/commerce-api/src/main/java/com/loopers/application/admin/product/AdminProductAppService.java
+++ b/apps/commerce-api/src/main/java/com/loopers/application/admin/product/AdminProductAppService.java
@@ -5,6 +5,7 @@
 import com.loopers.domain.product.OptionRepository;
 import com.loopers.domain.product.Product;
 import com.loopers.domain.product.ProductRepository;
+import com.loopers.application.product.ProductCacheManager;
 import com.loopers.support.error.CoreException;
 import com.loopers.support.error.ErrorType;
 import lombok.RequiredArgsConstructor;
@@ -18,6 +19,7 @@
 public class AdminProductAppService {
     private final ProductRepository productRepository;
     private final OptionRepository optionRepository;
+    private final ProductCacheManager productCacheManager;
 
     @Transactional
     public Product create(Long brandId, String name, Money basePrice) {
@@ -36,6 +38,7 @@ public Option createOption(Long productId, String name, Money additionalPrice, i
     public Product update(Long id, String name, Money basePrice) {
         Product product = getById(id);
         product.update(name, basePrice);
+        productCacheManager.evictProductCaches(id, product.getBrandId());
         return product;
     }
 
@@ -44,6 +47,7 @@ public void delete(Long id) {
         Product product = getById(id);
         product.delete();
         deleteOptionsByProductId(id);
+        productCacheManager.evictProductCaches(id, product.getBrandId());
     }
 
     @Transactional
diff --git a/apps/commerce-api/src/main/java/com/loopers/application/product/CachedBrandProductPage.java b/apps/commerce-api/src/main/java/com/loopers/application/product/CachedBrandProductPage.java
new file mode 100644
index 000000000..68f3c6614
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/application/product/CachedBrandProductPage.java
@@ -0,0 +1,38 @@
+package com.loopers.application.product;
+
+import com.loopers.domain.common.Money;
+import com.loopers.domain.product.Product;
+import lombok.Builder;
+import lombok.Getter;
+import lombok.extern.jackson.Jacksonized;
+
+import java.util.List;
+
+@Getter
+@Builder
+@Jacksonized
+public class CachedBrandProductPage {
+    private final List<ProductSummary> content;
+    private final long totalElements;
+
+    @Getter
+    @Builder
+    @Jacksonized
+    public static class ProductSummary {
+        private final Long productId;
+        private final String productName;
+        private final Money basePrice;
+        private final boolean deleted;
+        private final long likeCount;
+
+        public static ProductSummary from(Product product) {
+            return ProductSummary.builder()
+                    .productId(product.getId())
+                    .productName(product.getName())
+                    .basePrice(product.getBasePrice())
+                    .deleted(product.isDeleted())
+                    .likeCount(product.getLikeCount())
+                    .build();
+        }
+    }
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/application/product/CachedProductDetail.java b/apps/commerce-api/src/main/java/com/loopers/application/product/CachedProductDetail.java
new file mode 100644
index 000000000..742650bf8
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/application/product/CachedProductDetail.java
@@ -0,0 +1,38 @@
+package com.loopers.application.product;
+
+import com.loopers.domain.common.Money;
+import com.loopers.domain.product.Option;
+import com.loopers.domain.product.Product;
+import lombok.Builder;
+import lombok.Getter;
+import lombok.extern.jackson.Jacksonized;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.Optional;
+
+@Getter
+@Builder
+@Jacksonized
+public class CachedProductDetail {
+    private final Long productId;
+    private final String productName;
+    private final Money basePrice;
+    private final boolean deleted;
+    private final Long brandId;
+    private final long likeCount;
+    private final List<ProductInfo.OptionInfo> options;
+
+    public static CachedProductDetail from(Product product, List<Option> options, long likeCount) {
+        return CachedProductDetail.builder()
+                .productId(product.getId())
+                .productName(product.getName())
+                .basePrice(product.getBasePrice())
+                .deleted(product.isDeleted())
+                .brandId(product.getBrandId())
+                .likeCount(likeCount)
+                .options(Optional.ofNullable(options).orElseGet(Collections::emptyList)
+                        .stream().map(ProductInfo.OptionInfo::from).toList())
+                .build();
+    }
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/application/product/ProductAppService.java b/apps/commerce-api/src/main/java/com/loopers/application/product/ProductAppService.java
index de7e3e05b..98cacf83d 100644
--- a/apps/commerce-api/src/main/java/com/loopers/application/product/ProductAppService.java
+++ b/apps/commerce-api/src/main/java/com/loopers/application/product/ProductAppService.java
@@ -9,6 +9,10 @@
 import com.loopers.support.error.CoreException;
 import com.loopers.support.error.ErrorType;
 import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.data.domain.Pageable;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
@@ -16,12 +20,18 @@
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.Optional;
 
+@Slf4j
 @Service
 @RequiredArgsConstructor
 public class ProductAppService {
+    private static final int CACHEABLE_PAGE_LIMIT = 2;
+    private static final int MAX_PAGE_SIZE = 50;
+
     private final ProductRepository productRepository;
     private final OptionRepository optionRepository;
+    private final ProductCacheManager productCacheManager;
 
     @Transactional
     public Product create(Long brandId, String name, Money basePrice) {
@@ -40,6 +50,65 @@ public List<Product> getProducts(ProductSortCondition condition) {
         return productRepository.findAll(condition);
     }
 
+    @Transactional(readOnly = true)
+    public Page<Product> getProductsByBrandId(Long brandId, int page, int size) {
+        return productRepository.findByBrandIdWithPaging(brandId, validatedPageRequest(page, size));
+    }
+
+    @Transactional(readOnly = true)
+    public CachedProductDetail getProductDetailCached(Long productId) {
+        try {
+            Optional<CachedProductDetail> cached = productCacheManager.getProductDetail(productId);
+            if (cached.isPresent()) {
+                return cached.get();
+            }
+        } catch (Exception e) {
+            log.warn("캐시 조회 실패, DB fallback. productId={}", productId, e);
+        }
+
+        Product product = getById(productId);
+        List<Option> options = optionRepository.findByProductId(productId);
+        long likeCount = product.getLikeCount();
+
+        CachedProductDetail detail = CachedProductDetail.from(product, options, likeCount);
+        try {
+            productCacheManager.putProductDetail(productId, detail);
+        } catch (Exception e) {
+            log.warn("캐시 저장 실패. productId={}", productId, e);
+        }
+        return detail;
+    }
+
+    @Transactional(readOnly = true)
+    public CachedBrandProductPage getProductsByBrandIdCached(Long brandId, int page, int size) {
+        if (page <= CACHEABLE_PAGE_LIMIT) {
+            try {
+                Optional<CachedBrandProductPage> cached = productCacheManager.getProductList(brandId, page, size);
+                if (cached.isPresent()) {
+                    return cached.get();
+                }
+            } catch (Exception e) {
+                log.warn("캐시 조회 실패, DB fallback. brandId={}, page={}", brandId, page, e);
+            }
+        }
+
+        Page<Product> products = productRepository.findByBrandIdWithPaging(brandId, validatedPageRequest(page, size));
+        CachedBrandProductPage result = CachedBrandProductPage.builder()
+                .content(products.getContent().stream().map(CachedBrandProductPage.ProductSummary::from).toList())
+                .totalElements(products.getTotalElements())
+                .build();
+
+        if (page <= CACHEABLE_PAGE_LIMIT) {
+            try {
+                productCacheManager.putProductList(brandId, page, size, result);
+            } catch (Exception e) {
+                log.warn("캐시 저장 실패. brandId={}, page={}", brandId, page, e);
+            }
+        }
+
+        return result;
+    }
+
     @Transactional(readOnly = true)
     public Option getOptionById(Long optionId) {
         return optionRepository.findById(optionId)
@@ -119,4 +188,11 @@ public void increaseLikeCount(Long productId) {
     public void decreaseLikeCount(Long productId) {
         productRepository.decreaseLikeCount(productId);
     }
+
+    private Pageable validatedPageRequest(int page, int size) {
+        if (page < 0 || size <= 0 || size > MAX_PAGE_SIZE) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "page는 0 이상, size는 1~" + MAX_PAGE_SIZE + " 범위여야 합니다.");
+        }
+        return PageRequest.of(page, size);
+    }
 }
diff --git a/apps/commerce-api/src/main/java/com/loopers/application/product/ProductCacheManager.java b/apps/commerce-api/src/main/java/com/loopers/application/product/ProductCacheManager.java
new file mode 100644
index 000000000..312f14d84
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/application/product/ProductCacheManager.java
@@ -0,0 +1,16 @@
+package com.loopers.application.product;
+
+import java.util.Optional;
+
+public interface ProductCacheManager {
+
+    Optional<CachedBrandProductPage> getProductList(Long brandId, int page, int size);
+
+    void putProductList(Long brandId, int page, int size, CachedBrandProductPage value);
+
+    Optional<CachedProductDetail> getProductDetail(Long productId);
+
+    void putProductDetail(Long productId, CachedProductDetail value);
+
+    void evictProductCaches(Long productId, Long brandId);
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/application/product/ProductFacade.java b/apps/commerce-api/src/main/java/com/loopers/application/product/ProductFacade.java
index e87ad84ca..63b89be8a 100644
--- a/apps/commerce-api/src/main/java/com/loopers/application/product/ProductFacade.java
+++ b/apps/commerce-api/src/main/java/com/loopers/application/product/ProductFacade.java
@@ -7,6 +7,9 @@
 import com.loopers.domain.product.Product;
 import com.loopers.domain.product.ProductSortCondition;
 import lombok.RequiredArgsConstructor;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.PageImpl;
+import org.springframework.data.domain.PageRequest;
 import org.springframework.stereotype.Component;
 
 import java.util.List;
@@ -21,13 +24,19 @@ public class ProductFacade {
     private final LikeAppService likeAppService;
 
     public ProductInfo getProductDetail(Long productId, Long userId) {
-        Product product = productAppService.getById(productId);
-        Brand brand = brandAppService.getById(product.getBrandId());
-        List<Option> options = productAppService.getOptionsByProductId(productId);
-        long likeCount = likeAppService.countByProductId(productId);
+        CachedProductDetail detail = productAppService.getProductDetailCached(productId);
+        Brand brand = brandAppService.getById(detail.getBrandId());
         boolean likedByUser = userId != null && likeAppService.isLikedByUser(userId, productId);
+        return toProductInfo(detail, brand, likedByUser);
+    }
 
-        return ProductInfo.of(product, brand, options, likeCount, likedByUser);
+    public Page<ProductInfo> getProductsByBrand(Long brandId, int page, int size) {
+        CachedBrandProductPage cached = productAppService.getProductsByBrandIdCached(brandId, page, size);
+        Brand brand = brandAppService.getById(brandId);
+        List<ProductInfo> content = cached.getContent().stream()
+                .map(summary -> toProductInfo(summary, brand))
+                .toList();
+        return new PageImpl<>(content, PageRequest.of(page, size), cached.getTotalElements());
     }
 
     public List<ProductInfo> getProductList(ProductSortCondition condition, Long userId) {
@@ -57,4 +66,32 @@ public List<ProductInfo> getProductList(ProductSortCondition condition, Long use
                 ))
                 .toList();
     }
+
+    private ProductInfo toProductInfo(CachedProductDetail detail, Brand brand, boolean likedByUser) {
+        return ProductInfo.builder()
+                .productId(detail.getProductId())
+                .productName(detail.getProductName())
+                .basePrice(detail.getBasePrice())
+                .deleted(detail.isDeleted())
+                .brandId(brand.getId())
+                .brandName(brand.getName())
+                .likeCount(detail.getLikeCount())
+                .likedByUser(likedByUser)
+                .options(detail.getOptions())
+                .build();
+    }
+
+    private ProductInfo toProductInfo(CachedBrandProductPage.ProductSummary summary, Brand brand) {
+        return ProductInfo.builder()
+                .productId(summary.getProductId())
+                .productName(summary.getProductName())
+                .basePrice(summary.getBasePrice())
+                .deleted(summary.isDeleted())
+                .brandId(brand.getId())
+                .brandName(brand.getName())
+                .likeCount(summary.getLikeCount())
+                .likedByUser(false)
+                .options(List.of())
+                .build();
+    }
 }
diff --git a/apps/commerce-api/src/main/java/com/loopers/application/product/ProductInfo.java b/apps/commerce-api/src/main/java/com/loopers/application/product/ProductInfo.java
index bafc4216f..ec9ccecd6 100644
--- a/apps/commerce-api/src/main/java/com/loopers/application/product/ProductInfo.java
+++ b/apps/commerce-api/src/main/java/com/loopers/application/product/ProductInfo.java
@@ -6,11 +6,13 @@
 import com.loopers.domain.product.Product;
 import lombok.Builder;
 import lombok.Getter;
+import lombok.extern.jackson.Jacksonized;
 
 import java.util.List;
 
 @Getter
 @Builder
+@Jacksonized
 public class ProductInfo {
     private final Long productId;
     private final String productName;
@@ -24,6 +26,7 @@ public class ProductInfo {
 
     @Getter
     @Builder
+    @Jacksonized
     public static class OptionInfo {
         private final Long optionId;
         private final String optionName;
@@ -42,6 +45,20 @@ public static OptionInfo from(Option option) {
         }
     }
 
+    public ProductInfo withLikedByUser(boolean likedByUser) {
+        return ProductInfo.builder()
+                .productId(this.productId)
+                .productName(this.productName)
+                .basePrice(this.basePrice)
+                .deleted(this.deleted)
+                .brandId(this.brandId)
+                .brandName(this.brandName)
+                .likeCount(this.likeCount)
+                .likedByUser(likedByUser)
+                .options(this.options)
+                .build();
+    }
+
     public static ProductInfo of(Product product, Brand brand, List<Option> options, long likeCount, boolean likedByUser) {
         return ProductInfo.builder()
                 .productId(product.getId())
diff --git a/apps/commerce-api/src/main/java/com/loopers/domain/common/Money.java b/apps/commerce-api/src/main/java/com/loopers/domain/common/Money.java
index d25e1f431..ac39c4154 100644
--- a/apps/commerce-api/src/main/java/com/loopers/domain/common/Money.java
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/common/Money.java
@@ -1,5 +1,7 @@
 package com.loopers.domain.common;
 
+import com.fasterxml.jackson.annotation.JsonCreator;
+import com.fasterxml.jackson.annotation.JsonProperty;
 import com.loopers.support.error.CoreException;
 import com.loopers.support.error.ErrorType;
 import jakarta.persistence.Embeddable;
@@ -17,7 +19,8 @@
 public class Money {
     private BigDecimal amount;
 
-    private Money(BigDecimal amount) {
+    @JsonCreator
+    private Money(@JsonProperty("amount") BigDecimal amount) {
         if (amount == null || amount.compareTo(BigDecimal.ZERO) < 0) {
             throw new CoreException(ErrorType.BAD_REQUEST, "금액은 0 이상이어야 합니다.");
         }
@@ -55,7 +58,7 @@ public boolean isGreaterThanOrEqual(Money other) {
     public Money subtract(Money other) {
         BigDecimal result = this.amount.subtract(other.amount);
         if (result.compareTo(BigDecimal.ZERO) < 0) {
-            throw new IllegalArgumentException(
+            throw new CoreException(ErrorType.BAD_REQUEST,
                     "차감 결과가 음수입니다: " + this.amount + " - " + other.amount + " = " + result);
         }
         return new Money(result);
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
index ce744c299..71dc6e56f 100644
--- 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
@@ -8,13 +8,19 @@
 import jakarta.persistence.Column;
 import jakarta.persistence.Embedded;
 import jakarta.persistence.Entity;
+import jakarta.persistence.Index;
 import jakarta.persistence.Table;
 import lombok.AccessLevel;
 import lombok.Getter;
 import lombok.NoArgsConstructor;
 
 @Entity
-@Table(name = "products")
+@Table(name = "products", indexes = {
+        @Index(name = "idx_products_brand_deleted_likes", columnList = "brand_id, deleted, like_count DESC"),
+        @Index(name = "idx_products_deleted_likes", columnList = "deleted, like_count DESC"),
+        @Index(name = "idx_products_deleted_created", columnList = "deleted, created_at DESC"),
+        @Index(name = "idx_products_deleted_price", columnList = "deleted, base_price ASC")
+})
 @Getter
 @NoArgsConstructor(access = AccessLevel.PROTECTED)
 public class Product extends BaseEntity {
@@ -48,16 +54,6 @@ public static Product create(Long brandId, String name, Money basePrice) {
         return new Product(brandId, name, basePrice, false, 0L);
     }
 
-    public void increaseLikeCount() {
-        this.likeCount++;
-    }
-
-    public void decreaseLikeCount() {
-        if (this.likeCount > 0) {
-            this.likeCount--;
-        }
-    }
-
     public void update(String name, Money basePrice) {
         validateName(name);
         this.name = name;
diff --git a/apps/commerce-api/src/main/java/com/loopers/domain/product/ProductRepository.java b/apps/commerce-api/src/main/java/com/loopers/domain/product/ProductRepository.java
index e946eba7a..5a1918735 100644
--- a/apps/commerce-api/src/main/java/com/loopers/domain/product/ProductRepository.java
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/product/ProductRepository.java
@@ -1,5 +1,8 @@
 package com.loopers.domain.product;
 
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+
 import java.util.List;
 import java.util.Optional;
 
@@ -10,6 +13,7 @@ public interface ProductRepository {
     List<Product> findAll(ProductSortCondition condition);
     List<Product> findByBrandId(Long brandId);
     List<Product> findByIdIn(List<Long> productIds);
+    Page<Product> findByBrandIdWithPaging(Long brandId, Pageable pageable);
     void increaseLikeCount(Long id);
     void decreaseLikeCount(Long 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
index ef15d8674..0c2f878fb 100644
--- a/apps/commerce-api/src/main/java/com/loopers/infrastructure/product/ProductJpaRepository.java
+++ b/apps/commerce-api/src/main/java/com/loopers/infrastructure/product/ProductJpaRepository.java
@@ -3,6 +3,8 @@
 import com.loopers.domain.product.Product;
 import jakarta.persistence.LockModeType;
 import jakarta.persistence.QueryHint;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
 import org.springframework.data.domain.Sort;
 import org.springframework.data.jpa.repository.JpaRepository;
 import org.springframework.data.jpa.repository.Lock;
@@ -22,6 +24,9 @@ public interface ProductJpaRepository extends JpaRepository<Product, Long> {
 
     List<Product> findByBrandIdAndDeletedFalse(Long brandId);
 
+    @Query("SELECT p FROM Product p WHERE p.brandId = :brandId AND p.deleted = false ORDER BY p.likeCount DESC, p.id DESC")
+    Page<Product> findByBrandIdAndDeletedFalseOrderByLikeCountDesc(@Param("brandId") Long brandId, Pageable pageable);
+
     Optional<Product> findByIdAndDeletedFalse(Long id);
 
     List<Product> findByIdInAndDeletedFalse(List<Long> productIds);
diff --git a/apps/commerce-api/src/main/java/com/loopers/infrastructure/product/ProductRepositoryImpl.java b/apps/commerce-api/src/main/java/com/loopers/infrastructure/product/ProductRepositoryImpl.java
index b4e57655f..48e1622e2 100644
--- a/apps/commerce-api/src/main/java/com/loopers/infrastructure/product/ProductRepositoryImpl.java
+++ b/apps/commerce-api/src/main/java/com/loopers/infrastructure/product/ProductRepositoryImpl.java
@@ -6,6 +6,8 @@
 import com.loopers.support.error.CoreException;
 import com.loopers.support.error.ErrorType;
 import lombok.RequiredArgsConstructor;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
 import org.springframework.data.domain.Sort;
 import org.springframework.stereotype.Repository;
 
@@ -51,6 +53,11 @@ public List<Product> findByBrandId(Long brandId) {
         return productJpaRepository.findByBrandIdAndDeletedFalse(brandId);
     }
 
+    @Override
+    public Page<Product> findByBrandIdWithPaging(Long brandId, Pageable pageable) {
+        return productJpaRepository.findByBrandIdAndDeletedFalseOrderByLikeCountDesc(brandId, pageable);
+    }
+
     @Override
     public List<Product> findByIdIn(List<Long> productIds) {
         return productJpaRepository.findByIdInAndDeletedFalse(productIds);
diff --git a/apps/commerce-api/src/main/java/com/loopers/infrastructure/product/RedisProductCacheManager.java b/apps/commerce-api/src/main/java/com/loopers/infrastructure/product/RedisProductCacheManager.java
new file mode 100644
index 000000000..3759afd6a
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/infrastructure/product/RedisProductCacheManager.java
@@ -0,0 +1,106 @@
+package com.loopers.infrastructure.product;
+
+import com.loopers.application.product.CachedBrandProductPage;
+import com.loopers.application.product.CachedProductDetail;
+import com.loopers.application.product.ProductCacheManager;
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.data.redis.core.RedisTemplate;
+import org.springframework.stereotype.Component;
+
+import java.time.Duration;
+import java.util.Optional;
+import java.util.concurrent.ThreadLocalRandom;
+
+@Slf4j
+@Component
+@RequiredArgsConstructor
+public class RedisProductCacheManager implements ProductCacheManager {
+
+    private static final long LIST_BASE_TTL_SECONDS = 60;
+    private static final long LIST_JITTER_BOUND = 10;
+    private static final long DETAIL_BASE_TTL_SECONDS = 300;
+    private static final long DETAIL_JITTER_BOUND = 30;
+    private static final int EVICT_MAX_PAGE = 3;
+    private static final int EVICT_DEFAULT_SIZE = 20;
+
+    private final RedisTemplate<String, String> redisTemplate;
+    private final ObjectMapper objectMapper;
+
+    @Override
+    public Optional<CachedBrandProductPage> getProductList(Long brandId, int page, int size) {
+        return get(productListKey(brandId, page, size), CachedBrandProductPage.class);
+    }
+
+    @Override
+    public void putProductList(Long brandId, int page, int size, CachedBrandProductPage value) {
+        put(productListKey(brandId, page, size), value, listTtlWithJitter());
+    }
+
+    @Override
+    public Optional<CachedProductDetail> getProductDetail(Long productId) {
+        return get(productDetailKey(productId), CachedProductDetail.class);
+    }
+
+    @Override
+    public void putProductDetail(Long productId, CachedProductDetail value) {
+        put(productDetailKey(productId), value, detailTtlWithJitter());
+    }
+
+    @Override
+    public void evictProductCaches(Long productId, Long brandId) {
+        try {
+            redisTemplate.delete(productDetailKey(productId));
+
+            for (int page = 0; page < EVICT_MAX_PAGE; page++) {
+                redisTemplate.delete(productListKey(brandId, page, EVICT_DEFAULT_SIZE));
+            }
+        } catch (Exception e) {
+            log.warn("캐시 무효화 실패. productId={}, brandId={}", productId, brandId, e);
+        }
+    }
+
+    private <T> Optional<T> get(String key, Class<T> type) {
+        try {
+            String json = redisTemplate.opsForValue().get(key);
+            if (json == null) {
+                return Optional.empty();
+            }
+            return Optional.of(objectMapper.readValue(json, type));
+        } catch (Exception e) {
+            log.warn("Redis 조회 실패, DB fallback. key={}", key, e);
+            return Optional.empty();
+        }
+    }
+
+    private void put(String key, Object value, Duration ttl) {
+        try {
+            String json = objectMapper.writeValueAsString(value);
+            redisTemplate.opsForValue().set(key, json, ttl);
+        } catch (JsonProcessingException e) {
+            log.warn("캐시 직렬화 실패. key={}", key, e);
+        } catch (Exception e) {
+            log.warn("Redis 저장 실패. key={}", key, e);
+        }
+    }
+
+    private String productListKey(Long brandId, int page, int size) {
+        return "product:brand:" + brandId + ":page:" + page + ":size:" + size;
+    }
+
+    private String productDetailKey(Long productId) {
+        return "product:detail:" + productId;
+    }
+
+    private Duration listTtlWithJitter() {
+        long jitter = ThreadLocalRandom.current().nextLong(1, LIST_JITTER_BOUND + 1);
+        return Duration.ofSeconds(LIST_BASE_TTL_SECONDS + jitter);
+    }
+
+    private Duration detailTtlWithJitter() {
+        long jitter = ThreadLocalRandom.current().nextLong(1, DETAIL_JITTER_BOUND + 1);
+        return Duration.ofSeconds(DETAIL_BASE_TTL_SECONDS + jitter);
+    }
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/interfaces/api/product/ProductController.java b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/product/ProductController.java
index ed6e50094..1d91de285 100644
--- a/apps/commerce-api/src/main/java/com/loopers/interfaces/api/product/ProductController.java
+++ b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/product/ProductController.java
@@ -6,22 +6,45 @@
 import com.loopers.domain.product.ProductSortCondition;
 import com.loopers.interfaces.api.ApiResponse;
 import com.loopers.interfaces.resolver.LoginUser;
+import com.loopers.support.error.CoreException;
+import com.loopers.support.error.ErrorType;
 import lombok.RequiredArgsConstructor;
+import org.springframework.data.domain.Page;
 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;
 
 @RestController
-@RequestMapping("/api/v1/products")
 @RequiredArgsConstructor
 public class ProductController {
+    private static final int PAGE_SIZE = 20;
+    private static final int MAX_PAGE = 50;
+
     private final ProductFacade productFacade;
 
-    @GetMapping
+    @GetMapping("/api/v1/brands/{brandId}/products")
+    public ApiResponse<ProductDto.BrandProductListResponse> getProductsByBrand(
+            @PathVariable Long brandId,
+            @RequestParam(defaultValue = "0") int page
+    ) {
+        if (page < 0 || page > MAX_PAGE) {
+            throw new CoreException(ErrorType.BAD_REQUEST,
+                    "페이지는 0에서 " + MAX_PAGE + " 사이여야 합니다.");
+        }
+
+        Page<ProductInfo> productPage = productFacade.getProductsByBrand(brandId, page, PAGE_SIZE);
+        List<ProductDto.BrandProductResponse> products = productPage.getContent().stream()
+                .map(ProductDto.BrandProductResponse::from)
+                .toList();
+        return ApiResponse.success(new ProductDto.BrandProductListResponse(
+                products, page, PAGE_SIZE, productPage.getTotalElements(), productPage.getTotalPages()
+        ));
+    }
+
+    @GetMapping("/api/v1/products")
     public ApiResponse<ProductDto.ProductListResponse> getProductList(
             @RequestParam(required = false) ProductSortCondition sort,
             @LoginUser(required = false) Member member
@@ -32,7 +55,7 @@ public ApiResponse<ProductDto.ProductListResponse> getProductList(
         return ApiResponse.success(ProductDto.ProductListResponse.from(productList));
     }
 
-    @GetMapping("/{productId}")
+    @GetMapping("/api/v1/products/{productId}")
     public ApiResponse<ProductDto.ProductResponse> getProductDetail(
             @PathVariable Long productId,
             @LoginUser(required = false) Member member
diff --git a/apps/commerce-api/src/main/java/com/loopers/interfaces/api/product/ProductDto.java b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/product/ProductDto.java
index 6e1627f23..31faf1da8 100644
--- a/apps/commerce-api/src/main/java/com/loopers/interfaces/api/product/ProductDto.java
+++ b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/product/ProductDto.java
@@ -63,4 +63,30 @@ public static ProductListResponse from(List<ProductInfo> infoList) {
             );
         }
     }
+
+    public record BrandProductResponse(
+            Long productId,
+            String productName,
+            BigDecimal basePrice,
+            String brandName,
+            long likeCount
+    ) {
+        public static BrandProductResponse from(ProductInfo info) {
+            return new BrandProductResponse(
+                    info.getProductId(),
+                    info.getProductName(),
+                    info.getBasePrice().getAmount(),
+                    info.getBrandName(),
+                    info.getLikeCount()
+            );
+        }
+    }
+
+    public record BrandProductListResponse(
+            List<BrandProductResponse> products,
+            int page,
+            int size,
+            long totalElements,
+            int totalPages
+    ) {}
 }
diff --git a/apps/commerce-api/src/test/java/com/loopers/application/product/ProductAppServiceIntegrationTest.java b/apps/commerce-api/src/test/java/com/loopers/application/product/ProductAppServiceIntegrationTest.java
new file mode 100644
index 000000000..eb8aa8dc3
--- /dev/null
+++ b/apps/commerce-api/src/test/java/com/loopers/application/product/ProductAppServiceIntegrationTest.java
@@ -0,0 +1,127 @@
+package com.loopers.application.product;
+
+import com.loopers.domain.brand.Brand;
+import com.loopers.domain.brand.BrandRepository;
+import com.loopers.domain.common.Money;
+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.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.data.domain.Page;
+
+import java.math.BigDecimal;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+@SpringBootTest
+@DisplayName("ProductAppService 통합 테스트")
+class ProductAppServiceIntegrationTest {
+
+    @Autowired
+    private ProductAppService productAppService;
+    @Autowired
+    private ProductRepository productRepository;
+    @Autowired
+    private BrandRepository brandRepository;
+    @Autowired
+    private DatabaseCleanUp databaseCleanUp;
+
+    private Brand testBrand;
+
+    @BeforeEach
+    void setUp() {
+        testBrand = brandRepository.save(Brand.create("테스트 브랜드"));
+    }
+
+    @AfterEach
+    void tearDown() {
+        databaseCleanUp.truncateAllTables();
+    }
+
+    @Nested
+    @DisplayName("브랜드별 상품 페이징 조회")
+    class GetProductsByBrandIdTest {
+
+        @Test
+        @DisplayName("brandId로 필터링하고 likeCount DESC 정렬된 결과를 페이징 조회한다")
+        void getProductsByBrandId_success() {
+            // given
+            Product p1 = productRepository.save(Product.create(testBrand.getId(), "상품A", Money.of(BigDecimal.valueOf(10000))));
+            Product p2 = productRepository.save(Product.create(testBrand.getId(), "상품B", Money.of(BigDecimal.valueOf(20000))));
+            Product p3 = productRepository.save(Product.create(testBrand.getId(), "상품C", Money.of(BigDecimal.valueOf(30000))));
+
+            productAppService.increaseLikeCount(p2.getId());
+            productAppService.increaseLikeCount(p2.getId());
+            productAppService.increaseLikeCount(p2.getId());
+
+            productAppService.increaseLikeCount(p3.getId());
+
+            // when
+            Page<Product> result = productAppService.getProductsByBrandId(testBrand.getId(), 0, 20);
+
+            // then
+            assertThat(result.getContent()).hasSize(3);
+            assertThat(result.getContent().get(0).getName()).isEqualTo("상품B");
+            assertThat(result.getContent().get(1).getName()).isEqualTo("상품C");
+            assertThat(result.getContent().get(2).getName()).isEqualTo("상품A");
+        }
+
+        @Test
+        @DisplayName("페이징이 정상 동작한다")
+        void getProductsByBrandId_paging() {
+            // given
+            for (int i = 0; i < 25; i++) {
+                productRepository.save(Product.create(testBrand.getId(), "상품" + i, Money.of(BigDecimal.valueOf(1000))));
+            }
+
+            // when
+            Page<Product> firstPage = productAppService.getProductsByBrandId(testBrand.getId(), 0, 20);
+            Page<Product> secondPage = productAppService.getProductsByBrandId(testBrand.getId(), 1, 20);
+
+            // then
+            assertThat(firstPage.getContent()).hasSize(20);
+            assertThat(secondPage.getContent()).hasSize(5);
+            assertThat(firstPage.getTotalElements()).isEqualTo(25);
+            assertThat(firstPage.getTotalPages()).isEqualTo(2);
+        }
+
+        @Test
+        @DisplayName("다른 브랜드 상품은 조회되지 않는다")
+        void getProductsByBrandId_filterByBrand() {
+            // given
+            Brand otherBrand = brandRepository.save(Brand.create("다른 브랜드"));
+            productRepository.save(Product.create(testBrand.getId(), "내 브랜드 상품", Money.of(BigDecimal.valueOf(10000))));
+            productRepository.save(Product.create(otherBrand.getId(), "다른 브랜드 상품", Money.of(BigDecimal.valueOf(20000))));
+
+            // when
+            Page<Product> result = productAppService.getProductsByBrandId(testBrand.getId(), 0, 20);
+
+            // then
+            assertThat(result.getContent()).hasSize(1);
+            assertThat(result.getContent().get(0).getName()).isEqualTo("내 브랜드 상품");
+        }
+
+        @Test
+        @DisplayName("삭제된 상품은 조회되지 않는다")
+        void getProductsByBrandId_excludeDeleted() {
+            // given
+            Product active = productRepository.save(Product.create(testBrand.getId(), "활성 상품", Money.of(BigDecimal.valueOf(10000))));
+            Product deleted = productRepository.save(Product.create(testBrand.getId(), "삭제 상품", Money.of(BigDecimal.valueOf(20000))));
+            deleted.delete();
+            productRepository.save(deleted);
+
+            // when
+            Page<Product> result = productAppService.getProductsByBrandId(testBrand.getId(), 0, 20);
+
+            // then
+            assertThat(result.getContent()).hasSize(1);
+            assertThat(result.getContent().get(0).getName()).isEqualTo("활성 상품");
+        }
+    }
+}
diff --git a/apps/commerce-api/src/test/java/com/loopers/application/product/ProductAppServiceTest.java b/apps/commerce-api/src/test/java/com/loopers/application/product/ProductAppServiceTest.java
index d08eeffa7..5cc0c000c 100644
--- a/apps/commerce-api/src/test/java/com/loopers/application/product/ProductAppServiceTest.java
+++ b/apps/commerce-api/src/test/java/com/loopers/application/product/ProductAppServiceTest.java
@@ -12,6 +12,10 @@
 import org.junit.jupiter.api.Nested;
 import org.junit.jupiter.api.Test;
 
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.PageImpl;
+import org.springframework.data.domain.PageRequest;
+
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
@@ -19,9 +23,13 @@
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
 import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyInt;
+import static org.mockito.ArgumentMatchers.anyLong;
+import static org.mockito.ArgumentMatchers.eq;
 import static org.mockito.BDDMockito.given;
 import static org.mockito.Mockito.doThrow;
 import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.verify;
 
 @DisplayName("ProductAppService 단위 테스트")
@@ -30,12 +38,14 @@ class ProductAppServiceTest {
     private ProductAppService productAppService;
     private ProductRepository productRepository;
     private OptionRepository optionRepository;
+    private ProductCacheManager productCacheManager;
 
     @BeforeEach
     void setUp() {
         productRepository = mock(ProductRepository.class);
         optionRepository = mock(OptionRepository.class);
-        productAppService = new ProductAppService(productRepository, optionRepository);
+        productCacheManager = mock(ProductCacheManager.class);
+        productAppService = new ProductAppService(productRepository, optionRepository, productCacheManager);
     }
 
     @Nested
@@ -272,6 +282,129 @@ void increaseStock_success() {
         }
     }
 
+    @Nested
+    @DisplayName("브랜드 상품 부분 캐싱")
+    class BrandProductCacheTest {
+
+        @Test
+        @DisplayName("page 0~2 캐시 히트 시 Repository를 호출하지 않는다")
+        void cacheHit_withinLimit_skipsRepository() {
+            // given
+            int page = 1;
+            CachedBrandProductPage cachedPage = CachedBrandProductPage.builder()
+                    .content(List.of())
+                    .totalElements(0L)
+                    .build();
+            given(productCacheManager.getProductList(1L, page, 20))
+                    .willReturn(Optional.of(cachedPage));
+
+            // when
+            CachedBrandProductPage result = productAppService.getProductsByBrandIdCached(1L, page, 20);
+
+            // then
+            assertThat(result).isEqualTo(cachedPage);
+            verify(productRepository, never()).findByBrandIdWithPaging(anyLong(), any(PageRequest.class));
+        }
+
+        @Test
+        @DisplayName("page 0~2 캐시 미스 시 DB 조회 후 캐시에 저장한다")
+        void cacheMiss_withinLimit_queriesDbAndCaches() {
+            // given
+            int page = 0;
+            given(productCacheManager.getProductList(1L, page, 20))
+                    .willReturn(Optional.empty());
+
+            Page<Product> dbPage = new PageImpl<>(List.of(), PageRequest.of(page, 20), 0);
+            given(productRepository.findByBrandIdWithPaging(eq(1L), any(PageRequest.class)))
+                    .willReturn(dbPage);
+
+            // when
+            productAppService.getProductsByBrandIdCached(1L, page, 20);
+
+            // then
+            verify(productRepository).findByBrandIdWithPaging(eq(1L), any(PageRequest.class));
+            verify(productCacheManager).putProductList(eq(1L), eq(page), eq(20), any(CachedBrandProductPage.class));
+        }
+
+        @Test
+        @DisplayName("캐시 조회에서 예외 발생 시 DB fallback으로 정상 응답한다")
+        void cacheException_fallsBackToDb() {
+            // given
+            int page = 0;
+            given(productCacheManager.getProductList(1L, page, 20))
+                    .willThrow(new RuntimeException("Redis connection refused"));
+
+            Page<Product> dbPage = new PageImpl<>(List.of(), PageRequest.of(page, 20), 0);
+            given(productRepository.findByBrandIdWithPaging(eq(1L), any(PageRequest.class)))
+                    .willReturn(dbPage);
+
+            // when
+            CachedBrandProductPage result = productAppService.getProductsByBrandIdCached(1L, page, 20);
+
+            // then
+            assertThat(result).isNotNull();
+            verify(productRepository).findByBrandIdWithPaging(eq(1L), any(PageRequest.class));
+        }
+
+        @Test
+        @DisplayName("page=2(경계값) 캐시 히트 시 Repository를 호출하지 않는다")
+        void cacheHit_atBoundary_skipsRepository() {
+            // given
+            int page = 2;
+            CachedBrandProductPage cachedPage = CachedBrandProductPage.builder()
+                    .content(List.of())
+                    .totalElements(0L)
+                    .build();
+            given(productCacheManager.getProductList(1L, page, 20))
+                    .willReturn(Optional.of(cachedPage));
+
+            // when
+            CachedBrandProductPage result = productAppService.getProductsByBrandIdCached(1L, page, 20);
+
+            // then
+            assertThat(result).isEqualTo(cachedPage);
+            verify(productRepository, never()).findByBrandIdWithPaging(anyLong(), any(PageRequest.class));
+        }
+
+        @Test
+        @DisplayName("page=2(경계값) 캐시 미스 시 DB 조회 후 캐시에 저장한다")
+        void cacheMiss_atBoundary_queriesDbAndCaches() {
+            // given
+            int page = 2;
+            given(productCacheManager.getProductList(1L, page, 20))
+                    .willReturn(Optional.empty());
+
+            Page<Product> dbPage = new PageImpl<>(List.of(), PageRequest.of(page, 20), 0);
+            given(productRepository.findByBrandIdWithPaging(eq(1L), any(PageRequest.class)))
+                    .willReturn(dbPage);
+
+            // when
+            productAppService.getProductsByBrandIdCached(1L, page, 20);
+
+            // then
+            verify(productRepository).findByBrandIdWithPaging(eq(1L), any(PageRequest.class));
+            verify(productCacheManager).putProductList(eq(1L), eq(page), eq(20), any(CachedBrandProductPage.class));
+        }
+
+        @Test
+        @DisplayName("page 3 이상은 캐시를 사용하지 않고 DB에서 직접 조회한다")
+        void deepPage_bypassesCache() {
+            // given
+            int page = 3;
+            Page<Product> dbPage = new PageImpl<>(List.of(), PageRequest.of(page, 20), 0);
+            given(productRepository.findByBrandIdWithPaging(eq(1L), any(PageRequest.class)))
+                    .willReturn(dbPage);
+
+            // when
+            productAppService.getProductsByBrandIdCached(1L, page, 20);
+
+            // then
+            verify(productCacheManager, never()).getProductList(anyLong(), anyInt(), anyInt());
+            verify(productCacheManager, never()).putProductList(anyLong(), anyInt(), anyInt(), any(CachedBrandProductPage.class));
+            verify(productRepository).findByBrandIdWithPaging(eq(1L), any(PageRequest.class));
+        }
+    }
+
     @Nested
     @DisplayName("옵션 생성")
     class CreateOptionTest {
diff --git a/apps/commerce-api/src/test/java/com/loopers/application/product/ProductFacadeTest.java b/apps/commerce-api/src/test/java/com/loopers/application/product/ProductFacadeTest.java
index f629505be..4529b345d 100644
--- a/apps/commerce-api/src/test/java/com/loopers/application/product/ProductFacadeTest.java
+++ b/apps/commerce-api/src/test/java/com/loopers/application/product/ProductFacadeTest.java
@@ -51,29 +51,28 @@ void getProductDetail_success() {
             Long brandId = 10L;
             Long userId = 100L;
 
-            Product product = mock(Product.class);
-            given(product.getId()).willReturn(productId);
-            given(product.getBrandId()).willReturn(brandId);
-            given(product.getName()).willReturn("테스트 상품");
-            given(product.getBasePrice()).willReturn(Money.of(10000L));
-            given(product.isDeleted()).willReturn(false);
+            CachedProductDetail cachedDetail = CachedProductDetail.builder()
+                    .productId(productId)
+                    .productName("테스트 상품")
+                    .basePrice(Money.of(10000L))
+                    .deleted(false)
+                    .brandId(brandId)
+                    .likeCount(42L)
+                    .options(List.of(ProductInfo.OptionInfo.builder()
+                            .optionId(1L)
+                            .optionName("기본")
+                            .additionalPrice(Money.of(0L))
+                            .stock(50)
+                            .soldOut(false)
+                            .build()))
+                    .build();
 
             Brand brand = mock(Brand.class);
             given(brand.getId()).willReturn(brandId);
             given(brand.getName()).willReturn("테스트 브랜드");
 
-            Option option = mock(Option.class);
-            given(option.getId()).willReturn(1L);
-            given(option.getName()).willReturn("기본");
-            given(option.getAdditionalPrice()).willReturn(Money.of(0L));
-            given(option.getStock()).willReturn(50);
-            given(option.isSoldOut()).willReturn(false);
-            List<Option> options = List.of(option);
-
-            given(productAppService.getById(productId)).willReturn(product);
+            given(productAppService.getProductDetailCached(productId)).willReturn(cachedDetail);
             given(brandAppService.getById(brandId)).willReturn(brand);
-            given(productAppService.getOptionsByProductId(productId)).willReturn(options);
-            given(likeAppService.countByProductId(productId)).willReturn(42L);
             given(likeAppService.isLikedByUser(userId, productId)).willReturn(true);
 
             // when
@@ -94,21 +93,22 @@ void getProductDetail_noUser() {
             Long productId = 1L;
             Long brandId = 10L;
 
-            Product product = mock(Product.class);
-            given(product.getId()).willReturn(productId);
-            given(product.getBrandId()).willReturn(brandId);
-            given(product.getName()).willReturn("테스트 상품");
-            given(product.getBasePrice()).willReturn(Money.of(10000L));
-            given(product.isDeleted()).willReturn(false);
+            CachedProductDetail cachedDetail = CachedProductDetail.builder()
+                    .productId(productId)
+                    .productName("테스트 상품")
+                    .basePrice(Money.of(10000L))
+                    .deleted(false)
+                    .brandId(brandId)
+                    .likeCount(0L)
+                    .options(List.of())
+                    .build();
 
             Brand brand = mock(Brand.class);
             given(brand.getId()).willReturn(brandId);
             given(brand.getName()).willReturn("테스트 브랜드");
 
-            given(productAppService.getById(productId)).willReturn(product);
+            given(productAppService.getProductDetailCached(productId)).willReturn(cachedDetail);
             given(brandAppService.getById(brandId)).willReturn(brand);
-            given(productAppService.getOptionsByProductId(productId)).willReturn(List.of());
-            given(likeAppService.countByProductId(productId)).willReturn(0L);
 
             // when
             ProductInfo result = productFacade.getProductDetail(productId, null);
@@ -119,6 +119,53 @@ void getProductDetail_noUser() {
         }
     }
 
+    @Nested
+    @DisplayName("브랜드별 상품 목록 조회")
+    class GetProductsByBrandTest {
+
+        @Test
+        @DisplayName("브랜드별 상품 목록을 조합하여 반환한다")
+        void getProductsByBrand_success() {
+            // given
+            Long brandId = 10L;
+
+            CachedBrandProductPage cachedPage = CachedBrandProductPage.builder()
+                    .content(List.of(
+                            CachedBrandProductPage.ProductSummary.builder()
+                                    .productId(1L)
+                                    .productName("상품A")
+                                    .basePrice(Money.of(10000L))
+                                    .deleted(false)
+                                    .likeCount(5L)
+                                    .build(),
+                            CachedBrandProductPage.ProductSummary.builder()
+                                    .productId(2L)
+                                    .productName("상품B")
+                                    .basePrice(Money.of(20000L))
+                                    .deleted(false)
+                                    .likeCount(10L)
+                                    .build()))
+                    .totalElements(2L)
+                    .build();
+
+            Brand brand = mock(Brand.class);
+            given(brand.getId()).willReturn(brandId);
+            given(brand.getName()).willReturn("테스트 브랜드");
+
+            given(productAppService.getProductsByBrandIdCached(brandId, 0, 20)).willReturn(cachedPage);
+            given(brandAppService.getById(brandId)).willReturn(brand);
+
+            // when
+            var result = productFacade.getProductsByBrand(brandId, 0, 20);
+
+            // then
+            assertThat(result.getContent()).hasSize(2);
+            assertThat(result.getContent().get(0).getProductName()).isEqualTo("상품A");
+            assertThat(result.getContent().get(0).getBrandName()).isEqualTo("테스트 브랜드");
+            assertThat(result.getTotalElements()).isEqualTo(2L);
+        }
+    }
+
     @Nested
     @DisplayName("상품 목록 조회")
     class GetProductListTest {
diff --git a/apps/commerce-api/src/test/java/com/loopers/domain/common/MoneyTest.java b/apps/commerce-api/src/test/java/com/loopers/domain/common/MoneyTest.java
index 59ed96c46..fab832db5 100644
--- a/apps/commerce-api/src/test/java/com/loopers/domain/common/MoneyTest.java
+++ b/apps/commerce-api/src/test/java/com/loopers/domain/common/MoneyTest.java
@@ -1,6 +1,7 @@
 package com.loopers.domain.common;
 
 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;
@@ -34,10 +35,11 @@ void createWithZero() {
         }
 
         @Test
-        @DisplayName("음수 금액으로 생성 시 예외가 발생한다")
+        @DisplayName("음수 금액으로 생성 시 BAD_REQUEST 예외가 발생한다")
         void createWithNegativeAmountThrowsException() {
             assertThatThrownBy(() -> Money.of(-1000L))
-                    .isInstanceOf(CoreException.class);
+                    .isInstanceOfSatisfying(CoreException.class, e ->
+                            assertThat(e.getErrorType()).isEqualTo(ErrorType.BAD_REQUEST));
         }
     }
 
@@ -88,14 +90,14 @@ void subtractMoney() {
         }
 
         @Test
-        @DisplayName("빼기 결과가 음수이면 예외가 발생한다")
+        @DisplayName("빼기 결과가 음수이면 BAD_REQUEST 예외가 발생한다")
         void subtractMoneyThrowsExceptionWhenNegative() {
             Money money1 = Money.of(300L);
             Money money2 = Money.of(1000L);
 
             assertThatThrownBy(() -> money1.subtract(money2))
-                    .isInstanceOf(IllegalArgumentException.class)
-                    .hasMessageContaining("차감 결과가 음수");
+                    .isInstanceOfSatisfying(CoreException.class, e ->
+                            assertThat(e.getErrorType()).isEqualTo(ErrorType.BAD_REQUEST));
         }
 
         @Test
@@ -109,14 +111,16 @@ void percentageMoney() {
         }
 
         @Test
-        @DisplayName("잘못된 할인율은 예외가 발생한다")
+        @DisplayName("잘못된 할인율은 BAD_REQUEST 예외가 발생한다")
         void percentageWithInvalidRate() {
             Money money = Money.of(10000L);
 
             assertThatThrownBy(() -> money.percentage(101))
-                    .isInstanceOf(CoreException.class);
+                    .isInstanceOfSatisfying(CoreException.class, e ->
+                            assertThat(e.getErrorType()).isEqualTo(ErrorType.BAD_REQUEST));
             assertThatThrownBy(() -> money.percentage(-1))
-                    .isInstanceOf(CoreException.class);
+                    .isInstanceOfSatisfying(CoreException.class, e ->
+                            assertThat(e.getErrorType()).isEqualTo(ErrorType.BAD_REQUEST));
         }
 
         @Test
@@ -130,14 +134,16 @@ void percentageWithBigDecimalRate() {
         }
 
         @Test
-        @DisplayName("BigDecimal 할인율 범위 초과 시 예외가 발생한다")
+        @DisplayName("BigDecimal 할인율 범위 초과 시 BAD_REQUEST 예외가 발생한다")
         void percentageWithInvalidBigDecimalRate() {
             Money money = Money.of(10000L);
 
             assertThatThrownBy(() -> money.percentage(new BigDecimal("100.1")))
-                    .isInstanceOf(CoreException.class);
+                    .isInstanceOfSatisfying(CoreException.class, e ->
+                            assertThat(e.getErrorType()).isEqualTo(ErrorType.BAD_REQUEST));
             assertThatThrownBy(() -> money.percentage(new BigDecimal("-0.1")))
-                    .isInstanceOf(CoreException.class);
+                    .isInstanceOfSatisfying(CoreException.class, e ->
+                            assertThat(e.getErrorType()).isEqualTo(ErrorType.BAD_REQUEST));
         }
 
         @Test
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
index b88d904ae..098b23aa5 100644
--- 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
@@ -98,38 +98,5 @@ void createWithZeroLikeCount() {
 
             assertThat(product.getLikeCount()).isZero();
         }
-
-        @Test
-        @DisplayName("좋아요 수를 증가시킬 수 있다")
-        void increaseLikeCount() {
-            Product product = Product.create(1L, "테스트 상품", Money.of(10000L));
-
-            product.increaseLikeCount();
-            product.increaseLikeCount();
-
-            assertThat(product.getLikeCount()).isEqualTo(2L);
-        }
-
-        @Test
-        @DisplayName("좋아요 수를 감소시킬 수 있다")
-        void decreaseLikeCount() {
-            Product product = Product.create(1L, "테스트 상품", Money.of(10000L));
-            product.increaseLikeCount();
-            product.increaseLikeCount();
-
-            product.decreaseLikeCount();
-
-            assertThat(product.getLikeCount()).isEqualTo(1L);
-        }
-
-        @Test
-        @DisplayName("좋아요 수가 0이면 더 이상 감소하지 않는다")
-        void decreaseLikeCountAtZero() {
-            Product product = Product.create(1L, "테스트 상품", Money.of(10000L));
-
-            product.decreaseLikeCount();
-
-            assertThat(product.getLikeCount()).isZero();
-        }
     }
 }
diff --git a/apps/commerce-api/src/test/java/com/loopers/interfaces/api/BrandProductApiE2ETest.java b/apps/commerce-api/src/test/java/com/loopers/interfaces/api/BrandProductApiE2ETest.java
new file mode 100644
index 000000000..bf686aa88
--- /dev/null
+++ b/apps/commerce-api/src/test/java/com/loopers/interfaces/api/BrandProductApiE2ETest.java
@@ -0,0 +1,177 @@
+package com.loopers.interfaces.api;
+
+import com.loopers.application.product.ProductAppService;
+import com.loopers.domain.brand.Brand;
+import com.loopers.domain.brand.BrandRepository;
+import com.loopers.domain.common.Money;
+import com.loopers.domain.product.Product;
+import com.loopers.domain.product.ProductRepository;
+import com.loopers.interfaces.api.product.ProductDto;
+import com.loopers.utils.DatabaseCleanUp;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.boot.test.web.client.TestRestTemplate;
+import org.springframework.core.ParameterizedTypeReference;
+import org.springframework.http.HttpMethod;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+
+import java.math.BigDecimal;
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertAll;
+
+@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
+class BrandProductApiE2ETest {
+
+    @Autowired
+    private TestRestTemplate testRestTemplate;
+    @Autowired
+    private BrandRepository brandRepository;
+    @Autowired
+    private ProductRepository productRepository;
+    @Autowired
+    private ProductAppService productAppService;
+    @Autowired
+    private DatabaseCleanUp databaseCleanUp;
+
+    private Brand testBrand;
+
+    @BeforeEach
+    void setUp() {
+        testBrand = brandRepository.save(Brand.create("테스트 브랜드"));
+    }
+
+    @AfterEach
+    void tearDown() {
+        databaseCleanUp.truncateAllTables();
+    }
+
+    @DisplayName("GET /api/v1/brands/{brandId}/products")
+    @Nested
+    class GetBrandProducts {
+
+        @DisplayName("브랜드별 상품 목록을 조회할 수 있다.")
+        @Test
+        void getBrandProducts_success() {
+            // arrange
+            Product p1 = productRepository.save(Product.create(testBrand.getId(), "인기 상품", Money.of(BigDecimal.valueOf(10000))));
+            Product p2 = productRepository.save(Product.create(testBrand.getId(), "보통 상품", Money.of(BigDecimal.valueOf(20000))));
+            Product p3 = productRepository.save(Product.create(testBrand.getId(), "비인기 상품", Money.of(BigDecimal.valueOf(30000))));
+
+            productAppService.increaseLikeCount(p1.getId());
+            productAppService.increaseLikeCount(p1.getId());
+            productAppService.increaseLikeCount(p1.getId());
+
+            productAppService.increaseLikeCount(p2.getId());
+
+            // act
+            ResponseEntity<ApiResponse<ProductDto.BrandProductListResponse>> response = testRestTemplate.exchange(
+                    "/api/v1/brands/" + testBrand.getId() + "/products?page=0",
+                    HttpMethod.GET,
+                    null,
+                    new ParameterizedTypeReference<>() {}
+            );
+
+            // assert
+            assertAll(
+                    () -> assertThat(response.getStatusCode()).isEqualTo(HttpStatus.OK),
+                    () -> assertThat(response.getBody().meta().result()).isEqualTo(ApiResponse.Metadata.Result.SUCCESS),
+                    () -> assertThat(response.getBody().data().products()).hasSize(3),
+                    () -> assertThat(response.getBody().data().products().get(0).productName()).isEqualTo("인기 상품"),
+                    () -> assertThat(response.getBody().data().products().get(0).likeCount()).isEqualTo(3),
+                    () -> assertThat(response.getBody().data().products().get(1).productName()).isEqualTo("보통 상품"),
+                    () -> assertThat(response.getBody().data().products().get(2).productName()).isEqualTo("비인기 상품"),
+                    () -> assertThat(response.getBody().data().totalElements()).isEqualTo(3),
+                    () -> assertThat(response.getBody().data().page()).isEqualTo(0),
+                    () -> assertThat(response.getBody().data().size()).isEqualTo(20)
+            );
+        }
+
+        @DisplayName("브랜드명이 응답 DTO에 포함된다.")
+        @Test
+        void getBrandProducts_includesBrandName() {
+            // arrange
+            productRepository.save(Product.create(testBrand.getId(), "상품", Money.of(BigDecimal.valueOf(10000))));
+
+            // act
+            ResponseEntity<ApiResponse<ProductDto.BrandProductListResponse>> response = testRestTemplate.exchange(
+                    "/api/v1/brands/" + testBrand.getId() + "/products?page=0",
+                    HttpMethod.GET,
+                    null,
+                    new ParameterizedTypeReference<>() {}
+            );
+
+            // assert
+            List<ProductDto.BrandProductResponse> products = response.getBody().data().products();
+            assertThat(products.get(0).brandName()).isEqualTo("테스트 브랜드");
+        }
+
+        @DisplayName("페이징이 정상 동작한다.")
+        @Test
+        void getBrandProducts_paging() {
+            // arrange
+            for (int i = 0; i < 25; i++) {
+                productRepository.save(Product.create(testBrand.getId(), "상품" + i, Money.of(BigDecimal.valueOf(1000))));
+            }
+
+            // act
+            ResponseEntity<ApiResponse<ProductDto.BrandProductListResponse>> response = testRestTemplate.exchange(
+                    "/api/v1/brands/" + testBrand.getId() + "/products?page=1",
+                    HttpMethod.GET,
+                    null,
+                    new ParameterizedTypeReference<>() {}
+            );
+
+            // assert
+            assertAll(
+                    () -> assertThat(response.getStatusCode()).isEqualTo(HttpStatus.OK),
+                    () -> assertThat(response.getBody().data().products()).hasSize(5),
+                    () -> assertThat(response.getBody().data().totalElements()).isEqualTo(25),
+                    () -> assertThat(response.getBody().data().totalPages()).isEqualTo(2)
+            );
+        }
+
+        @DisplayName("존재하지 않는 브랜드 조회 시 404를 반환한다.")
+        @Test
+        void getBrandProducts_notFound() {
+            // act
+            ResponseEntity<ApiResponse<Object>> response = testRestTemplate.exchange(
+                    "/api/v1/brands/999999/products?page=0",
+                    HttpMethod.GET,
+                    null,
+                    new ParameterizedTypeReference<>() {}
+            );
+
+            // assert
+            assertAll(
+                    () -> assertThat(response.getStatusCode()).isEqualTo(HttpStatus.NOT_FOUND),
+                    () -> assertThat(response.getBody().meta().result()).isEqualTo(ApiResponse.Metadata.Result.FAIL)
+            );
+        }
+
+        @DisplayName("허용 범위를 초과한 페이지 요청 시 400을 반환한다.")
+        @Test
+        void getBrandProducts_deepPaging_rejected() {
+            // act
+            ResponseEntity<ApiResponse<Object>> response = testRestTemplate.exchange(
+                    "/api/v1/brands/" + testBrand.getId() + "/products?page=51",
+                    HttpMethod.GET,
+                    null,
+                    new ParameterizedTypeReference<>() {}
+            );
+
+            // assert
+            assertAll(
+                    () -> assertThat(response.getStatusCode()).isEqualTo(HttpStatus.BAD_REQUEST),
+                    () -> assertThat(response.getBody().meta().result()).isEqualTo(ApiResponse.Metadata.Result.FAIL)
+            );
+        }
+    }
+}
diff --git a/modules/jpa/src/main/resources/jpa.yml b/modules/jpa/src/main/resources/jpa.yml
index 37f4fb1b0..2249a5330 100644
--- a/modules/jpa/src/main/resources/jpa.yml
+++ b/modules/jpa/src/main/resources/jpa.yml
@@ -37,7 +37,7 @@ spring:
   jpa:
     show-sql: true
     hibernate:
-      ddl-auto: create
+      ddl-auto: update
 
 datasource:
   mysql-jpa:
diff --git a/modules/redis/src/main/java/com/loopers/config/redis/RedisConfig.java b/modules/redis/src/main/java/com/loopers/config/redis/RedisConfig.java
index 0a2b614ca..a8fbb270e 100644
--- a/modules/redis/src/main/java/com/loopers/config/redis/RedisConfig.java
+++ b/modules/redis/src/main/java/com/loopers/config/redis/RedisConfig.java
@@ -1,7 +1,10 @@
 package com.loopers.config.redis;
 
 
+import io.lettuce.core.ClientOptions;
 import io.lettuce.core.ReadFrom;
+import io.lettuce.core.SocketOptions;
+import io.lettuce.core.TimeoutOptions;
 import org.springframework.beans.factory.annotation.Qualifier;
 import org.springframework.boot.context.properties.EnableConfigurationProperties;
 import org.springframework.context.annotation.Bean;
@@ -13,6 +16,7 @@
 import org.springframework.data.redis.core.RedisTemplate;
 import org.springframework.data.redis.serializer.StringRedisSerializer;
 
+import java.time.Duration;
 import java.util.List;
 import java.util.function.Consumer;
 
@@ -21,6 +25,8 @@
 public class RedisConfig{
     private static final String CONNECTION_MASTER = "redisConnectionMaster";
     public static final String REDIS_TEMPLATE_MASTER = "redisTemplateMaster";
+    private static final Duration COMMAND_TIMEOUT = Duration.ofMillis(500);
+    private static final Duration CONNECT_TIMEOUT = Duration.ofMillis(300);
 
     private final RedisProperties redisProperties;
 
@@ -75,7 +81,17 @@ private LettuceConnectionFactory lettuceConnectionFactory(
             List<RedisNodeInfo> replicas,
             Consumer<LettuceClientConfiguration.LettuceClientConfigurationBuilder> customizer
     ){
-        LettuceClientConfiguration.LettuceClientConfigurationBuilder builder = LettuceClientConfiguration.builder();
+        SocketOptions socketOptions = SocketOptions.builder()
+                .connectTimeout(CONNECT_TIMEOUT)
+                .build();
+        ClientOptions clientOptions = ClientOptions.builder()
+                .socketOptions(socketOptions)
+                .timeoutOptions(TimeoutOptions.enabled(COMMAND_TIMEOUT))
+                .disconnectedBehavior(ClientOptions.DisconnectedBehavior.REJECT_COMMANDS)
+                .build();
+        LettuceClientConfiguration.LettuceClientConfigurationBuilder builder = LettuceClientConfiguration.builder()
+                .commandTimeout(COMMAND_TIMEOUT)
+                .clientOptions(clientOptions);
         if(customizer != null) customizer.accept(builder);
         LettuceClientConfiguration clientConfig = builder.build();
         RedisStaticMasterReplicaConfiguration masterReplicaConfig = new RedisStaticMasterReplicaConfiguration(master.host(), master.port());