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/.gitignore b/.gitignore
index 5a979af6..88ce09aa 100644
--- a/.gitignore
+++ b/.gitignore
@@ -38,3 +38,9 @@ out/
 
 ### Kotlin ###
 .kotlin
+
+### Claude Code ###
+.claude/
+
+### Documentation ###
+docs/
diff --git a/README.md b/README.md
index f86e4dd8..49ee650a 100644
--- a/README.md
+++ b/README.md
@@ -1,40 +1,77 @@
-# Loopers Template (Spring + Java)
-Loopers 에서 제공하는 스프링 자바 템플릿 프로젝트입니다.
-
-## Getting Started
-현재 프로젝트 안정성 및 유지보수성 등을 위해 아래와 같은 장치를 운용하고 있습니다. 이에 아래 명령어를 통해 프로젝트의 기반을 설치해주세요.
-### Environment
-`local` 프로필로 동작할 수 있도록, 필요 인프라를 `docker-compose` 로 제공합니다.
-```shell
-docker-compose -f ./docker/infra-compose.yml up
+# Round-1 
+### 시작 전 목표
+```
+- 나의 의도를 테스트 코드로 작성한다.
+- TDD 방식으로 AI와 함께 기능 구현해본다. 
+- TDD로 요구사항을 먼저 정리하는 장점을 느껴본다.
+- 작게 쪼개고 점진적으로 설계하는 과정을 느껴본다.
+- 리팩토링이 가능하다는것을 느껴본다. 
 ```
-### Monitoring
-`local` 환경에서 모니터링을 할 수 있도록, `docker-compose` 를 통해 `prometheus` 와 `grafana` 를 제공합니다.
 
-애플리케이션 실행 이후, **http://localhost:3000** 로 접속해, admin/admin 계정으로 로그인하여 확인하실 수 있습니다.
-```shell
-docker-compose -f ./docker/monitoring-compose.yml up
+### 시작 후 목표
+- 요구사항을 AI 실행 프롬프트로 구조화하는 방법 알아보기
 ```
+내 현재 학습 초점은 '설계는 내가, 구현은 AI가'라는 명확한 역할 분리다.
+TDD 방식으로 AI에게 코딩을 위임하면서도 설계 결정권은 내가 가져가는 방식이다. 
+여기서 질문이 생겼는데, 기능 요구사항을 받았을 때, 어떤 변환 과정을 거쳐 AI가 정확히 구현할 수 있는 프롬프트 형태로 만들어지는가?'
 
-## About Multi-Module Project
-본 프로젝트는 멀티 모듈 프로젝트로 구성되어 있습니다. 각 모듈의 위계 및 역할을 분명히 하고, 아래와 같은 규칙을 적용합니다.
+이 변환 과정을 알아보는 것을 목표로 했다.
+```
 
-- apps : 각 모듈은 실행가능한 **SpringBootApplication** 을 의미합니다.
-- modules : 특정 구현이나 도메인에 의존적이지 않고, reusable 한 configuration 을 원칙으로 합니다.
-- supports : logging, monitoring 과 같이 부가적인 기능을 지원하는 add-on 모듈입니다.
+### 내가 한 시도
 
