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/CLAUDE.md b/CLAUDE.md
new file mode 100644
index 00000000..aaa06230
--- /dev/null
+++ b/CLAUDE.md
@@ -0,0 +1,196 @@
+# CLAUDE.md
+
+이 파일은 Claude Code가 프로젝트 작업 시 참조하는 컨텍스트 문서입니다.
+
+## 프로젝트 개요
+
+**loopers-java-spring-template** - Loopers에서 제공하는 Spring + Java 멀티모듈 템플릿 프로젝트입니다.
+
+- **Group**: `com.loopers`
+- **Language**: Java 21
+- **Build Tool**: Gradle 8.13 (Kotlin DSL)
+- **Framework**: Spring Boot 3.4.4
+
+## 기술 스택
+
+### Core
+| 기술 | 버전 |
+|------|------|
+| Java | 21 |
+| Gradle | 8.13 |
+| Spring Boot | 3.4.4 |
+| Spring Cloud | 2024.0.1 |
+| Spring Dependency Management | 1.1.7 |
+
+### Database & Cache
+| 기술 | 용도 |
+|------|------|
+| Spring Data JPA | ORM |
+| QueryDSL (jakarta) | 타입 세이프 쿼리 |
+| MySQL | RDBMS |
+| Spring Data Redis | 캐시/세션 |
+| Spring Kafka | 메시지 브로커 |
+
+### 테스트
+| 기술 | 버전 |
+|------|------|
+| Testcontainers | 2.0.2 |
+| Spring MockK | 4.0.2 |
+| Mockito | 5.14.0 |
+| Instancio JUnit | 5.0.2 |
+| JaCoCo | 테스트 커버리지 |
+
+### 문서화 & 모니터링
+| 기술 | 버전/용도 |
+|------|----------|
+| SpringDoc OpenAPI | 2.7.0 |
+| Micrometer + Prometheus | 메트릭 수집 |
+| Micrometer Tracing (Brave) | 분산 추적 |
+| Logback Slack Appender | 1.6.1 |
+
+### 유틸리티
+- Lombok
+- Jackson (JSR310, Kotlin Module)
+
+## 모듈 구조
+
+```
+Root
+├── apps (실행 가능한 SpringBootApplication)
+│   ├── commerce-api        # REST API 서버 (Web + OpenAPI)
+│   ├── commerce-batch      # Spring Batch 애플리케이션
+│   └── commerce-streamer   # Kafka 기반 스트리밍 애플리케이션
+│
+├── modules (재사용 가능한 Configuration)
+│   ├── jpa                 # JPA + QueryDSL + MySQL 설정
+│   ├── redis               # Redis 설정
+│   └── kafka               # Kafka 설정
+│
+└── supports (부가 기능 Add-on)
+    ├── jackson             # Jackson 직렬화 설정
+    ├── logging             # 로깅 + Slack Appender
+    └── monitoring          # Actuator + Prometheus 메트릭
+```
+
+### 모듈 의존성
+
+| App | 의존 모듈 |
+|-----|----------|
+| commerce-api | jpa, redis, jackson, logging, monitoring |
+| commerce-batch | jpa, redis, jackson, logging, monitoring |
+| commerce-streamer | jpa, redis, kafka, jackson, logging, monitoring |
+
+## 빌드 & 실행
+
+### 빌드
+```bash
+./gradlew build
+```
+
+### 테스트
+```bash
+./gradlew test
+```
+
+테스트 설정:
+- Timezone: `Asia/Seoul`
+- Profile: `test`
+- 병렬 실행: 비활성화 (`maxParallelForks = 1`)
+
+### 로컬 환경 실행
+```bash
+# 인프라 (MySQL, Redis, Kafka 등)
+docker-compose -f ./docker/infra-compose.yml up
+
+# 모니터링 (Prometheus, Grafana)
+docker-compose -f ./docker/monitoring-compose.yml up
+```
+
+Grafana: http://localhost:3000 (admin/admin)
+
+## 컨벤션
+
+### 모듈 규칙
+- `apps`: BootJar 활성화, 일반 Jar 비활성화
+- `modules`, `supports`: 일반 Jar 활성화, BootJar 비활성화
+- `modules`, `supports`는 `java-library` 플러그인 사용
+- 테스트 픽스처는 `java-test-fixtures` 플러그인으로 관리
+
+### 버전 관리
+- 프로젝트 버전 미지정 시 Git short hash 사용
+- 의존성 버전은 `gradle.properties`에서 중앙 관리
+
+## 주요 디렉토리
+
+```
+/docker          # Docker Compose 파일
+/http            # HTTP 요청 테스트 파일
+/gradle          # Gradle Wrapper
+```
+
+## 개발 컨벤션 (Strict Rules)
+
+### Entity & Domain
+- **Entity**: `@Setter` 사용 금지. 변경 로직은 도메인 메서드(예: `updatePassword()`)로 구현.
+- **Lombok**: `@Getter`, `@NoArgsConstructor(access = AccessLevel.PROTECTED)` 기본 사용.
+- **BaseEntity**: 모든 Entity는 `com.loopers.domain.BaseEntity`를 상속받아 생성/수정 시간을 관리.
+- **Validation**: 생성자 시점에 `CoreException`을 사용하여 유효성 검증 수행.
+
+### API & Exception
+- **Response**: 모든 Controller 응답은 `com.loopers.interfaces.api.ApiResponse<T>`로 감싸서 반환.
+- **Exception**: 예외 발생 시 `com.loopers.support.error.CoreException`과 `ErrorType`을 사용. Java 표준 예외(`IllegalArgumentException` 등) 사용 지양.
+
+### Coding Style
+- **Null Safety**: `Optional`을 적극 활용. `null`을 직접 반환하거나 파라미터로 받지 않음.
+- **DI**: 생성자 주입(`@RequiredArgsConstructor`) 사용. Field Injection(`@Autowired`) 금지.
+
+## 테스트 전략 (TDD Workflow)
+
+**대원칙: Red(실패) -> Green(구현) -> Refactor(개선)** 순서를 반드시 준수한다.
+
+### 1. 단위 테스트 (Unit Test)
+- **대상**: Domain Entity, POJO
+- **도구**: JUnit5, AssertJ
+- **특징**: Spring Context 로딩 금지. 순수 자바 코드로 검증.
+- **위치**: `apps/commerce-api/src/test/java/com/loopers/domain/**`
+
+### 2. 통합 테스트 (Integration Test)
+- **대상**: Service, Repository
+- **도구**: `@SpringBootTest`, Testcontainers (MySQL)
+- **규칙**: `com.loopers.utils.DatabaseCleanUp`을 사용하여 매 테스트 종료 후 데이터 초기화.
+- **위치**: `apps/commerce-api/src/test/java/com/loopers/application/**`
+
+### 3. E2E 테스트 (API Test)
+- **대상**: Controller (HTTP 요청/응답)
+- **도구**: `TestRestTemplate`
+- **검증**: 실제 HTTP Status Code와 `ApiResponse` 본문 검증.
+
+## Round 1 Quest 요구사항 (Current Context)
+
+### 1. 회원가입
+- **필수 정보**: ID, 비밀번호, 이름, 생년월일, 이메일
+- **ID 규칙**: 영문/숫자 조합 10자 이내. 중복 불가.
+- **비밀번호 규칙**:
+    - 8~16자
+    - 영문 대소문자, 숫자, 특수문자 필수 포함
+    - 생년월일 포함 불가
+    - 암호화하여 저장 필수
+- **유효성 검사**: 이메일 형식, 생년월일(`yyyy-MM-dd`) 형식 검증.
+
+### 2. 내 정보 조회
+- **마스킹**: 이름의 마지막 글자를 `*`로 마스킹하여 반환 (예: `홍길동` -> `홍길*`).
+
+### 3. 비밀번호 수정
+- 현재 비밀번호 확인 후 새 비밀번호로 변경.
+- 기존 비밀번호와 동일한 비밀번호 사용 불가.
+
+## AI 페르소나 및 행동 지침
+- **언어**: 한국어 (기술 용어는 영어 병기 가능)
+- **우선순위**:
+    1. 실제 실행 가능한 코드 제공
+    2. 테스트 코드 우선 작성 (TDD)
+    3. 기존 프로젝트 구조(Multi-module) 준수
+- **금지사항**:
+    - `System.out.println` 사용 금지 (로깅은 `@Slf4j` 사용)
+    - 불필요한 주석이나 설명으로 답변 길게 하지 말 것.
+    - 존재하지 않는 라이브러리를 임의로 추가하지 말 것.
\ No newline at end of file
diff --git a/apps/commerce-api/build.gradle.kts b/apps/commerce-api/build.gradle.kts
index 03ce68f0..0fbb1f31 100644
--- a/apps/commerce-api/build.gradle.kts
+++ b/apps/commerce-api/build.gradle.kts
@@ -8,6 +8,9 @@ dependencies {
 
     // web
     implementation("org.springframework.boot:spring-boot-starter-web")
+
+    // security (for password encoding)
+    implementation("org.springframework.security:spring-security-crypto")
     implementation("org.springframework.boot:spring-boot-starter-actuator")
     implementation("org.springdoc:springdoc-openapi-starter-webmvc-ui:${project.properties["springDocOpenApiVersion"]}")
 
diff --git a/apps/commerce-api/src/main/java/com/loopers/application/member/MemberFacade.java b/apps/commerce-api/src/main/java/com/loopers/application/member/MemberFacade.java
new file mode 100644
index 00000000..c1899165
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/application/member/MemberFacade.java
@@ -0,0 +1,30 @@
+package com.loopers.application.member;
+
+import com.loopers.domain.member.Member;
+import com.loopers.domain.member.MemberRepository;
+import com.loopers.domain.member.MemberService;
+import com.loopers.support.error.CoreException;
+import com.loopers.support.error.ErrorType;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+
+@Component
+@RequiredArgsConstructor
+public class MemberFacade {
+
+    private final MemberService memberService;
+    private final MemberRepository memberRepository;
+
+    @Transactional
+    public Member signup(MemberService.SignupCommand command) {
+        return memberService.signup(command);
+    }
+
+    @Transactional
+    public void changePassword(Member member, String currentPassword, String newPassword) {
+        Member managedMember = memberRepository.findByMemberIdValue(member.getMemberId().getValue())
+                .orElseThrow(() -> new CoreException(ErrorType.NOT_FOUND, "회원을 찾을 수 없습니다."));
+        memberService.changePassword(managedMember, currentPassword, newPassword);
+    }
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/config/DomainConfig.java b/apps/commerce-api/src/main/java/com/loopers/config/DomainConfig.java
new file mode 100644
index 00000000..057c3260
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/config/DomainConfig.java
@@ -0,0 +1,16 @@
+package com.loopers.config;
+
+import com.loopers.domain.member.MemberRepository;
+import com.loopers.domain.member.MemberService;
+import com.loopers.domain.member.PasswordEncoder;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+@Configuration
+public class DomainConfig {
+
+    @Bean
+    public MemberService memberService(MemberRepository memberRepository, PasswordEncoder passwordEncoder) {
+        return new MemberService(memberRepository, passwordEncoder);
+    }
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/domain/member/Member.java b/apps/commerce-api/src/main/java/com/loopers/domain/member/Member.java
new file mode 100644
index 00000000..8d6c41d7
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/member/Member.java
@@ -0,0 +1,55 @@
+package com.loopers.domain.member;
+
+import com.loopers.domain.BaseEntity;
+import com.loopers.domain.member.vo.BirthDate;
+import com.loopers.domain.member.vo.Email;
+import com.loopers.domain.member.vo.MemberId;
+import com.loopers.domain.member.vo.Name;
+import com.loopers.domain.member.vo.Password;
+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.Getter;
+import lombok.NoArgsConstructor;
+
+@Entity
+@Table(name = "member")
+@Getter
+@NoArgsConstructor(access = AccessLevel.PROTECTED)
+public class Member extends BaseEntity {
+
+    @Embedded
+    @AttributeOverride(name = "value", column = @Column(name = "member_id", nullable = false, unique = true))
+    private MemberId memberId;
+
+    @Embedded
+    @AttributeOverride(name = "value", column = @Column(name = "password", nullable = false))
+    private Password password;
+
+    @Embedded
+    @AttributeOverride(name = "value", column = @Column(name = "name", nullable = false))
+    private Name name;
+
+    @Embedded
+    @AttributeOverride(name = "value", column = @Column(name = "email", nullable = false))
+    private Email email;
+
+    @Embedded
+    @AttributeOverride(name = "value", column = @Column(name = "birth_date", nullable = false))
+    private BirthDate birthDate;
+
+    public Member(MemberId memberId, Password password, Name name, Email email, BirthDate birthDate) {
+        this.memberId = memberId;
+        this.password = password;
+        this.name = name;
+        this.email = email;
+        this.birthDate = birthDate;
+    }
+
+    public void updatePassword(String currentPassword, String newPassword, PasswordEncoder encoder) {
+        this.password = this.password.change(currentPassword, newPassword, this.birthDate, encoder);
+    }
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/domain/member/MemberRepository.java b/apps/commerce-api/src/main/java/com/loopers/domain/member/MemberRepository.java
new file mode 100644
index 00000000..1550e6e3
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/member/MemberRepository.java
@@ -0,0 +1,12 @@
+package com.loopers.domain.member;
+
+import java.util.Optional;
+
+public interface MemberRepository {
+
+    Member save(Member member);
+
+    Optional<Member> findByMemberIdValue(String memberIdValue);
+
+    boolean existsByMemberIdValue(String memberIdValue);
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/domain/member/MemberService.java b/apps/commerce-api/src/main/java/com/loopers/domain/member/MemberService.java
new file mode 100644
index 00000000..87c94e73
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/member/MemberService.java
@@ -0,0 +1,51 @@
+package com.loopers.domain.member;
+
+import com.loopers.domain.member.vo.BirthDate;
+import com.loopers.domain.member.vo.Email;
+import com.loopers.domain.member.vo.MemberId;
+import com.loopers.domain.member.vo.Name;
+import com.loopers.domain.member.vo.Password;
+import com.loopers.support.error.CoreException;
+import com.loopers.support.error.ErrorType;
+import lombok.RequiredArgsConstructor;
+
+@RequiredArgsConstructor
+public class MemberService {
+
+    private final MemberRepository memberRepository;
+    private final PasswordEncoder passwordEncoder;
+
+    public Member signup(SignupCommand command) {
+        MemberId memberId = new MemberId(command.memberId());
+        BirthDate birthDate = new BirthDate(command.birthDate());
+
+        if (memberRepository.existsByMemberIdValue(memberId.getValue())) {
+            throw new CoreException(ErrorType.CONFLICT, "이미 존재하는 회원 ID입니다.");
+        }
+
+        Password.validate(command.password(), birthDate);
+        String encodedPassword = passwordEncoder.encode(command.password());
+
+        Member member = new Member(
+                memberId,
+                Password.ofEncoded(encodedPassword),
+                new Name(command.name()),
+                new Email(command.email()),
+                birthDate
+        );
+
+        return memberRepository.save(member);
+    }
+
+    public void changePassword(Member member, String currentPassword, String newPassword) {
+        member.updatePassword(currentPassword, newPassword, passwordEncoder);
+    }
+
+    public record SignupCommand(
+            String memberId,
+            String password,
+            String name,
+            String email,
+            String birthDate
+    ) {}
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/domain/member/PasswordEncoder.java b/apps/commerce-api/src/main/java/com/loopers/domain/member/PasswordEncoder.java
new file mode 100644
index 00000000..056131f0
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/member/PasswordEncoder.java
@@ -0,0 +1,8 @@
+package com.loopers.domain.member;
+
+public interface PasswordEncoder {
+
+    String encode(String rawPassword);
+
+    boolean matches(String rawPassword, String encodedPassword);
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/domain/member/vo/BirthDate.java b/apps/commerce-api/src/main/java/com/loopers/domain/member/vo/BirthDate.java
new file mode 100644
index 00000000..8e9e8d88
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/member/vo/BirthDate.java
@@ -0,0 +1,56 @@
+package com.loopers.domain.member.vo;
+
+import com.loopers.support.error.CoreException;
+import com.loopers.support.error.ErrorType;
+import jakarta.persistence.Embeddable;
+import lombok.AccessLevel;
+import lombok.EqualsAndHashCode;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import java.time.LocalDate;
+import java.time.format.DateTimeFormatter;
+import java.time.format.DateTimeParseException;
+import java.time.format.ResolverStyle;
+
+@Getter
+@EqualsAndHashCode
+@Embeddable
+@NoArgsConstructor(access = AccessLevel.PROTECTED)
+public class BirthDate {
+
+    private static final DateTimeFormatter FORMATTER = DateTimeFormatter.ofPattern("uuuu-MM-dd")
+            .withResolverStyle(ResolverStyle.STRICT);
+
+    private LocalDate value;
+
+    public BirthDate(String value) {
+        this.value = parse(value);
+        validateNotFuture(this.value);
+    }
+
+    private LocalDate parse(String value) {
+        if (value == null || value.isBlank()) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "생년월일은 필수입니다.");
+        }
+
+        try {
+            return LocalDate.parse(value, FORMATTER);
+        } catch (DateTimeParseException e) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "생년월일 형식이 올바르지 않습니다. (yyyy-MM-dd)", e);
+        }
+    }
+
+    private void validateNotFuture(LocalDate date) {
+        if (date.isAfter(LocalDate.now())) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "생년월일은 미래 날짜일 수 없습니다.");
+        }
+    }
+
+    public String getFormattedValue() {
+        return value.format(FORMATTER);
+    }
+
+    public String toPlainString() {
+        return getFormattedValue().replaceAll("-", "");
+    }
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/domain/member/vo/Email.java b/apps/commerce-api/src/main/java/com/loopers/domain/member/vo/Email.java
new file mode 100644
index 00000000..5cc0626d
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/member/vo/Email.java
@@ -0,0 +1,39 @@
+package com.loopers.domain.member.vo;
+
+import com.loopers.support.error.CoreException;
+import com.loopers.support.error.ErrorType;
+import jakarta.persistence.Embeddable;
+import lombok.AccessLevel;
+import lombok.EqualsAndHashCode;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import java.util.regex.Pattern;
+
+@Getter
+@EqualsAndHashCode
+@Embeddable
+@NoArgsConstructor(access = AccessLevel.PROTECTED)
+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 value;
+
+    public Email(String value) {
+        String normalized = value != null ? value.toLowerCase() : null;
+        validate(normalized);
+        this.value = normalized;
+    }
+
+    private void validate(String value) {
+        if (value == null || value.isBlank()) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "이메일은 필수입니다.");
+        }
+
+        if (!EMAIL_PATTERN.matcher(value).matches()) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "이메일 형식이 올바르지 않습니다.");
+        }
+    }
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/domain/member/vo/MemberId.java b/apps/commerce-api/src/main/java/com/loopers/domain/member/vo/MemberId.java
new file mode 100644
index 00000000..885bfb63
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/member/vo/MemberId.java
@@ -0,0 +1,41 @@
+package com.loopers.domain.member.vo;
+
+import com.loopers.support.error.CoreException;
+import com.loopers.support.error.ErrorType;
+import jakarta.persistence.Embeddable;
+import lombok.AccessLevel;
+import lombok.EqualsAndHashCode;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+
+@Getter
+@EqualsAndHashCode
+@Embeddable
+@NoArgsConstructor(access = AccessLevel.PROTECTED)
+public class MemberId {
+
+    private static final int MIN_LENGTH = 4;
+    private static final int MAX_LENGTH = 10;
+    private static final String PATTERN = "^[a-zA-Z0-9]+$";
+
+    private String value;
+
+    public MemberId(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는 " + MIN_LENGTH + "~" + MAX_LENGTH + "자여야 합니다.");
+        }
+
+        if (!value.matches(PATTERN)) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "회원 ID는 영문과 숫자만 사용할 수 있습니다.");
+        }
+    }
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/domain/member/vo/Name.java b/apps/commerce-api/src/main/java/com/loopers/domain/member/vo/Name.java
new file mode 100644
index 00000000..429ea931
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/member/vo/Name.java
@@ -0,0 +1,43 @@
+package com.loopers.domain.member.vo;
+
+import com.loopers.support.error.CoreException;
+import com.loopers.support.error.ErrorType;
+import jakarta.persistence.Embeddable;
+import lombok.AccessLevel;
+import lombok.EqualsAndHashCode;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+
+@Getter
+@EqualsAndHashCode
+@Embeddable
+@NoArgsConstructor(access = AccessLevel.PROTECTED)
+public class Name {
+
+    private static final int MAX_LENGTH = 20;
+
+    private String value;
+
+    public Name(String value) {
+        String trimmed = value != null ? value.trim() : null;
+        validate(trimmed);
+        this.value = trimmed;
+    }
+
+    private void validate(String value) {
+        if (value == null || value.isBlank()) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "이름은 필수입니다.");
+        }
+
+        if (value.length() > MAX_LENGTH) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "이름은 " + MAX_LENGTH + "자 이내여야 합니다.");
+        }
+    }
+
+    public String masked() {
+        if (value.length() == 1) {
+            return "*";
+        }
+        return value.substring(0, value.length() - 1) + "*";
+    }
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/domain/member/vo/Password.java b/apps/commerce-api/src/main/java/com/loopers/domain/member/vo/Password.java
new file mode 100644
index 00000000..cc0de132
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/member/vo/Password.java
@@ -0,0 +1,88 @@
+package com.loopers.domain.member.vo;
+
+import com.loopers.domain.member.PasswordEncoder;
+import com.loopers.support.error.CoreException;
+import com.loopers.support.error.ErrorType;
+import jakarta.persistence.Embeddable;
+import lombok.AccessLevel;
+import lombok.EqualsAndHashCode;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+
+@Getter
+@EqualsAndHashCode
+@Embeddable
+@NoArgsConstructor(access = AccessLevel.PROTECTED)
+public class Password {
+
+    private static final int MIN_LENGTH = 8;
+    private static final int MAX_LENGTH = 16;
+    private static final String COMPLEXITY_REGEX = "^(?=.*[a-zA-Z])(?=.*\\d)(?=.*[!@#$%^&*()_+\\-=\\[\\]{};':\"\\\\|,.<>/?]).+$";
+
+    private String value;
+
+    private Password(String encodedValue) {
+        this.value = encodedValue;
+    }
+
+    public static void validate(String rawPassword, BirthDate birthDate) {
+        validatePasswordPolicy(rawPassword, birthDate);
+    }
+
+    public static Password ofEncoded(String encodedValue) {
+        return new Password(encodedValue);
+    }
+
+    private static void validatePasswordPolicy(String rawPassword, BirthDate birthDate) {
+        if (rawPassword == null || rawPassword.length() < MIN_LENGTH || rawPassword.length() > MAX_LENGTH) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "비밀번호는 " + MIN_LENGTH + "~" + MAX_LENGTH + "자여야 합니다.");
+        }
+
+        if (!rawPassword.matches(COMPLEXITY_REGEX)) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "비밀번호는 영문, 숫자, 특수문자를 포함해야 합니다.");
+        }
+
+        checkBirthPatterns(rawPassword, birthDate);
+    }
+
+    private static void checkBirthPatterns(String rawPassword, BirthDate birthDate) {
+        String plainBirth = birthDate.toPlainString();
+
+        String year = plainBirth.substring(0, 4);
+        String yy = plainBirth.substring(2, 4);
+        String mmdd = plainBirth.substring(4, 8);
+
+        String[] blackListPatterns = {
+                year,
+                yy,
+                mmdd,
+                yy + mmdd,
+                year + mmdd
+        };
+
+        for (String pattern : blackListPatterns) {
+            if (rawPassword.contains(pattern)) {
+                throw new CoreException(ErrorType.BAD_REQUEST, "비밀번호에 생년월일과 관련된 숫자(" + pattern + ")를 포함할 수 없습니다.");
+            }
+        }
+    }
+
+    public boolean matches(String rawPassword, PasswordEncoder encoder) {
+        return encoder.matches(rawPassword, this.value);
+    }
+
+    public Password change(String currentPassword, String newPassword,
+                           BirthDate birthDate, PasswordEncoder encoder) {
+        if (!matches(currentPassword, encoder)) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "현재 비밀번호가 일치하지 않습니다.");
+        }
+
+        Password.validate(newPassword, birthDate);
+
+        if (matches(newPassword, encoder)) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "기존 비밀번호와 동일한 비밀번호는 사용할 수 없습니다.");
+        }
+
+        return Password.ofEncoded(encoder.encode(newPassword));
+    }
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/infrastructure/member/MemberJpaRepository.java b/apps/commerce-api/src/main/java/com/loopers/infrastructure/member/MemberJpaRepository.java
new file mode 100644
index 00000000..22cae84d
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/infrastructure/member/MemberJpaRepository.java
@@ -0,0 +1,17 @@
+package com.loopers.infrastructure.member;
+
+import com.loopers.domain.member.Member;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.repository.query.Param;
+
+import java.util.Optional;
+
+public interface MemberJpaRepository extends JpaRepository<Member, Long> {
+
+    @Query("SELECT m FROM Member m WHERE m.memberId.value = :value")
+    Optional<Member> findByMemberIdValue(@Param("value") String value);
+
+    @Query("SELECT CASE WHEN COUNT(m) > 0 THEN true ELSE false END FROM Member m WHERE m.memberId.value = :value")
+    boolean existsByMemberIdValue(@Param("value") String value);
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/infrastructure/member/MemberRepositoryImpl.java b/apps/commerce-api/src/main/java/com/loopers/infrastructure/member/MemberRepositoryImpl.java
new file mode 100644
index 00000000..20c12999
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/infrastructure/member/MemberRepositoryImpl.java
@@ -0,0 +1,36 @@
+package com.loopers.infrastructure.member;
+
+import com.loopers.domain.member.Member;
+import com.loopers.domain.member.MemberRepository;
+import com.loopers.support.error.CoreException;
+import com.loopers.support.error.ErrorType;
+import lombok.RequiredArgsConstructor;
+import org.springframework.dao.DataIntegrityViolationException;
+import org.springframework.stereotype.Repository;
+import java.util.Optional;
+
+@Repository
+@RequiredArgsConstructor
+public class MemberRepositoryImpl implements MemberRepository {
+
+    private final MemberJpaRepository memberJpaRepository;
+
+    @Override
+    public Member save(Member member) {
+        try {
+            return memberJpaRepository.save(member);
+        } catch (DataIntegrityViolationException e) {
+            throw new CoreException(ErrorType.CONFLICT, "이미 존재하는 회원 정보입니다.", e);
+        }
+    }
+
+    @Override
+    public Optional<Member> findByMemberIdValue(String memberIdValue) {
+        return memberJpaRepository.findByMemberIdValue(memberIdValue);
+    }
+
+    @Override
+    public boolean existsByMemberIdValue(String memberIdValue) {
+        return memberJpaRepository.existsByMemberIdValue(memberIdValue);
+    }
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/infrastructure/security/BCryptPasswordEncoderAdapter.java b/apps/commerce-api/src/main/java/com/loopers/infrastructure/security/BCryptPasswordEncoderAdapter.java
new file mode 100644
index 00000000..e0c346af
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/infrastructure/security/BCryptPasswordEncoderAdapter.java
@@ -0,0 +1,21 @@
+package com.loopers.infrastructure.security;
+
+import com.loopers.domain.member.PasswordEncoder;
+import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
+import org.springframework.stereotype.Component;
+
+@Component
+public class BCryptPasswordEncoderAdapter implements PasswordEncoder {
+
+    private final BCryptPasswordEncoder 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/interfaces/api/member/MemberV1Controller.java b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/member/MemberV1Controller.java
new file mode 100644
index 00000000..2422b2e1
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/member/MemberV1Controller.java
@@ -0,0 +1,41 @@
+package com.loopers.interfaces.api.member;
+
+import com.loopers.application.member.MemberFacade;
+import com.loopers.domain.member.Member;
+import com.loopers.interfaces.api.ApiResponse;
+import com.loopers.interfaces.resolver.LoginUser;
+import lombok.RequiredArgsConstructor;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.PutMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+@RestController
+@RequestMapping("/api/v1/members")
+@RequiredArgsConstructor
+public class MemberV1Controller {
+
+    private final MemberFacade memberFacade;
+
+    @PostMapping("/signup")
+    public ApiResponse<MemberV1Dto.SignupResponse> signup(@RequestBody MemberV1Dto.SignupRequest request) {
+        Member member = memberFacade.signup(request.toCommand());
+        return ApiResponse.success(MemberV1Dto.SignupResponse.from(member));
+    }
+
+    @GetMapping("/me")
+    public ApiResponse<MemberV1Dto.MeResponse> me(@LoginUser Member member) {
+        return ApiResponse.success(MemberV1Dto.MeResponse.from(member));
+    }
+
+    @PutMapping("/me/password")
+    public ApiResponse<Object> changePassword(
+            @LoginUser Member member,
+            @RequestBody MemberV1Dto.ChangePasswordRequest body
+    ) {
+        memberFacade.changePassword(member, body.currentPassword(), body.newPassword());
+        return ApiResponse.success();
+    }
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/interfaces/api/member/MemberV1Dto.java b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/member/MemberV1Dto.java
new file mode 100644
index 00000000..370a03d0
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/member/MemberV1Dto.java
@@ -0,0 +1,60 @@
+package com.loopers.interfaces.api.member;
+
+import com.loopers.domain.member.Member;
+import com.loopers.domain.member.MemberService;
+
+public class MemberV1Dto {
+
+    public record SignupRequest(
+            String memberId,
+            String password,
+            String name,
+            String email,
+            String birthDate
+    ) {
+        public MemberService.SignupCommand toCommand() {
+            return new MemberService.SignupCommand(
+                    memberId,
+                    password,
+                    name,
+                    email,
+                    birthDate
+            );
+        }
+    }
+
+    public record SignupResponse(
+            String memberId,
+            String name,
+            String email
+    ) {
+        public static SignupResponse from(Member member) {
+            return new SignupResponse(
+                    member.getMemberId().getValue(),
+                    member.getName().getValue(),
+                    member.getEmail().getValue()
+            );
+        }
+    }
+
+    public record ChangePasswordRequest(
+            String currentPassword,
+            String newPassword
+    ) {}
+
+    public record MeResponse(
+            String memberId,
+            String name,
+            String email,
+            String birthDate
+    ) {
+        public static MeResponse from(Member member) {
+            return new MeResponse(
+                    member.getMemberId().getValue(),
+                    member.getName().masked(),
+                    member.getEmail().getValue(),
+                    member.getBirthDate().getFormattedValue()
+            );
+        }
+    }
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/interfaces/config/WebConfig.java b/apps/commerce-api/src/main/java/com/loopers/interfaces/config/WebConfig.java
new file mode 100644
index 00000000..6faafcdd
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/interfaces/config/WebConfig.java
@@ -0,0 +1,21 @@
+package com.loopers.interfaces.config;
+
+import com.loopers.interfaces.resolver.LoginUserArgumentResolver;
+import lombok.RequiredArgsConstructor;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.web.method.support.HandlerMethodArgumentResolver;
+import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
+
+import java.util.List;
+
+@Configuration
+@RequiredArgsConstructor
+public class WebConfig implements WebMvcConfigurer {
+
+    private final LoginUserArgumentResolver loginUserArgumentResolver;
+
+    @Override
+    public void addArgumentResolvers(List<HandlerMethodArgumentResolver> resolvers) {
+        resolvers.add(loginUserArgumentResolver);
+    }
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/interfaces/filter/AuthenticationFilter.java b/apps/commerce-api/src/main/java/com/loopers/interfaces/filter/AuthenticationFilter.java
new file mode 100644
index 00000000..c93814d7
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/interfaces/filter/AuthenticationFilter.java
@@ -0,0 +1,104 @@
+package com.loopers.interfaces.filter;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.loopers.domain.member.Member;
+import com.loopers.domain.member.MemberRepository;
+import com.loopers.domain.member.PasswordEncoder;
+import com.loopers.interfaces.api.ApiResponse;
+import jakarta.servlet.Filter;
+import jakarta.servlet.FilterChain;
+import jakarta.servlet.ServletException;
+import jakarta.servlet.ServletRequest;
+import jakarta.servlet.ServletResponse;
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletResponse;
+import lombok.RequiredArgsConstructor;
+import org.springframework.core.annotation.Order;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.MediaType;
+import org.springframework.stereotype.Component;
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.util.Optional;
+import java.util.Set;
+
+@Component
+@Order(1)
+@RequiredArgsConstructor
+public class AuthenticationFilter implements Filter {
+
+    private static final String LOGIN_ID_HEADER = "X-Loopers-LoginId";
+    private static final String LOGIN_PW_HEADER = "X-Loopers-LoginPw";
+
+    private static final Set<String> PUBLIC_PATHS = Set.of(
+            "/api/v1/members/signup",
+            "/api/v1/examples"
+    );
+
+    private final MemberRepository memberRepository;
+    private final PasswordEncoder passwordEncoder;
+    private final ObjectMapper objectMapper;
+
+    @Override
+    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
+            throws IOException, ServletException {
+
+        HttpServletRequest httpRequest = (HttpServletRequest) request;
+        HttpServletResponse httpResponse = (HttpServletResponse) response;
+
+        String path = httpRequest.getRequestURI();
+
+        if (isPublicPath(path)) {
+            chain.doFilter(request, response);
+            return;
+        }
+
+        if (!path.startsWith("/api/")) {
+            chain.doFilter(request, response);
+            return;
+        }
+
+        String loginId = httpRequest.getHeader(LOGIN_ID_HEADER);
+        String loginPw = httpRequest.getHeader(LOGIN_PW_HEADER);
+
+        if (loginId == null || loginPw == null) {
+            sendUnauthorizedResponse(httpResponse, "인증 정보가 필요합니다.");
+            return;
+        }
+
+        Optional<Member> memberOpt = memberRepository.findByMemberIdValue(loginId);
+        if (memberOpt.isEmpty()) {
+            sendUnauthorizedResponse(httpResponse, "인증에 실패했습니다.");
+            return;
+        }
+
+        Member member = memberOpt.get();
+        if (!member.getPassword().matches(loginPw, passwordEncoder)) {
+            sendUnauthorizedResponse(httpResponse, "인증에 실패했습니다.");
+            return;
+        }
+
+        httpRequest.setAttribute("authenticatedMember", member);
+        chain.doFilter(request, response);
+    }
+
+    private boolean isPublicPath(String path) {
+        return PUBLIC_PATHS.stream().anyMatch(publicPath -> isPathMatch(path, publicPath));
+    }
+
+    private boolean isPathMatch(String requestPath, String publicPath) {
+        if (requestPath.equals(publicPath)) {
+            return true;
+        }
+        return requestPath.startsWith(publicPath + "/");
+    }
+
+    private void sendUnauthorizedResponse(HttpServletResponse response, String message) throws IOException {
+        response.setStatus(HttpStatus.UNAUTHORIZED.value());
+        response.setContentType(MediaType.APPLICATION_JSON_VALUE);
+        response.setCharacterEncoding(StandardCharsets.UTF_8.name());
+
+        ApiResponse<Object> apiResponse = ApiResponse.fail(HttpStatus.UNAUTHORIZED.getReasonPhrase(), message);
+        response.getWriter().write(objectMapper.writeValueAsString(apiResponse));
+    }
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/interfaces/resolver/LoginUser.java b/apps/commerce-api/src/main/java/com/loopers/interfaces/resolver/LoginUser.java
new file mode 100644
index 00000000..12302400
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/interfaces/resolver/LoginUser.java
@@ -0,0 +1,11 @@
+package com.loopers.interfaces.resolver;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target(ElementType.PARAMETER)
+@Retention(RetentionPolicy.RUNTIME)
+public @interface LoginUser {
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/interfaces/resolver/LoginUserArgumentResolver.java b/apps/commerce-api/src/main/java/com/loopers/interfaces/resolver/LoginUserArgumentResolver.java
new file mode 100644
index 00000000..34e4c182
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/interfaces/resolver/LoginUserArgumentResolver.java
@@ -0,0 +1,36 @@
+package com.loopers.interfaces.resolver;
+
+import com.loopers.domain.member.Member;
+import com.loopers.support.error.CoreException;
+import com.loopers.support.error.ErrorType;
+import jakarta.servlet.http.HttpServletRequest;
+import org.jspecify.annotations.NonNull;
+import org.springframework.core.MethodParameter;
+import org.springframework.stereotype.Component;
+import org.springframework.web.bind.support.WebDataBinderFactory;
+import org.springframework.web.context.request.NativeWebRequest;
+import org.springframework.web.method.support.HandlerMethodArgumentResolver;
+import org.springframework.web.method.support.ModelAndViewContainer;
+
+@Component
+public class LoginUserArgumentResolver implements HandlerMethodArgumentResolver {
+
+    @Override
+    public boolean supportsParameter(MethodParameter parameter) {
+        return parameter.hasParameterAnnotation(LoginUser.class)
+                && Member.class.isAssignableFrom(parameter.getParameterType());
+    }
+
+    @Override
+    public Object resolveArgument(@NonNull MethodParameter parameter, ModelAndViewContainer mavContainer,
+                                  NativeWebRequest webRequest, WebDataBinderFactory binderFactory) {
+        HttpServletRequest request = (HttpServletRequest) webRequest.getNativeRequest();
+        Object attribute = request.getAttribute("authenticatedMember");
+
+        if (!(attribute instanceof Member)) {
+            throw new CoreException(ErrorType.UNAUTHORIZED, "인증 정보가 유효하지 않습니다.");
+        }
+
+        return attribute;
+    }
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/support/error/CoreException.java b/apps/commerce-api/src/main/java/com/loopers/support/error/CoreException.java
index 0cc190b6..cb7d6aaf 100644
--- a/apps/commerce-api/src/main/java/com/loopers/support/error/CoreException.java
+++ b/apps/commerce-api/src/main/java/com/loopers/support/error/CoreException.java
@@ -8,11 +8,15 @@ public class CoreException extends RuntimeException {
     private final String customMessage;
 
     public CoreException(ErrorType errorType) {
-        this(errorType, null);
+        this(errorType, null, null);
     }
 
     public CoreException(ErrorType errorType, String customMessage) {
-        super(customMessage != null ? customMessage : errorType.getMessage());
+        this(errorType, customMessage, null);
+    }
+
+    public CoreException(ErrorType errorType, String customMessage, Throwable cause) {
+        super(customMessage != null ? customMessage : errorType.getMessage(), cause);
         this.errorType = errorType;
         this.customMessage = customMessage;
     }
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..bc9fb4c7 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/member/MemberServiceTest.java b/apps/commerce-api/src/test/java/com/loopers/domain/member/MemberServiceTest.java
new file mode 100644
index 00000000..c91830d9
--- /dev/null
+++ b/apps/commerce-api/src/test/java/com/loopers/domain/member/MemberServiceTest.java
@@ -0,0 +1,103 @@
+package com.loopers.domain.member;
+
+import com.loopers.support.error.CoreException;
+import com.loopers.support.error.ErrorType;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import java.util.Optional;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.BDDMockito.given;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+
+class MemberServiceTest {
+
+    private MemberService memberService;
+    private MemberRepository memberRepository;
+    private PasswordEncoder passwordEncoder;
+
+    @BeforeEach
+    void setUp() {
+        memberRepository = mock(MemberRepository.class);
+        passwordEncoder = mock(PasswordEncoder.class);
+        memberService = new MemberService(memberRepository, passwordEncoder);
+    }
+
+    @DisplayName("회원가입에 성공하면 저장된 회원을 반환한다.")
+    @Test
+    void signup_success() {
+        // given
+        MemberService.SignupCommand command = new MemberService.SignupCommand(
+                "user1",
+                "Password1!",
+                "홍길동",
+                "test@test.com",
+                "1997-01-01"
+        );
+
+        given(memberRepository.existsByMemberIdValue(anyString())).willReturn(false);
+        given(passwordEncoder.encode(anyString())).willReturn("encodedPassword");
+        given(memberRepository.save(any(Member.class))).willAnswer(invocation -> invocation.getArgument(0));
+
+        // when
+        Member member = memberService.signup(command);
+
+        // then
+        assertThat(member).isNotNull();
+        assertThat(member.getMemberId().getValue()).isEqualTo("user1");
+        verify(memberRepository).save(any(Member.class));
+    }
+
+    @DisplayName("이미 존재하는 ID로 회원가입하면 예외가 발생한다.")
+    @Test
+    void signup_fail_duplicate_id() {
+        // given
+        MemberService.SignupCommand command = new MemberService.SignupCommand(
+                "existing1",
+                "Password1!",
+                "홍길동",
+                "test@test.com",
+                "1997-01-01"
+        );
+
+        given(memberRepository.existsByMemberIdValue(anyString())).willReturn(true);
+
+        // when & then
+        assertThatThrownBy(() -> memberService.signup(command))
+                .isInstanceOf(CoreException.class)
+                .extracting("errorType").isEqualTo(ErrorType.CONFLICT);
+    }
+
+    @DisplayName("회원가입 시 비밀번호는 암호화되어 저장된다.")
+    @Test
+    void signup_password_encoded() {
+        // given
+        String rawPassword = "Password1!";
+        String encodedPassword = "$2a$10$encodedPasswordValue";
+
+        MemberService.SignupCommand command = new MemberService.SignupCommand(
+                "user1",
+                rawPassword,
+                "홍길동",
+                "test@test.com",
+                "1997-01-01"
+        );
+
+        given(memberRepository.existsByMemberIdValue(anyString())).willReturn(false);
+        given(passwordEncoder.encode(rawPassword)).willReturn(encodedPassword);
+        given(memberRepository.save(any(Member.class))).willAnswer(invocation -> invocation.getArgument(0));
+
+        // when
+        Member member = memberService.signup(command);
+
+        // then
+        assertThat(member.getPassword().getValue()).isEqualTo(encodedPassword);
+        verify(passwordEncoder).encode(rawPassword);
+    }
+}
diff --git a/apps/commerce-api/src/test/java/com/loopers/domain/member/MemberTest.java b/apps/commerce-api/src/test/java/com/loopers/domain/member/MemberTest.java
new file mode 100644
index 00000000..63de977c
--- /dev/null
+++ b/apps/commerce-api/src/test/java/com/loopers/domain/member/MemberTest.java
@@ -0,0 +1,135 @@
+package com.loopers.domain.member;
+
+import com.loopers.domain.member.vo.BirthDate;
+import com.loopers.domain.member.vo.Email;
+import com.loopers.domain.member.vo.MemberId;
+import com.loopers.domain.member.vo.Name;
+import com.loopers.domain.member.vo.Password;
+import com.loopers.support.error.CoreException;
+import com.loopers.support.error.ErrorType;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+class MemberTest {
+
+    private final PasswordEncoder fakeEncoder = new PasswordEncoder() {
+        @Override
+        public String encode(String rawPassword) {
+            return "encoded:" + rawPassword;
+        }
+
+        @Override
+        public boolean matches(String rawPassword, String encodedPassword) {
+            return encodedPassword.equals("encoded:" + rawPassword);
+        }
+    };
+
+    @DisplayName("회원 생성 시 각 필드의 검증 로직은 VO에게 위임한다.")
+    @Test
+    void create_member_success() {
+        // given
+        MemberId memberId = new MemberId("user1");
+        BirthDate birthDate = new BirthDate("1997-01-01");
+        Password.validate("Valid123!", birthDate);
+        Password password = Password.ofEncoded(fakeEncoder.encode("Valid123!"));
+        Name name = new Name("앤드류");
+        Email email = new Email("test@test.com");
+
+        // when
+        Member member = new Member(memberId, password, name, email, birthDate);
+
+        // then
+        assertThat(member).isNotNull();
+    }
+
+    @DisplayName("비밀번호 변경")
+    @Nested
+    class UpdatePassword {
+
+        @DisplayName("현재 비밀번호가 일치하면 새 비밀번호로 변경된다.")
+        @Test
+        void updatePassword_success() {
+            // given
+            String currentRaw = "OldPass123!";
+            String newRaw = "NewPass456!";
+            BirthDate birthDate = new BirthDate("1997-01-01");
+            Member member = new Member(
+                    new MemberId("user1"),
+                    Password.ofEncoded(fakeEncoder.encode(currentRaw)),
+                    new Name("앤드류"),
+                    new Email("test@test.com"),
+                    birthDate
+            );
+
+            // when
+            member.updatePassword(currentRaw, newRaw, fakeEncoder);
+
+            // then
+            assertThat(member.getPassword().matches(newRaw, fakeEncoder)).isTrue();
+        }
+
+        @DisplayName("현재 비밀번호가 일치하지 않으면 예외가 발생한다.")
+        @Test
+        void updatePassword_fail_wrongCurrentPassword() {
+            // given
+            String currentRaw = "OldPass123!";
+            BirthDate birthDate = new BirthDate("1997-01-01");
+            Member member = new Member(
+                    new MemberId("user1"),
+                    Password.ofEncoded(fakeEncoder.encode(currentRaw)),
+                    new Name("앤드류"),
+                    new Email("test@test.com"),
+                    birthDate
+            );
+
+            // when & then
+            assertThatThrownBy(() -> member.updatePassword("WrongPass1!", "NewPass456!", fakeEncoder))
+                    .isInstanceOf(CoreException.class)
+                    .satisfies(e -> assertThat(((CoreException) e).getErrorType()).isEqualTo(ErrorType.BAD_REQUEST));
+        }
+
+        @DisplayName("새 비밀번호가 정책을 위반하면 예외가 발생한다.")
+        @Test
+        void updatePassword_fail_invalidNewPassword() {
+            // given
+            String currentRaw = "OldPass123!";
+            BirthDate birthDate = new BirthDate("1997-01-01");
+            Member member = new Member(
+                    new MemberId("user1"),
+                    Password.ofEncoded(fakeEncoder.encode(currentRaw)),
+                    new Name("앤드류"),
+                    new Email("test@test.com"),
+                    birthDate
+            );
+
+            // when & then - 특수문자 없는 비밀번호
+            assertThatThrownBy(() -> member.updatePassword(currentRaw, "NewPass456", fakeEncoder))
+                    .isInstanceOf(CoreException.class)
+                    .satisfies(e -> assertThat(((CoreException) e).getErrorType()).isEqualTo(ErrorType.BAD_REQUEST));
+        }
+
+        @DisplayName("새 비밀번호가 기존과 동일하면 예외가 발생한다.")
+        @Test
+        void updatePassword_fail_samePassword() {
+            // given
+            String currentRaw = "OldPass123!";
+            BirthDate birthDate = new BirthDate("1997-01-01");
+            Member member = new Member(
+                    new MemberId("user1"),
+                    Password.ofEncoded(fakeEncoder.encode(currentRaw)),
+                    new Name("앤드류"),
+                    new Email("test@test.com"),
+                    birthDate
+            );
+
+            // when & then
+            assertThatThrownBy(() -> member.updatePassword(currentRaw, currentRaw, fakeEncoder))
+                    .isInstanceOf(CoreException.class)
+                    .satisfies(e -> assertThat(((CoreException) e).getErrorType()).isEqualTo(ErrorType.BAD_REQUEST));
+        }
+    }
+}
diff --git a/apps/commerce-api/src/test/java/com/loopers/domain/member/vo/BirthDateTest.java b/apps/commerce-api/src/test/java/com/loopers/domain/member/vo/BirthDateTest.java
new file mode 100644
index 00000000..82ecb0b3
--- /dev/null
+++ b/apps/commerce-api/src/test/java/com/loopers/domain/member/vo/BirthDateTest.java
@@ -0,0 +1,101 @@
+package com.loopers.domain.member.vo;
+
+import com.loopers.support.error.CoreException;
+import com.loopers.support.error.ErrorType;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
+import java.time.LocalDate;
+import java.time.format.DateTimeFormatter;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+class BirthDateTest {
+
+    @DisplayName("yyyy-MM-dd 형식의 생년월일은 생성에 성공한다.")
+    @Test
+    void create_success() {
+        // given
+        String birth = "1997-01-15";
+
+        // when
+        BirthDate birthDate = new BirthDate(birth);
+
+        // then
+        assertThat(birthDate.getFormattedValue()).isEqualTo(birth);
+    }
+
+    @DisplayName("잘못된 형식의 생년월일은 예외가 발생한다.")
+    @ParameterizedTest
+    @ValueSource(strings = {"19970115", "1997/01/15", "01-15-1997", "1997-1-15", "1997-01-1"})
+    void create_fail_invalid_format(String invalidBirth) {
+        assertThatThrownBy(() -> new BirthDate(invalidBirth))
+                .isInstanceOf(CoreException.class)
+                .extracting("errorType").isEqualTo(ErrorType.BAD_REQUEST);
+    }
+
+    @DisplayName("null 또는 빈 문자열은 예외가 발생한다.")
+    @ParameterizedTest
+    @ValueSource(strings = {"", " "})
+    void create_fail_empty(String emptyBirth) {
+        assertThatThrownBy(() -> new BirthDate(emptyBirth))
+                .isInstanceOf(CoreException.class)
+                .extracting("errorType").isEqualTo(ErrorType.BAD_REQUEST);
+    }
+
+    @DisplayName("null은 예외가 발생한다.")
+    @Test
+    void create_fail_null() {
+        assertThatThrownBy(() -> new BirthDate(null))
+                .isInstanceOf(CoreException.class)
+                .extracting("errorType").isEqualTo(ErrorType.BAD_REQUEST);
+    }
+
+    @DisplayName("유효하지 않은 날짜는 예외가 발생한다.")
+    @ParameterizedTest
+    @ValueSource(strings = {"1997-13-01", "1997-02-30", "1997-00-15"})
+    void create_fail_invalid_date(String invalidDate) {
+        assertThatThrownBy(() -> new BirthDate(invalidDate))
+                .isInstanceOf(CoreException.class)
+                .extracting("errorType").isEqualTo(ErrorType.BAD_REQUEST);
+    }
+
+    @DisplayName("숫자만 포함된 문자열(yyyyMMdd)을 반환한다.")
+    @Test
+    void toPlainString() {
+        // given
+        BirthDate birthDate = new BirthDate("1997-01-15");
+
+        // when
+        String plain = birthDate.toPlainString();
+
+        // then
+        assertThat(plain).isEqualTo("19970115");
+    }
+
+    @DisplayName("미래 날짜는 예외가 발생한다.")
+    @Test
+    void create_fail_future_date() {
+        // given
+        String futureDate = LocalDate.now().plusDays(1).format(DateTimeFormatter.ofPattern("yyyy-MM-dd"));
+
+        // when & then
+        assertThatThrownBy(() -> new BirthDate(futureDate))
+                .isInstanceOf(CoreException.class)
+                .extracting("errorType").isEqualTo(ErrorType.BAD_REQUEST);
+    }
+
+    @DisplayName("오늘 날짜는 생성에 성공한다.")
+    @Test
+    void create_success_today() {
+        // given
+        String today = LocalDate.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd"));
+
+        // when
+        BirthDate birthDate = new BirthDate(today);
+
+        // then
+        assertThat(birthDate.getFormattedValue()).isEqualTo(today);
+    }
+}
diff --git a/apps/commerce-api/src/test/java/com/loopers/domain/member/vo/EmailTest.java b/apps/commerce-api/src/test/java/com/loopers/domain/member/vo/EmailTest.java
new file mode 100644
index 00000000..42750064
--- /dev/null
+++ b/apps/commerce-api/src/test/java/com/loopers/domain/member/vo/EmailTest.java
@@ -0,0 +1,51 @@
+package com.loopers.domain.member.vo;
+
+import com.loopers.support.error.CoreException;
+import com.loopers.support.error.ErrorType;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+class EmailTest {
+
+    @DisplayName("유효한 이메일 형식은 생성에 성공한다.")
+    @ParameterizedTest
+    @ValueSource(strings = {"test@test.com", "user.name@domain.co.kr", "user+tag@example.org"})
+    void create_success(String validEmail) {
+        // when
+        Email email = new Email(validEmail);
+
+        // then
+        assertThat(email.getValue()).isEqualTo(validEmail);
+    }
+
+    @DisplayName("잘못된 이메일 형식은 예외가 발생한다.")
+    @ParameterizedTest
+    @ValueSource(strings = {"invalid", "invalid@", "@domain.com", "invalid@domain", "invalid @domain.com"})
+    void create_fail_invalid_format(String invalidEmail) {
+        assertThatThrownBy(() -> new Email(invalidEmail))
+                .isInstanceOf(CoreException.class)
+                .extracting("errorType").isEqualTo(ErrorType.BAD_REQUEST);
+    }
+
+    @DisplayName("null 또는 빈 문자열은 예외가 발생한다.")
+    @ParameterizedTest
+    @ValueSource(strings = {"", " "})
+    void create_fail_empty(String emptyEmail) {
+        assertThatThrownBy(() -> new Email(emptyEmail))
+                .isInstanceOf(CoreException.class)
+                .extracting("errorType").isEqualTo(ErrorType.BAD_REQUEST);
+    }
+
+    @DisplayName("null은 예외가 발생한다.")
+    @Test
+    void create_fail_null() {
+        assertThatThrownBy(() -> new Email(null))
+                .isInstanceOf(CoreException.class)
+                .extracting("errorType").isEqualTo(ErrorType.BAD_REQUEST);
+    }
+}
diff --git a/apps/commerce-api/src/test/java/com/loopers/domain/member/vo/MemberIdTest.java b/apps/commerce-api/src/test/java/com/loopers/domain/member/vo/MemberIdTest.java
new file mode 100644
index 00000000..d506a119
--- /dev/null
+++ b/apps/commerce-api/src/test/java/com/loopers/domain/member/vo/MemberIdTest.java
@@ -0,0 +1,63 @@
+package com.loopers.domain.member.vo;
+
+import com.loopers.support.error.CoreException;
+import com.loopers.support.error.ErrorType;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+class MemberIdTest {
+
+    @DisplayName("영문/숫자 조합 10자 이내의 ID는 생성에 성공한다.")
+    @ParameterizedTest
+    @ValueSource(strings = {"user1", "User123", "abcd1234", "ABCD123456"})
+    void create_success(String validId) {
+        // when
+        MemberId memberId = new MemberId(validId);
+
+        // then
+        assertThat(memberId.getValue()).isEqualTo(validId);
+    }
+
+    @DisplayName("10자를 초과하는 ID는 예외가 발생한다.")
+    @Test
+    void create_fail_too_long() {
+        // given
+        String tooLongId = "abcdefghijk";
+
+        // when & then
+        assertThatThrownBy(() -> new MemberId(tooLongId))
+                .isInstanceOf(CoreException.class)
+                .extracting("errorType").isEqualTo(ErrorType.BAD_REQUEST);
+    }
+
+    @DisplayName("영문/숫자 외의 문자가 포함되면 예외가 발생한다.")
+    @ParameterizedTest
+    @ValueSource(strings = {"user@1", "user-1", "user_1", "user 1", "유저1"})
+    void create_fail_invalid_chars(String invalidId) {
+        assertThatThrownBy(() -> new MemberId(invalidId))
+                .isInstanceOf(CoreException.class)
+                .extracting("errorType").isEqualTo(ErrorType.BAD_REQUEST);
+    }
+
+    @DisplayName("null 또는 빈 문자열은 예외가 발생한다.")
+    @ParameterizedTest
+    @ValueSource(strings = {"", " "})
+    void create_fail_empty(String emptyId) {
+        assertThatThrownBy(() -> new MemberId(emptyId))
+                .isInstanceOf(CoreException.class)
+                .extracting("errorType").isEqualTo(ErrorType.BAD_REQUEST);
+    }
+
+    @DisplayName("null은 예외가 발생한다.")
+    @Test
+    void create_fail_null() {
+        assertThatThrownBy(() -> new MemberId(null))
+                .isInstanceOf(CoreException.class)
+                .extracting("errorType").isEqualTo(ErrorType.BAD_REQUEST);
+    }
+}
diff --git a/apps/commerce-api/src/test/java/com/loopers/domain/member/vo/NameTest.java b/apps/commerce-api/src/test/java/com/loopers/domain/member/vo/NameTest.java
new file mode 100644
index 00000000..4f0ab3d7
--- /dev/null
+++ b/apps/commerce-api/src/test/java/com/loopers/domain/member/vo/NameTest.java
@@ -0,0 +1,62 @@
+package com.loopers.domain.member.vo;
+
+import com.loopers.support.error.CoreException;
+import com.loopers.support.error.ErrorType;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.CsvSource;
+import org.junit.jupiter.params.provider.ValueSource;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+class NameTest {
+
+    @DisplayName("유효한 이름은 생성에 성공한다.")
+    @ParameterizedTest
+    @ValueSource(strings = {"홍길동", "김", "Andrew", "김앤드류"})
+    void create_success(String validName) {
+        // when
+        Name name = new Name(validName);
+
+        // then
+        assertThat(name.getValue()).isEqualTo(validName);
+    }
+
+    @DisplayName("null 또는 빈 문자열은 예외가 발생한다.")
+    @ParameterizedTest
+    @ValueSource(strings = {"", " "})
+    void create_fail_empty(String emptyName) {
+        assertThatThrownBy(() -> new Name(emptyName))
+                .isInstanceOf(CoreException.class)
+                .extracting("errorType").isEqualTo(ErrorType.BAD_REQUEST);
+    }
+
+    @DisplayName("null은 예외가 발생한다.")
+    @Test
+    void create_fail_null() {
+        assertThatThrownBy(() -> new Name(null))
+                .isInstanceOf(CoreException.class)
+                .extracting("errorType").isEqualTo(ErrorType.BAD_REQUEST);
+    }
+
+    @DisplayName("이름의 마지막 글자를 마스킹하여 반환한다.")
+    @ParameterizedTest
+    @CsvSource({
+            "홍길동, 홍길*",
+            "김, *",
+            "Andrew, Andre*",
+            "AB, A*"
+    })
+    void masked(String original, String expected) {
+        // given
+        Name name = new Name(original);
+
+        // when
+        String masked = name.masked();
+
+        // then
+        assertThat(masked).isEqualTo(expected);
+    }
+}
diff --git a/apps/commerce-api/src/test/java/com/loopers/domain/member/vo/PasswordTest.java b/apps/commerce-api/src/test/java/com/loopers/domain/member/vo/PasswordTest.java
new file mode 100644
index 00000000..1fb3b463
--- /dev/null
+++ b/apps/commerce-api/src/test/java/com/loopers/domain/member/vo/PasswordTest.java
@@ -0,0 +1,164 @@
+package com.loopers.domain.member.vo;
+
+import com.loopers.domain.member.PasswordEncoder;
+import com.loopers.support.error.CoreException;
+import com.loopers.support.error.ErrorType;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.CsvSource;
+import org.junit.jupiter.params.provider.ValueSource;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+class PasswordTest {
+
+    @DisplayName("비밀번호 정책(8~16자, 영문/숫자/특수문자 포함)을 준수하면 검증에 성공한다.")
+    @Test
+    void validate_success() {
+        // given
+        String pw = "PassWord123!";
+        BirthDate birthDate = new BirthDate("1997-01-01");
+
+        // when & then - 예외가 발생하지 않으면 성공
+        Password.validate(pw, birthDate);
+    }
+
+    @DisplayName("비밀번호 길이가 8자 미만이거나, 16자 초과면 예외가 발생한다.")
+    @ParameterizedTest
+    @ValueSource(strings = {"Short1!", "TooooooooooooLongPassword123!"})
+    void create_fail_length(String invalidPw) {
+        // given
+        BirthDate birthDate = new BirthDate("1997-01-01");
+
+        // when & then
+        assertThatThrownBy(() -> Password.validate(invalidPw, birthDate))
+                .isInstanceOf(CoreException.class)
+                .extracting("errorType").isEqualTo(ErrorType.BAD_REQUEST);
+    }
+
+    @DisplayName("비밀번호에 영문, 숫자, 특수문자가 모두 포함되지 않으면 예외가 발생한다.")
+    @ParameterizedTest
+    @ValueSource(strings = {"Password123", "Password!@#", "12345678!@#"})
+    void create_fail_complexity(String invalidPw) {
+        // given
+        BirthDate birthDate = new BirthDate("1997-01-01");
+
+        // when & then
+        assertThatThrownBy(() -> Password.validate(invalidPw, birthDate))
+                .isInstanceOf(CoreException.class)
+                .hasMessageContaining("영문, 숫자, 특수문자");
+    }
+
+    @DisplayName("비밀번호에 생년월일 패턴(YYYY, YY, MMDD)이 포함되면 예외가 발생한다.")
+    @ParameterizedTest
+    @CsvSource({
+            "1997-12-31, Pass1997!@#",
+            "1997-12-31, Pass97!@#abc",
+            "1997-12-31, Pass1231!@#",
+            "1997-12-31, Pass971231!@#"
+    })
+    void create_fail_contains_birth_pattern(String birth, String invalidPw) {
+        // given
+        BirthDate birthDate = new BirthDate(birth);
+
+        // when & then
+        assertThatThrownBy(() -> Password.validate(invalidPw, birthDate))
+                .isInstanceOf(CoreException.class)
+                .hasMessageContaining("생년월일");
+    }
+
+    @DisplayName("이미 암호화된 비밀번호로 Password 객체를 생성할 수 있다.")
+    @Test
+    void create_with_encoded_value() {
+        // given
+        String encodedValue = "$2a$10$someEncodedPasswordValue";
+
+        // when
+        Password password = Password.ofEncoded(encodedValue);
+
+        // then
+        assertThat(password.getValue()).isEqualTo(encodedValue);
+    }
+
+    @DisplayName("비밀번호 변경 테스트")
+    @Nested
+    class ChangePasswordTest {
+
+        private final PasswordEncoder fakeEncoder = new PasswordEncoder() {
+            @Override
+            public String encode(String rawPassword) {
+                return "encoded:" + rawPassword;
+            }
+
+            @Override
+            public boolean matches(String rawPassword, String encodedPassword) {
+                return encodedPassword.equals("encoded:" + rawPassword);
+            }
+        };
+
+        @DisplayName("현재 비밀번호가 일치하고 새 비밀번호가 유효하면 변경에 성공한다.")
+        @Test
+        void change_success() {
+            // given
+            String currentRaw = "OldPass123!";
+            String newRaw = "NewPass456!";
+            BirthDate birthDate = new BirthDate("1997-01-01");
+            Password password = Password.ofEncoded(fakeEncoder.encode(currentRaw));
+
+            // when
+            Password changed = password.change(currentRaw, newRaw, birthDate, fakeEncoder);
+
+            // then
+            assertThat(changed.matches(newRaw, fakeEncoder)).isTrue();
+        }
+
+        @DisplayName("현재 비밀번호가 일치하지 않으면 예외가 발생한다.")
+        @Test
+        void change_fail_wrong_current_password() {
+            // given
+            String currentRaw = "OldPass123!";
+            String wrongCurrent = "WrongPass1!";
+            String newRaw = "NewPass456!";
+            BirthDate birthDate = new BirthDate("1997-01-01");
+            Password password = Password.ofEncoded(fakeEncoder.encode(currentRaw));
+
+            // when & then
+            assertThatThrownBy(() -> password.change(wrongCurrent, newRaw, birthDate, fakeEncoder))
+                    .isInstanceOf(CoreException.class)
+                    .hasMessageContaining("현재 비밀번호가 일치하지 않습니다");
+        }
+
+        @DisplayName("새 비밀번호가 기존 비밀번호와 동일하면 예외가 발생한다.")
+        @Test
+        void change_fail_same_password() {
+            // given
+            String currentRaw = "OldPass123!";
+            String newRaw = "OldPass123!";
+            BirthDate birthDate = new BirthDate("1997-01-01");
+            Password password = Password.ofEncoded(fakeEncoder.encode(currentRaw));
+
+            // when & then
+            assertThatThrownBy(() -> password.change(currentRaw, newRaw, birthDate, fakeEncoder))
+                    .isInstanceOf(CoreException.class)
+                    .hasMessageContaining("기존 비밀번호와 동일한 비밀번호는 사용할 수 없습니다");
+        }
+
+        @DisplayName("새 비밀번호가 정책을 위반하면 예외가 발생한다.")
+        @Test
+        void change_fail_invalid_new_password() {
+            // given
+            String currentRaw = "OldPass123!";
+            String newRaw = "short1!";
+            BirthDate birthDate = new BirthDate("1997-01-01");
+            Password password = Password.ofEncoded(fakeEncoder.encode(currentRaw));
+
+            // when & then
+            assertThatThrownBy(() -> password.change(currentRaw, newRaw, birthDate, fakeEncoder))
+                    .isInstanceOf(CoreException.class)
+                    .hasMessageContaining("8~16자");
+        }
+    }
+}
diff --git a/apps/commerce-api/src/test/java/com/loopers/interfaces/api/MemberV1ApiE2ETest.java b/apps/commerce-api/src/test/java/com/loopers/interfaces/api/MemberV1ApiE2ETest.java
new file mode 100644
index 00000000..10746c57
--- /dev/null
+++ b/apps/commerce-api/src/test/java/com/loopers/interfaces/api/MemberV1ApiE2ETest.java
@@ -0,0 +1,395 @@
+package com.loopers.interfaces.api;
+
+import com.loopers.domain.member.Member;
+import com.loopers.domain.member.MemberRepository;
+import com.loopers.domain.member.PasswordEncoder;
+import com.loopers.domain.member.vo.BirthDate;
+import com.loopers.domain.member.vo.Email;
+import com.loopers.domain.member.vo.MemberId;
+import com.loopers.domain.member.vo.Name;
+import com.loopers.domain.member.vo.Password;
+import com.loopers.interfaces.api.member.MemberV1Dto;
+import com.loopers.utils.DatabaseCleanUp;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.boot.test.web.client.TestRestTemplate;
+import org.springframework.core.ParameterizedTypeReference;
+import org.springframework.http.HttpEntity;
+import org.springframework.http.HttpHeaders;
+import org.springframework.http.HttpMethod;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.MediaType;
+import org.springframework.http.ResponseEntity;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertAll;
+
+@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
+class MemberV1ApiE2ETest {
+
+    private static final String SIGNUP_ENDPOINT = "/api/v1/members/signup";
+    private static final String ME_ENDPOINT = "/api/v1/members/me";
+    private static final String CHANGE_PASSWORD_ENDPOINT = "/api/v1/members/me/password";
+
+    private final TestRestTemplate testRestTemplate;
+    private final MemberRepository memberRepository;
+    private final PasswordEncoder passwordEncoder;
+    private final DatabaseCleanUp databaseCleanUp;
+
+    @Autowired
+    public MemberV1ApiE2ETest(
+            TestRestTemplate testRestTemplate,
+            MemberRepository memberRepository,
+            PasswordEncoder passwordEncoder,
+            DatabaseCleanUp databaseCleanUp
+    ) {
+        this.testRestTemplate = testRestTemplate;
+        this.memberRepository = memberRepository;
+        this.passwordEncoder = passwordEncoder;
+        this.databaseCleanUp = databaseCleanUp;
+    }
+
+    @AfterEach
+    void tearDown() {
+        databaseCleanUp.truncateAllTables();
+    }
+
+    @DisplayName("POST /api/v1/members/signup")
+    @Nested
+    class Signup {
+
+        @DisplayName("유효한 회원 정보로 회원가입하면 성공한다.")
+        @Test
+        void signup_success() {
+            // arrange
+            MemberV1Dto.SignupRequest request = new MemberV1Dto.SignupRequest(
+                    "user1",
+                    "Password1!",
+                    "홍길동",
+                    "test@test.com",
+                    "1997-01-01"
+            );
+
+            HttpHeaders headers = new HttpHeaders();
+            headers.setContentType(MediaType.APPLICATION_JSON);
+            HttpEntity<MemberV1Dto.SignupRequest> httpEntity = new HttpEntity<>(request, headers);
+
+            // act
+            ParameterizedTypeReference<ApiResponse<MemberV1Dto.SignupResponse>> responseType = new ParameterizedTypeReference<>() {};
+            ResponseEntity<ApiResponse<MemberV1Dto.SignupResponse>> response =
+                    testRestTemplate.exchange(SIGNUP_ENDPOINT, HttpMethod.POST, httpEntity, responseType);
+
+            // assert
+            assertAll(
+                    () -> assertThat(response.getStatusCode()).isEqualTo(HttpStatus.OK),
+                    () -> assertThat(response.getBody().meta().result()).isEqualTo(ApiResponse.Metadata.Result.SUCCESS),
+                    () -> assertThat(response.getBody().data().memberId()).isEqualTo("user1")
+            );
+        }
+
+        @DisplayName("중복된 ID로 회원가입하면 409 CONFLICT 응답을 받는다.")
+        @Test
+        void signup_fail_duplicate_id() {
+            // arrange - 먼저 회원가입
+            MemberV1Dto.SignupRequest firstRequest = new MemberV1Dto.SignupRequest(
+                    "user1",
+                    "Password1!",
+                    "홍길동",
+                    "test@test.com",
+                    "1997-01-01"
+            );
+
+            HttpHeaders headers = new HttpHeaders();
+            headers.setContentType(MediaType.APPLICATION_JSON);
+            HttpEntity<MemberV1Dto.SignupRequest> httpEntity = new HttpEntity<>(firstRequest, headers);
+
+            testRestTemplate.exchange(SIGNUP_ENDPOINT, HttpMethod.POST, httpEntity, new ParameterizedTypeReference<ApiResponse<MemberV1Dto.SignupResponse>>() {});
+
+            // 같은 ID로 다시 회원가입 시도
+            MemberV1Dto.SignupRequest duplicateRequest = new MemberV1Dto.SignupRequest(
+                    "user1",
+                    "Password2!",
+                    "김철수",
+                    "test2@test.com",
+                    "1998-02-02"
+            );
+
+            HttpEntity<MemberV1Dto.SignupRequest> duplicateHttpEntity = new HttpEntity<>(duplicateRequest, headers);
+
+            // act
+            ParameterizedTypeReference<ApiResponse<Object>> responseType = new ParameterizedTypeReference<>() {};
+            ResponseEntity<ApiResponse<Object>> response =
+                    testRestTemplate.exchange(SIGNUP_ENDPOINT, HttpMethod.POST, duplicateHttpEntity, responseType);
+
+            // assert
+            assertAll(
+                    () -> assertThat(response.getStatusCode()).isEqualTo(HttpStatus.CONFLICT),
+                    () -> assertThat(response.getBody().meta().result()).isEqualTo(ApiResponse.Metadata.Result.FAIL)
+            );
+        }
+
+        @DisplayName("잘못된 이메일 형식으로 회원가입하면 400 BAD_REQUEST 응답을 받는다.")
+        @Test
+        void signup_fail_invalid_email() {
+            // arrange
+            MemberV1Dto.SignupRequest request = new MemberV1Dto.SignupRequest(
+                    "user1",
+                    "Password1!",
+                    "홍길동",
+                    "invalid-email",
+                    "1997-01-01"
+            );
+
+            HttpHeaders headers = new HttpHeaders();
+            headers.setContentType(MediaType.APPLICATION_JSON);
+            HttpEntity<MemberV1Dto.SignupRequest> httpEntity = new HttpEntity<>(request, headers);
+
+            // act
+            ParameterizedTypeReference<ApiResponse<Object>> responseType = new ParameterizedTypeReference<>() {};
+            ResponseEntity<ApiResponse<Object>> response =
+                    testRestTemplate.exchange(SIGNUP_ENDPOINT, HttpMethod.POST, httpEntity, responseType);
+
+            // assert
+            assertAll(
+                    () -> assertThat(response.getStatusCode()).isEqualTo(HttpStatus.BAD_REQUEST),
+                    () -> assertThat(response.getBody().meta().result()).isEqualTo(ApiResponse.Metadata.Result.FAIL)
+            );
+        }
+
+        @DisplayName("비밀번호 정책을 위반하면 400 BAD_REQUEST 응답을 받는다.")
+        @Test
+        void signup_fail_invalid_password() {
+            // arrange - 특수문자 없는 비밀번호
+            MemberV1Dto.SignupRequest request = new MemberV1Dto.SignupRequest(
+                    "user1",
+                    "Password1",
+                    "홍길동",
+                    "test@test.com",
+                    "1997-01-01"
+            );
+
+            HttpHeaders headers = new HttpHeaders();
+            headers.setContentType(MediaType.APPLICATION_JSON);
+            HttpEntity<MemberV1Dto.SignupRequest> httpEntity = new HttpEntity<>(request, headers);
+
+            // act
+            ParameterizedTypeReference<ApiResponse<Object>> responseType = new ParameterizedTypeReference<>() {};
+            ResponseEntity<ApiResponse<Object>> response =
+                    testRestTemplate.exchange(SIGNUP_ENDPOINT, HttpMethod.POST, httpEntity, responseType);
+
+            // assert
+            assertAll(
+                    () -> assertThat(response.getStatusCode()).isEqualTo(HttpStatus.BAD_REQUEST),
+                    () -> assertThat(response.getBody().meta().result()).isEqualTo(ApiResponse.Metadata.Result.FAIL)
+            );
+        }
+    }
+
+    @DisplayName("GET /api/v1/members/me")
+    @Nested
+    class Me {
+
+        @DisplayName("인증된 사용자가 내 정보를 조회하면 마스킹된 이름으로 응답받는다.")
+        @Test
+        void me_success_with_masked_name() {
+            // arrange
+            String rawPassword = "Password1!";
+            String encodedPassword = passwordEncoder.encode(rawPassword);
+            Member member = new Member(
+                    new MemberId("testuser"),
+                    Password.ofEncoded(encodedPassword),
+                    new Name("홍길동"),
+                    new Email("test@test.com"),
+                    new BirthDate("1997-01-01")
+            );
+            memberRepository.save(member);
+
+            HttpHeaders headers = new HttpHeaders();
+            headers.set("X-Loopers-LoginId", "testuser");
+            headers.set("X-Loopers-LoginPw", rawPassword);
+            HttpEntity<Void> httpEntity = new HttpEntity<>(headers);
+
+            // act
+            ParameterizedTypeReference<ApiResponse<MemberV1Dto.MeResponse>> responseType = new ParameterizedTypeReference<>() {};
+            ResponseEntity<ApiResponse<MemberV1Dto.MeResponse>> response =
+                    testRestTemplate.exchange(ME_ENDPOINT, HttpMethod.GET, httpEntity, responseType);
+
+            // assert
+            assertAll(
+                    () -> assertThat(response.getStatusCode()).isEqualTo(HttpStatus.OK),
+                    () -> assertThat(response.getBody().meta().result()).isEqualTo(ApiResponse.Metadata.Result.SUCCESS),
+                    () -> assertThat(response.getBody().data().memberId()).isEqualTo("testuser"),
+                    () -> assertThat(response.getBody().data().name()).isEqualTo("홍길*"),
+                    () -> assertThat(response.getBody().data().email()).isEqualTo("test@test.com"),
+                    () -> assertThat(response.getBody().data().birthDate()).isEqualTo("1997-01-01")
+            );
+        }
+
+        @DisplayName("한 글자 이름인 경우 전체가 마스킹된다.")
+        @Test
+        void me_success_with_single_char_name() {
+            // arrange
+            String rawPassword = "Password1!";
+            String encodedPassword = passwordEncoder.encode(rawPassword);
+            Member member = new Member(
+                    new MemberId("testuser2"),
+                    Password.ofEncoded(encodedPassword),
+                    new Name("홍"),
+                    new Email("test2@test.com"),
+                    new BirthDate("1997-01-01")
+            );
+            memberRepository.save(member);
+
+            HttpHeaders headers = new HttpHeaders();
+            headers.set("X-Loopers-LoginId", "testuser2");
+            headers.set("X-Loopers-LoginPw", rawPassword);
+            HttpEntity<Void> httpEntity = new HttpEntity<>(headers);
+
+            // act
+            ParameterizedTypeReference<ApiResponse<MemberV1Dto.MeResponse>> responseType = new ParameterizedTypeReference<>() {};
+            ResponseEntity<ApiResponse<MemberV1Dto.MeResponse>> response =
+                    testRestTemplate.exchange(ME_ENDPOINT, HttpMethod.GET, httpEntity, responseType);
+
+            // assert
+            assertAll(
+                    () -> assertThat(response.getStatusCode()).isEqualTo(HttpStatus.OK),
+                    () -> assertThat(response.getBody().data().name()).isEqualTo("*")
+            );
+        }
+    }
+
+    @DisplayName("PUT /api/v1/members/me/password")
+    @Nested
+    class ChangePassword {
+
+        private Member createMember(String memberId, String rawPassword) {
+            String encodedPassword = passwordEncoder.encode(rawPassword);
+            Member member = new Member(
+                    new MemberId(memberId),
+                    Password.ofEncoded(encodedPassword),
+                    new Name("홍길동"),
+                    new Email(memberId + "@test.com"),
+                    new BirthDate("1997-01-01")
+            );
+            return memberRepository.save(member);
+        }
+
+        @DisplayName("현재 비밀번호가 일치하면 비밀번호 변경에 성공한다.")
+        @Test
+        void change_password_success() {
+            // arrange
+            String currentPassword = "Password1!";
+            String newPassword = "NewPass456!";
+            createMember("testuser", currentPassword);
+
+            HttpHeaders headers = new HttpHeaders();
+            headers.setContentType(MediaType.APPLICATION_JSON);
+            headers.set("X-Loopers-LoginId", "testuser");
+            headers.set("X-Loopers-LoginPw", currentPassword);
+
+            MemberV1Dto.ChangePasswordRequest request =
+                    new MemberV1Dto.ChangePasswordRequest(currentPassword, newPassword);
+            HttpEntity<MemberV1Dto.ChangePasswordRequest> httpEntity = new HttpEntity<>(request, headers);
+
+            // act
+            ResponseEntity<ApiResponse<Object>> response = testRestTemplate.exchange(
+                    CHANGE_PASSWORD_ENDPOINT, HttpMethod.PUT, httpEntity,
+                    new ParameterizedTypeReference<>() {}
+            );
+
+            // assert
+            assertThat(response.getStatusCode()).isEqualTo(HttpStatus.OK);
+
+            // 변경된 비밀번호로 /me API 호출하여 실제 로그인 검증
+            HttpHeaders newHeaders = new HttpHeaders();
+            newHeaders.set("X-Loopers-LoginId", "testuser");
+            newHeaders.set("X-Loopers-LoginPw", newPassword);
+            HttpEntity<Void> meEntity = new HttpEntity<>(newHeaders);
+
+            ResponseEntity<ApiResponse<MemberV1Dto.MeResponse>> meResponse = testRestTemplate.exchange(
+                    ME_ENDPOINT, HttpMethod.GET, meEntity,
+                    new ParameterizedTypeReference<>() {}
+            );
+
+            assertThat(meResponse.getStatusCode()).isEqualTo(HttpStatus.OK);
+            assertThat(meResponse.getBody().data().memberId()).isEqualTo("testuser");
+        }
+
+        @DisplayName("현재 비밀번호가 틀리면 400 BAD_REQUEST 응답을 받는다.")
+        @Test
+        void change_password_fail_wrong_current() {
+            // arrange
+            String currentPassword = "Password1!";
+            createMember("testuser", currentPassword);
+
+            HttpHeaders headers = new HttpHeaders();
+            headers.setContentType(MediaType.APPLICATION_JSON);
+            headers.set("X-Loopers-LoginId", "testuser");
+            headers.set("X-Loopers-LoginPw", currentPassword);
+
+            MemberV1Dto.ChangePasswordRequest request =
+                    new MemberV1Dto.ChangePasswordRequest("WrongPass1!", "NewPass456!");
+            HttpEntity<MemberV1Dto.ChangePasswordRequest> httpEntity = new HttpEntity<>(request, headers);
+
+            // act
+            ResponseEntity<ApiResponse<Object>> response = testRestTemplate.exchange(
+                    CHANGE_PASSWORD_ENDPOINT, HttpMethod.PUT, httpEntity,
+                    new ParameterizedTypeReference<>() {}
+            );
+
+            // assert
+            assertThat(response.getStatusCode()).isEqualTo(HttpStatus.BAD_REQUEST);
+        }
+
+        @DisplayName("새 비밀번호가 기존과 동일하면 400 BAD_REQUEST 응답을 받는다.")
+        @Test
+        void change_password_fail_same_password() {
+            // arrange
+            String currentPassword = "Password1!";
+            createMember("testuser", currentPassword);
+
+            HttpHeaders headers = new HttpHeaders();
+            headers.setContentType(MediaType.APPLICATION_JSON);
+            headers.set("X-Loopers-LoginId", "testuser");
+            headers.set("X-Loopers-LoginPw", currentPassword);
+
+            MemberV1Dto.ChangePasswordRequest request =
+                    new MemberV1Dto.ChangePasswordRequest(currentPassword, currentPassword);
+            HttpEntity<MemberV1Dto.ChangePasswordRequest> httpEntity = new HttpEntity<>(request, headers);
+
+            // act
+            ResponseEntity<ApiResponse<Object>> response = testRestTemplate.exchange(
+                    CHANGE_PASSWORD_ENDPOINT, HttpMethod.PUT, httpEntity,
+                    new ParameterizedTypeReference<>() {}
+            );
+
+            // assert
+            assertThat(response.getStatusCode()).isEqualTo(HttpStatus.BAD_REQUEST);
+        }
+
+        @DisplayName("인증 없이 비밀번호 변경을 시도하면 401 UNAUTHORIZED 응답을 받는다.")
+        @Test
+        void change_password_fail_unauthorized() {
+            // arrange
+            HttpHeaders headers = new HttpHeaders();
+            headers.setContentType(MediaType.APPLICATION_JSON);
+
+            MemberV1Dto.ChangePasswordRequest request =
+                    new MemberV1Dto.ChangePasswordRequest("Password1!", "NewPass456!");
+            HttpEntity<MemberV1Dto.ChangePasswordRequest> httpEntity = new HttpEntity<>(request, headers);
+
+            // act
+            ResponseEntity<ApiResponse<Object>> response = testRestTemplate.exchange(
+                    CHANGE_PASSWORD_ENDPOINT, HttpMethod.PUT, httpEntity,
+                    new ParameterizedTypeReference<>() {}
+            );
+
+            // assert
+            assertThat(response.getStatusCode()).isEqualTo(HttpStatus.UNAUTHORIZED);
+        }
+    }
+}
diff --git a/apps/commerce-api/src/test/java/com/loopers/interfaces/filter/AuthenticationFilterTest.java b/apps/commerce-api/src/test/java/com/loopers/interfaces/filter/AuthenticationFilterTest.java
new file mode 100644
index 00000000..26943188
--- /dev/null
+++ b/apps/commerce-api/src/test/java/com/loopers/interfaces/filter/AuthenticationFilterTest.java
@@ -0,0 +1,185 @@
+package com.loopers.interfaces.filter;
+
+import com.loopers.domain.member.Member;
+import com.loopers.domain.member.MemberRepository;
+import com.loopers.domain.member.PasswordEncoder;
+import com.loopers.domain.member.vo.BirthDate;
+import com.loopers.domain.member.vo.Email;
+import com.loopers.domain.member.vo.MemberId;
+import com.loopers.domain.member.vo.Name;
+import com.loopers.domain.member.vo.Password;
+import com.loopers.interfaces.api.ApiResponse;
+import com.loopers.utils.DatabaseCleanUp;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.boot.test.web.client.TestRestTemplate;
+import org.springframework.core.ParameterizedTypeReference;
+import org.springframework.http.HttpEntity;
+import org.springframework.http.HttpHeaders;
+import org.springframework.http.HttpMethod;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import java.util.Map;
+import static org.assertj.core.api.Assertions.assertThat;
+
+@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
+class AuthenticationFilterTest {
+
+    private static final String ME_ENDPOINT = "/api/v1/members/me";
+
+    @Autowired
+    private TestRestTemplate testRestTemplate;
+
+    @Autowired
+    private MemberRepository memberRepository;
+
+    @Autowired
+    private PasswordEncoder passwordEncoder;
+
+    @Autowired
+    private DatabaseCleanUp databaseCleanUp;
+
+    private Member testMember;
+
+    @BeforeEach
+    void setUp() {
+        String encodedPassword = passwordEncoder.encode("Password1!");
+        testMember = new Member(
+                new MemberId("testuser"),
+                Password.ofEncoded(encodedPassword),
+                new Name("홍길동"),
+                new Email("test@test.com"),
+                new BirthDate("1997-01-01")
+        );
+        memberRepository.save(testMember);
+    }
+
+    @AfterEach
+    void tearDown() {
+        databaseCleanUp.truncateAllTables();
+    }
+
+    @DisplayName("인증 필터 테스트")
+    @Nested
+    class AuthenticationTest {
+
+        @DisplayName("인증 헤더 없이 보호된 API에 접근하면 401 UNAUTHORIZED 응답을 받는다.")
+        @Test
+        void access_protected_api_without_auth_header_returns_unauthorized() {
+            // act
+            ResponseEntity<ApiResponse<Object>> response = testRestTemplate.exchange(
+                    ME_ENDPOINT,
+                    HttpMethod.GET,
+                    null,
+                    new ParameterizedTypeReference<>() {}
+            );
+
+            // assert
+            assertThat(response.getStatusCode()).isEqualTo(HttpStatus.UNAUTHORIZED);
+        }
+
+        @DisplayName("잘못된 비밀번호로 접근하면 401 UNAUTHORIZED 응답을 받는다.")
+        @Test
+        void access_protected_api_with_wrong_password_returns_unauthorized() {
+            // arrange
+            HttpHeaders headers = new HttpHeaders();
+            headers.set("X-Loopers-LoginId", "testuser");
+            headers.set("X-Loopers-LoginPw", "WrongPassword1!");
+            HttpEntity<Void> httpEntity = new HttpEntity<>(headers);
+
+            // act
+            ResponseEntity<ApiResponse<Object>> response = testRestTemplate.exchange(
+                    ME_ENDPOINT,
+                    HttpMethod.GET,
+                    httpEntity,
+                    new ParameterizedTypeReference<>() {}
+            );
+
+            // assert
+            assertThat(response.getStatusCode()).isEqualTo(HttpStatus.UNAUTHORIZED);
+        }
+
+        @DisplayName("존재하지 않는 사용자로 접근하면 401 UNAUTHORIZED 응답을 받는다.")
+        @Test
+        void access_protected_api_with_non_existent_user_returns_unauthorized() {
+            // arrange
+            HttpHeaders headers = new HttpHeaders();
+            headers.set("X-Loopers-LoginId", "nonexistent");
+            headers.set("X-Loopers-LoginPw", "Password1!");
+            HttpEntity<Void> httpEntity = new HttpEntity<>(headers);
+
+            // act
+            ResponseEntity<ApiResponse<Object>> response = testRestTemplate.exchange(
+                    ME_ENDPOINT,
+                    HttpMethod.GET,
+                    httpEntity,
+                    new ParameterizedTypeReference<>() {}
+            );
+
+            // assert
+            assertThat(response.getStatusCode()).isEqualTo(HttpStatus.UNAUTHORIZED);
+        }
+
+        @DisplayName("유효한 인증 정보로 보호된 API에 접근하면 성공한다.")
+        @Test
+        void access_protected_api_with_valid_auth_returns_success() {
+            // arrange
+            HttpHeaders headers = new HttpHeaders();
+            headers.set("X-Loopers-LoginId", "testuser");
+            headers.set("X-Loopers-LoginPw", "Password1!");
+            HttpEntity<Void> httpEntity = new HttpEntity<>(headers);
+
+            // act
+            ResponseEntity<ApiResponse<Map<String, Object>>> response = testRestTemplate.exchange(
+                    ME_ENDPOINT,
+                    HttpMethod.GET,
+                    httpEntity,
+                    new ParameterizedTypeReference<>() {}
+            );
+
+            // assert
+            assertThat(response.getStatusCode()).isEqualTo(HttpStatus.OK);
+        }
+
+        @DisplayName("public 경로와 접두사만 같은 경로는 인증이 필요하다. (예: /api/v1/members/signup-admin)")
+        @Test
+        void path_with_same_prefix_as_public_path_requires_auth() {
+            // arrange - /signup은 public이지만 /signup-admin은 public이 아님
+            String signupAdminPath = "/api/v1/members/signup-admin";
+
+            // act - 인증 없이 요청
+            ResponseEntity<ApiResponse<Object>> response = testRestTemplate.exchange(
+                    signupAdminPath,
+                    HttpMethod.GET,
+                    null,
+                    new ParameterizedTypeReference<>() {}
+            );
+
+            // assert - 인증이 필요하므로 401 반환 (404가 아닌 401이 먼저 반환됨)
+            assertThat(response.getStatusCode()).isEqualTo(HttpStatus.UNAUTHORIZED);
+        }
+
+        @DisplayName("public 경로의 하위 경로는 인증 없이 접근 가능하다. (예: /api/v1/members/signup/)")
+        @Test
+        void subpath_of_public_path_is_accessible_without_auth() {
+            // arrange - /signup의 하위 경로
+            String signupSubPath = "/api/v1/members/signup/something";
+
+            // act - 인증 없이 요청
+            ResponseEntity<ApiResponse<Object>> response = testRestTemplate.exchange(
+                    signupSubPath,
+                    HttpMethod.GET,
+                    null,
+                    new ParameterizedTypeReference<>() {}
+            );
+
+            // assert - public 경로의 하위 경로이므로 인증 통과 (404는 라우팅 문제)
+            assertThat(response.getStatusCode()).isNotEqualTo(HttpStatus.UNAUTHORIZED);
+        }
+    }
+}
diff --git a/build.gradle.kts b/build.gradle.kts
index 9c8490b8..dc167f2e 100644
--- a/build.gradle.kts
+++ b/build.gradle.kts
@@ -42,6 +42,7 @@ subprojects {
     dependencyManagement {
         imports {
             mavenBom("org.springframework.cloud:spring-cloud-dependencies:${project.properties["springCloudDependenciesVersion"]}")
+            mavenBom("org.testcontainers:testcontainers-bom:${project.properties["testcontainersVersion"]}")
         }
     }
 
diff --git a/gradle.properties b/gradle.properties
index 142d7120..5ae37ac9 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -10,6 +10,7 @@ springBootVersion=3.4.4
 springDependencyManagementVersion=1.1.7
 springCloudDependenciesVersion=2024.0.1
 ### Library versions ###
+testcontainersVersion=2.0.2
 springDocOpenApiVersion=2.7.0
 springMockkVersion=4.0.2
 mockitoVersion=5.14.0