diff --git a/.docs/week2/01-requirements.md b/.docs/week2/01-requirements.md
new file mode 100644
index 000000000..3cfd247ba
--- /dev/null
+++ b/.docs/week2/01-requirements.md
@@ -0,0 +1,68 @@
+## US-01 상품 목록 조회
+[유저 스토리]
+- 사용자는 상품 목록을 조회할 수 있다.
+
+[기능 흐름]
+1. 로그인 사용자는 상품 목록을 조회할 수 있다.
+2. 사용자는 특정 브랜드의 상품을 필터링하여 조회할 수 있다. 
+3. 사용자는 정렬 조건(신상품순, 낮은 가격순, 높은 좋아요순)으로 조회할 수 있다.
+4. 상품 목록 조회 시 각 상품의 총 좋아요 수가 포함된다.
+5. 상품 목록은 페이징 처리되어 반환된다. 
+
+## US-02 상품 상세 조회
+[유저 스토리]
+- 사용자는 상품 상세 정보를 조회할 수 있다.
+
+[기능 흐름]
+1. 로그인 사용자는 상품 ID로 특정 상품의 상세 정보를 조회할 수 있다. 
+2. 상품이 존재하면 상품의 총 좋아요 수가 포함된 상품 상세 정보가 반환된다. 
+   - 상품이 존재하지 않으면 404 Not Found 응답을 반환한다.
+
+## US-03 브랜드 정보 조회
+[유저 스토리]
+- 사용자는 브랜드 정보를 조회할 수 있다.
+
+[기능 흐름]
+1. 로그인 사용자는 브랜드 ID로 특정 브랜드 정보를 조회할 수 있다. 
+2. 브랜드가 존재하면 브랜드 정보가 반환된다. 
+   - 브랜드가 존재하지 않으면 404 Not Found 응답을 반환한다.
+
+## US-04 좋아요 등록/취소
+[유저 스토리]
+- 사용자는 각 상품에 한 번만 좋아요를 누를 수 있다.
+- 상품에 대한 좋아요 등록/취소 기능은 멱등하게 동작한다.
+- 사용자는 자신이 좋아요 한 상품 목록을 조회할 수 있다.
+
+[기능 흐름]
+1. 로그인 사용자는 특정 상품에 좋아요 등록 또는 취소를 누를 수 있다. 
+   - 해당 상품이 존재하지 않으면 404 Not Found 응답을 반환한다. 
+2. 상품이 존재하면, 요청에 따라 다음을 수행한다.
+   - 좋아요 등록 요청 시, 좋아요 상태가 아니라면 등록되고 상품의 좋아요 수가 증가한다.
+   - 취소 요청 시, 이미 좋아요한 상태일 때만 취소되고 상품의 좋아요 수가 감소한다.
+3. 사용자는 자신이 좋아요한 상품 목록을 조회할 수 있다.
+
+## US-05 주문 요청
+[유저 스토리]
+- 사용자는 주문을 요청할 수 있다.
+
+[기능 흐름]
+1. 로그인 사용자는 주문할 상품과 각 상품의 수량을 선택한다.
+2. 사용자가 주문을 클릭하면 주문 요청이 전송된다.
+3. 시스템은 아래 케이스를 모두 만족할 경우 상품 재고와 사용자의 포인트를 차감하고 주문을 생성한다.
+   - 주문 상품이 모두 존재하고, 각 상품의 재고가 주문 수량 이상이고, 사용자의 포인트가 총 주문 금액 이상이어야 한다.
+     - 주문상태가 CREATED -> PAID로 변경된다.
+   - 각 조건을 만족하지 못할 경우 각각 404 Not Found, 400 Bad Request, 400 Bad Request 응답을 반환한다.
+     - 주문상태가 CREATED -> CANCELED로 변경된다.
+4. 생성된 주문 정보를 외부 시스템으로 전송한다.
+   - 전송이 실패하면 502 Bad Gateway 응답을 반환한다.
+
+## US-06 주문 목록/상세 조회
+[유저 스토리]
+- 사용자는 자신의 주문 목록을 조회할 수 있다.
+- 사용자는 자신의 주문 상세 정보를 조회할 수 있다.
+
+[기능 흐름]
+1. 로그인 사용자는 자신의 주문 목록을 조회할 수 있다. 
+2. 사용자는 특정 주문 ID로 자신의 주문 상세 정보를 조회할 수 있다. 
+   - 주문이 존재하면 주문 상세 정보가 반환된다. 
+   - 주문이 존재하지 않으면 404 Not Found 응답을 반환한다.
diff --git a/.docs/week2/02-sequence-diagrams.md b/.docs/week2/02-sequence-diagrams.md
new file mode 100644
index 000000000..16b4d4ef0
--- /dev/null
+++ b/.docs/week2/02-sequence-diagrams.md
@@ -0,0 +1,62 @@
+
+```mermaid
+sequenceDiagram
+    title 좋아요 등록 시나리오
+    participant User
+    participant ProductLikeController
+    participant ProductLikeService
+    participant ProductService
+    participant ProductRepository
+    participant ProductLikeRepository
+
+    User->>ProductLikeController: POST /api/v1/like/products/{productId}
+    ProductLikeController->>ProductLikeService: addLike(userId, productId)
+    ProductLikeService->>ProductService: findProduct(productId)
+    ProductService->>ProductRepository: findById(productId)
+
+    alt 상품이 존재하는 경우
+        ProductLikeService->>ProductLikeRepository: exists(userId, productId)
+        
+        alt 사용자가 해당 상품을 처음 좋아요 한 경우
+            ProductLikeService->>ProductLikeRepository: save(userId, productId)
+        end
+    end
+    
+    
+```
+
+
+```mermaid
+sequenceDiagram
+    title 주문 등록 시나리오
+    participant User
+    participant OrderController
+    participant OrderService
+    participant ProductService
+    participant PointService
+    participant OrderRepository
+    participant OrderItemService
+    participant OrderItemRepository
+
+    User->>OrderController: POST /api/v1/orders
+    OrderController->>OrderService: createOrder(order)
+    OrderService->>ProductService: validateOrderable(orderItems)
+
+    alt 각 상품이 존재하고, 주문 수량이 재고 이하인 경우
+        OrderService->>PointService: validatePayable(userId, totalPrice)
+
+        alt 주문 총 금액이 사용자의 보유 포인트 이하인 경우
+            OrderService->>OrderRepository: save(order)
+            
+            OrderService->>OrderItemService: createOrderItems(order, orderItems)
+            OrderItemService->>OrderItemRepository: saveAll(orderItems)
+            
+            OrderService->>ProductService: decreaseStock(orderItems)
+            OrderService->>PointService: usePoint(userId, totalPrice)
+            
+            OrderService->>OrderRepository: changeOrderStatus(orderId, PAID)
+        else
+            OrderService->>OrderRepository: changeOrderStatus(orderId, CANCELED)
+        end
+    end
+```
\ No newline at end of file
diff --git a/.docs/week2/03-class-diagram.md b/.docs/week2/03-class-diagram.md
new file mode 100644
index 000000000..7c985a934
--- /dev/null
+++ b/.docs/week2/03-class-diagram.md
@@ -0,0 +1,54 @@
+```mermaid
+classDiagram
+    class Brand {
+        Long id
+        String name
+    }
+    class Product {
+        Long id
+        Brand brand
+        String name
+        Price price
+        Stock stock
+    }
+    class ProductLike {
+        Long id
+        User user
+        Product product
+        LocalDateTime deletedAt
+    }
+    class User {
+        Long id
+        String loginId
+        String password
+    }
+    class Point {
+        Long id
+        User user
+        int balance
+    }
+    class Order {
+        Long id
+        User user
+    }
+    class OrderItem {
+        Long id
+        Order order
+        Product product
+        int quantity
+        Price itemPrice
+    }
+    
+    class OrderStatus {
+        <<enumeration>>
+        CREATED
+        PAID
+        CANCELED
+    }
+
+    Product --> Brand
+    ProductLike --> Product
+    Point --> User
+    OrderItem --> Order
+    OrderItem --> Product
+```
\ No newline at end of file
diff --git a/.docs/week2/04-erd.md b/.docs/week2/04-erd.md
new file mode 100644
index 000000000..e70f47f43
--- /dev/null
+++ b/.docs/week2/04-erd.md
@@ -0,0 +1,57 @@
+```mermaid
+erDiagram
+brands {
+    bigint id PK
+    varchar name
+}
+products {
+    bigint id PK
+    varchar name
+    bigint brand_id FK
+    Price price
+    Stock stock
+}
+product_likes {
+    bigint user_id PK, FK
+    bigint product_id PK, FK
+    timestamp deleted_at
+}
+product_like_count {
+    bigint product_id PK, FK
+    int total_count
+}
+users {
+    bigint id PK
+    varchar login_id
+    varchar password
+    varchar email
+    varchar birth_date
+    varchar gender
+}
+points {
+    bigint id PK
+    bigint user_id FK 
+    int balance
+}
+orders {
+    bigint id PK
+    bigint user_id FK
+    orderStatus status
+}
+order_items {
+    bigint id PK
+    bigint order_id FK
+    bigint product_id FK
+    int quantity
+    Price item_price
+}
+
+brands ||--o{ products : ""
+users ||--o{ product_likes : ""
+users ||--|| points : ""
+users ||--o{ orders : ""
+orders ||--o{ order_items : ""
+products ||--o{ product_likes : ""
+products ||--|| product_like_count : ""
+order_items ||--|| products : ""
+```
\ No newline at end of file
diff --git a/apps/commerce-api/src/main/java/com/loopers/application/point/PointFacade.java b/apps/commerce-api/src/main/java/com/loopers/application/point/PointFacade.java
new file mode 100644
index 000000000..2659d2ca5
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/application/point/PointFacade.java
@@ -0,0 +1,20 @@
+package com.loopers.application.point;
+
+import com.loopers.domain.point.Point;
+import com.loopers.domain.point.PointService;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Component;
+
+@RequiredArgsConstructor
+@Component
+public class PointFacade {
+    private final PointService pointService;
+
+    public Point getPoint(Long userId) {
+        return pointService.getPointOrThrow(userId);
+    }
+
+    public int chargePoint(Long userId, int amount) {
+        return pointService.chargePoint(userId, amount);
+    }
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/application/user/UserFacade.java b/apps/commerce-api/src/main/java/com/loopers/application/user/UserFacade.java
index c6a7024ba..3ef7fc31d 100644
--- a/apps/commerce-api/src/main/java/com/loopers/application/user/UserFacade.java
+++ b/apps/commerce-api/src/main/java/com/loopers/application/user/UserFacade.java
@@ -1,6 +1,6 @@
 package com.loopers.application.user;
 
-import com.loopers.domain.user.UserModel;
+import com.loopers.domain.user.User;
 import com.loopers.domain.user.UserService;
 import lombok.RequiredArgsConstructor;
 import org.springframework.stereotype.Component;
@@ -10,22 +10,13 @@
 public class UserFacade {
     private final UserService userService;
 
-    public UserInfo createUser(String id, String email, String birthDate, String gender) {
-        UserModel user = userService.createUser(id, email, birthDate, gender);
-        return UserInfo.from(user);
-    }
-
-    public UserInfo getUserById(String id) {
-        UserModel user = userService.getUserById(id);
-        return user != null ? UserInfo.from(user) : null;
-    }
-
-    public Integer getUserPoint(String id) {
-        return userService.getUserPoint(id);
+    public UserInfo signup(User user) {
+        User savedUser = userService.register(user);
+        return UserInfo.from(savedUser);
     }
 
-    public UserInfo chargePoint(String id, Integer amount) {
-        UserModel user = userService.chargePoint(id, amount);
+    public UserInfo getUser(Long id) {
+        User user = userService.findById(id);
         return UserInfo.from(user);
     }
 }
diff --git a/apps/commerce-api/src/main/java/com/loopers/application/user/UserInfo.java b/apps/commerce-api/src/main/java/com/loopers/application/user/UserInfo.java
index c2edb687b..825437af3 100644
--- a/apps/commerce-api/src/main/java/com/loopers/application/user/UserInfo.java
+++ b/apps/commerce-api/src/main/java/com/loopers/application/user/UserInfo.java
@@ -1,16 +1,16 @@
 package com.loopers.application.user;
 
-import com.loopers.domain.user.UserModel;
-import java.time.LocalDate;
+import com.loopers.domain.user.User;
 
-public record UserInfo(String id, String email, LocalDate birthDate, String gender, Integer point) {
-    public static UserInfo from(UserModel model) {
+public record UserInfo(Long id, String loginId, String email, String birthDate, String gender) {
+
+    public static UserInfo from(User user) {
         return new UserInfo(
-            model.getUserId(),
-            model.getEmail(),
-            model.getBirthDate(),
-            model.getGender(),
-            model.getPoint()
+            user.getId(),
+            user.getLoginId(),
+            user.getEmail(),
+            user.getBirthDate(),
+            user.getGender()
         );
     }
 }
diff --git a/apps/commerce-api/src/main/java/com/loopers/domain/point/Point.java b/apps/commerce-api/src/main/java/com/loopers/domain/point/Point.java
new file mode 100644
index 000000000..fe30c5794
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/point/Point.java
@@ -0,0 +1,45 @@
+package com.loopers.domain.point;
+
+import com.loopers.domain.BaseEntity;
+import com.loopers.domain.user.User;
+import com.loopers.support.error.CoreException;
+import com.loopers.support.error.ErrorType;
+import jakarta.persistence.*;
+import lombok.Getter;
+
+@Getter
+@Entity
+@Table(name = "points")
+public class Point extends BaseEntity {
+
+    @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @OneToOne(fetch = FetchType.LAZY, optional = false)
+    @JoinColumn(name = "user_id", nullable = false, unique = true)
+    private User user;
+
+    @Column(nullable = false)
+    private int balance;
+
+    protected Point() {
+    }
+
+    private Point(User user) {
+        this.user = user;
+        this.balance = 0;
+    }
+
+    public static Point create(User user) {
+        return new Point(user);
+    }
+
+    public int increase(int amount) {
+        if (amount <= 0) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "충전 금액은 0보다 커야 합니다.");
+        }
+
+        this.balance += amount;
+        return this.balance;
+    }
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/domain/point/PointRepository.java b/apps/commerce-api/src/main/java/com/loopers/domain/point/PointRepository.java
new file mode 100644
index 000000000..ebb3064fe
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/point/PointRepository.java
@@ -0,0 +1,7 @@
+package com.loopers.domain.point;
+
+import java.util.Optional;
+
+public interface PointRepository {
+    Optional<Point> findByUserId(Long userId);
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/domain/point/PointService.java b/apps/commerce-api/src/main/java/com/loopers/domain/point/PointService.java
new file mode 100644
index 000000000..34132b940
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/point/PointService.java
@@ -0,0 +1,11 @@
+package com.loopers.domain.point;
+
+import java.util.Optional;
+
+public interface PointService {
+    Optional<Integer> findPoint(Long userId);
+
+    Point getPointOrThrow(Long userId);
+
+    int chargePoint(Long userId, int amount);
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/domain/point/PointServiceImpl.java b/apps/commerce-api/src/main/java/com/loopers/domain/point/PointServiceImpl.java
new file mode 100644
index 000000000..86ace44c9
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/point/PointServiceImpl.java
@@ -0,0 +1,35 @@
+package com.loopers.domain.point;
+
+import com.loopers.support.error.CoreException;
+import com.loopers.support.error.ErrorType;
+import jakarta.transaction.Transactional;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+
+import java.util.Optional;
+
+@Service
+@RequiredArgsConstructor
+public class PointServiceImpl implements PointService {
+
+    private final PointRepository pointRepository;
+
+    @Override
+    public Optional<Integer> findPoint(Long userId) {
+        return pointRepository.findByUserId(userId).map(Point::getBalance);
+    }
+
+    @Override
+    public Point getPointOrThrow(Long userId) {
+        return pointRepository.findByUserId(userId).orElseThrow(
+                () -> new CoreException(ErrorType.NOT_FOUND, "포인트 정보가 존재하지 않는 유저입니다.")
+        );
+    }
+
+    @Transactional
+    public int chargePoint(Long userId, int amount) {
+        Point point = getPointOrThrow(userId);
+
+        return point.increase(amount);
+    }
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/domain/user/User.java b/apps/commerce-api/src/main/java/com/loopers/domain/user/User.java
new file mode 100644
index 000000000..b1865dde4
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/user/User.java
@@ -0,0 +1,70 @@
+package com.loopers.domain.user;
+
+import com.loopers.domain.BaseEntity;
+import com.loopers.support.error.CoreException;
+import com.loopers.support.error.ErrorType;
+import jakarta.persistence.*;
+import lombok.Getter;
+
+@Getter
+@Entity
+@Table(name = "users")
+public class User extends BaseEntity {
+
+    @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @Column(nullable = false, unique = true)
+    private String loginId;
+    @Column(nullable = false)
+    private String password;
+
+    @Column(nullable = false, unique = true)
+    private String email;
+    @Column(nullable = false)
+    private String birthDate;    // yyyy-MM-dd
+
+    private String gender;
+
+    protected User() {}
+
+    private User(String loginId, String password, String email, String birthDate, String gender) {
+        this.loginId = loginId;
+        this.password = password;
+        this.email = email;
+        this.birthDate = birthDate;
+        this.gender = gender;
+    }
+
+    public static User create(String loginId, String password, String email, String birthDate, String gender) {
+        validLoginID(loginId);
+        validEmail(email);
+        validBirthDate(birthDate);
+        validGender(gender);
+        return new User(loginId, password, email, birthDate, gender);
+    }
+
+    private static void validBirthDate(String birthDate) {
+        if(!birthDate.matches("^\\d{4}-\\d{2}-\\d{2}$")) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "생년월일 형식이 올바르지 않습니다.");
+        }
+    }
+
+    private static void validEmail(String email) {
+        if (!email.matches("^[\\w.-]+@[\\w.-]+\\.[a-zA-Z]{2,}$")) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "이메일 형식이 올바르지 않습니다.");
+        }
+    }
+
+    private static void validLoginID(String loginId) {
+        if (!loginId.matches("^[a-zA-Z0-9]{1,10}$")) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "ID 형식이 올바르지 않습니다.");
+        }
+    }
+
+    private static void validGender(String gender) {
+        if (gender == null) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "성별 데이터가 존재하지 않습니다.");
+        }
+    }
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/domain/user/UserRepository.java b/apps/commerce-api/src/main/java/com/loopers/domain/user/UserRepository.java
index 0c15a339a..f60174885 100644
--- a/apps/commerce-api/src/main/java/com/loopers/domain/user/UserRepository.java
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/user/UserRepository.java
@@ -3,7 +3,12 @@
 import java.util.Optional;
 
 public interface UserRepository {
-    Optional<UserModel> findById(String id);
-    UserModel save(UserModel user);
-    boolean existsById(String id);
+    Optional<User> findById(Long id);
+
+    Optional<User> findByLoginId(String loginId);
+
+    boolean existsByLoginId(String loginId);
+
+    User save(User user);
+
 }
