diff --git a/.claude/settings.local.json b/.claude/settings.local.json
new file mode 100644
index 00000000..4cd83877
--- /dev/null
+++ b/.claude/settings.local.json
@@ -0,0 +1,8 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(./gradlew test:*)",
+      "Bash(./gradlew :apps:commerce-api:test:*)"
+    ]
+  }
+}
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..e57d39ca
--- /dev/null
+++ b/CLAUDE.md
@@ -0,0 +1,166 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Tech Stack & Versions
+
+| Category | Technology | Version |
+|----------|------------|---------|
+| Language | Java | 21 |
+| Framework | Spring Boot | 3.4.4 |
+| Dependency Management | Spring Dependency Management | 1.1.7 |
+| Cloud | Spring Cloud | 2024.0.1 |
+| Build Tool | Gradle (Kotlin DSL) | 8.13+ |
+| API Documentation | SpringDoc OpenAPI | 2.7.0 |
+| ORM | Spring Data JPA + QueryDSL | (managed by Spring Boot) |
+| Database | MySQL | 8.0 |
+| Cache | Redis (Master-Replica) | - |
+| Messaging | Kafka | 3.5.1 |
+| Monitoring | Micrometer + Prometheus | (managed by Spring Boot) |
+| Logging | Logback + Slack Appender | 1.6.1 |
+| Testing | JUnit 5, Mockito 5.14.0, SpringMockk 4.0.2, Instancio 5.0.2 | - |
+| Containers | TestContainers | (managed by Spring Boot) |
+
+## Build & Run Commands
+
+```bash
+# Build all modules
+./gradlew build
+
+# Run tests (profile: test, timezone: Asia/Seoul)
+./gradlew test
+
+# Run specific app
+./gradlew :apps:commerce-api:bootRun
+./gradlew :apps:commerce-batch:bootRun --args='--job.name=jobName'
+./gradlew :apps:commerce-streamer:bootRun
+
+# Build specific module
+./gradlew :apps:commerce-api:build
+
+# Run single test class
+./gradlew test --tests "com.loopers.ExampleServiceIntegrationTest"
+
+# Run single test method
+./gradlew test --tests "com.loopers.ExampleServiceIntegrationTest.testMethodName"
+
+# Test with coverage report
+./gradlew test jacocoTestReport
+```
+
+**Java version**: 21 (configured via Gradle toolchain)
+
+## Local Infrastructure
+
+```bash
+# Start MySQL, Redis (master+replica), Kafka
+docker-compose -f docker/infra-compose.yml up
+
+# Start Prometheus + Grafana monitoring
+docker-compose -f docker/monitoring-compose.yml up
+```
+
+- MySQL: localhost:3307 (root/root, application/application)
+- Redis Master: localhost:6379, Replica: localhost:6380
+- Kafka: localhost:19092, Kafka UI: localhost:9099
+- Grafana: localhost:3000 (admin/admin)
+
+## Architecture
+
+### Multi-Module Structure
+
+```
+loopers-java-spring-template/
+├── apps/                          # Executable Spring Boot applications
+│   ├── commerce-api              # REST API (web, actuator, springdoc-openapi)
+│   ├── commerce-batch            # Batch jobs (spring-batch)
+│   └── commerce-streamer         # Event streaming (web, kafka)
+├── modules/                       # Reusable infrastructure configurations
+│   ├── jpa                       # JPA, QueryDSL, MySQL connector
+│   ├── redis                     # Spring Data Redis (master-replica)
+│   └── kafka                     # Spring Kafka
+└── supports/                      # Cross-cutting add-on modules
+    ├── jackson                   # Jackson serialization (Kotlin module, JSR310)
+    ├── logging                   # Logback, Slack appender
+    └── monitoring                # Micrometer, Prometheus registry
+```
+
+### Module Dependencies
+
+| App | modules | supports |
+|-----|---------|----------|
+| commerce-api | jpa, redis | jackson, logging, monitoring |
+| commerce-batch | jpa, redis | jackson, logging, monitoring |
+| commerce-streamer | jpa, redis, kafka | jackson, logging, monitoring |
+
+### Layer Architecture (commerce-api)
+```
+interfaces/api/     → Controllers, DTOs, OpenAPI specs
+application/        → Facades (use case orchestration)
+domain/             → Entities, Services, Repository interfaces
+infrastructure/     → Repository implementations, adapters
+```
+
+### Key Patterns
+- **Controllers**: Implement `*ApiSpec` interfaces for OpenAPI documentation
+- **Facades**: Orchestrate domain services, convert domain models to DTOs
+- **Services**: `@Component` with `@Transactional`, contain business logic
+- **Repositories**: Interface in `domain/`, implementation in `infrastructure/`
+- **Entities**: Extend `BaseEntity` (provides id, createdAt, updatedAt, deletedAt)
+- **Response wrapper**: All APIs return `ApiResponse<T>`
+- **Error handling**: `CoreException` with `ErrorType` enum, caught by `ApiControllerAdvice`
+
+### Soft Delete
+Entities use `deletedAt` field via `BaseEntity`:
+```java
+entity.delete();   // marks as deleted
+entity.restore();  // restores
+```
+
+## Configuration
+
+- Profile-based: local, test, dev, qa, prd
+- Config imports in application.yml: jpa.yml, redis.yml, logging.yml, monitoring.yml
+- Management endpoints on port 8081 (/health, /prometheus)
+
+## Testing
+
+- Framework: JUnit 5 + AssertJ + Mockito + SpringMockk + Instancio
+- `DatabaseCleanUp` utility truncates tables between tests (from jpa test fixtures)
+- `RedisCleanUp` available from redis test fixtures
+- TestContainers support for MySQL, Redis, Kafka
+
+## 개발 규칙
+
+### 진행 Workflow - 증강 코딩
+- **대원칙**: 방향성 및 주요 의사 결정은 개발자에게 제안만 할 수 있으며, 최종 승인된 사항을 기반으로 작업 수행
+- **중간 결과 보고**: AI가 반복적인 동작을 하거나, 요청하지 않은 기능을 구현, 테스트 삭제를 임의로 진행할 경우 개발자가 개입
+- **설계 주도권 유지**: AI가 임의판단을 하지 않고, 방향성에 대한 제안 등을 진행할 수 있으나 개발자의 승인을 받은 후 수행
+
+### 개발 Workflow - TDD (Red → Green → Refactor)
+- 모든 테스트는 3A 원칙으로 작성 (Arrange - Act - Assert)
+
+| Phase | 설명 |
+|-------|------|
+| **Red** | 요구사항을 만족하는 실패하는 테스트 케이스 먼저 작성 |
+| **Green** | Red Phase의 테스트가 모두 통과할 수 있는 최소한의 코드 작성 (오버엔지니어링 금지) |
+| **Refactor** | 불필요한 private 함수 지양, 객체지향적 코드 작성, unused import 제거, 성능 최적화. 모든 테스트 통과 필수 |
+
+### 주의사항
+
+**Never Do:**
+- 실제 동작하지 않는 코드, 불필요한 Mock 데이터를 이용한 구현 금지
+- null-safety 하지 않은 코드 작성 금지 (Java의 경우 Optional 활용)
+- println 코드 남기지 말 것
+
+**Recommendation:**
+- 실제 API를 호출해 확인하는 E2E 테스트 코드 작성
+- 재사용 가능한 객체 설계
+- 성능 최적화에 대한 대안 및 제안
+- 개발 완료된 API는 `http/*.http` 파일에 분류해 작성
+
+**Priority:**
+1. 실제 동작하는 해결책만 고려
+2. null-safety, thread-safety 고려
+3. 테스트 가능한 구조로 설계
+4. 기존 코드 패턴 분석 후 일관성 유지
diff --git a/MERMAID.md b/MERMAID.md
new file mode 100644
index 00000000..09f77cf3
--- /dev/null
+++ b/MERMAID.md
@@ -0,0 +1,167 @@
+# Flow Diagrams
+
+## 1. 회원가입 (POST /api/v1/members)
+
+```mermaid
+sequenceDiagram
+    autonumber
+    participant Client
+    participant Controller
+    participant Facade
+    participant Service
+    participant DB
+
+    Client->>Controller: POST /api/v1/members (SignUpRequest)
+    Controller->>Facade: signupMember(request)
+    Facade->>Facade: Request to MemberModel 변환
+    Facade->>Service: saveMember(memberModel)
+    Service->>DB: findByLoginId (중복 체크)
+    DB-->>Service: Optional.empty()
+    Service->>Service: passwordEncoder.encode()
+    Service->>DB: save(memberModel)
+    DB-->>Service: savedMember
+    Service-->>Facade: MemberModel
+    Facade->>Facade: MemberModel to MemberInfo 변환
+    Facade-->>Controller: MemberInfo
+    Controller-->>Client: 201 Created (SignUpResponse)
+```
+
+### 예외 흐름
+
+```mermaid
+sequenceDiagram
+    autonumber
+    participant Client
+    participant Controller
+    participant Facade
+    participant Service
+    participant DB
+
+    Client->>Controller: POST /api/v1/members (중복 ID)
+    Controller->>Facade: signupMember(request)
+    Facade->>Service: saveMember(memberModel)
+    Service->>DB: findByLoginId
+    DB-->>Service: Optional.of(existingMember)
+    Service-->>Controller: CoreException (CONFLICT)
+    Controller-->>Client: 409 Conflict
+```
+
+---
+
+## 2. 내 정보 조회 (GET /api/v1/members/me)
+
+```mermaid
+sequenceDiagram
+    autonumber
+    participant Client
+    participant Controller
+    participant Facade
+    participant Service
+    participant DB
+
+    Client->>Controller: GET /api/v1/members/me
+    Note over Client,Controller: Headers: X-Loopers-LoginId, X-Loopers-LoginPw
+    Controller->>Facade: getMyInfo(loginId, password)
+    Facade->>Service: authenticate(loginId, password)
+    Service->>DB: findByLoginId
+    DB-->>Service: MemberModel
+    Service->>Service: passwordEncoder.matches()
+    Service-->>Facade: MemberModel (인증 성공)
+    Facade->>Facade: MemberModel to MemberInfo 변환 (이름 마스킹)
+    Facade-->>Controller: MemberInfo
+    Controller-->>Client: 200 OK (MemberInfoResponse)
+```
+
+### 예외 흐름 - 인증 실패
+
+```mermaid
+sequenceDiagram
+    autonumber
+    participant Client
+    participant Controller
+    participant Facade
+    participant Service
+    participant DB
+
+    Client->>Controller: GET /api/v1/members/me (틀린 비밀번호)
+    Controller->>Facade: getMyInfo(loginId, wrongPassword)
+    Facade->>Service: authenticate(loginId, wrongPassword)
+    Service->>DB: findByLoginId
+    DB-->>Service: MemberModel
+    Service->>Service: passwordEncoder.matches() = false
+    Service-->>Controller: CoreException (UNAUTHORIZED)
+    Controller-->>Client: 401 Unauthorized
+```
+
+---
+
+## 3. 비밀번호 변경 (PATCH /api/v1/members/me/password)
+
+```mermaid
+sequenceDiagram
+    autonumber
+    participant Client
+    participant Controller
+    participant Facade
+    participant Service
+    participant DB
+
+    Client->>Controller: PATCH /api/v1/members/me/password
+    Note over Client,Controller: Headers: X-Loopers-LoginId, X-Loopers-LoginPw
+    Note over Client,Controller: Body: oldPassword, newPassword
+    Controller->>Facade: changePassword(loginId, headerPw, oldPw, newPw)
+    Facade->>Service: authenticate(loginId, headerPw)
+    Service->>DB: findByLoginId
+    DB-->>Service: MemberModel
+    Service->>Service: passwordEncoder.matches(headerPw)
+    Service-->>Facade: 인증 성공
+    Facade->>Facade: new MemberModel(loginId, oldPw)
+    Facade->>Service: changePassword(memberModel, newPw)
+    Service->>Service: passwordEncoder.matches(oldPw) 검증
+    Service->>Service: newPw != oldPw 검증
+    Service->>Service: validatePassword(newPw) 규칙 검증
+    Service->>Service: passwordEncoder.encode(newPw)
+    Service->>DB: Dirty Checking (자동 저장)
+    Service-->>Facade: void
+    Facade-->>Controller: void
+    Controller-->>Client: 200 OK
+```
+
+### 예외 흐름 - Body의 기존 비밀번호 불일치
+
+```mermaid
+sequenceDiagram
+    autonumber
+    participant Client
+    participant Controller
+    participant Facade
+    participant Service
+
+    Client->>Controller: PATCH (헤더 인증 OK, Body oldPw 틀림)
+    Controller->>Facade: changePassword(...)
+    Facade->>Service: authenticate() 성공
+    Facade->>Service: changePassword(wrongOldPw, newPw)
+    Service->>Service: passwordEncoder.matches(wrongOldPw) = false
+    Service-->>Controller: CoreException (UNAUTHORIZED)
+    Controller-->>Client: 401 Unauthorized
+```
+
+### 예외 흐름 - 새 비밀번호가 기존과 동일
+
+```mermaid
+sequenceDiagram
+    autonumber
+    participant Client
+    participant Controller
+    participant Facade
+    participant Service
+
+    Client->>Controller: PATCH (newPw == oldPw)
+    Controller->>Facade: changePassword(...)
+    Facade->>Service: authenticate() 성공
+    Facade->>Service: changePassword(oldPw, samePassword)
+    Service->>Service: oldPw 검증 성공
+    Service->>Service: newPw == oldPw 체크
+    Service-->>Controller: CoreException (BAD_REQUEST)
+    Controller-->>Client: 400 Bad Request
+```
\ No newline at end of file
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..781bacce
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/application/member/MemberFacade.java
@@ -0,0 +1,49 @@
+package com.loopers.application.member;
+
+import com.loopers.domain.member.MemberModel;
+import com.loopers.domain.member.MemberService;
+import com.loopers.interfaces.api.member.MemberV1Dto;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Component;
+
+@RequiredArgsConstructor
+@Component
+public class MemberFacade {
+
+  private final MemberService memberService;
+
+  public MemberInfo signupMember(MemberV1Dto.SignUpRequest request) {
+    // 1. Request → MemberModel로 변환
+    MemberModel memberModel = new MemberModel(
+        request.loginId(),
+        request.password(),
+        request.name(),
+        request.birthDate(),
+        request.email()
+    );
+
+    // 2. Service 호출 (저장 + 중복 체크)
+    MemberModel saved = memberService.saveMember(memberModel);
+
+    // 3. MemberModel → MemberInfo로 변환해서 반환
+    return MemberInfo.from(saved);
+  }
+
+
+  public MemberInfo getMyInfo(String loginId, String password) {
+    MemberModel member = memberService.authenticate(loginId, password);
+    return MemberInfo.from(member);
+  }
+
+
+  public void changePassword(String loginId, String password, String prevPassword, String newPassword) {
+    // 헤더 인증
+    memberService.authenticate(loginId, password);
+
+    MemberModel memberModel = new MemberModel(loginId, prevPassword);  // raw prevPassword
+
+    // Service 호출
+    memberService.changePassword(memberModel, newPassword);
+
+  }
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/application/member/MemberInfo.java b/apps/commerce-api/src/main/java/com/loopers/application/member/MemberInfo.java
new file mode 100644
index 00000000..38b99890
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/application/member/MemberInfo.java
@@ -0,0 +1,15 @@
+package com.loopers.application.member;
+
+import com.loopers.domain.member.MemberModel;
+
+// MemberInfo는 Facade → Controller로 전달되는 데이터
+public record MemberInfo(String loginId, String name, String birthDate, String email) {
+    public static MemberInfo from(MemberModel model) {
+        return new MemberInfo(
+            model.getLoginId(),
+            model.getMaskedName(),
+            model.getBirthDate(),
+            model.getEmail()
+          );
+    }
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/config/SecurityConfig.java b/apps/commerce-api/src/main/java/com/loopers/config/SecurityConfig.java
new file mode 100644
index 00000000..7e23f737
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/config/SecurityConfig.java
@@ -0,0 +1,15 @@
+package com.loopers.config;
+
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
+import org.springframework.security.crypto.password.PasswordEncoder;
+
+@Configuration
+public class SecurityConfig {
+
+  @Bean
+  public PasswordEncoder passwordEncoder() {
+    return new BCryptPasswordEncoder();
+  }
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/domain/member/MemberModel.java b/apps/commerce-api/src/main/java/com/loopers/domain/member/MemberModel.java
new file mode 100644
index 00000000..58e72de9
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/member/MemberModel.java
@@ -0,0 +1,148 @@
+package com.loopers.domain.member;
+
+import com.loopers.domain.BaseEntity;
+import com.loopers.support.error.CoreException;
+import com.loopers.support.error.ErrorType;
+import jakarta.persistence.Entity;
+import jakarta.persistence.Table;
+
+@Entity
+@Table(name = "member")
+public class MemberModel extends BaseEntity {
+
+  private String loginId;
+  private String password;
+  private String name;
+  private String birthDate;
+  private String email;
+
+  protected MemberModel() {
+  }
+
+  public MemberModel(String loginId, String password, String name, String birthDate, String email) {
+
+    // 모든 항목은 비어 있을 수 없다
+    if (loginId == null || loginId.isBlank()) {
+      throw new CoreException(ErrorType.BAD_REQUEST, "아이디는 비어있을 수 없습니다.");
+    }
+    if (password == null || password.isBlank()) {
+      throw new CoreException(ErrorType.BAD_REQUEST, "비밀번호는 비어있을 수 없습니다.");
+    }
+    if (name == null || name.isBlank()) {
+      throw new CoreException(ErrorType.BAD_REQUEST, "이름은 비어있을 수 없습니다.");
+    }
+    if (birthDate == null || birthDate.isBlank()) {
+      throw new CoreException(ErrorType.BAD_REQUEST, "생년월일은 비어있을 수 없습니다.");
+    }
+    if (email == null || email.isBlank()) {
+      throw new CoreException(ErrorType.BAD_REQUEST, "이메일은 비어있을 수 없습니다.");
+    }
+
+    // 가입된 아이디로는 가입이 불가능하다 -> 디비에서 검증. 서비스에서 하기
+    // 가입하는 로그인 ID는 영문과 숫자만 허용한다
+    validateLoginId(loginId);
+
+    // 비밀번호 8~16자의 영문 대소문자, 숫자, 특수문자만 가능합니다.
+    // 비밀번호 생년월일은 비밀번호 내에 포함될 수 없습니다.
+    // 비밀번호 규칙 검증
+    validatePassword(password, birthDate);
+
+    this.loginId = loginId;
+    this.password = password;
+    this.name = name;
+    this.birthDate = birthDate;
+    this.email = email;
+  }
+
+  public MemberModel(String loginId) {
+    // 모든 항목은 비어 있을 수 없다
+    if (loginId == null || loginId.isBlank()) {
+      throw new CoreException(ErrorType.BAD_REQUEST, "아이디는 비어있을 수 없습니다.");
+    }
+
+    // 가입하는 로그인 ID는 영문과 숫자만 허용한다
+    validateLoginId(loginId);
+    this.loginId = loginId;
+  }
+
+  public MemberModel(String loginId, String prevPassword) {
+    this.loginId = loginId;
+    this.password = prevPassword;
+  }
+
+  public String getLoginId() {
+    return loginId;
+  }
+
+  public String getPassword() {
+    return password;
+  }
+
+  public String getName() {
+    return name;
+  }
+
+  public String getBirthDate() {
+    return birthDate;
+  }
+
+  public String getEmail() {
+    return email;
+  }
+
+  private void validateLoginId(String loginId) {
+    // 로그인 ID 는 영문과 숫자만 허용
+    if (!loginId.matches("^[a-zA-Z0-9]+$")) {
+      throw new CoreException(ErrorType.BAD_REQUEST, "로그인 아이디는 영문자와 숫자만 사용할 수 있습니다.");
+    }
+  }
+
+  private void validatePassword(String password, String birthDate) {
+    // 1. 8~16자 길이 체크
+    if (password.length() < 8 || password.length() > 16) {
+      throw new CoreException(ErrorType.BAD_REQUEST, "비밀번호는 8~16자여야 합니다.");
+    }
+
+    // 2. 영문 대소문자, 숫자, 특수문자만 허용 (한글, 공백 등 불가)
+    if (!password.matches("^[a-zA-Z0-9!@#$%^&*()_+\\-=\\[\\]{};':\"\\\\|,.<>/?]+$")) {
+      throw new CoreException(ErrorType.BAD_REQUEST, "비밀번호는 영문 대소문자, 숫자, 특수문자만 가능합니다.");
+    }
+
+    // 3. 생년월일이 비밀번호에 포함되면 안됨
+    if (password.contains(birthDate)) {
+      throw new CoreException(ErrorType.BAD_REQUEST, "비밀번호에 생년월일을 포함할 수 없습니다.");
+    }
+  }
+
+  // 암호화된 비밀번호를 엔티티에 넣어주기
+  public void encryptPassword(String encryptedPassword) {
+    this.password = encryptedPassword;
+  }
+
+  // 이름 마지막 글자에 마스킹 추가
+  public String maskLastChar(String name) {
+    if (name == null || name.isBlank()) {
+      throw new IllegalArgumentException("이름은 비어 있을 수 없습니다.");
+    }
+
+    if (name.length() == 1) {
+      return "*";
+    }
+
+    return name.substring(0, name.length() - 1) + "*";
+  }
+
+  // 마스킹된 이름 가져오기
+  public String getMaskedName() {
+    return maskLastChar(this.name);
+  }
+
+
+  // 비밀번호 변경하기
+  public void changePassword(String newPassword, String birthDate) {
+    validatePassword(newPassword, birthDate);
+    this.password = newPassword;
+  }
+
+
+}
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..ca1e3cd8
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/member/MemberRepository.java
@@ -0,0 +1,10 @@
+package com.loopers.domain.member;
+
+import java.util.Optional;
+
+public interface MemberRepository {
+    MemberModel save(MemberModel memberModel);
+    Optional<MemberModel> findByLoginId(String id);
+    Optional<MemberModel> update(MemberModel memberModel);
+
+}
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..0ab66665
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/member/MemberService.java
@@ -0,0 +1,82 @@
+package com.loopers.domain.member;
+
+import com.loopers.support.error.CoreException;
+import com.loopers.support.error.ErrorType;
+import java.util.Optional;
+import lombok.RequiredArgsConstructor;
+import org.springframework.dao.DataIntegrityViolationException;
+import org.springframework.security.crypto.password.PasswordEncoder;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+
+@RequiredArgsConstructor
+@Component
+public class MemberService {
+
+  private final MemberRepository memberRepository;
+  private final PasswordEncoder passwordEncoder;
+
+  @Transactional(readOnly = false)
+  public MemberModel saveMember(MemberModel memberModel) {
+    //저장하기 전에 이미 같은 loginId가 있는지 확인
+    Optional<MemberModel> existing = memberRepository.findByLoginId(memberModel.getLoginId());
+    if (existing.isPresent()) {
+      throw new CoreException(ErrorType.CONFLICT, "이미 존재하는 아이디입니다.");
+    }
+
+    // 비밀번호 암호화 후 저장
+    String encrypted = passwordEncoder.encode(memberModel.getPassword());
+    memberModel.encryptPassword(encrypted);
+
+    try {
+      return memberRepository.save(memberModel);
+    } catch (DataIntegrityViolationException e) {
+      throw new CoreException(ErrorType.CONFLICT, "이미 존재하는 아이디입니다.");
+    }
+  }
+
+  public MemberModel authenticate(String loginId, String password) {
+    // 1. 회원 조회
+    MemberModel member = getMember(loginId);  // 없으면 NOT_FOUND
+
+    // 2. 비밀번호 일치 여부 확인
+    if (!passwordEncoder.matches(password, member.getPassword())) {
+      // 3. 불일치 시 UNAUTHORIZED 예외
+      throw new CoreException(ErrorType.UNAUTHORIZED, "인증 실패");
+    }
+
+    return member;
+  }
+
+  @Transactional(readOnly = true)
+  public MemberModel getMember(String loginId) {
+    MemberModel model = new MemberModel(loginId);  // 객체 먼저 생성해야 함
+    return memberRepository.findByLoginId(model.getLoginId())
+        .orElseThrow(() -> new CoreException(ErrorType.NOT_FOUND, "[id = " + loginId + "] 회원을 찾을 수 없습니다."));
+  }
+
+  @Transactional(readOnly = false)
+  public void changePassword(MemberModel memberModel, String newPassword) {
+
+    // 기존 회원 정보 조회
+    MemberModel member = getMember(memberModel.getLoginId());
+
+    // 암호화된 DB 비밀번호와 입력한 기존 비밀번호 비교
+    if (!passwordEncoder.matches(memberModel.getPassword(), member.getPassword())) {
+      throw new CoreException(ErrorType.UNAUTHORIZED, "기존 비밀번호가 일치하지 않습니다.");
+    }
+
+    // 암호화된 DB 기존 비밀번호와 입력한 새로운 비밀번호 비교
+    if (passwordEncoder.matches(newPassword, member.getPassword())) {
+      throw new CoreException(ErrorType.BAD_REQUEST, "새 비밀번호는 기존 비밀번호와 달라야 합니다.");
+    }
+
+    // 새 비밀번호 규칙 검증 + 암호화 + 저장 (Dirty Checking)
+    member.changePassword(newPassword, member.getBirthDate());
+
+    // 암호화 후 저장 (Dirty Checking)
+    String encryptedPassword = passwordEncoder.encode(newPassword);
+    member.encryptPassword(encryptedPassword);
+
+  }
+}
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..0bcc2c78
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/infrastructure/member/MemberJpaRepository.java
@@ -0,0 +1,11 @@
+package com.loopers.infrastructure.member;
+
+import com.loopers.domain.member.MemberModel;
+import java.util.Optional;
+import org.springframework.data.jpa.repository.JpaRepository;
+
+public interface MemberJpaRepository extends JpaRepository<MemberModel, Long> {
+
+  Optional<MemberModel> findByLoginId(String loginId);
+  MemberModel save(MemberModel memberModel);
+}
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..17e86c5d
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/infrastructure/member/MemberRepositoryImpl.java
@@ -0,0 +1,29 @@
+package com.loopers.infrastructure.member;
+
+import com.loopers.domain.member.MemberModel;
+import com.loopers.domain.member.MemberRepository;
+import java.util.Optional;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Component;
+
+@RequiredArgsConstructor
+@Component
+public class MemberRepositoryImpl implements MemberRepository {
+
+  private final MemberJpaRepository memberJpaRepository;
+
+  @Override
+  public MemberModel save(MemberModel memberModel) {
+    return memberJpaRepository.save(memberModel);
+  }
+
+  @Override
+  public Optional<MemberModel> update(MemberModel memberModel) {
+    return Optional.empty();
+  }
+
+  @Override
+  public Optional<MemberModel> findByLoginId(String id) {
+    return memberJpaRepository.findByLoginId(id);
+  }
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/interfaces/api/member/MemberV1ApiSpec.java b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/member/MemberV1ApiSpec.java
new file mode 100644
index 00000000..52cb6480
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/member/MemberV1ApiSpec.java
@@ -0,0 +1,40 @@
+package com.loopers.interfaces.api.member;
+
+import com.loopers.interfaces.api.ApiResponse;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import org.springframework.web.bind.annotation.RequestHeader;
+
+@Tag(name = "Member V1 API", description = "회원 API")
+public interface MemberV1ApiSpec {
+
+  @Operation(
+      summary = "회원 가입 요청",
+      description = "주어진 정보를 가지고 회원 가입을 실행한다"
+  )
+    // @Schema는 Swagger API 문서에서 파라미터 설명을 보여주는 용도
+    // 예제에서는 Long exampleId 같은 단일 파라미터에 붙였는데, 지금은 SignUpRequest로 통째로 받으니까 여기엔 필요 없음
+  ApiResponse<MemberV1Dto.SignUpResponse> signUp(
+      MemberV1Dto.SignUpRequest request
+  );
+
+  @Operation(
+      summary = "내 정보 조회",
+      description = "로그인 ID로 내 회원 정보를 조회한다"
+  )
+  ApiResponse<MemberV1Dto.MemberInfoResponse> getMyInfo(
+      @RequestHeader("X-Loopers-LoginId") String loginId,
+      @RequestHeader("X-Loopers-LoginPw") String password
+  );
+
+  @Operation(
+      summary = "비밀번호 변경",
+      description = "기존 비밀번호와 새 비밀번호를 받아 비밀번호를 변경한다"
+  )
+  ApiResponse<String> changePassword(
+      @RequestHeader("X-Loopers-LoginId") String loginId,
+      @RequestHeader("X-Loopers-LoginPw") String password,
+      MemberV1Dto.ChangePasswordRequest request
+  );
+
+}
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..07bf218e
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/member/MemberV1Controller.java
@@ -0,0 +1,63 @@
+package com.loopers.interfaces.api.member;
+
+import com.loopers.application.member.MemberFacade;
+import com.loopers.application.member.MemberInfo;
+import com.loopers.interfaces.api.ApiResponse;
+import com.loopers.interfaces.api.member.MemberV1Dto.ChangePasswordRequest;
+import com.loopers.interfaces.api.member.MemberV1Dto.MemberInfoResponse;
+import com.loopers.interfaces.api.member.MemberV1Dto.SignUpRequest;
+import com.loopers.interfaces.api.member.MemberV1Dto.SignUpResponse;
+import lombok.RequiredArgsConstructor;
+import org.springframework.http.HttpStatus;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PatchMapping;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestHeader;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.ResponseStatus;
+import org.springframework.web.bind.annotation.RestController;
+
+@RequiredArgsConstructor
+@RestController
+@RequestMapping("/api/v1/members")
+public class MemberV1Controller implements MemberV1ApiSpec {
+
+  //  클라이언트 → [SignUpRequest (record)] → Controller → Facade → Service → [MemberModel (entity)] → DB
+  //                   요청 데이터 전달용                                           DB에 저장되는 객체
+  //  DB → [MemberModel (entity)] → Facade → [SignUpResponse (record)] → Controller → 클라이언트
+  //            DB에서 꺼낸 객체                     응답 데이터 전달용
+  private final MemberFacade memberFacade;
+
+    @PostMapping
+    @ResponseStatus(HttpStatus.CREATED)
+    @Override
+    public ApiResponse<SignUpResponse> signUp(@RequestBody SignUpRequest request) {
+        MemberInfo info = memberFacade.signupMember(request);
+        MemberV1Dto.SignUpResponse response = MemberV1Dto.SignUpResponse.from(info);
+        return ApiResponse.success(response);
+    }
+
+    @GetMapping("/me")
+    @Override
+    public ApiResponse<MemberInfoResponse> getMyInfo(
+        @RequestHeader("X-Loopers-LoginId") String loginId,
+        @RequestHeader("X-Loopers-LoginPw") String password
+    ) {
+        MemberInfo info = memberFacade.getMyInfo(loginId, password);
+        MemberInfoResponse response = MemberInfoResponse.from(info);
+        return ApiResponse.success(response);
+    }
+
+  @PatchMapping("/me/password")
+    public ApiResponse<String> changePassword(
+        @RequestHeader("X-Loopers-LoginId") String loginId,
+        @RequestHeader("X-Loopers-LoginPw") String password,
+        @RequestBody ChangePasswordRequest request
+    ) {
+      memberFacade.changePassword(loginId, password, request.oldPassword(), request.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..e4e6f046
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/member/MemberV1Dto.java
@@ -0,0 +1,48 @@
+package com.loopers.interfaces.api.member;
+
+
+import com.loopers.application.member.MemberInfo;
+
+public class MemberV1Dto {
+
+    // Request: POST방식으로 보낼때 데이터를 담는 그릇 (from 필요 없음)
+    public record SignUpRequest(
+        String loginId,
+        String password,
+        String name,
+        String birthDate,
+        String email
+    ) {}
+
+    // Response: 변환 메서드(from)가 여기에!
+    public record SignUpResponse(String loginId) {
+      public static SignUpResponse from(MemberInfo info) {
+        return new SignUpResponse(info.loginId());
+      }
+    }
+
+    public record MemberInfoResponse(
+        String loginId,
+        String name,
+        String birthDate,
+        String email
+    ) {
+      public static MemberInfoResponse from(MemberInfo info) {
+        return new MemberInfoResponse(
+            info.loginId(),
+            info.name(),
+            info.birthDate(),
+            info.email()
+        );
+      }
+    }
+
+
+    // Request: 비밀번호 변경 요청
+    public record ChangePasswordRequest(
+      String oldPassword,
+      String newPassword
+    ) {}
+
+
+}
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..96c81c9f 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
@@ -11,7 +11,8 @@ public enum ErrorType {
     INTERNAL_ERROR(HttpStatus.INTERNAL_SERVER_ERROR, HttpStatus.INTERNAL_SERVER_ERROR.getReasonPhrase(), "일시적인 오류가 발생했습니다."),
     BAD_REQUEST(HttpStatus.BAD_REQUEST, HttpStatus.BAD_REQUEST.getReasonPhrase(), "잘못된 요청입니다."),
     NOT_FOUND(HttpStatus.NOT_FOUND, HttpStatus.NOT_FOUND.getReasonPhrase(), "존재하지 않는 요청입니다."),
-    CONFLICT(HttpStatus.CONFLICT, HttpStatus.CONFLICT.getReasonPhrase(), "이미 존재하는 리소스입니다.");
+    CONFLICT(HttpStatus.CONFLICT, HttpStatus.CONFLICT.getReasonPhrase(), "이미 존재하는 리소스입니다."),
+    UNAUTHORIZED(HttpStatus.UNAUTHORIZED, HttpStatus.UNAUTHORIZED.getReasonPhrase(), "유효하지 않은 인증 정보입니다.");
 
     private final HttpStatus status;
     private final String code;
diff --git a/apps/commerce-api/src/test/java/com/loopers/domain/member/MemberModelTest.java b/apps/commerce-api/src/test/java/com/loopers/domain/member/MemberModelTest.java
new file mode 100644
index 00000000..e28f0cda
--- /dev/null
+++ b/apps/commerce-api/src/test/java/com/loopers/domain/member/MemberModelTest.java
@@ -0,0 +1,220 @@
+package com.loopers.domain.member;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+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;
+
+class MemberModelTest {
+
+  @DisplayName("회원 모델을 생성할 때, ")
+  @Nested
+  class Create {
+
+    @DisplayName("(성공케이스) 필수 정보가 모두 주어지면, 정상적으로 생성된다.")
+    @Test
+    void createsMemberModel_whenAllFieldsAreProvided() {
+      // arrange
+      String loginId = "testuser";
+      String rawPassword = "Test1234!";
+      String name = "홍길동";
+      String birthDate = "19900101";
+      String email = "test@example.com";
+
+      // act
+      MemberModel member = new MemberModel(loginId, rawPassword, name, birthDate, email);
+
+      // assert
+      assertThat(member.getLoginId()).isEqualTo(loginId);
+      assertThat(member.getPassword()).isEqualTo(rawPassword);
+      assertThat(member.getName()).isEqualTo(name);
+      assertThat(member.getBirthDate()).isEqualTo(birthDate);
+      assertThat(member.getEmail()).isEqualTo(email);
+      // 비밀번호는 암호화되어 저장되므로 원본과 다를 수 있음 - 나중에 검증 방식 결정
+    }
+
+    @DisplayName("아이디로 회원 모델을 생성할 때, 영문과 숫자가 아닌 문자가 포함되면 예외가 발생한다.")
+    @Test
+    void throwsBadRequestException_whenLoginIdContainsInvalidChars() {
+      // arrange
+      String loginId = "testuser!@#";
+
+      // act
+      CoreException result = assertThrows(CoreException.class, () -> {
+        new MemberModel(loginId);
+      });
+      // assert
+      assertThat(result.getErrorType()).isEqualTo(ErrorType.BAD_REQUEST);
+    }
+
+
+    @DisplayName("(실패케이스) 비밀번호가 7자일때, 예외발생.")
+    @Test
+    void throwsBadRequestException_whenPwIsOutOfRange() {
+      // arrange
+      String loginId = "testuser";
+      String password = "Test12!";
+      String name = "홍길동";
+      String birthDate = "19900101";
+      String email = "test@example.com";
+
+      // act
+      CoreException result = assertThrows(CoreException.class, () -> {
+        new MemberModel(loginId, password, name, birthDate, email);
+      });
+
+      // assert
+      assertThat(result.getErrorType()).isEqualTo(ErrorType.BAD_REQUEST);
+    }
+
+
+    @DisplayName("비밀번호가 17자일 때 → 예외 발생")
+    @Test
+    void throwsBadRequestException_whenPwIsOutOfRange2() {
+      // arrange
+      String loginId = "testuser";
+      String password = "Test123456789012!";
+      String name = "홍길동";
+      String birthDate = "19900101";
+      String email = "test@example.com";
+
+      // act
+      CoreException result = assertThrows(CoreException.class, () -> {
+        new MemberModel(loginId, password, name, birthDate, email);
+      });
+
+      // assert
+      assertThat(result.getErrorType()).isEqualTo(ErrorType.BAD_REQUEST);
+    }
+
+    @DisplayName("비밀번호에 한글이 있을 때 → 예외 발생")
+    @Test
+    void throwsBadRequestException_whenPwIsKorean() {
+      // arrange
+      String loginId = "testuser";
+      String password = "Test홍길동890123!";
+      String name = "홍길동";
+      String birthDate = "19900101";
+      String email = "test@example.com";
+
+      // act
+      CoreException result = assertThrows(CoreException.class, () -> {
+        new MemberModel(loginId, password, name, birthDate, email);
+      });
+
+      // assert
+      assertThat(result.getErrorType()).isEqualTo(ErrorType.BAD_REQUEST);
+    }
+
+    @DisplayName("비밀번호에 생년월일이 포함될 때 → 예외 발생")
+    @Test
+    void throwsBadRequestException_whenPwContainsBirthDate() {
+      // arrange
+      String loginId = "testuser";
+      String password = "Test19900101!";
+      String name = "홍길동";
+      String birthDate = "19900101";
+      String email = "test@example.com";
+
+      // act
+      CoreException result = assertThrows(CoreException.class, () -> {
+        new MemberModel(loginId, password, name, birthDate, email);
+      });
+
+      // assert
+      assertThat(result.getErrorType()).isEqualTo(ErrorType.BAD_REQUEST);
+    }
+  }
+
+  @DisplayName("회원정보조회할 때,")
+  @Nested
+  class GetMemberInfo {
+
+    @DisplayName("이름 마지막 글자를 마스킹한다")
+    @Test
+    void mask_last_character() {
+      //arrange
+      String loginId = "testuser";
+      String rawPassword = "Test1234!";
+      String name = "홍길동";
+      String birthDate = "19900101";
+      String email = "test@example.com";
+
+      // act
+      MemberModel member = new MemberModel(loginId, rawPassword, name, birthDate, email);
+
+      assertThat(member.getMaskedName()).isEqualTo("홍길*");
+    }
+
+    @DisplayName("이름 마지막 글자를 마스킹한다")
+    @Test
+    void single_character_name_is_fully_masked() {
+      //arrange
+      String loginId = "testuser";
+      String rawPassword = "Test1234!";
+      String name = "홍";
+      String birthDate = "19900101";
+      String email = "test@example.com";
+
+      // act
+      MemberModel member = new MemberModel(loginId, rawPassword, name, birthDate, email);
+
+      assertThat(member.getMaskedName()).isEqualTo("*");
+    }
+
+  }
+
+  @DisplayName("비밀번호 수정 할 때,")
+  @Nested
+  class ChangePassword {
+
+    @DisplayName("새 비밀번호가 규칙을 만족하면, 비밀번호가 변경된다.")
+    @Test
+    void changesPassword_whenOldPasswordMatchesAndNewPasswordIsValid() {
+      // arrange
+      String loginId = "testuser";
+      String prevPassword = "Test1234!";
+      String name = "홍길동";
+      String birthDate = "19900101";
+      String email = "test@test.co.kr";
+
+      // act
+      MemberModel member = new MemberModel(loginId, prevPassword, name, birthDate, email);
+      String newPassword = "Newpass123!";
+      member.changePassword(newPassword, birthDate);
+
+      // assert
+      assertThat(member.getPassword()).isEqualTo(newPassword);
+    }
+
+
+    @DisplayName("새 비밀번호에 생년월일이 포함되면, 예외가 발생한다.")
+    @Test
+    void throwsException_whenNewPasswordContainsBirthDate() {
+      // arrange
+      String loginId = "testuser";
+      String prevPassword = "Test1234!";
+      String name = "홍길동";
+      String birthDate = "19900101";
+      String email = "test@test.co.kr";
+
+      String newPassword = "Test19900101!";
+
+      // act
+      MemberModel member = new MemberModel(loginId, prevPassword, name, birthDate, email);
+
+      // act
+      CoreException result = assertThrows(CoreException.class, () -> {
+        member.changePassword(newPassword, birthDate);
+      });
+
+      // assert - ErrorType.BAD_REQUEST
+      assertThat(result.getErrorType()).isEqualTo(ErrorType.BAD_REQUEST);
+
+    }
+  }
+}
diff --git a/apps/commerce-api/src/test/java/com/loopers/domain/member/MemberServiceIntegrationTest.java b/apps/commerce-api/src/test/java/com/loopers/domain/member/MemberServiceIntegrationTest.java
new file mode 100644
index 00000000..90820170
--- /dev/null
+++ b/apps/commerce-api/src/test/java/com/loopers/domain/member/MemberServiceIntegrationTest.java
@@ -0,0 +1,188 @@
+package com.loopers.domain.member;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertAll;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+import com.loopers.support.error.CoreException;
+import com.loopers.support.error.ErrorType;
+import com.loopers.utils.DatabaseCleanUp;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+
+@SpringBootTest
+class MemberServiceIntegrationTest {
+
+  @Autowired
+  private MemberService memberService;
+
+  @Autowired
+  private DatabaseCleanUp databaseCleanUp;
+
+  @AfterEach
+  void tearDown() {
+    databaseCleanUp.truncateAllTables();
+  }
+
+  @DisplayName("회원가입을 성공한다")
+  @Nested
+  class SaveMember {
+
+    @DisplayName("회원가입에 필요한 정보가 들어오면 디비에 저장하고 저장한 아이디를 조회한다")
+    @Test
+    void returnsMemberInfo_whenValidMemberInfoIsProvided() {
+      // arrange
+      MemberModel memberModel = new MemberModel("testuser", "Test1234!", "홍길동", "19900101", "test@example.com");
+
+      // act
+      memberService.saveMember(memberModel);
+      MemberModel result = memberService.getMember(memberModel.getLoginId());
+
+      // assert
+      assertAll(() -> assertThat(result).isNotNull(), () -> assertThat(result.getLoginId()).isEqualTo(memberModel.getLoginId()), () -> assertThat(result.getName()).isEqualTo(memberModel.getName()), () -> assertThat(result.getBirthDate()).isEqualTo(memberModel.getBirthDate()), () -> assertThat(result.getEmail()).isEqualTo(memberModel.getEmail()));
+    }
+
+    @DisplayName("중복 ID로 가입 시도하면 예외가 발생한다")
+    @Test
+    void throwsException_whenExistIdIsTryToSaveMember() {
+      // arrange - 먼저 한 명 가입시키기
+      memberService.saveMember(new MemberModel("testuser", "Test1234!", "홍길동", "19900101", "test@example.com"));
+
+      // act - 같은 ID로 또 가입 시도
+      CoreException exception = assertThrows(CoreException.class, () -> {
+        memberService.saveMember(new MemberModel("testuser", "Test1234!", "홍길동", "19900101", "test@example.com"));
+      });
+
+      // assert
+      assertThat(exception.getErrorType()).isEqualTo(ErrorType.CONFLICT);
+    }
+
+  }
+
+  @DisplayName("회원을 조회할 때, ")
+  @Nested
+  class GetMember {
+
+    @DisplayName("존재하는 ID를 주면, 해당 유저 정보를 반환한다.")
+    @Test
+    void returnsExampleInfo_whenValidIdIsProvided() {
+      // arrange  // 정보저장
+      MemberModel memberModel = new MemberModel("testuser", "Test1234!", "홍길동", "19900101", "test@example.com");
+      memberService.saveMember(memberModel);
+
+      // act
+      MemberModel result = memberService.getMember(memberModel.getLoginId());
+
+      // assert
+      assertAll(() -> assertThat(result).isNotNull(), () -> assertThat(result.getLoginId()).isEqualTo(memberModel.getLoginId()), () -> assertThat(result.getName()).isEqualTo(memberModel.getName()), () -> assertThat(result.getBirthDate()).isEqualTo(memberModel.getBirthDate()), () -> assertThat(result.getEmail()).isEqualTo(memberModel.getEmail()));
+    }
+
+    @DisplayName("존재하지 않는 ID로 조회하면 예외가 발생한다")
+    @Test
+    void throwsException_whenMemberNotFound() {
+      // arrange
+      String loginId = "testuser"; // Assuming this ID does not exist
+
+      // act
+      CoreException exception = assertThrows(CoreException.class, () -> {
+        memberService.getMember(loginId);
+      });
+
+      // assert
+      assertThat(exception.getErrorType()).isEqualTo(ErrorType.NOT_FOUND);
+    }
+  }
+
+
+  @DisplayName("비밀번호 변경을 할 때, ")
+  @Nested
+  class ChangePassword {
+
+    @DisplayName("기존 비밀번호와 새 비밀번호가 유효하면, 비밀번호가 변경된다.")
+    @Test
+    void changesPassword_whenOldAndNewPasswordsAreValid() {
+      // arrange
+      String loginId = "testuser";
+      String prevPassword = "Test1234!";
+      String name = "홍길동";
+      String birthDate = "19900101";
+      String email = "test@test.co.kr";
+
+      // act
+      // 기존 등록된 디비 설정
+      MemberModel member = new MemberModel(loginId, prevPassword, name, birthDate, email);
+      memberService.saveMember(member);
+
+      // 클라에서 입력한 아이디와 기존 비밀번호, 새로운 비밀번호
+      MemberModel insertedMember = new MemberModel(loginId, prevPassword);
+      String newPassword = "NewPass123!";
+
+      // act
+      memberService.changePassword(insertedMember, newPassword);
+
+      // assert
+      MemberModel updatedMember = memberService.getMember("testuser");
+      // 비밀번호가 변경되었는지 확인 (암호화된 비밀번호 비교)
+      assertThat(updatedMember.getPassword()).isNotEqualTo(insertedMember.getPassword());
+    }
+
+    @DisplayName("기존 비밀번호가 일치하지 않으면, 예외가 발생한다.")
+    @Test
+    void throwsException_whenOldPasswordDoesNotMatch() {
+      // arrange
+      String loginId = "testuser";
+      String prevPassword = "Test1234!";
+      String name = "홍길동";
+      String birthDate = "19900101";
+      String email = "test@test.co.kr";
+
+      // act
+      // 기존 등록된 디비 설정
+      MemberModel member = new MemberModel(loginId, prevPassword, name, birthDate, email);
+      memberService.saveMember(member);
+
+      // 클라에서 입력한 아이디와 기존 비밀번호, 새로운 비밀번호
+      String wrongPrevPassword = "WrongPass!";
+      MemberModel insertedMember = new MemberModel(loginId, wrongPrevPassword);
+      String newPassword = "NewPass123!";
+
+      // act
+      CoreException exception = assertThrows(CoreException.class, () -> {
+        memberService.changePassword(insertedMember, newPassword);
+      });
+
+      // assert - ErrorType.UNAUTHORIZED
+      assertThat(exception.getErrorType()).isEqualTo(ErrorType.UNAUTHORIZED);
+    }
+
+    @DisplayName("새 비밀번호가 기존 비밀번호와 같으면, 예외가 발생한다.")
+    @Test
+    void throwsException_whenNewPasswordIsSameAsOld() {
+      // arrange
+      String loginId = "testuser";
+      String prevPassword = "Test1234!";
+      String name = "홍길동";
+      String birthDate = "19900101";
+      String email = "test@test.co.kr";
+
+      MemberModel member = new MemberModel(loginId, prevPassword, name, birthDate, email);
+      memberService.saveMember(member);
+
+      // 클라에서 입력한 아이디와 기존 비밀번호, 새로운 비밀번호
+      MemberModel insertedMember = new MemberModel(loginId, prevPassword);
+      String newPassword = "Test1234!";
+
+      // act
+      CoreException exception = assertThrows(CoreException.class, () -> {
+        memberService.changePassword(insertedMember, newPassword);
+      });
+
+      // assert - ErrorType.UNAUTHORIZED 또는 BAD_REQUEST
+      assertThat(exception.getErrorType()).isEqualTo(ErrorType.BAD_REQUEST);
+    }
+  }
+}
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..b9fb6e26
--- /dev/null
+++ b/apps/commerce-api/src/test/java/com/loopers/interfaces/api/MemberV1ApiE2ETest.java
@@ -0,0 +1,355 @@
+package com.loopers.interfaces.api;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertAll;
+
+import com.loopers.utils.DatabaseCleanUp;
+import java.util.Map;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.Assertions;
+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;
+
+@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
+class MemberV1ApiE2ETest {
+
+    private static final String ENDPOINT = "/api/v1/members";
+
+    private final TestRestTemplate testRestTemplate;
+    private final DatabaseCleanUp databaseCleanUp;
+
+    @Autowired
+    public MemberV1ApiE2ETest(
+        TestRestTemplate testRestTemplate,
+        DatabaseCleanUp databaseCleanUp
+    ) {
+        this.testRestTemplate = testRestTemplate;
+        this.databaseCleanUp = databaseCleanUp;
+    }
+
+    @AfterEach
+    void tearDown() {
+        databaseCleanUp.truncateAllTables();
+    }
+
+    @DisplayName("POST /api/v1/members (회원가입)")
+    @Nested
+    class SignUp {
+
+        @DisplayName("유효한 회원 정보를 보내면, 201 Created와 생성된 ID를 반환한다.")
+        @Test
+        void returnsCreated_whenValidMemberInfoIsProvided() {
+            // arrange
+            Map<String, String> request = Map.of(
+                "loginId", "testuser",
+                "password", "Test1234!",
+                "name", "홍길동",
+                "birthDate", "19900101",
+                "email", "test@example.com"
+            );
+
+            // act
+            ResponseEntity<ApiResponse<Map<String, String>>> response = testRestTemplate.exchange(
+                ENDPOINT,
+                HttpMethod.POST,
+                new HttpEntity<>(request),
+                new ParameterizedTypeReference<>() {}
+            );
+
+            // assert
+            assertAll(
+                () -> assertThat(response.getStatusCode()).isEqualTo(HttpStatus.CREATED),
+                () -> assertThat(response.getBody()).isNotNull(),
+                () -> {
+                  Assertions.assertNotNull(response.getBody());
+                  assertThat(response.getBody().data()).isNotNull();
+                },
+                () -> {
+                  Assertions.assertNotNull(response.getBody());
+                  assertThat(response.getBody().data().get("loginId")).isNotNull();
+                }
+            );
+        }
+
+        @DisplayName("중복된 loginId로 가입하면, 409 Conflict를 반환한다.")
+        @Test
+        void returnsConflict_whenDuplicateLoginIdIsProvided() {
+            // arrange - 먼저 한 명 가입
+            Map<String, String> request = Map.of(
+                "loginId", "testuser",
+                "password", "Test1234!",
+                "name", "홍길동",
+                "birthDate", "19900101",
+                "email", "test@example.com"
+            );
+            testRestTemplate.exchange(ENDPOINT, HttpMethod.POST, new HttpEntity<>(request), new ParameterizedTypeReference<ApiResponse<Map<String, String>>>() {});
+
+            // act - 같은 ID로 다시 가입
+            ResponseEntity<ApiResponse<Map<String, String>>> response = testRestTemplate.exchange(
+                ENDPOINT,
+                HttpMethod.POST,
+                new HttpEntity<>(request),
+                new ParameterizedTypeReference<>() {}
+            );
+
+            // assert
+            assertThat(response.getStatusCode()).isEqualTo(HttpStatus.CONFLICT);
+        }
+    }
+
+    @DisplayName("GET /api/v1/members/me (회원정보조회)")
+    @Nested
+    class GetMemberInfo {
+
+        @DisplayName("헤더 인증 성공 시, 200 OK와 마스킹된 이름을 반환한다.")
+        @Test
+        void returnsMemberInfo_whenHeaderAuthIsValid() {
+            // arrange - 먼저 회원 가입
+            Map<String, String> signUpRequest = Map.of(
+                "loginId", "testuser",
+                "password", "Test1234!",
+                "name", "홍길동",
+                "birthDate", "19900101",
+                "email", "test@test.co.kr"
+            );
+            testRestTemplate.exchange(ENDPOINT, HttpMethod.POST, new HttpEntity<>(signUpRequest), new ParameterizedTypeReference<ApiResponse<Map<String, String>>>() {});
+
+            // act - 헤더에 인증 정보 포함하여 조회
+            HttpHeaders headers = new HttpHeaders();
+            headers.set("X-Loopers-LoginId", "testuser");
+            headers.set("X-Loopers-LoginPw", "Test1234!");
+
+            ResponseEntity<ApiResponse<Map<String, String>>> response = testRestTemplate.exchange(
+                ENDPOINT + "/me",
+                HttpMethod.GET,
+                new HttpEntity<>(headers),
+                new ParameterizedTypeReference<>() {}
+            );
+
+            // assert
+            assertAll(
+                () -> assertThat(response.getStatusCode()).isEqualTo(HttpStatus.OK),
+                () -> assertThat(response.getBody()).isNotNull(),
+                () -> {
+                  Assertions.assertNotNull(response.getBody());
+                  assertThat(response.getBody().data()).isNotNull();
+                },
+                () -> {
+                  Assertions.assertNotNull(response.getBody());
+                  assertThat(response.getBody().data().get("loginId")).isEqualTo("testuser");
+                },
+                () -> {
+                  Assertions.assertNotNull(response.getBody());
+                  assertThat(response.getBody().data().get("name")).isEqualTo("홍길*");
+                }
+            );
+        }
+
+        @DisplayName("헤더 인증 실패 시 (비밀번호 불일치), 401 Unauthorized를 반환한다.")
+        @Test
+        void returnsUnauthorized_whenHeaderPasswordIsWrong() {
+            // arrange - 먼저 회원 가입
+            Map<String, String> signUpRequest = Map.of(
+                "loginId", "testuser",
+                "password", "Test1234!",
+                "name", "홍길동",
+                "birthDate", "19900101",
+                "email", "test@test.co.kr"
+            );
+            testRestTemplate.exchange(ENDPOINT, HttpMethod.POST, new HttpEntity<>(signUpRequest), new ParameterizedTypeReference<ApiResponse<Map<String, String>>>() {});
+
+            // act - 틀린 비밀번호로 조회
+            HttpHeaders headers = new HttpHeaders();
+            headers.set("X-Loopers-LoginId", "testuser");
+            headers.set("X-Loopers-LoginPw", "WrongPass1!");
+
+            ResponseEntity<ApiResponse<Map<String, String>>> response = testRestTemplate.exchange(
+                ENDPOINT + "/me",
+                HttpMethod.GET,
+                new HttpEntity<>(headers),
+                new ParameterizedTypeReference<>() {}
+            );
+
+            // assert
+            assertThat(response.getStatusCode()).isEqualTo(HttpStatus.UNAUTHORIZED);
+        }
+
+        @DisplayName("존재하지 않는 회원의 ID로 조회하면, 404 Not Found를 반환한다.")
+        @Test
+        void returnsNotFound_whenMemberDoesNotExist() {
+            // arrange - 아무 데이터 없음
+            HttpHeaders headers = new HttpHeaders();
+            headers.set("X-Loopers-LoginId", "nonexistent");
+            headers.set("X-Loopers-LoginPw", "Test1234!");
+
+            // act
+            ResponseEntity<ApiResponse<Map<String, String>>> response = testRestTemplate.exchange(
+                ENDPOINT + "/me",
+                HttpMethod.GET,
+                new HttpEntity<>(headers),
+                new ParameterizedTypeReference<>() {}
+            );
+
+            // assert
+            assertThat(response.getStatusCode()).isEqualTo(HttpStatus.NOT_FOUND);
+        }
+    }
+
+    @DisplayName("PATCH /api/v1/members/me/password (비밀번호 변경)")
+    @Nested
+    class ChangePassword {
+
+        @DisplayName("헤더 인증 성공 + 유효한 비밀번호 변경 요청이면, 200 OK를 반환한다.")
+        @Test
+        void returnsOk_whenHeaderAuthAndPasswordChangeAreValid() {
+            // arrange - 먼저 회원 가입
+            Map<String, String> signUpRequest = Map.of(
+                "loginId", "testuser",
+                "password", "Test1234!",
+                "name", "홍길동",
+                "birthDate", "19900101",
+                "email", "test@test.co.kr"
+            );
+            testRestTemplate.exchange(ENDPOINT, HttpMethod.POST, new HttpEntity<>(signUpRequest), new ParameterizedTypeReference<ApiResponse<Map<String, String>>>() {});
+
+            // act - 헤더 인증 + 비밀번호 변경 요청
+            HttpHeaders headers = new HttpHeaders();
+            headers.set("X-Loopers-LoginId", "testuser");
+            headers.set("X-Loopers-LoginPw", "Test1234!");
+            headers.set("Content-Type", "application/json");
+
+            Map<String, String> changePasswordRequest = Map.of(
+                "oldPassword", "Test1234!",
+                "newPassword", "NewPass123!"
+            );
+            ResponseEntity<ApiResponse<String>> response = testRestTemplate.exchange(
+                ENDPOINT + "/me/password",
+                HttpMethod.PATCH,
+                new HttpEntity<>(changePasswordRequest, headers),
+                new ParameterizedTypeReference<>() {}
+            );
+
+            // assert
+            assertAll(
+                () -> assertThat(response.getStatusCode()).isEqualTo(HttpStatus.OK),
+                () -> assertThat(response.getBody()).isNotNull(),
+                () -> {
+                  Assertions.assertNotNull(response.getBody());
+                  assertThat(response.getBody().data()).isEqualTo("비밀번호가 변경되었습니다.");
+                }
+            );
+        }
+
+        @DisplayName("헤더 인증 실패 시 (비밀번호 불일치), 401 Unauthorized를 반환한다.")
+        @Test
+        void returnsUnauthorized_whenHeaderPasswordIsWrong() {
+            // arrange - 먼저 회원 가입
+            Map<String, String> signUpRequest = Map.of(
+                "loginId", "testuser",
+                "password", "Test1234!",
+                "name", "홍길동",
+                "birthDate", "19900101",
+                "email", "test@test.co.kr"
+            );
+            testRestTemplate.exchange(ENDPOINT, HttpMethod.POST, new HttpEntity<>(signUpRequest), new ParameterizedTypeReference<ApiResponse<Map<String, String>>>() {});
+
+            // act - 틀린 헤더 비밀번호로 요청
+            HttpHeaders headers = new HttpHeaders();
+            headers.set("X-Loopers-LoginId", "testuser");
+            headers.set("X-Loopers-LoginPw", "WrongPass1!");
+            headers.set("Content-Type", "application/json");
+
+            Map<String, String> changePasswordRequest = Map.of(
+                "oldPassword", "Test1234!",
+                "newPassword", "NewPass123!"
+            );
+            ResponseEntity<ApiResponse<String>> response = testRestTemplate.exchange(
+                ENDPOINT + "/me/password",
+                HttpMethod.PATCH,
+                new HttpEntity<>(changePasswordRequest, headers),
+                new ParameterizedTypeReference<>() {}
+            );
+
+            // assert
+            assertThat(response.getStatusCode()).isEqualTo(HttpStatus.UNAUTHORIZED);
+        }
+
+        @DisplayName("Body의 기존 비밀번호가 일치하지 않으면, 401 Unauthorized를 반환한다.")
+        @Test
+        void returnsUnauthorized_whenOldPasswordInBodyDoesNotMatch() {
+            // arrange - 먼저 회원 가입
+            Map<String, String> signUpRequest = Map.of(
+                "loginId", "testuser",
+                "password", "Test1234!",
+                "name", "홍길동",
+                "birthDate", "19900101",
+                "email", "test@test.co.kr"
+            );
+            testRestTemplate.exchange(ENDPOINT, HttpMethod.POST, new HttpEntity<>(signUpRequest), new ParameterizedTypeReference<ApiResponse<Map<String, String>>>() {});
+
+            // act - 헤더는 맞지만 Body의 oldPassword가 틀림
+            HttpHeaders headers = new HttpHeaders();
+            headers.set("X-Loopers-LoginId", "testuser");
+            headers.set("X-Loopers-LoginPw", "Test1234!");
+            headers.set("Content-Type", "application/json");
+
+            Map<String, String> changePasswordRequest = Map.of(
+                "oldPassword", "WrongPass1!",
+                "newPassword", "NewPass123!"
+            );
+            ResponseEntity<ApiResponse<String>> response = testRestTemplate.exchange(
+                ENDPOINT + "/me/password",
+                HttpMethod.PATCH,
+                new HttpEntity<>(changePasswordRequest, headers),
+                new ParameterizedTypeReference<>() {}
+            );
+
+            // assert
+            assertThat(response.getStatusCode()).isEqualTo(HttpStatus.UNAUTHORIZED);
+        }
+
+        @DisplayName("새 비밀번호가 기존 비밀번호와 같으면, 400 Bad Request를 반환한다.")
+        @Test
+        void returnsBadRequest_whenNewPasswordIsSameAsOld() {
+            // arrange - 먼저 회원 가입
+            Map<String, String> signUpRequest = Map.of(
+                "loginId", "testuser",
+                "password", "Test1234!",
+                "name", "홍길동",
+                "birthDate", "19900101",
+                "email", "test@test.co.kr"
+            );
+            testRestTemplate.exchange(ENDPOINT, HttpMethod.POST, new HttpEntity<>(signUpRequest), new ParameterizedTypeReference<ApiResponse<Map<String, String>>>() {});
+
+            // act - 기존과 동일한 비밀번호로 변경 요청
+            HttpHeaders headers = new HttpHeaders();
+            headers.set("X-Loopers-LoginId", "testuser");
+            headers.set("X-Loopers-LoginPw", "Test1234!");
+            headers.set("Content-Type", "application/json");
+
+            Map<String, String> changePasswordRequest = Map.of(
+                "oldPassword", "Test1234!",
+                "newPassword", "Test1234!"
+            );
+            ResponseEntity<ApiResponse<String>> response = testRestTemplate.exchange(
+                ENDPOINT + "/me/password",
+                HttpMethod.PATCH,
+                new HttpEntity<>(changePasswordRequest, headers),
+                new ParameterizedTypeReference<>() {}
+            );
+
+            // assert
+            assertThat(response.getStatusCode()).isEqualTo(HttpStatus.BAD_REQUEST);
+        }
+    }
+}
diff --git a/build.gradle.kts b/build.gradle.kts
index 9c8490b8..b7f02279 100644
--- a/build.gradle.kts
+++ b/build.gradle.kts
@@ -34,10 +34,15 @@ allprojects {
 }
 
 subprojects {
+    val containerProjects = setOf("apps", "modules", "supports")
+
     apply(plugin = "java")
     apply(plugin = "org.springframework.boot")
     apply(plugin = "io.spring.dependency-management")
-    apply(plugin = "jacoco")
+
+     if (name !in containerProjects) {
+         apply(plugin = "jacoco")
+     }
 
     dependencyManagement {
         imports {
@@ -55,6 +60,8 @@ subprojects {
         // Lombok
         implementation("org.projectlombok:lombok")
         annotationProcessor("org.projectlombok:lombok")
+        // 암호화
+        implementation ("org.springframework.security:spring-security-crypto")
         // Test
         testRuntimeOnly("org.junit.platform:junit-platform-launcher")
         // testcontainers:mysql 이 jdbc 사용함
@@ -85,24 +92,27 @@ subprojects {
         jvmArgs("-Xshare:off")
     }
 
-    tasks.withType<JacocoReport> {
-        mustRunAfter("test")
-        executionData(fileTree(layout.buildDirectory.asFile).include("jacoco/*.exec"))
-        reports {
-            xml.required = true
-            csv.required = false
-            html.required = false
-        }
-        afterEvaluate {
-            classDirectories.setFrom(
-                files(
-                    classDirectories.files.map {
-                        fileTree(it)
-                    },
-                ),
-            )
-        }
-    }
+    // TODO: JDK 24 환경에서 JacocoReport 태스크 생성 오류 발생 - JDK 21로 전환 후 활성화 필요
+    // if (name !in containerProjects) {
+    //     tasks.withType<JacocoReport> {
+    //         mustRunAfter("test")
+    //         executionData(fileTree(layout.buildDirectory.asFile).include("jacoco/*.exec"))
+    //         reports {
+    //             xml.required = true
+    //             csv.required = false
+    //             html.required = false
+    //         }
+    //         afterEvaluate {
+    //             classDirectories.setFrom(
+    //                 files(
+    //                     classDirectories.files.map {
+    //                         fileTree(it)
+    //                     },
+    //                 ),
+    //             )
+    //         }
+    //     }
+    // }
 }
 
 // module-container 는 task 를 실행하지 않도록 한다.
diff --git a/docker/infra-compose.yml b/docker/infra-compose.yml
index 18e5fcf5..6921cb39 100644
--- a/docker/infra-compose.yml
+++ b/docker/infra-compose.yml
@@ -3,7 +3,7 @@ services:
   mysql:
     image: mysql:8.0
     ports:
-      - "3306:3306"
+      - "3307:3306"
     environment:
       - MYSQL_ROOT_PASSWORD=root
       - MYSQL_USER=application
diff --git a/modules/jpa/src/main/resources/jpa.yml b/modules/jpa/src/main/resources/jpa.yml
index 37f4fb1b..8b90b1c7 100644
--- a/modules/jpa/src/main/resources/jpa.yml
+++ b/modules/jpa/src/main/resources/jpa.yml
@@ -42,7 +42,7 @@ spring:
 datasource:
   mysql-jpa:
     main:
-      jdbc-url: jdbc:mysql://localhost:3306/loopers
+      jdbc-url: jdbc:mysql://localhost:3307/loopers
       username: application
       password: application