-```
-Root
-├── apps ( spring-applications )
-│   ├── 📦 commerce-api
-│   ├── 📦 commerce-batch
-│   └── 📦 commerce-streamer
-├── modules ( reusable-configurations )
-│   ├── 📦 jpa
-│   ├── 📦 redis
-│   └── 📦 kafka
-└── supports ( add-ons )
-    ├── 📦 jackson
-    ├── 📦 monitoring
-    └── 📦 logging
-```
+시도 1: AI가 설계하고, AI가 결정
+- 방식: 기능 요구사항을 그대로 던져주고 TDD(Red-Green-Refactor)로 개발하라고 했다.
+- 문제점: 이 과정에서 내 설계도, 내 의도도 없다는 걸 자각했다. AI가 알아서 다 했을 뿐이었다.
+
+시도 2: AI가 설계하고, 내가 결정
+- 방식: AI가 설계 보고서를 작성하면 내가 읽고 결정하는 위치에 서기로 했다.
+- 문제점:
+  - AI가 너무 복잡한 설계를 제시했다.
+  - 그 문서를 읽는 데 시간이 많이 들었고, 전부 읽을 수도 없었다.
+  - 내 의도가 담긴 설계라고 전혀 느껴지지 않았다.
+
+시도 3: 내가 설계하고, AI의 피드백을 받기
+- 방식: 기능 요구사항으로부터 객체와 메시지 정의, 검증 및 예외 케이스를 내가 직접 문서로 정리했다.
+- 좋았던 점:
+  - 오직 내 설계 틀 안에서 AI가 고려해줘서, 유용한 피드백을 받았다.
+  - 레이어별 특징, 해야 할 것, 하지 말아야 할 것을 먼저 정의해야 한다는 걸 배웠다.
+  - 내가 놓친 엣지 케이스나 잠재적 문제를 해상도 높게 알려주고, 판단을 요구해줬다.
+- 문제점:
+  - 회원가입 기능을 도메인부터 API까지 전부 수도코드로 문서화하고 있었는데, 이러다 보니 생각이 들었다.
+  - "수도코드로 문서화할 바에, 그냥 내가 코드로 먼저 작성하고 이 스타일대로 나머지 기능을 구현하라고 하는 게 더 내 의도가 담긴 코드 아닌가?"
+  - 요구사항 규칙뿐만 아니라 개발 규칙들을 명확히 하는 것이 부족했다. 
+  - 내 의도를 설명하면서 개발 스타일을 알려줄 때, 지금처럼 문서로 전달하는 게 맞는지, 아니면 내가 기능 구현 하나를 예시로 만들어주고 이 스타일을 참고해서 개발하라고 해야 할지 고민이 들었다.
+
+시도 4: 내가 설계하고 시범 구현을 작성하고, AI에게 이 방식대로 하라고 명령
+- 방식: 회원가입 기능을 TDD(Red-Green-Refactor)로 도메인에서 API까지 직접 구현하고, 내 코드 스타일대로 다른 기능 개발을 맡겼다.
+- 진행 과정:
+  - AI는 A부터 Z까지 전부 만들어냈다.
+  - 나는 왜 그렇게 설계했고 만들었는지 물어보는 식으로 AI의 설계 사고를 배우고 있었다.
+  - 이 내용들은 내가 설계를 진행했어도 AI에게 물어볼 내용들이었다.
+  - 내 의도가 담긴 코드라기보다는, 나는 그 의도를 이해해 나가고, 동의하지 않으면 내 설계를 담아내는 식으로 진행했다.
+- 문제점:
+  - 한 번 구현하라고 할 때마다 오래 걸렸다. 처음부터 API까지 관련 모든 코드를 20분 동안 작업하고 있었다.
+  - 전부 한 큐에 완성시키기 때문에 양이 방대했다.
+  - 나는 추가된 main 코드 확인과 테스트 통과 여부만 확인하고 있었다.
+  - 이게 맞는 방식인지는 아직 잘 모르겠다.
+
+
+
+### 과제 후 느낀점
+- AI 협업에 대한 미해결 고민
+  - 아직 어떻게 AI를 파트너로 협업하는 것인지 깨닫지 못했다.
+  - 이번 과제는 사실 처음부터 완벽한 설계를 만들고 AI에게 개발하라고 하는 게 아니라, 기능 요구사항으로부터 개발자가 직접 TDD를 구현하면서 이 과정에서 궁금하거나, 막히거나, 노가다 과정을 AI에게 맡기는 것을 기대한 과제였던 걸까?
+- 클로드 코드 사용 경험
+  - 이번에 클로드 코드를 사용해서 개발해보는 건 처음인데, 한 번의 명령으로 A부터 Z까지 기능 구현, 문서화, 테스트 코드 전부 구현해줘서 놀라웠다.
+  - 더 이상 구현은 중요하지 않다는 것을 이번에 체감했다.
+  - 대신 개발이 되는 환경을 잘 이해하는 것, 계층 책임이나 객체 책임 및 검증 스코프를 잘 정의하는 것, 이런 것들이 더 중요한 것 같은 느낌을 받았다.
+  - 클로드 스킬에 관심이 생겼다.
+
+
+
+---
+
+## 📋 기능 요구 사항
+
+기능 요구 사항 정리 [ToDoList.md](./ToDoList.md)
diff --git a/ToDoList.md b/ToDoList.md
new file mode 100644
index 00000000..3aa6eddf
--- /dev/null
+++ b/ToDoList.md
@@ -0,0 +1,42 @@
+# 기능 요구 사항
+
+
+## 1. 회원가입
+
+### 요구사항
+- **필요 정보 : { 로그인 ID, 비밀번호, 이름, 생년월일, 이메일 }**
+- 이미 가입된 로그인 ID 로는 가입이 불가능함
+- 각 정보는 포맷에 맞는 검증 필요 (이름, 이메일, 생년월일)
+- 비밀번호는 암호화해 저장하며, 아래와 같은 규칙을 따름
+```
+1. 8~16자의 영문 대소문자, 숫자, 특수문자만 가능합니다.
+2. 생년월일은 비밀번호 내에 포함될 수 없습니다.
+```
+> 이후, 유저 정보가 필요한 모든 요청은 아래 헤더를 통해 요청
+> * X-Loopers-LoginId : 로그인 ID
+> * X-Loopers-LoginPw : 비밀번호
+
+
+---
+
+## 2. 내 정보 조회
+- **반환 정보 : { 로그인 ID, 이름, 생년월일, 이메일 }**
+- 로그인 ID 는 영문과 숫자만 허용
+- 이름은 마지막 글자를 마스킹해 반환
+
+> 마스킹 문자는 `*` 로 통일
+>
+
+---
+
+## 3. 비밀번호 수정
+- **필요 정보 : { 기존 비밀번호, 새 비밀번호 }**
+- 비밀 번호 RULE 을 따르되, 현재 비밀번호는 사용할 수 없습니다.
+
+> **비밀번호 RULE**
+> * 영문 대/소문자, 숫자, 특수문자 사용 가능
+> * 생년월일 사용 불가
+
+
+---
+
diff --git a/apps/commerce-api/build.gradle.kts b/apps/commerce-api/build.gradle.kts
index 03ce68f0..6acd8606 100644
--- a/apps/commerce-api/build.gradle.kts
+++ b/apps/commerce-api/build.gradle.kts
@@ -11,6 +11,9 @@ dependencies {
     implementation("org.springframework.boot:spring-boot-starter-actuator")
     implementation("org.springdoc:springdoc-openapi-starter-webmvc-ui:${project.properties["springDocOpenApiVersion"]}")
 
+    // security
+    implementation("org.springframework.security:spring-security-crypto")
+
     // querydsl
     annotationProcessor("com.querydsl:querydsl-apt::jakarta")
     annotationProcessor("jakarta.persistence:jakarta.persistence-api")
diff --git a/apps/commerce-api/src/main/java/com/loopers/domain/AuthenticationService.java b/apps/commerce-api/src/main/java/com/loopers/domain/AuthenticationService.java
new file mode 100644
index 00000000..bf148ae1
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/AuthenticationService.java
@@ -0,0 +1,28 @@
+package com.loopers.domain;
+
+import com.loopers.infrastructure.PasswordEncoder;
+import com.loopers.support.error.CoreException;
+import com.loopers.support.error.ErrorType;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+
+@Service
+@RequiredArgsConstructor
+public class AuthenticationService {
+
+    private final UserRepository userRepository;
+    private final PasswordEncoder passwordEncoder;
+
+    public UserModel authenticate(String loginIdValue, String rawPassword) {
+        LoginId loginId = new LoginId(loginIdValue);
+
+        UserModel user = userRepository.find(loginId)
+            .orElseThrow(() -> new CoreException(ErrorType.UNAUTHORIZED, "로그인 ID 또는 비밀번호가 일치하지 않습니다."));
+
+        if (!passwordEncoder.matches(rawPassword, user.getPassword().getValue())) {
+            throw new CoreException(ErrorType.UNAUTHORIZED, "로그인 ID 또는 비밀번호가 일치하지 않습니다.");
+        }
+
+        return user;
+    }
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/domain/BirthDate.java b/apps/commerce-api/src/main/java/com/loopers/domain/BirthDate.java
new file mode 100644
index 00000000..8dcb741c
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/BirthDate.java
@@ -0,0 +1,41 @@
+package com.loopers.domain;
+
+import com.loopers.support.error.CoreException;
+import com.loopers.support.error.ErrorType;
+import jakarta.persistence.Embeddable;
+import java.time.LocalDate;
+import java.time.format.DateTimeFormatter;
+import lombok.EqualsAndHashCode;
+
+@Embeddable
+@EqualsAndHashCode
+public class BirthDate {
+
+    private static final DateTimeFormatter DATE_STRING_FORMATTER = DateTimeFormatter.ofPattern("yyyyMMdd");
+
+    private LocalDate birthDate;
+
+    protected BirthDate() {}
+
+    public BirthDate(LocalDate birthDate) {
+        validate(birthDate);
+        this.birthDate = birthDate;
+    }
+
+    private void validate(LocalDate birthDate) {
+        if (birthDate == null) {
+            throw new CoreException(ErrorType.BAD_REQUEST,"생년월일은 필수 입력값입니다.");
+        }
+        if (birthDate.isAfter(LocalDate.now())) {
+            throw new CoreException(ErrorType.BAD_REQUEST,"생년월일은 과거 날짜여야 합니다.");
+        }
+    }
+
+    public String toDateString() {
+        return birthDate.format(DATE_STRING_FORMATTER);
+    }
+
+    public LocalDate getDate() {
+        return birthDate;
+    }
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/domain/Email.java b/apps/commerce-api/src/main/java/com/loopers/domain/Email.java
new file mode 100644
index 00000000..767b156b
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/Email.java
@@ -0,0 +1,34 @@
+package com.loopers.domain;
+
+import com.loopers.support.error.CoreException;
+import com.loopers.support.error.ErrorType;
+import jakarta.persistence.Embeddable;
+import java.util.regex.Pattern;
+import lombok.EqualsAndHashCode;
+import lombok.Getter;
+
+@Embeddable
+@Getter
+@EqualsAndHashCode
+public class Email {
+    private static final Pattern EMAIL_PATTERN = Pattern.compile("^[A-Za-z0-9+_.-]+@([A-Za-z0-9-]+\\.)+[A-Za-z]{2,}$");
+
+    private String mail;
+
+    protected Email() {}
+
+    public Email(String mail) {
+        validateEmail(mail);
+        this.mail = mail;
+    }
+
+    private void validateEmail(String mail) {
+        if (mail == null || mail.isBlank()) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "이메일은 비어있을 수 없습니다.");
+        }
+
+        if (!EMAIL_PATTERN.matcher(mail).matches()) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "이메일 형식이 올바르지 않습니다.");
+        }
+    }
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/domain/LoginId.java b/apps/commerce-api/src/main/java/com/loopers/domain/LoginId.java
new file mode 100644
index 00000000..98e718ed
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/LoginId.java
@@ -0,0 +1,41 @@
+package com.loopers.domain;
+
+import com.loopers.support.error.CoreException;
+import com.loopers.support.error.ErrorType;
+import jakarta.persistence.Embeddable;
+import java.util.regex.Pattern;
+import lombok.EqualsAndHashCode;
+
+@Embeddable
+@EqualsAndHashCode
+public class LoginId {
+    private static final int MIN_LENGTH = 4;
+    private static final int MAX_LENGTH = 12;
+
+    private static final Pattern ALPHANUMERIC_PATTERN = Pattern.compile("^[a-zA-Z0-9]*$");
+
+    private String value;
+
+    protected LoginId() {}
+
+    public LoginId(String value) {
+        validate(value);
+        this.value = value;
+    }
+
+    private void validate(String value) {
+        if (value == null || value.isBlank()) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "로그인 ID는 비어있을 수 없습니다.");
+        }
+        if (value.length() < MIN_LENGTH || value.length() > MAX_LENGTH) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "로그인 ID는 4자에서 12자 사이여야 합니다.");
+        }
+        if (!ALPHANUMERIC_PATTERN.matcher(value).matches()) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "로그인 ID는 영문과 숫자만 허용됩니다.");
+        }
+    }
+
+    public String getValue() {
+        return value;
+    }
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/domain/Name.java b/apps/commerce-api/src/main/java/com/loopers/domain/Name.java
new file mode 100644
index 00000000..e7495e8c
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/Name.java
@@ -0,0 +1,35 @@
+package com.loopers.domain;
+
+import com.loopers.support.error.CoreException;
+import com.loopers.support.error.ErrorType;
+import jakarta.persistence.Embeddable;
+import lombok.EqualsAndHashCode;
+
+@Embeddable
+@EqualsAndHashCode
+public class Name {
+    private final static int MIN_LENGTH = 2;
+    private final static int MAX_LENGTH = 10;
+    private String name;
+
+    protected Name() {}
+
+    public Name(String name) {
+        validate(name);
+        this.name = name;
+    }
+
+    private void validate(String name) {
+        if (name == null || name.isBlank()) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "이름은 비어있을 수 없습니다.");
+        }
+        if(name.length() < MIN_LENGTH ||  name.length() > MAX_LENGTH){
+            throw new CoreException(ErrorType.BAD_REQUEST, "유효하지 않은 이름 길이입니다.");
+        }
+    }
+
+    public String getMaskedName() {
+        if (name == null || name.isEmpty()) return name;
+        return name.substring(0, name.length() - 1) + "*";
+    }
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/domain/Password.java b/apps/commerce-api/src/main/java/com/loopers/domain/Password.java
new file mode 100644
index 00000000..17d4ec1d
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/Password.java
@@ -0,0 +1,56 @@
+package com.loopers.domain;
+
+import com.loopers.support.error.CoreException;
+import com.loopers.support.error.ErrorType;
+import jakarta.persistence.Embeddable;
+import java.util.regex.Pattern;
+import lombok.EqualsAndHashCode;
+
+@Embeddable
+@EqualsAndHashCode
+public class Password {
+    // 특수문자 범위를 ~!@#$%^&*()_+=- 로 확장했습니다.
+    private static final Pattern PASSWORD_PATTERN =
+            Pattern.compile("^(?=.*[a-z])(?=.*[A-Z])(?=.*\\d)(?=.*[~!@#$%^&*()_+=-])[A-Za-z\\d~!@#$%^&*()_+=-]{8,16}$");
+
+    private String value;
+
+    protected Password() {}
+
+    public Password(String value) {
+        validate(value);
+        this.value = value;
+    }
+
+    private Password(String value, boolean skipValidation) {
+        this.value = value;
+    }
+
+    public static Password fromEncoded(String encodedValue) {
+        return new Password(encodedValue, true);
+    }
+
+    private void validate(String value) {
+        if (value == null || !PASSWORD_PATTERN.matcher(value).matches()) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "비밀번호는 8~16자의 영문 대소문자, 숫자, 특수문자 조합이어야 합니다.");
+        }
+    }
+
+    public void validateNotContainBirthday(BirthDate birthDate) {
+        String birthDateString = birthDate.toDateString();
+
+        if (this.value.contains(birthDateString)) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "생년월일은 비밀번호 내에 포함될 수 없습니다.");
+        }
+    }
+
+    public void validateNotSameAs(Password other) {
+        if (this.equals(other)) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "현재 사용 중인 비밀번호는 사용할 수 없습니다.");
+        }
+    }
+
+    public String getValue() {
+        return value;
+    }
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/domain/UserModel.java b/apps/commerce-api/src/main/java/com/loopers/domain/UserModel.java
new file mode 100644
index 00000000..4c76f23d
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/UserModel.java
@@ -0,0 +1,67 @@
+package com.loopers.domain;
+
+import com.loopers.support.error.CoreException;
+import com.loopers.support.error.ErrorType;
+import jakarta.persistence.AttributeOverride;
+import jakarta.persistence.Column;
+import jakarta.persistence.Embedded;
+import jakarta.persistence.Entity;
+import jakarta.persistence.Table;
+import lombok.AccessLevel;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+
+@Getter
+@Entity
+@Table(name = "users")
+@NoArgsConstructor(access = AccessLevel.PROTECTED)
+public class UserModel extends BaseEntity {
+
+    @Embedded
+    @AttributeOverride(name = "value", column = @Column(name = "login_id"))
+    private LoginId loginId;
+
+    @Embedded
+    @AttributeOverride(name = "value", column = @Column(name = "password"))
+    private Password password;
+
+    @Embedded
+    @AttributeOverride(name = "name", column = @Column(name = "name"))
+    private Name name;
+
+    @Embedded
+    @AttributeOverride(name = "birthDate", column = @Column(name = "birth_date"))
+    private BirthDate birthDate;
+
+    @Embedded
+    @AttributeOverride(name = "mail", column = @Column(name = "email"))
+    private Email email;
+
+    public UserModel(LoginId loginId, Password password, Name name, BirthDate birthDate, Email email) {
+        validate(loginId, password, name, birthDate, email);
+        this.loginId = loginId;
+        this.password = password;
+        this.name = name;
+        this.birthDate = birthDate;
+        this.email = email;
+    }
+
+    private void validate(LoginId loginId, Password password, Name name, BirthDate birthDate, Email email) {
+        validateNotNull(loginId, "로그인 ID");
+        validateNotNull(password, "비밀번호");
+        validateNotNull(name, "이름");
+        validateNotNull(birthDate, "생년월일");
+        validateNotNull(email, "이메일");
+    }
+    private void validateNotNull(Object value, String fieldName) {
+        if (value == null) {
+            throw new CoreException(ErrorType.BAD_REQUEST,fieldName + "은(는) 필수 입력값입니다.");
+        }
+    }
+
+    public void changePassword(Password currentPassword, Password newPassword) {
+        // 검증은 UserService에서 수행
+        this.password = newPassword;
+    }
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/domain/UserRepository.java b/apps/commerce-api/src/main/java/com/loopers/domain/UserRepository.java
new file mode 100644
index 00000000..64706be3
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/UserRepository.java
@@ -0,0 +1,9 @@
+package com.loopers.domain;
+
+import java.util.Optional;
+
+public interface UserRepository {
+    UserModel save(UserModel userModel);
+
+    Optional<UserModel> find(LoginId loginId);
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/domain/UserService.java b/apps/commerce-api/src/main/java/com/loopers/domain/UserService.java
new file mode 100644
index 00000000..874c1f87
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/UserService.java
@@ -0,0 +1,62 @@
+package com.loopers.domain;
+
+import com.loopers.infrastructure.PasswordEncoder;
+import com.loopers.support.error.CoreException;
+import com.loopers.support.error.ErrorType;
+import jakarta.transaction.Transactional;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+
+@Service
+@RequiredArgsConstructor
+public class UserService {
+    private final UserRepository userRepository;
+    private final PasswordEncoder passwordEncoder;
+
+    @Transactional
+    public UserModel signup(LoginId loginId, Password password, Name name, BirthDate birthDate, Email email) {
+
+        if(userRepository.find(loginId).isPresent()) {
+            throw new CoreException(ErrorType.BAD_REQUEST,"이미 존재하는 아이디입니다.");
+        }
+
+        password.validateNotContainBirthday(birthDate);
+
+        String encodedPasswordValue = passwordEncoder.encode(password.getValue());
+        Password encryptedPassword = Password.fromEncoded(encodedPasswordValue);
+
+        UserModel userModel = new UserModel(loginId,encryptedPassword,name,birthDate,email);
+
+        return userRepository.save(userModel);
+    }
+
+    public UserModel getMyInfo(LoginId loginId) {
+        return userRepository.find(loginId)
+            .orElseThrow(() -> new CoreException(ErrorType.NOT_FOUND, "사용자를 찾을 수 없습니다."));
+    }
+
+    @Transactional
+    public void changePassword(LoginId loginId, Password currentPassword, Password newPassword) {
+        UserModel user = userRepository.find(loginId)
+            .orElseThrow(() -> new CoreException(ErrorType.NOT_FOUND, "사용자를 찾을 수 없습니다."));
+
+        // 현재 비밀번호 검증
+        if (!passwordEncoder.matches(currentPassword.getValue(), user.getPassword().getValue())) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "현재 비밀번호가 일치하지 않습니다.");
+        }
+
+        // 새 비밀번호 검증
+        if (passwordEncoder.matches(newPassword.getValue(), user.getPassword().getValue())) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "현재 사용 중인 비밀번호는 사용할 수 없습니다.");
+        }
+
+        newPassword.validateNotContainBirthday(user.getBirthDate());
+
+        // 새 비밀번호 암호화 및 저장
+        String encodedNewPassword = passwordEncoder.encode(newPassword.getValue());
+        Password encryptedNewPassword = Password.fromEncoded(encodedNewPassword);
+
+        user.changePassword(Password.fromEncoded(user.getPassword().getValue()), encryptedNewPassword);
+        userRepository.save(user);
+    }
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/infrastructure/BCryptPasswordEncoderImpl.java b/apps/commerce-api/src/main/java/com/loopers/infrastructure/BCryptPasswordEncoderImpl.java
new file mode 100644
index 00000000..6545f186
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/infrastructure/BCryptPasswordEncoderImpl.java
@@ -0,0 +1,24 @@
+package com.loopers.infrastructure;
+
+import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
+import org.springframework.stereotype.Component;
+
+@Component
+public class BCryptPasswordEncoderImpl implements PasswordEncoder {
+
+    private final BCryptPasswordEncoder delegate;
+
+    public BCryptPasswordEncoderImpl() {
+        this.delegate = new BCryptPasswordEncoder();
+    }
+
+    @Override
+    public String encode(String rawPassword) {
+        return delegate.encode(rawPassword);
+    }
+
+    @Override
+    public boolean matches(String rawPassword, String encodedPassword) {
+        return delegate.matches(rawPassword, encodedPassword);
+    }
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/infrastructure/PasswordEncoder.java b/apps/commerce-api/src/main/java/com/loopers/infrastructure/PasswordEncoder.java
new file mode 100644
index 00000000..fbe0ff62
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/infrastructure/PasswordEncoder.java
@@ -0,0 +1,6 @@
+package com.loopers.infrastructure;
+
+public interface PasswordEncoder {
+    String encode(String rawPassword);
+    boolean matches(String rawPassword, String encodedPassword);
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/infrastructure/UserJpaRepository.java b/apps/commerce-api/src/main/java/com/loopers/infrastructure/UserJpaRepository.java
new file mode 100644
index 00000000..adf3d6a3
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/infrastructure/UserJpaRepository.java
@@ -0,0 +1,10 @@
+package com.loopers.infrastructure;
+
+import com.loopers.domain.LoginId;
+import com.loopers.domain.UserModel;
+import java.util.Optional;
+import org.springframework.data.jpa.repository.JpaRepository;
+
+public interface UserJpaRepository extends JpaRepository<UserModel,Long> {
+    Optional<UserModel> findByLoginId(LoginId loginId);
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/infrastructure/UserRepositoryImpl.java b/apps/commerce-api/src/main/java/com/loopers/infrastructure/UserRepositoryImpl.java
new file mode 100644
index 00000000..afecf020
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/infrastructure/UserRepositoryImpl.java
@@ -0,0 +1,24 @@
+package com.loopers.infrastructure;
+
+import com.loopers.domain.LoginId;
+import com.loopers.domain.UserModel;
+import com.loopers.domain.UserRepository;
+import java.util.Optional;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Component;
+
+@RequiredArgsConstructor
+@Component
+public class UserRepositoryImpl implements UserRepository {
+    private final UserJpaRepository userJpaRepository;
+
+    @Override
+    public UserModel save(UserModel userModel) {
+        return userJpaRepository.save(userModel);
+    }
+
+    @Override
+    public Optional<UserModel> find(LoginId 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..2ec0dbbd 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,8 @@
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.http.ResponseEntity;
 import org.springframework.http.converter.HttpMessageNotReadableException;
+import org.springframework.validation.FieldError;
+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 +48,13 @@ public ResponseEntity<ApiResponse<?>> handleBadRequest(MissingServletRequestPara
         return failureResponse(ErrorType.BAD_REQUEST, message);
     }
 
+    @ExceptionHandler
+    public ResponseEntity<ApiResponse<?>> handleBadRequest(MethodArgumentNotValidException e) {
+        FieldError fieldError = e.getBindingResult().getFieldError();
+        String message = fieldError != null ? fieldError.getDefaultMessage() : "잘못된 요청입니다.";
+        return failureResponse(ErrorType.BAD_REQUEST, message);
+    }
+
     @ExceptionHandler
     public ResponseEntity<ApiResponse<?>> handleBadRequest(HttpMessageNotReadableException e) {
         String errorMessage;
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
new file mode 100644
index 00000000..b3d0743c
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/user/UserV1ApiSpec.java
@@ -0,0 +1,44 @@
+package com.loopers.interfaces.api.user;
+
+import com.loopers.interfaces.api.ApiResponse;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.Parameter;
+import io.swagger.v3.oas.annotations.parameters.RequestBody;
+import io.swagger.v3.oas.annotations.tags.Tag;
+
+@Tag(name = "User V1 API", description = "사용자 API 입니다.")
+public interface UserV1ApiSpec {
+
+    @Operation(
+        summary = "회원가입",
+        description = "새로운 사용자를 등록합니다."
+    )
+    ApiResponse<UserV1Dto.SignupResponse> signup(
+        @RequestBody(description = "회원가입 요청 정보")
+        UserV1Dto.SignupRequest request
+    );
+
+    @Operation(
+        summary = "내 정보 조회",
+        description = "인증된 사용자의 정보를 조회합니다. 헤더에 X-Loopers-LoginId와 X-Loopers-LoginPw를 포함해야 합니다."
+    )
+    ApiResponse<UserV1Dto.MyInfoResponse> getMyInfo(
+        @Parameter(description = "로그인 ID", required = true)
+        String loginId,
+        @Parameter(description = "비밀번호", required = true)
+        String password
+    );
+
+    @Operation(
+        summary = "비밀번호 변경",
+        description = "인증된 사용자의 비밀번호를 변경합니다. 헤더에 X-Loopers-LoginId와 X-Loopers-LoginPw를 포함해야 합니다."
+    )
+    ApiResponse<UserV1Dto.ChangePasswordResponse> changePassword(
+        @Parameter(description = "로그인 ID", required = true)
+        String loginId,
+        @Parameter(description = "현재 비밀번호", required = true)
+        String currentPassword,
+        @RequestBody(description = "비밀번호 변경 요청 정보")
+        UserV1Dto.ChangePasswordRequest request
+    );
+}
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..2f715515
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/user/UserV1Controller.java
@@ -0,0 +1,70 @@
+package com.loopers.interfaces.api.user;
+
+import com.loopers.domain.*;
+import com.loopers.interfaces.api.ApiResponse;
+import jakarta.validation.Valid;
+import lombok.RequiredArgsConstructor;
+import org.springframework.web.bind.annotation.*;
+
+import java.time.LocalDate;
+import java.time.format.DateTimeFormatter;
+
+@RequiredArgsConstructor
+@RestController
+@RequestMapping("/api/v1/users")
+public class UserV1Controller implements UserV1ApiSpec {
+
+    private static final DateTimeFormatter BIRTH_DATE_FORMATTER = DateTimeFormatter.ofPattern("yyyyMMdd");
+    private static final String HEADER_LOGIN_ID = "X-Loopers-LoginId";
+    private static final String HEADER_LOGIN_PW = "X-Loopers-LoginPw";
+
+    private final UserService userService;
+    private final AuthenticationService authenticationService;
+
+    @PostMapping("/signup")
+    @Override
+    public ApiResponse<UserV1Dto.SignupResponse> signup(
+        @Valid @RequestBody UserV1Dto.SignupRequest request
+    ) {
+        LoginId loginId = new LoginId(request.loginId());
+        Password password = new Password(request.password());
+        Name name = new Name(request.name());
+        BirthDate birthDate = new BirthDate(LocalDate.parse(request.birthDate(), BIRTH_DATE_FORMATTER));
+        Email email = new Email(request.email());
+
+        UserModel userModel = userService.signup(loginId, password, name, birthDate, email);
+        UserV1Dto.SignupResponse response = UserV1Dto.SignupResponse.from(userModel);
+
+        return ApiResponse.success(response);
+    }
+
+    @GetMapping("/me")
+    @Override
+    public ApiResponse<UserV1Dto.MyInfoResponse> getMyInfo(
+        @RequestHeader(HEADER_LOGIN_ID) String loginId,
+        @RequestHeader(HEADER_LOGIN_PW) String password
+    ) {
+        UserModel authenticatedUser = authenticationService.authenticate(loginId, password);
+        UserModel userInfo = userService.getMyInfo(authenticatedUser.getLoginId());
+        UserV1Dto.MyInfoResponse response = UserV1Dto.MyInfoResponse.from(userInfo);
+
+        return ApiResponse.success(response);
+    }
+
+    @PatchMapping("/password")
+    @Override
+    public ApiResponse<UserV1Dto.ChangePasswordResponse> changePassword(
+        @RequestHeader(HEADER_LOGIN_ID) String loginId,
+        @RequestHeader(HEADER_LOGIN_PW) String currentPasswordValue,
+        @Valid @RequestBody UserV1Dto.ChangePasswordRequest request
+    ) {
+        UserModel authenticatedUser = authenticationService.authenticate(loginId, currentPasswordValue);
+
+        Password currentPassword = new Password(request.currentPassword());
+        Password newPassword = new Password(request.newPassword());
+
+        userService.changePassword(authenticatedUser.getLoginId(), currentPassword, newPassword);
+
+        return ApiResponse.success(UserV1Dto.ChangePasswordResponse.success());
+    }
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/interfaces/api/user/UserV1Dto.java b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/user/UserV1Dto.java
new file mode 100644
index 00000000..7daae480
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/user/UserV1Dto.java
@@ -0,0 +1,92 @@
+package com.loopers.interfaces.api.user;
+
+import com.loopers.domain.UserModel;
+import jakarta.validation.constraints.Email;
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.Pattern;
+import jakarta.validation.constraints.Size;
+
+public class UserV1Dto {
+
+    public record SignupRequest(
+        @NotBlank(message = "로그인 ID는 필수 입력값입니다.")
+        @Size(min = 4, max = 12, message = "로그인 ID는 4자에서 12자 사이여야 합니다.")
+        @Pattern(regexp = "^[a-zA-Z0-9]*$", message = "로그인 ID는 영문과 숫자만 허용됩니다.")
+        String loginId,
+
+        @NotBlank(message = "비밀번호는 필수 입력값입니다.")
+        @Pattern(
+            regexp = "^(?=.*[a-z])(?=.*[A-Z])(?=.*\\d)(?=.*[~!@#$%^&*()_+=-])[A-Za-z\\d~!@#$%^&*()_+=-]{8,16}$",
+            message = "비밀번호는 8~16자의 영문 대소문자, 숫자, 특수문자 조합이어야 합니다."
+        )
+        String password,
+
+        @NotBlank(message = "이름은 필수 입력값입니다.")
+        @Size(min = 2, max = 10, message = "이름은 2자에서 10자 사이여야 합니다.")
+        String name,
+
+        @NotBlank(message = "생년월일은 필수 입력값입니다.")
+        @Pattern(regexp = "^\\d{8}$", message = "생년월일은 yyyyMMdd 형식이어야 합니다.")
+        String birthDate,
+
+        @NotBlank(message = "이메일은 필수 입력값입니다.")
+        @Email(message = "이메일 형식이 올바르지 않습니다.")
+        String email
+    ) {
+    }
+
+    public record SignupResponse(
+        Long id,
+        String loginId,
+        String name,
+        String birthDate,
+        String email
+    ) {
+        public static SignupResponse from(UserModel model) {
+            return new SignupResponse(
+                model.getId(),
+                model.getLoginId().getValue(),
+                model.getName().getMaskedName(),
+                model.getBirthDate().toDateString(),
+                model.getEmail().getMail()
+            );
+        }
+    }
+
+    public record MyInfoResponse(
+        String loginId,
+        String name,
+        String birthDate,
+        String email
+    ) {
+        public static MyInfoResponse from(UserModel model) {
+            return new MyInfoResponse(
+                model.getLoginId().getValue(),
+                model.getName().getMaskedName(),
+                model.getBirthDate().toDateString(),
+                model.getEmail().getMail()
+            );
+        }
+    }
+
+    public record ChangePasswordRequest(
+        @NotBlank(message = "현재 비밀번호는 필수 입력값입니다.")
+        String currentPassword,
+
+        @NotBlank(message = "새 비밀번호는 필수 입력값입니다.")
+        @Pattern(
+            regexp = "^(?=.*[a-z])(?=.*[A-Z])(?=.*\\d)(?=.*[~!@#$%^&*()_+=-])[A-Za-z\\d~!@#$%^&*()_+=-]{8,16}$",
+            message = "비밀번호는 8~16자의 영문 대소문자, 숫자, 특수문자 조합이어야 합니다."
+        )
+        String newPassword
+    ) {
+    }
+
+    public record ChangePasswordResponse(
+        String message
+    ) {
+        public static ChangePasswordResponse success() {
+            return new ChangePasswordResponse("비밀번호가 성공적으로 변경되었습니다.");
+        }
+    }
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/support/error/ErrorType.java b/apps/commerce-api/src/main/java/com/loopers/support/error/ErrorType.java
index 5d142efb..8d493491 100644
--- a/apps/commerce-api/src/main/java/com/loopers/support/error/ErrorType.java
+++ b/apps/commerce-api/src/main/java/com/loopers/support/error/ErrorType.java
@@ -10,6 +10,7 @@ public enum ErrorType {
     /** 범용 에러 */
     INTERNAL_ERROR(HttpStatus.INTERNAL_SERVER_ERROR, HttpStatus.INTERNAL_SERVER_ERROR.getReasonPhrase(), "일시적인 오류가 발생했습니다."),
     BAD_REQUEST(HttpStatus.BAD_REQUEST, HttpStatus.BAD_REQUEST.getReasonPhrase(), "잘못된 요청입니다."),
+    UNAUTHORIZED(HttpStatus.UNAUTHORIZED, HttpStatus.UNAUTHORIZED.getReasonPhrase(), "인증에 실패했습니다."),
     NOT_FOUND(HttpStatus.NOT_FOUND, HttpStatus.NOT_FOUND.getReasonPhrase(), "존재하지 않는 요청입니다."),
     CONFLICT(HttpStatus.CONFLICT, HttpStatus.CONFLICT.getReasonPhrase(), "이미 존재하는 리소스입니다.");
 
diff --git a/apps/commerce-api/src/test/java/com/loopers/domain/AuthenticationServiceTest.java b/apps/commerce-api/src/test/java/com/loopers/domain/AuthenticationServiceTest.java
new file mode 100644
index 00000000..1cf99940
--- /dev/null
+++ b/apps/commerce-api/src/test/java/com/loopers/domain/AuthenticationServiceTest.java
@@ -0,0 +1,114 @@
+package com.loopers.domain;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.when;
+
+import com.loopers.support.error.CoreException;
+import com.loopers.support.error.ErrorType;
+import java.time.LocalDate;
+import java.util.Optional;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+@DisplayName("AuthenticationService 단위 테스트")
+@ExtendWith(MockitoExtension.class)
+class AuthenticationServiceTest {
+
+    @Mock
+    private UserRepository userRepository;
+
+    @Mock
+    private com.loopers.infrastructure.PasswordEncoder passwordEncoder;
+
+    @InjectMocks
+    private AuthenticationService authenticationService;
+
+    private UserModel testUser;
+    private String validLoginId;
+    private String validPassword;
+    private String encodedPassword;
+
+    @BeforeEach
+    void setUp() {
+        validLoginId = "testuser123";
+        validPassword = "Test1234!@#";
+        encodedPassword = "$2a$10$encodedPasswordHash";
+
+        testUser = new UserModel(
+            new LoginId(validLoginId),
+            Password.fromEncoded(encodedPassword),
+            new Name("홍길동"),
+            new BirthDate(LocalDate.of(1990, 1, 15)),
+            new Email("test@example.com")
+        );
+    }
+
+    @DisplayName("authenticate 메서드는")
+    @Nested
+    class Authenticate {
+
+        @Test
+        @DisplayName("올바른 로그인 ID와 비밀번호로 인증하면 사용자 정보를 반환한다")
+        void authenticate_should_return_user_when_credentials_are_correct() {
+            // arrange
+            when(userRepository.find(any(LoginId.class))).thenReturn(Optional.of(testUser));
+            when(passwordEncoder.matches(validPassword, encodedPassword)).thenReturn(true);
+
+            // act
+            UserModel result = authenticationService.authenticate(validLoginId, validPassword);
+
+            // assert
+            assertThat(result).isNotNull();
+            assertThat(result.getLoginId().getValue()).isEqualTo(validLoginId);
+        }
+
+        @Test
+        @DisplayName("존재하지 않는 로그인 ID로 인증하면 UNAUTHORIZED 예외를 던진다")
+        void authenticate_should_throw_exception_when_user_not_found() {
+            // arrange
+            when(userRepository.find(any(LoginId.class))).thenReturn(Optional.empty());
+
+            // act & assert
+            assertThatThrownBy(() -> authenticationService.authenticate(validLoginId, validPassword))
+                .isInstanceOf(CoreException.class)
+                .hasFieldOrPropertyWithValue("errorType", ErrorType.UNAUTHORIZED)
+                .hasMessageContaining("로그인 ID 또는 비밀번호가 일치하지 않습니다.");
+        }
+
+        @Test
+        @DisplayName("잘못된 비밀번호로 인증하면 UNAUTHORIZED 예외를 던진다")
+        void authenticate_should_throw_exception_when_password_is_incorrect() {
+            // arrange
+            when(userRepository.find(any(LoginId.class))).thenReturn(Optional.of(testUser));
+            String wrongPassword = "Wrong1234!@#";
+            when(passwordEncoder.matches(wrongPassword, encodedPassword)).thenReturn(false);
+
+            // act & assert
+            assertThatThrownBy(() -> authenticationService.authenticate(validLoginId, wrongPassword))
+                .isInstanceOf(CoreException.class)
+                .hasFieldOrPropertyWithValue("errorType", ErrorType.UNAUTHORIZED)
+                .hasMessageContaining("로그인 ID 또는 비밀번호가 일치하지 않습니다.");
+        }
+
+        @Test
+        @DisplayName("비밀번호가 null이면 UNAUTHORIZED 예외를 던진다")
+        void authenticate_should_throw_exception_when_password_is_null() {
+            // arrange
+            when(userRepository.find(any(LoginId.class))).thenReturn(Optional.of(testUser));
+            when(passwordEncoder.matches(null, encodedPassword)).thenReturn(false);
+
+            // act & assert
+            assertThatThrownBy(() -> authenticationService.authenticate(validLoginId, null))
+                .isInstanceOf(CoreException.class)
+                .hasFieldOrPropertyWithValue("errorType", ErrorType.UNAUTHORIZED);
+        }
+    }
+}
diff --git a/apps/commerce-api/src/test/java/com/loopers/domain/BirthDateTest.java b/apps/commerce-api/src/test/java/com/loopers/domain/BirthDateTest.java
new file mode 100644
index 00000000..cb3c0304
--- /dev/null
+++ b/apps/commerce-api/src/test/java/com/loopers/domain/BirthDateTest.java
@@ -0,0 +1,69 @@
+package com.loopers.domain;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+import com.loopers.support.error.CoreException;
+import java.time.LocalDate;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+
+class BirthDateTest {
+
+    @DisplayName("생년월일 객체를 생성할 때, ")
+    @Nested
+    class Create {
+
+        @DisplayName("과거 혹은 현재의 날짜가 주어지면, 정상적으로 생성된다.")
+        @Test
+        void createBirthDate_whenValidDateProvided() {
+            // arrange
+            LocalDate validDate = LocalDate.of(1995, 5, 20);
+
+            // act
+            BirthDate birthDate = new BirthDate(validDate);
+
+            // assert
+            assertThat(birthDate.getDate()).isEqualTo(validDate);
+        }
+
+        @DisplayName("날짜가 null이면 예외가 발생한다.")
+        @Test
+        void createBirthDate_whenDateIsNull() {
+            assertThatThrownBy(() -> new BirthDate(null))
+                    .isInstanceOf(CoreException.class)
+                    .hasMessageContaining("필수 입력값입니다.");
+        }
+
+        @DisplayName("날짜가 미래의 날짜이면 예외가 발생한다.")
+        @Test
+        void createBirthDate_whenDateIsInFuture() {
+            // arrange
+            LocalDate futureDate = LocalDate.now().plusDays(1);
+
+            // act & assert
+            assertThatThrownBy(() -> new BirthDate(futureDate))
+                    .isInstanceOf(CoreException.class)
+                    .hasMessageContaining("과거 날짜여야 합니다.");
+        }
+    }
+
+    @DisplayName("날짜를 문자열로 변환할 때, ")
+    @Nested
+    class Conversion {
+
+        @DisplayName("yyyyMMdd 형식의 문자열을 반환한다.")
+        @Test
+        void toDateString_returnsFormattedString() {
+            // arrange
+            BirthDate birthDate = new BirthDate(LocalDate.of(1988, 12, 5));
+
+            // act
+            String result = birthDate.toDateString();
+
+            // assert
+            assertThat(result).isEqualTo("19881205");
+        }
+    }
+}
diff --git a/apps/commerce-api/src/test/java/com/loopers/domain/EmailTest.java b/apps/commerce-api/src/test/java/com/loopers/domain/EmailTest.java
new file mode 100644
index 00000000..245c1f36
--- /dev/null
+++ b/apps/commerce-api/src/test/java/com/loopers/domain/EmailTest.java
@@ -0,0 +1,66 @@
+package com.loopers.domain;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+import com.loopers.support.error.CoreException;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
+
+class EmailTest {
+
+    @DisplayName("이메일 객체를 생성할 때, ")
+    @Nested
+    class Create {
+
+        @DisplayName("올바른 이메일 형식이 주어지면, 정상적으로 생성된다.")
+        @ParameterizedTest
+        @ValueSource(strings = {
+                "test@example.com",
+                "user.name+tag@domain.co.kr",
+                "12345@loopers.io",
+                "email@sub.domain.com"
+        })
+        void createEmail_whenValidFormat(String validEmail) {
+            // act
+            Email email = new Email(validEmail);
+
+            // assert
+            assertThat(email.getMail()).isEqualTo(validEmail);
+        }
+
+        @DisplayName("이메일이 null이거나 비어있으면 예외가 발생한다.")
+        @ParameterizedTest
+        @ValueSource(strings = {"", " ", "   "})
+        void createEmail_whenNullOrBlank(String blankEmail) {
+            // null 케이스 별도 테스트
+            assertThatThrownBy(() -> new Email(null))
+                    .isInstanceOf(CoreException.class)
+                    .hasMessageContaining("이메일은 비어있을 수 없습니다.");
+
+            // 공백 케이스
+            assertThatThrownBy(() -> new Email(blankEmail))
+                    .isInstanceOf(CoreException.class)
+                    .hasMessageContaining("이메일은 비어있을 수 없습니다.");
+        }
+
+        @DisplayName("형식이 올바르지 않으면 예외가 발생한다.")
+        @ParameterizedTest
+        @ValueSource(strings = {
+                "plainaddress",      // @ 없음
+                "#@%^%#$@#$@#.com",  // 특수문자 남발
+                "@domain.com",       // 로컬 파트 없음
+                "Joe Smith <email@domain.com>", // 이름 포함
+                "email.domain.com",  // @ 없음
+                "email@domain@domain.com", // @ 중복
+                "email@domain..com"  // 도메인 마침표 중복
+        })
+        void createEmail_whenInvalidFormat(String invalidEmail) {
+            assertThatThrownBy(() -> new Email(invalidEmail))
+                    .isInstanceOf(CoreException.class)
+                    .hasMessageContaining("이메일 형식이 올바르지 않습니다.");
+        }
+    }
+}
diff --git a/apps/commerce-api/src/test/java/com/loopers/domain/LoginIdTest.java b/apps/commerce-api/src/test/java/com/loopers/domain/LoginIdTest.java
new file mode 100644
index 00000000..36e3c898
--- /dev/null
+++ b/apps/commerce-api/src/test/java/com/loopers/domain/LoginIdTest.java
@@ -0,0 +1,42 @@
+package com.loopers.domain;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+import com.loopers.support.error.CoreException;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
+
+class LoginIdTest {
+
+    @DisplayName("로그인 ID 객체를 생성할 때, ")
+    @Nested
+    class Create {
+
+        @DisplayName("4~12자의 영문/숫자가 주어지면, 정상적으로 생성된다.")
+        @ParameterizedTest
+        @ValueSource(strings = {"user123", "loop", "loopers2026"})
+        void createLoginId_whenValidValue(String validValue) {
+            LoginId loginId = new LoginId(validValue);
+            assertThat(loginId.getValue()).isEqualTo(validValue);
+        }
+
+        @DisplayName("4자 미만이거나 12자를 초과하면 예외가 발생한다.")
+        @ParameterizedTest
+        @ValueSource(strings = {"abc", "longloginid123"})
+        void createLoginId_whenLengthIsInvalid(String invalidLengthValue) {
+            assertThatThrownBy(() -> new LoginId(invalidLengthValue))
+                    .isInstanceOf(CoreException.class);
+        }
+
+        @DisplayName("영문/숫자가 아닌 문자가 포함되면 예외가 발생한다.")
+        @ParameterizedTest
+        @ValueSource(strings = {"user!", "로그인id", "user 12"})
+        void createLoginId_whenContainsInvalidChars(String invalidCharValue) {
+            assertThatThrownBy(() -> new LoginId(invalidCharValue))
+                    .isInstanceOf(CoreException.class);
+        }
+    }
+}
diff --git a/apps/commerce-api/src/test/java/com/loopers/domain/NameTest.java b/apps/commerce-api/src/test/java/com/loopers/domain/NameTest.java
new file mode 100644
index 00000000..eeb4796e
--- /dev/null
+++ b/apps/commerce-api/src/test/java/com/loopers/domain/NameTest.java
@@ -0,0 +1,86 @@
+package com.loopers.domain;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+import com.loopers.support.error.CoreException;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.CsvSource;
+import org.junit.jupiter.params.provider.ValueSource;
+
+class NameTest {
+
+    @DisplayName("이름 객체를 생성할 때, ")
+    @Nested
+    class Create {
+
+        @DisplayName("2자 이상 10자 이하의 이름이 주어지면, 정상적으로 생성된다.")
+        @ParameterizedTest
+        @ValueSource(strings = {"홍길", "홍길동", "가나다라마바사아자차"})
+        void createName_whenValidNameProvided(String validNameValue) {
+            // act
+            Name name = new Name(validNameValue);
+
+            // assert
+            assertThat(name).isNotNull();
+        }
+
+        @DisplayName("이름이 null이면 예외가 발생한다.")
+        @Test
+        void createName_whenNameIsNull() {
+            assertThatThrownBy(() -> new Name(null))
+                    .isInstanceOf(CoreException.class);
+        }
+
+        @DisplayName("이름이 빈 문자열이거나 공백이면 예외가 발생한다.")
+        @ParameterizedTest
+        @ValueSource(strings = {"", " ", "   "})
+        void createName_whenNameIsBlank(String blankName) {
+            assertThatThrownBy(() -> new Name(blankName))
+                    .isInstanceOf(CoreException.class);
+        }
+
+        @DisplayName("이름이 2자 미만이면 예외가 발생한다.")
+        @Test
+        void createName_whenNameIsTooShort() {
+            String shortName = "가";
+
+            assertThatThrownBy(() -> new Name(shortName))
+                    .isInstanceOf(CoreException.class);
+        }
+
+        @DisplayName("이름이 10자를 초과하면 예외가 발생한다.")
+        @Test
+        void createName_whenNameIsTooLong() {
+            String longName = "가나다라마바사아자차카"; // 11자
+
+            assertThatThrownBy(() -> new Name(longName))
+                    .isInstanceOf(CoreException.class);}
+    }
+
+    @DisplayName("이름을 마스킹할 때, ")
+    @Nested
+    class Masking {
+
+        @DisplayName("이름의 마지막 글자가 '*'로 치환된다.")
+        @ParameterizedTest
+        @CsvSource({
+                "홍길, 홍*",
+                "홍길동, 홍길*",
+                "가나다라마, 가나다라*"
+        })
+        void getMaskedName_shouldMaskLastCharacter(String original, String expected) {
+            // arrange
+            Name name = new Name(original);
+
+            // act
+            String maskedName = name.getMaskedName();
+
+            // assert
+            assertThat(maskedName).isEqualTo(expected);
+        }
+    }
+}
diff --git a/apps/commerce-api/src/test/java/com/loopers/domain/PasswordTest.java b/apps/commerce-api/src/test/java/com/loopers/domain/PasswordTest.java
new file mode 100644
index 00000000..50d2220e
--- /dev/null
+++ b/apps/commerce-api/src/test/java/com/loopers/domain/PasswordTest.java
@@ -0,0 +1,61 @@
+package com.loopers.domain;
+
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+
+import com.loopers.support.error.CoreException;
+import java.time.LocalDate;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+
+class PasswordTest {
+
+    @DisplayName("비밀번호 객체를 생성할 때, ")
+    @Nested
+    class Create {
+
+        @DisplayName("8~16자의 영문 대소문자, 숫자, 특수문자가 모두 포함되면 정상 생성된다.")
+        @Test
+        void createPassword_whenValidFormat() {
+            // 대문자(V), 소문자(alid), 숫자(123), 특수문자(!@#) 모두 포함
+            assertDoesNotThrow(() -> new Password("Valid123!@#"));
+        }
+
+        @DisplayName("규칙에 어긋나는 형식이면 예외가 발생한다.")
+        @Test
+        void createPassword_whenInvalidFormat() {
+            assertThatThrownBy(() -> new Password("invalid"))
+                    .isInstanceOf(CoreException.class);
+        }
+    }
+
+    @DisplayName("비밀번호 비즈니스 규칙을 검증할 때, ")
+    @Nested
+    class Validation {
+
+        @DisplayName("비밀번호에 생년월일(yyyyMMdd)이 포함되어 있으면 예외가 발생한다.")
+        @Test
+        void validateNotContainBirthday_fail() {
+            // arrange: 정규식을 통과하기 위해 대문자 'P' 추가
+            Password password = new Password("Pw19900115!");
+            BirthDate birthDate = new BirthDate(LocalDate.of(1990, 1, 15));
+
+            // act & assert
+            assertThatThrownBy(() -> password.validateNotContainBirthday(birthDate))
+                    .isInstanceOf(CoreException.class);
+        }
+
+        @DisplayName("수정하려는 비밀번호가 기존 비밀번호와 동일하면 예외가 발생한다.")
+        @Test
+        void validateNotSameAs_fail() {
+            // arrange
+            Password currentPassword = new Password("Current123!");
+            Password newPassword = new Password("Current123!");
+
+            // act & assert
+            assertThatThrownBy(() -> newPassword.validateNotSameAs(currentPassword))
+                    .isInstanceOf(CoreException.class);
+        }
+    }
+}
diff --git a/apps/commerce-api/src/test/java/com/loopers/domain/UserModelTest.java b/apps/commerce-api/src/test/java/com/loopers/domain/UserModelTest.java
new file mode 100644
index 00000000..6082a9ef
--- /dev/null
+++ b/apps/commerce-api/src/test/java/com/loopers/domain/UserModelTest.java
@@ -0,0 +1,86 @@
+package com.loopers.domain;
+
+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 com.loopers.support.error.CoreException;
+import java.time.LocalDate;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+
+class UserModelTest {
+
+    private LoginId validLoginId;
+    private Password validPassword;
+    private Name validName;
+    private BirthDate validBirthDate;
+    private Email validEmail;
+
+    @BeforeEach
+    void setUp() {
+        validLoginId = new LoginId("testuser123");
+        validPassword = new Password("Test1234!@#");
+        validName = new Name("홍길동");
+        validBirthDate = new BirthDate(LocalDate.of(1990, 1, 15));
+        validEmail = new Email("test@example.com");
+    }
+
+    @DisplayName("유저 모델을 생성할 때, ")
+    @Nested
+    class Create {
+
+        @DisplayName("모든 필드가 주어지면, 정상적으로 생성된다.")
+        @Test
+        void createUserModel_whenAllDataProvided() {
+            // act
+            UserModel user = new UserModel(validLoginId, validPassword, validName, validBirthDate, validEmail);
+
+            // assert
+            assertAll(
+                    () -> assertThat(user.getLoginId()).isEqualTo(validLoginId),
+                    () -> assertThat(user.getPassword()).isEqualTo(validPassword),
+                    () -> assertThat(user.getName()).isEqualTo(validName),
+                    () -> assertThat(user.getBirthDate()).isEqualTo(validBirthDate),
+                    () -> assertThat(user.getEmail()).isEqualTo(validEmail)
+            );
+        }
+
+        @DisplayName("로그인 ID가 누락되면 예외가 발생한다.")
+        @Test
+        void createUserModel_whenLoginIdIsNull() {
+            assertThatThrownBy(() -> new UserModel(null, validPassword, validName, validBirthDate, validEmail))
+                    .isInstanceOf(CoreException.class);
+        }
+
+        @DisplayName("비밀번호가 누락되면 예외가 발생한다.")
+        @Test
+        void createUserModel_whenPasswordIsNull() {
+            assertThatThrownBy(() -> new UserModel(validLoginId, null, validName, validBirthDate, validEmail))
+                    .isInstanceOf(CoreException.class);
+        }
+
+        @DisplayName("이름이 누락되면 예외가 발생한다.")
+        @Test
+        void createUserModel_whenNameIsNull() {
+            assertThatThrownBy(() -> new UserModel(validLoginId, validPassword, null, validBirthDate, validEmail))
+                    .isInstanceOf(CoreException.class);
+        }
+
+        @DisplayName("생년월일이 누락되면 예외가 발생한다.")
+        @Test
+        void createUserModel_whenBirthDateIsNull() {
+            assertThatThrownBy(() -> new UserModel(validLoginId, validPassword, validName, null, validEmail))
+                    .isInstanceOf(CoreException.class);
+        }
+
+        @DisplayName("이메일이 누락되면 예외가 발생한다.")
+        @Test
+        void createUserModel_whenEmailIsNull() {
+            assertThatThrownBy(() -> new UserModel(validLoginId, validPassword, validName, validBirthDate, null))
+                    .isInstanceOf(CoreException.class);
+        }
+    }
+}
diff --git a/apps/commerce-api/src/test/java/com/loopers/domain/UserServiceIntegrationTest.java b/apps/commerce-api/src/test/java/com/loopers/domain/UserServiceIntegrationTest.java
new file mode 100644
index 00000000..67067309
--- /dev/null
+++ b/apps/commerce-api/src/test/java/com/loopers/domain/UserServiceIntegrationTest.java
@@ -0,0 +1,221 @@
+package com.loopers.domain;
+
+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 com.loopers.infrastructure.PasswordEncoder;
+import com.loopers.infrastructure.UserJpaRepository;
+import com.loopers.support.error.CoreException;
+import com.loopers.support.error.ErrorType;
+import com.loopers.utils.DatabaseCleanUp;
+import java.time.LocalDate;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+
+@SpringBootTest
+public class UserServiceIntegrationTest {
+    @Autowired
+    private UserService userService;
+
+    @Autowired
+    private UserJpaRepository userJpaRepository;
+
+    @Autowired
+    private PasswordEncoder passwordEncoder;
+
+    @Autowired
+    private DatabaseCleanUp databaseCleanUp;
+
+    private LoginId validLoginId;
+    private Password validPassword;
+    private String rawPassword;
+    private Name validName;
+    private BirthDate validBirthDate;
+    private Email validEmail;
+
+    @BeforeEach
+    void setUp() {
+        validLoginId = new LoginId("testuser123");
+        rawPassword = "Test1234!@#";
+        validPassword = new Password(rawPassword);
+        validName = new Name("홍길동");
+        validBirthDate = new BirthDate(LocalDate.of(1990, 1, 15));
+        validEmail = new Email("test@example.com");
+    }
+
+    @AfterEach
+    void tearDown() {
+        databaseCleanUp.truncateAllTables();
+    }
+
+    @DisplayName("유저가 회원가입할 때")
+    @Nested
+    class SingUp{
+            @DisplayName("로그인 ID, 비밀번호, 이름, 생년월일, 이메일을 주면, 회원가입을 한다.")
+            @Test
+            void signup_whenAllInfoProvided() {
+                // act
+                UserModel result = userService.signup(validLoginId,validPassword,validName,validBirthDate,validEmail);
+
+                // assert
+                assertAll(
+                        () -> assertThat(result).isNotNull(),
+                        () -> assertThat(result.getLoginId()).isEqualTo(validLoginId),
+                        () -> assertThat(result.getName()).isEqualTo(validName),
+                        () -> assertThat(result.getBirthDate()).isEqualTo(validBirthDate),
+                        () -> assertThat(result.getEmail()).isEqualTo(validEmail)
+                );
+            }
+
+            @DisplayName("비밀번호를 암호화하여 저장한다")
+            @Test
+            void signup_should_encrypt_password() {
+                // act
+                UserModel result = userService.signup(validLoginId,validPassword,validName,validBirthDate,validEmail);
+
+                // assert
+                String savedPassword = result.getPassword().getValue();
+                assertAll(
+                        () -> assertThat(savedPassword).isNotEqualTo(rawPassword), // 평문과 다름
+                        () -> assertThat(savedPassword).startsWith("$2a$"), // BCrypt 포맷
+                        () -> assertThat(passwordEncoder.matches(rawPassword, savedPassword)).isTrue() // 평문과 매칭됨
+                );
+            }
+
+            @DisplayName("DB에 저장된 비밀번호가 암호화되어 있다")
+            @Test
+            void signup_should_save_encrypted_password_to_database() {
+                // act
+                UserModel result = userService.signup(validLoginId,validPassword,validName,validBirthDate,validEmail);
+
+                // assert
+                UserModel savedUser = userJpaRepository.findById(result.getId()).orElseThrow();
+                String savedPassword = savedUser.getPassword().getValue();
+                assertAll(
+                        () -> assertThat(savedPassword).isNotEqualTo(rawPassword), // 평문과 다름
+                        () -> assertThat(savedPassword).startsWith("$2a$"), // BCrypt 포맷
+                        () -> assertThat(passwordEncoder.matches(rawPassword, savedPassword)).isTrue() // 평문과 매칭됨
+                );
+            }
+    }
+
+    @DisplayName("유저가 내 정보를 조회할 때")
+    @Nested
+    class GetMyInfo {
+        @DisplayName("로그인 ID로 내 정보를 조회한다")
+        @Test
+        void getMyInfo_whenValidLoginId() {
+            // arrange
+            userService.signup(validLoginId, validPassword, validName, validBirthDate, validEmail);
+
+            // act
+            UserModel result = userService.getMyInfo(validLoginId);
+
+            // assert
+            assertAll(
+                () -> assertThat(result).isNotNull(),
+                () -> assertThat(result.getLoginId()).isEqualTo(validLoginId),
+                () -> assertThat(result.getName()).isEqualTo(validName),
+                () -> assertThat(result.getBirthDate()).isEqualTo(validBirthDate),
+                () -> assertThat(result.getEmail()).isEqualTo(validEmail)
+            );
+        }
+
+        @DisplayName("존재하지 않는 로그인 ID로 조회하면 예외가 발생한다")
+        @Test
+        void getMyInfo_whenInvalidLoginId() {
+            // arrange
+            LoginId invalidLoginId = new LoginId("invalid123");
+
+            // act & assert
+            assertThatThrownBy(() -> userService.getMyInfo(invalidLoginId))
+                .isInstanceOf(CoreException.class)
+                .hasFieldOrPropertyWithValue("errorType", ErrorType.NOT_FOUND)
+                .hasMessageContaining("사용자를 찾을 수 없습니다.");
+        }
+    }
+
+    @DisplayName("유저가 비밀번호를 변경할 때")
+    @Nested
+    class ChangePassword {
+        @DisplayName("올바른 현재 비밀번호와 새 비밀번호를 주면 비밀번호가 변경된다")
+        @Test
+        void changePassword_whenValidPasswords() {
+            // arrange
+            userService.signup(validLoginId, validPassword, validName, validBirthDate, validEmail);
+            Password newPassword = new Password("NewPass123!@");
+
+            // act
+            userService.changePassword(validLoginId, validPassword, newPassword);
+
+            // assert
+            UserModel updatedUser = userService.getMyInfo(validLoginId);
+            String savedPassword = updatedUser.getPassword().getValue();
+            assertAll(
+                    () -> assertThat(savedPassword).isNotEqualTo(rawPassword), // 이전 평문과 다름
+                    () -> assertThat(savedPassword).isNotEqualTo(newPassword.getValue()), // 새 평문과도 다름 (암호화됨)
+                    () -> assertThat(passwordEncoder.matches(newPassword.getValue(), savedPassword)).isTrue() // 새 비밀번호와 매칭됨
+            );
+        }
+
+        @DisplayName("현재 비밀번호가 일치하지 않으면 예외가 발생한다")
+        @Test
+        void changePassword_whenCurrentPasswordNotMatch() {
+            // arrange
+            userService.signup(validLoginId, validPassword, validName, validBirthDate, validEmail);
+            Password wrongPassword = new Password("Wrong123!@#");
+            Password newPassword = new Password("NewPass123!@");
+
+            // act & assert
+            assertThatThrownBy(() -> userService.changePassword(validLoginId, wrongPassword, newPassword))
+                .isInstanceOf(CoreException.class)
+                .hasMessageContaining("현재 비밀번호가 일치하지 않습니다.");
+        }
+
+        @DisplayName("새 비밀번호가 현재 비밀번호와 동일하면 예외가 발생한다")
+        @Test
+        void changePassword_whenNewPasswordSameAsCurrent() {
+            // arrange
+            userService.signup(validLoginId, validPassword, validName, validBirthDate, validEmail);
+            Password samePassword = new Password("Test1234!@#");
+
+            // act & assert
+            assertThatThrownBy(() -> userService.changePassword(validLoginId, validPassword, samePassword))
+                .isInstanceOf(CoreException.class)
+                .hasMessageContaining("현재 사용 중인 비밀번호는 사용할 수 없습니다.");
+        }
+
+        @DisplayName("새 비밀번호에 생년월일이 포함되면 예외가 발생한다")
+        @Test
+        void changePassword_whenNewPasswordContainsBirthDate() {
+            // arrange
+            userService.signup(validLoginId, validPassword, validName, validBirthDate, validEmail);
+            Password newPasswordWithBirthDate = new Password("Pw19900115!");
+
+            // act & assert
+            assertThatThrownBy(() -> userService.changePassword(validLoginId, validPassword, newPasswordWithBirthDate))
+                .isInstanceOf(CoreException.class)
+                .hasMessageContaining("생년월일은 비밀번호 내에 포함될 수 없습니다.");
+        }
+
+        @DisplayName("존재하지 않는 사용자의 비밀번호 변경 시 예외가 발생한다")
+        @Test
+        void changePassword_whenUserNotFound() {
+            // arrange
+            LoginId invalidLoginId = new LoginId("invalid123");
+            Password newPassword = new Password("NewPass123!@");
+
+            // act & assert
+            assertThatThrownBy(() -> userService.changePassword(invalidLoginId, validPassword, newPassword))
+                .isInstanceOf(CoreException.class)
+                .hasFieldOrPropertyWithValue("errorType", ErrorType.NOT_FOUND)
+                .hasMessageContaining("사용자를 찾을 수 없습니다.");
+        }
+    }
+}
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..c81b0f5b
--- /dev/null
+++ b/apps/commerce-api/src/test/java/com/loopers/interfaces/api/UserV1ApiE2ETest.java
@@ -0,0 +1,679 @@
+package com.loopers.interfaces.api;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertAll;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import com.loopers.infrastructure.UserJpaRepository;
+import com.loopers.interfaces.api.user.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;
+
+@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
+class UserV1ApiE2ETest {
+
+    private static final String ENDPOINT_SIGNUP = "/api/v1/users/signup";
+
+    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("POST /api/v1/users/signup")
+    @Nested
+    class Signup {
+
+        @DisplayName("유효한 회원가입 정보를 주면, 회원가입에 성공하고 사용자 정보를 반환한다.")
+        @Test
+        void returnsUserInfo_whenValidSignupRequestIsProvided() {
+            // arrange
+            UserV1Dto.SignupRequest request = new UserV1Dto.SignupRequest(
+                "testuser1",
+                "Test1234!",
+                "홍길동",
+                "19900101",
+                "test@example.com"
+            );
+
+            // act
+            ParameterizedTypeReference<ApiResponse<UserV1Dto.SignupResponse>> responseType = new ParameterizedTypeReference<>() {};
+            ResponseEntity<ApiResponse<UserV1Dto.SignupResponse>> response =
+                testRestTemplate.exchange(ENDPOINT_SIGNUP, HttpMethod.POST, new HttpEntity<>(request), responseType);
+
+            // assert
+            assertAll(
+                () -> assertTrue(response.getStatusCode().is2xxSuccessful()),
+                () -> assertThat(response.getStatusCode()).isEqualTo(HttpStatus.OK),
+                () -> assertThat(response.getBody().data().loginId()).isEqualTo("testuser1"),
+                () -> assertThat(response.getBody().data().name()).isEqualTo("홍길*"),
+                () -> assertThat(response.getBody().data().birthDate()).isEqualTo("19900101"),
+                () -> assertThat(response.getBody().data().email()).isEqualTo("test@example.com"),
+                () -> assertThat(userJpaRepository.count()).isEqualTo(1)
+            );
+        }
+
+        @DisplayName("로그인 ID가 4자 미만이면, 400 BAD_REQUEST 응답을 받는다.")
+        @Test
+        void throwsBadRequest_whenLoginIdIsTooShort() {
+            // arrange
+            UserV1Dto.SignupRequest request = new UserV1Dto.SignupRequest(
+                "abc",
+                "Test1234!",
+                "홍길동",
+                "19900101",
+                "test@example.com"
+            );
+
+            // act
+            ParameterizedTypeReference<ApiResponse<UserV1Dto.SignupResponse>> responseType = new ParameterizedTypeReference<>() {};
+            ResponseEntity<ApiResponse<UserV1Dto.SignupResponse>> response =
+                testRestTemplate.exchange(ENDPOINT_SIGNUP, HttpMethod.POST, new HttpEntity<>(request), responseType);
+
+            // assert
+            assertAll(
+                () -> assertTrue(response.getStatusCode().is4xxClientError()),
+                () -> assertThat(response.getStatusCode()).isEqualTo(HttpStatus.BAD_REQUEST),
+                () -> assertThat(userJpaRepository.count()).isEqualTo(0)
+            );
+        }
+
+        @DisplayName("로그인 ID가 12자 초과이면, 400 BAD_REQUEST 응답을 받는다.")
+        @Test
+        void throwsBadRequest_whenLoginIdIsTooLong() {
+            // arrange
+            UserV1Dto.SignupRequest request = new UserV1Dto.SignupRequest(
+                "testuser12345",
+                "Test1234!",
+                "홍길동",
+                "19900101",
+                "test@example.com"
+            );
+
+            // act
+            ParameterizedTypeReference<ApiResponse<UserV1Dto.SignupResponse>> responseType = new ParameterizedTypeReference<>() {};
+            ResponseEntity<ApiResponse<UserV1Dto.SignupResponse>> response =
+                testRestTemplate.exchange(ENDPOINT_SIGNUP, HttpMethod.POST, new HttpEntity<>(request), responseType);
+
+            // assert
+            assertAll(
+                () -> assertTrue(response.getStatusCode().is4xxClientError()),
+                () -> assertThat(response.getStatusCode()).isEqualTo(HttpStatus.BAD_REQUEST),
+                () -> assertThat(userJpaRepository.count()).isEqualTo(0)
+            );
+        }
+
+        @DisplayName("로그인 ID에 특수문자가 포함되면, 400 BAD_REQUEST 응답을 받는다.")
+        @Test
+        void throwsBadRequest_whenLoginIdContainsSpecialCharacters() {
+            // arrange
+            UserV1Dto.SignupRequest request = new UserV1Dto.SignupRequest(
+                "test@user",
+                "Test1234!",
+                "홍길동",
+                "19900101",
+                "test@example.com"
+            );
+
+            // act
+            ParameterizedTypeReference<ApiResponse<UserV1Dto.SignupResponse>> responseType = new ParameterizedTypeReference<>() {};
+            ResponseEntity<ApiResponse<UserV1Dto.SignupResponse>> response =
+                testRestTemplate.exchange(ENDPOINT_SIGNUP, HttpMethod.POST, new HttpEntity<>(request), responseType);
+
+            // assert
+            assertAll(
+                () -> assertTrue(response.getStatusCode().is4xxClientError()),
+                () -> assertThat(response.getStatusCode()).isEqualTo(HttpStatus.BAD_REQUEST),
+                () -> assertThat(userJpaRepository.count()).isEqualTo(0)
+            );
+        }
+
+        @DisplayName("비밀번호가 8자 미만이면, 400 BAD_REQUEST 응답을 받는다.")
+        @Test
+        void throwsBadRequest_whenPasswordIsTooShort() {
+            // arrange
+            UserV1Dto.SignupRequest request = new UserV1Dto.SignupRequest(
+                "testuser1",
+                "Test12!",
+                "홍길동",
+                "19900101",
+                "test@example.com"
+            );
+
+            // act
+            ParameterizedTypeReference<ApiResponse<UserV1Dto.SignupResponse>> responseType = new ParameterizedTypeReference<>() {};
+            ResponseEntity<ApiResponse<UserV1Dto.SignupResponse>> response =
+                testRestTemplate.exchange(ENDPOINT_SIGNUP, HttpMethod.POST, new HttpEntity<>(request), responseType);
+
+            // assert
+            assertAll(
+                () -> assertTrue(response.getStatusCode().is4xxClientError()),
+                () -> assertThat(response.getStatusCode()).isEqualTo(HttpStatus.BAD_REQUEST),
+                () -> assertThat(userJpaRepository.count()).isEqualTo(0)
+            );
+        }
+
+        @DisplayName("비밀번호가 16자 초과이면, 400 BAD_REQUEST 응답을 받는다.")
+        @Test
+        void throwsBadRequest_whenPasswordIsTooLong() {
+            // arrange
+            UserV1Dto.SignupRequest request = new UserV1Dto.SignupRequest(
+                "testuser1",
+                "Test1234567890123!",
+                "홍길동",
+                "19900101",
+                "test@example.com"
+            );
+
+            // act
+            ParameterizedTypeReference<ApiResponse<UserV1Dto.SignupResponse>> responseType = new ParameterizedTypeReference<>() {};
+            ResponseEntity<ApiResponse<UserV1Dto.SignupResponse>> response =
+                testRestTemplate.exchange(ENDPOINT_SIGNUP, HttpMethod.POST, new HttpEntity<>(request), responseType);
+
+            // assert
+            assertAll(
+                () -> assertTrue(response.getStatusCode().is4xxClientError()),
+                () -> assertThat(response.getStatusCode()).isEqualTo(HttpStatus.BAD_REQUEST),
+                () -> assertThat(userJpaRepository.count()).isEqualTo(0)
+            );
+        }
+
+        @DisplayName("비밀번호에 생년월일이 포함되면, 400 BAD_REQUEST 응답을 받는다.")
+        @Test
+        void throwsBadRequest_whenPasswordContainsBirthDate() {
+            // arrange
+            UserV1Dto.SignupRequest request = new UserV1Dto.SignupRequest(
+                "testuser1",
+                "Test19900101!",
+                "홍길동",
+                "19900101",
+                "test@example.com"
+            );
+
+            // act
+            ParameterizedTypeReference<ApiResponse<UserV1Dto.SignupResponse>> responseType = new ParameterizedTypeReference<>() {};
+            ResponseEntity<ApiResponse<UserV1Dto.SignupResponse>> response =
+                testRestTemplate.exchange(ENDPOINT_SIGNUP, HttpMethod.POST, new HttpEntity<>(request), responseType);
+
+            // assert
+            assertAll(
+                () -> assertTrue(response.getStatusCode().is4xxClientError()),
+                () -> assertThat(response.getStatusCode()).isEqualTo(HttpStatus.BAD_REQUEST),
+                () -> assertThat(userJpaRepository.count()).isEqualTo(0)
+            );
+        }
+
+        @DisplayName("이메일 형식이 올바르지 않으면, 400 BAD_REQUEST 응답을 받는다.")
+        @Test
+        void throwsBadRequest_whenEmailFormatIsInvalid() {
+            // arrange
+            UserV1Dto.SignupRequest request = new UserV1Dto.SignupRequest(
+                "testuser1",
+                "Test1234!",
+                "홍길동",
+                "19900101",
+                "invalid-email"
+            );
+
+            // act
+            ParameterizedTypeReference<ApiResponse<UserV1Dto.SignupResponse>> responseType = new ParameterizedTypeReference<>() {};
+            ResponseEntity<ApiResponse<UserV1Dto.SignupResponse>> response =
+                testRestTemplate.exchange(ENDPOINT_SIGNUP, HttpMethod.POST, new HttpEntity<>(request), responseType);
+
+            // assert
+            assertAll(
+                () -> assertTrue(response.getStatusCode().is4xxClientError()),
+                () -> assertThat(response.getStatusCode()).isEqualTo(HttpStatus.BAD_REQUEST),
+                () -> assertThat(userJpaRepository.count()).isEqualTo(0)
+            );
+        }
+
+        @DisplayName("이미 존재하는 로그인 ID로 회원가입하면, 400 BAD_REQUEST 응답을 받는다.")
+        @Test
+        void throwsBadRequest_whenLoginIdAlreadyExists() {
+            // arrange
+            UserV1Dto.SignupRequest firstRequest = new UserV1Dto.SignupRequest(
+                "testuser1",
+                "Test1234!",
+                "홍길동",
+                "19900101",
+                "test1@example.com"
+            );
+            UserV1Dto.SignupRequest secondRequest = new UserV1Dto.SignupRequest(
+                "testuser1",
+                "Test5678!",
+                "김철수",
+                "19950505",
+                "test2@example.com"
+            );
+
+            ParameterizedTypeReference<ApiResponse<UserV1Dto.SignupResponse>> responseType = new ParameterizedTypeReference<>() {};
+            testRestTemplate.exchange(ENDPOINT_SIGNUP, HttpMethod.POST, new HttpEntity<>(firstRequest), responseType);
+
+            // act
+            ResponseEntity<ApiResponse<UserV1Dto.SignupResponse>> response =
+                testRestTemplate.exchange(ENDPOINT_SIGNUP, HttpMethod.POST, new HttpEntity<>(secondRequest), responseType);
+
+            // assert
+            assertAll(
+                () -> assertTrue(response.getStatusCode().is4xxClientError()),
+                () -> assertThat(response.getStatusCode()).isEqualTo(HttpStatus.BAD_REQUEST),
+                () -> assertThat(userJpaRepository.count()).isEqualTo(1)
+            );
+        }
+
+        @DisplayName("이름이 2자 미만이면, 400 BAD_REQUEST 응답을 받는다.")
+        @Test
+        void throwsBadRequest_whenNameIsTooShort() {
+            // arrange
+            UserV1Dto.SignupRequest request = new UserV1Dto.SignupRequest(
+                "testuser1",
+                "Test1234!",
+                "홍",
+                "19900101",
+                "test@example.com"
+            );
+
+            // act
+            ParameterizedTypeReference<ApiResponse<UserV1Dto.SignupResponse>> responseType = new ParameterizedTypeReference<>() {};
+            ResponseEntity<ApiResponse<UserV1Dto.SignupResponse>> response =
+                testRestTemplate.exchange(ENDPOINT_SIGNUP, HttpMethod.POST, new HttpEntity<>(request), responseType);
+
+            // assert
+            assertAll(
+                () -> assertTrue(response.getStatusCode().is4xxClientError()),
+                () -> assertThat(response.getStatusCode()).isEqualTo(HttpStatus.BAD_REQUEST),
+                () -> assertThat(userJpaRepository.count()).isEqualTo(0)
+            );
+        }
+
+        @DisplayName("이름이 10자 초과이면, 400 BAD_REQUEST 응답을 받는다.")
+        @Test
+        void throwsBadRequest_whenNameIsTooLong() {
+            // arrange
+            UserV1Dto.SignupRequest request = new UserV1Dto.SignupRequest(
+                "testuser1",
+                "Test1234!",
+                "홍길동김철수박영희최강",
+                "19900101",
+                "test@example.com"
+            );
+
+            // act
+            ParameterizedTypeReference<ApiResponse<UserV1Dto.SignupResponse>> responseType = new ParameterizedTypeReference<>() {};
+            ResponseEntity<ApiResponse<UserV1Dto.SignupResponse>> response =
+                testRestTemplate.exchange(ENDPOINT_SIGNUP, HttpMethod.POST, new HttpEntity<>(request), responseType);
+
+            // assert
+            assertAll(
+                () -> assertTrue(response.getStatusCode().is4xxClientError()),
+                () -> assertThat(response.getStatusCode()).isEqualTo(HttpStatus.BAD_REQUEST),
+                () -> assertThat(userJpaRepository.count()).isEqualTo(0)
+            );
+        }
+    }
+
+    @DisplayName("GET /api/v1/users/me")
+    @Nested
+    class GetMyInfo {
+
+        private static final String ENDPOINT_MY_INFO = "/api/v1/users/me";
+        private static final String HEADER_LOGIN_ID = "X-Loopers-LoginId";
+        private static final String HEADER_LOGIN_PW = "X-Loopers-LoginPw";
+
+        @DisplayName("유효한 인증 헤더로 내 정보를 조회하면, 사용자 정보를 반환한다")
+        @Test
+        void returnsMyInfo_whenValidAuthenticationHeaders() {
+            // arrange
+            UserV1Dto.SignupRequest signupRequest = new UserV1Dto.SignupRequest(
+                "testuser1",
+                "Test1234!",
+                "홍길동",
+                "19900101",
+                "test@example.com"
+            );
+
+            ParameterizedTypeReference<ApiResponse<UserV1Dto.SignupResponse>> signupResponseType = new ParameterizedTypeReference<>() {};
+            testRestTemplate.exchange(ENDPOINT_SIGNUP, HttpMethod.POST, new HttpEntity<>(signupRequest), signupResponseType);
+
+            // act
+            org.springframework.http.HttpHeaders headers = new org.springframework.http.HttpHeaders();
+            headers.set(HEADER_LOGIN_ID, "testuser1");
+            headers.set(HEADER_LOGIN_PW, "Test1234!");
+
+            ParameterizedTypeReference<ApiResponse<UserV1Dto.MyInfoResponse>> responseType = new ParameterizedTypeReference<>() {};
+            ResponseEntity<ApiResponse<UserV1Dto.MyInfoResponse>> response =
+                testRestTemplate.exchange(ENDPOINT_MY_INFO, HttpMethod.GET, new HttpEntity<>(headers), responseType);
+
+            // assert
+            assertAll(
+                () -> assertTrue(response.getStatusCode().is2xxSuccessful()),
+                () -> assertThat(response.getStatusCode()).isEqualTo(HttpStatus.OK),
+                () -> assertThat(response.getBody().data().loginId()).isEqualTo("testuser1"),
+                () -> assertThat(response.getBody().data().name()).isEqualTo("홍길*"),
+                () -> assertThat(response.getBody().data().birthDate()).isEqualTo("19900101"),
+                () -> assertThat(response.getBody().data().email()).isEqualTo("test@example.com")
+            );
+        }
+
+        @DisplayName("존재하지 않는 로그인 ID로 조회하면, 401 UNAUTHORIZED 응답을 받는다")
+        @Test
+        void throwsUnauthorized_whenUserNotFound() {
+            // arrange
+            org.springframework.http.HttpHeaders headers = new org.springframework.http.HttpHeaders();
+            headers.set(HEADER_LOGIN_ID, "nonexistent");
+            headers.set(HEADER_LOGIN_PW, "Test1234!");
+
+            // act
+            ParameterizedTypeReference<ApiResponse<UserV1Dto.MyInfoResponse>> responseType = new ParameterizedTypeReference<>() {};
+            ResponseEntity<ApiResponse<UserV1Dto.MyInfoResponse>> response =
+                testRestTemplate.exchange(ENDPOINT_MY_INFO, HttpMethod.GET, new HttpEntity<>(headers), responseType);
+
+            // assert
+            assertAll(
+                () -> assertTrue(response.getStatusCode().is4xxClientError()),
+                () -> assertThat(response.getStatusCode()).isEqualTo(HttpStatus.UNAUTHORIZED)
+            );
+        }
+
+        @DisplayName("잘못된 비밀번호로 조회하면, 401 UNAUTHORIZED 응답을 받는다")
+        @Test
+        void throwsUnauthorized_whenPasswordIsIncorrect() {
+            // arrange
+            UserV1Dto.SignupRequest signupRequest = new UserV1Dto.SignupRequest(
+                "testuser1",
+                "Test1234!",
+                "홍길동",
+                "19900101",
+                "test@example.com"
+            );
+
+            ParameterizedTypeReference<ApiResponse<UserV1Dto.SignupResponse>> signupResponseType = new ParameterizedTypeReference<>() {};
+            testRestTemplate.exchange(ENDPOINT_SIGNUP, HttpMethod.POST, new HttpEntity<>(signupRequest), signupResponseType);
+
+            org.springframework.http.HttpHeaders headers = new org.springframework.http.HttpHeaders();
+            headers.set(HEADER_LOGIN_ID, "testuser1");
+            headers.set(HEADER_LOGIN_PW, "Wrong1234!");
+
+            // act
+            ParameterizedTypeReference<ApiResponse<UserV1Dto.MyInfoResponse>> responseType = new ParameterizedTypeReference<>() {};
+            ResponseEntity<ApiResponse<UserV1Dto.MyInfoResponse>> response =
+                testRestTemplate.exchange(ENDPOINT_MY_INFO, HttpMethod.GET, new HttpEntity<>(headers), responseType);
+
+            // assert
+            assertAll(
+                () -> assertTrue(response.getStatusCode().is4xxClientError()),
+                () -> assertThat(response.getStatusCode()).isEqualTo(HttpStatus.UNAUTHORIZED)
+            );
+        }
+
+        @DisplayName("인증 헤더가 없으면, 4xx 에러 응답을 받는다")
+        @Test
+        void throwsError_whenAuthenticationHeadersMissing() {
+            // act
+            ParameterizedTypeReference<ApiResponse<UserV1Dto.MyInfoResponse>> responseType = new ParameterizedTypeReference<>() {};
+            ResponseEntity<ApiResponse<UserV1Dto.MyInfoResponse>> response =
+                testRestTemplate.exchange(ENDPOINT_MY_INFO, HttpMethod.GET, null, responseType);
+
+            // assert
+            assertTrue(response.getStatusCode().is4xxClientError() || response.getStatusCode().is5xxServerError());
+        }
+    }
+
+    @DisplayName("PATCH /api/v1/users/password")
+    @Nested
+    class ChangePassword {
+
+        private static final String ENDPOINT_CHANGE_PASSWORD = "/api/v1/users/password";
+        private static final String HEADER_LOGIN_ID = "X-Loopers-LoginId";
+        private static final String HEADER_LOGIN_PW = "X-Loopers-LoginPw";
+
+        @DisplayName("유효한 인증 헤더와 비밀번호로 변경하면, 비밀번호가 변경된다")
+        @Test
+        void changePassword_whenValidRequest() {
+            // arrange
+            UserV1Dto.SignupRequest signupRequest = new UserV1Dto.SignupRequest(
+                "testuser1",
+                "Test1234!",
+                "홍길동",
+                "19900101",
+                "test@example.com"
+            );
+
+            ParameterizedTypeReference<ApiResponse<UserV1Dto.SignupResponse>> signupResponseType = new ParameterizedTypeReference<>() {};
+            testRestTemplate.exchange(ENDPOINT_SIGNUP, HttpMethod.POST, new HttpEntity<>(signupRequest), signupResponseType);
+
+            org.springframework.http.HttpHeaders headers = new org.springframework.http.HttpHeaders();
+            headers.set(HEADER_LOGIN_ID, "testuser1");
+            headers.set(HEADER_LOGIN_PW, "Test1234!");
+            headers.setContentType(org.springframework.http.MediaType.APPLICATION_JSON);
+
+            UserV1Dto.ChangePasswordRequest request = new UserV1Dto.ChangePasswordRequest(
+                "Test1234!",
+                "NewPass123!@"
+            );
+
+            // act
+            ParameterizedTypeReference<ApiResponse<UserV1Dto.ChangePasswordResponse>> responseType = new ParameterizedTypeReference<>() {};
+            ResponseEntity<ApiResponse<UserV1Dto.ChangePasswordResponse>> response =
+                testRestTemplate.exchange(ENDPOINT_CHANGE_PASSWORD, HttpMethod.PATCH, new HttpEntity<>(request, headers), responseType);
+
+            // assert
+            assertAll(
+                () -> assertTrue(response.getStatusCode().is2xxSuccessful()),
+                () -> assertThat(response.getStatusCode()).isEqualTo(HttpStatus.OK),
+                () -> assertThat(response.getBody().data().message()).isEqualTo("비밀번호가 성공적으로 변경되었습니다.")
+            );
+        }
+
+        @DisplayName("현재 비밀번호가 일치하지 않으면, 400 BAD_REQUEST 응답을 받는다")
+        @Test
+        void changePassword_whenCurrentPasswordNotMatch() {
+            // arrange
+            UserV1Dto.SignupRequest signupRequest = new UserV1Dto.SignupRequest(
+                "testuser1",
+                "Test1234!",
+                "홍길동",
+                "19900101",
+                "test@example.com"
+            );
+
+            ParameterizedTypeReference<ApiResponse<UserV1Dto.SignupResponse>> signupResponseType = new ParameterizedTypeReference<>() {};
+            testRestTemplate.exchange(ENDPOINT_SIGNUP, HttpMethod.POST, new HttpEntity<>(signupRequest), signupResponseType);
+
+            org.springframework.http.HttpHeaders headers = new org.springframework.http.HttpHeaders();
+            headers.set(HEADER_LOGIN_ID, "testuser1");
+            headers.set(HEADER_LOGIN_PW, "Test1234!");
+            headers.setContentType(org.springframework.http.MediaType.APPLICATION_JSON);
+
+            UserV1Dto.ChangePasswordRequest request = new UserV1Dto.ChangePasswordRequest(
+                "Wrong1234!",
+                "NewPass123!@"
+            );
+
+            // act
+            ParameterizedTypeReference<ApiResponse<UserV1Dto.ChangePasswordResponse>> responseType = new ParameterizedTypeReference<>() {};
+            ResponseEntity<ApiResponse<UserV1Dto.ChangePasswordResponse>> response =
+                testRestTemplate.exchange(ENDPOINT_CHANGE_PASSWORD, HttpMethod.PATCH, new HttpEntity<>(request, headers), responseType);
+
+            // assert
+            assertAll(
+                () -> assertTrue(response.getStatusCode().is4xxClientError()),
+                () -> assertThat(response.getStatusCode()).isEqualTo(HttpStatus.BAD_REQUEST)
+            );
+        }
+
+        @DisplayName("새 비밀번호가 현재 비밀번호와 동일하면, 400 BAD_REQUEST 응답을 받는다")
+        @Test
+        void changePassword_whenNewPasswordSameAsCurrent() {
+            // arrange
+            UserV1Dto.SignupRequest signupRequest = new UserV1Dto.SignupRequest(
+                "testuser1",
+                "Test1234!",
+                "홍길동",
+                "19900101",
+                "test@example.com"
+            );
+
+            ParameterizedTypeReference<ApiResponse<UserV1Dto.SignupResponse>> signupResponseType = new ParameterizedTypeReference<>() {};
+            testRestTemplate.exchange(ENDPOINT_SIGNUP, HttpMethod.POST, new HttpEntity<>(signupRequest), signupResponseType);
+
+            org.springframework.http.HttpHeaders headers = new org.springframework.http.HttpHeaders();
+            headers.set(HEADER_LOGIN_ID, "testuser1");
+            headers.set(HEADER_LOGIN_PW, "Test1234!");
+            headers.setContentType(org.springframework.http.MediaType.APPLICATION_JSON);
+
+            UserV1Dto.ChangePasswordRequest request = new UserV1Dto.ChangePasswordRequest(
+                "Test1234!",
+                "Test1234!"
+            );
+
+            // act
+            ParameterizedTypeReference<ApiResponse<UserV1Dto.ChangePasswordResponse>> responseType = new ParameterizedTypeReference<>() {};
+            ResponseEntity<ApiResponse<UserV1Dto.ChangePasswordResponse>> response =
+                testRestTemplate.exchange(ENDPOINT_CHANGE_PASSWORD, HttpMethod.PATCH, new HttpEntity<>(request, headers), responseType);
+
+            // assert
+            assertAll(
+                () -> assertTrue(response.getStatusCode().is4xxClientError()),
+                () -> assertThat(response.getStatusCode()).isEqualTo(HttpStatus.BAD_REQUEST)
+            );
+        }
+
+        @DisplayName("새 비밀번호에 생년월일이 포함되면, 400 BAD_REQUEST 응답을 받는다")
+        @Test
+        void changePassword_whenNewPasswordContainsBirthDate() {
+            // arrange
+            UserV1Dto.SignupRequest signupRequest = new UserV1Dto.SignupRequest(
+                "testuser1",
+                "Test1234!",
+                "홍길동",
+                "19900101",
+                "test@example.com"
+            );
+
+            ParameterizedTypeReference<ApiResponse<UserV1Dto.SignupResponse>> signupResponseType = new ParameterizedTypeReference<>() {};
+            testRestTemplate.exchange(ENDPOINT_SIGNUP, HttpMethod.POST, new HttpEntity<>(signupRequest), signupResponseType);
+
+            org.springframework.http.HttpHeaders headers = new org.springframework.http.HttpHeaders();
+            headers.set(HEADER_LOGIN_ID, "testuser1");
+            headers.set(HEADER_LOGIN_PW, "Test1234!");
+            headers.setContentType(org.springframework.http.MediaType.APPLICATION_JSON);
+
+            UserV1Dto.ChangePasswordRequest request = new UserV1Dto.ChangePasswordRequest(
+                "Test1234!",
+                "Pw19900101!"
+            );
+
+            // act
+            ParameterizedTypeReference<ApiResponse<UserV1Dto.ChangePasswordResponse>> responseType = new ParameterizedTypeReference<>() {};
+            ResponseEntity<ApiResponse<UserV1Dto.ChangePasswordResponse>> response =
+                testRestTemplate.exchange(ENDPOINT_CHANGE_PASSWORD, HttpMethod.PATCH, new HttpEntity<>(request, headers), responseType);
+
+            // assert
+            assertAll(
+                () -> assertTrue(response.getStatusCode().is4xxClientError()),
+                () -> assertThat(response.getStatusCode()).isEqualTo(HttpStatus.BAD_REQUEST)
+            );
+        }
+
+        @DisplayName("잘못된 인증 헤더로 요청하면, 401 UNAUTHORIZED 응답을 받는다")
+        @Test
+        void changePassword_whenUnauthorized() {
+            // arrange
+            UserV1Dto.SignupRequest signupRequest = new UserV1Dto.SignupRequest(
+                "testuser1",
+                "Test1234!",
+                "홍길동",
+                "19900101",
+                "test@example.com"
+            );
+
+            ParameterizedTypeReference<ApiResponse<UserV1Dto.SignupResponse>> signupResponseType = new ParameterizedTypeReference<>() {};
+            testRestTemplate.exchange(ENDPOINT_SIGNUP, HttpMethod.POST, new HttpEntity<>(signupRequest), signupResponseType);
+
+            org.springframework.http.HttpHeaders headers = new org.springframework.http.HttpHeaders();
+            headers.set(HEADER_LOGIN_ID, "testuser1");
+            headers.set(HEADER_LOGIN_PW, "Wrong1234!");
+            headers.setContentType(org.springframework.http.MediaType.APPLICATION_JSON);
+
+            UserV1Dto.ChangePasswordRequest request = new UserV1Dto.ChangePasswordRequest(
+                "Test1234!",
+                "NewPass123!@"
+            );
+
+            // act
+            ParameterizedTypeReference<ApiResponse<UserV1Dto.ChangePasswordResponse>> responseType = new ParameterizedTypeReference<>() {};
+            ResponseEntity<ApiResponse<UserV1Dto.ChangePasswordResponse>> response =
+                testRestTemplate.exchange(ENDPOINT_CHANGE_PASSWORD, HttpMethod.PATCH, new HttpEntity<>(request, headers), responseType);
+
+            // assert
+            assertAll(
+                () -> assertTrue(response.getStatusCode().is4xxClientError()),
+                () -> assertThat(response.getStatusCode()).isEqualTo(HttpStatus.UNAUTHORIZED)
+            );
+        }
+
+        @DisplayName("새 비밀번호 형식이 잘못되면, 400 BAD_REQUEST 응답을 받는다")
+        @Test
+        void changePassword_whenInvalidPasswordFormat() {
+            // arrange
+            UserV1Dto.SignupRequest signupRequest = new UserV1Dto.SignupRequest(
+                "testuser1",
+                "Test1234!",
+                "홍길동",
+                "19900101",
+                "test@example.com"
+            );
+
+            ParameterizedTypeReference<ApiResponse<UserV1Dto.SignupResponse>> signupResponseType = new ParameterizedTypeReference<>() {};
+            testRestTemplate.exchange(ENDPOINT_SIGNUP, HttpMethod.POST, new HttpEntity<>(signupRequest), signupResponseType);
+
+            org.springframework.http.HttpHeaders headers = new org.springframework.http.HttpHeaders();
+            headers.set(HEADER_LOGIN_ID, "testuser1");
+            headers.set(HEADER_LOGIN_PW, "Test1234!");
+            headers.setContentType(org.springframework.http.MediaType.APPLICATION_JSON);
+
+            UserV1Dto.ChangePasswordRequest request = new UserV1Dto.ChangePasswordRequest(
+                "Test1234!",
+                "short"
+            );
+
+            // act
+            ParameterizedTypeReference<ApiResponse<UserV1Dto.ChangePasswordResponse>> responseType = new ParameterizedTypeReference<>() {};
+            ResponseEntity<ApiResponse<UserV1Dto.ChangePasswordResponse>> response =
+                testRestTemplate.exchange(ENDPOINT_CHANGE_PASSWORD, HttpMethod.PATCH, new HttpEntity<>(request, headers), responseType);
+
+            // assert
+            assertAll(
+                () -> assertTrue(response.getStatusCode().is4xxClientError()),
+                () -> assertThat(response.getStatusCode()).isEqualTo(HttpStatus.BAD_REQUEST)
+            );
+        }
+    }
+}
diff --git a/apps/commerce-api/src/test/java/com/loopers/interfaces/api/UserV1ApiScenarioTest.java b/apps/commerce-api/src/test/java/com/loopers/interfaces/api/UserV1ApiScenarioTest.java
new file mode 100644
index 00000000..e15c7e65
--- /dev/null
+++ b/apps/commerce-api/src/test/java/com/loopers/interfaces/api/UserV1ApiScenarioTest.java
@@ -0,0 +1,171 @@
+package com.loopers.interfaces.api;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertAll;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import com.loopers.interfaces.api.user.UserV1Dto;
+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.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;
+
+@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
+@DisplayName("User V1 API 시나리오 테스트")
+class UserV1ApiScenarioTest {
+
+    private static final String ENDPOINT_SIGNUP = "/api/v1/users/signup";
+    private static final String ENDPOINT_MY_INFO = "/api/v1/users/me";
+    private static final String ENDPOINT_CHANGE_PASSWORD = "/api/v1/users/password";
+    private static final String HEADER_LOGIN_ID = "X-Loopers-LoginId";
+    private static final String HEADER_LOGIN_PW = "X-Loopers-LoginPw";
+
+    private final TestRestTemplate testRestTemplate;
+    private final DatabaseCleanUp databaseCleanUp;
+
+    @Autowired
+    public UserV1ApiScenarioTest(
+        TestRestTemplate testRestTemplate,
+        DatabaseCleanUp databaseCleanUp
+    ) {
+        this.testRestTemplate = testRestTemplate;
+        this.databaseCleanUp = databaseCleanUp;
+    }
+
+    @AfterEach
+    void tearDown() {
+        databaseCleanUp.truncateAllTables();
+    }
+
+    @DisplayName("유저 전체 플로우: 회원가입 -> 내 정보 조회 -> 비밀번호 변경 -> 내 정보 조회")
+    @Test
+    void fullUserFlowScenario() {
+        String loginId = "testuser123";
+        String originalPassword = "Test1234!@#";
+        String newPassword = "NewPass123!@";
+        String name = "홍길동";
+        String birthDate = "19900115";
+        String email = "test@example.com";
+
+        // ===== 1단계: 회원가입 =====
+        UserV1Dto.SignupRequest signupRequest = new UserV1Dto.SignupRequest(
+            loginId,
+            originalPassword,
+            name,
+            birthDate,
+            email
+        );
+
+        ParameterizedTypeReference<ApiResponse<UserV1Dto.SignupResponse>> signupResponseType =
+            new ParameterizedTypeReference<>() {};
+        ResponseEntity<ApiResponse<UserV1Dto.SignupResponse>> signupResponse =
+            testRestTemplate.exchange(ENDPOINT_SIGNUP, HttpMethod.POST, new HttpEntity<>(signupRequest), signupResponseType);
+
+        // 회원가입 검증
+        assertAll(
+            "회원가입 성공 검증",
+            () -> assertTrue(signupResponse.getStatusCode().is2xxSuccessful()),
+            () -> assertThat(signupResponse.getStatusCode()).isEqualTo(HttpStatus.OK),
+            () -> assertThat(signupResponse.getBody()).isNotNull(),
+            () -> assertThat(signupResponse.getBody().data().loginId()).isEqualTo(loginId),
+            () -> assertThat(signupResponse.getBody().data().name()).isEqualTo("홍길*"),
+            () -> assertThat(signupResponse.getBody().data().birthDate()).isEqualTo(birthDate),
+            () -> assertThat(signupResponse.getBody().data().email()).isEqualTo(email)
+        );
+
+        // ===== 2단계: 내 정보 조회 (원래 비밀번호로) =====
+        HttpHeaders headers1 = new HttpHeaders();
+        headers1.set(HEADER_LOGIN_ID, loginId);
+        headers1.set(HEADER_LOGIN_PW, originalPassword);
+
+        ParameterizedTypeReference<ApiResponse<UserV1Dto.MyInfoResponse>> myInfoResponseType =
+            new ParameterizedTypeReference<>() {};
+        ResponseEntity<ApiResponse<UserV1Dto.MyInfoResponse>> myInfoResponse1 =
+            testRestTemplate.exchange(ENDPOINT_MY_INFO, HttpMethod.GET, new HttpEntity<>(headers1), myInfoResponseType);
+
+        // 첫 번째 내 정보 조회 검증
+        assertAll(
+            "첫 번째 내 정보 조회 성공 검증",
+            () -> assertTrue(myInfoResponse1.getStatusCode().is2xxSuccessful()),
+            () -> assertThat(myInfoResponse1.getStatusCode()).isEqualTo(HttpStatus.OK),
+            () -> assertThat(myInfoResponse1.getBody()).isNotNull(),
+            () -> assertThat(myInfoResponse1.getBody().data().loginId()).isEqualTo(loginId),
+            () -> assertThat(myInfoResponse1.getBody().data().name()).isEqualTo("홍길*"),
+            () -> assertThat(myInfoResponse1.getBody().data().birthDate()).isEqualTo(birthDate),
+            () -> assertThat(myInfoResponse1.getBody().data().email()).isEqualTo(email)
+        );
+
+        // ===== 3단계: 비밀번호 변경 =====
+        HttpHeaders headers2 = new HttpHeaders();
+        headers2.set(HEADER_LOGIN_ID, loginId);
+        headers2.set(HEADER_LOGIN_PW, originalPassword);
+
+        UserV1Dto.ChangePasswordRequest changePasswordRequest = new UserV1Dto.ChangePasswordRequest(
+            originalPassword,
+            newPassword
+        );
+
+        ParameterizedTypeReference<ApiResponse<UserV1Dto.ChangePasswordResponse>> changePasswordResponseType =
+            new ParameterizedTypeReference<>() {};
+        ResponseEntity<ApiResponse<UserV1Dto.ChangePasswordResponse>> changePasswordResponse =
+            testRestTemplate.exchange(
+                ENDPOINT_CHANGE_PASSWORD,
+                HttpMethod.PATCH,
+                new HttpEntity<>(changePasswordRequest, headers2),
+                changePasswordResponseType
+            );
+
+        // 비밀번호 변경 검증
+        assertAll(
+            "비밀번호 변경 성공 검증",
+            () -> assertTrue(changePasswordResponse.getStatusCode().is2xxSuccessful()),
+            () -> assertThat(changePasswordResponse.getStatusCode()).isEqualTo(HttpStatus.OK),
+            () -> assertThat(changePasswordResponse.getBody()).isNotNull(),
+            () -> assertThat(changePasswordResponse.getBody().data().message()).isEqualTo("비밀번호가 성공적으로 변경되었습니다.")
+        );
+
+        // ===== 4단계: 내 정보 조회 (새 비밀번호로) =====
+        HttpHeaders headers3 = new HttpHeaders();
+        headers3.set(HEADER_LOGIN_ID, loginId);
+        headers3.set(HEADER_LOGIN_PW, newPassword);
+
+        ResponseEntity<ApiResponse<UserV1Dto.MyInfoResponse>> myInfoResponse2 =
+            testRestTemplate.exchange(ENDPOINT_MY_INFO, HttpMethod.GET, new HttpEntity<>(headers3), myInfoResponseType);
+
+        // 두 번째 내 정보 조회 검증 (새 비밀번호로 인증 성공)
+        assertAll(
+            "새 비밀번호로 내 정보 조회 성공 검증",
+            () -> assertTrue(myInfoResponse2.getStatusCode().is2xxSuccessful()),
+            () -> assertThat(myInfoResponse2.getStatusCode()).isEqualTo(HttpStatus.OK),
+            () -> assertThat(myInfoResponse2.getBody()).isNotNull(),
+            () -> assertThat(myInfoResponse2.getBody().data().loginId()).isEqualTo(loginId),
+            () -> assertThat(myInfoResponse2.getBody().data().name()).isEqualTo("홍길*"),
+            () -> assertThat(myInfoResponse2.getBody().data().birthDate()).isEqualTo(birthDate),
+            () -> assertThat(myInfoResponse2.getBody().data().email()).isEqualTo(email)
+        );
+
+        // ===== 5단계: 이전 비밀번호로는 인증 실패 확인 =====
+        HttpHeaders headers4 = new HttpHeaders();
+        headers4.set(HEADER_LOGIN_ID, loginId);
+        headers4.set(HEADER_LOGIN_PW, originalPassword);
+
+        ResponseEntity<ApiResponse<UserV1Dto.MyInfoResponse>> myInfoResponse3 =
+            testRestTemplate.exchange(ENDPOINT_MY_INFO, HttpMethod.GET, new HttpEntity<>(headers4), myInfoResponseType);
+
+        // 이전 비밀번호로 인증 실패 검증
+        assertAll(
+            "이전 비밀번호로 인증 실패 검증",
+            () -> assertTrue(myInfoResponse3.getStatusCode().is4xxClientError()),
+            () -> assertThat(myInfoResponse3.getStatusCode()).isEqualTo(HttpStatus.UNAUTHORIZED)
+        );
+    }
+}
diff --git a/http/commerce-api/user-v1.http b/http/commerce-api/user-v1.http
new file mode 100644
index 00000000..726e819a
--- /dev/null
+++ b/http/commerce-api/user-v1.http
@@ -0,0 +1,265 @@
+### 회원가입 - 성공 케이스
+POST {{commerce-api}}/api/v1/users/signup
+Content-Type: application/json
+
+{
+  "loginId": "testuser1",
+  "password": "Test1234!",
+  "name": "홍길동",
+  "birthDate": "19900101",
+  "email": "test@example.com"
+}
+
+### 회원가입 - 로그인 ID 4자 미만 (실패)
+POST {{commerce-api}}/api/v1/users/signup
+Content-Type: application/json
+
+{
+  "loginId": "abc",
+  "password": "Test1234!",
+  "name": "홍길동",
+  "birthDate": "19900101",
+  "email": "test@example.com"
+}
+
+### 회원가입 - 로그인 ID 12자 초과 (실패)
+POST {{commerce-api}}/api/v1/users/signup
+Content-Type: application/json
+
+{
+  "loginId": "testuser12345",
+  "password": "Test1234!",
+  "name": "홍길동",
+  "birthDate": "19900101",
+  "email": "test@example.com"
+}
+
+### 회원가입 - 로그인 ID 특수문자 포함 (실패)
+POST {{commerce-api}}/api/v1/users/signup
+Content-Type: application/json
+
+{
+  "loginId": "test@user",
+  "password": "Test1234!",
+  "name": "홍길동",
+  "birthDate": "19900101",
+  "email": "test@example.com"
+}
+
+### 회원가입 - 비밀번호 8자 미만 (실패)
+POST {{commerce-api}}/api/v1/users/signup
+Content-Type: application/json
+
+{
+  "loginId": "testuser1",
+  "password": "Test12!",
+  "name": "홍길동",
+  "birthDate": "19900101",
+  "email": "test@example.com"
+}
+
+### 회원가입 - 비밀번호 16자 초과 (실패)
+POST {{commerce-api}}/api/v1/users/signup
+Content-Type: application/json
+
+{
+  "loginId": "testuser1",
+  "password": "Test1234567890123!",
+  "name": "홍길동",
+  "birthDate": "19900101",
+  "email": "test@example.com"
+}
+
+### 회원가입 - 비밀번호에 생년월일 포함 (실패)
+POST {{commerce-api}}/api/v1/users/signup
+Content-Type: application/json
+
+{
+  "loginId": "testuser1",
+  "password": "Test19900101!",
+  "name": "홍길동",
+  "birthDate": "19900101",
+  "email": "test@example.com"
+}
+
+### 회원가입 - 이메일 형식 오류 (실패)
+POST {{commerce-api}}/api/v1/users/signup
+Content-Type: application/json
+
+{
+  "loginId": "testuser1",
+  "password": "Test1234!",
+  "name": "홍길동",
+  "birthDate": "19900101",
+  "email": "invalid-email"
+}
+
+### 회원가입 - 이름 2자 미만 (실패)
+POST {{commerce-api}}/api/v1/users/signup
+Content-Type: application/json
+
+{
+  "loginId": "testuser1",
+  "password": "Test1234!",
+  "name": "홍",
+  "birthDate": "19900101",
+  "email": "test@example.com"
+}
+
+### 회원가입 - 이름 10자 초과 (실패)
+POST {{commerce-api}}/api/v1/users/signup
+Content-Type: application/json
+
+{
+  "loginId": "testuser1",
+  "password": "Test1234!",
+  "name": "홍길동김철수박영희최강",
+  "birthDate": "19900101",
+  "email": "test@example.com"
+}
+
+### 회원가입 - 중복 로그인 ID (실패)
+POST {{commerce-api}}/api/v1/users/signup
+Content-Type: application/json
+
+{
+  "loginId": "testuser1",
+  "password": "Test5678!",
+  "name": "김철수",
+  "birthDate": "19950505",
+  "email": "test2@example.com"
+}
+
+###############################################
+# 내 정보 조회 API
+###############################################
+
+### 내 정보 조회 - 성공 케이스
+GET {{commerce-api}}/api/v1/users/me
+X-Loopers-LoginId: testuser1
+X-Loopers-LoginPw: Test1234!
+
+### 내 정보 조회 - 존재하지 않는 로그인 ID (실패)
+GET {{commerce-api}}/api/v1/users/me
+X-Loopers-LoginId: nonexistent
+X-Loopers-LoginPw: Test1234!
+
+### 내 정보 조회 - 잘못된 비밀번호 (실패)
+GET {{commerce-api}}/api/v1/users/me
+X-Loopers-LoginId: testuser1
+X-Loopers-LoginPw: Wrong1234!
+
+### 내 정보 조회 - 인증 헤더 누락 (실패)
+GET {{commerce-api}}/api/v1/users/me
+
+###############################################
+# 비밀번호 변경 API
+###############################################
+
+### 비밀번호 변경 - 성공 케이스
+PATCH {{commerce-api}}/api/v1/users/password
+X-Loopers-LoginId: testuser1
+X-Loopers-LoginPw: Test1234!
+Content-Type: application/json
+
+{
+  "currentPassword": "Test1234!",
+  "newPassword": "NewPass123!@"
+}
+
+### 비밀번호 변경 - 현재 비밀번호 불일치 (실패)
+PATCH {{commerce-api}}/api/v1/users/password
+X-Loopers-LoginId: testuser1
+X-Loopers-LoginPw: Test1234!
+Content-Type: application/json
+
+{
+  "currentPassword": "Wrong1234!",
+  "newPassword": "NewPass123!@"
+}
+
+### 비밀번호 변경 - 새 비밀번호가 현재 비밀번호와 동일 (실패)
+PATCH {{commerce-api}}/api/v1/users/password
+X-Loopers-LoginId: testuser1
+X-Loopers-LoginPw: Test1234!
+Content-Type: application/json
+
+{
+  "currentPassword": "Test1234!",
+  "newPassword": "Test1234!"
+}
+
+### 비밀번호 변경 - 새 비밀번호에 생년월일 포함 (실패)
+PATCH {{commerce-api}}/api/v1/users/password
+X-Loopers-LoginId: testuser1
+X-Loopers-LoginPw: Test1234!
+Content-Type: application/json
+
+{
+  "currentPassword": "Test1234!",
+  "newPassword": "Pw19900101!"
+}
+
+### 비밀번호 변경 - 잘못된 인증 헤더 (실패)
+PATCH {{commerce-api}}/api/v1/users/password
+X-Loopers-LoginId: testuser1
+X-Loopers-LoginPw: Wrong1234!
+Content-Type: application/json
+
+{
+  "currentPassword": "Test1234!",
+  "newPassword": "NewPass123!@"
+}
+
+### 비밀번호 변경 - 새 비밀번호 형식 오류 (실패)
+PATCH {{commerce-api}}/api/v1/users/password
+X-Loopers-LoginId: testuser1
+X-Loopers-LoginPw: Test1234!
+Content-Type: application/json
+
+{
+  "currentPassword": "Test1234!",
+  "newPassword": "short"
+}
+
+###############################################
+# 시나리오 테스트 (전체 플로우)
+###############################################
+
+### [STEP 1] 회원가입 - 시나리오 테스트용 사용자
+POST {{commerce-api}}/api/v1/users/signup
+Content-Type: application/json
+
+{
+  "loginId": "scenario123",
+  "password": "Test1234!@#",
+  "name": "홍길동",
+  "birthDate": "19900115",
+  "email": "scenario@example.com"
+}
+
+### [STEP 2] 내 정보 조회 - 원래 비밀번호로 인증
+GET {{commerce-api}}/api/v1/users/me
+X-Loopers-LoginId: scenario123
+X-Loopers-LoginPw: Test1234!@#
+
+### [STEP 3] 비밀번호 변경
+PATCH {{commerce-api}}/api/v1/users/password
+X-Loopers-LoginId: scenario123
+X-Loopers-LoginPw: Test1234!@#
+Content-Type: application/json
+
+{
+  "currentPassword": "Test1234!@#",
+  "newPassword": "NewPass123!@"
+}
+
+### [STEP 4] 내 정보 조회 - 새 비밀번호로 인증 (성공)
+GET {{commerce-api}}/api/v1/users/me
+X-Loopers-LoginId: scenario123
+X-Loopers-LoginPw: NewPass123!@
+
+### [STEP 5] 내 정보 조회 - 이전 비밀번호로 인증 (실패)
+GET {{commerce-api}}/api/v1/users/me
+X-Loopers-LoginId: scenario123
+X-Loopers-LoginPw: Test1234!@#