diff --git a/.codeguide/loopers-1-week.md b/.codeguide/loopers-1-week.md
deleted file mode 100644
index a8ace53e..00000000
--- a/.codeguide/loopers-1-week.md
+++ /dev/null
@@ -1,45 +0,0 @@
-## 🧪 Implementation Quest
-
-> 지정된 **단위 테스트 / 통합 테스트 / E2E 테스트 케이스**를 필수로 구현하고, 모든 테스트를 통과시키는 것을 목표로 합니다.
-
-### 회원 가입
-
-**🧱 단위 테스트**
-
-- [ ]  ID 가 `영문 및 숫자 10자 이내` 형식에 맞지 않으면, User 객체 생성에 실패한다.
-- [ ]  이메일이 `xx@yy.zz` 형식에 맞지 않으면, User 객체 생성에 실패한다.
-- [ ]  생년월일이 `yyyy-MM-dd` 형식에 맞지 않으면, User 객체 생성에 실패한다.
-
-**🔗 통합 테스트**
-
-- [ ]  회원 가입시 User 저장이 수행된다. ( spy 검증 )
-- [ ]  이미 가입된 ID 로 회원가입 시도 시, 실패한다.
-
-**🌐 E2E 테스트**
-
-- [ ]  회원 가입이 성공할 경우, 생성된 유저 정보를 응답으로 반환한다.
-- [ ]  회원 가입 시에 성별이 없을 경우, `400 Bad Request` 응답을 반환한다.
-
-### 내 정보 조회
-
-**🔗 통합 테스트**
-
-- [ ]  해당 ID 의 회원이 존재할 경우, 회원 정보가 반환된다.
-- [ ]  해당 ID 의 회원이 존재하지 않을 경우, null 이 반환된다.
-
-**🌐 E2E 테스트**
-
-- [ ]  내 정보 조회에 성공할 경우, 해당하는 유저 정보를 응답으로 반환한다.
-- [ ]  존재하지 않는 ID 로 조회할 경우, `404 Not Found` 응답을 반환한다.
-
-### 포인트 조회
-
-**🔗 통합 테스트**
-
-- [ ]  해당 ID 의 회원이 존재할 경우, 보유 포인트가 반환된다.
-- [ ]  해당 ID 의 회원이 존재하지 않을 경우, null 이 반환된다.
-
-**🌐 E2E 테스트**
-
-- [ ]  포인트 조회에 성공할 경우, 보유 포인트를 응답으로 반환한다.
-- [ ]  `X-USER-ID` 헤더가 없을 경우, `400 Bad Request` 응답을 반환한다.
diff --git a/apps/commerce-api/build.gradle.kts b/apps/commerce-api/build.gradle.kts
index 03ce68f0..cb54a44b 100644
--- a/apps/commerce-api/build.gradle.kts
+++ b/apps/commerce-api/build.gradle.kts
@@ -8,6 +8,7 @@ dependencies {
 
     // web
     implementation("org.springframework.boot:spring-boot-starter-web")
+    implementation("org.springframework.security:spring-security-crypto")
     implementation("org.springframework.boot:spring-boot-starter-actuator")
     implementation("org.springdoc:springdoc-openapi-starter-webmvc-ui:${project.properties["springDocOpenApiVersion"]}")
 
diff --git a/apps/commerce-api/src/main/java/com/loopers/application/user/SignUpCommand.java b/apps/commerce-api/src/main/java/com/loopers/application/user/SignUpCommand.java
new file mode 100644
index 00000000..12eef0a4
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/application/user/SignUpCommand.java
@@ -0,0 +1,23 @@
+package com.loopers.application.user;
+
+import com.loopers.interfaces.api.user.dto.UserV1Dto;
+
+import java.time.LocalDate;
+
+public record SignUpCommand(
+        String loginId,
+        String password,
+        String name,
+        LocalDate birthDate,
+        String email
+) {
+    public static SignUpCommand from(UserV1Dto.CreateRequest request) {
+        return new SignUpCommand(
+                request.loginId(),
+                request.password(),
+                request.name(),
+                request.birthDate(),
+                request.email()
+        );
+    }
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/application/user/UpdatePasswordCommand.java b/apps/commerce-api/src/main/java/com/loopers/application/user/UpdatePasswordCommand.java
new file mode 100644
index 00000000..ebf9f0f5
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/application/user/UpdatePasswordCommand.java
@@ -0,0 +1,13 @@
+package com.loopers.application.user;
+
+import com.loopers.interfaces.api.user.dto.UserV1Dto;
+
+public record UpdatePasswordCommand(
+    String loginId,
+    String currentPassword,
+    String newPassword
+) {
+    public static UpdatePasswordCommand from(String loginId, String currentPassword, UserV1Dto.UpdatePasswordRequest request) {
+        return new UpdatePasswordCommand(loginId, currentPassword, request.newPassword());
+    }
+}
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
new file mode 100644
index 00000000..abc8599e
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/application/user/UserInfo.java
@@ -0,0 +1,23 @@
+package com.loopers.application.user;
+
+import com.loopers.domain.user.User;
+
+import java.time.LocalDate;
+
+public record UserInfo(String loginId, String name, LocalDate birthDate, String email) {
+    public static UserInfo from(User user) {
+        return new UserInfo(
+            user.getLoginId(),
+            maskLastChar(user.getName()),
+            user.getBirthDate(),
+            user.getEmail()
+        );
+    }
+
+    private static String maskLastChar(String name) {
+        if (name == null || name.isBlank()) return name;
+        if (name.length() == 1) return "*";
+
+        return name.substring(0, name.length() - 1) + "*";
+    }
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/domain/user/PasswordEncoder.java b/apps/commerce-api/src/main/java/com/loopers/domain/user/PasswordEncoder.java
new file mode 100644
index 00000000..30ea71ff
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/user/PasswordEncoder.java
@@ -0,0 +1,6 @@
+package com.loopers.domain.user;
+
+public interface PasswordEncoder {
+    String encode(String rawPassword);
+    boolean matches(String rawPassword, String encodedPassword);
+}
\ No newline at end of file
diff --git a/apps/commerce-api/src/main/java/com/loopers/domain/user/PasswordPolicyValidator.java b/apps/commerce-api/src/main/java/com/loopers/domain/user/PasswordPolicyValidator.java
new file mode 100644
index 00000000..b1fa4455
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/user/PasswordPolicyValidator.java
@@ -0,0 +1,25 @@
+package com.loopers.domain.user;
+
+import com.loopers.support.error.CoreException;
+import com.loopers.support.error.ErrorType;
+import java.time.LocalDate;
+import java.time.format.DateTimeFormatter;
+
+public class PasswordPolicyValidator {
+
+    private static final DateTimeFormatter BIRTH_DATE_FORMAT_FOR_PASSWORD_CHECK = DateTimeFormatter.ofPattern("yyyyMMdd");
+    private static final String PASSWORD_PATTERN = "^[a-zA-Z0-9!@#$%^&*()_+\\-=\\[\\]{};':\"\\\\|,.<>/?~`]{8,16}$";
+
+    private PasswordPolicyValidator() {}
+
+    public static void validate(String password, LocalDate birthDate) {
+        if (!password.matches(PASSWORD_PATTERN)) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "비밀번호는 8~16자의 영문/숫자/특수문자만 가능합니다.");
+        }
+
+        String birthDateString = birthDate.format(BIRTH_DATE_FORMAT_FOR_PASSWORD_CHECK);
+        if (password.contains(birthDateString)) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "비밀번호에 생년월일을 포함할 수 없습니다.");
+        }
+    }
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/domain/user/SignUpService.java b/apps/commerce-api/src/main/java/com/loopers/domain/user/SignUpService.java
new file mode 100644
index 00000000..a24218e1
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/user/SignUpService.java
@@ -0,0 +1,23 @@
+package com.loopers.domain.user;
+
+import com.loopers.application.user.SignUpCommand;
+import jakarta.transaction.Transactional;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+
+@Service
+@Transactional
+@RequiredArgsConstructor
+public class SignUpService {
+    private final SignUpValidator signUpValidator;
+    private final PasswordEncoder passwordEncoder;
+    private final UserRepository userRepository;
+
+    public void signUp(SignUpCommand command) {
+        signUpValidator.validate(command);
+        String encodedPassword = passwordEncoder.encode(command.password());
+        User user = User.create(command, encodedPassword);
+
+        userRepository.save(user);
+    }
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/domain/user/SignUpValidator.java b/apps/commerce-api/src/main/java/com/loopers/domain/user/SignUpValidator.java
new file mode 100644
index 00000000..38c4d2a3
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/user/SignUpValidator.java
@@ -0,0 +1,27 @@
+package com.loopers.domain.user;
+
+import com.loopers.application.user.SignUpCommand;
+import com.loopers.support.error.CoreException;
+import com.loopers.support.error.ErrorType;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Component;
+
+import java.time.LocalDate;
+
+@Component
+@RequiredArgsConstructor
+public class SignUpValidator {
+    private final UserRepository userRepository;
+
+    public void validate(SignUpCommand command) {
+        if (userRepository.findByLoginId(command.loginId()).isPresent()) {
+            throw new CoreException(ErrorType.CONFLICT, "이미 존재하는 로그인 ID입니다.");
+        }
+
+        if (command.birthDate().isAfter(LocalDate.now())) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "생년월일은 미래일 수 없습니다.");
+        }
+
+        PasswordPolicyValidator.validate(command.password(), command.birthDate());
+    }
+}
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 00000000..7e57a997
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/user/User.java
@@ -0,0 +1,95 @@
+package com.loopers.domain.user;
+
+import com.loopers.application.user.SignUpCommand;
+import com.loopers.domain.BaseEntity;
+import com.loopers.support.error.CoreException;
+import com.loopers.support.error.ErrorType;
+import jakarta.persistence.Column;
+import jakarta.persistence.Entity;
+import jakarta.persistence.Table;
+import lombok.Getter;
+
+import java.time.LocalDate;
+
+@Getter
+@Entity
+@Table(name = "users")
+public class User extends BaseEntity {
+    @Column(unique = true)
+    private String loginId;
+    private String password; // encoded
+    private String name;
+    private LocalDate birthDate;
+    private String email;
+
+    protected User() {}
+
+    private User(String loginId, String encodedPassword, String name, LocalDate birthDate, String email) {
+        validateLoginId(loginId);
+        validateEncodedPassword(encodedPassword);
+        validateName(name);
+        validateBirthDate(birthDate);
+        validateEmail(email);
+
+        this.loginId = loginId;
+        this.password = encodedPassword;
+        this.name = name;
+        this.birthDate = birthDate;
+        this.email = email;
+    }
+
+    public static User create(String loginId, String encodedPassword, String name, LocalDate birthDate, String email) {
+        return new User(loginId, encodedPassword, name, birthDate, email);
+    }
+
+    public static User create(SignUpCommand command, String encodedPassword) {
+        return new User(command.loginId(), encodedPassword, command.name(), command.birthDate(), command.email());
+
+    }
+
+    private void validateLoginId(String loginId) {
+        if (loginId == null || loginId.isBlank()) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "로그인 ID는 필수값입니다.");
+        }
+
+        if (!loginId.matches("^[a-zA-Z0-9]+$")) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "로그인 ID는 영문/숫자만 가능합니다.");
+        }
+    }
+
+    private void validateEncodedPassword(String encodedPassword) {
+        if (encodedPassword == null || encodedPassword.isBlank()) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "비밀번호는 필수값입니다.");
+        }
+    }
+
+    private void validateName(String name) {
+        if (name == null || name.isBlank()) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "이름은 필수값입니다.");
+        }
+
+        if (name.length() < 2) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "이름은 최소 두글자 이상이어야 합니다.");
+        }
+    }
+
+    private void validateBirthDate(LocalDate birthDate) {
+        if (birthDate == null) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "생년월일은 필수값입니다.");
+        }
+    }
+
+    private void validateEmail(String email) {
+        if (email == null || email.isBlank()) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "이메일은 필수값입니다.");
+        }
+
+        if (!email.contains("@") || !email.matches("^[\\w\\.]+@[\\w\\.]+\\.[a-zA-Z]{2,}$")) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "이메일 형식이 올바르지 않습니다.");
+        }
+    }
+
+    public void updatePassword(String newEncodedPassword) {
+        this.password = newEncodedPassword;
+    }
+}
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
new file mode 100644
index 00000000..d33a021a
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/user/UserRepository.java
@@ -0,0 +1,8 @@
+package com.loopers.domain.user;
+
+import java.util.Optional;
+
+public interface UserRepository {
+    void save(User user);
+    Optional<User> findByLoginId(String loginId);
+}
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
new file mode 100644
index 00000000..160d6a90
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/user/UserService.java
@@ -0,0 +1,45 @@
+package com.loopers.domain.user;
+
+import com.loopers.application.user.UpdatePasswordCommand;
+import com.loopers.application.user.UserInfo;
+import com.loopers.support.error.CoreException;
+import com.loopers.support.error.ErrorType;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+@RequiredArgsConstructor
+@Service
+public class UserService {
+    private final UserRepository userRepository;
+    private final PasswordEncoder passwordEncoder;
+
+    @Transactional
+    public void updatePassword(UpdatePasswordCommand command) {
+        User user = getUser(command.loginId());
+
+        if (!passwordEncoder.matches(command.currentPassword(), user.getPassword())) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "현재 비밀번호가 일치하지 않습니다.");
+        }
+
+        if (passwordEncoder.matches(command.newPassword(), user.getPassword())) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "현재 비밀번호와 동일한 비밀번호로 변경할 수 없습니다.");
+        }
+
+        PasswordPolicyValidator.validate(command.newPassword(), user.getBirthDate());
+        String encoded = passwordEncoder.encode(command.newPassword());
+        user.updatePassword(encoded);
+    }
+
+    @Transactional(readOnly = true)
+    public UserInfo getMyInfo(String loginId) {
+        User user = getUser(loginId);
+        return UserInfo.from(user);
+    }
+
+    private User getUser(String loginId) {
+        return userRepository.findByLoginId(loginId)
+                             .orElseThrow(() -> new CoreException(ErrorType.NOT_FOUND,
+                                                                  "[loginId = " + loginId + "] 를 찾을 수 없습니다."));
+    }
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/infrastructure/user/BcryptPasswordEncoder.java b/apps/commerce-api/src/main/java/com/loopers/infrastructure/user/BcryptPasswordEncoder.java
new file mode 100644
index 00000000..dc75c1de
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/infrastructure/user/BcryptPasswordEncoder.java
@@ -0,0 +1,20 @@
+package com.loopers.infrastructure.user;
+
+import com.loopers.domain.user.PasswordEncoder;
+import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
+import org.springframework.stereotype.Component;
+
+@Component
+public class BcryptPasswordEncoder implements PasswordEncoder {
+    private final BCryptPasswordEncoder encoder = new BCryptPasswordEncoder();
+
+    @Override
+    public String encode(String rawPassword) {
+        return encoder.encode(rawPassword);
+    }
+
+    @Override
+    public boolean matches(String rawPassword, String encodedPassword) {
+        return encoder.matches(rawPassword, encodedPassword);
+    }
+}
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
new file mode 100644
index 00000000..d89ee854
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/infrastructure/user/UserJpaRepository.java
@@ -0,0 +1,10 @@
+package com.loopers.infrastructure.user;
+
+import com.loopers.domain.user.User;
+import org.springframework.data.jpa.repository.JpaRepository;
+
+import java.util.Optional;
+
+public interface UserJpaRepository extends JpaRepository<User, Long> {
+    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
new file mode 100644
index 00000000..b0f42f5d
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/infrastructure/user/UserRepositoryImpl.java
@@ -0,0 +1,25 @@
+package com.loopers.infrastructure.user;
+
+import com.loopers.domain.user.User;
+import com.loopers.domain.user.UserRepository;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Repository;
+
+import java.util.Optional;
+
+@RequiredArgsConstructor
+@Repository
+public class UserRepositoryImpl implements UserRepository {
+    private final UserJpaRepository userJpaRepository;
+
+
+    @Override
+    public void save(User user) {
+        userJpaRepository.save(user);
+    }
+
+    @Override
+    public Optional<User> findByLoginId(String loginId) {
+        return userJpaRepository.findByLoginId(loginId);
+    }
+}
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 20b2809c..8a438fb5 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.MethodArgumentNotValidException;
 import org.springframework.web.bind.MissingServletRequestParameterException;
 import org.springframework.web.bind.annotation.ExceptionHandler;
 import org.springframework.web.bind.annotation.RestControllerAdvice;
@@ -46,6 +47,14 @@ public ResponseEntity<ApiResponse<?>> handleBadRequest(MissingServletRequestPara
         return failureResponse(ErrorType.BAD_REQUEST, message);
     }
 
+    @ExceptionHandler
+    public ResponseEntity<ApiResponse<?>> handleValidationException(MethodArgumentNotValidException e) {
+        String errorMessage = e.getBindingResult().getFieldErrors().stream()
+            .map(error -> error.getDefaultMessage())
+            .collect(Collectors.joining(", "));
+        return failureResponse(ErrorType.BAD_REQUEST, errorMessage);
+    }
+
     @ExceptionHandler
     public ResponseEntity<ApiResponse<?>> handleBadRequest(HttpMessageNotReadableException e) {
         String errorMessage;
diff --git a/apps/commerce-api/src/main/java/com/loopers/interfaces/api/user/SignUpV1Controller.java b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/user/SignUpV1Controller.java
new file mode 100644
index 00000000..90ae6e0e
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/user/SignUpV1Controller.java
@@ -0,0 +1,31 @@
+package com.loopers.interfaces.api.user;
+
+import com.loopers.application.user.SignUpCommand;
+import com.loopers.domain.user.SignUpService;
+import com.loopers.interfaces.api.ApiResponse;
+import com.loopers.interfaces.api.user.dto.UserV1Dto;
+import jakarta.validation.Valid;
+import lombok.RequiredArgsConstructor;
+import org.springframework.http.HttpStatus;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.ResponseStatus;
+import org.springframework.web.bind.annotation.RestController;
+
+@RequiredArgsConstructor
+@RestController
+@RequestMapping("/api/v1/users")
+public class SignUpV1Controller {
+
+    private final SignUpService signUpService;
+
+    @PostMapping
+    @ResponseStatus(HttpStatus.CREATED)
+    public ApiResponse<Void> signUp(@Valid @RequestBody UserV1Dto.CreateRequest request) {
+        SignUpCommand command = SignUpCommand.from(request);
+        signUpService.signUp(command);
+
+        return ApiResponse.success(null);
+    }
+}
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
new file mode 100644
index 00000000..d4d219da
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/user/UserV1Controller.java
@@ -0,0 +1,39 @@
+package com.loopers.interfaces.api.user;
+
+import com.loopers.application.user.UserInfo;
+import com.loopers.application.user.UpdatePasswordCommand;
+import com.loopers.domain.user.UserService;
+import com.loopers.interfaces.api.ApiResponse;
+import com.loopers.interfaces.api.user.dto.UserV1Dto;
+import jakarta.validation.Valid;
+import lombok.RequiredArgsConstructor;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PatchMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestHeader;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+@RequiredArgsConstructor
+@RestController
+@RequestMapping("/api/v1/users")
+public class UserV1Controller {
+
+    private final UserService userService;
+
+    @GetMapping("/me")
+    public ApiResponse<UserV1Dto.UserResponse> getMyInfo(@RequestHeader("X-Loopers-LoginId") String loginId) {
+        UserInfo userInfo = userService.getMyInfo(loginId);
+        return ApiResponse.success(UserV1Dto.UserResponse.from(userInfo));
+    }
+
+    @PatchMapping("/me/password")
+    public ApiResponse<Void> updatePassword(
+            @RequestHeader("X-Loopers-LoginId") String loginId,
+            @RequestHeader("X-Loopers-LoginPw") String currentPassword,
+            @Valid @RequestBody UserV1Dto.UpdatePasswordRequest request
+    ) {
+        userService.updatePassword(UpdatePasswordCommand.from(loginId, currentPassword, request));
+        return ApiResponse.success(null);
+    }
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/interfaces/api/user/dto/UserV1Dto.java b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/user/dto/UserV1Dto.java
new file mode 100644
index 00000000..6fa7ccb3
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/user/dto/UserV1Dto.java
@@ -0,0 +1,41 @@
+package com.loopers.interfaces.api.user.dto;
+
+import com.fasterxml.jackson.annotation.JsonFormat;
+import com.loopers.application.user.UserInfo;
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.NotNull;
+
+import java.time.LocalDate;
+
+public class UserV1Dto {
+
+    public record CreateRequest(
+            @NotBlank(message = "로그인 ID는 필수값입니다.")
+            String loginId,
+            @NotBlank(message = "비밀번호는 필수값입니다.")
+            String password,
+            @NotBlank(message = "이름은 필수값입니다.")
+            String name,
+            @NotNull(message = "생년월일은 필수값입니다.")
+            @JsonFormat(pattern = "yyyy-MM-dd")
+            LocalDate birthDate,
+            @NotBlank(message = "이메일은 필수값입니다.")
+            String email
+    ) {}
+
+    public record UpdatePasswordRequest(
+            @NotBlank(message = "새 비밀번호는 필수값입니다.")
+            String newPassword
+    ) {}
+
+    public record UserResponse(String loginId, String name, LocalDate birthDate, String email) {
+        public static UserResponse from(UserInfo info) {
+            return new UserResponse(
+                    info.loginId(),
+                    info.name(),
+                    info.birthDate(),
+                    info.email()
+            );
+        }
+    }
+}
diff --git a/apps/commerce-api/src/test/java/com/loopers/domain/user/InMemoryUserRepository.java b/apps/commerce-api/src/test/java/com/loopers/domain/user/InMemoryUserRepository.java
new file mode 100644
index 00000000..9c1535db
--- /dev/null
+++ b/apps/commerce-api/src/test/java/com/loopers/domain/user/InMemoryUserRepository.java
@@ -0,0 +1,21 @@
+package com.loopers.domain.user;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Optional;
+
+public class InMemoryUserRepository implements UserRepository {
+    private final Map<String, User> storeByEmail = new HashMap<>();
+    private final Map<String, User> storeByLoginId = new HashMap<>();
+
+    @Override
+    public void save(User user) {
+        storeByEmail.put(user.getEmail(), user);
+        storeByLoginId.put(user.getLoginId(), user);
+    }
+
+    @Override
+    public Optional<User> findByLoginId(String loginId) {
+        return Optional.ofNullable(storeByLoginId.get(loginId));
+    }
+}
diff --git a/apps/commerce-api/src/test/java/com/loopers/domain/user/SignUpServiceIntegrationTest.java b/apps/commerce-api/src/test/java/com/loopers/domain/user/SignUpServiceIntegrationTest.java
new file mode 100644
index 00000000..6766179a
--- /dev/null
+++ b/apps/commerce-api/src/test/java/com/loopers/domain/user/SignUpServiceIntegrationTest.java
@@ -0,0 +1,55 @@
+package com.loopers.domain.user;
+
+import com.loopers.application.user.SignUpCommand;
+import com.loopers.utils.DatabaseCleanUp;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import com.loopers.infrastructure.user.UserJpaRepository;
+import org.springframework.test.context.ActiveProfiles;
+
+import java.time.LocalDate;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+@SpringBootTest
+public class SignUpServiceIntegrationTest {
+    @Autowired
+    private SignUpService signUpService;
+
+    @Autowired
+    private UserJpaRepository userJpaRepository;
+
+    @Autowired
+    private DatabaseCleanUp databaseCleanUp;
+
+    @AfterEach
+    void tearDown() {
+        databaseCleanUp.truncateAllTables();
+    }
+
+    @Test
+    @DisplayName("회원가입하면 DB에 저장된다.")
+    void signUp_savesUser() {
+        // arrange
+        SignUpCommand command = new SignUpCommand(
+                "testUser123",
+                "ValidPass1!",
+                "박자바",
+                LocalDate.of(1990, 1, 15),
+                "test@example.com"
+        );
+
+        // act
+        signUpService.signUp(command);
+
+        // assert
+        User savedUser = userJpaRepository.findByLoginId("testUser123")
+                                          .orElseThrow(() -> new AssertionError("User not saved"));
+
+        assertThat(savedUser.getLoginId()).isEqualTo("testUser123");
+        assertThat(savedUser.getId()).isGreaterThan(0L);
+    }
+}
diff --git a/apps/commerce-api/src/test/java/com/loopers/domain/user/SignUpServiceTest.java b/apps/commerce-api/src/test/java/com/loopers/domain/user/SignUpServiceTest.java
new file mode 100644
index 00000000..b1b09d19
--- /dev/null
+++ b/apps/commerce-api/src/test/java/com/loopers/domain/user/SignUpServiceTest.java
@@ -0,0 +1,47 @@
+package com.loopers.domain.user;
+
+import com.loopers.application.user.SignUpCommand;
+import com.loopers.infrastructure.user.BcryptPasswordEncoder;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.DisplayName;
+
+import java.time.LocalDate;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class SignUpServiceTest {
+    private InMemoryUserRepository userRepository;
+    private PasswordEncoder passwordEncoder;
+    private SignUpValidator signUpValidator;
+    private SignUpService signUpService;
+
+    @BeforeEach
+    void setUp() {
+        userRepository = new InMemoryUserRepository();
+        passwordEncoder = new BcryptPasswordEncoder();
+        signUpValidator = new SignUpValidator(userRepository);
+        signUpService = new SignUpService(signUpValidator, passwordEncoder, userRepository);
+    }
+
+    @Test
+    @DisplayName("회원가입시 비밀번호를 암호화해서 저장한다.")
+    void signUp_encryptsPassword() {
+        // arrange
+        SignUpCommand command = new SignUpCommand(
+                "testUser123",
+                "ValidPass1!",
+                "박자바",
+                LocalDate.of(1990, 1, 15),
+                "test@example.com"
+        );
+
+        // act
+        signUpService.signUp(command);
+
+        // assert
+        User savedUser = userRepository.findByLoginId("testUser123").orElse(null);
+        assertThat(savedUser).isNotNull();
+        assertThat(savedUser.getPassword()).isNotEqualTo("ValidPass1!");
+    }
+}
diff --git a/apps/commerce-api/src/test/java/com/loopers/domain/user/SignUpValidatorTest.java b/apps/commerce-api/src/test/java/com/loopers/domain/user/SignUpValidatorTest.java
new file mode 100644
index 00000000..4ac27b40
--- /dev/null
+++ b/apps/commerce-api/src/test/java/com/loopers/domain/user/SignUpValidatorTest.java
@@ -0,0 +1,143 @@
+package com.loopers.domain.user;
+
+import com.loopers.application.user.SignUpCommand;
+import com.loopers.infrastructure.user.BcryptPasswordEncoder;
+import com.loopers.support.error.CoreException;
+import com.loopers.support.error.ErrorType;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import java.time.LocalDate;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+public class SignUpValidatorTest {
+    private InMemoryUserRepository userRepository;
+    private PasswordEncoder passwordEncoder;
+    private SignUpValidator signUpValidator;
+    private SignUpService signUpService;
+
+    @BeforeEach
+    void setUp() {
+        userRepository = new InMemoryUserRepository();
+        passwordEncoder = new BcryptPasswordEncoder();
+        signUpValidator = new SignUpValidator(userRepository);
+        signUpService = new SignUpService(signUpValidator, passwordEncoder, userRepository);
+    }
+
+    @Test
+    @DisplayName("회원가입시 loginId가 중복되면 예외가 발생한다.")
+    void validate_throwsException_whenLoginIdIsDuplicated() {
+        // arrange
+        SignUpCommand firstCommand = new SignUpCommand(
+                "duplicateId",
+                "ValidPass1!",
+                "박자바",
+                LocalDate.of(1990, 1, 15),
+                "first@example.com"
+        );
+        signUpService.signUp(firstCommand);
+
+        SignUpCommand secondCommand = new SignUpCommand(
+                "duplicateId",
+                "ValidPass2!",
+                "김자바",
+                LocalDate.of(1995, 5, 20),
+                "second@example.com"
+        );
+
+        // act
+        CoreException result = assertThrows(CoreException.class, () -> {
+            signUpValidator.validate(secondCommand);
+        });
+
+        // assert
+        assertThat(result.getErrorType()).isEqualTo(ErrorType.CONFLICT);
+    }
+
+    @Test
+    @DisplayName("회원가입시 password가 8자 미만이면 예외가 발생한다.")
+    void validate_throwsException_whenPasswordIsTooShort() {
+        // arrange
+        SignUpCommand command = new SignUpCommand(
+                "testUser",
+                "Short1!",
+                "박자바",
+                LocalDate.of(1990, 1, 15),
+                "test@example.com"
+        );
+
+        // act
+        CoreException result = assertThrows(CoreException.class, () -> {
+            signUpValidator.validate(command);
+        });
+
+        // assert
+        assertThat(result.getErrorType()).isEqualTo(ErrorType.BAD_REQUEST);
+    }
+
+    @Test
+    @DisplayName("회원가입시 password가 16자 초과면 예외가 발생한다.")
+    void validate_throwsException_whenPasswordIsTooLong() {
+        // arrange
+        SignUpCommand command = new SignUpCommand(
+                "testUser",
+                "VeryLongPass123!!",
+                "박자바",
+                LocalDate.of(1990, 1, 15),
+                "test@example.com"
+        );
+
+        // act
+        CoreException result = assertThrows(CoreException.class, () -> {
+            signUpValidator.validate(command);
+        });
+
+        // assert
+        assertThat(result.getErrorType()).isEqualTo(ErrorType.BAD_REQUEST);
+    }
+
+    @Test
+    @DisplayName("회원가입시 password에 공백이 포함되면 예외가 발생한다.")
+    void validate_throwsException_whenPasswordContainsWhitespace() {
+        // arrange
+        SignUpCommand command = new SignUpCommand(
+                "testUser",
+                "Pass 1234!",
+                "박자바",
+                LocalDate.of(1990, 1, 15),
+                "test@example.com"
+        );
+
+        // act
+        CoreException result = assertThrows(CoreException.class, () -> {
+            signUpValidator.validate(command);
+        });
+
+        // assert
+        assertThat(result.getErrorType()).isEqualTo(ErrorType.BAD_REQUEST);
+    }
+
+    @Test
+    @DisplayName("회원가입시 password에 생년월일이 포함되면 예외가 발생한다.")
+    void validate_throwsException_whenPasswordContainsBirthDate() {
+        // arrange
+        SignUpCommand command = new SignUpCommand(
+                "testUser",
+                "Pass19900115!",
+                "박자바",
+                LocalDate.of(1990, 1, 15),
+                "test@example.com"
+        );
+
+        // act
+        CoreException result = assertThrows(CoreException.class, () -> {
+            signUpValidator.validate(command);
+        });
+
+        // assert
+        assertThat(result.getErrorType()).isEqualTo(ErrorType.BAD_REQUEST);
+    }
+}
diff --git a/apps/commerce-api/src/test/java/com/loopers/domain/user/UserFixture.java b/apps/commerce-api/src/test/java/com/loopers/domain/user/UserFixture.java
new file mode 100644
index 00000000..b02fa210
--- /dev/null
+++ b/apps/commerce-api/src/test/java/com/loopers/domain/user/UserFixture.java
@@ -0,0 +1,50 @@
+package com.loopers.domain.user;
+
+import java.time.LocalDate;
+
+public class UserFixture {
+    public static final String VALID_LOGIN_ID = "testUser123";
+    public static final String VALID_ENCODED_PASSWORD = "ValidEncodedPass1!";
+    public static final String VALID_NAME = "박코틀린";
+    public static final LocalDate VALID_BIRTH_DATE = LocalDate.of(1990, 1, 15);
+    public static final String VALID_EMAIL = "test@example.com";
+
+    private String loginId = VALID_LOGIN_ID;
+    private String password = VALID_ENCODED_PASSWORD;
+    private String name = VALID_NAME;
+    private LocalDate birthDate = VALID_BIRTH_DATE;
+    private String email = VALID_EMAIL;
+
+    public static UserFixture builder() {
+        return new UserFixture();
+    }
+
+    public UserFixture loginId(String loginId) {
+        this.loginId = loginId;
+        return this;
+    }
+
+    public UserFixture password(String password) {
+        this.password = password;
+        return this;
+    }
+
+    public UserFixture name(String name) {
+        this.name = name;
+        return this;
+    }
+
+    public UserFixture birthDate(LocalDate birthDate) {
+        this.birthDate = birthDate;
+        return this;
+    }
+
+    public UserFixture email(String email) {
+        this.email = email;
+        return this;
+    }
+
+    public User build() {
+        return User.create(loginId, password, name, birthDate, email);
+    }
+}
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
new file mode 100644
index 00000000..292d9231
--- /dev/null
+++ b/apps/commerce-api/src/test/java/com/loopers/domain/user/UserServiceIntegrationTest.java
@@ -0,0 +1,80 @@
+package com.loopers.domain.user;
+
+import com.loopers.application.user.UpdatePasswordCommand;
+import com.loopers.application.user.UserInfo;
+import com.loopers.infrastructure.user.UserJpaRepository;
+import com.loopers.utils.DatabaseCleanUp;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertAll;
+
+@SpringBootTest
+class UserServiceIntegrationTest {
+
+    @Autowired
+    private UserService userService;
+
+    @Autowired
+    private UserJpaRepository userJpaRepository;
+
+    @Autowired
+    private DatabaseCleanUp databaseCleanUp;
+
+    private final BCryptPasswordEncoder bCryptPasswordEncoder = new BCryptPasswordEncoder();
+
+    @AfterEach
+    void tearDown() {
+        databaseCleanUp.truncateAllTables();
+    }
+
+    @Test
+    @DisplayName("내 정보 조회 시 이름 마지막 글자가 마스킹된다.")
+    void getMyInfo_returnsUserInfoWithMaskedName() {
+        // arrange
+        String loginId = "testUser123";
+        User user = UserFixture.builder()
+                               .loginId(loginId)
+                               .name("박자바")
+                               .build();
+        userJpaRepository.save(user);
+
+        // act
+        UserInfo result = userService.getMyInfo(loginId);
+
+        // assert
+        assertAll(
+            () -> assertThat(result.loginId()).isEqualTo(loginId),
+            () -> assertThat(result.name()).isEqualTo("박자*")
+        );
+    }
+
+    @Test
+    @DisplayName("비밀번호 변경 시 새 비밀번호로 업데이트된다.")
+    void updatePassword_updatesPasswordInDb() {
+        // arrange
+        String loginId = "testUser123";
+        String currentPassword = "OldPass1!";
+        String encode = bCryptPasswordEncoder.encode(currentPassword);
+        User user = UserFixture.builder()
+                               .loginId(loginId)
+                               .password(encode)
+                               .build();
+        userJpaRepository.save(user);
+
+        String newPassword = "NewPass1!";
+        UpdatePasswordCommand command = new UpdatePasswordCommand(loginId, currentPassword, newPassword);
+
+        // act
+        userService.updatePassword(command);
+
+        // assert
+        User updatedUser = userJpaRepository.findByLoginId(loginId).orElseThrow();
+        assertThat(bCryptPasswordEncoder.matches(newPassword, updatedUser.getPassword())).isTrue();
+    }
+}
diff --git a/apps/commerce-api/src/test/java/com/loopers/domain/user/UserServiceTest.java b/apps/commerce-api/src/test/java/com/loopers/domain/user/UserServiceTest.java
new file mode 100644
index 00000000..bf0516c9
--- /dev/null
+++ b/apps/commerce-api/src/test/java/com/loopers/domain/user/UserServiceTest.java
@@ -0,0 +1,90 @@
+package com.loopers.domain.user;
+
+import com.loopers.application.user.UpdatePasswordCommand;
+import com.loopers.application.user.UserInfo;
+import com.loopers.infrastructure.user.BcryptPasswordEncoder;
+import com.loopers.support.error.CoreException;
+import com.loopers.support.error.ErrorType;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+public class UserServiceTest {
+    private InMemoryUserRepository userRepository;
+    private PasswordEncoder passwordEncoder;
+    private UserService userService;
+
+    @BeforeEach
+    void setUp() {
+        userRepository = new InMemoryUserRepository();
+        passwordEncoder = new BcryptPasswordEncoder();
+        userService = new UserService(userRepository, passwordEncoder);
+    }
+
+    @DisplayName("내 정보 조회 시 이름의 마지막 글자는 마스킹(*)되어 반환된다")
+    @Test
+    void getMyInfo_masks_last_character_of_name() {
+        // given
+        User user = UserFixture.builder()
+                               .name("테스터")
+                               .build();
+
+        userRepository.save(user);
+
+        // when
+        UserInfo myInfo = userService.getMyInfo(user.getLoginId());
+
+        // then
+        assertThat(myInfo.name()).isEqualTo("테스*");
+        assertThat(myInfo.loginId()).isEqualTo(user.getLoginId());
+        assertThat(myInfo.email()).isEqualTo(user.getEmail());
+        assertThat(myInfo.birthDate()).isEqualTo(user.getBirthDate());
+    }
+
+    @DisplayName("현재 비밀번호가 일치하지 않으면, BAD_REQUEST 예외가 발생한다.")
+    @Test
+    void throwsException_whenCurrentPasswordNotMatches() {
+        // given
+        String currentPassword = "ValidPass1!";
+        String encodedPassword = passwordEncoder.encode(currentPassword);
+        User user = UserFixture.builder()
+                               .password(encodedPassword)
+                               .build();
+        userRepository.save(user);
+
+        UpdatePasswordCommand command = new UpdatePasswordCommand(user.getLoginId(), "WrongPass1!", "NewPass1!");
+
+        // when
+        CoreException result = assertThrows(CoreException.class, () -> {
+            userService.updatePassword(command);
+        });
+
+        // then
+        assertThat(result.getErrorType()).isEqualTo(ErrorType.BAD_REQUEST);
+    }
+
+    @DisplayName("새 비밀번호가 현재 비밀번호와 같으면, BAD_REQUEST 예외가 발생한다.")
+    @Test
+    void throwsException_whenNewPasswordSameAsCurrent() {
+        // given
+        String rawPassword = "ValidPass1!";
+        String encodedPassword = passwordEncoder.encode(rawPassword);
+        User user = UserFixture.builder()
+                               .password(encodedPassword)
+                               .build();
+        userRepository.save(user);
+
+        UpdatePasswordCommand command = new UpdatePasswordCommand(user.getLoginId(), rawPassword, rawPassword);
+
+        // when
+        CoreException result = assertThrows(CoreException.class, () -> {
+            userService.updatePassword(command);
+        });
+
+        // then
+        assertThat(result.getErrorType()).isEqualTo(ErrorType.BAD_REQUEST);
+    }
+}
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 00000000..72af6858
--- /dev/null
+++ b/apps/commerce-api/src/test/java/com/loopers/domain/user/UserTest.java
@@ -0,0 +1,148 @@
+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.Nested;
+import org.junit.jupiter.api.Test;
+
+import java.time.LocalDate;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertAll;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+public class UserTest {
+    @DisplayName("회원 가입시, ")
+    @Nested
+    class Create {
+        @DisplayName("loginId가 영문/숫자만 포함하면 정상적으로 생성된다.")
+        @Test
+        void createsUser_whenLoginIdIsAlphanumeric() {
+            // arrange
+            String loginId = "uniqueTester123";
+
+            // act
+            User user = UserFixture.builder()
+                                   .loginId(loginId)
+                                   .build();
+            // assert
+            assertAll(
+                () -> assertThat(user.getLoginId()).isNotNull()
+            );
+        }
+
+        @DisplayName("loginId에 영문/숫자 외의 문자가 포함되면 BAD_REQUEST 예외가 발생한다.")
+        @Test
+        void throwsBadRequestException_whenLoginIdIsNotAlphanumeric() {
+            // arrange
+            String loginId = "invalidId#?*";
+
+            // act
+            CoreException result = assertThrows(CoreException.class, () -> {
+                UserFixture.builder()
+                           .loginId(loginId)
+                           .build();
+            });
+
+            // assert
+            assertThat(result.getErrorType()).isEqualTo(ErrorType.BAD_REQUEST);
+        }
+
+        @DisplayName("이름이 공백 없는 문자열이면 정상적으로 생성된다.")
+        @Test
+        void createsUser_whenNameIsValid() {
+            // arrange
+            String name = "박자바";
+
+            // act
+            User user = UserFixture.builder()
+                                   .name(name)
+                                   .build();
+
+            // assert
+            assertThat(user.getName()).isEqualTo(name);
+        }
+
+        @DisplayName("name이 빈 문자열이면 BAD_REQUEST 예외가 발생한다.")
+        @Test
+        void throwsBadRequestException_whenNameIsEmpty() {
+            // arrange
+            String name = "";
+
+            // act
+            CoreException result = assertThrows(CoreException.class, () -> {
+                UserFixture.builder()
+                           .name(name)
+                           .build();
+            });
+
+            // assert
+            assertThat(result.getErrorType()).isEqualTo(ErrorType.BAD_REQUEST);
+        }
+
+        @DisplayName("email이 @와 .을 포함하면 정상적으로 생성된다.")
+        @Test
+        void createsUser_whenEmailIsValid() {
+            // arrange
+            String email = "test@example.com";
+
+            // act
+            User user = UserFixture.builder()
+                                   .email(email)
+                                   .build();
+
+            // assert
+            assertThat(user.getEmail()).isEqualTo(email);
+        }
+
+        @DisplayName("email에 @가 없으면 BAD_REQUEST 예외가 발생한다.")
+        @Test
+        void throwsBadRequestException_whenEmailHasNoAtSign() {
+            // arrange
+            String email = "testexample.com";
+
+            // act
+            CoreException result = assertThrows(CoreException.class, () -> {
+                UserFixture.builder()
+                           .email(email)
+                           .build();
+            });
+
+            // assert
+            assertThat(result.getErrorType()).isEqualTo(ErrorType.BAD_REQUEST);
+        }
+
+        @DisplayName("email에 .이 없으면 BAD_REQUEST 예외가 발생한다.")
+        @Test
+        void throwsBadRequestException_whenEmailHasNoDot() {
+            // arrange
+            String email = "test@examplecom";
+
+            // act
+            CoreException result = assertThrows(CoreException.class, () -> {
+                UserFixture.builder()
+                           .email(email)
+                           .build();
+            });
+
+            // assert
+            assertThat(result.getErrorType()).isEqualTo(ErrorType.BAD_REQUEST);
+        }
+
+        @DisplayName("birthDate가 유효한 LocalDate이면 정상적으로 생성된다.")
+        @Test
+        void createsUser_whenBirthDateIsValid() {
+            // arrange
+            LocalDate birthDate = LocalDate.of(1990, 1, 15);
+
+            // act
+            User user = UserFixture.builder()
+                                   .birthDate(birthDate)
+                                   .build();
+
+            // assert
+            assertThat(user.getBirthDate()).isEqualTo(birthDate);
+        }
+    }
+}
diff --git a/apps/commerce-api/src/test/java/com/loopers/interfaces/api/SignUpV1ApiE2ETest.java b/apps/commerce-api/src/test/java/com/loopers/interfaces/api/SignUpV1ApiE2ETest.java
new file mode 100644
index 00000000..87a8508c
--- /dev/null
+++ b/apps/commerce-api/src/test/java/com/loopers/interfaces/api/SignUpV1ApiE2ETest.java
@@ -0,0 +1,129 @@
+package com.loopers.interfaces.api;
+
+import com.loopers.infrastructure.user.UserJpaRepository;
+import com.loopers.interfaces.api.user.dto.UserV1Dto;
+import com.loopers.utils.DatabaseCleanUp;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.boot.test.web.client.TestRestTemplate;
+import org.springframework.core.ParameterizedTypeReference;
+import org.springframework.http.HttpEntity;
+import org.springframework.http.HttpMethod;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+
+import java.time.LocalDate;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertAll;
+
+@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
+class SignUpV1ApiE2ETest {
+
+    private static final String ENDPOINT_SIGN_UP = "/api/v1/users";
+
+    private final TestRestTemplate testRestTemplate;
+    private final UserJpaRepository userJpaRepository;
+    private final DatabaseCleanUp databaseCleanUp;
+
+    @Autowired
+    public SignUpV1ApiE2ETest(
+        TestRestTemplate testRestTemplate,
+        UserJpaRepository userJpaRepository,
+        DatabaseCleanUp databaseCleanUp
+    ) {
+        this.testRestTemplate = testRestTemplate;
+        this.userJpaRepository = userJpaRepository;
+        this.databaseCleanUp = databaseCleanUp;
+    }
+
+    @AfterEach
+    void tearDown() {
+        databaseCleanUp.truncateAllTables();
+    }
+
+    @DisplayName("POST /api/v1/users (회원가입)")
+    @Nested
+    class SignUp {
+        @DisplayName("유효한 회원가입 요청이면, 201 Created 응답을 반환한다.")
+        @Test
+        void returnsCreated_whenValidRequest() {
+            // arrange
+            UserV1Dto.CreateRequest request = new UserV1Dto.CreateRequest(
+                    "testUser123",
+                    "ValidPass1!",
+                    "박자바",
+                    LocalDate.of(1990, 1, 15),
+                    "test@example.com"
+            );
+
+            // act
+            ParameterizedTypeReference<ApiResponse<Void>> responseType = new ParameterizedTypeReference<>() {};
+            ResponseEntity<ApiResponse<Void>> response =
+                testRestTemplate.exchange(ENDPOINT_SIGN_UP, HttpMethod.POST, new HttpEntity<>(request), responseType);
+
+            // assert
+            assertAll(
+                () -> assertThat(response.getStatusCode()).isEqualTo(HttpStatus.CREATED),
+                () -> assertThat(userJpaRepository.findByLoginId("testUser123")).isPresent()
+            );
+        }
+
+        @DisplayName("loginId가 누락되면, 400 Bad Request 응답을 반환한다.")
+        @Test
+        void returnsBadRequest_whenLoginIdIsMissing() {
+            // arrange
+            UserV1Dto.CreateRequest request = new UserV1Dto.CreateRequest(
+                    null,
+                    "ValidPass1!",
+                    "박자바",
+                    LocalDate.of(1990, 1, 15),
+                    "test@example.com"
+            );
+
+            // act
+            ParameterizedTypeReference<ApiResponse<Void>> responseType = new ParameterizedTypeReference<>() {};
+            ResponseEntity<ApiResponse<Void>> response =
+                testRestTemplate.exchange(ENDPOINT_SIGN_UP, HttpMethod.POST, new HttpEntity<>(request), responseType);
+
+            // assert
+            assertThat(response.getStatusCode()).isEqualTo(HttpStatus.BAD_REQUEST);
+        }
+
+        @DisplayName("이미 존재하는 loginId로 요청하면, 409 Conflict 응답을 반환한다.")
+        @Test
+        void returnsConflict_whenLoginIdAlreadyExists() {
+            // arrange
+            UserV1Dto.CreateRequest firstRequest = new UserV1Dto.CreateRequest(
+                    "duplicateId",
+                    "ValidPass1!",
+                    "박자바",
+                    LocalDate.of(1990, 1, 15),
+                    "first@example.com"
+            );
+
+            testRestTemplate.exchange(ENDPOINT_SIGN_UP, HttpMethod.POST, new HttpEntity<>(firstRequest),
+                new ParameterizedTypeReference<ApiResponse<Void>>() {});
+
+            UserV1Dto.CreateRequest secondRequest = new UserV1Dto.CreateRequest(
+                    "duplicateId",
+                    "ValidPass2!",
+                    "김자바",
+                    LocalDate.of(1995, 5, 20),
+                    "second@example.com"
+            );
+
+            // act
+            ParameterizedTypeReference<ApiResponse<Void>> responseType = new ParameterizedTypeReference<>() {};
+            ResponseEntity<ApiResponse<Void>> response =
+                testRestTemplate.exchange(ENDPOINT_SIGN_UP, HttpMethod.POST, new HttpEntity<>(secondRequest), responseType);
+
+            // assert
+            assertThat(response.getStatusCode()).isEqualTo(HttpStatus.CONFLICT);
+        }
+    }
+}
\ No newline at end of file
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
new file mode 100644
index 00000000..66db6ea6
--- /dev/null
+++ b/apps/commerce-api/src/test/java/com/loopers/interfaces/api/UserV1ApiE2ETest.java
@@ -0,0 +1,225 @@
+package com.loopers.interfaces.api;
+
+import com.loopers.domain.user.User;
+import com.loopers.domain.user.UserFixture;
+import com.loopers.infrastructure.user.UserJpaRepository;
+import com.loopers.interfaces.api.user.dto.UserV1Dto;
+import com.loopers.utils.DatabaseCleanUp;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.boot.test.web.client.TestRestTemplate;
+import org.springframework.core.ParameterizedTypeReference;
+import org.springframework.http.HttpEntity;
+import org.springframework.http.HttpHeaders;
+import org.springframework.http.HttpMethod;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.MediaType;
+import org.springframework.http.ResponseEntity;
+import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertAll;
+
+@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
+class UserV1ApiE2ETest {
+
+    private static final String ENDPOINT_GET_MY_INFO = "/api/v1/users/me";
+    private static final String ENDPOINT_UPDATE_PASSWORD = "/api/v1/users/me/password";
+
+    private final TestRestTemplate testRestTemplate;
+    private final UserJpaRepository userJpaRepository;
+    private final DatabaseCleanUp databaseCleanUp;
+
+    @Autowired
+    public UserV1ApiE2ETest(
+        TestRestTemplate testRestTemplate,
+        UserJpaRepository userJpaRepository,
+        DatabaseCleanUp databaseCleanUp
+    ) {
+        this.testRestTemplate = testRestTemplate;
+        this.userJpaRepository = userJpaRepository;
+        this.databaseCleanUp = databaseCleanUp;
+    }
+
+    @AfterEach
+    void tearDown() {
+        databaseCleanUp.truncateAllTables();
+    }
+
+    @DisplayName("GET /api/v1/users/me (내 정보 조회)")
+    @Nested
+    class GetMyInfo {
+
+        @DisplayName("존재하는 사용자를 조회하면, 200 OK와 마스킹된 이름을 반환한다.")
+        @Test
+        void returnsOk_whenUserExists() {
+            // arrange
+            User savedUser = UserFixture.builder()
+                                        .loginId("testUser123")
+                                        .name("박자바")
+                                        .build();
+            userJpaRepository.save(savedUser);
+
+            HttpHeaders headers = new HttpHeaders();
+            headers.set("X-Loopers-LoginId", savedUser.getLoginId());
+            HttpEntity<Void> requestEntity = new HttpEntity<>(headers);
+
+            // act
+            ParameterizedTypeReference<ApiResponse<UserV1Dto.UserResponse>> responseType = new ParameterizedTypeReference<>() {};
+            ResponseEntity<ApiResponse<UserV1Dto.UserResponse>> response =
+                testRestTemplate.exchange(ENDPOINT_GET_MY_INFO, HttpMethod.GET, requestEntity, responseType);
+
+            // assert
+            assertAll(
+                () -> assertThat(response.getStatusCode()).isEqualTo(HttpStatus.OK),
+                () -> assertThat(response.getBody()).isNotNull(),
+                () -> assertThat(response.getBody().data().loginId()).isEqualTo("testUser123"),
+                () -> assertThat(response.getBody().data().name()).isEqualTo("박자*")
+            );
+        }
+
+        @DisplayName("존재하지 않는 사용자를 조회하면, 404 Not Found를 반환한다.")
+        @Test
+        void returnsNotFound_whenUserNotExists() {
+            // arrange
+            HttpHeaders headers = new HttpHeaders();
+            headers.set("X-Loopers-LoginId", "nonExistingId");
+            HttpEntity<Void> requestEntity = new HttpEntity<>(headers);
+
+            // act
+            ParameterizedTypeReference<ApiResponse<UserV1Dto.UserResponse>> responseType = new ParameterizedTypeReference<>() {};
+            ResponseEntity<ApiResponse<UserV1Dto.UserResponse>> response =
+                testRestTemplate.exchange(ENDPOINT_GET_MY_INFO, HttpMethod.GET, requestEntity, responseType);
+
+            // assert
+            assertThat(response.getStatusCode()).isEqualTo(HttpStatus.NOT_FOUND);
+        }
+    }
+
+    @DisplayName("PATCH /api/v1/users/me/password (비밀번호 변경)")
+    @Nested
+    class UpdatePassword {
+
+        private final BCryptPasswordEncoder bCryptPasswordEncoder = new BCryptPasswordEncoder();
+
+        @DisplayName("유효한 비밀번호 변경 요청이면, 200 OK를 반환하고 비밀번호가 변경된다.")
+        @Test
+        void returnsOk_whenValidRequest() {
+            // arrange
+            String loginId = "testUser123";
+            String currentPassword = "OldPass1!";
+            String encodedPassword = bCryptPasswordEncoder.encode(currentPassword);
+            User savedUser = UserFixture.builder()
+                                        .loginId(loginId)
+                                        .password(encodedPassword)
+                                        .build();
+            userJpaRepository.save(savedUser);
+
+            String newPassword = "NewPass1!";
+            UserV1Dto.UpdatePasswordRequest request = new UserV1Dto.UpdatePasswordRequest(newPassword);
+
+            HttpHeaders headers = new HttpHeaders();
+            headers.set("X-Loopers-LoginId", loginId);
+            headers.set("X-Loopers-LoginPw", currentPassword);
+            headers.setContentType(MediaType.APPLICATION_JSON);
+            HttpEntity<UserV1Dto.UpdatePasswordRequest> requestEntity = new HttpEntity<>(request, headers);
+
+            // act
+            ParameterizedTypeReference<ApiResponse<Void>> responseType = new ParameterizedTypeReference<>() {};
+            ResponseEntity<ApiResponse<Void>> response =
+                testRestTemplate.exchange(ENDPOINT_UPDATE_PASSWORD, HttpMethod.PATCH, requestEntity, responseType);
+
+            // assert
+            User updatedUser = userJpaRepository.findByLoginId(loginId).orElseThrow();
+            assertAll(
+                () -> assertThat(response.getStatusCode()).isEqualTo(HttpStatus.OK),
+                () -> assertThat(bCryptPasswordEncoder.matches(newPassword, updatedUser.getPassword())).isTrue()
+            );
+        }
+
+        @DisplayName("존재하지 않는 사용자의 비밀번호를 변경하면, 404 Not Found를 반환한다.")
+        @Test
+        void returnsNotFound_whenUserNotExists() {
+            // arrange
+            UserV1Dto.UpdatePasswordRequest request = new UserV1Dto.UpdatePasswordRequest("NewPass1!");
+
+            HttpHeaders headers = new HttpHeaders();
+            headers.set("X-Loopers-LoginId", "nonExistingId");
+            headers.set("X-Loopers-LoginPw", "OldPass1!");
+            headers.setContentType(MediaType.APPLICATION_JSON);
+            HttpEntity<UserV1Dto.UpdatePasswordRequest> requestEntity = new HttpEntity<>(request, headers);
+
+            // act
+            ParameterizedTypeReference<ApiResponse<Void>> responseType = new ParameterizedTypeReference<>() {};
+            ResponseEntity<ApiResponse<Void>> response =
+                testRestTemplate.exchange(ENDPOINT_UPDATE_PASSWORD, HttpMethod.PATCH, requestEntity, responseType);
+
+            // assert
+            assertThat(response.getStatusCode()).isEqualTo(HttpStatus.NOT_FOUND);
+        }
+
+        @DisplayName("현재 비밀번호가 일치하지 않으면, 400 Bad Request를 반환한다.")
+        @Test
+        void returnsBadRequest_whenCurrentPasswordNotMatches() {
+            // arrange
+            String loginId = "testUser123";
+            String currentPassword = "OldPass1!";
+            String encodedPassword = bCryptPasswordEncoder.encode(currentPassword);
+            User savedUser = UserFixture.builder()
+                    .loginId(loginId)
+                    .password(encodedPassword)
+                    .build();
+            userJpaRepository.save(savedUser);
+
+            UserV1Dto.UpdatePasswordRequest request = new UserV1Dto.UpdatePasswordRequest("NewPass1!");
+
+            HttpHeaders headers = new HttpHeaders();
+            headers.set("X-Loopers-LoginId", loginId);
+            headers.set("X-Loopers-LoginPw", "WrongPass1!");
+            headers.setContentType(MediaType.APPLICATION_JSON);
+            HttpEntity<UserV1Dto.UpdatePasswordRequest> requestEntity = new HttpEntity<>(request, headers);
+
+            // act
+            ParameterizedTypeReference<ApiResponse<Void>> responseType = new ParameterizedTypeReference<>() {};
+            ResponseEntity<ApiResponse<Void>> response =
+                testRestTemplate.exchange(ENDPOINT_UPDATE_PASSWORD, HttpMethod.PATCH, requestEntity, responseType);
+
+            // assert
+            assertThat(response.getStatusCode()).isEqualTo(HttpStatus.BAD_REQUEST);
+        }
+
+        @DisplayName("현재 비밀번호와 동일한 비밀번호로 변경하면, 400 Bad Request를 반환한다.")
+        @Test
+        void returnsBadRequest_whenSamePassword() {
+            // arrange
+            String loginId = "testUser123";
+            String currentPassword = "SamePass1!";
+            String encodedPassword = bCryptPasswordEncoder.encode(currentPassword);
+            User savedUser = UserFixture.builder()
+                    .loginId(loginId)
+                    .password(encodedPassword)
+                    .build();
+            userJpaRepository.save(savedUser);
+
+            UserV1Dto.UpdatePasswordRequest request = new UserV1Dto.UpdatePasswordRequest(currentPassword);
+
+            HttpHeaders headers = new HttpHeaders();
+            headers.set("X-Loopers-LoginId", loginId);
+            headers.set("X-Loopers-LoginPw", currentPassword);
+            headers.setContentType(MediaType.APPLICATION_JSON);
+            HttpEntity<UserV1Dto.UpdatePasswordRequest> requestEntity = new HttpEntity<>(request, headers);
+
+            // act
+            ParameterizedTypeReference<ApiResponse<Void>> responseType = new ParameterizedTypeReference<>() {};
+            ResponseEntity<ApiResponse<Void>> response =
+                testRestTemplate.exchange(ENDPOINT_UPDATE_PASSWORD, HttpMethod.PATCH, requestEntity, responseType);
+
+            // assert
+            assertThat(response.getStatusCode()).isEqualTo(HttpStatus.BAD_REQUEST);
+        }
+    }
+}