diff --git a/apps/commerce-api/src/main/java/com/loopers/domain/user/UserService.java b/apps/commerce-api/src/main/java/com/loopers/domain/user/UserService.java
index ecaba8c7c..0eb51c71d 100644
--- a/apps/commerce-api/src/main/java/com/loopers/domain/user/UserService.java
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/user/UserService.java
@@ -1,46 +1,11 @@
 package com.loopers.domain.user;
 
-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.Optional;
 
-@RequiredArgsConstructor
-@Component
-public class UserService {
+public interface UserService {
+    User register(User user);
 
-    private final UserRepository userRepository;
+    Optional<User> findByLoginId(String loginId);
 
-    @Transactional
-    public UserModel createUser(String id, String email, String birthDate, String gender) {
-        if (userRepository.existsById(id)) {
-            throw new CoreException(ErrorType.BAD_REQUEST, "이미 가입된 ID입니다.");
-        }
-        
-        UserModel user = new UserModel(id, email, birthDate, gender);
-        return userRepository.save(user);
-    }
-
-    @Transactional(readOnly = true)
-    public UserModel getUserById(String id) {
-        return userRepository.findById(id)
-            .orElse(null);
-    }
-
-    @Transactional(readOnly = true)
-    public Integer getUserPoint(String id) {
-        UserModel user = userRepository.findById(id)
-            .orElse(null);
-        return user != null ? user.getPoint() : null;
-    }
-
-    @Transactional
-    public UserModel chargePoint(String id, Integer amount) {
-        UserModel user = userRepository.findById(id)
-            .orElseThrow(() -> new CoreException(ErrorType.NOT_FOUND, "사용자를 찾을 수 없습니다."));
-        
-        user.chargePoint(amount);
-        return userRepository.save(user);
-    }
+    User findById(Long id);
 }
diff --git a/apps/commerce-api/src/main/java/com/loopers/domain/user/UserServiceImpl.java b/apps/commerce-api/src/main/java/com/loopers/domain/user/UserServiceImpl.java
new file mode 100644
index 000000000..7de88fe82
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/user/UserServiceImpl.java
@@ -0,0 +1,38 @@
+package com.loopers.domain.user;
+
+import com.loopers.support.error.CoreException;
+import com.loopers.support.error.ErrorType;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+
+import java.util.Optional;
+
+@Service
+@RequiredArgsConstructor
+public class UserServiceImpl implements UserService {
+
+    private final UserRepository userRepository;
+
+    @Override
+    public User register(User user) {
+        if(userRepository.existsByLoginId(user.getLoginId())) {
+            throw new CoreException(ErrorType.CONFLICT, "이미 존재하는 ID입니다.");
+        }
+
+        return userRepository.save(user);
+    }
+
+    @Override
+    public Optional<User> findByLoginId(String loginId) {
+        return userRepository.findByLoginId(loginId);
+    }
+
+    @Override
+    public User findById(Long id) {
+        User user = userRepository.findById(id).orElseThrow(
+                () -> new CoreException(ErrorType.NOT_FOUND, "존재하지 않는 사용자입니다.")
+        );
+        return user;
+    }
+
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/infrastructure/point/PointJpaRepository.java b/apps/commerce-api/src/main/java/com/loopers/infrastructure/point/PointJpaRepository.java
new file mode 100644
index 000000000..e3be92780
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/infrastructure/point/PointJpaRepository.java
@@ -0,0 +1,10 @@
+package com.loopers.infrastructure.point;
+
+import com.loopers.domain.point.Point;
+import org.springframework.data.jpa.repository.JpaRepository;
+
+import java.util.Optional;
+
+public interface PointJpaRepository extends JpaRepository<Point, Long> {
+    Optional<Point> findByUserId(Long userId);
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/infrastructure/point/PointRepositoryImpl.java b/apps/commerce-api/src/main/java/com/loopers/infrastructure/point/PointRepositoryImpl.java
new file mode 100644
index 000000000..03d9e35ae
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/infrastructure/point/PointRepositoryImpl.java
@@ -0,0 +1,19 @@
+package com.loopers.infrastructure.point;
+
+import com.loopers.domain.point.Point;
+import com.loopers.domain.point.PointRepository;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Repository;
+
+import java.util.Optional;
+
+@RequiredArgsConstructor
+@Repository
+public class PointRepositoryImpl implements PointRepository {
+    private final PointJpaRepository pointJpaRepository;
+
+    @Override
+    public Optional<Point> findByUserId(Long userId) {
+        return pointJpaRepository.findByUserId(userId);
+    }
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/infrastructure/user/UserJpaRepository.java b/apps/commerce-api/src/main/java/com/loopers/infrastructure/user/UserJpaRepository.java
index 539fd8c3c..71e687e73 100644
--- a/apps/commerce-api/src/main/java/com/loopers/infrastructure/user/UserJpaRepository.java
+++ b/apps/commerce-api/src/main/java/com/loopers/infrastructure/user/UserJpaRepository.java
@@ -1,9 +1,12 @@
 package com.loopers.infrastructure.user;
 
-import com.loopers.domain.user.UserModel;
+import com.loopers.domain.user.User;
 import org.springframework.data.jpa.repository.JpaRepository;
 
-public interface UserJpaRepository extends JpaRepository<UserModel, Long> {
-    UserModel findByUserId(String userId);
-    boolean existsByUserId(String userId);
+import java.util.Optional;
+
+public interface UserJpaRepository extends JpaRepository<User, Long> {
+    boolean existsByLoginId(String loginId);
+
+    Optional<User> findByLoginId(String loginId);
 }
diff --git a/apps/commerce-api/src/main/java/com/loopers/infrastructure/user/UserRepositoryImpl.java b/apps/commerce-api/src/main/java/com/loopers/infrastructure/user/UserRepositoryImpl.java
index 8c4cf18de..40785bdde 100644
--- a/apps/commerce-api/src/main/java/com/loopers/infrastructure/user/UserRepositoryImpl.java
+++ b/apps/commerce-api/src/main/java/com/loopers/infrastructure/user/UserRepositoryImpl.java
@@ -1,30 +1,35 @@
 package com.loopers.infrastructure.user;
 
-import com.loopers.domain.user.UserModel;
+import com.loopers.domain.user.User;
 import com.loopers.domain.user.UserRepository;
 import lombok.RequiredArgsConstructor;
-import org.springframework.stereotype.Component;
+import org.springframework.stereotype.Repository;
 
 import java.util.Optional;
 
+@Repository
 @RequiredArgsConstructor
-@Component
 public class UserRepositoryImpl implements UserRepository {
     private final UserJpaRepository userJpaRepository;
 
     @Override
-    public Optional<UserModel> findById(String id) {
-        UserModel user = userJpaRepository.findByUserId(id);
-        return Optional.ofNullable(user);
+    public Optional<User> findById(Long id) {
+        return userJpaRepository.findById(id);
     }
 
     @Override
-    public UserModel save(UserModel user) {
-        return userJpaRepository.save(user);
+    public Optional<User> findByLoginId(String loginId) {
+        return userJpaRepository.findByLoginId(loginId);
+    }
+
+    @Override
+    public boolean existsByLoginId(String loginId) {
+        return userJpaRepository.existsByLoginId(loginId);
     }
 
     @Override
-    public boolean existsById(String id) {
-        return userJpaRepository.existsByUserId(id);
+    public User save(User user) {
+        return userJpaRepository.save(user);
     }
+
 }
diff --git a/apps/commerce-api/src/main/java/com/loopers/interfaces/api/ApiControllerAdvice.java b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/ApiControllerAdvice.java
index 20b2809c8..1177513f0 100644
--- a/apps/commerce-api/src/main/java/com/loopers/interfaces/api/ApiControllerAdvice.java
+++ b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/ApiControllerAdvice.java
@@ -8,6 +8,7 @@
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.http.ResponseEntity;
 import org.springframework.http.converter.HttpMessageNotReadableException;
+import org.springframework.web.bind.MissingRequestHeaderException;
 import org.springframework.web.bind.MissingServletRequestParameterException;
 import org.springframework.web.bind.annotation.ExceptionHandler;
 import org.springframework.web.bind.annotation.RestControllerAdvice;
@@ -102,6 +103,11 @@ public ResponseEntity<ApiResponse<?>> handleBadRequest(ServerWebInputException e
         }
     }
 
+    @ExceptionHandler
+    public ResponseEntity<ApiResponse<?>> handleMissingHeader(MissingRequestHeaderException e) {
+        return failureResponse(ErrorType.BAD_REQUEST, e.getMessage());
+    }
+
     @ExceptionHandler
     public ResponseEntity<ApiResponse<?>> handleNotFound(NoResourceFoundException e) {
         return failureResponse(ErrorType.NOT_FOUND, null);
diff --git a/apps/commerce-api/src/main/java/com/loopers/interfaces/api/point/PointV1ApiSpec.java b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/point/PointV1ApiSpec.java
new file mode 100644
index 000000000..c14053c8f
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/point/PointV1ApiSpec.java
@@ -0,0 +1,28 @@
+package com.loopers.interfaces.api.point;
+
+import com.loopers.interfaces.api.ApiResponse;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.media.Schema;
+import io.swagger.v3.oas.annotations.tags.Tag;
+
+@Tag(name = "Point V1 API", description = "Loopers 예시 API 입니다.")
+public interface PointV1ApiSpec {
+
+    @Operation(
+        summary = "포인트 조회",
+        description = "유저 ID로 포인트를 조회합니다."
+    )
+    ApiResponse<PointV1Dto.PointResponse> getPoint(
+        @Schema(name = "유저 ID", description = "포인트 조회할 유저 ID")
+        Long userId
+    );
+
+    @Operation(
+            summary = "포인트 충전",
+            description = "유저 ID의 포인트를 충전합니다."
+    )
+    ApiResponse<PointV1Dto.PointResponse> chargePoint(
+            @Schema(name = "포인트 충전 요청", description = "포인트 충전에 필요한 정보")
+            PointV1Dto.PointChargeRequest request
+    );
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/interfaces/api/point/PointV1Controller.java b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/point/PointV1Controller.java
new file mode 100644
index 000000000..722009d33
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/point/PointV1Controller.java
@@ -0,0 +1,32 @@
+package com.loopers.interfaces.api.point;
+
+import com.loopers.application.point.PointFacade;
+import com.loopers.domain.point.Point;
+import com.loopers.interfaces.api.ApiResponse;
+import lombok.RequiredArgsConstructor;
+import org.springframework.web.bind.annotation.*;
+
+@RequiredArgsConstructor
+@RestController
+@RequestMapping("/api/v1/points")
+public class PointV1Controller implements PointV1ApiSpec {
+
+    private final PointFacade pointFacade;
+
+    @GetMapping
+    @Override
+    public ApiResponse<PointV1Dto.PointResponse> getPoint(@RequestHeader("X-USER-ID") Long userId) {
+        Point point = pointFacade.getPoint(userId);
+        PointV1Dto.PointResponse response = PointV1Dto.PointResponse.from(point.getBalance());
+        return ApiResponse.success(response);
+    }
+
+    @PostMapping("/charge")
+    @Override
+    public ApiResponse<PointV1Dto.PointResponse> chargePoint(@RequestBody PointV1Dto.PointChargeRequest request) {
+
+        int totalPoint = pointFacade.chargePoint(request.userId(), request.amount());
+        PointV1Dto.PointResponse response = PointV1Dto.PointResponse.from(totalPoint);
+        return ApiResponse.success(response);
+    }
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/interfaces/api/point/PointV1Dto.java b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/point/PointV1Dto.java
new file mode 100644
index 000000000..6a4f71dea
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/point/PointV1Dto.java
@@ -0,0 +1,11 @@
+package com.loopers.interfaces.api.point;
+
+public class PointV1Dto {
+    public record PointChargeRequest(Long userId, int amount) { }
+
+    public record PointResponse(int balance) {
+        public static PointResponse from(int balance) {
+            return new PointResponse(balance);
+        }
+    }
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/interfaces/api/user/UserV1ApiSpec.java b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/user/UserV1ApiSpec.java
index b4060293e..e486682fb 100644
--- a/apps/commerce-api/src/main/java/com/loopers/interfaces/api/user/UserV1ApiSpec.java
+++ b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/user/UserV1ApiSpec.java
@@ -5,46 +5,24 @@
 import io.swagger.v3.oas.annotations.media.Schema;
 import io.swagger.v3.oas.annotations.tags.Tag;
 
-@Tag(name = "User V1 API", description = "사용자 관리 API 입니다.")
+@Tag(name = "User V1 API", description = "Loopers 예시 API 입니다.")
 public interface UserV1ApiSpec {
 
     @Operation(
         summary = "회원 가입",
-        description = "새로운 사용자를 등록합니다."
+        description = "유저 정보로 회원 가입"
     )
-    ApiResponse<UserV1Dto.UserResponse> createUser(
+    ApiResponse<UserV1Dto.UserResponse> signup(
         @Schema(name = "회원 가입 요청", description = "회원 가입에 필요한 정보")
-        UserV1Dto.UserCreateRequest request
+        UserV1Dto.SignupRequest request
     );
 
     @Operation(
-        summary = "내 정보 조회",
-        description = "사용자 ID로 회원 정보를 조회합니다."
+            summary = "내 정보 조회",
+            description = "ID값으로 유저 정보 조회"
     )
     ApiResponse<UserV1Dto.UserResponse> getUser(
-        @Schema(name = "사용자 ID", description = "조회할 사용자의 ID")
-        String userId
-    );
-
-    @Operation(
-        summary = "포인트 조회",
-        description = "사용자의 보유 포인트를 조회합니다."
-    )
-    ApiResponse<UserV1Dto.PointResponse> getUserPoint(
-        @Schema(name = "사용자 ID", description = "포인트를 조회할 사용자의 ID")
-        String userId,
-        @Schema(name = "X-USER-ID", description = "사용자 인증을 위한 헤더")
-        String headerUserId
-    );
-
-    @Operation(
-        summary = "포인트 충전",
-        description = "사용자의 포인트를 충전합니다."
-    )
-    ApiResponse<UserV1Dto.PointResponse> chargePoint(
-        @Schema(name = "사용자 ID", description = "포인트를 충전할 사용자의 ID")
-        String userId,
-        @Schema(name = "포인트 충전 요청", description = "충전할 포인트 금액")
-        UserV1Dto.PointChargeRequest request
+            @Schema(name = "내 정보 조회 요청", description = "임시로 ID값으로 유저 정보 조회")
+            Long id
     );
 }
diff --git a/apps/commerce-api/src/main/java/com/loopers/interfaces/api/user/UserV1Controller.java b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/user/UserV1Controller.java
index 7c17c7a09..121648f95 100644
--- a/apps/commerce-api/src/main/java/com/loopers/interfaces/api/user/UserV1Controller.java
+++ b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/user/UserV1Controller.java
@@ -3,10 +3,7 @@
 import com.loopers.application.user.UserFacade;
 import com.loopers.application.user.UserInfo;
 import com.loopers.interfaces.api.ApiResponse;
-import com.loopers.support.error.CoreException;
-import com.loopers.support.error.ErrorType;
 import lombok.RequiredArgsConstructor;
-import org.springframework.http.HttpStatus;
 import org.springframework.web.bind.annotation.*;
 
 @RequiredArgsConstructor
@@ -16,61 +13,18 @@ public class UserV1Controller implements UserV1ApiSpec {
 
     private final UserFacade userFacade;
 
-    @PostMapping
     @Override
-    public ApiResponse<UserV1Dto.UserResponse> createUser(
-        @RequestBody UserV1Dto.UserCreateRequest request
-    ) {
-        if (request.gender() == null || request.gender().isBlank()) {
-            throw new CoreException(ErrorType.BAD_REQUEST, "성별은 필수입니다.");
-        }
-        
-        UserInfo info = userFacade.createUser(request.id(), request.email(), request.birthDate(), request.gender());
-        UserV1Dto.UserResponse response = UserV1Dto.UserResponse.from(info);
+    @PostMapping("/signup")
+    public ApiResponse<UserV1Dto.UserResponse> signup(@RequestBody UserV1Dto.SignupRequest request) {
+        UserInfo userInfo = userFacade.signup(request.toEntity());
+        UserV1Dto.UserResponse response = UserV1Dto.UserResponse.from(userInfo);
         return ApiResponse.success(response);
     }
 
-    @GetMapping("/{userId}")
-    @Override
-    public ApiResponse<UserV1Dto.UserResponse> getUser(
-        @PathVariable String userId
-    ) {
-        UserInfo info = userFacade.getUserById(userId);
-        if (info == null) {
-            throw new CoreException(ErrorType.NOT_FOUND, "사용자를 찾을 수 없습니다.");
-        }
-        
-        UserV1Dto.UserResponse response = UserV1Dto.UserResponse.from(info);
-        return ApiResponse.success(response);
-    }
-
-    @GetMapping("/{userId}/points")
-    @Override
-    public ApiResponse<UserV1Dto.PointResponse> getUserPoint(
-        @PathVariable String userId,
-        @RequestHeader(value = "X-USER-ID", required = false) String headerUserId
-    ) {
-        if (headerUserId == null || headerUserId.isBlank()) {
-            throw new CoreException(ErrorType.BAD_REQUEST, "X-USER-ID 헤더가 필요합니다.");
-        }
-        
-        Integer point = userFacade.getUserPoint(userId);
-        if (point == null) {
-            throw new CoreException(ErrorType.NOT_FOUND, "사용자를 찾을 수 없습니다.");
-        }
-        
-        UserV1Dto.PointResponse response = UserV1Dto.PointResponse.from(point);
-        return ApiResponse.success(response);
-    }
-
-    @PostMapping("/{userId}/points/charge")
-    @Override
-    public ApiResponse<UserV1Dto.PointResponse> chargePoint(
-        @PathVariable String userId,
-        @RequestBody UserV1Dto.PointChargeRequest request
-    ) {
-        UserInfo info = userFacade.chargePoint(userId, request.amount());
-        UserV1Dto.PointResponse response = UserV1Dto.PointResponse.from(info.point());
+    @GetMapping("/{id}")
+    public ApiResponse<UserV1Dto.UserResponse> getUser(@PathVariable Long id) {
+        UserInfo userInfo = userFacade.getUser(id);
+        UserV1Dto.UserResponse response = UserV1Dto.UserResponse.from(userInfo);
         return ApiResponse.success(response);
     }
 }
diff --git a/apps/commerce-api/src/main/java/com/loopers/interfaces/api/user/UserV1Dto.java b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/user/UserV1Dto.java
index 158bf7a65..975654925 100644
--- a/apps/commerce-api/src/main/java/com/loopers/interfaces/api/user/UserV1Dto.java
+++ b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/user/UserV1Dto.java
@@ -1,29 +1,25 @@
 package com.loopers.interfaces.api.user;
 
 import com.loopers.application.user.UserInfo;
-import java.time.LocalDate;
+import com.loopers.domain.user.User;
 
 public class UserV1Dto {
-    
-    public record UserCreateRequest(String id, String email, String birthDate, String gender) {}
-    
-    public record UserResponse(String id, String email, LocalDate birthDate, String gender, Integer point) {
+    public record SignupRequest(String loginId, String password, String email, String birthDate, String gender) {
+        public User toEntity() {
+            return User.create(loginId, password, email, birthDate, gender);
+        }
+    }
+
+    public record UserResponse(Long id, String loginId, String email, String birthDate, String gender) {
         public static UserResponse from(UserInfo info) {
             return new UserResponse(
-                info.id(),
-                info.email(),
-                info.birthDate(),
-                info.gender(),
-                info.point()
+                    info.id(),
+                    info.loginId(),
+                    info.email(),
+                    info.birthDate(),
+                    info.gender()
             );
         }
     }
-    
-    public record PointResponse(Integer point) {
-        public static PointResponse from(Integer point) {
-            return new PointResponse(point);
-        }
-    }
-    
-    public record PointChargeRequest(Integer amount) {}
+
 }
diff --git a/apps/commerce-api/src/test/java/com/loopers/domain/point/PointServiceIntegrationTest.java b/apps/commerce-api/src/test/java/com/loopers/domain/point/PointServiceIntegrationTest.java
new file mode 100644
index 000000000..30d12b85b
--- /dev/null
+++ b/apps/commerce-api/src/test/java/com/loopers/domain/point/PointServiceIntegrationTest.java
@@ -0,0 +1,116 @@
+package com.loopers.domain.point;
+
+import com.loopers.domain.user.User;
+import com.loopers.infrastructure.point.PointJpaRepository;
+import com.loopers.infrastructure.user.UserJpaRepository;
+import com.loopers.support.error.CoreException;
+import com.loopers.support.error.ErrorType;
+import com.loopers.utils.DatabaseCleanUp;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.test.context.bean.override.mockito.MockitoSpyBean;
+
+import java.util.Optional;
+
+import static com.loopers.support.fixture.UserFixtures.createValidUser;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+@SpringBootTest
+class PointServiceIntegrationTest {
+    @Autowired
+    private PointService pointService;
+
+    @MockitoSpyBean
+    private PointJpaRepository pointJpaRepository;
+
+    @Autowired
+    private UserJpaRepository userJpaRepository;
+
+    @Autowired
+    private DatabaseCleanUp databaseCleanUp;
+
+    @AfterEach
+    void tearDown() {
+        databaseCleanUp.truncateAllTables();
+    }
+
+    @DisplayName("포인트를 조회할 때,")
+    @Nested
+    class GetPoint {
+        @DisplayName("해당 ID 의 회원이 존재할 경우, 보유 포인트가 반환된다.")
+        @Test
+        void getPoint_whenUserExists() {
+            // arrange
+            User user = createValidUser();
+            userJpaRepository.save(user);
+
+            Point point = Point.create(user);
+            pointJpaRepository.save(point);
+
+            // act
+            Optional<Integer> balance = pointService.findPoint(user.getId());
+
+            // assert
+            assertThat(balance).isPresent();
+            assertThat(balance.get()).isEqualTo(0);
+        }
+
+        @DisplayName("해당 ID 의 회원이 존재하지 않을 경우, null 이 반환된다.")
+        @Test
+        void getPoint_failsWhenUserNotExists() {
+            // arrange
+            Long invalidId = -1L;
+
+            // act
+            Optional<Integer> balance = pointService.findPoint(invalidId);
+
+            // assert
+            assertThat(balance).isEmpty();
+        }
+
+    }
+
+    @DisplayName("포인트를 충전할 때,")
+    @Nested
+    class ChargePoint {
+
+        @DisplayName("존재하지 않는 유저 ID 로 충전을 시도한 경우, 실패한다.")
+        @Test
+        void chargePoint_failsWhenUserNotExists() {
+            // arrange
+            Long invalidId = -1L;
+
+            // act
+            CoreException result = assertThrows(CoreException.class, () ->
+                    pointService.chargePoint(invalidId, 1000)
+            );
+
+            // assert
+            assertThat(result.getErrorType()).isEqualTo(ErrorType.NOT_FOUND);
+        }
+
+        @DisplayName("존재하는 유저 ID 로 충전하면 성공한다.")
+        @Test
+        void chargePoint_WhenUserExists() {
+            // arrange
+            User user = createValidUser();
+            userJpaRepository.save(user);
+
+            Point point = Point.create(user);
+            pointJpaRepository.save(point);
+
+            // act
+            pointService.chargePoint(user.getId(), 1000);
+            Optional<Integer> balance = pointService.findPoint(user.getId());
+
+            // assert
+            assertThat(balance).isPresent();
+            assertThat(balance.get()).isEqualTo(1000);
+        }
+    }
+}
diff --git a/apps/commerce-api/src/test/java/com/loopers/domain/point/PointTest.java b/apps/commerce-api/src/test/java/com/loopers/domain/point/PointTest.java
new file mode 100644
index 000000000..aa7213404
--- /dev/null
+++ b/apps/commerce-api/src/test/java/com/loopers/domain/point/PointTest.java
@@ -0,0 +1,45 @@
+package com.loopers.domain.point;
+
+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 com.loopers.support.fixture.UserFixtures.createValidUser;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+class PointTest {
+    @DisplayName("포인트를 충전할 때, ")
+    @Nested
+    class Charge {
+        @DisplayName("0 이하의 정수로 포인트를 충전 시 실패한다.")
+        @Test
+        void chargePoint_failsWhenAmountIsZeroOrNegative() {
+            // arrange
+            Point point = Point.create(createValidUser());
+
+            // act + assert
+            CoreException result = assertThrows(CoreException.class, () ->
+                    point.increase(0)
+            );
+
+            assertThat(result.getErrorType()).isEqualTo(ErrorType.BAD_REQUEST);
+        }
+
+        @DisplayName("충전금액이 1 이상일 때, 포인트가 정상 충전된다.")
+        @Test
+        void chargePoint() {
+            // arrange
+            Point point = Point.create(createValidUser());
+            int chargeAmount = 1000;
+
+            // act
+            point.increase(chargeAmount);
+
+            // assert
+            assertThat(point.getBalance()).isEqualTo(chargeAmount);
+        }
+    }
+}
diff --git a/apps/commerce-api/src/test/java/com/loopers/domain/user/UserServiceIntegrationTest.java b/apps/commerce-api/src/test/java/com/loopers/domain/user/UserServiceIntegrationTest.java
index 98e852de9..2fe3292fd 100644
--- a/apps/commerce-api/src/test/java/com/loopers/domain/user/UserServiceIntegrationTest.java
+++ b/apps/commerce-api/src/test/java/com/loopers/domain/user/UserServiceIntegrationTest.java
@@ -10,17 +10,23 @@
 import org.junit.jupiter.api.Test;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.test.context.bean.override.mockito.MockitoSpyBean;
 
+import java.util.Optional;
+
+import static com.loopers.support.fixture.UserFixtures.*;
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
 import static org.junit.jupiter.api.Assertions.assertAll;
-import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.mockito.Mockito.*;
 
 @SpringBootTest
 class UserServiceIntegrationTest {
     @Autowired
     private UserService userService;
 
-    @Autowired
+    @MockitoSpyBean
     private UserJpaRepository userJpaRepository;
 
     @Autowired
@@ -31,186 +37,85 @@ void tearDown() {
         databaseCleanUp.truncateAllTables();
     }
 
-    @DisplayName("회원 가입할 때,")
+    @DisplayName("회원가입 시,")
     @Nested
-    class CreateUser {
-        
-        @DisplayName("유효한 정보로 가입하면, 사용자가 저장된다.")
+    class Signup {
+        @DisplayName("이미 가입된 ID로 시도 시 중복 예외가 발생한다.")
         @Test
-        void savesUser_whenValidInformationIsProvided() {
+        void register_failsWhenLoginIdExists() {
             // arrange
-            String id = "user123";
-            String email = "test@example.com";
-            String birthDate = "1990-01-01";
-            String gender = "M";
+            userJpaRepository.save(createValidUser());
 
-            // act
-            UserModel result = userService.createUser(id, email, birthDate, gender);
+            User duplicateUser = createValidUser();
 
-            // assert
-            assertAll(
-                () -> assertThat(result).isNotNull(),
-                () -> assertThat(result.getUserId()).isEqualTo(id),
-                () -> assertThat(result.getEmail()).isEqualTo(email),
-                () -> assertThat(result.getBirthDate().toString()).isEqualTo(birthDate),
-                () -> assertThat(result.getGender()).isEqualTo(gender),
-                () -> assertThat(result.getPoint()).isEqualTo(0)
-            );
-            
-            // 데이터베이스에 실제로 저장되었는지 확인
-            UserModel savedUser = userJpaRepository.findByUserId(id);
-            assertThat(savedUser).isNotNull();
-            assertThat(savedUser.getUserId()).isEqualTo(id);
-        }
+            // act + assert
+            assertThatThrownBy(() -> userService.register(duplicateUser))
+                    .isInstanceOf(CoreException.class)
+                    .hasMessageContaining("이미 존재하는 ID입니다.")
+                    .extracting("errorType")
+                    .isEqualTo(ErrorType.CONFLICT);
 
-        @DisplayName("이미 가입된 ID로 가입하면, BAD_REQUEST 예외가 발생한다.")
-        @Test
-        void throwsBadRequestException_whenDuplicateIdIsProvided() {
-            // arrange
-            String id = "user123";
-            String email1 = "test1@example.com";
-            String email2 = "test2@example.com";
-            String birthDate = "1990-01-01";
-            String gender = "M";
-
-            // 첫 번째 사용자 가입
-            userService.createUser(id, email1, birthDate, gender);
-
-            // act & assert - 같은 ID로 두 번째 가입 시도
-            CoreException result = assertThrows(CoreException.class, () -> {
-                userService.createUser(id, email2, birthDate, gender);
-            });
-
-            assertThat(result.getErrorType()).isEqualTo(ErrorType.BAD_REQUEST);
-            assertThat(result.getMessage()).contains("이미 가입된 ID입니다");
+            verify(userJpaRepository, times(1)).existsByLoginId("limjaein");
+            verify(userJpaRepository, times(1)).save(any());
         }
-    }
 
-    @DisplayName("사용자 조회할 때,")
-    @Nested
-    class GetUser {
-        
-        @DisplayName("존재하는 사용자 ID를 주면, 해당 사용자 정보를 반환한다.")
+        @DisplayName("User 저장이 수행된다 (Spy 검증)")
         @Test
-        void returnsUserInfo_whenValidIdIsProvided() {
+        void register_whenInputIsValid() {
             // arrange
-            String id = "user123";
-            String email = "test@example.com";
-            String birthDate = "1990-01-01";
-            String gender = "M";
-            
-            UserModel savedUser = userJpaRepository.save(
-                new UserModel(id, email, birthDate, gender)
-            );
+            User user = createValidUser();
 
             // act
-            UserModel result = userService.getUserById(id);
+            User savedUser = userService.register(user);
 
             // assert
-            assertAll(
-                () -> assertThat(result).isNotNull(),
-                () -> assertThat(result.getUserId()).isEqualTo(id),
-                () -> assertThat(result.getEmail()).isEqualTo(email),
-                () -> assertThat(result.getBirthDate().toString()).isEqualTo(birthDate),
-                () -> assertThat(result.getGender()).isEqualTo(gender)
-            );
-        }
+            verify(userJpaRepository, times(1)).save(any(User.class));
 
-        @DisplayName("존재하지 않는 사용자 ID를 주면, null을 반환한다.")
-        @Test
-        void returnsNull_whenInvalidIdIsProvided() {
-            // arrange
-            String invalidId = "nonexistent";
+            User persistedUser = userJpaRepository.findById(savedUser.getId()).orElseThrow();
+            assertEquals(user.getLoginId(), persistedUser.getLoginId());
 
-            // act
-            UserModel result = userService.getUserById(invalidId);
-
-            // assert
-            assertThat(result).isNull();
         }
     }
 
-    @DisplayName("포인트 조회할 때,")
-    @Nested
-    class GetUserPoint {
-        
-        @DisplayName("존재하는 사용자 ID를 주면, 보유 포인트를 반환한다.")
-        @Test
-        void returnsUserPoint_whenValidIdIsProvided() {
-            // arrange
-            String id = "user123";
-            String email = "test@example.com";
-            String birthDate = "1990-01-01";
-            String gender = "M";
-            
-            UserModel savedUser = userJpaRepository.save(
-                new UserModel(id, email, birthDate, gender)
-            );
-
-            // act
-            Integer result = userService.getUserPoint(id);
 
-            // assert
-            assertThat(result).isEqualTo(0);
-        }
-
-        @DisplayName("존재하지 않는 사용자 ID를 주면, null을 반환한다.")
+    @DisplayName("내 정보 조회 시,")
+    @Nested
+    class GetMe {
+        @DisplayName("해당 ID의 회원이 존재할 경우, 회원 정보가 반환된다.")
         @Test
-        void returnsNull_whenInvalidIdIsProvided() {
+        void returnUser_whenLoginIdExists() {
             // arrange
-            String invalidId = "nonexistent";
+            User user = User.create("limjaein", validPassword(), validEmail(), validBirthDate(), validGender());
+            userService.register(user);
 
             // act
-            Integer result = userService.getUserPoint(invalidId);
+            Optional<User> foundUser = userService.findByLoginId("limjaein");
 
             // assert
-            assertThat(result).isNull();
-        }
-    }
-
-    @DisplayName("포인트 충전할 때,")
-    @Nested
-    class ChargePoint {
-        
-        @DisplayName("존재하지 않는 사용자 ID로 충전하면, NOT_FOUND 예외가 발생한다.")
-        @Test
-        void throwsNotFoundException_whenInvalidUserIdIsProvided() {
-            // arrange
-            String invalidId = "nonexistent";
-            Integer amount = 1000;
 
-            // act & assert
-            CoreException result = assertThrows(CoreException.class, () -> {
-                userService.chargePoint(invalidId, amount);
-            });
+            verify(userJpaRepository, times(1)).findByLoginId("limjaein");
 
-            assertThat(result.getErrorType()).isEqualTo(ErrorType.NOT_FOUND);
-            assertThat(result.getMessage()).contains("사용자를 찾을 수 없습니다");
+            assertThat(foundUser).isPresent();
+            assertAll(
+                    () -> assertThat(foundUser.get().getLoginId()).isEqualTo(user.getLoginId()),
+                    () -> assertThat(foundUser.get().getEmail()).isEqualTo(user.getEmail()),
+                    () -> assertThat(foundUser.get().getBirthDate()).isEqualTo(user.getBirthDate()),
+                    () -> assertThat(foundUser.get().getGender()).isEqualTo(user.getGender())
+            );
         }
 
-        @DisplayName("존재하는 사용자에게 포인트를 충전하면, 포인트가 증가한다.")
+        @DisplayName("해당 ID의 회원이 존재하지 않을 경우, null이 반환된다.")
         @Test
-        void increasesPoint_whenValidUserChargesPoint() {
+        void returnNull_whenLoginIdNotExists() {
             // arrange
-            String id = "user123";
-            String email = "test@example.com";
-            String birthDate = "1990-01-01";
-            String gender = "M";
-            Integer chargeAmount = 1000;
-            
-            UserModel savedUser = userJpaRepository.save(
-                new UserModel(id, email, birthDate, gender)
-            );
 
             // act
-            UserModel result = userService.chargePoint(id, chargeAmount);
+            Optional<User> foundUser = userService.findByLoginId("limjaein");
 
             // assert
-            assertThat(result.getPoint()).isEqualTo(1000);
-            
-            // 데이터베이스에서도 확인
-            UserModel updatedUser = userJpaRepository.findByUserId(id);
-            assertThat(updatedUser.getPoint()).isEqualTo(1000);
+
+            verify(userJpaRepository, times(1)).findByLoginId("limjaein");
+            assertThat(foundUser).isEmpty();
         }
     }
 }
diff --git a/apps/commerce-api/src/test/java/com/loopers/domain/user/UserTest.java b/apps/commerce-api/src/test/java/com/loopers/domain/user/UserTest.java
new file mode 100644
index 000000000..ba671c580
--- /dev/null
+++ b/apps/commerce-api/src/test/java/com/loopers/domain/user/UserTest.java
@@ -0,0 +1,75 @@
+package com.loopers.domain.user;
+
+import com.loopers.support.error.CoreException;
+import com.loopers.support.error.ErrorType;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
+
+import static com.loopers.support.fixture.UserFixtures.*;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+@DisplayName("User 생성 시")
+public class UserTest {
+
+    @DisplayName("모든 필드가 유효하면 생성 성공한다.")
+    @Test
+    void createUser() {
+        // act
+        User result = createValidUser();
+
+        // assert
+        assertThat(result).isNotNull();
+        assertThat(result.getLoginId()).isEqualTo(validLoginId());
+        assertThat(result.getPassword()).isEqualTo(validPassword());
+        assertThat(result.getEmail()).isEqualTo(validEmail());
+        assertThat(result.getBirthDate()).isEqualTo(validBirthDate());
+        assertThat(result.getGender()).isEqualTo(validGender());
+
+    }
+
+    @DisplayName("ID 가 영문 및 숫자 10자 이내 형식에 맞지 않으면 실패한다.")
+    @ParameterizedTest
+    @ValueSource(strings = {"qwer1234567890", "아이디", "!@#$%^&*()!@#$%"})
+    void createUser_failsWhenIdHasInvalidFormat(String invalidId) {
+        // arrange
+
+        // act
+        CoreException result = assertThrows(CoreException.class, () ->
+            User.create(invalidId, validPassword(), validEmail(), validBirthDate(), validGender()));
+
+        // assert
+        assertThat(result.getErrorType()).isEqualTo(ErrorType.BAD_REQUEST);
+    }
+
+
+    @DisplayName("이메일이 xx@yy.zz 형식에 맞지 않으면 실패한다.")
+    @ParameterizedTest
+    @ValueSource(strings = {"email", "email@navercom", "email@naver.", "@naver.com"})
+    void createUser_failsWhenEmailHasInvalidFormat(String invalidEmail) {
+        // arrange
+
+        // act
+        CoreException result = assertThrows(CoreException.class, () ->
+                User.create(validLoginId(), validPassword(), invalidEmail, validBirthDate(), validGender()));
+
+        // assert
+        assertThat(result.getErrorType()).isEqualTo(ErrorType.BAD_REQUEST);
+    }
+
+    @DisplayName("생년월일이 yyyy-MM-dd 형식에 맞지 않으면 실패한다.")
+    @ParameterizedTest
+    @ValueSource(strings = {"19961127", "1996-1127", "199611-27", "19-96-11-27"})
+    void createUser_failsWhenBirthDateHasInvalidFormat(String invalidBirthDate) {
+        // arrange
+
+        // act
+        CoreException result = assertThrows(CoreException.class, () ->
+                User.create(validLoginId(), validPassword(), validEmail(), invalidBirthDate, validGender()));
+
+        // assert
+        assertThat(result.getErrorType()).isEqualTo(ErrorType.BAD_REQUEST);
+    }
+}
diff --git a/apps/commerce-api/src/test/java/com/loopers/interfaces/api/PointV1ApiE2ETest.java b/apps/commerce-api/src/test/java/com/loopers/interfaces/api/PointV1ApiE2ETest.java
new file mode 100644
index 000000000..10c9b36ee
--- /dev/null
+++ b/apps/commerce-api/src/test/java/com/loopers/interfaces/api/PointV1ApiE2ETest.java
@@ -0,0 +1,149 @@
+package com.loopers.interfaces.api;
+
+import com.loopers.domain.point.Point;
+import com.loopers.domain.user.User;
+import com.loopers.infrastructure.point.PointJpaRepository;
+import com.loopers.infrastructure.user.UserJpaRepository;
+import com.loopers.interfaces.api.example.ExampleV1Dto;
+import com.loopers.interfaces.api.point.PointV1Dto;
+import com.loopers.utils.DatabaseCleanUp;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.boot.test.web.client.TestRestTemplate;
+import org.springframework.core.ParameterizedTypeReference;
+import org.springframework.http.*;
+
+import static com.loopers.support.fixture.UserFixtures.createValidUser;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertAll;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
+class PointV1ApiE2ETest {
+
+    private static final String ENDPOINT_GET = "/api/v1/points";
+    private static final String ENDPOINT_POST = "/api/v1/points/charge";
+
+    private final TestRestTemplate testRestTemplate;
+    private final PointJpaRepository pointJpaRepository;
+    private final UserJpaRepository userJpaRepository;
+    private final DatabaseCleanUp databaseCleanUp;
+
+    @Autowired
+    public PointV1ApiE2ETest(
+        TestRestTemplate testRestTemplate,
+        PointJpaRepository pointJpaRepository,
+        UserJpaRepository userJpaRepository,
+        DatabaseCleanUp databaseCleanUp
+    ) {
+        this.testRestTemplate = testRestTemplate;
+        this.pointJpaRepository = pointJpaRepository;
+        this.userJpaRepository = userJpaRepository;
+        this.databaseCleanUp = databaseCleanUp;
+    }
+
+    @AfterEach
+    void tearDown() {
+        databaseCleanUp.truncateAllTables();
+    }
+
+    @DisplayName("GET /api/v1/points")
+    @Nested
+    class Get {
+        @DisplayName("포인트 조회에 성공할 경우, 보유 포인트를 응답으로 반환한다.")
+        @Test
+        void returnsPoint_whenValidUserIdIsProvided() {
+            // arrange
+            User user = userJpaRepository.save(createValidUser());
+            Point point = pointJpaRepository.save(Point.create(user));
+
+            HttpHeaders headers = new HttpHeaders();
+            headers.set("X-USER-ID", String.valueOf(user.getId()));
+
+            // act
+            ParameterizedTypeReference<ApiResponse<PointV1Dto.PointResponse>> responseType = new ParameterizedTypeReference<>() {};
+            ResponseEntity<ApiResponse<PointV1Dto.PointResponse>> response =
+                testRestTemplate.exchange(ENDPOINT_GET, HttpMethod.GET, new HttpEntity<>(headers), responseType);
+
+            // assert
+            assertThat(response.getBody()).isNotNull();
+            assertAll(
+                () -> assertTrue(response.getStatusCode().is2xxSuccessful()),
+                () -> assertThat(response.getBody().data().balance()).isEqualTo(point.getBalance())
+            );
+        }
+
+        @DisplayName("X-USER-ID 헤더가 없을 경우, 400 Bad Request 응답을 반환한다.")
+        @Test
+        void throwsBadRequest_whenXUserIdNotProvided() {
+            // arrange
+
+            // act
+            ParameterizedTypeReference<ApiResponse<ExampleV1Dto.ExampleResponse>> responseType = new ParameterizedTypeReference<>() {};
+            ResponseEntity<ApiResponse<ExampleV1Dto.ExampleResponse>> response =
+                testRestTemplate.exchange(ENDPOINT_GET, HttpMethod.GET, new HttpEntity<>(null), responseType);
+
+            // assert
+            assertAll(
+                () -> assertTrue(response.getStatusCode().is4xxClientError()),
+                () -> assertThat(response.getStatusCode()).isEqualTo(HttpStatus.BAD_REQUEST)
+            );
+        }
+    }
+
+
+    @DisplayName("POST /api/v1/points/charge")
+    @Nested
+    class Charge {
+        @DisplayName("존재하는 유저가 1000원을 충전할 경우, 충전된 보유 총량을 응답으로 반환한다.")
+        @Test
+        void returnsTotalPoint_whenUserChargesPoint() {
+            // arrange
+            User user = userJpaRepository.save(createValidUser());
+            Point point = pointJpaRepository.save(Point.create(user));
+
+            PointV1Dto.PointChargeRequest requestDto = new PointV1Dto.PointChargeRequest(
+                    user.getId(),
+                    1000
+            );
+
+            // act
+            ParameterizedTypeReference<ApiResponse<PointV1Dto.PointResponse>> responseType = new ParameterizedTypeReference<>() {};
+            ResponseEntity<ApiResponse<PointV1Dto.PointResponse>> response =
+                    testRestTemplate.exchange(ENDPOINT_POST, HttpMethod.POST, new HttpEntity<>(requestDto), responseType);
+
+            // assert
+            assertThat(response.getBody()).isNotNull();
+            assertAll(
+                    () -> assertTrue(response.getStatusCode().is2xxSuccessful()),
+                    () -> assertThat(response.getBody().data().balance()).isEqualTo(1000)
+            );
+        }
+
+        @DisplayName("존재하지 않는 유저로 요청할 경우, 404 Not Found 응답을 반환한다.")
+        @Test
+        void throwsNotFound_failsWhenUserNotExists() {
+            // arrange
+
+            PointV1Dto.PointChargeRequest requestDto = new PointV1Dto.PointChargeRequest(
+                    -1L,
+                    1000
+            );
+
+            // act
+            ParameterizedTypeReference<ApiResponse<ExampleV1Dto.ExampleResponse>> responseType = new ParameterizedTypeReference<>() {};
+            ResponseEntity<ApiResponse<ExampleV1Dto.ExampleResponse>> response =
+                    testRestTemplate.exchange(ENDPOINT_POST, HttpMethod.POST, new HttpEntity<>(requestDto), responseType);
+
+            // assert
+            assertAll(
+                    () -> assertTrue(response.getStatusCode().is4xxClientError()),
+                    () -> assertThat(response.getStatusCode()).isEqualTo(HttpStatus.NOT_FOUND)
+            );
+        }
+    }
+}
diff --git a/apps/commerce-api/src/test/java/com/loopers/interfaces/api/UserV1ApiE2ETest.java b/apps/commerce-api/src/test/java/com/loopers/interfaces/api/UserV1ApiE2ETest.java
index dfd8489bf..97ba225fd 100644
--- a/apps/commerce-api/src/test/java/com/loopers/interfaces/api/UserV1ApiE2ETest.java
+++ b/apps/commerce-api/src/test/java/com/loopers/interfaces/api/UserV1ApiE2ETest.java
@@ -1,6 +1,6 @@
 package com.loopers.interfaces.api;
 
-import com.loopers.domain.user.UserModel;
+import com.loopers.domain.user.User;
 import com.loopers.infrastructure.user.UserJpaRepository;
 import com.loopers.interfaces.api.user.UserV1Dto;
 import com.loopers.utils.DatabaseCleanUp;
@@ -13,13 +13,13 @@
 import org.springframework.boot.test.web.client.TestRestTemplate;
 import org.springframework.core.ParameterizedTypeReference;
 import org.springframework.http.HttpEntity;
-import org.springframework.http.HttpHeaders;
 import org.springframework.http.HttpMethod;
 import org.springframework.http.HttpStatus;
 import org.springframework.http.ResponseEntity;
 
 import java.util.function.Function;
 
+import static com.loopers.support.fixture.UserFixtures.*;
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.junit.jupiter.api.Assertions.assertAll;
 import static org.junit.jupiter.api.Assertions.assertTrue;
@@ -27,9 +27,8 @@
 @SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
 class UserV1ApiE2ETest {
 
-    private static final Function<String, String> ENDPOINT_GET_USER = id -> "/api/v1/users/" + id;
-    private static final Function<String, String> ENDPOINT_GET_POINT = id -> "/api/v1/users/" + id + "/points";
-    private static final Function<String, String> ENDPOINT_CHARGE_POINT = id -> "/api/v1/users/" + id + "/points/charge";
+    private static final Function<Long, String> ENDPOINT_GET = id -> "/api/v1/users/" + id;
+    private static final String ENDPOINT_POST = "/api/v1/users/signup";
 
     private final TestRestTemplate testRestTemplate;
     private final UserJpaRepository userJpaRepository;
@@ -51,48 +50,53 @@ void tearDown() {
         databaseCleanUp.truncateAllTables();
     }
 
-    @DisplayName("POST /api/v1/users")
+    @DisplayName("POST /api/v1/users/signup")
     @Nested
-    class CreateUser {
-        
-        @DisplayName("회원 가입이 성공할 경우, 생성된 유저 정보를 응답으로 반환한다.")
+    class Signup {
+        @DisplayName("회원가입이 성공할 경우, 생성된 유저 정보를 응답으로 반환한다.")
         @Test
-        void returnsCreatedUserInfo_whenUserRegistrationSucceeds() {
+        void returnsUserInfo_whenSignupSucceeds() {
             // arrange
-            UserV1Dto.UserCreateRequest request = new UserV1Dto.UserCreateRequest(
-                "user123", "test@example.com", "1990-01-01", "M"
+            UserV1Dto.SignupRequest requestDto = new UserV1Dto.SignupRequest(
+                    validLoginId(),
+                    validPassword(),
+                    validEmail(),
+                    validBirthDate(),
+                    validGender()
             );
-            HttpEntity<UserV1Dto.UserCreateRequest> httpEntity = new HttpEntity<>(request);
 
             // act
             ParameterizedTypeReference<ApiResponse<UserV1Dto.UserResponse>> responseType = new ParameterizedTypeReference<>() {};
             ResponseEntity<ApiResponse<UserV1Dto.UserResponse>> response =
-                testRestTemplate.exchange("/api/v1/users", HttpMethod.POST, httpEntity, responseType);
+                testRestTemplate.exchange(ENDPOINT_POST, HttpMethod.POST, new HttpEntity<>(requestDto), responseType);
 
             // assert
+            assertThat(response.getBody()).isNotNull();
             assertAll(
                 () -> assertTrue(response.getStatusCode().is2xxSuccessful()),
-                () -> assertThat(response.getBody().data().id()).isEqualTo("user123"),
-                () -> assertThat(response.getBody().data().email()).isEqualTo("test@example.com"),
-                () -> assertThat(response.getBody().data().birthDate().toString()).isEqualTo("1990-01-01"),
-                () -> assertThat(response.getBody().data().gender()).isEqualTo("M"),
-                () -> assertThat(response.getBody().data().point()).isEqualTo(0)
+                () -> assertThat(response.getBody().data().loginId()).isEqualTo(validLoginId()),
+                () -> assertThat(response.getBody().data().email()).isEqualTo(validEmail()),
+                () -> assertThat(response.getBody().data().birthDate()).isEqualTo(validBirthDate()),
+                () -> assertThat(response.getBody().data().gender()).isEqualTo(validGender())
             );
         }
 
-        @DisplayName("회원 가입 시에 성별이 없을 경우, 400 Bad Request 응답을 반환한다.")
+        @DisplayName("회원가입 시에 성별이 없을 경우, 400 BAD_REQUEST 응답을 반환한다.")
         @Test
-        void returnsBadRequest_whenGenderIsMissing() {
+        void throwsBadRequest_whenGenderIsNotProvided() {
             // arrange
-            UserV1Dto.UserCreateRequest request = new UserV1Dto.UserCreateRequest(
-                "user123", "test@example.com", "1990-01-01", null
+            UserV1Dto.SignupRequest requestDto = new UserV1Dto.SignupRequest(
+                    validLoginId(),
+                    validPassword(),
+                    validEmail(),
+                    validBirthDate(),
+                    null
             );
-            HttpEntity<UserV1Dto.UserCreateRequest> httpEntity = new HttpEntity<>(request);
 
             // act
             ParameterizedTypeReference<ApiResponse<UserV1Dto.UserResponse>> responseType = new ParameterizedTypeReference<>() {};
             ResponseEntity<ApiResponse<UserV1Dto.UserResponse>> response =
-                testRestTemplate.exchange("/api/v1/users", HttpMethod.POST, httpEntity, responseType);
+                testRestTemplate.exchange(ENDPOINT_POST, HttpMethod.POST, new HttpEntity<>(requestDto), responseType);
 
             // assert
             assertAll(
@@ -102,148 +106,50 @@ void returnsBadRequest_whenGenderIsMissing() {
         }
     }
 
-    @DisplayName("GET /api/v1/users/{userId}")
+    @DisplayName("GET /api/v1/users/{id}")
     @Nested
-    class GetUser {
-        
+    class GetMe {
         @DisplayName("내 정보 조회에 성공할 경우, 해당하는 유저 정보를 응답으로 반환한다.")
         @Test
-        void returnsUserInfo_whenUserExists() {
+        void returnsUserInfo_whenGetMeSucceeds() {
             // arrange
-            UserModel savedUser = userJpaRepository.save(
-                new UserModel("user123", "test@example.com", "1990-01-01", "M")
+            User user = userJpaRepository.save(
+                    User.create(validLoginId(), validPassword(), validEmail(), validBirthDate(), validGender())
             );
-            String requestUrl = ENDPOINT_GET_USER.apply("user123");
+            String requestUrl = ENDPOINT_GET.apply(user.getId());
 
             // act
             ParameterizedTypeReference<ApiResponse<UserV1Dto.UserResponse>> responseType = new ParameterizedTypeReference<>() {};
             ResponseEntity<ApiResponse<UserV1Dto.UserResponse>> response =
-                testRestTemplate.exchange(requestUrl, HttpMethod.GET, new HttpEntity<>(null), responseType);
+                    testRestTemplate.exchange(requestUrl, HttpMethod.GET, new HttpEntity<>(null), responseType);
 
             // assert
+            assertThat(response.getBody()).isNotNull();
             assertAll(
-                () -> assertTrue(response.getStatusCode().is2xxSuccessful()),
-                () -> assertThat(response.getBody().data().id()).isEqualTo("user123"),
-                () -> assertThat(response.getBody().data().email()).isEqualTo("test@example.com"),
-                () -> assertThat(response.getBody().data().birthDate().toString()).isEqualTo("1990-01-01"),
-                () -> assertThat(response.getBody().data().gender()).isEqualTo("M"),
-                () -> assertThat(response.getBody().data().point()).isEqualTo(0)
+                    () -> assertTrue(response.getStatusCode().is2xxSuccessful()),
+                    () -> assertThat(response.getBody().data().loginId()).isEqualTo(validLoginId()),
+                    () -> assertThat(response.getBody().data().email()).isEqualTo(validEmail()),
+                    () -> assertThat(response.getBody().data().birthDate()).isEqualTo(validBirthDate()),
+                    () -> assertThat(response.getBody().data().gender()).isEqualTo(validGender())
             );
         }
 
-        @DisplayName("존재하지 않는 ID로 조회할 경우, 404 Not Found 응답을 반환한다.")
+        @DisplayName("존재하지 않는 ID 로 조회할 경우, 404 Not Found 응답을 반환한다.")
         @Test
-        void returnsNotFound_whenUserDoesNotExist() {
-            // arrange
-            String requestUrl = ENDPOINT_GET_USER.apply("nonexistent");
+        void throwsNotFound_whenLoginIdIsNotProvided() {
+
+            Long invalidId = -1L;
+            String requestUrl = ENDPOINT_GET.apply(invalidId);
 
             // act
             ParameterizedTypeReference<ApiResponse<UserV1Dto.UserResponse>> responseType = new ParameterizedTypeReference<>() {};
             ResponseEntity<ApiResponse<UserV1Dto.UserResponse>> response =
-                testRestTemplate.exchange(requestUrl, HttpMethod.GET, new HttpEntity<>(null), responseType);
-
-            // assert
-            assertAll(
-                () -> assertTrue(response.getStatusCode().is4xxClientError()),
-                () -> assertThat(response.getStatusCode()).isEqualTo(HttpStatus.NOT_FOUND)
-            );
-        }
-    }
-
-    @DisplayName("GET /api/v1/users/{userId}/points")
-    @Nested
-    class GetUserPoint {
-        
-        @DisplayName("포인트 조회에 성공할 경우, 보유 포인트를 응답으로 반환한다.")
-        @Test
-        void returnsUserPoint_whenUserExists() {
-            // arrange
-            UserModel savedUser = userJpaRepository.save(
-                new UserModel("user123", "test@example.com", "1990-01-01", "M")
-            );
-            String requestUrl = ENDPOINT_GET_POINT.apply("user123");
-            
-            HttpHeaders headers = new HttpHeaders();
-            headers.set("X-USER-ID", "user123");
-            HttpEntity<String> httpEntity = new HttpEntity<>(null, headers);
-
-            // act
-            ParameterizedTypeReference<ApiResponse<UserV1Dto.PointResponse>> responseType = new ParameterizedTypeReference<>() {};
-            ResponseEntity<ApiResponse<UserV1Dto.PointResponse>> response =
-                testRestTemplate.exchange(requestUrl, HttpMethod.GET, httpEntity, responseType);
-
-            // assert
-            assertAll(
-                () -> assertTrue(response.getStatusCode().is2xxSuccessful()),
-                () -> assertThat(response.getBody().data().point()).isEqualTo(0)
-            );
-        }
-
-        @DisplayName("X-USER-ID 헤더가 없을 경우, 400 Bad Request 응답을 반환한다.")
-        @Test
-        void returnsBadRequest_whenXUserIdHeaderIsMissing() {
-            // arrange
-            String requestUrl = ENDPOINT_GET_POINT.apply("user123");
-
-            // act
-            ParameterizedTypeReference<ApiResponse<UserV1Dto.PointResponse>> responseType = new ParameterizedTypeReference<>() {};
-            ResponseEntity<ApiResponse<UserV1Dto.PointResponse>> response =
-                testRestTemplate.exchange(requestUrl, HttpMethod.GET, new HttpEntity<>(null), responseType);
+                    testRestTemplate.exchange(requestUrl, HttpMethod.GET, new HttpEntity<>(null), responseType);
 
             // assert
             assertAll(
-                () -> assertTrue(response.getStatusCode().is4xxClientError()),
-                () -> assertThat(response.getStatusCode()).isEqualTo(HttpStatus.BAD_REQUEST)
-            );
-        }
-    }
-
-    @DisplayName("POST /api/v1/users/{userId}/points/charge")
-    @Nested
-    class ChargePoint {
-        
-        @DisplayName("존재하는 유저가 1000원을 충전할 경우, 충전된 보유 총량을 응답으로 반환한다.")
-        @Test
-        void returnsChargedPoint_whenValidUserChargesPoint() {
-            // arrange
-            UserModel savedUser = userJpaRepository.save(
-                new UserModel("user123", "test@example.com", "1990-01-01", "M")
-            );
-            String requestUrl = ENDPOINT_CHARGE_POINT.apply("user123");
-            
-            UserV1Dto.PointChargeRequest request = new UserV1Dto.PointChargeRequest(1000);
-            HttpEntity<UserV1Dto.PointChargeRequest> httpEntity = new HttpEntity<>(request);
-
-            // act
-            ParameterizedTypeReference<ApiResponse<UserV1Dto.PointResponse>> responseType = new ParameterizedTypeReference<>() {};
-            ResponseEntity<ApiResponse<UserV1Dto.PointResponse>> response =
-                testRestTemplate.exchange(requestUrl, HttpMethod.POST, httpEntity, responseType);
-
-            // assert
-            assertAll(
-                () -> assertTrue(response.getStatusCode().is2xxSuccessful()),
-                () -> assertThat(response.getBody().data().point()).isEqualTo(1000)
-            );
-        }
-
-        @DisplayName("존재하지 않는 유저로 요청할 경우, 404 Not Found 응답을 반환한다.")
-        @Test
-        void returnsNotFound_whenUserDoesNotExist() {
-            // arrange
-            String requestUrl = ENDPOINT_CHARGE_POINT.apply("nonexistent");
-            
-            UserV1Dto.PointChargeRequest request = new UserV1Dto.PointChargeRequest(1000);
-            HttpEntity<UserV1Dto.PointChargeRequest> httpEntity = new HttpEntity<>(request);
-
-            // act
-            ParameterizedTypeReference<ApiResponse<UserV1Dto.PointResponse>> responseType = new ParameterizedTypeReference<>() {};
-            ResponseEntity<ApiResponse<UserV1Dto.PointResponse>> response =
-                testRestTemplate.exchange(requestUrl, HttpMethod.POST, httpEntity, responseType);
-
-            // assert
-            assertAll(
-                () -> assertTrue(response.getStatusCode().is4xxClientError()),
-                () -> assertThat(response.getStatusCode()).isEqualTo(HttpStatus.NOT_FOUND)
+                    () -> assertTrue(response.getStatusCode().is4xxClientError()),
+                    () -> assertThat(response.getStatusCode()).isEqualTo(HttpStatus.NOT_FOUND)
             );
         }
     }
diff --git a/apps/commerce-api/src/test/java/com/loopers/support/fixture/UserFixtures.java b/apps/commerce-api/src/test/java/com/loopers/support/fixture/UserFixtures.java
new file mode 100644
index 000000000..6ea41247f
--- /dev/null
+++ b/apps/commerce-api/src/test/java/com/loopers/support/fixture/UserFixtures.java
@@ -0,0 +1,24 @@
+package com.loopers.support.fixture;
+
+import com.loopers.domain.user.User;
+
+public final class UserFixtures {
+
+    private UserFixtures() {} // 인스턴스 생성 방지
+
+    public static String validLoginId() { return "limjaein"; }
+    public static String validPassword() { return "limjaein!@3"; }
+    public static String validEmail() { return "limjaein@google.com"; }
+    public static String validBirthDate() { return "1996-11-27"; }
+    public static String validGender() { return "F"; }
+
+    public static User createValidUser() {
+        return User.create(
+                validLoginId(),
+                validPassword(),
+                validEmail(),
+                validBirthDate(),
+                validGender()
+        );
+    }
+}
