diff --git a/.gitignore b/.gitignore
index 47e46733..d2f225f8 100644
--- a/.gitignore
+++ b/.gitignore
@@ -41,3 +41,10 @@ out/
 CLAUDE.md
 db_dev.mv.db
 db_dev.trace.db
+
+cookies.txt
+
+.DS_Store
+
+### QueryDSL Q클래스 ###
+**/generated/
\ No newline at end of file
diff --git a/back/.env.default b/back/.env.default
index 47d2f175..da8cf60b 100644
--- a/back/.env.default
+++ b/back/.env.default
@@ -1 +1 @@
-CUSTOM__JWT__SECRET_KEY=NEED_TO_SET
\ No newline at end of file
+CUSTOM__JWT__SECRET_KEY=abcdefghijklmnopqrstuvwxyz0123456789abcdefghijklmnopqrstuvwxyz0123456789abcdefghijklmnopqrstuvwxyz0123456789
diff --git a/back/build.gradle.kts b/back/build.gradle.kts
index 9ba7ee2a..ed959ef9 100644
--- a/back/build.gradle.kts
+++ b/back/build.gradle.kts
@@ -1,10 +1,12 @@
+import org.gradle.kotlin.dsl.implementation
+
 plugins {
 	java
 	id("org.springframework.boot") version "3.5.5"
 	id("io.spring.dependency-management") version "1.1.7"
 }
 
-group = "com.ll"
+group = "com"
 version = "0.0.1-SNAPSHOT"
 description = "back"
 
@@ -25,21 +27,45 @@ repositories {
 }
 
 dependencies {
+	// JWT
 	implementation("io.jsonwebtoken:jjwt-api:0.12.6")
 	runtimeOnly("io.jsonwebtoken:jjwt-impl:0.12.6")
 	runtimeOnly("io.jsonwebtoken:jjwt-jackson:0.12.6")
+
+	// Swagger
 	implementation("org.springdoc:springdoc-openapi-starter-webmvc-ui:2.8.9")
+	implementation("org.springdoc:springdoc-openapi-starter-webmvc-ui:2.8.13")
+
+	// Spring Boot
 	implementation("org.springframework.boot:spring-boot-starter-actuator")
 	implementation("org.springframework.boot:spring-boot-starter-data-jpa")
 	implementation("org.springframework.boot:spring-boot-starter-security")
 	implementation("org.springframework.boot:spring-boot-starter-web")
+	implementation ("org.springframework.boot:spring-boot-starter-data-redis")
+
+	// QueryDSL
+	implementation("com.querydsl:querydsl-jpa:5.0.0:jakarta")
+	annotationProcessor("com.querydsl:querydsl-apt:5.0.0:jakarta")
+	annotationProcessor("jakarta.persistence:jakarta.persistence-api:3.1.0")
+	annotationProcessor("jakarta.annotation:jakarta.annotation-api:2.1.1")
+
+	// Lombok
 	compileOnly("org.projectlombok:lombok")
-	developmentOnly("org.springframework.boot:spring-boot-devtools")
-	runtimeOnly("com.h2database:h2")
 	annotationProcessor("org.projectlombok:lombok")
+
+	// DB
+	runtimeOnly("com.h2database:h2")
+	runtimeOnly("com.mysql:mysql-connector-j")
+
+	// DevTools
+	developmentOnly("org.springframework.boot:spring-boot-devtools")
+
+	// Test
 	testImplementation("org.springframework.boot:spring-boot-starter-test")
 	testImplementation("org.springframework.security:spring-security-test")
 	testRuntimeOnly("org.junit.platform:junit-platform-launcher")
+
+	implementation ("software.amazon.awssdk:s3:2.25.0")
 }
 
 tasks.withType<Test> {
diff --git a/back/src/main/java/com/back/domain/file/controller/VideoController.java b/back/src/main/java/com/back/domain/file/controller/VideoController.java
new file mode 100644
index 00000000..cdbe3a6e
--- /dev/null
+++ b/back/src/main/java/com/back/domain/file/controller/VideoController.java
@@ -0,0 +1,33 @@
+package com.back.domain.file.controller;
+
+import com.back.domain.file.service.VideoService;
+import lombok.RequiredArgsConstructor;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RestController;
+
+import java.net.URL;
+import java.util.List;
+import java.util.Map;
+
+@RestController
+@RequiredArgsConstructor
+public class VideoController {
+
+    private final VideoService videoService;
+
+    // 업로드용 Presigned URL
+    @GetMapping("/videos/upload-url")
+    public URL getUploadUrl(@RequestParam String fileName) {
+        return videoService.generateUploadUrl("test-bucket", fileName);
+    }
+
+    // DASH 스트리밍용 URL
+    @GetMapping("/videos/dash-urls")
+    public Map<String, URL> getDashUrls(
+            @RequestParam String mpdFile,
+            @RequestParam List<String> segmentFiles
+    ) {
+        return videoService.generateDashUrls("test-bucket", mpdFile, segmentFiles);
+    }
+}
\ No newline at end of file
diff --git a/back/src/main/java/com/back/domain/file/entity/Video.java b/back/src/main/java/com/back/domain/file/entity/Video.java
new file mode 100644
index 00000000..d4557dfe
--- /dev/null
+++ b/back/src/main/java/com/back/domain/file/entity/Video.java
@@ -0,0 +1,66 @@
+package com.back.domain.file.entity;
+
+import com.back.global.jpa.BaseEntity;
+import jakarta.persistence.Column;
+import jakarta.persistence.Entity;
+import lombok.AccessLevel;
+import lombok.Builder;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import org.hibernate.annotations.JdbcTypeCode;
+import org.hibernate.type.SqlTypes;
+
+@Getter
+@Entity
+@NoArgsConstructor(access = AccessLevel.PROTECTED)
+public class Video extends BaseEntity {
+    @Column(unique = true)
+    private String uuid;
+
+    @JdbcTypeCode(SqlTypes.JSON)
+    @Column(name = "transcoding_results")
+    private String transcodingResults;
+
+    private String originalPath;
+
+    private Integer views;
+
+    private String originalFileName;
+
+    private Integer duration;
+
+    private Long fileSize;
+
+    @Builder(access = AccessLevel.PRIVATE)
+    private Video(String uuid, String transcodingResults, String originalPath, Integer views, String originalFileName, Integer duration, Long fileSize) {
+        this.uuid = uuid;
+        this.transcodingResults = transcodingResults;
+        this.originalPath = originalPath;
+        this.views = views;
+        this.originalFileName = originalFileName;
+        this.duration = duration;
+        this.fileSize = fileSize;
+    }
+
+    public static Video create(String uuid, String transcodingResults, String originalPath, String originalFileName, Integer duration, Long fileSize) {
+        if (uuid == null || uuid.isBlank()) {
+            throw new IllegalArgumentException("uuid cannot be null or empty");
+        }
+        if (originalPath == null || originalPath.isBlank()) {
+            throw new IllegalArgumentException("originalPath cannot be null or empty");
+        }
+        if (originalFileName == null || originalFileName.isBlank()) {
+            throw new IllegalArgumentException("originalFileName cannot be null or empty");
+        }
+
+        return Video.builder()
+                .uuid(uuid)
+                .transcodingResults(transcodingResults)
+                .originalPath(originalPath)
+                .views(0)
+                .originalFileName(originalFileName)
+                .duration(duration)
+                .fileSize(fileSize)
+                .build();
+    }
+}
diff --git a/back/src/main/java/com/back/domain/file/repository/VideoRepository.java b/back/src/main/java/com/back/domain/file/repository/VideoRepository.java
new file mode 100644
index 00000000..02e6431e
--- /dev/null
+++ b/back/src/main/java/com/back/domain/file/repository/VideoRepository.java
@@ -0,0 +1,12 @@
+package com.back.domain.file.repository;
+
+import com.back.domain.file.entity.Video;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+import java.util.Optional;
+
+@Repository
+public interface VideoRepository extends JpaRepository<Video, Integer> {
+    Optional<Video> findByUuid(String uuid);
+}
diff --git a/back/src/main/java/com/back/domain/file/service/VideoService.java b/back/src/main/java/com/back/domain/file/service/VideoService.java
new file mode 100644
index 00000000..3885f771
--- /dev/null
+++ b/back/src/main/java/com/back/domain/file/service/VideoService.java
@@ -0,0 +1,116 @@
+package com.back.domain.file.service;
+
+import com.back.domain.file.entity.Video;
+import com.back.domain.file.repository.VideoRepository;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+import software.amazon.awssdk.services.s3.S3Client;
+import software.amazon.awssdk.services.s3.model.GetObjectRequest;
+import software.amazon.awssdk.services.s3.model.HeadObjectRequest;
+import software.amazon.awssdk.services.s3.model.PutObjectRequest;
+import software.amazon.awssdk.services.s3.model.S3Exception;
+import software.amazon.awssdk.services.s3.presigner.S3Presigner;
+import software.amazon.awssdk.services.s3.presigner.model.PresignedGetObjectRequest;
+import software.amazon.awssdk.services.s3.presigner.model.PresignedPutObjectRequest;
+
+import java.net.URL;
+import java.time.Duration;
+import java.util.List;
+import java.util.Map;
+import java.util.NoSuchElementException;
+import java.util.UUID;
+import java.util.stream.Collectors;
+
+@Service
+@RequiredArgsConstructor
+public class VideoService {
+    private final VideoRepository videoRepository;
+    private final S3Presigner presigner;
+    private final S3Client s3Client;
+
+    public Video createVideo(String transcodingStatus, String originalPath, String originalFilename, Integer duration, Long fileSize) {
+        String uuid = UUID.randomUUID().toString();
+        Video video = Video.create(uuid, transcodingStatus, originalPath, originalFilename, duration, fileSize);
+        return videoRepository.save(video);
+    }
+
+    public Video getNewsByUuid(String uuid) {
+        return videoRepository.findByUuid(uuid)
+                .orElseThrow(() -> new NoSuchElementException("존재하지 않는 비디오입니다."));
+    }
+
+    //HeadObjectRequest 고려
+    public URL generateUploadUrl(String bucket, String objectKey) {
+        if(!isExist(bucket, objectKey)){
+            throw new NoSuchElementException("요청한 파일이 존재하지 않습니다: " + objectKey);
+        }
+
+        PutObjectRequest request = PutObjectRequest.builder()
+                .bucket(bucket)
+                .key(objectKey)
+                .build();
+
+        PresignedPutObjectRequest presignedRequest =
+                presigner.presignPutObject(builder -> builder
+                        .signatureDuration(Duration.ofMinutes(30))
+                        .putObjectRequest(request));
+
+        URL url = presignedRequest.url();
+        if (url == null) {
+            throw new RuntimeException("Presigned URL 생성 실패");
+        }
+
+        return url;
+    }
+
+    public URL generateDownloadUrl(String bucket, String objectKey) {
+        if(!isExist(bucket, objectKey)){
+            throw new NoSuchElementException("요청한 파일이 존재하지 않습니다: " + objectKey);
+        }
+
+        GetObjectRequest request = GetObjectRequest.builder()
+                .bucket(bucket)
+                .key(objectKey)
+                .build();
+
+        PresignedGetObjectRequest presignedRequest =
+                presigner.presignGetObject(builder -> builder
+                        .signatureDuration(Duration.ofHours(1))
+                        .getObjectRequest(request));
+
+        URL url = presignedRequest.url();
+        if (url == null) {
+            throw new RuntimeException("Presigned URL 생성 실패");
+        }
+
+        return url;
+    }
+
+    // DASH용 인덱스 + 세그먼트 URL 발급
+    public Map<String, URL> generateDashUrls(String bucket, String mpdFile, List<String> segmentFiles) {
+        // MPD 파일 URL
+        URL mpdUrl = generateDownloadUrl(bucket, mpdFile);
+
+        // 각 세그먼트 파일 URL
+        Map<String, URL> segmentUrls = segmentFiles.stream()
+                .collect(Collectors.toMap(f -> f, f -> generateDownloadUrl(bucket, f)));
+
+        // MPD 포함 합쳐서 반환
+        segmentUrls.put("mpd", mpdUrl);
+        return segmentUrls;
+    }
+
+    public boolean isExist(String bucket, String objectKey) {
+        try {
+            HeadObjectRequest headRequest = HeadObjectRequest.builder()
+                    .bucket(bucket)
+                    .key(objectKey)
+                    .build();
+
+            s3Client.headObject(headRequest);
+            return true;
+        } catch (S3Exception e) {
+            return false;
+        }
+    }
+}
diff --git a/back/src/main/java/com/back/domain/job/job/entity/Job.java b/back/src/main/java/com/back/domain/job/job/entity/Job.java
new file mode 100644
index 00000000..a4e04d32
--- /dev/null
+++ b/back/src/main/java/com/back/domain/job/job/entity/Job.java
@@ -0,0 +1,34 @@
+package com.back.domain.job.job.entity;
+
+import com.back.global.jpa.BaseEntity;
+import jakarta.persistence.*;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+import java.util.List;
+
+@Entity
+@Table(name = "job")
+@Getter @Setter
+@NoArgsConstructor
+public class Job extends BaseEntity {
+    @Column(name = "name", nullable = false, unique = true)
+    private String name;
+
+    @Column(name = "description", columnDefinition = "TEXT")
+    private String description;
+
+    @OneToMany(mappedBy = "job", cascade = CascadeType.ALL)
+    private List<JobAlias> aliases;
+
+    public Job(String name, String description) {
+        this.name = name;
+        this.description = description;
+    }
+
+    public void addAlias(JobAlias alias) {
+        aliases.add(alias);
+        alias.setJob(this);
+    }
+}
diff --git a/back/src/main/java/com/back/domain/job/job/entity/JobAlias.java b/back/src/main/java/com/back/domain/job/job/entity/JobAlias.java
new file mode 100644
index 00000000..25997c3b
--- /dev/null
+++ b/back/src/main/java/com/back/domain/job/job/entity/JobAlias.java
@@ -0,0 +1,25 @@
+package com.back.domain.job.job.entity;
+
+import com.back.global.jpa.BaseEntity;
+import jakarta.persistence.*;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Entity
+@Table(name = "job_alias")
+@Getter @Setter
+@NoArgsConstructor
+public class JobAlias extends BaseEntity {
+    @Column(name = "name", nullable = false, unique = true)
+    private String name; // 사용자가 입력한 직군 이름
+
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "job_id")
+    private Job job; // 표준 Job 연결 (NULL이면 pending 상태)
+
+    public JobAlias(String name) {
+        this.name = name;
+        this.job = null; // 기본적으로 연결된 Job이 없음 (pending 상태)
+    }
+}
diff --git a/back/src/main/java/com/back/domain/job/job/repository/JobAliasRepository.java b/back/src/main/java/com/back/domain/job/job/repository/JobAliasRepository.java
new file mode 100644
index 00000000..63a2f4e9
--- /dev/null
+++ b/back/src/main/java/com/back/domain/job/job/repository/JobAliasRepository.java
@@ -0,0 +1,13 @@
+package com.back.domain.job.job.repository;
+
+import com.back.domain.job.job.entity.JobAlias;
+import org.springframework.data.jpa.repository.JpaRepository;
+
+import java.util.List;
+import java.util.Optional;
+
+public interface JobAliasRepository extends JpaRepository<JobAlias, Long> {
+    Optional<JobAlias> findByName(String name);
+    Optional<JobAlias> findByNameIgnoreCase(String name);
+    List<JobAlias> findByJobIsNull(); // pending 상태인 alias 조회
+}
diff --git a/back/src/main/java/com/back/domain/job/job/repository/JobRepository.java b/back/src/main/java/com/back/domain/job/job/repository/JobRepository.java
new file mode 100644
index 00000000..43f1565b
--- /dev/null
+++ b/back/src/main/java/com/back/domain/job/job/repository/JobRepository.java
@@ -0,0 +1,10 @@
+package com.back.domain.job.job.repository;
+
+import com.back.domain.job.job.entity.Job;
+import org.springframework.data.jpa.repository.JpaRepository;
+
+import java.util.Optional;
+
+public interface JobRepository extends JpaRepository<Job, Long> {
+    Optional<Job> findByName(String name);
+}
diff --git a/back/src/main/java/com/back/domain/job/job/service/JobService.java b/back/src/main/java/com/back/domain/job/job/service/JobService.java
new file mode 100644
index 00000000..0a6b8614
--- /dev/null
+++ b/back/src/main/java/com/back/domain/job/job/service/JobService.java
@@ -0,0 +1,34 @@
+package com.back.domain.job.job.service;
+
+import com.back.domain.job.job.entity.Job;
+import com.back.domain.job.job.entity.JobAlias;
+import com.back.domain.job.job.repository.JobAliasRepository;
+import com.back.domain.job.job.repository.JobRepository;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+@Service
+@RequiredArgsConstructor
+@Transactional(readOnly = true)
+public class JobService {
+    private final JobRepository jobRepository;
+    private final JobAliasRepository jobAliasRepository;
+
+    public long count() {
+        return jobRepository.count();
+    }
+
+    @Transactional
+    public Job create(String name, String description) {
+        Job job = new Job(name, description);
+        return jobRepository.save(job);
+    }
+
+    @Transactional
+    public JobAlias createAlias(Job job, String aliasName) {
+        JobAlias alias = new JobAlias(aliasName);
+        alias.setJob(job);
+        return jobAliasRepository.save(alias);
+    }
+}
diff --git a/back/src/main/java/com/back/domain/member/member/controller/MemberController.java b/back/src/main/java/com/back/domain/member/member/controller/MemberController.java
index 0ae40cca..77f03baa 100644
--- a/back/src/main/java/com/back/domain/member/member/controller/MemberController.java
+++ b/back/src/main/java/com/back/domain/member/member/controller/MemberController.java
@@ -1,76 +1,116 @@
 package com.back.domain.member.member.controller;
 
 import com.back.domain.member.member.dto.LoginRequest;
-import com.back.domain.member.member.dto.SignupRequest;
+import com.back.domain.member.member.dto.MenteeSignupRequest;
+import com.back.domain.member.member.dto.MentorVerificationRequest;
+import com.back.domain.member.member.dto.MentorSignupVerifyRequest;
 import com.back.domain.member.member.entity.Member;
 import com.back.domain.member.member.service.MemberService;
 import com.back.global.rq.Rq;
 import com.back.global.rsData.RsData;
+import com.back.domain.member.member.verification.EmailVerificationService;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.tags.Tag;
 import lombok.RequiredArgsConstructor;
 import org.springframework.web.bind.annotation.*;
 
-import java.util.Optional;
 
 @RestController
 @RequestMapping("/auth")
 @RequiredArgsConstructor
-public class MemberController {
+@Tag(name = "MemberController", description = "회원 컨트롤러")
+public class  MemberController {
     private final MemberService memberService;
     private final Rq rq;
+    private final EmailVerificationService emailVerificationService;
 
-    @PostMapping("/signup")
-    public RsData<Void> signup(@RequestBody SignupRequest request) {
-        try {
-            Member member = memberService.join(
-                request.getEmail(), 
-                request.getName(), 
-                request.getPassword(), 
-                request.getRole()
-            );
-            return new RsData<>("200-1", "회원가입 성공");
-        } catch (IllegalArgumentException e) {
-            return new RsData<>("400-1", e.getMessage());
-        }
+    @PostMapping("/signup/mentee")
+    @Operation(summary = "멘티 회원가입")
+    public RsData<Void> signupMentee(@RequestBody MenteeSignupRequest request) {
+        memberService.joinMentee(
+            request.email(),
+            request.name(),
+            request.nickname(),
+            request.password(),
+            request.interestedField()
+        );
+        return new RsData<>("200-1", "멘티 회원가입 성공");
+    }
+
+    @PostMapping("/signup/mentor/send-verification")
+    @Operation(summary = "멘토 회원가입 인증번호 발송")
+    public RsData<Void> sendMentorVerification(@RequestBody MentorVerificationRequest request) {
+        emailVerificationService.generateAndSendCode(request.email());
+        return new RsData<>("200-2", "인증번호가 발송되었습니다.");
+    }
+
+    @PostMapping("/signup/mentor")
+    @Operation(summary = "멘토 회원가입 (인증번호 확인)")
+    public RsData<Void> signupMentor(@RequestBody MentorSignupVerifyRequest request) {
+        // 인증번호 검증
+        emailVerificationService.verifyCode(request.email(), request.verificationCode());
+
+        // 회원가입 진행
+        memberService.joinMentor(
+            request.email(),
+            request.name(),
+            request.nickname(),
+            request.password(),
+            request.career(),
+            request.careerYears()
+        );
+        return new RsData<>("200-3", "멘토 회원가입 성공");
     }
 
     @PostMapping("/login")
     public RsData<Void> login(@RequestBody LoginRequest request) {
-        String email = request.getEmail();
-        String password = request.getPassword();
-        Optional<Member> memberOpt = memberService.findByEmail(email);
-        
-        if (memberOpt.isEmpty()) {
-            return new RsData<>("400-1", "존재하지 않는 이메일입니다.");
-        }
-
-        Member member = memberOpt.get();
-        
-        // TODO: 비밀번호 암호화 후 검증 로직 추가 필요
-        if (!member.getPassword().equals(password)) {
-            return new RsData<>("400-1", "비밀번호가 일치하지 않습니다.");
-        }
+        Member member = memberService.login(request.email(), request.password());
 
         // JWT 토큰 생성 후 쿠키에 저장
         String accessToken = memberService.genAccessToken(member);
+        String refreshToken = memberService.genRefreshToken(member);
+
         rq.setCookie("accessToken", accessToken);
+        rq.setCookie("refreshToken", refreshToken);
 
-        return new RsData<>("200-1", "로그인 성공");
+        return new RsData<>("200-4", "로그인 성공");
     }
 
     @PostMapping("/logout")
     public RsData<Void> logout() {
         rq.deleteCookie("accessToken");
-        return new RsData<>("200-1", "로그아웃 성공");
+        rq.deleteCookie("refreshToken");
+        return new RsData<>("200-8", "로그아웃 성공");
     }
 
     @GetMapping("/me")
     public RsData<Member> me() {
-        Member actor = rq.getActor();
-        
-        if (actor == null) {
-            return new RsData<>("401-1", "로그인이 필요합니다.");
-        }
+        Member actor = memberService.getCurrentUser(rq.getActor());
+        return new RsData<>("200-5", "사용자 정보 조회 성공", actor);
+    }
+
+    @PostMapping("/refresh")
+    public RsData<Void> refresh() {
+        String refreshToken = rq.getCookieValue("refreshToken", "");
+        Member member = memberService.refreshAccessToken(refreshToken);
+
+        // 새로운 access token 생성
+        String newAccessToken = memberService.genAccessToken(member);
+        rq.setCookie("accessToken", newAccessToken);
+
+        return new RsData<>("200-6", "토큰 갱신 성공");
+    }
+
+    @DeleteMapping("/me")
+    @Operation(summary = "회원 탈퇴")
+    public RsData<Void> deleteMember() {
+        Member currentUser = rq.getActor();
+        memberService.deleteMember(currentUser);
+
+        // 탈퇴 후 쿠키 삭제
+        rq.deleteCookie("accessToken");
+        rq.deleteCookie("refreshToken");
 
-        return new RsData<>("200-1", "사용자 정보 조회 성공", actor);
+        return new RsData<>("200-7", "회원 탈퇴가 완료되었습니다.");
     }
 }
diff --git a/back/src/main/java/com/back/domain/member/member/dto/LoginRequest.java b/back/src/main/java/com/back/domain/member/member/dto/LoginRequest.java
index 1132ecb7..ddd0c162 100644
--- a/back/src/main/java/com/back/domain/member/member/dto/LoginRequest.java
+++ b/back/src/main/java/com/back/domain/member/member/dto/LoginRequest.java
@@ -1,9 +1,7 @@
 package com.back.domain.member.member.dto;
 
-import lombok.Data;
-
-@Data
-public class LoginRequest {
-    private String email;
-    private String password;
+public record LoginRequest(
+    String email,
+    String password
+) {
 }
\ No newline at end of file
diff --git a/back/src/main/java/com/back/domain/member/member/dto/MenteeSignupRequest.java b/back/src/main/java/com/back/domain/member/member/dto/MenteeSignupRequest.java
new file mode 100644
index 00000000..c509e5ce
--- /dev/null
+++ b/back/src/main/java/com/back/domain/member/member/dto/MenteeSignupRequest.java
@@ -0,0 +1,10 @@
+package com.back.domain.member.member.dto;
+
+public record MenteeSignupRequest(
+    String email,
+    String password,
+    String name,
+    String nickname,
+    String interestedField
+) {
+}
\ No newline at end of file
diff --git a/back/src/main/java/com/back/domain/member/member/dto/MentorSignupRequest.java b/back/src/main/java/com/back/domain/member/member/dto/MentorSignupRequest.java
new file mode 100644
index 00000000..9c219483
--- /dev/null
+++ b/back/src/main/java/com/back/domain/member/member/dto/MentorSignupRequest.java
@@ -0,0 +1,11 @@
+package com.back.domain.member.member.dto;
+
+public record MentorSignupRequest(
+    String email,
+    String password,
+    String name,
+    String nickname,
+    String career,
+    Integer careerYears
+) {
+}
\ No newline at end of file
diff --git a/back/src/main/java/com/back/domain/member/member/dto/MentorSignupVerifyRequest.java b/back/src/main/java/com/back/domain/member/member/dto/MentorSignupVerifyRequest.java
new file mode 100644
index 00000000..88f05b5e
--- /dev/null
+++ b/back/src/main/java/com/back/domain/member/member/dto/MentorSignupVerifyRequest.java
@@ -0,0 +1,12 @@
+package com.back.domain.member.member.dto;
+
+public record MentorSignupVerifyRequest(
+    String email,
+    String verificationCode,
+    String password,
+    String name,
+    String nickname,
+    String career,
+    Integer careerYears
+) {
+}
\ No newline at end of file
diff --git a/back/src/main/java/com/back/domain/member/member/dto/MentorVerificationRequest.java b/back/src/main/java/com/back/domain/member/member/dto/MentorVerificationRequest.java
new file mode 100644
index 00000000..3a7ce1ff
--- /dev/null
+++ b/back/src/main/java/com/back/domain/member/member/dto/MentorVerificationRequest.java
@@ -0,0 +1,6 @@
+package com.back.domain.member.member.dto;
+
+public record MentorVerificationRequest(
+    String email
+) {
+}
\ No newline at end of file
diff --git a/back/src/main/java/com/back/domain/member/member/dto/SignupRequest.java b/back/src/main/java/com/back/domain/member/member/dto/SignupRequest.java
deleted file mode 100644
index 9a356d2f..00000000
--- a/back/src/main/java/com/back/domain/member/member/dto/SignupRequest.java
+++ /dev/null
@@ -1,12 +0,0 @@
-package com.back.domain.member.member.dto;
-
-import com.back.domain.member.member.entity.Member;
-import lombok.Data;
-
-@Data
-public class SignupRequest {
-    private String email;
-    private String password;
-    private String name;
-    private Member.Role role;
-}
\ No newline at end of file
diff --git a/back/src/main/java/com/back/domain/member/member/entity/Member.java b/back/src/main/java/com/back/domain/member/member/entity/Member.java
index b4098964..739588ab 100644
--- a/back/src/main/java/com/back/domain/member/member/entity/Member.java
+++ b/back/src/main/java/com/back/domain/member/member/entity/Member.java
@@ -18,6 +18,9 @@ public class Member extends BaseEntity {
     @Column(nullable = false)
     private String name;
 
+    @Column(unique = true, nullable = false)
+    private String nickname;
+
     @Column(nullable = false)
     private String password;
 
@@ -29,16 +32,19 @@ public enum Role {
         MENTOR, MENTEE, ADMIN
     }
 
-    public Member(String email, String password, String name, Role role) {
+    public Member(String email, String password, String name, String nickname, Role role) {
         this.email = email;
         this.password = password;
         this.name = name;
+        this.nickname = nickname;
         this.role = role;
     }
 
-    public Member(int id, String email, String name) {
+    public Member(Long id, String email, String name, String nickname, Role role) {
         this.setId(id);
         this.email = email;
         this.name = name;
+        this.nickname = nickname;
+        this.role = role;
     }
 }
diff --git a/back/src/main/java/com/back/domain/member/member/repository/MemberRepository.java b/back/src/main/java/com/back/domain/member/member/repository/MemberRepository.java
index ece6c652..3d8fef24 100644
--- a/back/src/main/java/com/back/domain/member/member/repository/MemberRepository.java
+++ b/back/src/main/java/com/back/domain/member/member/repository/MemberRepository.java
@@ -5,7 +5,7 @@
 
 import java.util.Optional;
 
-public interface MemberRepository extends JpaRepository<Member, Integer> {
+public interface MemberRepository extends JpaRepository<Member, Long> {
     Optional<Member> findByEmail(String email);
-
+    Optional<Member> findByNickname(String nickname);
 }
diff --git a/back/src/main/java/com/back/domain/member/member/service/AuthTokenService.java b/back/src/main/java/com/back/domain/member/member/service/AuthTokenService.java
index d831d2b4..7dfeafe1 100644
--- a/back/src/main/java/com/back/domain/member/member/service/AuthTokenService.java
+++ b/back/src/main/java/com/back/domain/member/member/service/AuthTokenService.java
@@ -15,15 +15,19 @@ public class AuthTokenService {
     @Value("${custom.accessToken.expirationSeconds}")
     private int accessTokenExpirationSeconds;
 
-    String genAccessToken(Member member) {
+    @Value("${custom.refreshToken.expirationSeconds}")
+    private int refreshTokenExpirationSeconds;
+
+    public String genAccessToken(Member member) {
         String email = member.getEmail();
         String name = member.getName();
+        String nickname = member.getNickname();
         String role = member.getRole().name();
 
         return Ut.jwt.toString(
                 jwtSecretKey,
                 accessTokenExpirationSeconds,
-                Map.of("email", email, "name", name, "role", role)
+                Map.of("email", email, "name", name, "nickname", nickname, "role", role)
         );
     }
 
@@ -33,8 +37,33 @@ Map<String, Object> payload(String accessToken) {
 
         String email = (String) parsedPayload.get("email");
         String name = (String) parsedPayload.get("name");
+        String nickname = (String) parsedPayload.get("nickname");
         String role = (String) parsedPayload.get("role");
 
-        return Map.of("email", email, "name", name, "role", role);
+        return Map.of("email", email, "name", name, "nickname", nickname, "role", role);
+    }
+
+    public String genRefreshToken(Member member) {
+        String email = member.getEmail();
+        String name = member.getName();
+        String nickname = member.getNickname();
+        String role = member.getRole().name();
+
+        return Ut.jwt.toString(
+                jwtSecretKey,
+                refreshTokenExpirationSeconds,
+                Map.of("email", email, "name", name, "nickname", nickname, "role", role, "type", "refresh")
+        );
+    }
+
+    public boolean isRefreshToken(String token) {
+        Map<String, Object> payload = Ut.jwt.payload(jwtSecretKey, token);
+        if (payload == null) return false;
+
+        return "refresh".equals(payload.get("type"));
+    }
+
+    public boolean isValidToken(String token) {
+        return Ut.jwt.payload(jwtSecretKey, token) != null;
     }
 }
\ No newline at end of file
diff --git a/back/src/main/java/com/back/domain/member/member/service/MemberService.java b/back/src/main/java/com/back/domain/member/member/service/MemberService.java
index 5238a933..a8d2d620 100644
--- a/back/src/main/java/com/back/domain/member/member/service/MemberService.java
+++ b/back/src/main/java/com/back/domain/member/member/service/MemberService.java
@@ -2,8 +2,15 @@
 
 import com.back.domain.member.member.entity.Member;
 import com.back.domain.member.member.repository.MemberRepository;
+import com.back.domain.member.mentee.entity.Mentee;
+import com.back.domain.member.mentee.repository.MenteeRepository;
+import com.back.domain.member.mentor.entity.Mentor;
+import com.back.domain.member.mentor.repository.MentorRepository;
+import com.back.global.exception.ServiceException;
 import lombok.RequiredArgsConstructor;
+import org.springframework.security.crypto.password.PasswordEncoder;
 import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
 
 import java.util.Map;
 import java.util.Optional;
@@ -13,17 +20,56 @@
 public class MemberService {
     private final MemberRepository memberRepository;
     private final AuthTokenService authTokenService;
+    private final MentorRepository mentorRepository;
+    private final MenteeRepository menteeRepository;
+    private final PasswordEncoder passwordEncoder;
 
-    public Member join(String email, String name, String password, Member.Role role) {
+    @Transactional
+    public Member joinMentee(String email, String name, String nickname, String password, String interestedField) {
         memberRepository.findByEmail(email).ifPresent(
                 member -> {
-                    throw new IllegalArgumentException("이미 존재하는 이메일입니다.");
+                    throw new ServiceException("400-1", "이미 존재하는 이메일입니다.");
                 }
         );
 
-        Member member = new Member(email, password, name, role);
+        memberRepository.findByNickname(nickname).ifPresent(
+                member -> {
+                    throw new ServiceException("400-3", "이미 존재하는 닉네임입니다.");
+                }
+        );
 
-        return memberRepository.save(member);
+        Member member = new Member(email, passwordEncoder.encode(password), name, nickname, Member.Role.MENTEE);
+        Member savedMember = memberRepository.save(member);
+
+        // TODO: interestedField를 jobId로 매핑하는 로직 필요
+        Mentee mentee = new Mentee(savedMember, null);
+        menteeRepository.save(mentee);
+
+        return savedMember;
+    }
+
+    @Transactional
+    public Member joinMentor(String email, String name, String nickname, String password, String career, Integer careerYears) {
+        memberRepository.findByEmail(email).ifPresent(
+                member -> {
+                    throw new ServiceException("400-2", "이미 존재하는 이메일입니다.");
+                }
+        );
+
+        memberRepository.findByNickname(nickname).ifPresent(
+                member -> {
+                    throw new ServiceException("400-4", "이미 존재하는 닉네임입니다.");
+                }
+        );
+
+        Member member = new Member(email, passwordEncoder.encode(password), name, nickname, Member.Role.MENTOR);
+        Member savedMember = memberRepository.save(member);
+
+        // TODO: career를 jobId로 매핑하는 로직 필요
+        Mentor mentor = new Mentor(savedMember, null, null, careerYears);
+        mentorRepository.save(mentor);
+
+        return savedMember;
     }
 
     public Optional<Member> findByEmail(String email) {
@@ -37,4 +83,78 @@ public String genAccessToken(Member member) {
     public Map<String, Object> payload(String accessToken) {
         return authTokenService.payload(accessToken);
     }
+
+    public String genRefreshToken(Member member) {
+        return authTokenService.genRefreshToken(member);
+    }
+
+    public boolean isValidToken(String token) {
+        return authTokenService.isValidToken(token);
+    }
+
+    @Transactional
+    public void deleteMember(Member currentUser) {
+        if (currentUser == null) {
+            throw new ServiceException("401-1", "로그인이 필요합니다.");
+        }
+
+        Member member = memberRepository.findById(currentUser.getId())
+                .orElseThrow(() -> new ServiceException("404-1", "존재하지 않는 회원입니다."));
+
+        // 관련 엔티티들 먼저 삭제
+        menteeRepository.findByMemberId(member.getId()).ifPresent(menteeRepository::delete);
+        mentorRepository.findByMemberId(member.getId()).ifPresent(mentorRepository::delete);
+
+        memberRepository.delete(member);
+    }
+
+    public boolean isRefreshToken(String token) {
+        return authTokenService.isRefreshToken(token);
+    }
+
+    public void checkPassword(Member member, String password) {
+        if (!passwordEncoder.matches(password, member.getPassword()))
+            throw new ServiceException("401-1", "비밀번호가 일치하지 않습니다.");
+    }
+
+    public Member login(String email, String password) {
+        Member member = memberRepository.findByEmail(email)
+                .orElseThrow(() -> new ServiceException("400-3", "존재하지 않는 이메일입니다."));
+
+        checkPassword(member, password);
+        return member;
+    }
+
+    public Member getCurrentUser(Member actor) {
+        if (actor == null) {
+            throw new ServiceException("401-1", "로그인이 필요합니다.");
+        }
+        return actor;
+    }
+
+    public Member refreshAccessToken(String refreshToken) {
+        if (refreshToken.isBlank()) {
+            throw new ServiceException("401-1", "Refresh token이 없습니다.");
+        }
+
+        // Refresh token 유효성 검증
+        if (!isValidToken(refreshToken)) {
+            throw new ServiceException("401-2", "유효하지 않은 refresh token입니다.");
+        }
+
+        // Refresh token인지 확인
+        if (!isRefreshToken(refreshToken)) {
+            throw new ServiceException("401-3", "Access token으로는 갱신할 수 없습니다.");
+        }
+
+        // Refresh token에서 사용자 정보 추출
+        Map<String, Object> payload = payload(refreshToken);
+        if (payload == null) {
+            throw new ServiceException("401-4", "토큰에서 사용자 정보를 추출할 수 없습니다.");
+        }
+
+        String email = (String) payload.get("email");
+        return memberRepository.findByEmail(email)
+                .orElseThrow(() -> new ServiceException("401-5", "존재하지 않는 사용자입니다."));
+    }
 }
diff --git a/back/src/main/java/com/back/domain/member/member/verification/EmailVerificationService.java b/back/src/main/java/com/back/domain/member/member/verification/EmailVerificationService.java
new file mode 100644
index 00000000..ce98c1d4
--- /dev/null
+++ b/back/src/main/java/com/back/domain/member/member/verification/EmailVerificationService.java
@@ -0,0 +1,48 @@
+package com.back.domain.member.member.verification;
+
+import com.back.global.exception.ServiceException;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+
+import java.security.SecureRandom;
+import java.time.Duration;
+import java.util.Optional;
+
+@Service
+@RequiredArgsConstructor
+@Slf4j
+public class EmailVerificationService {
+    private final VerificationCodeStore codeStore;
+    private static final Duration CODE_TTL = Duration.ofMinutes(5);
+    private static final SecureRandom random = new SecureRandom();
+
+    public String generateAndSendCode(String email) {
+        // 6자리 랜덤 코드 생성
+        String code = String.format("%06d", random.nextInt(1000000));
+
+        // 저장
+        codeStore.saveCode(email, code, CODE_TTL);
+
+        // TODO: 실제 이메일 발송 로직 추가 (JavaMailSender)
+        log.info("Generated verification code for {}: {}", email, code);
+
+        return code; // 테스트용으로 반환 (실제로는 이메일로만 전송)
+    }
+
+    public void verifyCode(String email, String inputCode) {
+        Optional<String> storedCode = codeStore.getCode(email);
+
+        if (storedCode.isEmpty()) {
+            throw new ServiceException("400-1", "인증번호가 존재하지 않거나 만료되었습니다.");
+        }
+
+        if (!storedCode.get().equals(inputCode)) {
+            throw new ServiceException("400-2", "인증번호가 일치하지 않습니다.");
+        }
+
+        // 인증 성공 시 코드 삭제
+        codeStore.deleteCode(email);
+        log.info("Email verification successful for: {}", email);
+    }
+}
\ No newline at end of file
diff --git a/back/src/main/java/com/back/domain/member/member/verification/InMemoryVerificationCodeStore.java b/back/src/main/java/com/back/domain/member/member/verification/InMemoryVerificationCodeStore.java
new file mode 100644
index 00000000..d9b45b3b
--- /dev/null
+++ b/back/src/main/java/com/back/domain/member/member/verification/InMemoryVerificationCodeStore.java
@@ -0,0 +1,56 @@
+package com.back.domain.member.member.verification;
+
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.context.annotation.Profile;
+import org.springframework.scheduling.annotation.Scheduled;
+import org.springframework.stereotype.Component;
+
+import java.time.Duration;
+import java.time.LocalDateTime;
+import java.util.Map;
+import java.util.Optional;
+import java.util.concurrent.ConcurrentHashMap;
+
+@Component
+@Profile({"test", "dev"})
+@Slf4j
+public class InMemoryVerificationCodeStore implements VerificationCodeStore {
+    private final Map<String, CodeData> store = new ConcurrentHashMap<>();
+
+    @Override
+    public void saveCode(String email, String code, Duration ttl) {
+        LocalDateTime expiresAt = LocalDateTime.now().plus(ttl);
+        store.put(email, new CodeData(code, expiresAt));
+        log.debug("Saved verification code for email: {}", email);
+    }
+
+    @Override
+    public Optional<String> getCode(String email) {
+        CodeData data = store.get(email);
+        if (data == null) {
+            return Optional.empty();
+        }
+
+        if (data.expiresAt.isBefore(LocalDateTime.now())) {
+            store.remove(email);
+            log.debug("Verification code expired for email: {}", email);
+            return Optional.empty();
+        }
+
+        return Optional.of(data.code);
+    }
+
+    @Override
+    public void deleteCode(String email) {
+        store.remove(email);
+        log.debug("Deleted verification code for email: {}", email);
+    }
+
+    @Scheduled(fixedRate = 60000) // 1분마다 만료된 코드 정리
+    public void cleanupExpiredCodes() {
+        LocalDateTime now = LocalDateTime.now();
+        store.entrySet().removeIf(entry -> entry.getValue().expiresAt.isBefore(now));
+    }
+
+    private record CodeData(String code, LocalDateTime expiresAt) {}
+}
\ No newline at end of file
diff --git a/back/src/main/java/com/back/domain/member/member/verification/RedisVerificationCodeStore.java b/back/src/main/java/com/back/domain/member/member/verification/RedisVerificationCodeStore.java
new file mode 100644
index 00000000..20977709
--- /dev/null
+++ b/back/src/main/java/com/back/domain/member/member/verification/RedisVerificationCodeStore.java
@@ -0,0 +1,39 @@
+package com.back.domain.member.member.verification;
+
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
+import org.springframework.context.annotation.Profile;
+import org.springframework.data.redis.core.RedisTemplate;
+import org.springframework.stereotype.Component;
+
+import java.time.Duration;
+import java.util.Optional;
+
+@Component
+@Profile("prod")
+@ConditionalOnProperty(name = "spring.data.redis.host")
+@RequiredArgsConstructor
+@Slf4j
+public class RedisVerificationCodeStore implements VerificationCodeStore {
+    private final RedisTemplate<String, String> redisTemplate;
+
+    @Override
+    public void saveCode(String email, String code, Duration ttl) {
+        String key = "verification:" + email;
+        redisTemplate.opsForValue().set(key, code, ttl);
+    }
+
+    @Override
+    public Optional<String> getCode(String email) {
+        String key = "verification:" + email;
+        String code = redisTemplate.opsForValue().get(key);
+        return Optional.ofNullable(code);
+    }
+
+    @Override
+    public void deleteCode(String email) {
+        String key = "verification:" + email;
+        redisTemplate.delete(key);
+    }
+}
\ No newline at end of file
diff --git a/back/src/main/java/com/back/domain/member/member/verification/VerificationCodeStore.java b/back/src/main/java/com/back/domain/member/member/verification/VerificationCodeStore.java
new file mode 100644
index 00000000..e4e1a8ab
--- /dev/null
+++ b/back/src/main/java/com/back/domain/member/member/verification/VerificationCodeStore.java
@@ -0,0 +1,10 @@
+package com.back.domain.member.member.verification;
+
+import java.time.Duration;
+import java.util.Optional;
+
+public interface VerificationCodeStore {
+    void saveCode(String email, String code, Duration ttl);
+    Optional<String> getCode(String email);
+    void deleteCode(String email);
+}
\ No newline at end of file
diff --git a/back/src/main/java/com/back/domain/member/mentee/entity/Mentee.java b/back/src/main/java/com/back/domain/member/mentee/entity/Mentee.java
new file mode 100644
index 00000000..d72b068c
--- /dev/null
+++ b/back/src/main/java/com/back/domain/member/mentee/entity/Mentee.java
@@ -0,0 +1,26 @@
+package com.back.domain.member.mentee.entity;
+
+import com.back.domain.member.member.entity.Member;
+import com.back.global.jpa.BaseEntity;
+import jakarta.persistence.*;
+import lombok.Builder;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+
+@Entity
+@Getter
+@NoArgsConstructor
+public class Mentee extends BaseEntity {
+    @OneToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "member_id", nullable = false)
+    private Member member;
+
+    @Column(name = "job_id")
+    private Long jobId;
+
+    @Builder
+    public Mentee(Member member, Long jobId) {
+        this.member = member;
+        this.jobId = jobId;
+    }
+}
diff --git a/back/src/main/java/com/back/domain/member/mentee/repository/MenteeRepository.java b/back/src/main/java/com/back/domain/member/mentee/repository/MenteeRepository.java
new file mode 100644
index 00000000..b66d56ed
--- /dev/null
+++ b/back/src/main/java/com/back/domain/member/mentee/repository/MenteeRepository.java
@@ -0,0 +1,10 @@
+package com.back.domain.member.mentee.repository;
+
+import com.back.domain.member.mentee.entity.Mentee;
+import org.springframework.data.jpa.repository.JpaRepository;
+
+import java.util.Optional;
+
+public interface MenteeRepository extends JpaRepository<Mentee, Long> {
+    Optional<Mentee> findByMemberId(Long memberId);
+}
\ No newline at end of file
diff --git a/back/src/main/java/com/back/domain/member/mentor/dto/MentorDto.java b/back/src/main/java/com/back/domain/member/mentor/dto/MentorDto.java
new file mode 100644
index 00000000..ecd7a2ef
--- /dev/null
+++ b/back/src/main/java/com/back/domain/member/mentor/dto/MentorDto.java
@@ -0,0 +1,25 @@
+package com.back.domain.member.mentor.dto;
+
+import com.back.domain.member.mentor.entity.Mentor;
+import io.swagger.v3.oas.annotations.media.Schema;
+
+public record MentorDto (
+    @Schema(description = "멘토 ID")
+    Long mentorId,
+    @Schema(description = "멘토명")
+    String name,
+    @Schema(description = "평점")
+    Double rate,
+    // TODO: Job id, name
+    @Schema(description = "연차")
+    Integer careerYears
+) {
+    public static MentorDto from(Mentor mentor) {
+        return new MentorDto(
+            mentor.getId(),
+            mentor.getMember().getName(),
+            mentor.getRate(),
+            mentor.getCareerYears()
+        );
+    }
+}
diff --git a/back/src/main/java/com/back/domain/member/mentor/entity/Mentor.java b/back/src/main/java/com/back/domain/member/mentor/entity/Mentor.java
new file mode 100644
index 00000000..4eac842e
--- /dev/null
+++ b/back/src/main/java/com/back/domain/member/mentor/entity/Mentor.java
@@ -0,0 +1,34 @@
+package com.back.domain.member.mentor.entity;
+
+import com.back.domain.member.member.entity.Member;
+import com.back.global.jpa.BaseEntity;
+import jakarta.persistence.*;
+import lombok.Builder;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+
+@Entity
+@Getter
+@NoArgsConstructor
+public class Mentor extends BaseEntity {
+    @OneToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "member_id", nullable = false)
+    private Member member;
+
+    @Column(name = "job_id")
+    private Long jobId;
+
+    @Column
+    private Double rate;
+
+    @Column(name = "career_years")
+    private Integer careerYears;
+
+    @Builder
+    public Mentor(Member member, Long jobId, Double rate, Integer careerYears) {
+        this.member = member;
+        this.jobId = jobId;
+        this.rate = rate;
+        this.careerYears = careerYears;
+    }
+}
diff --git a/back/src/main/java/com/back/domain/member/mentor/repository/MentorRepository.java b/back/src/main/java/com/back/domain/member/mentor/repository/MentorRepository.java
new file mode 100644
index 00000000..fa31fc97
--- /dev/null
+++ b/back/src/main/java/com/back/domain/member/mentor/repository/MentorRepository.java
@@ -0,0 +1,10 @@
+package com.back.domain.member.mentor.repository;
+
+import com.back.domain.member.mentor.entity.Mentor;
+import org.springframework.data.jpa.repository.JpaRepository;
+
+import java.util.Optional;
+
+public interface MentorRepository extends JpaRepository<Mentor, Long> {
+    Optional<Mentor> findByMemberId(Long memberId);
+}
\ No newline at end of file
diff --git a/back/src/main/java/com/back/domain/mentoring/mentoring/controller/MentoringController.java b/back/src/main/java/com/back/domain/mentoring/mentoring/controller/MentoringController.java
new file mode 100644
index 00000000..f6144ee2
--- /dev/null
+++ b/back/src/main/java/com/back/domain/mentoring/mentoring/controller/MentoringController.java
@@ -0,0 +1,103 @@
+package com.back.domain.mentoring.mentoring.controller;
+
+import com.back.domain.member.member.entity.Member;
+import com.back.domain.mentoring.mentoring.dto.MentoringDto;
+import com.back.domain.mentoring.mentoring.dto.request.MentoringRequest;
+import com.back.domain.mentoring.mentoring.dto.response.MentoringPagingResponse;
+import com.back.domain.mentoring.mentoring.dto.response.MentoringResponse;
+import com.back.domain.mentoring.mentoring.service.MentoringService;
+import com.back.global.rq.Rq;
+import com.back.global.rsData.RsData;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import jakarta.validation.Valid;
+import lombok.RequiredArgsConstructor;
+import org.springframework.data.domain.Page;
+import org.springframework.security.access.prepost.PreAuthorize;
+import org.springframework.web.bind.annotation.*;
+
+@RestController
+@RequestMapping("/mentoring")
+@RequiredArgsConstructor
+@Tag(name = "MentoringController", description = "멘토링 API")
+public class MentoringController {
+    private final MentoringService mentoringService;
+    private final Rq rq;
+
+    @GetMapping
+    @Operation(summary = "멘토링 목록 조회")
+    public RsData<MentoringPagingResponse> getMentorings(
+        @RequestParam(defaultValue = "0") int page,
+        @RequestParam(defaultValue = "10") int size,
+        @RequestParam(required = false) String keyword
+    ) {
+        Page<MentoringDto> mentoringPage = mentoringService.getMentorings(keyword, page, size);
+        MentoringPagingResponse resDto = MentoringPagingResponse.from(mentoringPage);
+
+        return new RsData<>(
+            "200",
+            "멘토링 목록을 조회하였습니다.",
+            resDto
+        );
+    }
+
+    @GetMapping("/{mentoringId}")
+    @Operation(summary = "멘토링 상세 조회")
+    public RsData<MentoringResponse> getMentoring(
+        @PathVariable Long mentoringId
+    ) {
+        MentoringResponse resDto = mentoringService.getMentoring(mentoringId);
+
+        return new RsData<>(
+            "200",
+            "멘토링을 조회하였습니다.",
+            resDto
+        );
+    }
+
+    @PostMapping
+    @PreAuthorize("hasRole('MENTOR')")
+    @Operation(summary = "멘토링 생성")
+    public RsData<MentoringResponse> createMentoring(
+        @RequestBody @Valid MentoringRequest reqDto
+    ) {
+        Member member = rq.getActor();
+        MentoringResponse resDto = mentoringService.createMentoring(reqDto, member);
+
+        return new RsData<>(
+            "201",
+            "멘토링이 생성 완료되었습니다.",
+            resDto
+        );
+    }
+
+    @PutMapping("/{mentoringId}")
+    @Operation(summary = "멘토링 수정")
+    public RsData<MentoringResponse> updateMentoring(
+        @PathVariable Long mentoringId,
+        @RequestBody @Valid MentoringRequest reqDto
+    ) {
+        Member member = rq.getActor();
+        MentoringResponse resDto = mentoringService.updateMentoring(mentoringId, reqDto, member);
+
+        return new RsData<>(
+            "200",
+            "멘토링이 수정되었습니다.",
+            resDto
+        );
+    }
+
+    @DeleteMapping("/{mentoringId}")
+    @Operation(summary = "멘토링 삭제")
+    public RsData<Void> deleteMentoring(
+        @PathVariable Long mentoringId
+    ) {
+        Member member = rq.getActor();
+        mentoringService.deleteMentoring(mentoringId, member);
+
+        return new RsData<>(
+            "200",
+            "멘토링이 삭제되었습니다."
+        );
+    }
+}
diff --git a/back/src/main/java/com/back/domain/mentoring/mentoring/dto/MentoringDetailDto.java b/back/src/main/java/com/back/domain/mentoring/mentoring/dto/MentoringDetailDto.java
new file mode 100644
index 00000000..ed36a8c5
--- /dev/null
+++ b/back/src/main/java/com/back/domain/mentoring/mentoring/dto/MentoringDetailDto.java
@@ -0,0 +1,36 @@
+package com.back.domain.mentoring.mentoring.dto;
+
+import com.back.domain.mentoring.mentoring.entity.Mentoring;
+import io.swagger.v3.oas.annotations.media.Schema;
+
+import java.time.LocalDateTime;
+import java.util.List;
+
+public record MentoringDetailDto(
+    @Schema(description = "멘토링 ID")
+    Long mentoringId,
+    @Schema(description = "멘토링 제목")
+    String title,
+    @Schema(description = "멘토링 태그")
+    List<String> tags,
+    @Schema(description = "멘토링 소개")
+    String bio,
+    @Schema(description = "멘토링 썸네일")
+    String thumb,
+    @Schema(description = "생성일")
+    LocalDateTime createDate,
+    @Schema(description = "수정일")
+    LocalDateTime modifyDate
+) {
+    public static MentoringDetailDto from(Mentoring mentoring) {
+        return new MentoringDetailDto(
+            mentoring.getId(),
+            mentoring.getTitle(),
+            mentoring.getTags(),
+            mentoring.getBio(),
+            mentoring.getThumb(),
+            mentoring.getCreateDate(),
+            mentoring.getModifyDate()
+        );
+    }
+}
diff --git a/back/src/main/java/com/back/domain/mentoring/mentoring/dto/MentoringDto.java b/back/src/main/java/com/back/domain/mentoring/mentoring/dto/MentoringDto.java
new file mode 100644
index 00000000..8635e10a
--- /dev/null
+++ b/back/src/main/java/com/back/domain/mentoring/mentoring/dto/MentoringDto.java
@@ -0,0 +1,23 @@
+package com.back.domain.mentoring.mentoring.dto;
+
+import com.back.domain.mentoring.mentoring.entity.Mentoring;
+import io.swagger.v3.oas.annotations.media.Schema;
+
+import java.util.List;
+
+public record MentoringDto(
+    @Schema(description = "멘토링 ID")
+    Long mentoringId,
+    @Schema(description = "멘토링 제목")
+    String title,
+    @Schema(description = "멘토링 태그")
+    List<String> tags
+) {
+    public static MentoringDto from(Mentoring mentoring) {
+        return new MentoringDto(
+            mentoring.getId(),
+            mentoring.getTitle(),
+            mentoring.getTags()
+        );
+    }
+}
diff --git a/back/src/main/java/com/back/domain/mentoring/mentoring/dto/request/MentoringRequest.java b/back/src/main/java/com/back/domain/mentoring/mentoring/dto/request/MentoringRequest.java
new file mode 100644
index 00000000..e9853dc7
--- /dev/null
+++ b/back/src/main/java/com/back/domain/mentoring/mentoring/dto/request/MentoringRequest.java
@@ -0,0 +1,24 @@
+package com.back.domain.mentoring.mentoring.dto.request;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import jakarta.validation.constraints.NotNull;
+import jakarta.validation.constraints.Size;
+
+import java.util.List;
+
+public record MentoringRequest(
+    @Schema(description = "멘토링 제목")
+    @NotNull @Size(max = 100)
+    String title,
+
+    @Schema(description = "멘토링 태그", example = "[\"Java\", \"Spring\"]")
+    List<String> tags,
+
+    @Schema(description = "멘토링 소개")
+    @NotNull
+    String bio,
+
+    @Schema(description = "멘토링 썸네일")
+    String thumb
+) {
+}
diff --git a/back/src/main/java/com/back/domain/mentoring/mentoring/dto/response/MentoringPagingResponse.java b/back/src/main/java/com/back/domain/mentoring/mentoring/dto/response/MentoringPagingResponse.java
new file mode 100644
index 00000000..8d5819f8
--- /dev/null
+++ b/back/src/main/java/com/back/domain/mentoring/mentoring/dto/response/MentoringPagingResponse.java
@@ -0,0 +1,30 @@
+package com.back.domain.mentoring.mentoring.dto.response;
+
+import com.back.domain.mentoring.mentoring.dto.MentoringDto;
+import io.swagger.v3.oas.annotations.media.Schema;
+import org.springframework.data.domain.Page;
+
+import java.util.List;
+
+public record MentoringPagingResponse(
+    @Schema(description = "멘토링 목록")
+    List<MentoringDto> mentorings,
+    @Schema(description = "현재 페이지 (0부터 시작)")
+    int currentPage,
+    @Schema(description = "총 페이지")
+    int totalPage,
+    @Schema(description = "총 개수")
+    long totalElements,
+    @Schema(description = "다음 페이지 존재 여부")
+    boolean hasNext
+) {
+    public static MentoringPagingResponse from(Page<MentoringDto> page) {
+        return new MentoringPagingResponse(
+            page.getContent(),
+            page.getNumber(),
+            page.getTotalPages(),
+            page.getTotalElements(),
+            page.hasNext()
+        );
+    }
+}
diff --git a/back/src/main/java/com/back/domain/mentoring/mentoring/dto/response/MentoringResponse.java b/back/src/main/java/com/back/domain/mentoring/mentoring/dto/response/MentoringResponse.java
new file mode 100644
index 00000000..56e9809b
--- /dev/null
+++ b/back/src/main/java/com/back/domain/mentoring/mentoring/dto/response/MentoringResponse.java
@@ -0,0 +1,13 @@
+package com.back.domain.mentoring.mentoring.dto.response;
+
+import com.back.domain.member.mentor.dto.MentorDto;
+import com.back.domain.mentoring.mentoring.dto.MentoringDetailDto;
+import io.swagger.v3.oas.annotations.media.Schema;
+
+public record MentoringResponse(
+    @Schema(description = "멘토링")
+    MentoringDetailDto mentoring,
+    @Schema(description = "멘토")
+    MentorDto mentor
+) {
+}
diff --git a/back/src/main/java/com/back/domain/mentoring/mentoring/entity/Mentoring.java b/back/src/main/java/com/back/domain/mentoring/mentoring/entity/Mentoring.java
new file mode 100644
index 00000000..086a6d2e
--- /dev/null
+++ b/back/src/main/java/com/back/domain/mentoring/mentoring/entity/Mentoring.java
@@ -0,0 +1,54 @@
+package com.back.domain.mentoring.mentoring.entity;
+
+import com.back.domain.member.mentor.entity.Mentor;
+import com.back.global.converter.StringListConverter;
+import com.back.global.jpa.BaseEntity;
+import jakarta.persistence.*;
+import lombok.Builder;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+
+import java.util.ArrayList;
+import java.util.List;
+
+@Entity
+@Getter
+@NoArgsConstructor
+public class Mentoring extends BaseEntity {
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "mentor_id")
+    private Mentor mentor;
+
+    @Column(length = 100)
+    private String title;
+
+    @Column(columnDefinition = "TEXT")
+    private String bio;
+
+    @Convert(converter = StringListConverter.class)
+    @Column(columnDefinition = "JSON")
+    private List<String> tags;
+
+    @Column(length = 255)
+    private String thumb;
+
+    @Builder
+    public Mentoring(Mentor mentor, String title, String bio, List<String> tags, String thumb) {
+        this.mentor = mentor;
+        this.title = title;
+        this.bio = bio;
+        this.tags = tags != null ? tags : new ArrayList<>();
+        this.thumb = thumb;
+    }
+
+    public void update(String title, String bio, List<String> tags, String thumb) {
+        this.title = title;
+        this.bio = bio;
+        this.tags = tags != null ? tags : new ArrayList<>();
+        this.thumb = thumb;
+    }
+
+    public boolean isOwner(Mentor mentor) {
+        return this.mentor.equals(mentor);
+    }
+}
diff --git a/back/src/main/java/com/back/domain/mentoring/mentoring/entity/Review.java b/back/src/main/java/com/back/domain/mentoring/mentoring/entity/Review.java
new file mode 100644
index 00000000..be5cb818
--- /dev/null
+++ b/back/src/main/java/com/back/domain/mentoring/mentoring/entity/Review.java
@@ -0,0 +1,20 @@
+package com.back.domain.mentoring.mentoring.entity;
+
+import com.back.domain.mentoring.reservation.entity.Reservation;
+import com.back.global.jpa.BaseEntity;
+import jakarta.persistence.*;
+import lombok.Getter;
+
+@Entity
+@Getter
+public class Review extends BaseEntity {
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "reservation_id", nullable = false)
+    private Reservation reservation;
+
+    @Column(nullable = false)
+    private double rating;
+
+    @Column(columnDefinition = "TEXT")
+    private String content;
+}
diff --git a/back/src/main/java/com/back/domain/mentoring/mentoring/error/MentoringErrorCode.java b/back/src/main/java/com/back/domain/mentoring/mentoring/error/MentoringErrorCode.java
new file mode 100644
index 00000000..05ea5866
--- /dev/null
+++ b/back/src/main/java/com/back/domain/mentoring/mentoring/error/MentoringErrorCode.java
@@ -0,0 +1,26 @@
+package com.back.domain.mentoring.mentoring.error;
+
+import com.back.global.exception.ErrorCode;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+@Getter
+@AllArgsConstructor
+public enum MentoringErrorCode implements ErrorCode {
+
+    // 400
+    CANNOT_DELETE_MENTORING("400-1", "예약 이력이 있는 멘토링은 삭제할 수 없습니다."),
+
+    // 403
+    FORBIDDEN_NOT_OWNER("403-1", "해당 멘토링에 대한 권한이 없습니다."),
+
+    // 404
+    NOT_FOUND_MENTOR("404-1", "멘토를 찾을 수 없습니다."),
+    NOT_FOUND_MENTORING("404-2", "멘토링을 찾을 수 없습니다."),
+
+    // 409
+    ALREADY_EXISTS_MENTORING("409-1", "이미 멘토링 정보가 존재합니다.");
+
+    private final String code;
+    private final String message;
+}
diff --git a/back/src/main/java/com/back/domain/mentoring/mentoring/repository/MentoringRepository.java b/back/src/main/java/com/back/domain/mentoring/mentoring/repository/MentoringRepository.java
new file mode 100644
index 00000000..007ef4a6
--- /dev/null
+++ b/back/src/main/java/com/back/domain/mentoring/mentoring/repository/MentoringRepository.java
@@ -0,0 +1,13 @@
+package com.back.domain.mentoring.mentoring.repository;
+
+import com.back.domain.mentoring.mentoring.entity.Mentoring;
+import org.springframework.data.jpa.repository.JpaRepository;
+
+import java.util.List;
+import java.util.Optional;
+
+public interface MentoringRepository extends JpaRepository<Mentoring, Long>, MentoringRepositoryCustom {
+    List<Mentoring> findByMentorId(Long mentorId);
+    Optional<Mentoring> findTopByOrderByIdDesc();
+    boolean existsByMentorId(Long mentorId);
+}
diff --git a/back/src/main/java/com/back/domain/mentoring/mentoring/repository/MentoringRepositoryCustom.java b/back/src/main/java/com/back/domain/mentoring/mentoring/repository/MentoringRepositoryCustom.java
new file mode 100644
index 00000000..03fe4e14
--- /dev/null
+++ b/back/src/main/java/com/back/domain/mentoring/mentoring/repository/MentoringRepositoryCustom.java
@@ -0,0 +1,9 @@
+package com.back.domain.mentoring.mentoring.repository;
+
+import com.back.domain.mentoring.mentoring.entity.Mentoring;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+
+public interface MentoringRepositoryCustom {
+    Page<Mentoring> searchMentorings(String keyword, Pageable pageable);
+}
diff --git a/back/src/main/java/com/back/domain/mentoring/mentoring/repository/MentoringRepositoryImpl.java b/back/src/main/java/com/back/domain/mentoring/mentoring/repository/MentoringRepositoryImpl.java
new file mode 100644
index 00000000..18e1ecb8
--- /dev/null
+++ b/back/src/main/java/com/back/domain/mentoring/mentoring/repository/MentoringRepositoryImpl.java
@@ -0,0 +1,64 @@
+package com.back.domain.mentoring.mentoring.repository;
+
+import com.back.domain.member.member.entity.QMember;
+import com.back.domain.member.mentor.entity.QMentor;
+import com.back.domain.mentoring.mentoring.entity.Mentoring;
+import com.back.domain.mentoring.mentoring.entity.QMentoring;
+import com.querydsl.core.BooleanBuilder;
+import com.querydsl.jpa.impl.JPAQueryFactory;
+import lombok.RequiredArgsConstructor;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.PageImpl;
+import org.springframework.data.domain.Pageable;
+
+import java.util.List;
+
+@RequiredArgsConstructor
+public class MentoringRepositoryImpl implements MentoringRepositoryCustom {
+
+    private final JPAQueryFactory queryFactory;
+
+    @Override
+    public Page<Mentoring> searchMentorings(String keyword, Pageable pageable) {
+        QMentoring mentoring = QMentoring.mentoring;
+        QMentor mentor = QMentor.mentor;
+        QMember member = QMember.member;
+
+        BooleanBuilder builder = new BooleanBuilder();
+
+        // 제목, 멘토 이름 검색 조건
+        if (keyword != null && !keyword.isBlank()) {
+            builder.and(
+                mentoring.title.containsIgnoreCase(keyword)
+                    .or(mentor.member.name.containsIgnoreCase(keyword))
+            );
+        }
+
+        // 1. 조건에 맞는 모든 데이터 조회 (태그 제외)
+        List<Mentoring> content = queryFactory
+            .selectFrom(mentoring)
+            .leftJoin(mentoring.mentor, mentor).fetchJoin()
+            .leftJoin(mentor.member, member).fetchJoin()
+            .where(builder)
+            .orderBy(mentoring.id.desc())
+            .offset(pageable.getOffset())
+            .limit(pageable.getPageSize())
+            .fetch();
+
+        // 2. 태그 검색
+        // TODO: 태그 테이블 분리 후 추가 예정
+
+        long total = getTotal(mentoring, builder);
+
+        return new PageImpl<>(content, pageable, total);
+    }
+
+    private long getTotal(QMentoring mentoring, BooleanBuilder builder) {
+        Long totalCount = queryFactory
+            .select(mentoring.count())
+            .from(mentoring)
+            .where(builder)
+            .fetchOne();
+        return totalCount != null ? totalCount : 0L;
+    }
+}
diff --git a/back/src/main/java/com/back/domain/mentoring/mentoring/repository/ReviewRepository.java b/back/src/main/java/com/back/domain/mentoring/mentoring/repository/ReviewRepository.java
new file mode 100644
index 00000000..990dcfa4
--- /dev/null
+++ b/back/src/main/java/com/back/domain/mentoring/mentoring/repository/ReviewRepository.java
@@ -0,0 +1,7 @@
+package com.back.domain.mentoring.mentoring.repository;
+
+import com.back.domain.mentoring.mentoring.entity.Review;
+import org.springframework.data.jpa.repository.JpaRepository;
+
+public interface ReviewRepository extends JpaRepository<Review, Long> {
+}
diff --git a/back/src/main/java/com/back/domain/mentoring/mentoring/service/MentoringService.java b/back/src/main/java/com/back/domain/mentoring/mentoring/service/MentoringService.java
new file mode 100644
index 00000000..d3c4bd0a
--- /dev/null
+++ b/back/src/main/java/com/back/domain/mentoring/mentoring/service/MentoringService.java
@@ -0,0 +1,132 @@
+package com.back.domain.mentoring.mentoring.service;
+
+import com.back.domain.member.member.entity.Member;
+import com.back.domain.member.mentor.dto.MentorDto;
+import com.back.domain.member.mentor.entity.Mentor;
+import com.back.domain.member.mentor.repository.MentorRepository;
+import com.back.domain.mentoring.mentoring.dto.MentoringDetailDto;
+import com.back.domain.mentoring.mentoring.dto.MentoringDto;
+import com.back.domain.mentoring.mentoring.dto.request.MentoringRequest;
+import com.back.domain.mentoring.mentoring.dto.response.MentoringResponse;
+import com.back.domain.mentoring.mentoring.entity.Mentoring;
+import com.back.domain.mentoring.mentoring.error.MentoringErrorCode;
+import com.back.domain.mentoring.mentoring.repository.MentoringRepository;
+import com.back.domain.mentoring.reservation.repository.ReservationRepository;
+import com.back.domain.mentoring.slot.repository.MentorSlotRepository;
+import com.back.global.exception.ServiceException;
+import lombok.RequiredArgsConstructor;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.data.domain.Pageable;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+@Service
+@RequiredArgsConstructor
+public class MentoringService {
+    private final MentoringRepository mentoringRepository;
+    private final MentorRepository mentorRepository;
+    private final ReservationRepository reservationRepository;
+    private final MentorSlotRepository mentorSlotRepository;
+
+    @Transactional(readOnly = true)
+    public Page<MentoringDto> getMentorings(String keyword, int page, int size) {
+        Pageable pageable = PageRequest.of(page, size);
+
+        return mentoringRepository.searchMentorings(keyword, pageable)
+            .map(MentoringDto::from);
+    }
+
+    @Transactional(readOnly = true)
+    public MentoringResponse getMentoring(Long mentoringId)  {
+        Mentoring mentoring = findMentoring(mentoringId);
+        Mentor mentor = mentoring.getMentor();
+
+        return new MentoringResponse(
+            MentoringDetailDto.from(mentoring),
+            MentorDto.from(mentor)
+        );
+    }
+
+    @Transactional
+    public MentoringResponse createMentoring(MentoringRequest reqDto, Member member) {
+        Mentor mentor = findMentor(member);
+
+        // 멘토당 멘토링 1개 제한 체크 (추후 1:N 변경 시 제거 필요)
+        if (mentoringRepository.existsByMentorId(mentor.getId())) {
+            throw new ServiceException(MentoringErrorCode.ALREADY_EXISTS_MENTORING);
+        }
+
+        Mentoring mentoring = Mentoring.builder()
+            .mentor(mentor)
+            .title(reqDto.title())
+            .bio(reqDto.bio())
+            .tags(reqDto.tags())
+            .thumb(reqDto.thumb())
+            .build();
+
+        mentoringRepository.save(mentoring);
+
+        return new MentoringResponse(
+            MentoringDetailDto.from(mentoring),
+            MentorDto.from(mentor)
+        );
+    }
+
+    @Transactional
+    public MentoringResponse updateMentoring(Long mentoringId, MentoringRequest reqDto, Member member) {
+        Mentor mentor = findMentor(member);
+        Mentoring mentoring = findMentoring(mentoringId);
+
+        validateOwner(mentoring, mentor);
+
+        mentoring.update(reqDto.title(), reqDto.bio(), reqDto.tags(), reqDto.thumb());
+
+        return new MentoringResponse(
+            MentoringDetailDto.from(mentoring),
+            MentorDto.from(mentor)
+        );
+    }
+
+    @Transactional
+    public void deleteMentoring(Long mentoringId, Member member) {
+        Mentor mentor = findMentor(member);
+        Mentoring mentoring = findMentoring(mentoringId);
+
+        validateOwner(mentoring, mentor);
+
+        // 예약 이력이 있을 시 삭제 불가
+        if (reservationRepository.existsByMentoringId(mentoring.getId())) {
+            throw new ServiceException(MentoringErrorCode.CANNOT_DELETE_MENTORING);
+        }
+
+        // 멘토 슬롯 있을 시 일괄 삭제 (추후 1:N 변경 시 제거 필요)
+        if (mentorSlotRepository.existsByMentorId(mentor.getId())) {
+            mentorSlotRepository.deleteAllByMentorId(mentor.getId());
+        }
+        // 멘토 삭제
+        mentoringRepository.delete(mentoring);
+    }
+
+
+    // ===== 헬퍼 메서드 =====
+
+    private Mentor findMentor(Member member) {
+        return mentorRepository.findByMemberId(member.getId())
+            .orElseThrow(() -> new ServiceException(MentoringErrorCode.NOT_FOUND_MENTOR));
+    }
+
+    private Mentoring findMentoring(Long mentoringId) {
+        return mentoringRepository.findById(mentoringId)
+            .orElseThrow(() -> new ServiceException(MentoringErrorCode.NOT_FOUND_MENTORING));
+    }
+
+
+    // ===== 유효성 검사 =====
+
+    private void validateOwner(Mentoring mentoring, Mentor mentor) {
+        if (!mentoring.isOwner(mentor)) {
+            throw new ServiceException(MentoringErrorCode.FORBIDDEN_NOT_OWNER);
+        }
+    }
+}
diff --git a/back/src/main/java/com/back/domain/mentoring/reservation/constant/ReservationStatus.java b/back/src/main/java/com/back/domain/mentoring/reservation/constant/ReservationStatus.java
new file mode 100644
index 00000000..cec09091
--- /dev/null
+++ b/back/src/main/java/com/back/domain/mentoring/reservation/constant/ReservationStatus.java
@@ -0,0 +1,9 @@
+package com.back.domain.mentoring.reservation.constant;
+
+public enum ReservationStatus {
+    PENDING,    // 예약 승인 대기
+    APPROVED,   // 승인됨
+    REJECTED,   // 거절됨
+    CANCELED,   // 취소됨
+    COMPLETED   // 완료됨
+}
diff --git a/back/src/main/java/com/back/domain/mentoring/reservation/entity/Reservation.java b/back/src/main/java/com/back/domain/mentoring/reservation/entity/Reservation.java
new file mode 100644
index 00000000..4a4db327
--- /dev/null
+++ b/back/src/main/java/com/back/domain/mentoring/reservation/entity/Reservation.java
@@ -0,0 +1,50 @@
+package com.back.domain.mentoring.reservation.entity;
+
+import com.back.domain.member.mentee.entity.Mentee;
+import com.back.domain.member.mentor.entity.Mentor;
+import com.back.domain.mentoring.mentoring.entity.Mentoring;
+import com.back.domain.mentoring.reservation.constant.ReservationStatus;
+import com.back.domain.mentoring.slot.entity.MentorSlot;
+import com.back.global.jpa.BaseEntity;
+import jakarta.persistence.*;
+import lombok.Builder;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+
+@Entity
+@Getter
+@NoArgsConstructor
+public class Reservation extends BaseEntity {
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "mentoring_id", nullable = false)
+    private Mentoring mentoring;
+
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "mentor_id", nullable = false)
+    private Mentor mentor;
+
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "mentee_id", nullable = false)
+    private Mentee mentee;
+
+    @OneToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "mentor_slot_id", nullable = false)
+    private MentorSlot mentorSlot;
+
+    @Column(columnDefinition = "TEXT")
+    private String preQuestion;
+
+    @Enumerated(EnumType.STRING)
+    @Column(nullable = false)
+    private ReservationStatus status;
+
+    @Builder
+    public Reservation(Mentoring mentoring, Mentee mentee, MentorSlot mentorSlot, String preQuestion) {
+        this.mentoring = mentoring;
+        this.mentor = mentoring.getMentor();
+        this.mentee = mentee;
+        this.mentorSlot = mentorSlot;
+        this.preQuestion = preQuestion;
+        this.status = ReservationStatus.PENDING;
+    }
+}
diff --git a/back/src/main/java/com/back/domain/mentoring/reservation/repository/ReservationRepository.java b/back/src/main/java/com/back/domain/mentoring/reservation/repository/ReservationRepository.java
new file mode 100644
index 00000000..b7c6904b
--- /dev/null
+++ b/back/src/main/java/com/back/domain/mentoring/reservation/repository/ReservationRepository.java
@@ -0,0 +1,8 @@
+package com.back.domain.mentoring.reservation.repository;
+
+import com.back.domain.mentoring.reservation.entity.Reservation;
+import org.springframework.data.jpa.repository.JpaRepository;
+
+public interface ReservationRepository extends JpaRepository<Reservation, Long> {
+    boolean existsByMentoringId(Long mentoringId);
+}
diff --git a/back/src/main/java/com/back/domain/mentoring/slot/constant/MentorSlotStatus.java b/back/src/main/java/com/back/domain/mentoring/slot/constant/MentorSlotStatus.java
new file mode 100644
index 00000000..13d16388
--- /dev/null
+++ b/back/src/main/java/com/back/domain/mentoring/slot/constant/MentorSlotStatus.java
@@ -0,0 +1,8 @@
+package com.back.domain.mentoring.slot.constant;
+
+public enum MentorSlotStatus {
+    AVAILABLE,  // 예약 가능
+    PENDING,    // 예약 승인 대기
+    APPROVED,   // 예약 승인됨(확정)
+    COMPLETED   // 멘토링 완료
+}
diff --git a/back/src/main/java/com/back/domain/mentoring/slot/controller/MentorSlotController.java b/back/src/main/java/com/back/domain/mentoring/slot/controller/MentorSlotController.java
new file mode 100644
index 00000000..f3fce346
--- /dev/null
+++ b/back/src/main/java/com/back/domain/mentoring/slot/controller/MentorSlotController.java
@@ -0,0 +1,57 @@
+package com.back.domain.mentoring.slot.controller;
+
+import com.back.domain.member.member.entity.Member;
+import com.back.domain.mentoring.slot.dto.request.MentorSlotRequest;
+import com.back.domain.mentoring.slot.dto.response.MentorSlotResponse;
+import com.back.domain.mentoring.slot.service.MentorSlotService;
+import com.back.global.rq.Rq;
+import com.back.global.rsData.RsData;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import jakarta.validation.Valid;
+import lombok.RequiredArgsConstructor;
+import org.springframework.security.access.prepost.PreAuthorize;
+import org.springframework.web.bind.annotation.*;
+
+@RestController
+@RequestMapping("/mentor-slot")
+@RequiredArgsConstructor
+@Tag(name = "MentorSlotController", description = "멘토 슬롯(멘토의 예약 가능 일정) API")
+public class MentorSlotController {
+
+    private final MentorSlotService mentorSlotService;
+    private final Rq rq;
+
+    @PostMapping
+    @PreAuthorize("hasRole('MENTOR')")
+    @Operation(summary = "멘토 슬롯 생성")
+    public RsData<MentorSlotResponse> createMentorSlot(
+        @RequestBody @Valid MentorSlotRequest reqDto
+    ) {
+        Member member = rq.getActor();
+        MentorSlotResponse resDto = mentorSlotService.createMentorSlot(reqDto, member);
+
+        return new RsData<>(
+            "201",
+            "멘토링 예약 일정을 등록했습니다.",
+            resDto
+        );
+    }
+
+    @PutMapping("/{slotId}")
+    @Operation(summary = "멘토 슬롯 수정")
+    public RsData<MentorSlotResponse> updateMentorSlot(
+        @PathVariable Long slotId,
+        @RequestBody @Valid MentorSlotRequest reqDto
+    ) {
+        Member member = rq.getActor();
+        MentorSlotResponse resDto = mentorSlotService.updateMentorSlot(slotId, reqDto, member);
+
+        return new RsData<>(
+            "200",
+            "멘토링 예약 일정이 수정되었습니다.",
+            resDto
+        );
+    }
+
+}
diff --git a/back/src/main/java/com/back/domain/mentoring/slot/dto/MentorSlotDto.java b/back/src/main/java/com/back/domain/mentoring/slot/dto/MentorSlotDto.java
new file mode 100644
index 00000000..6eeb673a
--- /dev/null
+++ b/back/src/main/java/com/back/domain/mentoring/slot/dto/MentorSlotDto.java
@@ -0,0 +1,18 @@
+package com.back.domain.mentoring.slot.dto;
+
+import com.back.domain.mentoring.slot.constant.MentorSlotStatus;
+import io.swagger.v3.oas.annotations.media.Schema;
+
+import java.time.LocalDateTime;
+
+public record MentorSlotDto(
+    @Schema(description = "멘토링 슬롯 ID")
+    Long mentorSlotId,
+    @Schema(description = "시작 일시")
+    LocalDateTime startDateTime,
+    @Schema(description = "종료 일시")
+    LocalDateTime endDateTime,
+    @Schema(description = "멘토 슬롯 상태")
+    MentorSlotStatus mentorSlotStatus
+) {
+}
diff --git a/back/src/main/java/com/back/domain/mentoring/slot/dto/request/MentorSlotRequest.java b/back/src/main/java/com/back/domain/mentoring/slot/dto/request/MentorSlotRequest.java
new file mode 100644
index 00000000..ba243213
--- /dev/null
+++ b/back/src/main/java/com/back/domain/mentoring/slot/dto/request/MentorSlotRequest.java
@@ -0,0 +1,21 @@
+package com.back.domain.mentoring.slot.dto.request;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import jakarta.validation.constraints.NotNull;
+
+import java.time.LocalDateTime;
+
+public record MentorSlotRequest(
+    @Schema(description = "멘토 ID")
+    @NotNull
+    Long mentorId,
+
+    @Schema(description = "시작 일시")
+    @NotNull
+    LocalDateTime startDateTime,
+
+    @Schema(description = "종료 일시")
+    @NotNull
+    LocalDateTime endDateTime
+) {
+}
diff --git a/back/src/main/java/com/back/domain/mentoring/slot/dto/response/MentorSlotResponse.java b/back/src/main/java/com/back/domain/mentoring/slot/dto/response/MentorSlotResponse.java
new file mode 100644
index 00000000..e951764e
--- /dev/null
+++ b/back/src/main/java/com/back/domain/mentoring/slot/dto/response/MentorSlotResponse.java
@@ -0,0 +1,51 @@
+package com.back.domain.mentoring.slot.dto.response;
+
+import com.back.domain.mentoring.mentoring.entity.Mentoring;
+import com.back.domain.mentoring.slot.constant.MentorSlotStatus;
+import com.back.domain.mentoring.slot.entity.MentorSlot;
+import io.swagger.v3.oas.annotations.media.Schema;
+
+import java.time.LocalDateTime;
+
+public record MentorSlotResponse(
+    @Schema(description = "멘토링 슬롯 ID")
+    Long mentorSlotId,
+
+    @Schema(description = "멘토 ID")
+    Long mentorId,
+
+    @Schema(description = "멘토링 ID")
+    Long mentoringId,
+
+    @Schema(description = "멘토링 제목")
+    String mentoringTitle,
+
+    @Schema(description = "시작 일시")
+    LocalDateTime startDateTime,
+
+    @Schema(description = "종료 일시")
+    LocalDateTime endDateTime,
+
+    @Schema(description = "멘토 슬롯 상태")
+    MentorSlotStatus mentorSlotStatus,
+
+    @Schema(description = "생성일")
+    LocalDateTime createDate,
+
+    @Schema(description = "수정일")
+    LocalDateTime modifyDate
+) {
+    public static MentorSlotResponse from(MentorSlot mentorSlot, Mentoring mentoring) {
+        return new MentorSlotResponse(
+            mentorSlot.getId(),
+            mentorSlot.getMentor().getId(),
+            mentoring.getId(),
+            mentoring.getTitle(),
+            mentorSlot.getStartDateTime(),
+            mentorSlot.getEndDateTime(),
+            mentorSlot.getStatus(),
+            mentorSlot.getCreateDate(),
+            mentorSlot.getModifyDate()
+        );
+    }
+}
diff --git a/back/src/main/java/com/back/domain/mentoring/slot/entity/MentorSlot.java b/back/src/main/java/com/back/domain/mentoring/slot/entity/MentorSlot.java
new file mode 100644
index 00000000..37556276
--- /dev/null
+++ b/back/src/main/java/com/back/domain/mentoring/slot/entity/MentorSlot.java
@@ -0,0 +1,81 @@
+package com.back.domain.mentoring.slot.entity;
+
+import com.back.domain.member.mentor.entity.Mentor;
+import com.back.domain.mentoring.reservation.constant.ReservationStatus;
+import com.back.domain.mentoring.reservation.entity.Reservation;
+import com.back.domain.mentoring.slot.constant.MentorSlotStatus;
+import com.back.global.jpa.BaseEntity;
+import jakarta.persistence.*;
+import lombok.Builder;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+
+import java.time.LocalDateTime;
+
+@Entity
+@Getter
+@NoArgsConstructor
+public class MentorSlot extends BaseEntity {
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "mentor_id", nullable = false)
+    private Mentor mentor;
+
+    @Column(nullable = false)
+    private LocalDateTime startDateTime;
+
+    @Column(nullable = false)
+    private LocalDateTime endDateTime;
+
+    @OneToOne(mappedBy = "mentorSlot")
+    private Reservation reservation;
+
+    @Enumerated(EnumType.STRING)
+    @Column(nullable = false)
+    private MentorSlotStatus status;
+
+    @Builder
+    public MentorSlot(Mentor mentor, LocalDateTime startDateTime, LocalDateTime endDateTime) {
+        this.mentor = mentor;
+        this.startDateTime = startDateTime;
+        this.endDateTime = endDateTime;
+        this.status = MentorSlotStatus.AVAILABLE;
+    }
+
+    // =========================
+    // TODO - 현재 상태
+    // 1. reservation 필드에는 활성 예약(PENDING, APPROVED)만 세팅
+    // 2. 취소/거절 예약은 DB에 남기고 reservation 필드에는 연결하지 않음
+    // 3. 슬롯 재생성 불필요, 상태 기반 isAvailable() 로 새 예약 가능 판단
+    //
+    // TODO - 추후 변경
+    // 1. 1:N 구조로 리팩토링
+    //    - MentorSlot에 여러 Reservation 연결 가능
+    //    - 모든 예약 기록(히스토리) 보존
+    // 2. 상태 기반 필터링 유지: 활성 예약만 계산 시 사용
+    // 3. 이벤트 소싱/분석 등 확장 가능하도록 구조 개선
+    // =========================
+
+    public void updateStatus() {
+        if (reservation == null) {
+            this.status =  MentorSlotStatus.AVAILABLE;
+        } else {
+            this.status = switch (reservation.getStatus()) {
+                case PENDING -> MentorSlotStatus.PENDING;
+                case APPROVED -> MentorSlotStatus.APPROVED;
+                case COMPLETED -> MentorSlotStatus.COMPLETED;
+                case REJECTED, CANCELED -> MentorSlotStatus.AVAILABLE;
+            };
+        }
+    }
+
+    public boolean isAvailable() {
+        return reservation == null ||
+            reservation.getStatus().equals(ReservationStatus.REJECTED) ||
+            reservation.getStatus().equals(ReservationStatus.CANCELED);
+    }
+
+    public void update(LocalDateTime startDateTime, LocalDateTime endDateTime) {
+        this.startDateTime = startDateTime;
+        this.endDateTime = endDateTime;
+    }
+}
diff --git a/back/src/main/java/com/back/domain/mentoring/slot/error/MentorSlotErrorCode.java b/back/src/main/java/com/back/domain/mentoring/slot/error/MentorSlotErrorCode.java
new file mode 100644
index 00000000..92166927
--- /dev/null
+++ b/back/src/main/java/com/back/domain/mentoring/slot/error/MentorSlotErrorCode.java
@@ -0,0 +1,32 @@
+package com.back.domain.mentoring.slot.error;
+
+import com.back.global.exception.ErrorCode;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+@Getter
+@AllArgsConstructor
+public enum MentorSlotErrorCode implements ErrorCode {
+
+    // 400 DateTime 체크
+    START_TIME_REQUIRED("400-1", "시작 일시와 종료 일시는 필수입니다."),
+    END_TIME_REQUIRED("400-2", "시작 일시와 종료 일시는 필수입니다."),
+    START_TIME_IN_PAST("400-3", "시작 일시는 현재 이후여야 합니다."),
+    END_TIME_BEFORE_START("400-4", "종료 일시는 시작 일시보다 이후여야 합니다."),
+    INSUFFICIENT_SLOT_DURATION("400-5", "슬롯은 최소 30분 이상이어야 합니다."),
+
+    // 400 Slot 체크
+    CANNOT_UPDATE_RESERVED_SLOT("400-6", "예약된 슬롯은 수정할 수 없습니다."),
+
+    // 403
+    NOT_OWNER("403-1", "일정의 소유주가 아닙니다."),
+
+    // 404
+    NOT_FOUND_MENTOR_SLOT("404-1", "일정 정보가 없습니다."),
+
+    // 409
+    OVERLAPPING_SLOT("409-1", "선택한 시간은 이미 예약된 시간대입니다.");
+
+    private final String code;
+    private final String message;
+}
diff --git a/back/src/main/java/com/back/domain/mentoring/slot/repository/MentorSlotRepository.java b/back/src/main/java/com/back/domain/mentoring/slot/repository/MentorSlotRepository.java
new file mode 100644
index 00000000..a5885554
--- /dev/null
+++ b/back/src/main/java/com/back/domain/mentoring/slot/repository/MentorSlotRepository.java
@@ -0,0 +1,46 @@
+package com.back.domain.mentoring.slot.repository;
+
+import com.back.domain.mentoring.slot.entity.MentorSlot;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.repository.query.Param;
+
+import java.time.LocalDateTime;
+import java.util.Optional;
+
+public interface MentorSlotRepository extends JpaRepository<MentorSlot, Long> {
+    Optional<MentorSlot> findTopByOrderByIdDesc();
+    boolean existsByMentorId(Long mentorId);
+    void deleteAllByMentorId(Long mentorId);
+
+    // TODO: 현재는 시간 겹침만 체크, 추후 1:N 구조 시 활성 예약 기준으로 변경
+    @Query("""
+        SELECT CASE WHEN COUNT(ms) > 0
+                THEN TRUE
+                ELSE FALSE END
+        FROM MentorSlot ms
+        WHERE ms.mentor.id = :mentorId
+        AND (ms.startDateTime < :end AND ms.endDateTime > :start)
+        """)
+    boolean existsOverlappingSlot(
+        @Param("mentorId") Long mentorId,
+        @Param("start")LocalDateTime start,
+        @Param("end") LocalDateTime end
+    );
+
+    @Query("""
+        SELECT CASE WHEN COUNT(ms) > 0
+                THEN TRUE
+                ELSE FALSE END
+        FROM MentorSlot ms
+        WHERE ms.mentor.id = :mentorId
+        AND ms.id != :slotId
+        AND (ms.startDateTime < :end AND ms.endDateTime > :start)
+        """)
+    boolean existsOverlappingExcept(
+        @Param("mentorId") Long mentorId,
+        @Param("slotId") Long slotId,
+        @Param("start") LocalDateTime start,
+        @Param("end") LocalDateTime end
+    );
+}
diff --git a/back/src/main/java/com/back/domain/mentoring/slot/service/MentorSlotService.java b/back/src/main/java/com/back/domain/mentoring/slot/service/MentorSlotService.java
new file mode 100644
index 00000000..7e3e06f9
--- /dev/null
+++ b/back/src/main/java/com/back/domain/mentoring/slot/service/MentorSlotService.java
@@ -0,0 +1,111 @@
+package com.back.domain.mentoring.slot.service;
+
+import com.back.domain.member.member.entity.Member;
+import com.back.domain.member.mentor.entity.Mentor;
+import com.back.domain.member.mentor.repository.MentorRepository;
+import com.back.domain.mentoring.mentoring.entity.Mentoring;
+import com.back.domain.mentoring.mentoring.error.MentoringErrorCode;
+import com.back.domain.mentoring.mentoring.repository.MentoringRepository;
+import com.back.domain.mentoring.slot.dto.request.MentorSlotRequest;
+import com.back.domain.mentoring.slot.dto.response.MentorSlotResponse;
+import com.back.domain.mentoring.slot.entity.MentorSlot;
+import com.back.domain.mentoring.slot.error.MentorSlotErrorCode;
+import com.back.domain.mentoring.slot.repository.MentorSlotRepository;
+import com.back.global.exception.ServiceException;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.time.LocalDateTime;
+import java.util.List;
+
+@Service
+@RequiredArgsConstructor
+public class MentorSlotService {
+
+    private final MentorSlotRepository mentorSlotRepository;
+    private final MentorRepository mentorRepository;
+    private final MentoringRepository mentoringRepository;
+
+    @Transactional
+    public MentorSlotResponse createMentorSlot(MentorSlotRequest reqDto, Member member) {
+        Mentor mentor = findMentor(member);
+        Mentoring mentoring = findMentoring(mentor);
+
+        // 시간대 유효성 검사
+        MentorSlotValidator.validateTimeSlot(reqDto.startDateTime(), reqDto.endDateTime());
+
+        // 기존 슬롯과 시간 겹치는지 검사
+        validateOverlappingSlots(mentor, reqDto.startDateTime(), reqDto.endDateTime());
+
+        MentorSlot mentorSlot = MentorSlot.builder()
+            .mentor(mentor)
+            .startDateTime(reqDto.startDateTime())
+            .endDateTime(reqDto.endDateTime())
+            .build();
+
+        mentorSlotRepository.save(mentorSlot);
+
+        return MentorSlotResponse.from(mentorSlot, mentoring);
+    }
+
+    @Transactional
+    public MentorSlotResponse updateMentorSlot(Long slotId, MentorSlotRequest reqDto, Member member) {
+        Mentor mentor = findMentor(member);
+        Mentoring mentoring = findMentoring(mentor);
+        MentorSlot mentorSlot = findMentorSlot(slotId);
+
+        if (!mentorSlot.getMentor().equals(mentor)) {
+            throw new ServiceException(MentorSlotErrorCode.NOT_OWNER);
+        }
+        if (!mentorSlot.isAvailable()) {
+            throw new ServiceException(MentorSlotErrorCode.CANNOT_UPDATE_RESERVED_SLOT);
+        }
+
+        // 시간대 유효성 검사
+        MentorSlotValidator.validateTimeSlot(reqDto.startDateTime(), reqDto.endDateTime());
+
+        // 기존 슬롯과 시간 겹치는지 검사
+        validateOverlappingExcept(mentor, mentorSlot, reqDto.startDateTime(), reqDto.endDateTime());
+
+        mentorSlot.update(reqDto.startDateTime(), reqDto.endDateTime());
+
+        return MentorSlotResponse.from(mentorSlot, mentoring);
+    }
+
+
+    // ===== 헬퍼 메서드 =====
+
+    private Mentor findMentor(Member member) {
+        return mentorRepository.findByMemberId(member.getId())
+            .orElseThrow(() -> new ServiceException(MentoringErrorCode.NOT_FOUND_MENTOR));
+    }
+
+    private Mentoring findMentoring(Mentor mentor) {
+        List<Mentoring> mentorings = mentoringRepository.findByMentorId(mentor.getId());
+        if (mentorings.isEmpty()) {
+            throw new ServiceException(MentoringErrorCode.NOT_FOUND_MENTORING);
+        }
+        return mentorings.getFirst();
+    }
+
+    private MentorSlot findMentorSlot(Long slotId) {
+        return mentorSlotRepository.findById(slotId)
+            .orElseThrow(() -> new ServiceException(MentorSlotErrorCode.NOT_FOUND_MENTOR_SLOT));
+    }
+
+
+    // ===== 검증 메서드 =====
+
+    private void validateOverlappingSlots(Mentor mentor, LocalDateTime start, LocalDateTime end) {
+        if (mentorSlotRepository.existsOverlappingSlot(mentor.getId(), start, end)) {
+            throw new ServiceException(MentorSlotErrorCode.OVERLAPPING_SLOT);
+        }
+    }
+
+    private void validateOverlappingExcept(Mentor mentor, MentorSlot mentorSlot, LocalDateTime start, LocalDateTime end) {
+        if (mentorSlotRepository.existsOverlappingExcept(mentor.getId(), mentorSlot.getId(), start, end)) {
+            throw new ServiceException(MentorSlotErrorCode.OVERLAPPING_SLOT);
+        }
+    }
+}
diff --git a/back/src/main/java/com/back/domain/mentoring/slot/service/MentorSlotValidator.java b/back/src/main/java/com/back/domain/mentoring/slot/service/MentorSlotValidator.java
new file mode 100644
index 00000000..048dc6d1
--- /dev/null
+++ b/back/src/main/java/com/back/domain/mentoring/slot/service/MentorSlotValidator.java
@@ -0,0 +1,43 @@
+package com.back.domain.mentoring.slot.service;
+
+import com.back.domain.mentoring.slot.error.MentorSlotErrorCode;
+import com.back.global.exception.ServiceException;
+
+import java.time.Duration;
+import java.time.LocalDateTime;
+
+public class MentorSlotValidator {
+
+    private static final int MIN_SLOT_DURATION = 20;
+
+    public static void validateNotNull(LocalDateTime start, LocalDateTime end) {
+        if (start == null) {
+            throw new ServiceException(MentorSlotErrorCode.START_TIME_REQUIRED);
+        }
+        if (end == null) {
+            throw new ServiceException(MentorSlotErrorCode.END_TIME_REQUIRED);
+        }
+    }
+
+    public static void validateTimeRange(LocalDateTime start, LocalDateTime end) {
+        if (!end.isAfter(start)) {
+            throw new ServiceException(MentorSlotErrorCode.END_TIME_BEFORE_START);
+        }
+        if (start.isBefore(LocalDateTime.now())) {
+            throw new ServiceException(MentorSlotErrorCode.START_TIME_IN_PAST);
+        }
+    }
+
+    public static void validateMinimumDuration(LocalDateTime start, LocalDateTime end) {
+        long duration = Duration.between(start, end).toMinutes();
+        if (duration < MIN_SLOT_DURATION) {
+            throw new ServiceException(MentorSlotErrorCode.INSUFFICIENT_SLOT_DURATION);
+        }
+    }
+
+    public static void validateTimeSlot(LocalDateTime start, LocalDateTime end) {
+        validateNotNull(start, end);
+        validateTimeRange(start, end);
+        validateMinimumDuration(start, end);
+    }
+}
diff --git a/back/src/main/java/com/back/domain/news/comment/controller/CommentController.java b/back/src/main/java/com/back/domain/news/comment/controller/CommentController.java
new file mode 100644
index 00000000..361b27fd
--- /dev/null
+++ b/back/src/main/java/com/back/domain/news/comment/controller/CommentController.java
@@ -0,0 +1,89 @@
+package com.back.domain.news.comment.controller;
+
+import com.back.domain.member.member.entity.Member;
+import com.back.domain.news.comment.dto.CommentCreateRequest;
+import com.back.domain.news.comment.dto.CommentResponse;
+import com.back.domain.news.comment.dto.CommentUpdateRequest;
+import com.back.domain.news.comment.entity.Comment;
+import com.back.domain.news.comment.service.CommentService;
+import com.back.domain.news.news.entity.News;
+import com.back.domain.news.news.service.NewsService;
+import com.back.global.rq.Rq;
+import com.back.global.rsData.RsData;
+import io.swagger.v3.oas.annotations.Operation;
+import lombok.RequiredArgsConstructor;
+import org.springframework.security.access.AccessDeniedException;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+@RestController
+@RequestMapping("/news/{newsId}/comment")
+@RequiredArgsConstructor
+public class CommentController {
+    private final NewsService newsService;
+    private final CommentService commentService;
+    private final Rq rq;
+
+    @GetMapping
+    @Operation(summary = "댓글 목록 조회", description = "특정 뉴스의 댓글 목록을 불러옵니다.")
+    public RsData<List<CommentResponse>> getComments(@PathVariable Long newsId) {
+        News news = newsService.getNewsById(newsId);
+        List<Comment> comments = commentService.getComments(news);
+        List<CommentResponse> commentResponses = comments.stream()
+                .map(CommentResponse::new)
+                .collect(Collectors.toList());
+        return new RsData<>("200", "댓글 목록 불러오기 완료", commentResponses);
+    }
+
+    @PostMapping
+    @Operation(summary = "댓글 생성", description = "특정 뉴스에 댓글을 생성합니다. 로그인한 사용자만 접근할 수 있습니다.")
+    public RsData<CommentResponse> createComment(@PathVariable Long newsId, @RequestBody CommentCreateRequest request) {
+        Member member = rq.getActor();
+        if (member == null) {
+            return new RsData<>("401", "로그인이 필요합니다.");
+        }
+        News news = newsService.getNewsById(newsId);
+        Comment comment = commentService.createComment(member, news, request.content());
+        CommentResponse commentResponse = new CommentResponse(comment);
+        return new RsData<>("201", "댓글 생성 완료", commentResponse);
+    }
+
+    @PutMapping("/{commentId}")
+    @Operation(summary = "댓글 수정", description = "특정 뉴스의 댓글을 수정합니다. 댓글 작성자만 접근할 수 있습니다.")
+    public RsData<CommentResponse> updateComment(@PathVariable Long newsId, @PathVariable Long commentId, @RequestBody CommentUpdateRequest request) {
+        Member member = rq.getActor();
+        if (member == null) {
+            return new RsData<>("401", "로그인이 필요합니다.");
+        }
+        try {
+            News news = newsService.getNewsById(newsId);
+            Comment updatedComment = commentService.updateComment(member, news, commentId, request.content());
+            CommentResponse commentResponse = new CommentResponse(updatedComment);
+            return new RsData<>("200", "댓글 수정 완료", commentResponse);
+        } catch (AccessDeniedException e) {
+            return new RsData<>("403", e.getMessage());
+        } catch (IllegalArgumentException e) {
+            return new RsData<>("400", e.getMessage());
+        }
+    }
+
+    @DeleteMapping("/{commentId}")
+    @Operation(summary = "댓글 삭제", description = "특정 뉴스의 댓글을 삭제합니다. 댓글 작성자만 접근할 수 있습니다.")
+    public RsData<Void> deleteComment(@PathVariable Long newsId, @PathVariable Long commentId) {
+        Member member = rq.getActor();
+        if (member == null) {
+            return new RsData<>("401", "로그인이 필요합니다.");
+        }
+        try {
+            News news = newsService.getNewsById(newsId);
+            commentService.deleteComment(member, news, commentId);
+            return new RsData<>("200", "댓글 삭제 완료");
+        } catch (AccessDeniedException e) {
+            return new RsData<>("403", e.getMessage());
+        } catch (IllegalArgumentException e) {
+            return new RsData<>("400", e.getMessage());
+        }
+    }
+}
diff --git a/back/src/main/java/com/back/domain/news/comment/dto/CommentCreateRequest.java b/back/src/main/java/com/back/domain/news/comment/dto/CommentCreateRequest.java
new file mode 100644
index 00000000..dc3ac171
--- /dev/null
+++ b/back/src/main/java/com/back/domain/news/comment/dto/CommentCreateRequest.java
@@ -0,0 +1,4 @@
+package com.back.domain.news.comment.dto;
+
+public record CommentCreateRequest(String content) {
+}
diff --git a/back/src/main/java/com/back/domain/news/comment/dto/CommentResponse.java b/back/src/main/java/com/back/domain/news/comment/dto/CommentResponse.java
new file mode 100644
index 00000000..cf852e15
--- /dev/null
+++ b/back/src/main/java/com/back/domain/news/comment/dto/CommentResponse.java
@@ -0,0 +1,23 @@
+package com.back.domain.news.comment.dto;
+
+import com.back.domain.news.comment.entity.Comment;
+import lombok.Getter;
+
+import java.time.LocalDateTime;
+
+@Getter
+public class CommentResponse {
+    private final Long id;
+    private final String content;
+    private final String author;
+    private final LocalDateTime createdDate;
+    private final LocalDateTime modifiedDate;
+
+    public CommentResponse(Comment comment) {
+        this.id = comment.getId();
+        this.content = comment.getContent();
+        this.author = comment.getMember().getName();
+        this.createdDate = comment.getCreateDate();
+        this.modifiedDate = comment.getModifyDate();
+    }
+}
diff --git a/back/src/main/java/com/back/domain/news/comment/dto/CommentUpdateRequest.java b/back/src/main/java/com/back/domain/news/comment/dto/CommentUpdateRequest.java
new file mode 100644
index 00000000..8b27898c
--- /dev/null
+++ b/back/src/main/java/com/back/domain/news/comment/dto/CommentUpdateRequest.java
@@ -0,0 +1,4 @@
+package com.back.domain.news.comment.dto;
+
+public record CommentUpdateRequest(String content) {
+}
diff --git a/back/src/main/java/com/back/domain/news/comment/entity/Comment.java b/back/src/main/java/com/back/domain/news/comment/entity/Comment.java
new file mode 100644
index 00000000..647255d6
--- /dev/null
+++ b/back/src/main/java/com/back/domain/news/comment/entity/Comment.java
@@ -0,0 +1,58 @@
+package com.back.domain.news.comment.entity;
+
+import com.back.domain.member.member.entity.Member;
+import com.back.domain.news.news.entity.News;
+import com.back.global.jpa.BaseEntity;
+import jakarta.persistence.Entity;
+import jakarta.persistence.JoinColumn;
+import jakarta.persistence.ManyToOne;
+import lombok.AccessLevel;
+import lombok.Builder;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+
+@Getter
+@Entity
+@NoArgsConstructor(access = AccessLevel.PROTECTED)
+public class Comment extends BaseEntity {
+    @ManyToOne
+    private Member member;
+    @ManyToOne
+    @JoinColumn
+    private News news;
+    private String content;
+
+    @Builder(access = AccessLevel.PRIVATE)
+    private Comment(Member member, News news, String content) {
+        if (member == null) {
+            throw new IllegalArgumentException("Member cannot be null");
+        }
+        if (news == null) {
+            throw new IllegalArgumentException("News cannot be null");
+        }
+        if (content == null || content.isBlank()) {
+            throw new IllegalArgumentException("Content cannot be null or empty");
+        }
+        this.member = member;
+        this.news = news;
+        this.content = content;
+    }
+
+    public static Comment create(Member member, News news, String content) {
+        Comment comment = Comment.builder()
+                .member(member)
+                .news(news)
+                .content(content)
+                .build();
+
+        return comment;
+    }
+
+    public Comment update(String content) {
+        if (content == null || content.isBlank()) {
+            throw new IllegalArgumentException("Content cannot be null or empty");
+        }
+        this.content = content;
+        return this;
+    }
+}
diff --git a/back/src/main/java/com/back/domain/news/comment/repository/CommentRepository.java b/back/src/main/java/com/back/domain/news/comment/repository/CommentRepository.java
new file mode 100644
index 00000000..14909bb0
--- /dev/null
+++ b/back/src/main/java/com/back/domain/news/comment/repository/CommentRepository.java
@@ -0,0 +1,13 @@
+package com.back.domain.news.comment.repository;
+
+import com.back.domain.news.comment.entity.Comment;
+import com.back.domain.news.news.entity.News;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+
+@Repository
+public interface CommentRepository extends JpaRepository<Comment, Long> {
+    List<Comment> findByNews(News news);
+}
diff --git a/back/src/main/java/com/back/domain/news/comment/service/CommentService.java b/back/src/main/java/com/back/domain/news/comment/service/CommentService.java
new file mode 100644
index 00000000..8644cb49
--- /dev/null
+++ b/back/src/main/java/com/back/domain/news/comment/service/CommentService.java
@@ -0,0 +1,59 @@
+package com.back.domain.news.comment.service;
+
+import com.back.domain.member.member.entity.Member;
+import com.back.domain.news.comment.entity.Comment;
+import com.back.domain.news.comment.repository.CommentRepository;
+import com.back.domain.news.news.entity.News;
+import lombok.RequiredArgsConstructor;
+import org.springframework.security.access.AccessDeniedException;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.List;
+import java.util.NoSuchElementException;
+
+@Service
+@RequiredArgsConstructor
+@Transactional(readOnly = true)
+public class CommentService {
+    private final CommentRepository commentRepository;
+
+    public Comment createComment(Member member, News news, String content) {
+        Comment comment = Comment.create(member, news, content);
+        return commentRepository.save(comment);
+    }
+
+    public List<Comment> getComments(News news) {
+        return commentRepository.findByNews(news);
+    }
+
+    public Comment getCommentById(Long commentId) {
+        return commentRepository.findById(commentId)
+                .orElseThrow(() -> new NoSuchElementException("Comment not found: " + commentId));
+    }
+
+    public Comment updateComment(Member member, News news, Long commentId, String content) {
+        Comment comment = getCommentById(commentId);
+
+        if (!comment.getMember().equals(member)) {
+            throw new AccessDeniedException("You do not have permission to update this comment.");
+        }
+        if (!comment.getNews().equals(news)) {
+            throw new IllegalArgumentException("This comment does not belong to the given news.");
+        }
+        comment.update(content);
+        return comment;
+    }
+
+    public void deleteComment(Member member, News news, Long commentId) {
+        Comment comment = getCommentById(commentId);
+
+        if (!comment.getMember().equals(member)) {
+            throw new AccessDeniedException("You do not have permission to delete this comment.");
+        }
+        if (!comment.getNews().equals(news)) {
+            throw new IllegalArgumentException("This comment does not belong to the given news.");
+        }
+        commentRepository.delete(comment);
+    }
+}
diff --git a/back/src/main/java/com/back/domain/news/like/entity/Like.java b/back/src/main/java/com/back/domain/news/like/entity/Like.java
new file mode 100644
index 00000000..4658afbb
--- /dev/null
+++ b/back/src/main/java/com/back/domain/news/like/entity/Like.java
@@ -0,0 +1,49 @@
+package com.back.domain.news.like.entity;
+
+import com.back.domain.member.member.entity.Member;
+import com.back.domain.news.news.entity.News;
+import com.back.global.jpa.BaseEntity;
+import jakarta.persistence.Entity;
+import jakarta.persistence.FetchType;
+import jakarta.persistence.ManyToOne;
+import jakarta.persistence.Table;
+import jakarta.persistence.UniqueConstraint;
+import lombok.AccessLevel;
+import lombok.Builder;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+
+@Getter
+@Entity
+@Table(name = "news_like", uniqueConstraints = {
+        @UniqueConstraint(columnNames = {"member_id", "news_id"})
+})
+@NoArgsConstructor(access = AccessLevel.PROTECTED)
+public class Like extends BaseEntity {
+
+    @ManyToOne(fetch = FetchType.LAZY)
+    private Member member;
+
+    @ManyToOne(fetch = FetchType.LAZY)
+    private News news;
+
+    @Builder(access = AccessLevel.PRIVATE)
+    private Like(Member member, News news) {
+        this.member = member;
+        this.news = news;
+    }
+
+    public static Like create(Member member, News news) {
+        if (member == null) {
+            throw new IllegalArgumentException("Member cannot be null");
+        }
+        if (news == null) {
+            throw new IllegalArgumentException("News cannot be null");
+        }
+        Like like = Like.builder()
+                .member(member)
+                .news(news)
+                .build();
+        return like;
+    }
+}
diff --git a/back/src/main/java/com/back/domain/news/like/repository/LikeRepository.java b/back/src/main/java/com/back/domain/news/like/repository/LikeRepository.java
new file mode 100644
index 00000000..b9735d36
--- /dev/null
+++ b/back/src/main/java/com/back/domain/news/like/repository/LikeRepository.java
@@ -0,0 +1,15 @@
+package com.back.domain.news.like.repository;
+
+import com.back.domain.member.member.entity.Member;
+import com.back.domain.news.like.entity.Like;
+import com.back.domain.news.news.entity.News;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+import java.util.Optional;
+
+@Repository
+public interface LikeRepository extends JpaRepository<Like, Long> {
+    Optional<Like> findByMemberAndNews(Member member, News news);
+    long countByNews(News news);
+}
\ No newline at end of file
diff --git a/back/src/main/java/com/back/domain/news/like/service/LikeService.java b/back/src/main/java/com/back/domain/news/like/service/LikeService.java
new file mode 100644
index 00000000..ff923bf5
--- /dev/null
+++ b/back/src/main/java/com/back/domain/news/like/service/LikeService.java
@@ -0,0 +1,39 @@
+package com.back.domain.news.like.service;
+
+import com.back.domain.member.member.entity.Member;
+import com.back.domain.news.like.entity.Like;
+import com.back.domain.news.like.repository.LikeRepository;
+import com.back.domain.news.news.entity.News;
+import com.back.domain.news.news.repository.NewsRepository;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.Optional;
+
+@Service
+@RequiredArgsConstructor
+@Transactional
+public class LikeService {
+    private final LikeRepository likeRepository;
+    private final NewsRepository newsRepository;
+
+    public Like likeNews(Member member, Long newsId) {
+        News news = newsRepository.findById(newsId)
+                .orElseThrow(() -> new IllegalArgumentException("해당 뉴스를 찾을 수 없습니다."));
+
+        Optional<Like> existingLike = likeRepository.findByMemberAndNews(member, news);
+        if (existingLike.isPresent()) {
+            throw new IllegalStateException("이미 좋아요를 누른 뉴스입니다.");
+        }
+
+        Like like = Like.create(member, news);
+        return likeRepository.save(like);
+    }
+
+    public long getLikeCount(Long newsId) {
+        News news = newsRepository.findById(newsId)
+                .orElseThrow(() -> new IllegalArgumentException("해당 뉴스를 찾을 수 없습니다."));
+        return likeRepository.countByNews(news);
+    }
+}
\ No newline at end of file
diff --git a/back/src/main/java/com/back/domain/news/news/controller/NewsController.java b/back/src/main/java/com/back/domain/news/news/controller/NewsController.java
new file mode 100644
index 00000000..cb86871d
--- /dev/null
+++ b/back/src/main/java/com/back/domain/news/news/controller/NewsController.java
@@ -0,0 +1,118 @@
+package com.back.domain.news.news.controller;
+
+import com.back.domain.file.entity.Video;
+import com.back.domain.file.service.VideoService;
+import com.back.domain.member.member.entity.Member;
+import com.back.domain.news.like.service.LikeService;
+import com.back.domain.news.news.dto.*;
+import com.back.domain.news.news.entity.News;
+import com.back.domain.news.news.service.NewsService;
+import com.back.global.rq.Rq;
+import com.back.global.rsData.RsData;
+import io.swagger.v3.oas.annotations.Operation;
+import lombok.RequiredArgsConstructor;
+import org.springframework.data.domain.Page;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+
+@RestController
+@RequestMapping("/news")
+@RequiredArgsConstructor
+public class NewsController {
+    private final NewsService newsService;
+    private final VideoService videoService;
+    private final LikeService likeService;
+    private final Rq rq;
+
+    @PostMapping
+    @Operation(summary = "뉴스 생성", description = "뉴스를 생성합니다. ADMIN 사용자만 접근할 수 있습니다.")
+    public RsData<NewsCreateResponse> createNews(@RequestBody NewsCreateRequest request) {
+        Member member = rq.getActorFromDb().get();
+        if (member == null) {
+            return new RsData<>("401", "로그인 후 이용해주세요.", null);
+        }
+        if (member.getRole() != Member.Role.ADMIN) {
+            return new RsData<>("403", "권한이 없습니다.", null);
+        }
+        Video video = videoService.getNewsByUuid(request.videoUuid());
+        News news = newsService.createNews(member, request.title(), video, request.content());
+        NewsCreateResponse response = new NewsCreateResponse(news.getTitle(), news.getVideo().getUuid(), news.getContent(), member.getName());
+        return new RsData<>("201", "뉴스가 생성되었습니다.", response);
+    }
+
+    @GetMapping("{newsId}")
+    @Operation(summary = "뉴스 단건 조회", description = "특정 ID의 뉴스를 읽어옵니다.")
+    public RsData<NewsGetResponse> getNews(@PathVariable("newsId") Long newsId) {
+        News news = newsService.getNewsById(newsId);
+        NewsGetResponse response = new NewsGetResponse(news);
+        return new RsData<>("200", "뉴스 읽어오기 완료", response);
+    }
+
+    @GetMapping
+    @Operation(summary = "뉴스 목록 조회", description = "뉴스 목록을 페이지 단위로 불러옵니다. 기본 페이지 크기는 10입니다.")
+    public RsData<List<NewsGetResponse>> getNewsList(
+            @RequestParam(defaultValue = "0") int page,
+            @RequestParam(defaultValue = "10") int size) {
+
+        Page<News> newsPage = newsService.getNewsByPage(page, size);
+
+        List<NewsGetResponse> responses = newsPage.getContent().stream()
+                .map(NewsGetResponse::new)
+                .toList();
+
+        return new RsData<>("200", "뉴스 목록 불러오기 완료", responses);
+    }
+
+    @PutMapping("{newsId}/likes")
+    @Operation(summary = "뉴스 좋아요", description = "특정 ID의 뉴스를 좋아요 합니다. 로그인한 사용자만 접근할 수 있습니다.")
+    public RsData<NewsLikeResponse> likeNews(@PathVariable("newsId") Long newsId) {
+        Member member = rq.getActorFromDb().get();
+        if (member == null) {
+            return new RsData<>("401", "로그인 후 이용해주세요.", null);
+        }
+        try {
+            likeService.likeNews(member, newsId);
+            NewsLikeResponse response = new NewsLikeResponse(member.getId(), newsId, likeService.getLikeCount(newsId));
+            return new RsData<>("200", "뉴스를 좋아합니다.", response);
+        } catch (IllegalArgumentException e) {
+            return new RsData<>("404", e.getMessage(), null);
+        }
+    }
+
+    @PutMapping("{newsId}")
+    @Operation(summary = "뉴스 수정", description = "특정 ID의 뉴스를 수정합니다. ADMIN 사용자만 접근할 수 있습니다.")
+    public RsData<NewsUpdateResponse> modifyNews(@PathVariable("newsId") Long newsId, @RequestBody NewsUpdateRequest request) {
+        Member member = rq.getActorFromDb().get();
+        if (member == null) {
+            return new RsData<>("401", "로그인 후 이용해주세요.", null);
+        }
+        if (member.getRole() != Member.Role.ADMIN) {
+            return new RsData<>("403", "권한이 없습니다.", null);
+        }
+        try {
+            News news = newsService.getNewsById(newsId);
+            Video video = videoService.getNewsByUuid(request.videoUuid());
+            News updatedNews = newsService.updateNews(member, news, request.title(), video, request.content());
+            NewsUpdateResponse response = new NewsUpdateResponse(updatedNews);
+            return new RsData<>("200", "뉴스가 수정되었습니다.", response);
+        } catch (IllegalArgumentException e) {
+            return new RsData<>("404", e.getMessage(), null);
+        }
+    }
+
+    @DeleteMapping("{newsId}")
+    @Operation(summary = "뉴스 삭제", description = "특정 ID의 뉴스를 삭제합니다. ADMIN 사용자만 접근할 수 있습니다.")
+    public RsData<?> deleteNews(@PathVariable("newsId") Long newsId) {
+        Member member = rq.getActorFromDb().get();
+        if (member == null){
+            return new RsData<>("401", "로그인 후 이용해주세요.", null);
+        }
+        if (member.getRole() != Member.Role.ADMIN) {
+            return new RsData<>("403", "권한이 없습니다.", null);
+        }
+        News news = newsService.getNewsById(newsId);
+        newsService.deleteNews(member, news);
+        return new RsData<>("200", newsId + "번 뉴스가 삭제되었습니다.", null);
+    }
+}
diff --git a/back/src/main/java/com/back/domain/news/news/dto/NewsCreateRequest.java b/back/src/main/java/com/back/domain/news/news/dto/NewsCreateRequest.java
new file mode 100644
index 00000000..390da742
--- /dev/null
+++ b/back/src/main/java/com/back/domain/news/news/dto/NewsCreateRequest.java
@@ -0,0 +1,8 @@
+package com.back.domain.news.news.dto;
+
+public record NewsCreateRequest(
+        String title,
+        String videoUuid,
+        String content
+        ) {
+}
diff --git a/back/src/main/java/com/back/domain/news/news/dto/NewsCreateResponse.java b/back/src/main/java/com/back/domain/news/news/dto/NewsCreateResponse.java
new file mode 100644
index 00000000..94579e17
--- /dev/null
+++ b/back/src/main/java/com/back/domain/news/news/dto/NewsCreateResponse.java
@@ -0,0 +1,15 @@
+package com.back.domain.news.news.dto;
+
+public record NewsCreateResponse(
+        String title,
+        String videoUrl,
+        String content,
+        String author
+) {
+    public NewsCreateResponse(String title, String videoUrl, String content, String author) {
+        this.title = title;
+        this.videoUrl = videoUrl;
+        this.content = content;
+        this.author = author;
+    }
+}
diff --git a/back/src/main/java/com/back/domain/news/news/dto/NewsGetResponse.java b/back/src/main/java/com/back/domain/news/news/dto/NewsGetResponse.java
new file mode 100644
index 00000000..40a9cd10
--- /dev/null
+++ b/back/src/main/java/com/back/domain/news/news/dto/NewsGetResponse.java
@@ -0,0 +1,25 @@
+package com.back.domain.news.news.dto;
+
+import com.back.domain.news.news.entity.News;
+
+import java.time.LocalDateTime;
+
+public record NewsGetResponse(
+        String title,
+        String videoUuid,
+        String content,
+        String authorId,
+        LocalDateTime createdAt,
+        LocalDateTime updatedAt
+) {
+    public NewsGetResponse(News news) {
+        this(
+                news.getTitle(),
+                news.getVideo().getUuid(),
+                news.getContent(),
+                news.getMember().getName(),
+                news.getCreateDate(),
+                news.getModifyDate()
+        );
+    }
+}
diff --git a/back/src/main/java/com/back/domain/news/news/dto/NewsLikeResponse.java b/back/src/main/java/com/back/domain/news/news/dto/NewsLikeResponse.java
new file mode 100644
index 00000000..054de3d1
--- /dev/null
+++ b/back/src/main/java/com/back/domain/news/news/dto/NewsLikeResponse.java
@@ -0,0 +1,9 @@
+package com.back.domain.news.news.dto;
+
+
+public record NewsLikeResponse(
+        Long memberId,
+        Long newsId,
+        Long like
+) {
+}
\ No newline at end of file
diff --git a/back/src/main/java/com/back/domain/news/news/dto/NewsUpdateRequest.java b/back/src/main/java/com/back/domain/news/news/dto/NewsUpdateRequest.java
new file mode 100644
index 00000000..bc531918
--- /dev/null
+++ b/back/src/main/java/com/back/domain/news/news/dto/NewsUpdateRequest.java
@@ -0,0 +1,7 @@
+package com.back.domain.news.news.dto;
+
+public record NewsUpdateRequest(
+        String title,
+        String content,
+        String videoUuid
+) {}
diff --git a/back/src/main/java/com/back/domain/news/news/dto/NewsUpdateResponse.java b/back/src/main/java/com/back/domain/news/news/dto/NewsUpdateResponse.java
new file mode 100644
index 00000000..6a64a67f
--- /dev/null
+++ b/back/src/main/java/com/back/domain/news/news/dto/NewsUpdateResponse.java
@@ -0,0 +1,21 @@
+package com.back.domain.news.news.dto;
+
+import com.back.domain.news.news.entity.News;
+
+public record NewsUpdateResponse(
+        Long id,
+        String title,
+        String content,
+        String videoUuid,
+        String authorName
+) {
+    public NewsUpdateResponse(News news) {
+        this(
+                news.getId(),
+                news.getTitle(),
+                news.getContent(),
+                news.getVideo().getUuid(),
+                news.getMember().getName()
+        );
+    }
+}
diff --git a/back/src/main/java/com/back/domain/news/news/entity/News.java b/back/src/main/java/com/back/domain/news/news/entity/News.java
new file mode 100644
index 00000000..d4fc8735
--- /dev/null
+++ b/back/src/main/java/com/back/domain/news/news/entity/News.java
@@ -0,0 +1,111 @@
+package com.back.domain.news.news.entity;
+
+import com.back.domain.file.entity.Video;
+import com.back.domain.member.member.entity.Member;
+import com.back.domain.news.comment.entity.Comment;
+import com.back.domain.news.like.entity.Like;
+import com.back.global.jpa.BaseEntity;
+import jakarta.persistence.*;
+import lombok.AccessLevel;
+import lombok.Builder;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+
+import java.util.ArrayList;
+import java.util.List;
+
+@Getter
+@Entity
+@NoArgsConstructor(access = AccessLevel.PROTECTED)
+public class News extends BaseEntity {
+    @ManyToOne
+    private Member member;
+    private String title;
+    @OneToOne
+    private Video video;
+    private String content;
+    @OneToMany(mappedBy = "news", cascade = CascadeType.ALL, orphanRemoval = true)
+    private List<Comment> comment;
+    @OneToMany(mappedBy = "news", cascade = CascadeType.ALL, orphanRemoval = true)
+    private List<Like> likes = new ArrayList<>();
+
+    @Builder(access = AccessLevel.PRIVATE)
+    private News(Member member, String title, Video video, String content, List<Comment> comment, List<Like> likes) {
+        this.member = member;
+        this.title = title;
+        this.video = video;
+        this.content = content;
+        this.comment = comment;
+        this.likes = likes;
+    }
+
+    public static News create(Member member, String title, Video video, String content) {
+        if (member == null) {
+            throw new IllegalArgumentException("Member cannot be null");
+        }
+        if (title == null || title.isBlank()) {
+            throw new IllegalArgumentException("Title cannot be null or empty");
+        }
+        if (video == null) {
+            throw new IllegalArgumentException("Video cannot be null");
+        }
+        if (content == null || content.isBlank()) {
+            throw new IllegalArgumentException("Content cannot be null or empty");
+        }
+        return News.builder()
+                .member(member)
+                .title(title)
+                .video(video)
+                .content(content)
+                .comment(new ArrayList<>())
+                .likes(new ArrayList<>())
+                .build();
+    }
+
+    public void like(Like like) {
+        if (this.likes.contains(like)) {
+            throw new IllegalStateException("이미 좋아요를 누른 뉴스입니다.");
+        }
+        this.likes.add(like);
+    }
+
+    /**
+     * 좋아요를 취소할 수 있게 해야할까요?
+     */
+    @Deprecated(forRemoval = true)
+    public void unLike(Like like) {
+        if (!this.likes.contains(like)) {
+            throw new IllegalStateException("좋아요를 누르지 않은 뉴스입니다.");
+        }
+        this.likes.remove(like);
+    }
+
+    public void addComment(Comment comment) {
+        if (comment == null) {
+            throw new IllegalArgumentException("Comment cannot be null");
+        }
+        this.comment.add(comment);
+    }
+
+    public void removeComment(Comment comment) {
+        if (comment == null) {
+            throw new IllegalArgumentException("Comment cannot be null");
+        }
+        this.comment.remove(comment);
+    }
+
+    public void update(String title, Video video, String content) {
+        if (title == null || title.isBlank()) {
+            throw new IllegalArgumentException("Title cannot be null or empty");
+        }
+        if (video == null) {
+            throw new IllegalArgumentException("Video cannot be null");
+        }
+        if (content == null || content.isBlank()) {
+            throw new IllegalArgumentException("Content cannot be null or empty");
+        }
+        this.title = title;
+        this.video = video;
+        this.content = content;
+    }
+}
diff --git a/back/src/main/java/com/back/domain/news/news/repository/NewsRepository.java b/back/src/main/java/com/back/domain/news/news/repository/NewsRepository.java
new file mode 100644
index 00000000..0e948ad9
--- /dev/null
+++ b/back/src/main/java/com/back/domain/news/news/repository/NewsRepository.java
@@ -0,0 +1,9 @@
+package com.back.domain.news.news.repository;
+
+import com.back.domain.news.news.entity.News;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+@Repository
+public interface NewsRepository extends JpaRepository<News, Long> {
+}
diff --git a/back/src/main/java/com/back/domain/news/news/service/NewsService.java b/back/src/main/java/com/back/domain/news/news/service/NewsService.java
new file mode 100644
index 00000000..36222a78
--- /dev/null
+++ b/back/src/main/java/com/back/domain/news/news/service/NewsService.java
@@ -0,0 +1,50 @@
+package com.back.domain.news.news.service;
+
+
+import com.back.domain.file.entity.Video;
+import com.back.domain.member.member.entity.Member;
+import com.back.domain.news.news.entity.News;
+import com.back.domain.news.news.repository.NewsRepository;
+import lombok.RequiredArgsConstructor;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.domain.Sort;
+import org.springframework.stereotype.Service;
+
+import java.util.NoSuchElementException;
+
+@Service
+@RequiredArgsConstructor
+public class NewsService {
+    private final NewsRepository newsRepository;
+
+    public News createNews(Member member, String title, Video video, String content) {
+        News news = News.create(member, title, video, content);
+        return newsRepository.save(news);
+    }
+
+    public Page<News> getNewsByPage(int page, int size) {
+        Pageable pageable = PageRequest.of(page, size, Sort.by("createDate").descending());
+        return newsRepository.findAll(pageable);
+    }
+
+    public News getNewsById(Long id) {
+        return newsRepository.findById(id).orElseThrow(() -> new NoSuchElementException("뉴스를 찾을 수 없습니다."));
+    }
+
+    public News updateNews(Member member, News news, String title, Video video, String content) {
+        if (!(member.getRole()== Member.Role.ADMIN)) {
+            throw new SecurityException("수정 권한이 없습니다.");
+        }
+        news.update(title, video, content);
+        return newsRepository.save(news);
+    }
+
+    public void deleteNews(Member member, News news) {
+        if (!(member.getRole()== Member.Role.ADMIN)) {
+            throw new SecurityException("삭제 권한이 없습니다.");
+        }
+        newsRepository.delete(news);
+    }
+}
diff --git a/back/src/main/java/com/back/domain/post/comment/controller/PostCommentController.java b/back/src/main/java/com/back/domain/post/comment/controller/PostCommentController.java
new file mode 100644
index 00000000..2655cca6
--- /dev/null
+++ b/back/src/main/java/com/back/domain/post/comment/controller/PostCommentController.java
@@ -0,0 +1,70 @@
+package com.back.domain.post.comment.controller;
+
+import com.back.domain.member.member.entity.Member;
+import com.back.domain.post.comment.dto.CommentAllResponse;
+import com.back.domain.post.comment.dto.CommentCreateRequest;
+import com.back.domain.post.comment.dto.CommentDeleteRequest;
+import com.back.domain.post.comment.dto.CommentModifyRequest;
+import com.back.domain.post.comment.service.PostCommentService;
+import com.back.global.rq.Rq;
+import com.back.global.rsData.RsData;
+import io.swagger.v3.oas.annotations.Operation;
+import jakarta.validation.Valid;
+import jakarta.validation.constraints.Positive;
+import lombok.RequiredArgsConstructor;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+
+@RestController
+@RequestMapping("/post/comment")
+public class PostCommentController {
+    @Autowired
+    private Rq rq;
+    @Autowired
+    private PostCommentService postCommentService;
+
+    @Operation(summary = "댓글 생성")
+    @PostMapping("/post/{post_id}")
+    public RsData<Void> createComment(@PathVariable Long post_id,
+                                      @Valid @RequestBody CommentCreateRequest commentCreateRequest
+    ) {
+        Member member = rq.getActor();
+        postCommentService.createComment(member, post_id, commentCreateRequest);
+
+        return new RsData<>("200", "댓글 작성 완료", null);
+    }
+
+    @Operation(summary = "댓글 다건 조회")
+    @GetMapping("/post/{post_id}")
+    @Transactional(readOnly = true)
+    public RsData<List<CommentAllResponse>> getAllPostComment(@PathVariable Long post_id) {
+        List<CommentAllResponse> postAllResponse = postCommentService.getAllPostCommentResponse(post_id);
+        return new RsData<>("200", "게시글 다건 조회 성공", postAllResponse);
+    }
+
+    @Operation(summary = "댓글 삭제")
+    @DeleteMapping("/post/{post_id}/comment")
+    public RsData<Void> removePostComment(@PathVariable @Positive Long post_id
+            , @RequestBody @Valid CommentDeleteRequest commentDeleteRequest) {
+        Member member = rq.getActor();
+
+        postCommentService.removePostComment(post_id, commentDeleteRequest, member);
+
+        return new RsData<>("200", "게시글 삭제 성공", null);
+    }
+
+    @Operation(summary = "댓글 수정")
+    @PutMapping("/post/{post_id}/comment/")
+    public RsData<Void> updatePostComment(@PathVariable Long post_id
+            , @Valid @RequestBody CommentModifyRequest commentModifyRequest) {
+        Member member = rq.getActor();
+
+        postCommentService.updatePostComment(post_id, commentModifyRequest, member);
+
+        return new RsData<>("200", "댓글 수정 성공", null);
+    }
+
+}
diff --git a/back/src/main/java/com/back/domain/post/comment/dto/CommentAllResponse.java b/back/src/main/java/com/back/domain/post/comment/dto/CommentAllResponse.java
new file mode 100644
index 00000000..562601bb
--- /dev/null
+++ b/back/src/main/java/com/back/domain/post/comment/dto/CommentAllResponse.java
@@ -0,0 +1,23 @@
+package com.back.domain.post.comment.dto;
+
+import com.back.domain.post.comment.entity.PostComment;
+import lombok.Data;
+
+import java.time.LocalDateTime;
+
+@Data
+public class CommentAllResponse {
+    Long id;
+    String content;
+    String authorName;
+    LocalDateTime createdAt;
+
+    public static CommentAllResponse from(PostComment comment) {
+        CommentAllResponse response = new CommentAllResponse();
+        response.setId(comment.getId());
+        response.setContent(comment.getContent());
+        response.setAuthorName(comment.getMember().getName()); // Member에서 이름 가져오기
+        response.setCreatedAt(comment.getCreateDate());
+        return response;
+    }
+}
diff --git a/back/src/main/java/com/back/domain/post/comment/dto/CommentCreateRequest.java b/back/src/main/java/com/back/domain/post/comment/dto/CommentCreateRequest.java
new file mode 100644
index 00000000..12ea86d8
--- /dev/null
+++ b/back/src/main/java/com/back/domain/post/comment/dto/CommentCreateRequest.java
@@ -0,0 +1,12 @@
+package com.back.domain.post.comment.dto;
+
+import jakarta.validation.constraints.NotBlank;
+import lombok.Data;
+
+@Data
+public class CommentCreateRequest {
+    private Long postId;
+    private String role;
+    @NotBlank(message = "댓글을 입력해주세요")
+    private String comment;
+}
diff --git a/back/src/main/java/com/back/domain/post/comment/dto/CommentDeleteRequest.java b/back/src/main/java/com/back/domain/post/comment/dto/CommentDeleteRequest.java
new file mode 100644
index 00000000..4f95ea0d
--- /dev/null
+++ b/back/src/main/java/com/back/domain/post/comment/dto/CommentDeleteRequest.java
@@ -0,0 +1,10 @@
+package com.back.domain.post.comment.dto;
+
+import jakarta.validation.constraints.NotNull;
+import lombok.Data;
+
+@Data
+public class CommentDeleteRequest {
+    @NotNull
+    private Long CommentId;
+}
diff --git a/back/src/main/java/com/back/domain/post/comment/dto/CommentModifyRequest.java b/back/src/main/java/com/back/domain/post/comment/dto/CommentModifyRequest.java
new file mode 100644
index 00000000..ee3d79ac
--- /dev/null
+++ b/back/src/main/java/com/back/domain/post/comment/dto/CommentModifyRequest.java
@@ -0,0 +1,13 @@
+package com.back.domain.post.comment.dto;
+
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.NotNull;
+import lombok.Data;
+
+@Data
+public class CommentModifyRequest {
+    @NotNull
+    private Long commentId;
+    @NotBlank(message = "공백일 수 없습니다.")
+    private String content;
+}
diff --git a/back/src/main/java/com/back/domain/post/comment/entity/PostComment.java b/back/src/main/java/com/back/domain/post/comment/entity/PostComment.java
new file mode 100644
index 00000000..208e1210
--- /dev/null
+++ b/back/src/main/java/com/back/domain/post/comment/entity/PostComment.java
@@ -0,0 +1,26 @@
+package com.back.domain.post.comment.entity;
+
+import com.back.domain.member.member.entity.Member;
+import com.back.domain.post.post.entity.Post;
+import com.back.global.jpa.BaseEntity;
+import jakarta.persistence.Entity;
+import jakarta.persistence.FetchType;
+import jakarta.persistence.ManyToOne;
+import lombok.Getter;
+import lombok.Setter;
+
+@Entity
+@Getter
+@Setter
+public class PostComment extends BaseEntity {
+    @ManyToOne(fetch = FetchType.LAZY)
+    private Post post;
+
+    private String content;
+
+    @ManyToOne(fetch = FetchType.LAZY)
+    private Member member;
+
+    private String role;
+
+}
diff --git a/back/src/main/java/com/back/domain/post/comment/repository/PostCommentRepository.java b/back/src/main/java/com/back/domain/post/comment/repository/PostCommentRepository.java
new file mode 100644
index 00000000..1c2ab975
--- /dev/null
+++ b/back/src/main/java/com/back/domain/post/comment/repository/PostCommentRepository.java
@@ -0,0 +1,9 @@
+package com.back.domain.post.comment.repository;
+
+import com.back.domain.post.comment.entity.PostComment;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+@Repository
+public interface PostCommentRepository extends JpaRepository<PostComment, Long> {
+}
diff --git a/back/src/main/java/com/back/domain/post/comment/service/PostCommentService.java b/back/src/main/java/com/back/domain/post/comment/service/PostCommentService.java
new file mode 100644
index 00000000..424fa485
--- /dev/null
+++ b/back/src/main/java/com/back/domain/post/comment/service/PostCommentService.java
@@ -0,0 +1,82 @@
+package com.back.domain.post.comment.service;
+
+import com.back.domain.member.member.entity.Member;
+import com.back.domain.post.comment.dto.CommentAllResponse;
+import com.back.domain.post.comment.dto.CommentCreateRequest;
+import com.back.domain.post.comment.dto.CommentDeleteRequest;
+import com.back.domain.post.comment.dto.CommentModifyRequest;
+import com.back.domain.post.comment.entity.PostComment;
+import com.back.domain.post.comment.repository.PostCommentRepository;
+import com.back.domain.post.post.entity.Post;
+import com.back.domain.post.post.repository.PostRepository;
+import com.back.global.exception.ServiceException;
+import jakarta.transaction.Transactional;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+
+import java.util.List;
+import java.util.Objects;
+
+@Service
+@RequiredArgsConstructor
+public class PostCommentService {
+    private final PostRepository postRepository;
+    private final PostCommentRepository postCommentRepository;
+
+    @Transactional
+    public void createComment(Member member, Long postId, CommentCreateRequest commentCreateRequest) {
+        Post post = postRepository.findById(postId).orElseThrow(() -> new ServiceException("400", "해당 Id의 게시글이 없습니다."));
+
+        PostComment postComment = new PostComment();
+
+        postComment.setContent(commentCreateRequest.getComment());
+        postComment.setMember(member);
+        postComment.setRole(String.valueOf(member.getRole()));
+
+        post.addComment(postComment);
+
+        postCommentRepository.save(postComment);
+
+    }
+
+    public List<CommentAllResponse> getAllPostCommentResponse(Long postId) {
+        Post post = postRepository.findById(postId).orElseThrow(() -> new ServiceException("400", "해당 Id의 게시글이 없습니다."));
+
+        List<PostComment> listPostComment = post.getComments();
+
+
+        return listPostComment.stream()
+                .map(CommentAllResponse::from)
+                .toList();
+    }
+
+    public void removePostComment(Long postId, CommentDeleteRequest commentDeleteRequest, Member member) {
+        Post post = postRepository.findById(postId).orElseThrow(() -> new ServiceException("400", "해당 Id의 게시글이 없습니다."));
+
+        PostComment postComment = postCommentRepository.findById(commentDeleteRequest.getCommentId()).orElseThrow(() -> new ServiceException("400", "해당 Id의 댓글이 없습니다."));
+        Member author = postComment.getMember();
+
+
+        if(!Objects.equals(member.getId(), author.getId())) {
+            throw new ServiceException("400", "삭제 권한이 없습니다.");
+        }
+
+        postCommentRepository.delete(postComment);
+
+    }
+
+    @Transactional
+    public void updatePostComment(Long postId, CommentModifyRequest commentModifyRequest, Member member) {
+        Post post = postRepository.findById(postId).orElseThrow(() -> new ServiceException("400", "해당 Id의 게시글이 없습니다."));
+
+        PostComment postComment = postCommentRepository.findById(commentModifyRequest.getCommentId()).orElseThrow(() -> new ServiceException("400", "해당 Id의 댓글이 없습니다."));
+        Member author = postComment.getMember();
+
+
+        if(!Objects.equals(member.getId(), author.getId())) {
+            throw new ServiceException("400", "수정 권한이 없습니다.");
+        }
+
+        postComment.setContent(commentModifyRequest.getContent());
+    }
+}
diff --git a/back/src/main/java/com/back/domain/post/post/controller/InformationPostController.java b/back/src/main/java/com/back/domain/post/post/controller/InformationPostController.java
new file mode 100644
index 00000000..47415bf9
--- /dev/null
+++ b/back/src/main/java/com/back/domain/post/post/controller/InformationPostController.java
@@ -0,0 +1,117 @@
+package com.back.domain.post.post.controller;
+
+import com.back.domain.member.member.entity.Member;
+import com.back.domain.post.post.dto.*;
+import com.back.domain.post.post.entity.Post;
+import com.back.domain.post.post.service.PostService;
+import com.back.global.rq.Rq;
+import com.back.global.rsData.RsData;
+import io.swagger.v3.oas.annotations.Operation;
+import jakarta.validation.Valid;
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.domain.Sort;
+import org.springframework.data.web.PageableDefault;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+
+@RestController
+@RequestMapping("post/infor")
+@RequiredArgsConstructor
+public class InformationPostController {
+    private final PostService postService;
+    private final Rq rq;
+
+
+    @Operation(summary = "게시글 조회 - 페이징 처리")
+    @GetMapping
+    public RsData<PostPagingResponse> getPostWithPage(
+            @RequestParam(defaultValue = "0") int page,
+            @RequestParam(defaultValue = "10") int size,
+            @RequestParam(required = false) String keyword
+    ) {
+        Page<PostDto> postPage = postService.getPosts(keyword, page,size);
+        PostPagingResponse resDto = PostPagingResponse.from(postPage);
+
+        return new RsData<>("200", "게시글이 조회 되었습니다.", resDto);
+    }
+
+    @Operation(summary = "게시글 생성")
+    @PostMapping
+    public RsData<PostCreateResponse> createPost(
+            @Valid @RequestBody PostCreateRequest postCreateRequest
+            ) {
+        Member member = rq.getActor();
+        Post post = postService.createPost(postCreateRequest, member);
+        PostCreateResponse postCreateResponse = PostCreateResponse.from(post);
+
+        return new RsData<>("200", "게시글이 성공적으로 생성되었습니다.", postCreateResponse);
+    }
+
+    @Operation(summary = "게시글 다건 조회")
+    @GetMapping("/all")
+    public RsData<List<PostAllResponse>> getAllPost() {
+        List<PostAllResponse> postAllResponse = postService.getAllPostResponse();
+
+
+        return new RsData<>("200", "게시글 다건 조회 성공", postAllResponse);
+    }
+
+    @Operation(summary = "게시글 단건 조회")
+    @GetMapping("/{post_id}")
+    public RsData<PostSingleResponse> getSinglePost(@PathVariable Long post_id) {
+        Post post = postService.findById(post_id);
+
+        PostSingleResponse postSingleResponse = new PostSingleResponse(post);
+
+        return new RsData<>("200", "게시글 단건 조회 성공", postSingleResponse);
+    }
+
+    @Operation(summary = "게시글 삭제")
+    @DeleteMapping("/{post_id}")
+    public RsData<Void> removePost(@PathVariable Long post_id) {
+        Member member = rq.getActor();
+
+        postService.removePost(post_id, member);
+
+        return new RsData<>("200", "게시글 삭제 성공", null);
+    }
+
+    @Operation(summary = "게시글 수정")
+    @PutMapping("/{post_id}")
+    public RsData<Void> updatePost(@PathVariable Long post_id
+            ,@Valid @RequestBody PostCreateRequest postCreateRequest) {
+        Member member = rq.getActor();
+        postService.updatePost(post_id, member, postCreateRequest);
+
+        return new RsData<>("200", "게시글 수정 성공", null);
+    }
+
+    @Operation(summary = "게시글 좋아요 + ")
+    @PostMapping("/{post_id}/liked")
+    public RsData<Void> likePost(@PathVariable Long post_id) {
+        postService.likePost(post_id);
+
+        return new RsData<>("200", "게시글 좋아요 성공", null);
+    }
+
+    @Operation(summary = "게시글 좋아요 (Show)")
+    @GetMapping("/{post_id}/liked")
+    public RsData<PostLikedResponse> getlike(@PathVariable Long post_id) {
+        int likeCount = postService.showLikeCount(post_id);
+        PostLikedResponse postLikedResponse = new PostLikedResponse(likeCount);
+
+        return new RsData<>("200", "게시글 좋아요 조회 성공", postLikedResponse);
+    }
+
+    @Operation(summary = "게시글 싫어요")
+    @PostMapping("/{post_id}/disliked")
+    public RsData<PostLikedResponse> disLikePost(@PathVariable Long post_id) {
+        postService.disLikePost(post_id);
+
+        return new RsData<>("200", "게시글 싫어요 성공", null);
+    }
+}
diff --git a/back/src/main/java/com/back/domain/post/post/dto/PostAllResponse.java b/back/src/main/java/com/back/domain/post/post/dto/PostAllResponse.java
new file mode 100644
index 00000000..ca25dcce
--- /dev/null
+++ b/back/src/main/java/com/back/domain/post/post/dto/PostAllResponse.java
@@ -0,0 +1,26 @@
+package com.back.domain.post.post.dto;
+
+import com.back.domain.post.post.entity.Post;
+import lombok.Data;
+
+import java.time.LocalDateTime;
+
+@Data
+public class PostAllResponse {
+    private Long id;
+    private String title;
+    private String authorName;
+    private LocalDateTime createdAt;
+    private int viewCount;
+    private int like;
+
+    public PostAllResponse(Post post) {
+        this.id = post.getId();
+        this.title = post.getTitle();
+        this.authorName = post.getAuthorName();
+        this.createdAt = post.getCreateDate();
+        this.viewCount = post.getViewCount();
+        this.like = post.getLiked();
+    }
+
+}
diff --git a/back/src/main/java/com/back/domain/post/post/dto/PostCreateRequest.java b/back/src/main/java/com/back/domain/post/post/dto/PostCreateRequest.java
new file mode 100644
index 00000000..1ff1838c
--- /dev/null
+++ b/back/src/main/java/com/back/domain/post/post/dto/PostCreateRequest.java
@@ -0,0 +1,14 @@
+package com.back.domain.post.post.dto;
+
+import jakarta.validation.constraints.NotBlank;
+import lombok.Data;
+
+@Data
+public class PostCreateRequest {
+    private Long memberId;
+    private String postType;
+    @NotBlank(message = "제목은 null 혹은 공백일 수 없습니다.")
+    private String title;
+    @NotBlank(message = "제목은 null 혹은 공백일 수 없습니다.")
+    private String content;
+}
diff --git a/back/src/main/java/com/back/domain/post/post/dto/PostCreateResponse.java b/back/src/main/java/com/back/domain/post/post/dto/PostCreateResponse.java
new file mode 100644
index 00000000..da16a1d2
--- /dev/null
+++ b/back/src/main/java/com/back/domain/post/post/dto/PostCreateResponse.java
@@ -0,0 +1,17 @@
+package com.back.domain.post.post.dto;
+
+import com.back.domain.post.post.entity.Post;
+import lombok.Data;
+
+@Data
+public class PostCreateResponse {
+    private Long postId;
+    private String title;
+
+    public static PostCreateResponse from(Post post) {
+        PostCreateResponse response = new PostCreateResponse();
+        response.setPostId(post.getId());
+        response.setTitle(post.getTitle());
+        return response;
+    }
+}
diff --git a/back/src/main/java/com/back/domain/post/post/dto/PostDto.java b/back/src/main/java/com/back/domain/post/post/dto/PostDto.java
new file mode 100644
index 00000000..e2a50698
--- /dev/null
+++ b/back/src/main/java/com/back/domain/post/post/dto/PostDto.java
@@ -0,0 +1,18 @@
+package com.back.domain.post.post.dto;
+
+
+import com.back.domain.post.post.entity.Post;
+
+public record PostDto(
+        Long postId,
+        String title,
+        String content
+) {
+    public static PostDto from(Post post) {
+        return new PostDto(
+                post.getId(),
+                post.getTitle(),
+                post.getContent()
+        );
+    }
+}
diff --git a/back/src/main/java/com/back/domain/post/post/dto/PostLikedResponse.java b/back/src/main/java/com/back/domain/post/post/dto/PostLikedResponse.java
new file mode 100644
index 00000000..95ac2847
--- /dev/null
+++ b/back/src/main/java/com/back/domain/post/post/dto/PostLikedResponse.java
@@ -0,0 +1,9 @@
+package com.back.domain.post.post.dto;
+
+public class PostLikedResponse {
+    int liked;
+
+    public PostLikedResponse(int liked) {
+        this.liked= liked;
+    }
+}
diff --git a/back/src/main/java/com/back/domain/post/post/dto/PostModifyRequest.java b/back/src/main/java/com/back/domain/post/post/dto/PostModifyRequest.java
new file mode 100644
index 00000000..0ff0b8c7
--- /dev/null
+++ b/back/src/main/java/com/back/domain/post/post/dto/PostModifyRequest.java
@@ -0,0 +1,9 @@
+package com.back.domain.post.post.dto;
+
+import lombok.Data;
+
+@Data
+public class PostModifyRequest {
+    String title;
+    String content;
+}
diff --git a/back/src/main/java/com/back/domain/post/post/dto/PostPagingResponse.java b/back/src/main/java/com/back/domain/post/post/dto/PostPagingResponse.java
new file mode 100644
index 00000000..cdc08383
--- /dev/null
+++ b/back/src/main/java/com/back/domain/post/post/dto/PostPagingResponse.java
@@ -0,0 +1,32 @@
+package com.back.domain.post.post.dto;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import org.springframework.data.domain.Page;
+
+import java.util.List;
+
+public record PostPagingResponse(
+        @Schema(description = "게시글 목록")
+        List<PostDto> posts,
+        @Schema(description = "현재 페이지 (0부터 시작)")
+        int currentPage,
+        @Schema(description = "총 페이지")
+        int totalPage,
+        @Schema(description = "총 개수")
+        long totalElements,
+        @Schema(description = "다음 페이지 존재 여부")
+        boolean hasNext
+) {
+
+    public static PostPagingResponse from(Page<PostDto> page) {
+        return new PostPagingResponse(
+                page.getContent(),
+                page.getNumber(),
+                page.getTotalPages(),
+                page.getTotalElements(),
+                page.hasNext()
+                );
+    }
+
+}
+
diff --git a/back/src/main/java/com/back/domain/post/post/dto/PostSingleResponse.java b/back/src/main/java/com/back/domain/post/post/dto/PostSingleResponse.java
new file mode 100644
index 00000000..6c079709
--- /dev/null
+++ b/back/src/main/java/com/back/domain/post/post/dto/PostSingleResponse.java
@@ -0,0 +1,25 @@
+package com.back.domain.post.post.dto;
+
+import com.back.domain.post.post.entity.Post;
+import lombok.Data;
+
+import java.time.LocalDateTime;
+
+@Data
+public class PostSingleResponse {
+    private Long id;
+    private String title;
+    private String authorName;
+    private LocalDateTime createdAt;
+    private int viewCount;
+    private int like;
+
+    public PostSingleResponse(Post post) {
+        this.id = post.getId();
+        this.title = post.getTitle();
+        this.authorName = post.getAuthorName();
+        this.createdAt = post.getCreateDate();
+        this.viewCount = post.getViewCount();
+        this.like = post.getLiked();
+    }
+}
diff --git a/back/src/main/java/com/back/domain/post/post/entity/Post.java b/back/src/main/java/com/back/domain/post/post/entity/Post.java
new file mode 100644
index 00000000..8370f49f
--- /dev/null
+++ b/back/src/main/java/com/back/domain/post/post/entity/Post.java
@@ -0,0 +1,62 @@
+package com.back.domain.post.post.entity;
+
+import com.back.domain.member.member.entity.Member;
+import com.back.domain.post.comment.entity.PostComment;
+import com.back.global.jpa.BaseEntity;
+import jakarta.persistence.*;
+import jakarta.validation.constraints.NotNull;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+import java.util.ArrayList;
+import java.util.List;
+
+@Entity
+@NoArgsConstructor
+@Getter
+@Setter
+public class Post extends BaseEntity {
+    @NotNull(message = "제목은 null일 수 없습니다.")
+    private String title;
+    @NotNull
+    private String content;
+    @NotNull
+    private String authorName;
+
+    @ManyToOne(fetch = FetchType.LAZY)
+    private Member member;
+
+    @Enumerated(EnumType.STRING)
+    private PostType postType;
+
+    public enum PostType {
+        INFORMATIONPOST,
+        PRACTICEPOST,
+        QUESTIONPOST
+    }
+
+    @OneToMany(mappedBy = "post", cascade = CascadeType.ALL, orphanRemoval = true)
+    private List<PostComment> comments = new ArrayList<>();
+
+    private int viewCount;
+
+    private int liked;
+
+    private Boolean isMento;
+    private String carrer;
+
+    private Boolean isResolve;
+
+
+
+    public void addComment(PostComment comment) {
+        comments.add(comment);
+        comment.setPost(this);
+    }
+
+    public void removeComment(PostComment comment) {
+        comments.remove(comment);
+        comment.setPost(null);
+    }
+}
diff --git a/back/src/main/java/com/back/domain/post/post/repository/PostRepository.java b/back/src/main/java/com/back/domain/post/post/repository/PostRepository.java
new file mode 100644
index 00000000..cb6f9cfe
--- /dev/null
+++ b/back/src/main/java/com/back/domain/post/post/repository/PostRepository.java
@@ -0,0 +1,12 @@
+package com.back.domain.post.post.repository;
+
+import com.back.domain.post.post.entity.Post;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+@Repository
+public interface PostRepository extends JpaRepository<Post, Long> , PostRepositoryCustom{
+
+}
diff --git a/back/src/main/java/com/back/domain/post/post/repository/PostRepositoryCustom.java b/back/src/main/java/com/back/domain/post/post/repository/PostRepositoryCustom.java
new file mode 100644
index 00000000..52ed920d
--- /dev/null
+++ b/back/src/main/java/com/back/domain/post/post/repository/PostRepositoryCustom.java
@@ -0,0 +1,9 @@
+package com.back.domain.post.post.repository;
+
+import com.back.domain.post.post.entity.Post;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+
+public interface PostRepositoryCustom {
+    Page<Post> searchPosts(String keyword, Pageable pageable);
+}
diff --git a/back/src/main/java/com/back/domain/post/post/repository/PostRepositoryImpl.java b/back/src/main/java/com/back/domain/post/post/repository/PostRepositoryImpl.java
new file mode 100644
index 00000000..0ac4506c
--- /dev/null
+++ b/back/src/main/java/com/back/domain/post/post/repository/PostRepositoryImpl.java
@@ -0,0 +1,57 @@
+package com.back.domain.post.post.repository;
+
+import com.back.domain.member.member.entity.QMember;
+import com.back.domain.post.post.entity.Post;
+import com.back.domain.post.post.entity.QPost;
+import com.querydsl.core.BooleanBuilder;
+import com.querydsl.jpa.impl.JPAQueryFactory;
+import lombok.RequiredArgsConstructor;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.PageImpl;
+import org.springframework.data.domain.Pageable;
+
+import java.util.List;
+
+@RequiredArgsConstructor
+public class PostRepositoryImpl implements PostRepositoryCustom{
+    private final JPAQueryFactory queryFactory;
+
+    @Override
+    public Page<Post> searchPosts(String keyword, Pageable pageable) {
+        QPost post = QPost.post;
+        QMember member = QMember.member;
+
+        BooleanBuilder builder = new BooleanBuilder();
+
+        if(keyword != null && !keyword.isBlank()) {
+            builder.and(
+                    post.title.containsIgnoreCase(keyword)
+                            .or(post.authorName.containsIgnoreCase(keyword))
+            );
+        }
+
+        List<Post> content = queryFactory
+                .selectFrom(post)
+                .where(builder)
+                .orderBy(post.createDate.desc())
+                .offset(pageable.getOffset())// 이거뭐임
+                .limit(pageable.getPageSize())
+                .fetch();
+
+        long total = getTotal(post, builder);
+
+        return new PageImpl<>(content,pageable,total);
+
+    }
+
+    private long getTotal(QPost post, BooleanBuilder builder) {
+        Long totalCount = queryFactory
+                .select(post.count())
+                .from(post)
+                .where(builder)
+                .fetchOne();
+
+        return totalCount != null ? totalCount : 0L;
+    }
+
+}
diff --git a/back/src/main/java/com/back/domain/post/post/rq/ApiResponse.java b/back/src/main/java/com/back/domain/post/post/rq/ApiResponse.java
new file mode 100644
index 00000000..7af57293
--- /dev/null
+++ b/back/src/main/java/com/back/domain/post/post/rq/ApiResponse.java
@@ -0,0 +1,15 @@
+package com.back.domain.post.post.rq;
+
+import lombok.Getter;
+
+@Getter
+public class ApiResponse<T> {
+    private String msg;
+    private T data;
+
+
+    public ApiResponse(String msg, T data) {
+        this.msg = msg;
+        this.data = data;
+    }
+}
diff --git a/back/src/main/java/com/back/domain/post/post/service/PostService.java b/back/src/main/java/com/back/domain/post/post/service/PostService.java
new file mode 100644
index 00000000..b924cd53
--- /dev/null
+++ b/back/src/main/java/com/back/domain/post/post/service/PostService.java
@@ -0,0 +1,121 @@
+package com.back.domain.post.post.service;
+
+import com.back.domain.member.member.entity.Member;
+import com.back.domain.mentoring.mentoring.dto.MentoringDto;
+import com.back.domain.post.post.dto.PostAllResponse;
+import com.back.domain.post.post.dto.PostCreateRequest;
+import com.back.domain.post.post.dto.PostDto;
+import com.back.domain.post.post.entity.Post;
+import com.back.domain.post.post.repository.PostRepository;
+import com.back.domain.post.post.repository.PostRepositoryCustom;
+import com.back.global.exception.ServiceException;
+import jakarta.transaction.Transactional;
+import jakarta.validation.Valid;
+import lombok.RequiredArgsConstructor;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.data.domain.Pageable;
+import org.springframework.stereotype.Service;
+
+import java.util.List;
+
+@Service
+@RequiredArgsConstructor
+public class PostService {
+
+    private final PostRepository postRepository;
+
+    public List<Post> getAllPosts() {
+        List<Post> posts = postRepository.findAll();
+
+        return posts;
+    }
+
+    @Transactional
+    public Post createPost(PostCreateRequest postCreateRequest, Member member) {
+        String postTypeStr = postCreateRequest.getPostType();
+
+        validPostType(postTypeStr);
+
+
+
+        Post.PostType postType = Post.PostType.valueOf(postTypeStr);
+
+        Post post = new Post();
+        post.setTitle(postCreateRequest.getTitle());
+        post.setContent(postCreateRequest.getContent());
+        post.setAuthorName(member.getName());
+        post.setMember(member);
+        post.setPostType(postType);
+
+        postRepository.save(post);
+
+        return post;
+    }
+
+    private void validPostType(String postTypeStr) {
+        try {
+            Post.PostType.valueOf(postTypeStr);
+        } catch (IllegalArgumentException e) {
+            throw new ServiceException("400-2", "유효하지 않은 PostType입니다.");
+        }
+    }
+
+
+    public Post findById(Long postId) {
+        Post post = postRepository.findById(postId).orElseThrow(() -> new ServiceException("400", "해당 Id의 게시글이 없습니다."));
+        return post;
+    }
+
+    public List<PostAllResponse> getAllPostResponse() {
+        return postRepository.findAll().stream()
+                .map(PostAllResponse::new)
+                .toList();
+    }
+    @Transactional
+    public void removePost(Long postId, Member member) {
+        Post post = postRepository.findById(postId).orElseThrow(() -> new ServiceException("400", "해당 Id의 게시글이 없습니다."));
+        Long authorId = post.getMember().getId();
+        if(authorId != member.getId()) throw new ServiceException("400", "삭제 권한이 없습니다.");
+
+        postRepository.delete(post);
+    }
+    @Transactional
+    public void updatePost(long postId, Member member, @Valid PostCreateRequest postCreateRequest) {
+        Post post = postRepository.findById(postId).orElseThrow(() -> new ServiceException("400", "해당 Id의 게시글이 없습니다."));
+        Long authorId = post.getMember().getId();
+        if(authorId != member.getId()) throw new ServiceException("400", "수정 권한이 없습니다.");
+
+        post.setTitle(postCreateRequest.getTitle());
+        post.setContent(postCreateRequest.getContent());
+
+        postRepository.save(post);
+    }
+    @Transactional
+    public void likePost(long postId) {
+        Post post = postRepository.findById(postId).orElseThrow(() -> new ServiceException("400", "해당 Id의 게시글이 없습니다."));
+
+        post.setLiked(post.getLiked()+1);
+    }
+    @Transactional
+    public void disLikePost(long postId) {
+        Post post = postRepository.findById(postId).orElseThrow(() -> new ServiceException("400", "해당 Id의 게시글이 없습니다."));
+
+        post.setLiked(post.getLiked()-1);
+    }
+    @Transactional()
+    public int showLikeCount(long postId) {
+        Post post = postRepository.findById(postId).orElseThrow(() -> new ServiceException("400", "해당 Id의 게시글이 없습니다."));
+
+        int count = post.getLiked();
+        return count;
+    }
+
+
+    public Page<PostDto> getPosts(String keyword, int page, int size) {
+        Pageable pageable = PageRequest.of(page,size);
+
+
+        return postRepository.searchPosts(keyword, pageable).map(PostDto::from);
+    }
+}
diff --git a/back/src/main/java/com/back/domain/roadmap/roadmap/entity/JobRoadmap.java b/back/src/main/java/com/back/domain/roadmap/roadmap/entity/JobRoadmap.java
new file mode 100644
index 00000000..00546906
--- /dev/null
+++ b/back/src/main/java/com/back/domain/roadmap/roadmap/entity/JobRoadmap.java
@@ -0,0 +1,25 @@
+package com.back.domain.roadmap.roadmap.entity;
+
+import com.back.global.jpa.BaseEntity;
+import jakarta.persistence.*;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Entity
+@Table(name = "job_roadmap")
+@Getter @Setter
+@NoArgsConstructor
+public class JobRoadmap extends BaseEntity {
+    @Column(name = "job_id", nullable = false)
+    private Long jobId; // Job FK
+
+    @OneToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "root_node_id", nullable = false)
+    private RoadmapNode rootNode;
+
+    public JobRoadmap(Long jobId, RoadmapNode rootNode) {
+        this.jobId = jobId;
+        this.rootNode = rootNode;
+    }
+}
diff --git a/back/src/main/java/com/back/domain/roadmap/roadmap/entity/JobRoadmapNodeStat.java b/back/src/main/java/com/back/domain/roadmap/roadmap/entity/JobRoadmapNodeStat.java
new file mode 100644
index 00000000..bc75b026
--- /dev/null
+++ b/back/src/main/java/com/back/domain/roadmap/roadmap/entity/JobRoadmapNodeStat.java
@@ -0,0 +1,23 @@
+package com.back.domain.roadmap.roadmap.entity;
+
+import com.back.global.jpa.BaseEntity;
+import jakarta.persistence.*;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Entity
+@Table(name = "job_roadmap_node_stat")
+@Getter @Setter
+@NoArgsConstructor
+public class JobRoadmapNodeStat extends BaseEntity {
+    @Column(name = "step_order")
+    private Integer stepOrder;
+
+    @Column(name = "weight", nullable = false)
+    private Double weight = 0.0;
+
+    @OneToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "node_id", nullable = false)
+    private RoadmapNode node;
+}
diff --git a/back/src/main/java/com/back/domain/roadmap/roadmap/entity/MentorRoadmap.java b/back/src/main/java/com/back/domain/roadmap/roadmap/entity/MentorRoadmap.java
new file mode 100644
index 00000000..9ae1cdfd
--- /dev/null
+++ b/back/src/main/java/com/back/domain/roadmap/roadmap/entity/MentorRoadmap.java
@@ -0,0 +1,33 @@
+package com.back.domain.roadmap.roadmap.entity;
+
+import com.back.global.jpa.BaseEntity;
+import jakarta.persistence.*;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Entity
+@Table(name = "mentor_roadmap")
+@Getter @Setter
+@NoArgsConstructor
+public class MentorRoadmap extends BaseEntity {
+    @Column(name = "title", nullable = false)
+    private String title;
+
+    @Column(name = "description", columnDefinition = "TEXT")
+    private String description;
+
+    @Column(name = "mentor_id", nullable = false)
+    private Long mentorId; // Mentor 엔티티 FK
+
+    @OneToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "root_node_id", nullable = false)
+    private RoadmapNode rootNode;
+
+    public MentorRoadmap(Long mentorId, String title, String description, RoadmapNode rootNode) {
+        this.mentorId = mentorId;
+        this.title = title;
+        this.description = description;
+        this.rootNode = rootNode;
+    }
+}
diff --git a/back/src/main/java/com/back/domain/roadmap/roadmap/entity/RoadmapNode.java b/back/src/main/java/com/back/domain/roadmap/roadmap/entity/RoadmapNode.java
new file mode 100644
index 00000000..02b043a1
--- /dev/null
+++ b/back/src/main/java/com/back/domain/roadmap/roadmap/entity/RoadmapNode.java
@@ -0,0 +1,47 @@
+package com.back.domain.roadmap.roadmap.entity;
+
+import com.back.domain.roadmap.task.entity.Task;
+import com.back.global.jpa.BaseEntity;
+import jakarta.persistence.*;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+import java.util.List;
+
+@Entity
+@Table(name = "roadmap_node")
+@Getter @Setter
+@NoArgsConstructor
+public class RoadmapNode extends BaseEntity {
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "parent_id")
+    private RoadmapNode parent;
+
+    @OneToMany(mappedBy = "parent", cascade = CascadeType.ALL, orphanRemoval = true)
+    private List<RoadmapNode> children;
+
+    @Column(name = "step_order", nullable = false)
+    private int stepOrder = 0;
+
+    @Column(name = "raw_task_name")
+    private String rawTaskName; // 원본 Task 입력값
+
+    @Column(name = "description", columnDefinition = "TEXT")
+    private String description;
+
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "task_id")
+    private Task task; // 표준 Task
+
+    public RoadmapNode(String rawTaskName, String description, Task task) {
+        this.rawTaskName = rawTaskName;
+        this.description = description;
+        this.task = task;
+    }
+
+    public void addChild(RoadmapNode child) {
+        children.add(child);
+        child.setParent(this);
+    }
+}
diff --git a/back/src/main/java/com/back/domain/roadmap/task/controller/TaskController.java b/back/src/main/java/com/back/domain/roadmap/task/controller/TaskController.java
new file mode 100644
index 00000000..a51cf520
--- /dev/null
+++ b/back/src/main/java/com/back/domain/roadmap/task/controller/TaskController.java
@@ -0,0 +1,138 @@
+package com.back.domain.roadmap.task.controller;
+
+import com.back.domain.member.member.entity.Member;
+import com.back.domain.roadmap.task.dto.*;
+import com.back.domain.roadmap.task.entity.Task;
+import com.back.domain.roadmap.task.entity.TaskAlias;
+import com.back.domain.roadmap.task.service.TaskService;
+import com.back.global.exception.ServiceException;
+import com.back.global.rq.Rq;
+import com.back.global.rsData.RsData;
+import io.swagger.v3.oas.annotations.Operation;
+import jakarta.validation.Valid;
+import lombok.RequiredArgsConstructor;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.domain.Sort;
+import org.springframework.data.web.PageableDefault;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.Collections;
+import java.util.List;
+
+@RestController
+@RequestMapping("/tasks")
+@RequiredArgsConstructor
+public class TaskController {
+    private final TaskService taskService;
+    private final Rq rq;
+
+    @Operation(summary = "키워드로 task 검색", description = "사용자가 입력한 키워드로 Task를 검색합니다.")
+    @GetMapping("/search")
+    public RsData<List<TaskDto>> searchTasks(@RequestParam String keyword) {
+        // 입력값 검증
+        if (keyword == null || keyword.trim().isEmpty()) {
+            return new RsData<>(
+                    "200",
+                    "검색 결과가 없습니다.",
+                    Collections.emptyList()
+            );
+        }
+
+        List<Task> tasks = taskService.searchByKeyword(keyword.trim());
+        List<TaskDto> responses = tasks.stream()
+                .map(TaskDto::new)
+                .toList();
+
+        return new RsData<>(
+                "200",
+                "Task 검색 성공",
+                responses
+        );
+    }
+
+    // 사용자가 새로운 기술 제안 (pending alias 생성)
+    @Operation(summary = "사용자가 새로운 Task 제안", description = "사용자가 입력한 Task 이름으로 pending 상태의(표준 Task와 연결되지 않은) TaskAlias를 생성합니다.")
+    @PostMapping("/aliases/pending")
+    public RsData<CreatePendingAliasResponse> createPendingAlias(@Valid @RequestBody CreatePendingAliasRequest request) {
+        TaskAlias pendingAlias = taskService.createPendingAlias(request.taskName().trim());
+
+        return new RsData<>(
+                "201",
+                "새로운 Pending Alias 등록 성공. 관리자 검토 후 매칭 또는 새로운 Task로 등록됩니다.",
+                new CreatePendingAliasResponse(pendingAlias)
+        );
+    }
+
+
+    //=== 관리자용 API ===
+    // 나중에 CORS 설정
+    @Operation(summary = "pending 상태의 TaskAlias 목록 조회", description = "관리자가 pending 상태의 (아직 매칭되지 않은) TaskAlias 목록을 페이징하여 조회합니다.")
+    @GetMapping("/aliases/pending")
+    public RsData<Page<TaskAliasDto>> getPendingTaskAliases(
+            @PageableDefault(size = 10, sort = "createdDate", direction = Sort.Direction.DESC) Pageable pageable
+    ) {
+        validateAdminRole();
+
+        Page<TaskAliasDto> pendingTaskAliases = taskService.getPendingTaskAliases(pageable);
+
+        return  new RsData<>(
+                "200",
+                "pending 상태의 TaskAlias 목록 조회 성공",
+                pendingTaskAliases
+        );
+    }
+
+    // Pending alias를 기존 Task와 연결
+    @Operation(summary = "pending 상태의 alias를 기존 표준 Task와 연결", description = "관리자가 pending 상태의 (아직 매칭되지 않은) TaskAlias를 기존에 존재하는 표준 Task와 연결합니다.")
+    @PutMapping("/aliases/pending/{aliasId}/link")
+    public RsData<TaskAliasDetailDto> linkPendingAlias(
+            @PathVariable Long aliasId,
+            @Valid @RequestBody LinkPendingAliasRequest request
+    ) {
+        validateAdminRole();
+
+        TaskAlias linkedAlias = taskService.linkPendingAlias(aliasId, request.taskId());
+
+        return new RsData<>(
+                "200",
+                "Pending Alias를 Task와 연결 성공",
+                new TaskAliasDetailDto(linkedAlias)
+        );
+    }
+
+    // Pending alias를 새로운 Task로 등록(생성)
+    @Operation(summary = "pending 상태의 alias를 새로운 표준 Task로 등록", description = "관리자가 pending 상태의 (아직 매칭되지 않은) TaskAlias를 표준 Task로 생성하고, 해당 alias를 새 Task와 연결합니다.")
+    @PostMapping("/aliases/pending/{aliasId}")
+    public RsData<TaskDto> createTaskFromPending(
+            @PathVariable Long aliasId
+    ) {
+        validateAdminRole();
+
+        Task newTask = taskService.createTaskFromPending(aliasId);
+
+        return new RsData<>(
+                "201",
+                "Pending Alias를 새로운 Task로 등록 성공",
+                new TaskDto(newTask)
+        );
+    }
+
+    @Operation(summary = "pending 상태의 alias 삭제", description = "관리자가 pending 상태의 (아직 매칭되지 않은) TaskAlias를 삭제합니다. 더 이상 필요하지 않은 제안이거나, 부적절한 제안인 경우에 사용됩니다.")
+    @DeleteMapping("/aliases/pending/{aliasId}")
+    public RsData<Void> deletePendingAlias(@PathVariable Long aliasId) {
+        validateAdminRole();
+        taskService.deletePendingAlias(aliasId);
+        return new RsData<>("200", "Pending Alias 삭제 성공", null);
+    }
+
+    private void validateAdminRole() {
+        Member member = rq.getActor();
+        if(member == null) {
+            throw new ServiceException("401", "로그인 후 이용해주세요.");
+        }
+        if(member.getRole() != Member.Role.ADMIN){
+            throw new ServiceException("403", "권한이 없습니다.");
+        }
+    }
+}
diff --git a/back/src/main/java/com/back/domain/roadmap/task/dto/CreatePendingAliasRequest.java b/back/src/main/java/com/back/domain/roadmap/task/dto/CreatePendingAliasRequest.java
new file mode 100644
index 00000000..f194b96a
--- /dev/null
+++ b/back/src/main/java/com/back/domain/roadmap/task/dto/CreatePendingAliasRequest.java
@@ -0,0 +1,10 @@
+package com.back.domain.roadmap.task.dto;
+
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.Size;
+
+public record CreatePendingAliasRequest(
+        @NotBlank(message = "기술명은 필수입니다")
+        @Size(min = 1, max = 50, message = "기술명은 1-50자 사이여야 합니다")
+        String taskName
+) {}
diff --git a/back/src/main/java/com/back/domain/roadmap/task/dto/CreatePendingAliasResponse.java b/back/src/main/java/com/back/domain/roadmap/task/dto/CreatePendingAliasResponse.java
new file mode 100644
index 00000000..87b21150
--- /dev/null
+++ b/back/src/main/java/com/back/domain/roadmap/task/dto/CreatePendingAliasResponse.java
@@ -0,0 +1,19 @@
+package com.back.domain.roadmap.task.dto;
+
+import com.back.domain.roadmap.task.entity.TaskAlias;
+
+import java.time.LocalDateTime;
+
+public record CreatePendingAliasResponse(
+        Long aliasId,
+        String aliasName,
+        LocalDateTime createTime
+) {
+    public CreatePendingAliasResponse(TaskAlias alias){
+        this(
+                alias.getId(),
+                alias.getName(),
+                alias.getCreateDate()
+        );
+    }
+}
diff --git a/back/src/main/java/com/back/domain/roadmap/task/dto/LinkPendingAliasRequest.java b/back/src/main/java/com/back/domain/roadmap/task/dto/LinkPendingAliasRequest.java
new file mode 100644
index 00000000..843f6be5
--- /dev/null
+++ b/back/src/main/java/com/back/domain/roadmap/task/dto/LinkPendingAliasRequest.java
@@ -0,0 +1,9 @@
+package com.back.domain.roadmap.task.dto;
+
+import jakarta.validation.constraints.NotNull;
+
+public record LinkPendingAliasRequest(
+        @NotNull(message = "Task ID는 필수입니다.")
+        Long taskId
+) {
+}
diff --git a/back/src/main/java/com/back/domain/roadmap/task/dto/TaskAliasDetailDto.java b/back/src/main/java/com/back/domain/roadmap/task/dto/TaskAliasDetailDto.java
new file mode 100644
index 00000000..eb8b5152
--- /dev/null
+++ b/back/src/main/java/com/back/domain/roadmap/task/dto/TaskAliasDetailDto.java
@@ -0,0 +1,19 @@
+package com.back.domain.roadmap.task.dto;
+
+import com.back.domain.roadmap.task.entity.TaskAlias;
+
+public record TaskAliasDetailDto(
+        Long aliasId,
+        String aliasName,
+        Long taskId,
+        String taskName
+) {
+    public TaskAliasDetailDto(TaskAlias alias){
+        this(
+                alias.getId(),
+                alias.getName(),
+                alias.getTask().getId(),
+                alias.getTask().getName()
+        );
+    }
+}
diff --git a/back/src/main/java/com/back/domain/roadmap/task/dto/TaskAliasDto.java b/back/src/main/java/com/back/domain/roadmap/task/dto/TaskAliasDto.java
new file mode 100644
index 00000000..7a91ebc2
--- /dev/null
+++ b/back/src/main/java/com/back/domain/roadmap/task/dto/TaskAliasDto.java
@@ -0,0 +1,15 @@
+package com.back.domain.roadmap.task.dto;
+
+import com.back.domain.roadmap.task.entity.TaskAlias;
+
+public record TaskAliasDto(
+        Long aliasId,
+        String aliasName
+) {
+    public TaskAliasDto(TaskAlias alias){
+        this(
+                alias.getId(),
+                alias.getName()
+        );
+    }
+}
diff --git a/back/src/main/java/com/back/domain/roadmap/task/dto/TaskDto.java b/back/src/main/java/com/back/domain/roadmap/task/dto/TaskDto.java
new file mode 100644
index 00000000..ab285fa6
--- /dev/null
+++ b/back/src/main/java/com/back/domain/roadmap/task/dto/TaskDto.java
@@ -0,0 +1,12 @@
+package com.back.domain.roadmap.task.dto;
+
+import com.back.domain.roadmap.task.entity.Task;
+
+public record TaskDto(
+        Long id,
+        String name
+) {
+    public TaskDto(Task task){
+        this(task.getId(),task.getName());
+    }
+}
diff --git a/back/src/main/java/com/back/domain/roadmap/task/entity/Task.java b/back/src/main/java/com/back/domain/roadmap/task/entity/Task.java
new file mode 100644
index 00000000..c31fd4a3
--- /dev/null
+++ b/back/src/main/java/com/back/domain/roadmap/task/entity/Task.java
@@ -0,0 +1,30 @@
+package com.back.domain.roadmap.task.entity;
+
+import com.back.global.jpa.BaseEntity;
+import jakarta.persistence.*;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+import java.util.List;
+
+@Entity
+@Table(name = "task")
+@Getter @Setter
+@NoArgsConstructor
+public class Task extends BaseEntity {
+    @Column(name = "name", nullable = false, unique = true)
+    private String name;
+
+    @OneToMany(mappedBy = "task", cascade = CascadeType.ALL)
+    private List<TaskAlias> aliases;
+
+    public Task(String name) {
+        this.name = name;
+    }
+
+    public void addAlias(TaskAlias alias) {
+        aliases.add(alias);
+        alias.setTask(this);
+    }
+}
diff --git a/back/src/main/java/com/back/domain/roadmap/task/entity/TaskAlias.java b/back/src/main/java/com/back/domain/roadmap/task/entity/TaskAlias.java
new file mode 100644
index 00000000..f0ae86d5
--- /dev/null
+++ b/back/src/main/java/com/back/domain/roadmap/task/entity/TaskAlias.java
@@ -0,0 +1,25 @@
+package com.back.domain.roadmap.task.entity;
+
+import com.back.global.jpa.BaseEntity;
+import jakarta.persistence.*;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Entity
+@Table(name = "task_alias")
+@Getter @Setter
+@NoArgsConstructor
+public class TaskAlias extends BaseEntity {
+    @Column(name = "name", nullable = false, unique = true)
+    private String name; // 사용자가 입력한 Task 이름
+
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "task_id")
+    private Task task; // 표준 Task 연결 (NULL이면 pending 상태)
+
+    public TaskAlias(String name) {
+        this.name = name;
+        this.task = null; // 기본적으로 연결된 Task가 없음 (pending 상태)
+    }
+}
diff --git a/back/src/main/java/com/back/domain/roadmap/task/repository/TaskAliasRepository.java b/back/src/main/java/com/back/domain/roadmap/task/repository/TaskAliasRepository.java
new file mode 100644
index 00000000..f4e841f0
--- /dev/null
+++ b/back/src/main/java/com/back/domain/roadmap/task/repository/TaskAliasRepository.java
@@ -0,0 +1,13 @@
+package com.back.domain.roadmap.task.repository;
+
+import com.back.domain.roadmap.task.entity.TaskAlias;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.jpa.repository.JpaRepository;
+
+import java.util.Optional;
+
+public interface TaskAliasRepository extends JpaRepository<TaskAlias, Long> {
+    Optional<TaskAlias> findByNameIgnoreCase(String name);
+    Page<TaskAlias> findByTaskIsNull(Pageable pageable); // pending alias 목록 페이징 조회
+}
diff --git a/back/src/main/java/com/back/domain/roadmap/task/repository/TaskRepository.java b/back/src/main/java/com/back/domain/roadmap/task/repository/TaskRepository.java
new file mode 100644
index 00000000..f4bcf09e
--- /dev/null
+++ b/back/src/main/java/com/back/domain/roadmap/task/repository/TaskRepository.java
@@ -0,0 +1,22 @@
+package com.back.domain.roadmap.task.repository;
+
+import com.back.domain.roadmap.task.entity.Task;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.repository.query.Param;
+
+import java.util.List;
+import java.util.Optional;
+
+public interface TaskRepository extends JpaRepository<Task, Long> {
+    Optional<Task> findByNameIgnoreCase(String name);
+
+    @Query("""
+        SELECT DISTINCT t FROM Task t 
+        LEFT JOIN FETCH t.aliases ta
+        WHERE LOWER(t.name) LIKE LOWER(CONCAT('%', :keyword, '%'))
+           OR (ta.task IS NOT NULL AND LOWER(ta.name) LIKE LOWER(CONCAT('%', :keyword, '%')))
+        ORDER BY t.name
+        """)
+    List<Task> findTasksByKeyword(@Param("keyword") String keyword);
+}
diff --git a/back/src/main/java/com/back/domain/roadmap/task/service/TaskService.java b/back/src/main/java/com/back/domain/roadmap/task/service/TaskService.java
new file mode 100644
index 00000000..e5755c0d
--- /dev/null
+++ b/back/src/main/java/com/back/domain/roadmap/task/service/TaskService.java
@@ -0,0 +1,135 @@
+package com.back.domain.roadmap.task.service;
+
+import com.back.domain.roadmap.task.dto.TaskAliasDto;
+import com.back.domain.roadmap.task.entity.Task;
+import com.back.domain.roadmap.task.entity.TaskAlias;
+import com.back.domain.roadmap.task.repository.TaskAliasRepository;
+import com.back.domain.roadmap.task.repository.TaskRepository;
+import com.back.global.exception.ServiceException;
+import lombok.RequiredArgsConstructor;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.*;
+
+@Service
+@RequiredArgsConstructor
+public class TaskService {
+    private final TaskRepository taskRepository;
+    private final TaskAliasRepository taskAliasRepository;
+
+    @Transactional(readOnly = true)
+    public long count() {
+        return taskRepository.count();
+    }
+
+    @Transactional
+    public Task create(String name) {
+        Task task = new Task(name);
+        return taskRepository.save(task);
+    }
+
+    @Transactional
+    public TaskAlias createAlias(Task task, String aliasName) {
+        TaskAlias alias = new TaskAlias(aliasName);
+        alias.setTask(task);
+        return taskAliasRepository.save(alias);
+    }
+
+    // 사용자가 입력한 키워드 기반 검색
+    @Transactional(readOnly = true)
+    public List<Task> searchByKeyword(String keyword){
+        return taskRepository.findTasksByKeyword(keyword);
+    }
+
+    @Transactional
+    public TaskAlias createPendingAlias(String taskName){
+        // 1. 먼저 Alias가 존재하는지 확인 (Pending 포함)
+        Optional<TaskAlias> existingAliasOpt = taskAliasRepository.findByNameIgnoreCase(taskName);
+        if (existingAliasOpt.isPresent()) {
+            TaskAlias existingAlias = existingAliasOpt.get();
+            if (existingAlias.getTask() != null) {
+                throw new ServiceException("400", "이미 등록된 task의 별칭입니다.");
+            } else {
+                throw new ServiceException("400", "이미 제안된 task입니다.");
+            }
+        }
+
+        // 2. Alias가 없다면, Task 테이블에 직접 존재하는지 확인
+        Optional<Task> existingTaskOpt = taskRepository.findByNameIgnoreCase(taskName);
+        if(existingTaskOpt.isPresent()){
+            throw new ServiceException("400", "이미 등록된 task입니다.");
+        }
+
+        // 3. 모두 해당 없으면 새로운 pending alias 생성
+        TaskAlias pendingAlias = new TaskAlias(taskName);
+        return taskAliasRepository.save(pendingAlias);
+    }
+
+    // === 관리자용 기능들 ===
+    // Pending alias 목록 조회 (페이징)
+    @Transactional(readOnly = true)
+    public Page<TaskAliasDto> getPendingTaskAliases(Pageable pageable) {
+        Page<TaskAlias> pendingTaskAliases = taskAliasRepository.findByTaskIsNull(pageable);
+        return pendingTaskAliases.map(taskAlias ->
+                new TaskAliasDto(taskAlias.getId(), taskAlias.getName()));
+    }
+
+    // Pending alias를 기존 Task와 연결
+    @Transactional
+    public TaskAlias linkPendingAlias(Long aliasId, Long taskId) {
+        TaskAlias pendingAlias = taskAliasRepository.findById(aliasId)
+                .orElseThrow(() -> new ServiceException("404", "해당 별칭이 존재하지 않습니다."));
+
+        if (pendingAlias.getTask() != null) {
+            throw new ServiceException("400", "이미 연결된 별칭입니다.");
+        }
+
+        Task task = taskRepository.findById(taskId)
+                .orElseThrow(() -> new ServiceException("404", "해당 Task가 존재하지 않습니다."));
+
+        pendingAlias.setTask(task);
+        return taskAliasRepository.save(pendingAlias);
+    }
+
+    // Pending alias를 새로운 Task로 생성
+    @Transactional
+    public Task createTaskFromPending(Long aliasId) {
+        TaskAlias pendingAlias = taskAliasRepository.findById(aliasId)
+                .orElseThrow(() -> new ServiceException("404", "해당 별칭이 존재하지 않습니다."));
+
+        if (pendingAlias.getTask() != null) {
+            throw new ServiceException("400", "이미 연결된 별칭입니다.");
+        }
+
+        // 동일한 이름의 Task가 이미 존재하는지 확인
+        Optional<Task> existingTask = taskRepository.findByNameIgnoreCase(pendingAlias.getName());
+        if (existingTask.isPresent()) {
+            throw new ServiceException("400", "이미 존재하는 Task 이름입니다.");
+        }
+
+        // 새 Task 생성
+        Task newTask = create(pendingAlias.getName());
+
+        // pending alias를 새 Task와 연결
+        pendingAlias.setTask(newTask);
+        taskAliasRepository.save(pendingAlias);
+
+        return newTask;
+    }
+
+    // Pending alias 삭제
+    @Transactional
+    public void deletePendingAlias(Long aliasId) {
+        TaskAlias pendingAlias = taskAliasRepository.findById(aliasId)
+                .orElseThrow(() -> new ServiceException("404", "해당 별칭이 존재하지 않습니다."));
+
+        if (pendingAlias.getTask() != null) {
+            throw new ServiceException("400", "연결된 별칭은 삭제할 수 없습니다.");
+        }
+
+        taskAliasRepository.delete(pendingAlias);
+    }
+}
diff --git a/back/src/main/java/com/back/global/app/S3Config.java b/back/src/main/java/com/back/global/app/S3Config.java
new file mode 100644
index 00000000..285f95fc
--- /dev/null
+++ b/back/src/main/java/com/back/global/app/S3Config.java
@@ -0,0 +1,46 @@
+package com.back.global.app;
+
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import software.amazon.awssdk.auth.credentials.AwsBasicCredentials;
+import software.amazon.awssdk.auth.credentials.StaticCredentialsProvider;
+import software.amazon.awssdk.regions.Region;
+import software.amazon.awssdk.services.s3.S3Client;
+import software.amazon.awssdk.services.s3.presigner.S3Presigner;
+
+import java.net.URI;
+
+@Configuration
+public class S3Config {
+
+    private static final String ACCESS_KEY = "minioadmin"; // FIXME: 실제 키로 교체
+    private static final String SECRET_KEY = "minioadmin"; // FIXME: 실제 비밀키로 교체
+    private static final String ENDPOINT = "http://localhost:9000"; // FIXME: 실제 엔드포인트로 교체
+    private static final Region REGION = Region.AP_SOUTHEAST_1; // FIXME: 실제 리전으로 교체
+
+    @Bean
+    public S3Presigner s3Presigner() {
+        return S3Presigner.builder()
+                .credentialsProvider(
+                        StaticCredentialsProvider.create(
+                                AwsBasicCredentials.create(ACCESS_KEY, SECRET_KEY)
+                        )
+                )
+                .endpointOverride(URI.create(ENDPOINT))
+                .region(REGION)
+                .build();
+    }
+
+    @Bean
+    public S3Client s3Client() {
+        return S3Client.builder()
+                .credentialsProvider(
+                        StaticCredentialsProvider.create(
+                                AwsBasicCredentials.create(ACCESS_KEY, SECRET_KEY)
+                        )
+                )
+                .endpointOverride(URI.create(ENDPOINT))
+                .region(REGION)
+                .build();
+    }
+}
diff --git a/back/src/main/java/com/back/global/auth/CurrentUser.java b/back/src/main/java/com/back/global/auth/CurrentUser.java
new file mode 100644
index 00000000..70888101
--- /dev/null
+++ b/back/src/main/java/com/back/global/auth/CurrentUser.java
@@ -0,0 +1,11 @@
+package com.back.global.auth;
+
+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 CurrentUser {
+}
diff --git a/back/src/main/java/com/back/global/auth/CurrentUserArgumentResolver.java b/back/src/main/java/com/back/global/auth/CurrentUserArgumentResolver.java
new file mode 100644
index 00000000..0c42b611
--- /dev/null
+++ b/back/src/main/java/com/back/global/auth/CurrentUserArgumentResolver.java
@@ -0,0 +1,58 @@
+package com.back.global.auth;
+
+import com.back.domain.member.member.entity.Member;
+import com.back.domain.member.member.repository.MemberRepository;
+import com.back.global.security.SecurityUser;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.core.MethodParameter;
+import org.springframework.security.core.Authentication;
+import org.springframework.security.core.context.SecurityContextHolder;
+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
+@RequiredArgsConstructor
+@Slf4j
+public class CurrentUserArgumentResolver implements HandlerMethodArgumentResolver {
+    private final MemberRepository memberRepository;
+    @Override
+    public boolean supportsParameter(MethodParameter parameter) {
+        // 여기에 구현
+        return parameter.hasParameterAnnotation(CurrentUser.class) && parameter.getParameterType().equals(Member.class);
+    }
+
+    @Override
+    public Object resolveArgument(MethodParameter parameter,
+                                  ModelAndViewContainer mavContainer,
+                                  NativeWebRequest webRequest,
+                                  WebDataBinderFactory binderFactory) {
+        // 여기에 구현
+        Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
+        log.info("Authentication: {}", authentication != null ? "존재" : "null");
+
+        if (authentication == null || !authentication.isAuthenticated()) {
+            // 인증되지 않은 사용자라면 예외 처리
+            log.warn("인증 정보 없음");
+            return null;
+        }
+        Object principal = authentication.getPrincipal();
+        log.info("Principal 타입: {}", authentication.getPrincipal().getClass().getSimpleName());
+        log.info("Principal 값: {}", principal);
+
+        SecurityUser securityUser = (SecurityUser) authentication.getPrincipal();
+        Long memberId = securityUser.getId();
+        log.info("Member ID: {}", memberId);
+
+
+
+        Member member = memberRepository.findById(memberId).orElse(null);
+        log.info("Member 조회 결과: {}", member != null ? "성공" : "실패");
+
+
+        return member;
+    }
+}
diff --git a/back/src/main/java/com/back/global/config/WebConfig.java b/back/src/main/java/com/back/global/config/WebConfig.java
new file mode 100644
index 00000000..a5eeab15
--- /dev/null
+++ b/back/src/main/java/com/back/global/config/WebConfig.java
@@ -0,0 +1,21 @@
+package com.back.global.config;
+
+import com.back.global.auth.CurrentUserArgumentResolver;
+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 CurrentUserArgumentResolver currentUserArgumentResolver;
+
+    @Override
+    public void addArgumentResolvers(List<HandlerMethodArgumentResolver> resolvers) {
+        resolvers.add(currentUserArgumentResolver);
+    }
+}
diff --git a/back/src/main/java/com/back/global/converter/StringListConverter.java b/back/src/main/java/com/back/global/converter/StringListConverter.java
new file mode 100644
index 00000000..099a6385
--- /dev/null
+++ b/back/src/main/java/com/back/global/converter/StringListConverter.java
@@ -0,0 +1,23 @@
+package com.back.global.converter;
+
+import com.back.standard.util.Ut;
+import jakarta.persistence.AttributeConverter;
+import jakarta.persistence.Converter;
+import org.springframework.stereotype.Component;
+
+import java.util.List;
+
+@Converter
+@Component
+public class StringListConverter implements AttributeConverter<List<String>, String> {
+
+    @Override
+    public String convertToDatabaseColumn(List<String> attribute) {
+        return attribute == null ? null : Ut.json.toString(attribute);
+    }
+
+    @Override
+    public List<String> convertToEntityAttribute(String dbData) {
+        return Ut.json.toList(dbData, String.class);
+    }
+}
diff --git a/back/src/main/java/com/back/global/exception/ErrorCode.java b/back/src/main/java/com/back/global/exception/ErrorCode.java
new file mode 100644
index 00000000..7d0cad08
--- /dev/null
+++ b/back/src/main/java/com/back/global/exception/ErrorCode.java
@@ -0,0 +1,6 @@
+package com.back.global.exception;
+
+public interface ErrorCode {
+    String getCode();
+    String getMessage();
+}
diff --git a/back/src/main/java/com/back/global/exception/ServiceException.java b/back/src/main/java/com/back/global/exception/ServiceException.java
index d8b33a79..a9edab57 100644
--- a/back/src/main/java/com/back/global/exception/ServiceException.java
+++ b/back/src/main/java/com/back/global/exception/ServiceException.java
@@ -12,6 +12,12 @@ public ServiceException(String resultCode, String msg) {
         this.msg = msg;
     }
 
+    public ServiceException(ErrorCode errorCode) {
+        super(errorCode.getCode() + " : " + errorCode.getMessage());
+        this.resultCode = errorCode.getCode();
+        this.msg = errorCode.getMessage();
+    }
+
     public RsData<Void> getRsData() {
         return new RsData<>(resultCode, msg, null);
     }
diff --git a/back/src/main/java/com/back/global/globalExceptionHandler/GlobalExceptionHandler.java b/back/src/main/java/com/back/global/globalExceptionHandler/GlobalExceptionHandler.java
index 9bbd4f92..dd42b432 100644
--- a/back/src/main/java/com/back/global/globalExceptionHandler/GlobalExceptionHandler.java
+++ b/back/src/main/java/com/back/global/globalExceptionHandler/GlobalExceptionHandler.java
@@ -6,6 +6,7 @@
 import lombok.RequiredArgsConstructor;
 import org.springframework.http.ResponseEntity;
 import org.springframework.http.converter.HttpMessageNotReadableException;
+import org.springframework.security.authorization.AuthorizationDeniedException;
 import org.springframework.validation.FieldError;
 import org.springframework.web.bind.MethodArgumentNotValidException;
 import org.springframework.web.bind.MissingRequestHeaderException;
@@ -17,8 +18,7 @@
 import java.util.NoSuchElementException;
 import java.util.stream.Collectors;
 
-import static org.springframework.http.HttpStatus.BAD_REQUEST;
-import static org.springframework.http.HttpStatus.NOT_FOUND;
+import static org.springframework.http.HttpStatus.*;
 
 @RestControllerAdvice
 @RequiredArgsConstructor
@@ -106,6 +106,18 @@ public ResponseEntity<RsData<Void>> handle(MissingRequestHeaderException ex) {
         );
     }
 
+    // @PreAuthorize 권한 에러
+    @ExceptionHandler(AuthorizationDeniedException.class)
+    public ResponseEntity<RsData<Void>> handle(AuthorizationDeniedException ex) {
+        return new ResponseEntity<>(
+            new RsData<>(
+                "403-1",
+                "접근 권한이 없습니다."
+            ),
+            FORBIDDEN
+        );
+    }
+
     @ExceptionHandler(ServiceException.class)
     @ResponseStatus(BAD_REQUEST)
     public ResponseEntity<RsData<Void>> handle(ServiceException ex) {
diff --git a/back/src/main/java/com/back/global/init/PostInitData.java b/back/src/main/java/com/back/global/init/PostInitData.java
new file mode 100644
index 00000000..3aa680de
--- /dev/null
+++ b/back/src/main/java/com/back/global/init/PostInitData.java
@@ -0,0 +1,104 @@
+package com.back.global.init;
+
+import com.back.domain.member.member.entity.Member;
+import com.back.domain.member.member.service.MemberService;
+import com.back.domain.post.comment.entity.PostComment;
+import com.back.domain.post.comment.repository.PostCommentRepository;
+import com.back.domain.post.post.entity.Post;
+import com.back.domain.post.post.repository.PostRepository;
+import com.back.global.exception.ServiceException;
+import jakarta.transaction.Transactional;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.boot.ApplicationArguments;
+import org.springframework.boot.ApplicationRunner;
+import org.springframework.context.annotation.Profile;
+import org.springframework.stereotype.Component;
+
+@Profile("test")
+@Component
+@RequiredArgsConstructor
+@Slf4j
+public class PostInitData implements ApplicationRunner {
+    private final PostRepository postRepository;
+    private final MemberService memberService;
+    private final PostCommentRepository postCommentRepository;
+
+
+    @Override
+    public void run(ApplicationArguments args) throws Exception {
+        log.info("postinit데이터 생성");
+        initDateForPostDataAndPostCommentData();
+
+
+        log.info("postRepo개수는 " + postRepository.count());
+
+        log.info("postinit데이터 생성 완료");
+    }
+
+
+    @Transactional
+    protected void initDateForPostDataAndPostCommentData() {
+        if (postRepository.count() > 0) return;
+
+        Member member2 = memberService.joinMentee("user2", "사용자1", "nickname1","password123","");
+        Member member3 = memberService.joinMentee("user3", "사용자1", "nickname2","password123", "");
+        Member member4 = memberService.joinMentee("user4", "사용자1", "nickname3","password123", "");
+
+        // 여러 종류의 게시글 생성
+        createPost("정보글 제목", "정보글 내용", member2, Post.PostType.INFORMATIONPOST);
+        createPost("연습글 제목", "연습글 내용", member3, Post.PostType.PRACTICEPOST);
+        createPost("질문글 제목", "질문글 내용", member4, Post.PostType.QUESTIONPOST);
+
+        createComment(member2, 1L, "1번댓글");
+        createComment(member2, 1L, "2댓글");
+        createComment(member2, 1L, "3번댓글");
+        createComment(member2, 1L, "4번댓글");
+        createComment(member2, 1L, "5번댓글");
+        createComment(member2, 1L, "6번댓글");
+        createComment(member2, 1L, "7번댓글");
+
+
+    }
+
+    private void createPost(String title, String content, Member member, Post.PostType type) {
+        validPostType(String.valueOf(type));
+
+        Post post = new Post();
+        post.setTitle(title);
+        post.setContent(content);
+        post.setAuthorName("테스트유저");
+        post.setPostType(type);
+        post.setMember(member);
+
+        postRepository.save(post);
+    }
+
+    public void createComment(Member member, Long postId, String content) {
+        Post post = postRepository.findById(postId)
+                .orElseThrow(() -> new ServiceException("400", "해당 Id의 게시글이 없습니다."));
+
+        PostComment postComment = new PostComment();
+        postComment.setContent(content);
+        postComment.setMember(member);
+        postComment.setRole(String.valueOf(member.getRole()));
+        postComment.setPost(post);  // 직접 설정
+
+        postCommentRepository.save(postComment);
+
+    }
+
+    private void validPostType(String postTypeStr) {
+        boolean eq = false;
+
+        String[] validType = new String[3];
+        validType[0] = "INFORMATIONPOST";
+        validType[1] = "PRACTICEPOST";
+        validType[2] = "QUESTIONPOST";
+
+        for(String x : validType) if(x.equals(postTypeStr)) eq = true;
+
+        if(!eq) throw new ServiceException("400-2", "유효하지 않은 PostType입니다.");
+    }
+
+}
diff --git a/back/src/main/java/com/back/global/initData/RoadmapInitData.java b/back/src/main/java/com/back/global/initData/RoadmapInitData.java
new file mode 100644
index 00000000..7bc15fac
--- /dev/null
+++ b/back/src/main/java/com/back/global/initData/RoadmapInitData.java
@@ -0,0 +1,89 @@
+package com.back.global.initData;
+
+import com.back.domain.job.job.entity.Job;
+import com.back.domain.job.job.service.JobService;
+import com.back.domain.roadmap.task.entity.Task;
+import com.back.domain.roadmap.task.service.TaskService;
+import lombok.RequiredArgsConstructor;
+import org.springframework.boot.ApplicationRunner;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.transaction.annotation.Transactional;
+
+@Configuration
+@RequiredArgsConstructor
+@Transactional
+public class RoadmapInitData {
+    private final JobService jobService;
+    private final TaskService taskService;
+
+    @Bean
+    ApplicationRunner baseInitDataApplicationRunner() {
+        return args -> {
+            runInitData();
+        };
+    }
+
+    @Transactional
+    public void runInitData() {
+        initJobData();
+        initTaskData();
+    }
+
+    public void initJobData() {
+        if (jobService.count() > 0) return;
+
+        Job job1 = jobService.create("백엔드 개발자", "서버 사이드 로직 구현과 데이터베이스를 담당하는 개발자");
+        jobService.createAlias(job1, "백엔드");
+        jobService.createAlias(job1, "BE 개발자");
+        jobService.createAlias(job1, "Backend 개발자");
+        jobService.createAlias(job1, "서버 개발자");
+        jobService.createAlias(job1, "API 개발자");
+
+        Job job2 = jobService.create("프론트엔드 개발자", "사용자 인터페이스(UI)와 사용자 경험(UX)을 담당하는 개발자");
+        jobService.createAlias(job2, "프론트엔드");
+        jobService.createAlias(job2, "FE 개발자");
+        jobService.createAlias(job2, "Frontend 개발자");
+        jobService.createAlias(job2, "웹 퍼블리셔");
+        jobService.createAlias(job2, "UI 개발자");
+        jobService.createAlias(job2, "클라이언트 개발자");
+
+        // 일단 개발 및 테스트에 필요한 최소 데이터만 입력, 이후에 추가 예정
+    }
+
+    public void initTaskData() {
+        if (taskService.count() > 0) return;
+
+        // 백엔드 핵심 (5개)
+        Task java = taskService.create("Java");
+        Task springBoot = taskService.create("Spring Boot");
+        Task mysql = taskService.create("MySQL");
+        Task python = taskService.create("Python");
+        Task nodejs = taskService.create("Node.js");
+
+        // 프론트엔드 핵심 (5개)
+        Task htmlCss = taskService.create("HTML/CSS");
+        Task javascript = taskService.create("JavaScript");
+        Task react = taskService.create("React");
+        Task typescript = taskService.create("TypeScript");
+        Task vue = taskService.create("Vue.js");
+
+        // 공통 도구 (3개)
+        Task git = taskService.create("Git");
+        Task docker = taskService.create("Docker");
+        Task aws = taskService.create("AWS");
+
+        // 핵심 별칭만 (테스트용)
+        taskService.createAlias(java, "자바");
+        taskService.createAlias(javascript, "자바스크립트");
+        taskService.createAlias(javascript, "JS");
+        taskService.createAlias(react, "리액트");
+        taskService.createAlias(springBoot, "스프링부트");
+        taskService.createAlias(mysql, "마이SQL");
+        taskService.createAlias(vue, "뷰");
+        taskService.createAlias(git, "깃");
+        taskService.createAlias(docker, "도커");
+
+        // 일단 개발 및 테스트에 필요한 최소 데이터만 입력, 이후에 추가 예정
+    }
+}
diff --git a/back/src/main/java/com/back/global/jpa/BaseEntity.java b/back/src/main/java/com/back/global/jpa/BaseEntity.java
index ee07d02a..f7b35e6e 100644
--- a/back/src/main/java/com/back/global/jpa/BaseEntity.java
+++ b/back/src/main/java/com/back/global/jpa/BaseEntity.java
@@ -23,7 +23,7 @@ public abstract class BaseEntity {
     @Id
     @GeneratedValue(strategy = IDENTITY)
     @Setter(PROTECTED)
-    private int id;
+    private Long id;
 
     @CreatedDate
     private LocalDateTime createDate;
@@ -36,11 +36,11 @@ public boolean equals(Object o) {
         if (o == this) return true;
         if (o == null || getClass() != o.getClass()) return false;
         BaseEntity that = (BaseEntity) o;
-        return id == that.id;
+        return Objects.equals(id, that.id);
     }
 
     @Override
     public int hashCode() {
         return Objects.hashCode(id);
     }
-}
\ No newline at end of file
+}
diff --git a/back/src/main/java/com/back/global/jpa/JpaConfig.java b/back/src/main/java/com/back/global/jpa/JpaConfig.java
new file mode 100644
index 00000000..c0dbb9ad
--- /dev/null
+++ b/back/src/main/java/com/back/global/jpa/JpaConfig.java
@@ -0,0 +1,19 @@
+package com.back.global.jpa;
+
+import com.querydsl.jpa.impl.JPAQueryFactory;
+import jakarta.persistence.EntityManager;
+import lombok.RequiredArgsConstructor;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+@Configuration
+@RequiredArgsConstructor
+public class JpaConfig {
+
+    private final EntityManager entityManager;
+
+    @Bean
+    public JPAQueryFactory jpaQueryFactory() {
+        return new JPAQueryFactory(entityManager);
+    }
+}
diff --git a/back/src/main/java/com/back/global/rq/Rq.java b/back/src/main/java/com/back/global/rq/Rq.java
index 684745fb..763e1089 100644
--- a/back/src/main/java/com/back/global/rq/Rq.java
+++ b/back/src/main/java/com/back/global/rq/Rq.java
@@ -47,11 +47,19 @@ public Member getActor() {
                 .map(Authentication::getPrincipal)
                 .filter(principal -> principal instanceof SecurityUser)
                 .map(principal -> (SecurityUser) principal)
-                .map(securityUser -> new Member(
-                        securityUser.getId(),
-                        securityUser.getUsername(),  // email
-                        securityUser.getName()
-                ))
+                .map(securityUser -> {
+                    String role = securityUser.getAuthorities().stream()
+                            .findFirst()
+                            .map(auth -> auth.getAuthority().replace("ROLE_", ""))
+                            .orElse(null);
+                    return new Member(
+                            securityUser.getId(),
+                            securityUser.getUsername(),  // email
+                            securityUser.getName(),
+                            securityUser.getNickname(),
+                            role != null ? Member.Role.valueOf(role) : null
+                    );
+                })
                 .orElse(null);
     }
 
@@ -115,4 +123,4 @@ public void setHeader(String name, String value) {
             resp.setHeader(name, value);
         }
     }
-}
\ No newline at end of file
+}
diff --git a/back/src/main/java/com/back/global/security/CustomAuthenticationFilter.java b/back/src/main/java/com/back/global/security/CustomAuthenticationFilter.java
index 1ad157df..73b83ad8 100644
--- a/back/src/main/java/com/back/global/security/CustomAuthenticationFilter.java
+++ b/back/src/main/java/com/back/global/security/CustomAuthenticationFilter.java
@@ -11,6 +11,7 @@
 import jakarta.servlet.http.HttpServletRequest;
 import jakarta.servlet.http.HttpServletResponse;
 import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
 import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
 import org.springframework.security.core.Authentication;
 import org.springframework.security.core.authority.SimpleGrantedAuthority;
@@ -22,7 +23,7 @@
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
-
+@Slf4j
 @Component
 @RequiredArgsConstructor
 public class CustomAuthenticationFilter extends OncePerRequestFilter {
@@ -36,6 +37,7 @@ protected void doFilterInternal(HttpServletRequest request, HttpServletResponse
         try {
             work(request, response, filterChain);
         } catch (Exception e) {
+            log.error("CustomAuthenticationFilter에서 예외 발생: ",e); //401 에러로 빠지는거 추적 가능
             RsData<Void> rsData = new RsData<>("401-1", "인증 오류가 발생했습니다.");
             response.setContentType("application/json;charset=UTF-8");
             response.setStatus(rsData.statusCode());
@@ -47,13 +49,16 @@ protected void doFilterInternal(HttpServletRequest request, HttpServletResponse
 
     private void work(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
         // 인증이 필요없는 API 요청이라면 패스
-        if (List.of("/auth/login", "/auth/signup", "/h2-console").contains(request.getRequestURI()) ||
-                request.getRequestURI().startsWith("/h2-console/")) {
+        if (List.of("/auth/login", "/auth/refresh", "/h2-console").contains(request.getRequestURI()) ||
+                request.getRequestURI().startsWith("/auth/signup") ||
+                request.getRequestURI().startsWith("/h2-console/") ||
+                request.getRequestURI().startsWith("/swagger-ui/") ||
+                request.getRequestURI().startsWith("/v3/api-docs/") ||
+                request.getRequestURI().startsWith("/swagger-resources/")) {
             filterChain.doFilter(request, response);
             return;
         }
 
-        // 쿠키에서 토큰 추출
         String accessToken = rq.getCookieValue("accessToken", "");
 
         if (accessToken.isBlank()) {
@@ -65,8 +70,29 @@ private void work(HttpServletRequest request, HttpServletResponse response, Filt
         Map<String, Object> payload = memberService.payload(accessToken);
 
         if (payload == null) {
-            filterChain.doFilter(request, response);
-            return;
+            String refreshToken = rq.getCookieValue("refreshToken", "");
+            if (!refreshToken.isBlank() && memberService.isValidToken(refreshToken) && memberService.isRefreshToken(refreshToken)) {
+                // Refresh token에서 사용자 정보 추출
+                Map<String, Object> refreshPayload = memberService.payload(refreshToken);
+                if (refreshPayload != null) {
+                    String email = (String) refreshPayload.get("email");
+                    Optional<Member> memberOpt = memberService.findByEmail(email);
+                    if (memberOpt.isPresent()) {
+                        Member member = memberOpt.get();
+                        // 새로운 access token 생성 및 설정
+                        String newAccessToken = memberService.genAccessToken(member);
+                        rq.setCookie("accessToken", newAccessToken);
+
+                        // 새 토큰으로 다시 payload 추출
+                        payload = memberService.payload(newAccessToken);
+                    }
+                }
+            }
+
+            if (payload == null) {
+                filterChain.doFilter(request, response);
+                return;
+            }
         }
 
         String email = (String) payload.get("email");
@@ -85,6 +111,7 @@ private void work(HttpServletRequest request, HttpServletResponse response, Filt
                 member.getEmail(),
                 "",
                 member.getName(),
+                member.getNickname(),
                 List.of(new SimpleGrantedAuthority("ROLE_" + member.getRole().name()))
         );
 
@@ -98,4 +125,4 @@ private void work(HttpServletRequest request, HttpServletResponse response, Filt
 
         filterChain.doFilter(request, response);
     }
-}
\ No newline at end of file
+}
diff --git a/back/src/main/java/com/back/global/security/SecurityConfig.java b/back/src/main/java/com/back/global/security/SecurityConfig.java
index 59eb1843..3f7f533b 100644
--- a/back/src/main/java/com/back/global/security/SecurityConfig.java
+++ b/back/src/main/java/com/back/global/security/SecurityConfig.java
@@ -3,6 +3,7 @@
 import lombok.RequiredArgsConstructor;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
+import org.springframework.security.config.annotation.method.configuration.EnableMethodSecurity;
 import org.springframework.security.config.annotation.web.builders.HttpSecurity;
 import org.springframework.security.config.annotation.web.configurers.AbstractHttpConfigurer;
 import org.springframework.security.web.SecurityFilterChain;
@@ -15,6 +16,7 @@
 import static org.springframework.security.config.http.SessionCreationPolicy.STATELESS;
 
 @Configuration
+@EnableMethodSecurity
 @RequiredArgsConstructor
 public class SecurityConfig {
     private final CustomAuthenticationFilter customAuthenticationFilter;
@@ -27,6 +29,7 @@ public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
                         .requestMatchers("/h2-console/**").permitAll()
                         .requestMatchers("/auth/**").permitAll()
                         .requestMatchers("/actuator/**").permitAll()
+                        .requestMatchers("/swagger-ui/**", "/v3/api-docs/**", "/swagger-resources/**").permitAll()
                         .anyRequest().authenticated()
                 )
                 .headers(headers -> headers
@@ -58,4 +61,4 @@ public UrlBasedCorsConfigurationSource corsConfigurationSource() {
 
         return source;
     }
-}
\ No newline at end of file
+}
diff --git a/back/src/main/java/com/back/global/security/SecurityUser.java b/back/src/main/java/com/back/global/security/SecurityUser.java
index 49a744bf..56e575ab 100644
--- a/back/src/main/java/com/back/global/security/SecurityUser.java
+++ b/back/src/main/java/com/back/global/security/SecurityUser.java
@@ -9,20 +9,25 @@
 
 public class SecurityUser extends User {
     @Getter
-    private int id;
+    private Long id;
 
     @Getter
     private String name;
 
+    @Getter
+    private String nickname;
+
     public SecurityUser(
-            int id,
+            Long id,
             String username,
             String password,
             String name,
+            String nickname,
             Collection<? extends GrantedAuthority> authorities
     ) {
         super(username, password != null ? password : "", authorities);
         this.id = id;
         this.name = name;
+        this.nickname = nickname;
     }
-}
\ No newline at end of file
+}
diff --git a/back/src/main/java/com/back/global/springdoc/SpringDocConfig.java b/back/src/main/java/com/back/global/springdoc/SpringDocConfig.java
new file mode 100644
index 00000000..117551f7
--- /dev/null
+++ b/back/src/main/java/com/back/global/springdoc/SpringDocConfig.java
@@ -0,0 +1,19 @@
+package com.back.global.springdoc;
+
+import io.swagger.v3.oas.annotations.OpenAPIDefinition;
+import io.swagger.v3.oas.annotations.enums.SecuritySchemeIn;
+import io.swagger.v3.oas.annotations.enums.SecuritySchemeType;
+import io.swagger.v3.oas.annotations.info.Info;
+import io.swagger.v3.oas.annotations.security.SecurityScheme;
+import org.springframework.context.annotation.Configuration;
+
+@Configuration
+@OpenAPIDefinition(info = @Info(title = "API 서버", version = "beta", description = "API 서버 문서입니다."))
+@SecurityScheme(
+        name = "cookieAuth",
+        type = SecuritySchemeType.APIKEY,
+        in = SecuritySchemeIn.COOKIE,
+        paramName = "accessToken"
+)
+public class SpringDocConfig {
+}
diff --git a/back/src/main/java/com/back/standard/util/Ut.java b/back/src/main/java/com/back/standard/util/Ut.java
index b343e24f..f5de7fb3 100644
--- a/back/src/main/java/com/back/standard/util/Ut.java
+++ b/back/src/main/java/com/back/standard/util/Ut.java
@@ -8,7 +8,9 @@
 
 import javax.crypto.SecretKey;
 import java.security.Key;
+import java.util.ArrayList;
 import java.util.Date;
+import java.util.List;
 import java.util.Map;
 
 public class Ut {
@@ -83,6 +85,20 @@ public static String toString(Object object, String defaultValue) {
                 return defaultValue;
             }
         }
+
+        public static <T> List<T> toList(String json, Class<T> elementClass) {
+            if (json == null || json.isEmpty()) {
+                return new ArrayList<>();
+            }
+            try {
+                return objectMapper.readValue(
+                    json,
+                    objectMapper.getTypeFactory().constructCollectionType(List.class, elementClass)
+                );
+            } catch (Exception e) {
+                return new ArrayList<>();
+            }
+        }
     }
 
 }
diff --git a/back/src/main/resources/application.yml b/back/src/main/resources/application.yml
index 10a28328..9109e957 100644
--- a/back/src/main/resources/application.yml
+++ b/back/src/main/resources/application.yml
@@ -1,6 +1,7 @@
 server:
   port: 8080
   forward-headers-strategy: native
+
 spring:
   application:
     name: back
@@ -8,6 +9,9 @@ spring:
     import: optional:file:.env[.properties]
   profiles:
     active: dev
+  autoconfigure:
+    exclude:
+      - org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration
   output:
     ansi:
       enabled: always
@@ -32,12 +36,13 @@ spring:
         use_sql_comments: true
         default_batch_fetch_size: 100
     open-in-view: false
+
 springdoc: #Swagger ??
   default-produces-media-type: application/json;charset=UTF-8
   swagger-ui:
     path: /swagger-ui.html
   api-docs:
-    path: /api-docs
+    path: /v3/api-docs
 logging:
   level:
     org.hibernate.orm.jdbc.bind: TRACE
diff --git a/back/src/test/java/com/back/domain/file/entity/VideoTest.java b/back/src/test/java/com/back/domain/file/entity/VideoTest.java
new file mode 100644
index 00000000..b2abf596
--- /dev/null
+++ b/back/src/test/java/com/back/domain/file/entity/VideoTest.java
@@ -0,0 +1,91 @@
+package com.back.domain.file.entity;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class VideoTest {
+
+    @Test
+    @DisplayName("uuid, transcodingResults, originalPath, originalFileName, duration, fileSize로 Video 객체 생성")
+    void videoCreationTest() {
+        String uuid = "sample-uuid";
+        String transcodingResults = "{\"status\":\"done\"}";
+        String originalPath = "/videos/sample.mp4";
+        String originalFileName = "sample.mp4";
+        Integer duration = 120;
+        Long fileSize = 1024L;
+
+        Video video = Video.create(uuid, transcodingResults, originalPath, originalFileName, duration, fileSize);
+
+        assertThat(video).isNotNull();
+        assertThat(video.getUuid()).isEqualTo(uuid);
+        assertThat(video.getTranscodingResults()).isEqualTo(transcodingResults);
+        assertThat(video.getOriginalPath()).isEqualTo(originalPath);
+        assertThat(video.getViews()).isEqualTo(0); // 기본값 확인
+        assertThat(video.getOriginalFileName()).isEqualTo(originalFileName);
+        assertThat(video.getDuration()).isEqualTo(duration);
+        assertThat(video.getFileSize()).isEqualTo(fileSize);
+    }
+
+    @Test
+    @DisplayName("uuid가 null 또는 공백일 경우 예외를 반환한다.")
+    void videoCreationTestWithInvalidUuid() {
+        String transcodingResults = "{}";
+        String originalPath = "/videos/sample.mp4";
+        String originalFileName = "sample.mp4";
+
+        try {
+            Video.create(null, transcodingResults, originalPath, originalFileName, 100, 1000L);
+        } catch (Exception e) {
+            assertThat(e).isInstanceOf(IllegalArgumentException.class);
+        }
+
+        try {
+            Video.create("", transcodingResults, originalPath, originalFileName, 100, 1000L);
+        } catch (Exception e) {
+            assertThat(e).isInstanceOf(IllegalArgumentException.class);
+        }
+    }
+
+    @Test
+    @DisplayName("originalPath가 null 또는 공백일 경우 예외를 반환한다.")
+    void videoCreationTestWithInvalidOriginalPath() {
+        String uuid = "sample-uuid";
+        String transcodingResults = "{}";
+        String originalFileName = "sample.mp4";
+
+        try {
+            Video.create(uuid, transcodingResults, null, originalFileName, 100, 1000L);
+        } catch (Exception e) {
+            assertThat(e).isInstanceOf(IllegalArgumentException.class);
+        }
+
+        try {
+            Video.create(uuid, transcodingResults, "", originalFileName, 100, 1000L);
+        } catch (Exception e) {
+            assertThat(e).isInstanceOf(IllegalArgumentException.class);
+        }
+    }
+
+    @Test
+    @DisplayName("originalFileName이 null 또는 공백일 경우 예외를 반환한다.")
+    void videoCreationTestWithInvalidOriginalFileName() {
+        String uuid = "sample-uuid";
+        String transcodingResults = "{}";
+        String originalPath = "/videos/sample.mp4";
+
+        try {
+            Video.create(uuid, transcodingResults, originalPath, null, 100, 1000L);
+        } catch (Exception e) {
+            assertThat(e).isInstanceOf(IllegalArgumentException.class);
+        }
+
+        try {
+            Video.create(uuid, transcodingResults, originalPath, "", 100, 1000L);
+        } catch (Exception e) {
+            assertThat(e).isInstanceOf(IllegalArgumentException.class);
+        }
+    }
+}
diff --git a/back/src/test/java/com/back/domain/file/service/VideoServiceTest.java b/back/src/test/java/com/back/domain/file/service/VideoServiceTest.java
new file mode 100644
index 00000000..37e88ccb
--- /dev/null
+++ b/back/src/test/java/com/back/domain/file/service/VideoServiceTest.java
@@ -0,0 +1,227 @@
+package com.back.domain.file.service;
+
+import com.back.domain.file.entity.Video;
+import com.back.domain.file.repository.VideoRepository;
+import com.back.fixture.VideoFixture;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+import software.amazon.awssdk.services.s3.S3Client;
+import software.amazon.awssdk.services.s3.model.HeadObjectRequest;
+import software.amazon.awssdk.services.s3.model.HeadObjectResponse;
+import software.amazon.awssdk.services.s3.model.S3Exception;
+import software.amazon.awssdk.services.s3.presigner.S3Presigner;
+import software.amazon.awssdk.services.s3.presigner.model.PresignedGetObjectRequest;
+import software.amazon.awssdk.services.s3.presigner.model.PresignedPutObjectRequest;
+
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.util.List;
+import java.util.Map;
+import java.util.NoSuchElementException;
+import java.util.UUID;
+import java.util.function.Consumer;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.*;
+
+
+@ExtendWith(MockitoExtension.class)
+class VideoServiceTest {
+    @Mock
+    private VideoRepository videoRepository;
+    @Mock
+    private S3Presigner presigner;
+    @Mock
+    private S3Client s3Client;
+    @InjectMocks
+    private VideoService videoService;
+
+    @Test
+    @DisplayName("transcodingResults, originalPath, originalFileName, duration, fileSize로 Video 객체 생성")
+    void videoCreationTest() {
+        String uuid = UUID.randomUUID().toString();
+        String transcodingResults = """
+                {
+                  "1080p": {
+                    "file_path": "/path/to/1080p/video.mpd",
+                    "status": "COMPLETED",
+                    "size_mb": 150
+                  },
+                  "720p": {
+                    "file_path": "/path/to/720p/video.mpd",
+                    "status": "COMPLETED",
+                    "size_mb": 80
+                  },
+                  "480p": {
+                    "file_path": "/path/to/480p/video.mpd",
+                    "status": "COMPLETED",
+                    "size_mb": 40
+                  }
+                }
+                """;
+        String originalPath = "/videos/sample.mp4";
+        String originalFileName = "sample.mp4";
+        Integer duration = 120;
+        Long fileSize = 1024L;
+
+        Video video = VideoFixture.create(uuid, transcodingResults, originalPath, originalFileName, duration, fileSize);
+        when(videoRepository.save(any(Video.class))).thenReturn(video);
+
+        Video createdVideo = videoService.createVideo(transcodingResults, originalPath, originalFileName, duration, fileSize);
+        assertThat(createdVideo).isNotNull();
+        assertThat(createdVideo.getUuid()).isEqualTo(uuid);
+        assertThat(createdVideo.getTranscodingResults()).isEqualTo(transcodingResults);
+        assertThat(createdVideo.getOriginalPath()).isEqualTo(originalPath);
+        assertThat(createdVideo.getViews()).isEqualTo(0);
+        assertThat(createdVideo.getOriginalFileName()).isEqualTo(originalFileName);
+        assertThat(createdVideo.getDuration()).isEqualTo(duration);
+        assertThat(createdVideo.getFileSize()).isEqualTo(fileSize);
+    }
+
+    @Test
+    @DisplayName("uuid로 Video 객체 조회")
+    void getNewsByUuidTest() {
+        String uuid = UUID.randomUUID().toString();
+        Video video = VideoFixture.createDefault();
+        when(videoRepository.findByUuid(uuid)).thenReturn(java.util.Optional.of(video));
+
+        Video foundVideo = videoService.getNewsByUuid(uuid);
+        assertThat(foundVideo).isNotNull();
+        assertThat(foundVideo.getUuid()).isEqualTo(video.getUuid());
+    }
+
+    @Test
+    @DisplayName("존재하지 않는 uuid로 Video 객체 조회 시 예외 발생")
+    void getNewsByUuidNotFoundTest() {
+        String uuid = UUID.randomUUID().toString();
+        when(videoRepository.findByUuid(uuid)).thenReturn(java.util.Optional.empty());
+
+        try {
+            videoService.getNewsByUuid(uuid);
+        } catch (Exception e) {
+            assertThat(e).isInstanceOf(NoSuchElementException.class);
+            assertThat(e.getMessage()).isEqualTo("존재하지 않는 비디오입니다.");
+        }
+    }
+
+    @Test
+    @DisplayName("S3 업로드 URL 생성")
+    void generateUploadUrlTest() throws MalformedURLException {
+        String bucket = "test-bucket";
+        String objectKey = "test-video.mp4";
+
+        PresignedPutObjectRequest mocked = mock(PresignedPutObjectRequest.class);
+
+        when(presigner.presignPutObject(any(Consumer.class))).thenReturn(mocked);
+
+        when(mocked.url()).thenReturn(new URL("http://localhost:8080/upload"));
+
+        URL url = videoService.generateUploadUrl(bucket, objectKey);
+
+        assertThat(url).isNotNull();
+        assertThat(url.toString()).isEqualTo("http://localhost:8080/upload");
+    }
+
+    @Test
+    @DisplayName("S3 다운로드 URL 생성")
+    void generateDownloadUrlTest() throws MalformedURLException {
+        String bucket = "test-bucket";
+        String objectKey = "test-video.mp4";
+
+        var mocked = mock(software.amazon.awssdk.services.s3.presigner.model.PresignedGetObjectRequest.class);
+
+        when(presigner.presignGetObject(any(Consumer.class))).thenReturn(mocked);
+
+        when(mocked.url()).thenReturn(new URL("http://localhost:8080/download"));
+
+        URL url = videoService.generateDownloadUrl(bucket, objectKey);
+
+        assertThat(url).isNotNull();
+        assertThat(url.toString()).isEqualTo("http://localhost:8080/download");
+    }
+
+    @Test
+    @DisplayName("업로드 URL 요청의 결과가 null일 경우 예외 발생")
+    void generateUploadUrl_PresignRequestNull_Test() {
+        String bucket = "test-bucket";
+        String objectKey = "test-video.mp4";
+
+        when(presigner.presignPutObject(any(Consumer.class))).thenReturn(null);
+
+        try {
+            videoService.generateUploadUrl(bucket, objectKey);
+        } catch (Exception e) {
+            assertThat(e).isInstanceOf(RuntimeException.class);
+        }
+    }
+
+    @Test
+    @DisplayName("다운로드 URL 요청의 결과가 null일 경우 예외 발생")
+    void generateDownloadUrl_PresignRequestNull_Test() {
+        String bucket = "test-bucket";
+        String objectKey = "test-video.mp4";
+
+        when(presigner.presignGetObject(any(Consumer.class))).thenReturn(null);
+
+        try {
+            videoService.generateDownloadUrl(bucket, objectKey);
+        } catch (Exception e) {
+            assertThat(e).isInstanceOf(RuntimeException.class);
+        }
+    }
+
+
+    @Test
+    @DisplayName("isExist() - 객체 존재 시 true 반환")
+    void isExist_objectExists_shouldReturnTrue() {
+        String bucket = "test-bucket";
+        String objectKey = "existing.mp4";
+
+        HeadObjectResponse mockResponse = mock(HeadObjectResponse.class);
+        when(s3Client.headObject(any(HeadObjectRequest.class))).thenReturn(mockResponse);
+
+        boolean exist = videoService.isExist(bucket, objectKey);
+
+        assertThat(exist).isTrue();
+    }
+
+    @Test
+    @DisplayName("isExist() - 객체 존재하지 않으면 false 반환")
+    void isExist_objectNotExists_shouldReturnFalse() {
+        String bucket = "test-bucket";
+        String objectKey = "non-existing.mp4";
+
+        doThrow(S3Exception.builder().statusCode(404).build())
+                .when(s3Client).headObject(any(HeadObjectRequest.class));
+
+        boolean exist = videoService.isExist(bucket, objectKey);
+
+        assertThat(exist).isFalse();
+    }
+
+    @Test
+    @DisplayName("generateDashUrls() - MPD와 segment URL 정상 생성")
+    void generateDashUrls_shouldReturnUrls() throws Exception {
+        String bucket = "test-bucket";
+        String mpdFile = "video.mpd";
+        List<String> segmentFiles = List.of("seg1.mp4", "seg2.mp4");
+
+        PresignedGetObjectRequest mockedPresigned = mock(PresignedGetObjectRequest.class);
+        HeadObjectResponse mockResponse = mock(HeadObjectResponse.class);
+
+        when(mockedPresigned.url()).thenReturn(new URL("http://localhost:8080/download"));
+        when(presigner.presignGetObject(any(Consumer.class))).thenReturn(mockedPresigned);
+        when(s3Client.headObject(any(HeadObjectRequest.class))).thenReturn(mockResponse);
+
+        Map<String, URL> urls = videoService.generateDashUrls(bucket, mpdFile, segmentFiles);
+
+        assertThat(urls).isNotNull();
+        assertThat(urls).containsKeys("mpd", "seg1.mp4", "seg2.mp4");
+        urls.values().forEach(url -> assertThat(url.toString()).isEqualTo("http://localhost:8080/download"));
+    }
+}
\ No newline at end of file
diff --git a/back/src/test/java/com/back/domain/member/member/controller/MemberControllerTest.java b/back/src/test/java/com/back/domain/member/member/controller/MemberControllerTest.java
new file mode 100644
index 00000000..544dfdba
--- /dev/null
+++ b/back/src/test/java/com/back/domain/member/member/controller/MemberControllerTest.java
@@ -0,0 +1,499 @@
+package com.back.domain.member.member.controller;
+
+
+import com.back.domain.member.member.entity.Member;
+import com.back.domain.member.member.service.MemberService;
+import com.back.domain.member.member.verification.EmailVerificationService;
+import jakarta.servlet.http.Cookie;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.springframework.http.MediaType;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.test.context.ActiveProfiles;
+import org.springframework.test.web.servlet.MockMvc;
+import org.springframework.test.web.servlet.ResultActions;
+import org.springframework.transaction.annotation.Transactional;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*;
+import static org.springframework.test.web.servlet.result.MockMvcResultHandlers.print;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;
+
+@ActiveProfiles("test")
+@SpringBootTest
+@AutoConfigureMockMvc
+@Transactional
+public class MemberControllerTest {
+    @Autowired
+    private MemberService memberService;
+
+    @Autowired
+    private MockMvc mvc;
+
+    @Autowired
+    private EmailVerificationService emailVerificationService;
+
+    @Test
+    @DisplayName("멘티 회원가입")
+    void t1() throws Exception {
+        ResultActions resultActions = mvc
+                .perform(
+                        post("/auth/signup/mentee")
+                                .contentType(MediaType.APPLICATION_JSON)
+                                .content("""
+                                        {
+                                            "email": "user1@example.com",
+                                            "password": "password123",
+                                            "name": "사용자1",
+                                            "nickname": "유저1",
+                                            "interestedField": "Backend"
+                                        }
+                                        """.stripIndent())
+
+                )
+                .andDo(print());
+        Member member = memberService.findByEmail("user1@example.com").get();
+
+        resultActions
+                .andExpect(handler().handlerType(MemberController.class))
+                .andExpect(handler().methodName("signupMentee"))
+                .andExpect(status().is2xxSuccessful())
+                .andExpect(jsonPath("$.resultCode").value("200-1"))
+                .andExpect(jsonPath("$.msg").value("멘티 회원가입 성공"));
+    }
+
+    @Test
+    @DisplayName("멘토 인증번호 발송")
+    void t2() throws Exception {
+        ResultActions resultActions = mvc
+                .perform(
+                        post("/auth/signup/mentor/send-verification")
+                                .contentType(MediaType.APPLICATION_JSON)
+                                .content("""
+                                        {
+                                            "email": "mentor@example.com"
+                                        }
+                                        """.stripIndent())
+                )
+                .andDo(print());
+
+        resultActions
+                .andExpect(handler().handlerType(MemberController.class))
+                .andExpect(handler().methodName("sendMentorVerification"))
+                .andExpect(status().is2xxSuccessful())
+                .andExpect(jsonPath("$.resultCode").value("200-2"))
+                .andExpect(jsonPath("$.msg").value("인증번호가 발송되었습니다."));
+    }
+
+    @Test
+    @DisplayName("멘토 회원가입 (인증번호 확인)")
+    void t2_1() throws Exception {
+        String email = "mentor2@example.com";
+
+        // 인증번호 생성
+        String verificationCode = emailVerificationService.generateAndSendCode(email);
+
+        // 회원가입 요청
+        ResultActions resultActions = mvc
+                .perform(
+                        post("/auth/signup/mentor")
+                                .contentType(MediaType.APPLICATION_JSON)
+                                .content(String.format("""
+                                        {
+                                            "email": "%s",
+                                            "verificationCode": "%s",
+                                            "password": "password123",
+                                            "name": "멘토사용자",
+                                            "nickname": "멘토닉네임",
+                                            "career": "Backend",
+                                            "careerYears": 5
+                                        }
+                                        """, email, verificationCode).stripIndent())
+                )
+                .andDo(print());
+
+        Member member = memberService.findByEmail(email).get();
+
+        resultActions
+                .andExpect(handler().handlerType(MemberController.class))
+                .andExpect(handler().methodName("signupMentor"))
+                .andExpect(status().is2xxSuccessful())
+                .andExpect(jsonPath("$.resultCode").value("200-3"))
+                .andExpect(jsonPath("$.msg").value("멘토 회원가입 성공"));
+    }
+
+    @Test
+    @DisplayName("멘토 회원가입 시 잘못된 인증번호")
+    void t2_2() throws Exception {
+        String email = "mentor3@example.com";
+
+        // 인증번호 생성
+        emailVerificationService.generateAndSendCode(email);
+
+        // 잘못된 인증번호로 회원가입 시도
+        ResultActions resultActions = mvc
+                .perform(
+                        post("/auth/signup/mentor")
+                                .contentType(MediaType.APPLICATION_JSON)
+                                .content(String.format("""
+                                        {
+                                            "email": "%s",
+                                            "verificationCode": "999999",
+                                            "password": "password123",
+                                            "name": "멘토사용자",
+                                            "nickname": "잘못된닉네임",
+                                            "career": "Backend",
+                                            "careerYears": 5
+                                        }
+                                        """, email).stripIndent())
+                )
+                .andDo(print());
+
+        resultActions
+                .andExpect(handler().handlerType(MemberController.class))
+                .andExpect(handler().methodName("signupMentor"))
+                .andExpect(status().isBadRequest())
+                .andExpect(jsonPath("$.resultCode").value("400-2"))
+                .andExpect(jsonPath("$.msg").value("인증번호가 일치하지 않습니다."));
+    }
+
+    @Test
+    @DisplayName("멘티 회원가입 시 이메일 중복 오류")
+    void t3() throws Exception {
+        // 기존 멘티 회원가입
+        memberService.joinMentee("duplicate@example.com", "기존사용자", "기존닉네임", "password123", "Backend");
+
+        // 동일한 이메일로 다시 회원가입 시도
+        ResultActions resultActions = mvc
+                .perform(
+                        post("/auth/signup/mentee")
+                                .contentType(MediaType.APPLICATION_JSON)
+                                .content("""
+                                        {
+                                            "email": "duplicate@example.com",
+                                            "password": "password456",
+                                            "name": "새사용자",
+                                            "nickname": "새닉네임",
+                                            "interestedField": "Frontend"
+                                        }
+                                        """.stripIndent())
+                )
+                .andDo(print());
+
+        resultActions
+                .andExpect(handler().handlerType(MemberController.class))
+                .andExpect(handler().methodName("signupMentee"))
+                .andExpect(status().isBadRequest())
+                .andExpect(jsonPath("$.resultCode").value("400-1"))
+                .andExpect(jsonPath("$.msg").value("이미 존재하는 이메일입니다."));
+    }
+
+    @Test
+    @DisplayName("멘토 회원가입 시 이메일 중복 오류")
+    void t4() throws Exception {
+        String email = "duplicate2@example.com";
+
+        // 기존 멘토 회원가입
+        memberService.joinMentor(email, "기존멘토", "기존멘토닉네임", "password123", "Backend", 5);
+
+        // 인증번호 생성
+        String verificationCode = emailVerificationService.generateAndSendCode(email);
+
+        // 동일한 이메일로 다시 회원가입 시도
+        ResultActions resultActions = mvc
+                .perform(
+                        post("/auth/signup/mentor")
+                                .contentType(MediaType.APPLICATION_JSON)
+                                .content(String.format("""
+                                        {
+                                            "email": "%s",
+                                            "verificationCode": "%s",
+                                            "password": "password456",
+                                            "name": "새멘토",
+                                            "nickname": "새멘토닉네임",
+                                            "career": "Frontend",
+                                            "careerYears": 3
+                                        }
+                                        """, email, verificationCode).stripIndent())
+                )
+                .andDo(print());
+
+        resultActions
+                .andExpect(handler().handlerType(MemberController.class))
+                .andExpect(handler().methodName("signupMentor"))
+                .andExpect(status().isBadRequest())
+                .andExpect(jsonPath("$.resultCode").value("400-2"))
+                .andExpect(jsonPath("$.msg").value("이미 존재하는 이메일입니다."));
+    }
+
+    @Test
+    @DisplayName("멘티 로그인 후 /auth/me로 정보 조회 - rq.getActor() role 확인")
+    void t5() throws Exception {
+        // 멘티 회원가입
+        String email = "mentee@example.com";
+        memberService.joinMentee(email, "멘티사용자", "멘티닉네임", "password123", "Backend");
+
+        // 로그인하여 쿠키 받기
+        ResultActions loginResult = mvc.perform(
+                post("/auth/login")
+                        .contentType(MediaType.APPLICATION_JSON)
+                        .content(String.format("""
+                                {
+                                    "email": "%s",
+                                    "password": "password123"
+                                }
+                                """, email))
+        );
+
+        // 로그인 응답에서 쿠키 추출
+        Cookie accessToken = loginResult.andReturn().getResponse().getCookie("accessToken");
+
+        // /auth/me 호출하여 role 확인 (쿠키 포함)
+        ResultActions result = mvc
+                .perform(get("/auth/me")
+                        .cookie(accessToken))
+                .andDo(print());
+
+        result
+                .andExpect(status().is2xxSuccessful())
+                .andExpect(jsonPath("$.data.role").value("MENTEE"));
+    }
+
+    @Test
+    @DisplayName("멘티 로그인 성공 - 쿠키에 토큰 저장 확인")
+    void t6() throws Exception {
+        // 멘티 회원가입
+        String email = "login@example.com";
+        String password = "password123";
+        memberService.joinMentee(email, "로그인사용자", "로그인닉네임", password, "Backend");
+
+        // 로그인 요청
+        ResultActions result = mvc
+                .perform(
+                        post("/auth/login")
+                                .contentType(MediaType.APPLICATION_JSON)
+                                .content(String.format("""
+                                        {
+                                            "email": "%s",
+                                            "password": "%s"
+                                        }
+                                        """, email, password))
+                )
+                .andDo(print());
+
+        result
+                .andExpect(status().is2xxSuccessful())
+                .andExpect(jsonPath("$.resultCode").value("200-4"))
+                .andExpect(jsonPath("$.msg").value("로그인 성공"))
+                .andExpect(cookie().exists("accessToken"))
+                .andExpect(cookie().exists("refreshToken"));
+    }
+
+    @Test
+    @DisplayName("잘못된 비밀번호로 로그인 실패")
+    void t7() throws Exception {
+        // 멘티 회원가입
+        String email = "fail@example.com";
+        memberService.joinMentee(email, "실패사용자", "실패닉네임", "password123", "Backend");
+
+        // 잘못된 비밀번호로 로그인 시도
+        ResultActions result = mvc
+                .perform(
+                        post("/auth/login")
+                                .contentType(MediaType.APPLICATION_JSON)
+                                .content(String.format("""
+                                        {
+                                            "email": "%s",
+                                            "password": "wrongpassword"
+                                        }
+                                        """, email))
+                )
+                .andDo(print());
+
+        result
+                .andExpect(status().is4xxClientError());
+    }
+
+    @Test
+    @DisplayName("존재하지 않는 이메일로 로그인 실패")
+    void t8() throws Exception {
+        // 존재하지 않는 이메일로 로그인 시도
+        ResultActions result = mvc
+                .perform(
+                        post("/auth/login")
+                                .contentType(MediaType.APPLICATION_JSON)
+                                .content("""
+                                        {
+                                            "email": "notexist@example.com",
+                                            "password": "password123"
+                                        }
+                                        """)
+                )
+                .andDo(print());
+
+        result
+                .andExpect(status().isBadRequest());
+    }
+
+    @Test
+    @DisplayName("로그아웃 성공 - 쿠키 삭제 확인")
+    void t9() throws Exception {
+        // 멘티 회원가입 및 로그인
+        String email = "logout@example.com";
+        memberService.joinMentee(email, "로그아웃사용자", "로그아웃닉네임", "password123", "Backend");
+
+        ResultActions loginResult = mvc.perform(
+                post("/auth/login")
+                        .contentType(MediaType.APPLICATION_JSON)
+                        .content(String.format("""
+                                {
+                                    "email": "%s",
+                                    "password": "password123"
+                                }
+                                """, email))
+        );
+
+        Cookie accessToken = loginResult.andReturn().getResponse().getCookie("accessToken");
+        Cookie refreshToken = loginResult.andReturn().getResponse().getCookie("refreshToken");
+
+        // 로그아웃 요청
+        ResultActions result = mvc
+                .perform(
+                        post("/auth/logout")
+                                .cookie(accessToken)
+                                .cookie(refreshToken)
+                )
+                .andDo(print());
+
+        result
+                .andExpect(status().is2xxSuccessful())
+                .andExpect(jsonPath("$.resultCode").value("200-8"))
+                .andExpect(jsonPath("$.msg").value("로그아웃 성공"))
+                .andExpect(cookie().maxAge("accessToken", 0))
+                .andExpect(cookie().maxAge("refreshToken", 0));
+    }
+
+    @Test
+    @DisplayName("멘티 회원가입 시 닉네임 중복 오류")
+    void t10() throws Exception {
+        // 기존 멘티 회원가입
+        memberService.joinMentee("existing@example.com", "기존사용자", "중복닉네임", "password123", "Backend");
+
+        // 동일한 닉네임으로 다시 회원가입 시도
+        ResultActions resultActions = mvc
+                .perform(
+                        post("/auth/signup/mentee")
+                                .contentType(MediaType.APPLICATION_JSON)
+                                .content("""
+                                        {
+                                            "email": "new@example.com",
+                                            "password": "password456",
+                                            "name": "새사용자",
+                                            "nickname": "중복닉네임",
+                                            "interestedField": "Frontend"
+                                        }
+                                        """.stripIndent())
+                )
+                .andDo(print());
+
+        resultActions
+                .andExpect(handler().handlerType(MemberController.class))
+                .andExpect(handler().methodName("signupMentee"))
+                .andExpect(status().isBadRequest())
+                .andExpect(jsonPath("$.resultCode").value("400-3"))
+                .andExpect(jsonPath("$.msg").value("이미 존재하는 닉네임입니다."));
+    }
+
+    @Test
+    @DisplayName("멘토 회원가입 시 닉네임 중복 오류")
+    void t11() throws Exception {
+        String email = "newmentor@example.com";
+
+        // 기존 멘토 회원가입
+        memberService.joinMentor("existing@example.com", "기존멘토", "중복멘토닉네임", "password123", "Backend", 5);
+
+        // 인증번호 생성
+        String verificationCode = emailVerificationService.generateAndSendCode(email);
+
+        // 동일한 닉네임으로 다시 회원가입 시도
+        ResultActions resultActions = mvc
+                .perform(
+                        post("/auth/signup/mentor")
+                                .contentType(MediaType.APPLICATION_JSON)
+                                .content(String.format("""
+                                        {
+                                            "email": "%s",
+                                            "verificationCode": "%s",
+                                            "password": "password456",
+                                            "name": "새멘토",
+                                            "nickname": "중복멘토닉네임",
+                                            "career": "Frontend",
+                                            "careerYears": 3
+                                        }
+                                        """, email, verificationCode).stripIndent())
+                )
+                .andDo(print());
+
+        resultActions
+                .andExpect(handler().handlerType(MemberController.class))
+                .andExpect(handler().methodName("signupMentor"))
+                .andExpect(status().isBadRequest())
+                .andExpect(jsonPath("$.resultCode").value("400-4"))
+                .andExpect(jsonPath("$.msg").value("이미 존재하는 닉네임입니다."));
+    }
+
+    @Test
+    @DisplayName("회원 탈퇴 성공")
+    void t12() throws Exception {
+        // 멘티 회원가입
+        String email = "delete@example.com";
+        memberService.joinMentee(email, "탈퇴사용자", "탈퇴닉네임", "password123", "Backend");
+
+        // 로그인하여 쿠키 받기
+        ResultActions loginResult = mvc.perform(
+                post("/auth/login")
+                        .contentType(MediaType.APPLICATION_JSON)
+                        .content(String.format("""
+                                {
+                                    "email": "%s",
+                                    "password": "password123"
+                                }
+                                """, email))
+        );
+
+        Cookie accessToken = loginResult.andReturn().getResponse().getCookie("accessToken");
+
+        // 회원 탈퇴 요청
+        ResultActions result = mvc
+                .perform(
+                        delete("/auth/me")
+                                .cookie(accessToken)
+                )
+                .andDo(print());
+
+        result
+                .andExpect(status().is2xxSuccessful())
+                .andExpect(jsonPath("$.resultCode").value("200-7"))
+                .andExpect(jsonPath("$.msg").value("회원 탈퇴가 완료되었습니다."))
+                .andExpect(cookie().maxAge("accessToken", 0))
+                .andExpect(cookie().maxAge("refreshToken", 0));
+
+        // 탈퇴 후 해당 이메일로 조회했을 때 없어야 함
+        assertThat(memberService.findByEmail(email)).isEmpty();
+    }
+
+    @Test
+    @DisplayName("로그인하지 않은 상태에서 회원 탈퇴 시도 - 실패")
+    void t13() throws Exception {
+        // 로그인 없이 회원 탈퇴 시도
+        ResultActions result = mvc
+                .perform(delete("/auth/me"))
+                .andDo(print());
+
+        result
+                .andExpect(status().isUnauthorized());
+    }
+
+}
diff --git a/back/src/test/java/com/back/domain/member/member/service/AuthTokenServiceTest.java b/back/src/test/java/com/back/domain/member/member/service/AuthTokenServiceTest.java
new file mode 100644
index 00000000..bd58434f
--- /dev/null
+++ b/back/src/test/java/com/back/domain/member/member/service/AuthTokenServiceTest.java
@@ -0,0 +1,139 @@
+package com.back.domain.member.member.service;
+
+import com.back.domain.member.member.entity.Member;
+import com.back.standard.util.Ut;
+import io.jsonwebtoken.Jwts;
+import io.jsonwebtoken.security.Keys;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.test.context.ActiveProfiles;
+import org.springframework.transaction.annotation.Transactional;
+
+import javax.crypto.SecretKey;
+
+import java.nio.charset.StandardCharsets;
+import java.util.Date;
+import java.util.Map;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+@SpringBootTest
+@ActiveProfiles("test")
+@Transactional
+public class AuthTokenServiceTest {
+    @Autowired
+    private MemberService memberService;
+
+    @Autowired
+    private AuthTokenService authTokenService;
+
+    @Value("${custom.jwt.secretKey}")
+    private String jwtSecretKey;
+
+    @Value("${custom.accessToken.expirationSeconds}")
+    private int accessTokenExpirationSeconds;
+
+    @BeforeEach
+    void setUp() {
+        memberService.joinMentee("user1", "사용자1", "닉네임","password123", "테스트분야");
+    }
+
+    @Test
+    @DisplayName("authTokenService이 존재하는지")
+    void testAuthTokenServiceExists() {
+        assertThat(authTokenService).isNotNull();
+    }
+
+    @Test
+    @DisplayName("jjwt 최신 방식으로 JWT 생성, {name=\"Paul\", age=23}")
+    void t2() {
+        // 토큰 만료기간: 1년
+        long expireMillis = 1000L * accessTokenExpirationSeconds;
+
+        byte[] keyBytes = jwtSecretKey.getBytes(StandardCharsets.UTF_8);
+        SecretKey secretKey = Keys.hmacShaKeyFor(keyBytes);
+
+        // 발행 시간과 만료 시간 설정
+        Date issuedAt = new Date();
+        Date expiration = new Date(issuedAt.getTime() + expireMillis);
+
+        Map<String, Object> payload = Map.of(
+                "name", "Paul",
+                "age", 23
+        );
+
+        String jwt = Jwts.builder()
+                .claims(payload) // 내용
+                .issuedAt(issuedAt) // 생성날짜
+                .expiration(expiration) // 만료날짜
+                .signWith(secretKey) // 키 서명
+                .compact();
+
+        assertThat(jwt).isNotBlank();
+
+        System.out.println("jwt = " + jwt);
+
+        // 키가 유효한지 테스트
+        Map<String, Object> parsedPayload = (Map<String, Object>) Jwts
+                .parser()
+                .verifyWith(secretKey)
+                .build()
+                .parse(jwt)
+                .getPayload();
+
+        assertThat(parsedPayload)
+                .containsAllEntriesOf(payload);
+    }
+
+
+
+    @Test
+    @DisplayName("Ut.jwt.toString 를 통해서 JWT 생성, {name=\"Paul\", age=23}")
+    void t3() {
+        Map<String, Object> payload = Map.of("name", "Paul", "age", 23);
+
+        String jwt = Ut.jwt.toString(
+                jwtSecretKey,
+                accessTokenExpirationSeconds,
+                payload
+        );
+
+        assertThat(jwt).isNotBlank();
+
+        assertThat(Ut.jwt.isValid(jwtSecretKey, jwt))
+                .isTrue();
+
+        Map<String, Object> parsedPayload = Ut.jwt.payload(jwtSecretKey, jwt);
+
+        assertThat(parsedPayload).containsAllEntriesOf(payload);
+    }
+
+
+    @Test
+    @DisplayName("authTokenService.genAccessToken(member);")
+    void t4() {
+        Member memberUser1 = memberService.findByEmail("user1").get();
+
+        String accessToken = authTokenService.genAccessToken(memberUser1);
+
+        assertThat(accessToken).isNotBlank();
+
+        System.out.println("accessToken = " + accessToken);
+
+        Map<String, Object> parsedPayload = authTokenService.payload(accessToken);
+
+        assertThat(parsedPayload)
+                .containsAllEntriesOf(
+                        Map.of(
+                                "email", memberUser1.getEmail(),
+                                "name", memberUser1.getName(),
+                                "role", memberUser1.getRole().name()
+                        )
+                );
+    }
+
+}
diff --git a/back/src/test/java/com/back/domain/mentoring/mentoring/controller/MentoringControllerTest.java b/back/src/test/java/com/back/domain/mentoring/mentoring/controller/MentoringControllerTest.java
new file mode 100644
index 00000000..4d49de0a
--- /dev/null
+++ b/back/src/test/java/com/back/domain/mentoring/mentoring/controller/MentoringControllerTest.java
@@ -0,0 +1,491 @@
+package com.back.domain.mentoring.mentoring.controller;
+
+import com.back.domain.member.member.entity.Member;
+import com.back.domain.member.member.service.AuthTokenService;
+import com.back.domain.member.mentee.entity.Mentee;
+import com.back.domain.member.mentor.entity.Mentor;
+import com.back.domain.mentoring.mentoring.dto.request.MentoringRequest;
+import com.back.domain.mentoring.mentoring.entity.Mentoring;
+import com.back.domain.mentoring.mentoring.error.MentoringErrorCode;
+import com.back.domain.mentoring.mentoring.repository.MentoringRepository;
+import com.back.domain.mentoring.reservation.repository.ReservationRepository;
+import com.back.domain.mentoring.slot.entity.MentorSlot;
+import com.back.domain.mentoring.slot.repository.MentorSlotRepository;
+import com.back.fixture.MemberTestFixture;
+import com.back.fixture.MentoringFixture;
+import com.back.global.exception.ServiceException;
+import com.back.standard.util.Ut;
+import jakarta.servlet.http.Cookie;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.http.MediaType;
+import org.springframework.test.web.servlet.MockMvc;
+import org.springframework.test.web.servlet.ResultActions;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.time.LocalDateTime;
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*;
+import static org.springframework.test.web.servlet.result.MockMvcResultHandlers.print;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;
+
+@SpringBootTest
+@AutoConfigureMockMvc
+@Transactional
+class MentoringControllerTest {
+
+    @Autowired private MockMvc mvc;
+    @Autowired private MemberTestFixture memberFixture;
+    @Autowired private MentoringFixture mentoringFixture;
+
+    @Autowired private MentoringRepository mentoringRepository;
+    @Autowired private MentorSlotRepository mentorSlotRepository;
+    @Autowired private ReservationRepository reservationRepository;
+    @Autowired private AuthTokenService authTokenService;
+
+    private static final String TOKEN = "accessToken";
+    private static final String MENTORING_URL = "/mentoring";
+
+    private Mentor mentor;
+    private Mentee mentee;
+    private String mentorToken;
+    private String menteeToken;
+
+    @BeforeEach
+    void setUp() {
+        // Mentor
+        Member mentorMember = memberFixture.createMentorMember();
+        mentor = memberFixture.createMentor(mentorMember);
+
+        // Mentee
+        Member menteeMember = memberFixture.createMenteeMember();
+        mentee = memberFixture.createMentee(menteeMember);
+
+        // JWT 발급
+        mentorToken = authTokenService.genAccessToken(mentorMember);
+        menteeToken = authTokenService.genAccessToken(menteeMember);
+    }
+
+    // ===== 멘토링 다건 조회 ====
+    @Test
+    @DisplayName("멘토링 다건 조회 - 기본 페이징")
+    void getMentoringsSuccess() throws Exception {
+        mentoringFixture.createMentorings(mentor, 15);
+
+        // TODO: 일반 조회, 목록 조회는 쿠키 없어도 가능하게 설정 필요
+        performGetMentorings(null, "0")
+            .andExpect(jsonPath("$.data.mentorings").isArray())
+            .andExpect(jsonPath("$.data.mentorings.length()").value(10))
+            .andExpect(jsonPath("$.data.currentPage").value(0))
+            .andExpect(jsonPath("$.data.totalPage").value(2))
+            .andExpect(jsonPath("$.data.totalElements").value(15))
+            .andExpect(jsonPath("$.data.hasNext").value(true));
+    }
+
+    @Test
+    @DisplayName("멘토링 다건 조회 - 두번 째 페이지")
+    void getMentoringsSuccessSecondPage() throws Exception {
+        mentoringFixture.createMentorings(mentor, 15);
+
+        performGetMentorings(null, "1")
+            .andExpect(jsonPath("$.data.mentorings").isArray())
+            .andExpect(jsonPath("$.data.mentorings.length()").value(5))
+            .andExpect(jsonPath("$.data.currentPage").value(1))
+            .andExpect(jsonPath("$.data.totalPage").value(2))
+            .andExpect(jsonPath("$.data.totalElements").value(15))
+            .andExpect(jsonPath("$.data.hasNext").value(false));
+    }
+
+    @Test
+    @DisplayName("멘토링 다건 조회 - 빈 결과")
+    void getMentoringsSuccessEmpty() throws Exception {
+        performGetMentorings(null, "0")
+            .andExpect(jsonPath("$.data.mentorings").isArray())
+            .andExpect(jsonPath("$.data.mentorings.length()").value(0))
+            .andExpect(jsonPath("$.data.totalPage").value(0))
+            .andExpect(jsonPath("$.data.totalElements").value(0));
+    }
+
+    @Test
+    @DisplayName("멘토링 다건 조회 - 멘토명 검색")
+    void getMentoringsSuccessSearchMentor() throws Exception {
+        Member mentorMember = memberFixture.createMentorMember();
+        Mentor mentor2 = memberFixture.createMentor(mentorMember);
+
+        mentoringFixture.createMentorings(mentor, 8);
+        mentoringFixture.createMentorings(mentor2, 3);
+
+        performGetMentorings(mentorMember.getName(), "0")
+            .andExpect(jsonPath("$.data.mentorings").isArray())
+            .andExpect(jsonPath("$.data.mentorings.length()").value(3))
+            .andExpect(jsonPath("$.data.currentPage").value(0))
+            .andExpect(jsonPath("$.data.totalPage").value(1))
+            .andExpect(jsonPath("$.data.totalElements").value(3))
+            .andExpect(jsonPath("$.data.hasNext").value(false));
+    }
+
+    @Test
+    @DisplayName("멘토링 다건 조회 - 멘토링 검색")
+    void getMentoringsSuccessSearchMentoring() throws Exception {
+        mentoringFixture.createMentorings(mentor, 20);
+
+        performGetMentorings("테스트 멘토링 1", "0")
+            .andExpect(jsonPath("$.data.mentorings").isArray())
+            .andExpect(jsonPath("$.data.mentorings.length()").value(10))
+            .andExpect(jsonPath("$.data.currentPage").value(0));
+            /*.andExpect(jsonPath("$.data.totalPage").value(2))
+            .andExpect(jsonPath("$.data.totalElements").value(11))
+            .andExpect(jsonPath("$.data.hasNext").value(true));*/
+    }
+
+    @Test
+    @DisplayName("멘토링 다건 조회 - 검색 결과 없는 경우")
+    void getMentoringsSuccessSearchEmpty() throws Exception {
+        mentoringFixture.createMentorings(mentor, 2);
+
+        performGetMentorings("mentee", "0")
+            .andExpect(jsonPath("$.data.mentorings").isArray())
+            .andExpect(jsonPath("$.data.mentorings.length()").value(0))
+            .andExpect(jsonPath("$.data.totalPage").value(0))
+            .andExpect(jsonPath("$.data.totalElements").value(0));
+    }
+
+
+    // ===== 멘토링 단건 조회 =====
+    @Test
+    @DisplayName("멘토링 조회 성공")
+    void getMentoringSuccess() throws Exception {
+        Mentoring mentoring = mentoringFixture.createMentoring(mentor);
+
+        ResultActions resultActions = mvc
+            .perform(
+                get(MENTORING_URL + "/" + mentoring.getId())
+                    .cookie(new Cookie(TOKEN, mentorToken))
+            ).andDo(print());
+
+        resultActions
+            .andExpect(handler().handlerType(MentoringController.class))
+            .andExpect(handler().methodName("getMentoring"))
+            .andExpect(status().isOk())
+            .andExpect(jsonPath("$.resultCode").value("200"))
+            .andExpect(jsonPath("$.msg").value("멘토링을 조회하였습니다."));
+    }
+    
+    
+    // ===== 멘토링 생성 ======
+
+    @Test
+    @DisplayName("멘토링 생성 성공")
+    void createMentoringSuccess() throws Exception {
+        ResultActions resultActions = performCreateMentoring(mentorToken);
+
+        Mentoring mentoring = mentoringRepository.findTopByOrderByIdDesc()
+            .orElseThrow(() -> new ServiceException(MentoringErrorCode.NOT_FOUND_MENTORING));
+        Mentor mentorOfMentoring = mentoring.getMentor();
+
+        resultActions
+            .andExpect(handler().handlerType(MentoringController.class))
+            .andExpect(handler().methodName("createMentoring"))
+            .andExpect(status().isCreated())
+            .andExpect(jsonPath("$.resultCode").value("201"))
+            .andExpect(jsonPath("$.msg").value("멘토링이 생성 완료되었습니다."))
+
+            // Mentoring 정보 검증
+            .andExpect(jsonPath("$.data.mentoring.mentoringId").value(mentoring.getId()))
+            .andExpect(jsonPath("$.data.mentoring.title").value(mentoring.getTitle()))
+            .andExpect(jsonPath("$.data.mentoring.tags").value(mentoring.getTags()))
+            .andExpect(jsonPath("$.data.mentoring.bio").value(mentoring.getBio()))
+            .andExpect(jsonPath("$.data.mentoring.thumb").value(mentoring.getThumb()))
+
+            // Mentor 정보 검증
+            .andExpect(jsonPath("$.data.mentor.mentorId").value(mentorOfMentoring.getId()))
+            .andExpect(jsonPath("$.data.mentor.name").value(mentorOfMentoring.getMember().getName()))
+            .andExpect(jsonPath("$.data.mentor.rate").value(mentorOfMentoring.getRate()))
+            .andExpect(jsonPath("$.data.mentor.careerYears").value(mentorOfMentoring.getCareerYears()));
+    }
+
+    @Test
+    @DisplayName("멘토링 생성 실패 - 멘토가 아닌 경우")
+    void createMentoringFailNotMentorRole() throws Exception {
+        performCreateMentoring(menteeToken)
+            .andExpect(status().isForbidden())
+            .andExpect(jsonPath("$.resultCode").value("403-1"))
+            .andExpect(jsonPath("$.msg").value("접근 권한이 없습니다."));
+    }
+
+    @Test
+    @DisplayName("멘토링 생성 실패 - Mentor 권한이지만 Mentor 엔티티가 없는 경우")
+    void createMentoringFailNotMentor() throws Exception {
+        Member mentorMember = memberFixture.createMentorMember();
+        String token = authTokenService.genAccessToken(mentorMember);
+
+        performCreateMentoring(token)
+            .andExpect(status().isNotFound())
+            .andExpect(jsonPath("$.resultCode").value("404-1"))
+            .andExpect(jsonPath("$.msg").value("멘토를 찾을 수 없습니다."));
+    }
+
+    @Test
+    @DisplayName("멘토링 생성 실패 - 멘토당 멘토링 1개 제한")
+    void createMentoringFailDuplicate() throws Exception {
+        mentoringFixture.createMentoring(mentor);
+
+        performCreateMentoring(mentorToken)
+            .andExpect(status().isConflict())
+            .andExpect(jsonPath("$.resultCode").value("409-1"))
+            .andExpect(jsonPath("$.msg").value("이미 멘토링 정보가 존재합니다."));
+    }
+
+
+    // ===== 멘토링 수정 =====
+
+    @Test
+    @DisplayName("멘토링 수정 성공")
+    void updateMentoringSuccess() throws Exception {
+        Mentoring mentoring = mentoringFixture.createMentoring(mentor);
+
+        MentoringRequest reqDto = new MentoringRequest(
+            "Next.js 멘토링",
+            List.of("Next.js", "React"),
+            "Next.js를 활용한 프론트 개발 입문",
+            "https://example.com/thumb.jpg"
+        );
+
+        ResultActions resultActions = mvc.perform(
+                put(MENTORING_URL + "/" + mentoring.getId())
+                    .cookie(new Cookie(TOKEN, mentorToken))
+                    .contentType(MediaType.APPLICATION_JSON)
+                    .content(Ut.json.toString(reqDto))
+            )
+            .andDo(print());
+
+        resultActions
+            .andExpect(handler().handlerType(MentoringController.class))
+            .andExpect(handler().methodName("updateMentoring"))
+            .andExpect(status().isOk())
+            .andExpect(jsonPath("$.resultCode").value("200"))
+            .andExpect(jsonPath("$.msg").value("멘토링이 수정되었습니다."))
+
+            // Mentoring 정보 검증
+            .andExpect(jsonPath("$.data.mentoring.mentoringId").value(mentoring.getId()))
+            .andExpect(jsonPath("$.data.mentoring.title").value(reqDto.title()))
+            .andExpect(jsonPath("$.data.mentoring.tags[0]").value(reqDto.tags().get(0)))
+            .andExpect(jsonPath("$.data.mentoring.tags[1]").value(reqDto.tags().get(1)))
+            .andExpect(jsonPath("$.data.mentoring.bio").value(reqDto.bio()))
+            .andExpect(jsonPath("$.data.mentoring.thumb").value(reqDto.thumb()));
+    }
+
+    @Test
+    @DisplayName("멘토링 수정 실패 - 멘토링 존재하지 않는 경우")
+    void updateMentoringFailNotMentoring() throws Exception {
+        long nonId = Long.MAX_VALUE;
+
+        performUpdateMentoring(nonId, mentorToken)
+            .andExpect(status().isNotFound())
+            .andExpect(jsonPath("$.resultCode").value("404-2"))
+            .andExpect(jsonPath("$.msg").value("멘토링을 찾을 수 없습니다."));
+    }
+
+    @Test
+    @DisplayName("멘토링 수정 실패 - 멘토링 소유자가 아닌 경우")
+    void updateMentoringFailNotOwner() throws Exception {
+        Mentoring mentoring = mentoringFixture.createMentoring(mentor);
+
+        // 다른 멘토
+        Member otherMentor = memberFixture.createMentorMember();
+        memberFixture.createMentor(otherMentor);
+        String token = authTokenService.genAccessToken(otherMentor);
+
+        performUpdateMentoring(mentoring.getId(), token)
+            .andExpect(status().isForbidden())
+            .andExpect(jsonPath("$.resultCode").value("403-1"))
+            .andExpect(jsonPath("$.msg").value("해당 멘토링에 대한 권한이 없습니다."));
+    }
+
+
+    // ===== 멘토링 삭제 =====
+
+    @Test
+    @DisplayName("멘토링 삭제 성공 - 연관 엔티티 없는 경우")
+    void deleteMentoringSuccess() throws Exception {
+        Mentoring mentoring = mentoringFixture.createMentoring(mentor);
+
+        long preCnt = mentoringRepository.count();
+
+        ResultActions resultActions = mvc.perform(
+                delete(MENTORING_URL + "/" + mentoring.getId())
+                    .cookie(new Cookie(TOKEN, mentorToken))
+            )
+            .andDo(print());
+
+        long afterCnt = mentoringRepository.count();
+
+        resultActions
+            .andExpect(handler().handlerType(MentoringController.class))
+            .andExpect(handler().methodName("deleteMentoring"))
+            .andExpect(status().isOk())
+            .andExpect(jsonPath("$.resultCode").value("200"))
+            .andExpect(jsonPath("$.msg").value("멘토링이 삭제되었습니다."));
+
+        assertThat(preCnt - afterCnt).isEqualTo(1);
+        assertThat(mentoringRepository.findById(mentoring.getId())).isEmpty();
+        assertThat(reservationRepository.existsByMentoringId(mentoring.getId())).isFalse();
+        assertThat(mentorSlotRepository.existsByMentorId(mentor.getId())).isFalse();
+    }
+
+    @Test
+    @DisplayName("멘토링 삭제 성공 - 멘토 슬롯이 있는 경우")
+    void deleteMentoringSuccessExistsMentorSlot() throws Exception {
+        Mentoring mentoring = mentoringFixture.createMentoring(mentor);
+        LocalDateTime baseDateTime = LocalDateTime.of(2025, 10, 1, 10, 0);
+        mentoringFixture.createMentorSlots(mentor, baseDateTime, 3, 2);
+
+        long preMentoringCnt = mentoringRepository.count();
+        long preSlotCnt = mentorSlotRepository.count();
+
+        ResultActions resultActions = mvc.perform(
+                delete(MENTORING_URL + "/" + mentoring.getId())
+                    .cookie(new Cookie(TOKEN, mentorToken))
+            )
+            .andDo(print());
+
+        long afterMentoringCnt = mentoringRepository.count();
+        long afterSlotCnt = mentorSlotRepository.count();
+
+        resultActions
+            .andExpect(handler().handlerType(MentoringController.class))
+            .andExpect(handler().methodName("deleteMentoring"))
+            .andExpect(status().isOk())
+            .andExpect(jsonPath("$.resultCode").value("200"))
+            .andExpect(jsonPath("$.msg").value("멘토링이 삭제되었습니다."));
+
+        assertThat(preMentoringCnt - afterMentoringCnt).isEqualTo(1);
+        assertThat(preSlotCnt - afterSlotCnt).isEqualTo(6);
+        assertThat(mentoringRepository.findById(mentoring.getId())).isEmpty();
+        assertThat(reservationRepository.existsByMentoringId(mentoring.getId())).isFalse();
+        assertThat(mentorSlotRepository.existsByMentorId(mentor.getId())).isFalse();
+    }
+
+    @Test
+    @DisplayName("멘토링 삭제 실패 - 멘토링 존재하지 않는 경우")
+    void deleteMentoringFailNotMentoring() throws Exception {
+        long nonId = Long.MAX_VALUE;
+
+        performDeleteMentoring(nonId, mentorToken)
+            .andExpect(status().isNotFound())
+            .andExpect(jsonPath("$.resultCode").value("404-2"))
+            .andExpect(jsonPath("$.msg").value("멘토링을 찾을 수 없습니다."));
+    }
+
+    @Test
+    @DisplayName("멘토링 삭제 실패 - 멘토링 소유자가 아닌 경우")
+    void deleteMentoringFailNotOwner() throws Exception {
+        Mentoring mentoring = mentoringFixture.createMentoring(mentor);
+
+        // 다른 멘토
+        Member otherMentor = memberFixture.createMentorMember();
+        memberFixture.createMentor(otherMentor);
+        String token = authTokenService.genAccessToken(otherMentor);
+
+        performDeleteMentoring(mentoring.getId(), token)
+            .andExpect(status().isForbidden())
+            .andExpect(jsonPath("$.resultCode").value("403-1"))
+            .andExpect(jsonPath("$.msg").value("해당 멘토링에 대한 권한이 없습니다."));
+    }
+
+    @Test
+    @DisplayName("멘토링 삭제 실패 - 예약 정보가 있는 경우")
+    void deleteMentoringFailExistsReservation() throws Exception {
+        Mentoring mentoring = mentoringFixture.createMentoring(mentor);
+        MentorSlot mentorSlot = mentoringFixture.createMentorSlot(mentor);
+        mentoringFixture.createReservation(mentoring, mentee, mentorSlot);
+
+        performDeleteMentoring(mentoring.getId(), mentorToken)
+            .andExpect(status().isBadRequest())
+            .andExpect(jsonPath("$.resultCode").value("400-1"))
+            .andExpect(jsonPath("$.msg").value("예약 이력이 있는 멘토링은 삭제할 수 없습니다."));
+
+    }
+
+
+    // ===== perform =====
+
+    private ResultActions performGetMentorings(String keyword, String page) throws Exception {
+        ResultActions resultActions = mvc
+            .perform(
+                get(MENTORING_URL)
+                    .cookie(new Cookie(TOKEN, mentorToken))
+                    .param("page", page)
+                    .param("size", "10")
+                    .param("keyword", keyword)
+            ).andDo(print());
+
+        return resultActions
+            .andExpect(handler().handlerType(MentoringController.class))
+            .andExpect(handler().methodName("getMentorings"))
+            .andExpect(status().isOk())
+            .andExpect(jsonPath("$.resultCode").value("200"))
+            .andExpect(jsonPath("$.msg").value("멘토링 목록을 조회하였습니다."));
+    }
+
+    private ResultActions performCreateMentoring(String token) throws Exception {
+        String req = """
+                    {
+                        "title": "Spring Boot 멘토링",
+                        "tags": ["Spring", "Java"],
+                        "bio": "Spring Boot를 활용한 백엔드 개발 입문",
+                        "thumb": "https://example.com/thumb.jpg"
+                    }
+                    """;
+
+        return mvc
+            .perform(
+                post(MENTORING_URL)
+                    .cookie(new Cookie(TOKEN, token))
+                    .contentType(MediaType.APPLICATION_JSON)
+                    .content(req)
+            )
+            .andDo(print())
+            .andExpect(handler().handlerType(MentoringController.class))
+            .andExpect(handler().methodName("createMentoring"));
+    }
+
+    private ResultActions performUpdateMentoring(Long mentoringId, String token) throws Exception {
+        String req = """
+                    {
+                        "title": "Next.js 멘토링",
+                        "tags": ["Next.js", "React"],
+                        "bio": "Next.js를 활용한 프론트 개발 입문",
+                        "thumb": "https://example.com/thumb.jpg"
+                    }
+                    """;
+
+        return mvc
+            .perform(
+                put(MENTORING_URL + "/" + mentoringId)
+                    .cookie(new Cookie(TOKEN, token))
+                    .contentType(MediaType.APPLICATION_JSON)
+                    .content(req)
+            )
+            .andDo(print())
+            .andExpect(handler().handlerType(MentoringController.class))
+            .andExpect(handler().methodName("updateMentoring"));
+    }
+
+    private ResultActions performDeleteMentoring(Long mentoringId, String token) throws Exception {
+        return mvc
+            .perform(
+                delete(MENTORING_URL + "/" + mentoringId)
+                    .cookie(new Cookie(TOKEN, token))
+            )
+            .andDo(print())
+            .andExpect(handler().handlerType(MentoringController.class))
+            .andExpect(handler().methodName("deleteMentoring"));
+    }
+}
\ No newline at end of file
diff --git a/back/src/test/java/com/back/domain/mentoring/slot/controller/MentorSlotControllerTest.java b/back/src/test/java/com/back/domain/mentoring/slot/controller/MentorSlotControllerTest.java
new file mode 100644
index 00000000..359e092c
--- /dev/null
+++ b/back/src/test/java/com/back/domain/mentoring/slot/controller/MentorSlotControllerTest.java
@@ -0,0 +1,192 @@
+package com.back.domain.mentoring.slot.controller;
+
+import com.back.domain.member.member.entity.Member;
+import com.back.domain.member.member.service.AuthTokenService;
+import com.back.domain.member.mentor.entity.Mentor;
+import com.back.domain.mentoring.mentoring.entity.Mentoring;
+import com.back.domain.mentoring.slot.entity.MentorSlot;
+import com.back.domain.mentoring.slot.error.MentorSlotErrorCode;
+import com.back.domain.mentoring.slot.repository.MentorSlotRepository;
+import com.back.fixture.MemberTestFixture;
+import com.back.fixture.MentoringFixture;
+import com.back.global.exception.ServiceException;
+import jakarta.servlet.http.Cookie;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.http.MediaType;
+import org.springframework.test.web.servlet.MockMvc;
+import org.springframework.test.web.servlet.ResultActions;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.put;
+import static org.springframework.test.web.servlet.result.MockMvcResultHandlers.print;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;
+
+
+@SpringBootTest
+@AutoConfigureMockMvc
+@Transactional
+class MentorSlotControllerTest {
+
+    @Autowired private MockMvc mvc;
+    @Autowired private MemberTestFixture memberFixture;
+    @Autowired private MentoringFixture mentoringFixture;
+
+    @Autowired private MentorSlotRepository mentorSlotRepository;
+    @Autowired private AuthTokenService authTokenService;
+
+    private static final String TOKEN = "accessToken";
+    private static final String MENTOR_SLOT_URL = "/mentor-slot";
+
+    private Mentor mentor;
+    private String mentorToken;
+    private Mentoring mentoring;
+    private List<MentorSlot> mentorSlots = new ArrayList<>();
+
+    @BeforeEach
+    void setUp() {
+        // Mentor
+        Member mentorMember = memberFixture.createMentorMember();
+        mentor = memberFixture.createMentor(mentorMember);
+
+        // // JWT 발급
+        mentorToken = authTokenService.genAccessToken(mentorMember);
+
+        // Mentoring
+        mentoring = mentoringFixture.createMentoring(mentor);
+
+        // 2025-10-01 ~ 2025-10-02 10:00 ~ 11:30 (30분 단위 MentorSlot)
+        LocalDateTime baseDateTime = LocalDateTime.of(2025, 10, 1, 10, 0);
+        mentorSlots = mentoringFixture.createMentorSlots(mentor, baseDateTime, 2, 3);
+    }
+
+    // ===== 슬롯 생성 =====
+
+    @Test
+    @DisplayName("멘토 슬롯 생성 성공")
+    void createMentorSlotSuccess() throws Exception {
+        String startDateTime = "2025-09-30T15:00:00";
+        String endDateTime = "2025-09-30T16:00:00";
+
+        ResultActions resultActions = performCreateMentorSlot(mentor.getId(), mentorToken, startDateTime, endDateTime)
+            .andExpect(status().isCreated())
+            .andExpect(jsonPath("$.resultCode").value("201"))
+            .andExpect(jsonPath("$.msg").value("멘토링 예약 일정을 등록했습니다."));
+
+        MentorSlot mentorSlot = mentorSlotRepository.findTopByOrderByIdDesc()
+            .orElseThrow(() -> new ServiceException(MentorSlotErrorCode.NOT_FOUND_MENTOR_SLOT));
+
+        resultActions
+            .andExpect(jsonPath("$.data.mentorSlotId").value(mentorSlot.getId()))
+            .andExpect(jsonPath("$.data.mentorId").value(mentorSlot.getMentor().getId()))
+            .andExpect(jsonPath("$.data.mentoringId").value(mentoring.getId()))
+            .andExpect(jsonPath("$.data.mentoringTitle").value(mentoring.getTitle()))
+            .andExpect(jsonPath("$.data.startDateTime").value(startDateTime))
+            .andExpect(jsonPath("$.data.endDateTime").value(endDateTime))
+            .andExpect(jsonPath("$.data.mentorSlotStatus").value("AVAILABLE"));
+    }
+
+    @Test
+    @DisplayName("멘토 슬롯 생성 실패 - 멘토가 아닌 경우")
+    void createMentorSlotFailNotMentor() throws Exception {
+        Member menteeMember = memberFixture.createMenteeMember();
+        String token  = authTokenService.genAccessToken(menteeMember);
+
+        performCreateMentorSlot(mentor.getId(), token, "2025-09-30T15:00:00", "2025-09-30T16:00:00")
+            .andExpect(status().isForbidden())
+            .andExpect(jsonPath("$.resultCode").value("403-1"))
+            .andExpect(jsonPath("$.msg").value("접근 권한이 없습니다."));
+    }
+
+    @Test
+    @DisplayName("멘토 슬롯 생성 실패 - 종료 일시가 시작 일시보다 빠른 경우")
+    void createMentorSlotFailInValidDate() throws Exception {
+        performCreateMentorSlot(mentor.getId(), mentorToken, "2025-09-30T20:00:00", "2025-09-30T16:00:00")
+            .andExpect(status().isBadRequest())
+            .andExpect(jsonPath("$.resultCode").value("400-4"))
+            .andExpect(jsonPath("$.msg").value("종료 일시는 시작 일시보다 이후여야 합니다."));
+    }
+
+    @Test
+    @DisplayName("멘토 슬롯 생성 실패 - 기존 슬롯과 시간 겹치는 경우")
+    void createMentorSlotFailOverlappingSlots() throws Exception {
+        performCreateMentorSlot(mentor.getId(), mentorToken, "2025-10-01T11:00:00", "2025-10-01T11:20:00")
+            .andExpect(status().isConflict())
+            .andExpect(jsonPath("$.resultCode").value("409-1"))
+            .andExpect(jsonPath("$.msg").value("선택한 시간은 이미 예약된 시간대입니다."));
+    }
+
+
+    // ===== 슬롯 수정 =====
+
+    @Test
+    @DisplayName("멘토 슬롯 수정 성공")
+    void updateMentorSlotSuccess() throws Exception {
+        MentorSlot mentorSlot = mentorSlots.getFirst();
+        LocalDateTime updateEndDate = mentorSlot.getEndDateTime().minusMinutes(10);
+
+        String req = """
+            {
+                "mentorId": %d,
+                "startDateTime": "%s",
+                "endDateTime": "%s"
+            }
+            """.formatted(mentor.getId(), mentorSlot.getStartDateTime(), updateEndDate);
+
+        ResultActions resultActions = mvc.perform(
+                put(MENTOR_SLOT_URL + "/" + mentorSlot.getId())
+                    .cookie(new Cookie(TOKEN, mentorToken))
+                    .contentType(MediaType.APPLICATION_JSON)
+                    .content(req)
+            )
+            .andDo(print());
+
+        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH:mm:ss");
+        String expectedEndDate = updateEndDate.format(formatter);
+
+        resultActions
+            .andExpect(handler().handlerType(MentorSlotController.class))
+            .andExpect(handler().methodName("updateMentorSlot"))
+            .andExpect(jsonPath("$.resultCode").value("200"))
+            .andExpect(jsonPath("$.msg").value("멘토링 예약 일정이 수정되었습니다."))
+            .andExpect(jsonPath("$.data.mentorSlotId").value(mentorSlot.getId()))
+            .andExpect(jsonPath("$.data.mentorId").value(mentorSlot.getMentor().getId()))
+            .andExpect(jsonPath("$.data.mentoringId").value(mentoring.getId()))
+            .andExpect(jsonPath("$.data.mentoringTitle").value(mentoring.getTitle()))
+            .andExpect(jsonPath("$.data.endDateTime").value(expectedEndDate))
+            .andExpect(jsonPath("$.data.mentorSlotStatus").value("AVAILABLE"));
+    }
+
+
+    // ===== perform =====
+
+    private ResultActions performCreateMentorSlot(Long mentorId, String token, String start, String end) throws Exception {
+        String req = """
+            {
+                "mentorId": %d,
+                "startDateTime": "%s",
+                "endDateTime": "%s"
+            }
+            """.formatted(mentorId, start, end);
+
+        return mvc.perform(
+                post(MENTOR_SLOT_URL)
+                    .cookie(new Cookie(TOKEN, token))
+                    .contentType(MediaType.APPLICATION_JSON)
+                    .content(req)
+            )
+            .andDo(print())
+            .andExpect(handler().handlerType(MentorSlotController.class))
+            .andExpect(handler().methodName("createMentorSlot"));
+    }
+}
\ No newline at end of file
diff --git a/back/src/test/java/com/back/domain/news/comment/entity/NewsCommentTest.java b/back/src/test/java/com/back/domain/news/comment/entity/NewsCommentTest.java
new file mode 100644
index 00000000..f8f22f5b
--- /dev/null
+++ b/back/src/test/java/com/back/domain/news/comment/entity/NewsCommentTest.java
@@ -0,0 +1,107 @@
+package com.back.domain.news.comment.entity;
+
+
+import com.back.fixture.MemberFixture;
+import com.back.fixture.NewsFixture;
+import com.back.domain.member.member.entity.Member;
+import com.back.domain.news.news.entity.News;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class NewsCommentTest {
+    @Test
+    @DisplayName("사용자, 뉴스, 내용으로 댓글 객체 생성")
+    void commentCreationTest() {
+        Member member = MemberFixture.createDefault();
+        News news = NewsFixture.createDefault();
+        String content = "This is a sample comment content.";
+        Comment comment = Comment.create(member, news, content);
+
+        assertThat(comment).isNotNull();
+        assertThat(comment.getMember()).isEqualTo(member);
+        assertThat(comment.getNews()).isEqualTo(news);
+        assertThat(comment.getContent()).isEqualTo(content);
+    }
+
+    @Test
+    @DisplayName("멤버가 null인 경우 예외를 반환한다.")
+    void commentCreationTestWithInvalidMember() {
+        News news = NewsFixture.createDefault();
+        String content = "This is a sample comment content.";
+
+        try {
+            Comment.create(null, news, content);
+        } catch (Exception e) {
+            assertThat(e).isInstanceOf(IllegalArgumentException.class);
+        }
+    }
+
+    @Test
+    @DisplayName("뉴스가 null인 경우 예외를 반환한다.")
+    void commentCreationTestWithInvalidNews() {
+        Member member = MemberFixture.createDefault();
+        String content = "This is a sample comment content.";
+
+        try {
+            Comment.create(member, null, content);
+        } catch (Exception e) {
+            assertThat(e).isInstanceOf(IllegalArgumentException.class);
+        }
+    }
+
+    @Test
+    @DisplayName("내용이 null 혹은 공백인 경우 예외를 반환한다.")
+    void commentCreationTestWithInvalidContent() {
+        Member member = MemberFixture.createDefault();
+        News news = NewsFixture.createDefault();
+
+        try {
+            Comment.create(member, news, null);
+        } catch (Exception e) {
+            assertThat(e).isInstanceOf(IllegalArgumentException.class);
+        }
+
+        try {
+            Comment.create(member, news, "");
+        } catch (Exception e) {
+            assertThat(e).isInstanceOf(IllegalArgumentException.class);
+        }
+    }
+
+    @Test
+    @DisplayName("댓글 내용을 수정할 수 있다.")
+    void commentUpdateTest() {
+        Member member = MemberFixture.createDefault();
+        News news = NewsFixture.createDefault();
+        String content = "This is a sample comment content.";
+        Comment comment = Comment.create(member, news, content);
+
+        String newContent = "This is the updated comment content.";
+        comment.update(newContent);
+
+        assertThat(comment.getContent()).isEqualTo(newContent);
+    }
+
+    @Test
+    @DisplayName("댓글 수정 시 내용이 null 혹은 공백인 경우 예외를 반환한다.")
+    void commentUpdateTestWithInvalidContent() {
+        Member member = MemberFixture.createDefault();
+        News news = NewsFixture.createDefault();
+        String content = "This is a sample comment content.";
+        Comment comment = Comment.create(member, news, content);
+
+        try {
+            comment.update(null);
+        } catch (Exception e) {
+            assertThat(e).isInstanceOf(IllegalArgumentException.class);
+        }
+
+        try {
+            comment.update("");
+        } catch (Exception e) {
+            assertThat(e).isInstanceOf(IllegalArgumentException.class);
+        }
+    }
+}
diff --git a/back/src/test/java/com/back/domain/news/comment/service/NewsCommentServiceTest.java b/back/src/test/java/com/back/domain/news/comment/service/NewsCommentServiceTest.java
new file mode 100644
index 00000000..13015862
--- /dev/null
+++ b/back/src/test/java/com/back/domain/news/comment/service/NewsCommentServiceTest.java
@@ -0,0 +1,251 @@
+package com.back.domain.news.comment.service;
+
+import com.back.domain.member.member.entity.Member;
+import com.back.domain.news.comment.entity.Comment;
+import com.back.domain.news.comment.repository.CommentRepository;
+import com.back.domain.news.news.entity.News;
+import com.back.domain.news.news.service.NewsService;
+import com.back.fixture.MemberFixture;
+import com.back.fixture.NewsFixture;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+import org.springframework.security.access.AccessDeniedException;
+import java.util.Arrays;
+import java.util.List;
+import java.util.NoSuchElementException;
+import java.util.Optional;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.*;
+
+@ExtendWith(MockitoExtension.class)
+class NewsCommentServiceTest {
+
+    @Mock
+    private CommentRepository commentRepository;
+
+    @Mock
+    private NewsService newsService;
+
+    @InjectMocks
+    private CommentService commentService;
+
+    @Test
+    @DisplayName("댓글 생성 성공")
+    void createComment_Success() {
+        // given
+        Member member = MemberFixture.createDefault();
+        News news = NewsFixture.createDefault();
+        String content = "테스트 댓글입니다.";
+        Comment comment = Comment.create(member, news, content);
+
+        when(commentRepository.save(any(Comment.class))).thenReturn(comment);
+
+        // when
+        Comment createdComment = commentService.createComment(member, news, content);
+
+        // then
+        assertThat(createdComment).isNotNull();
+        assertThat(createdComment.getContent()).isEqualTo(content);
+        assertThat(createdComment.getMember()).isEqualTo(member);
+        assertThat(createdComment.getNews()).isEqualTo(news);
+        verify(commentRepository, times(1)).save(any(Comment.class));
+    }
+
+    @Test
+    @DisplayName("뉴스에 대한 댓글 목록 조회 성공")
+    void getComments_Success() {
+        // given
+        News news = NewsFixture.createDefault();
+        Comment comment1 = Comment.create(MemberFixture.createDefault(), news, "댓글1");
+        Comment comment2 = Comment.create(MemberFixture.createDefault(), news, "댓글2");
+        List<Comment> comments = Arrays.asList(comment1, comment2);
+
+        when(commentRepository.findByNews(news)).thenReturn(comments);
+
+        // when
+        List<Comment> foundComments = commentService.getComments(news);
+
+        // then
+        assertThat(foundComments).hasSize(2);
+        assertThat(foundComments).containsExactlyInAnyOrder(comment1, comment2);
+        verify(commentRepository, times(1)).findByNews(news);
+    }
+
+    @Test
+    @DisplayName("댓글 수정 성공")
+    void updateComment_Success() {
+        // given
+        Member member = MemberFixture.createDefault();
+        News news = NewsFixture.createDefault();
+        Comment existingComment = Comment.create(member, news, "기존 댓글");
+        Long commentId = 1L;
+        String updatedContent = "수정된 댓글입니다.";
+
+        when(commentRepository.findById(commentId)).thenReturn(Optional.of(existingComment));
+
+        // when
+        Comment result = commentService.updateComment(member, news, commentId, updatedContent);
+
+        // then
+        assertThat(result).isNotNull();
+        assertThat(result.getContent()).isEqualTo(updatedContent);
+        verify(commentRepository, times(1)).findById(commentId);
+    }
+
+    @Test
+    @DisplayName("존재하지 않는 댓글 수정 시 예외 발생")
+    void updateComment_CommentNotFound_ThrowsException() {
+        // given
+        Member member = MemberFixture.createDefault();
+        News news = NewsFixture.createDefault();
+        Long nonExistentCommentId = 999L;
+        String updatedContent = "수정된 댓글입니다.";
+
+        when(commentRepository.findById(nonExistentCommentId)).thenReturn(Optional.empty());
+
+        // when & then
+        NoSuchElementException exception = assertThrows(NoSuchElementException.class, () -> {
+            commentService.updateComment(member, news, nonExistentCommentId, updatedContent);
+        });
+
+
+        assertThat(exception.getMessage()).isEqualTo("Comment not found: " + nonExistentCommentId);
+        verify(commentRepository, times(1)).findById(nonExistentCommentId);
+    }
+
+    @Test
+    @DisplayName("댓글 작성자가 아닌 사용자가 수정 시 예외 발생")
+    void updateComment_NotAuthor_ThrowsException() {
+        // given
+        Member author = MemberFixture.createDefault();
+        Member otherMember = MemberFixture.create(2L, "other@example.com", "other", "otherpass", Member.Role.MENTEE);
+        News news = NewsFixture.createDefault();
+        Comment existingComment = Comment.create(author, news, "기존 댓글");
+        Long commentId = 1L;
+        String updatedContent = "수정된 댓글입니다.";
+
+        when(commentRepository.findById(commentId)).thenReturn(Optional.of(existingComment));
+
+        // when & then
+        AccessDeniedException exception = assertThrows(AccessDeniedException.class, () -> {
+            commentService.updateComment(otherMember, news, commentId, updatedContent);
+        });
+
+        assertThat(exception.getMessage()).isEqualTo("You do not have permission to update this comment.");
+        verify(commentRepository, times(1)).findById(commentId);
+    }
+
+    @Test
+    @DisplayName("다른 뉴스의 댓글 수정 시 예외 발생")
+    void updateComment_WrongNews_ThrowsException() {
+        // given
+        Member member = MemberFixture.createDefault();
+        News news1 = NewsFixture.createDefault();
+        News news2 = NewsFixture.create(2L, member, "다른 뉴스");
+        Comment existingComment = Comment.create(member, news1, "기존 댓글");
+        Long commentId = 1L;
+        String updatedContent = "수정된 댓글입니다.";
+
+        when(commentRepository.findById(commentId)).thenReturn(Optional.of(existingComment));
+
+        // when & then
+        IllegalArgumentException exception = assertThrows(IllegalArgumentException.class, () -> {
+            commentService.updateComment(member, news2, commentId, updatedContent);
+        });
+
+        assertThat(exception.getMessage()).isEqualTo("This comment does not belong to the given news.");
+        verify(commentRepository, times(1)).findById(commentId);
+    }
+
+    @Test
+    @DisplayName("댓글 삭제 성공")
+    void deleteComment_Success() {
+        // given
+        Member member = MemberFixture.createDefault();
+        News news = NewsFixture.createDefault();
+        Comment existingComment = Comment.create(member, news, "기존 댓글");
+        Long commentId = 1L;
+
+        when(commentRepository.findById(commentId)).thenReturn(Optional.of(existingComment));
+        doNothing().when(commentRepository).delete(existingComment);
+
+        // when
+        commentService.deleteComment(member, news, commentId);
+
+        // then
+        verify(commentRepository, times(1)).findById(commentId);
+        verify(commentRepository, times(1)).delete(existingComment);
+    }
+
+    @Test
+    @DisplayName("존재하지 않는 댓글 삭제 시 예외 발생")
+    void deleteComment_CommentNotFound_ThrowsException() {
+        // given
+        Member member = MemberFixture.createDefault();
+        News news = NewsFixture.createDefault();
+        Long nonExistentCommentId = 999L;
+
+        when(commentRepository.findById(nonExistentCommentId)).thenReturn(Optional.empty());
+
+        // when & then
+        NoSuchElementException exception = assertThrows(NoSuchElementException.class, () -> {
+            commentService.deleteComment(member, news, nonExistentCommentId);
+        });
+
+        assertThat(exception.getMessage()).isEqualTo("Comment not found: " + nonExistentCommentId);
+        verify(commentRepository, times(1)).findById(nonExistentCommentId);
+        verify(commentRepository, never()).delete(any(Comment.class));
+    }
+
+    @Test
+    @DisplayName("댓글 작성자가 아닌 사용자가 삭제 시 예외 발생")
+    void deleteComment_NotAuthor_ThrowsException() {
+        // given
+        Member author = MemberFixture.createDefault();
+        Member otherMember = MemberFixture.create(2L, "other@example.com", "other", "otherpass", Member.Role.MENTEE);
+        News news = NewsFixture.createDefault();
+        Comment existingComment = Comment.create(author, news, "기존 댓글");
+        Long commentId = 1L;
+
+        when(commentRepository.findById(commentId)).thenReturn(Optional.of(existingComment));
+
+        // when & then
+        AccessDeniedException exception = assertThrows(AccessDeniedException.class, () -> {
+            commentService.deleteComment(otherMember, news, commentId);
+        });
+
+        assertThat(exception.getMessage()).isEqualTo("You do not have permission to delete this comment.");
+        verify(commentRepository, times(1)).findById(commentId);
+        verify(commentRepository, never()).delete(any(Comment.class));
+    }
+
+    @Test
+    @DisplayName("다른 뉴스의 댓글 삭제 시 예외 발생")
+    void deleteComment_WrongNews_ThrowsException() {
+        // given
+        Member member = MemberFixture.createDefault();
+        News news1 = NewsFixture.createDefault();
+        News news2 = NewsFixture.create(2L, member, "다른 뉴스");
+        Comment existingComment = Comment.create(member, news1, "기존 댓글");
+        Long commentId = 1L;
+
+        when(commentRepository.findById(commentId)).thenReturn(Optional.of(existingComment));
+
+        // when & then
+        IllegalArgumentException exception = assertThrows(IllegalArgumentException.class, () -> {
+            commentService.deleteComment(member, news2, commentId);
+        });
+
+        assertThat(exception.getMessage()).isEqualTo("This comment does not belong to the given news.");
+        verify(commentRepository, times(1)).findById(commentId);
+        verify(commentRepository, never()).delete(any(Comment.class));
+    }
+}
diff --git a/back/src/test/java/com/back/domain/news/like/entity/LikeTest.java b/back/src/test/java/com/back/domain/news/like/entity/LikeTest.java
new file mode 100644
index 00000000..190599c4
--- /dev/null
+++ b/back/src/test/java/com/back/domain/news/like/entity/LikeTest.java
@@ -0,0 +1,59 @@
+package com.back.domain.news.like.entity;
+
+import com.back.domain.member.member.entity.Member;
+import com.back.domain.news.news.entity.News;
+import com.back.fixture.MemberFixture;
+import com.back.fixture.NewsFixture;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class LikeTest {
+
+    @Test
+    @DisplayName("멤버와 뉴스로 좋아요 객체 생성")
+    void createLikeTest() {
+        // given
+        Member member = MemberFixture.createDefault();
+        News news = NewsFixture.createDefault();
+
+        // when
+        Like like = Like.create(member, news);
+
+        // then
+        assertThat(like).isNotNull();
+        assertThat(like.getMember()).isEqualTo(member);
+        assertThat(like.getNews()).isEqualTo(news);
+    }
+
+    @Test
+    @DisplayName("멤버가 null일 경우 예외가 발생한다.")
+    void createLikeWithNullMemberTest() {
+        // given
+        News news = NewsFixture.createDefault();
+
+        // when & then
+        try {
+            Like.create(null, news);
+        } catch (Exception e) {
+            assertThat(e).isInstanceOf(IllegalArgumentException.class);
+            assertThat(e.getMessage()).isEqualTo("Member cannot be null");
+        }
+    }
+
+    @Test
+    @DisplayName("뉴스가 null일 경우 예외가 발생한다.")
+    void createLikeWithNullNewsTest() {
+        // given
+        Member member = MemberFixture.createDefault();
+
+        // when & then
+        try {
+            Like.create(member, null);
+        } catch (Exception e) {
+            assertThat(e).isInstanceOf(IllegalArgumentException.class);
+            assertThat(e.getMessage()).isEqualTo("News cannot be null");
+        }
+    }
+}
diff --git a/back/src/test/java/com/back/domain/news/like/service/LikeServiceTest.java b/back/src/test/java/com/back/domain/news/like/service/LikeServiceTest.java
new file mode 100644
index 00000000..d846e0ce
--- /dev/null
+++ b/back/src/test/java/com/back/domain/news/like/service/LikeServiceTest.java
@@ -0,0 +1,92 @@
+package com.back.domain.news.like.service;
+
+import com.back.domain.member.member.entity.Member;
+import com.back.domain.news.like.entity.Like;
+import com.back.domain.news.like.repository.LikeRepository;
+import com.back.domain.news.news.entity.News;
+import com.back.domain.news.news.repository.NewsRepository;
+import com.back.fixture.MemberFixture;
+import com.back.fixture.NewsFixture;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+import java.util.Optional;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.*;
+
+@ExtendWith(MockitoExtension.class)
+class LikeServiceTest {
+
+    @Mock
+    private LikeRepository likeRepository;
+
+    @Mock
+    private NewsRepository newsRepository;
+
+    @InjectMocks
+    private LikeService likeService;
+
+    @Test
+    @DisplayName("사용자는 뉴스에 '좋아요'를 누를 수 있다.")
+    void likeNews_Success() {
+        // given
+        Member member = MemberFixture.createDefault();
+        News news = NewsFixture.createDefault();
+        Long newsId = news.getId();
+
+        when(newsRepository.findById(newsId)).thenReturn(Optional.of(news));
+        when(likeRepository.findByMemberAndNews(member, news)).thenReturn(Optional.empty());
+
+        // when
+        likeService.likeNews(member, newsId);
+
+        // then
+        verify(likeRepository, times(1)).save(any(Like.class));
+    }
+
+    @Test
+    @DisplayName("존재하지 않는 뉴스에 '좋아요'를 누르면 예외가 발생한다.")
+    void likeNews_NewsNotFound_ThrowsException() {
+        // given
+        Member member = MemberFixture.createDefault();
+        Long nonExistentNewsId = 999L;
+
+        when(newsRepository.findById(nonExistentNewsId)).thenReturn(Optional.empty());
+
+        // when & then
+        IllegalArgumentException exception = assertThrows(IllegalArgumentException.class, () -> {
+            likeService.likeNews(member, nonExistentNewsId);
+        });
+
+        assertThat(exception.getMessage()).isEqualTo("해당 뉴스를 찾을 수 없습니다.");
+        verify(likeRepository, never()).save(any(Like.class));
+    }
+
+    @Test
+    @DisplayName("이미 '좋아요'를 누른 뉴스에 다시 '좋아요'를 누르면 예외가 발생한다.")
+    void likeNews_AlreadyLiked_ThrowsException() {
+        // given
+        Member member = MemberFixture.createDefault();
+        News news = NewsFixture.createDefault();
+        Long newsId = news.getId();
+        Like existingLike = Like.create(member, news);
+
+        when(newsRepository.findById(newsId)).thenReturn(Optional.of(news));
+        when(likeRepository.findByMemberAndNews(member, news)).thenReturn(Optional.of(existingLike));
+
+        // when & then
+        IllegalStateException exception = assertThrows(IllegalStateException.class, () -> {
+            likeService.likeNews(member, newsId);
+        });
+
+        assertThat(exception.getMessage()).isEqualTo("이미 좋아요를 누른 뉴스입니다.");
+        verify(likeRepository, never()).save(any(Like.class));
+    }
+}
diff --git a/back/src/test/java/com/back/domain/news/news/entity/NewsTest.java b/back/src/test/java/com/back/domain/news/news/entity/NewsTest.java
new file mode 100644
index 00000000..a29e2c10
--- /dev/null
+++ b/back/src/test/java/com/back/domain/news/news/entity/NewsTest.java
@@ -0,0 +1,294 @@
+package com.back.domain.news.news.entity;
+
+import com.back.domain.file.entity.Video;
+import com.back.domain.news.comment.entity.Comment;
+import com.back.domain.news.like.entity.Like;
+import com.back.fixture.MemberFixture;
+import com.back.fixture.VideoFixture;
+import com.back.domain.member.member.entity.Member;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class NewsTest {
+    @Test
+    @DisplayName("제목과 영상,내용으로 뉴스 객체 생성")
+    void newsCreationTestWithTitleAndContent() {
+        String title = "Sample News Title";
+        String content = "This is a sample news content.";
+        Video video = VideoFixture.createDefault();
+        Member member = MemberFixture.createDefault();
+        News news = News.create(member, title, video, content);
+
+        assertThat(news).isNotNull();
+        assertThat(news.getMember()).isEqualTo(member);
+        assertThat(news.getTitle()).isEqualTo(title);
+        assertThat(news.getVideo()).isEqualTo(video);
+        assertThat(news.getContent()).isEqualTo(content);
+        assertThat(news.getComment().size()).isEqualTo(0);
+        assertThat(news.getLikes().size()).isEqualTo(0);
+    }
+
+    @Test
+    @DisplayName("멤버가 null인 경우 예외를 반환한다.")
+    void newsCreationTestWithInvalidMember() {
+        String title = "Sample News Title";
+        String content = "This is a sample news content.";
+        Video video = VideoFixture.createDefault();
+
+        try {
+            News.create(null, title, video, content);
+        } catch (Exception e) {
+            assertThat(e).isInstanceOf(IllegalArgumentException.class);
+        }
+    }
+
+    @Test
+    @DisplayName("제목이 null 혹은 공백인 경우 예외를 반환한다.")
+    void newsCreationTestWithInvalidTitle() {
+        Member member = MemberFixture.createDefault();
+        String content = "This is a sample news content.";
+        Video video = VideoFixture.createDefault();
+
+        try {
+            News.create(member, null, video, content);
+        } catch (Exception e) {
+            assertThat(e).isInstanceOf(IllegalArgumentException.class);
+        }
+
+        try {
+            News.create(member, "", video, content);
+        } catch (Exception e) {
+            assertThat(e).isInstanceOf(IllegalArgumentException.class);
+        }
+    }
+
+    @Test
+    @DisplayName("영상이 null인 경우 예외를 반환한다.")
+    void newsCreationTestWithInvalidVideo() {
+        Member member = MemberFixture.createDefault();
+        String title = "Sample News Title";
+        String content = "This is a sample news content.";
+
+        try {
+            News.create(member, title, null, content);
+        } catch (Exception e) {
+            assertThat(e).isInstanceOf(IllegalArgumentException.class);
+        }
+    }
+
+    @Test
+    @DisplayName("내용이 null 혹은 공백인 경우 예외를 반환한다.")
+    void newsCreationTestWithInvalidContent() {
+        Member member = MemberFixture.createDefault();
+        String title = "Sample News Title";
+        Video video = VideoFixture.createDefault();
+
+        try {
+            News.create(member, title, video, null);
+        } catch (Exception e) {
+            assertThat(e).isInstanceOf(IllegalArgumentException.class);
+        }
+
+        try {
+            News.create(member, title, video, "");
+        } catch (Exception e) {
+            assertThat(e).isInstanceOf(IllegalArgumentException.class);
+        }
+    }
+
+    @Test
+    @DisplayName("사용자는 뉴스에 좋아요를 누를 수 있다.")
+    void likeNewsTest() {
+        Member member = MemberFixture.createDefault();
+        String title = "Sample News Title";
+        String content = "This is a sample news content.";
+        Video video = VideoFixture.createDefault();
+        News news = News.create(member, title, video, content);
+
+        Like like = Like.create(member, news);
+        news.like(like);
+
+        assertThat(news.getLikes().size()).isEqualTo(1);
+        assertThat(news.getLikes()).contains(like);
+    }
+
+    @Test
+    @DisplayName("사용자는 이미 좋아요를 누른 뉴스에 다시 좋아요를 누를 수 없다.")
+    void likeNewsAlreadyLikedTest() {
+        Member member = MemberFixture.createDefault();
+        String title = "Sample News Title";
+        String content = "This is a sample news content.";
+        Video video = VideoFixture.createDefault();
+        News news = News.create(member, title, video, content);
+
+        Like like = Like.create(member, news);
+        news.like(like);
+
+        try {
+            news.like(like);
+        } catch (Exception e) {
+            assertThat(e).isInstanceOf(IllegalStateException.class);
+        }
+
+        assertThat(news.getLikes().size()).isEqualTo(1);
+    }
+
+    @Test
+    @DisplayName("뉴스의 제목, 영상, 내용을 수정할 수 있다.")
+    void updateNewsTest() {
+        Member member = MemberFixture.createDefault();
+        String title = "Sample News Title";
+        String content = "This is a sample news content.";
+        Video video = VideoFixture.createDefault();
+        News news = News.create(member, title, video, content);
+
+        String newTitle = "Updated News Title";
+        String newContent = "This is the updated news content.";
+        Video newVideo = VideoFixture.createDefault();
+
+        news.update(newTitle, newVideo, newContent);
+
+        assertThat(news.getTitle()).isEqualTo(newTitle);
+        assertThat(news.getContent()).isEqualTo(newContent);
+        assertThat(news.getVideo()).isEqualTo(newVideo);
+    }
+
+    @Test
+    @DisplayName("업데이트시 제목이 null 혹은 공백인 경우 예외를 반환한다.")
+    void updateNewsTestWithInvalidTitle() {
+        Member member = MemberFixture.createDefault();
+        String title = "Sample News Title";
+        String content = "This is a sample news content.";
+        Video video = VideoFixture.createDefault();
+        News news = News.create(member, title, video, content);
+
+        String newContent = "This is the updated news content.";
+        Video newVideo = VideoFixture.createDefault();
+
+        try {
+            news.update(null, newVideo, newContent);
+        } catch (Exception e) {
+            assertThat(e).isInstanceOf(IllegalArgumentException.class);
+        }
+
+        try {
+            news.update("", newVideo, newContent);
+        } catch (Exception e) {
+            assertThat(e).isInstanceOf(IllegalArgumentException.class);
+        }
+    }
+
+    @Test
+    @DisplayName("업데이트시 영상이 null인 경우 예외를 반환한다.")
+    void updateNewsTestWithInvalidVideo() {
+        Member member = MemberFixture.createDefault();
+        String title = "Sample News Title";
+        String content = "This is a sample news content.";
+        Video video = VideoFixture.createDefault();
+        News news = News.create(member, title, video, content);
+
+        String newTitle = "Updated News Title";
+        String newContent = "This is the updated news content.";
+
+        try {
+            news.update(newTitle, null, newContent);
+        } catch (Exception e) {
+            assertThat(e).isInstanceOf(IllegalArgumentException.class);
+        }
+    }
+
+    @Test
+    @DisplayName("업데이트시 내용이 null 혹은 공백인 경우 예외를 반환한다.")
+    void updateNewsTestWithInvalidContent() {
+        Member member = MemberFixture.createDefault();
+        String title = "Sample News Title";
+        String content = "This is a sample news content.";
+        Video video = VideoFixture.createDefault();
+        News news = News.create(member, title, video, content);
+
+        String newTitle = "Updated News Title";
+        Video newVideo = VideoFixture.createDefault();
+
+        try {
+            news.update(newTitle, newVideo, null);
+        } catch (Exception e) {
+            assertThat(e).isInstanceOf(IllegalArgumentException.class);
+        }
+
+        try {
+            news.update(newTitle, newVideo, "");
+        } catch (Exception e) {
+            assertThat(e).isInstanceOf(IllegalArgumentException.class);
+        }
+    }
+
+    @Test
+    @DisplayName("뉴스에 댓글을 추가할 수 있다.")
+    void addCommentTest() {
+        Member member = MemberFixture.createDefault();
+        String title = "Sample News Title";
+        String content = "This is a sample news content.";
+        Video video = VideoFixture.createDefault();
+        News news = News.create(member, title, video, content);
+
+        Comment comment = Comment.create(member, news, "This is a comment.");
+        news.addComment(comment);
+
+        assertThat(news.getComment().size()).isEqualTo(1);
+        assertThat(news.getComment()).contains(comment);
+    }
+
+    @Test
+    @DisplayName("뉴스에 null 댓글을 추가하려 하면 예외를 반환한다.")
+    void addNullCommentTest() {
+        Member member = MemberFixture.createDefault();
+        String title = "Sample News Title";
+        String content = "This is a sample news content.";
+        Video video = VideoFixture.createDefault();
+        News news = News.create(member, title, video, content);
+
+        try {
+            news.addComment(null);
+        } catch (Exception e) {
+            assertThat(e).isInstanceOf(IllegalArgumentException.class);
+        }
+
+        assertThat(news.getComment().size()).isEqualTo(0);
+    }
+
+    @Test
+    @DisplayName("뉴스의 댓글을 제거할 수 있다.")
+    void removeCommentTest() {
+        Member member = MemberFixture.createDefault();
+        String title = "Sample News Title";
+        String content = "This is a sample news content.";
+        Video video = VideoFixture.createDefault();
+        News news = News.create(member, title, video, content);
+
+        Comment comment = Comment.create(member, news, "This is a comment.");
+        news.addComment(comment);
+        assertThat(news.getComment().size()).isEqualTo(1);
+
+        news.removeComment(comment);
+        assertThat(news.getComment().size()).isEqualTo(0);
+    }
+    @Test
+    @DisplayName("뉴스의 null 댓글을 제거하려하면 예외를 반환한다.")
+    void removeNullCommentTest() {
+        Member member = MemberFixture.createDefault();
+        String title = "Sample News Title";
+        String content = "This is a sample news content.";
+        Video video = VideoFixture.createDefault();
+        News news = News.create(member, title, video, content);
+
+        try {
+            news.removeComment(null);
+        } catch (Exception e) {
+            assertThat(e).isInstanceOf(IllegalArgumentException.class);
+        }
+
+        assertThat(news.getComment().size()).isEqualTo(0);
+    }
+}
\ No newline at end of file
diff --git a/back/src/test/java/com/back/domain/post/comment/PostCommentControllerTest.java b/back/src/test/java/com/back/domain/post/comment/PostCommentControllerTest.java
new file mode 100644
index 00000000..017ab35a
--- /dev/null
+++ b/back/src/test/java/com/back/domain/post/comment/PostCommentControllerTest.java
@@ -0,0 +1,299 @@
+package com.back.domain.post.comment;
+
+import com.back.domain.member.member.entity.Member;
+import com.back.domain.member.member.service.MemberService;
+import com.back.domain.post.comment.controller.PostCommentController;
+import com.back.domain.post.comment.entity.PostComment;
+import com.back.domain.post.comment.repository.PostCommentRepository;
+import com.back.domain.post.comment.service.PostCommentService;
+import com.back.global.security.SecurityUser;
+import jakarta.transaction.Transactional;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.http.MediaType;
+import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
+import org.springframework.security.core.Authentication;
+import org.springframework.security.core.authority.SimpleGrantedAuthority;
+import org.springframework.security.core.context.SecurityContextHolder;
+import org.springframework.test.context.ActiveProfiles;
+import org.springframework.test.web.servlet.MockMvc;
+import org.springframework.test.web.servlet.ResultActions;
+
+import java.util.List;
+
+import static org.hamcrest.Matchers.greaterThan;
+import static org.hamcrest.Matchers.hasSize;
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*;
+import static org.springframework.test.web.servlet.result.MockMvcResultHandlers.print;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;
+
+@ActiveProfiles("test")
+@SpringBootTest
+@AutoConfigureMockMvc
+@Transactional
+public class PostCommentControllerTest {
+
+    @Autowired
+    private PostCommentService postCommentService;
+
+    @Autowired
+    private PostCommentRepository postCommentRepository;
+
+    @Autowired
+    private MemberService memberService;
+
+    @Autowired
+    private MockMvc mvc;
+
+    @BeforeEach
+    void setUp() {
+        Member member = memberService.joinMentee("user1", "사용자1", "nickname4","password123", "" );
+
+        // SecurityContext에 인증 정보 설정
+        SecurityUser securityUser = new SecurityUser(
+                member.getId(),
+                member.getEmail(),
+                member.getPassword(),
+                member.getName(),
+                member.getNickname(),
+                List.of(new SimpleGrantedAuthority("ROLE_" + member.getRole().name()))
+        );
+
+        Authentication auth = new UsernamePasswordAuthenticationToken(
+                securityUser,
+                null,
+                securityUser.getAuthorities()
+        );
+
+        SecurityContextHolder.getContext().setAuthentication(auth);
+    }
+
+    @Test
+    @DisplayName("댓글 생성")
+    void t1() throws Exception {
+        ResultActions resultActions = mvc
+                .perform(
+                        post("/post/comment/post/{post_id}", 1L)
+                                .contentType(MediaType.APPLICATION_JSON)
+                                .content("""
+                                        {
+                                           "memberId": 123,
+                                           "postId": 1,
+                                           "role": "mentor",
+                                           "comment": "댓글 내용"
+                                         }
+                                        """.stripIndent())
+                )
+                .andDo(print());
+
+        // 실제 생성된 게시글 조회 (실제 DB에서)
+        PostComment createdPost = postCommentRepository.findById(1L).get();
+
+        resultActions
+                .andExpect(handler().handlerType(PostCommentController.class))
+                .andExpect(handler().methodName("createComment"))
+                .andExpect(status().isOk())
+                .andExpect(jsonPath("$.msg").value("댓글 작성 완료"));
+    }
+
+    @Test
+    @DisplayName("댓글 생성 실패 - comment blank")
+    void t2() throws Exception {
+        ResultActions resultActions = mvc
+                .perform(
+                        post("/post/comment/post/{post_id}", 1L)
+                                .contentType(MediaType.APPLICATION_JSON)
+                                .content("""
+                                        {
+                                           "memberId": 123,
+                                           "postId": 1,
+                                           "role": "mentor",
+                                           "comment": ""
+                                         }
+                                        """.stripIndent())
+                )
+                .andDo(print());
+
+
+        resultActions
+                .andExpect(handler().handlerType(PostCommentController.class))
+                .andExpect(handler().methodName("createComment"))
+                .andExpect(status().isBadRequest())
+                .andExpect(jsonPath("$.msg").value("comment-NotBlank-댓글을 입력해주세요"));
+    }
+
+
+    @Test
+    @DisplayName("댓글 다건조회")
+    void t3() throws Exception {
+        ResultActions resultActions = mvc
+                .perform(
+                        get("/post/comment/post/{post_id}", 1L)
+                )
+                .andDo(print());
+
+
+        resultActions
+                .andExpect(handler().handlerType(PostCommentController.class))
+                .andExpect(handler().methodName("getAllPostComment"))
+                .andExpect(status().isOk())
+                .andExpect(jsonPath("$.data").isArray())
+                .andExpect(jsonPath("$.msg").value("게시글 다건 조회 성공"))
+                .andExpect(jsonPath("$.data").exists())
+                .andExpect(jsonPath("$.data", hasSize(greaterThan(0))));
+
+    }
+
+    @Test
+    @DisplayName("댓글 삭제")
+    void t4() throws Exception {
+        mvc
+                .perform(
+                        post("/post/comment/post/{post_id}", 2L)
+                                .contentType(MediaType.APPLICATION_JSON)
+                                .content("""
+                                        {
+                                           "memberId": 7,
+                                           "postId": 2,
+                                           "role": "mentor",
+                                           "comment": "댓글 내용"
+                                         }
+                                        """)
+                );
+
+
+
+
+        // 댓글 삭제
+        ResultActions resultActions = mvc
+                .perform(
+                        delete("/post/comment/post/{post_id}/comment", 2L)  // URL 수정
+                                .contentType(MediaType.APPLICATION_JSON)   // Content-Type 추가
+                                .content("""
+                                    {
+                                       "commentId": 9
+                                     }
+                                    """)  // Request Body 추가
+                )
+                .andDo(print());
+
+        resultActions
+                .andExpect(status().isOk())  // 먼저 상태 확인
+                .andExpect(handler().handlerType(PostCommentController.class))
+                .andExpect(handler().methodName("removePostComment"))
+                .andExpect(jsonPath("$.resultCode").value("200"))
+                .andExpect(jsonPath("$.msg").value("게시글 삭제 성공"));
+    }
+
+    @Test
+    @DisplayName("댓글 삭제 실패 - 권한 없는 사용자")
+    void t5() throws Exception {
+        ResultActions resultActions = mvc
+                .perform(
+                        delete("/post/comment/post/{post_id}/comment", 1L)  // URL 수정
+                                .contentType(MediaType.APPLICATION_JSON)
+                                .content("""
+                                    {
+                                       "commentId": 1
+                                     }
+                                    """)  // Request Body 추가
+                )
+                .andDo(print());
+
+        resultActions
+                .andExpect(status().isBadRequest())  // 먼저 상태 확인
+                .andExpect(handler().handlerType(PostCommentController.class))
+                .andExpect(handler().methodName("removePostComment"))
+                .andExpect(jsonPath("$.resultCode").value("400"))
+                .andExpect(jsonPath("$.msg").value("삭제 권한이 없습니다."));
+    }
+
+    @Test
+    @DisplayName("댓글 수정")
+    void t6() throws Exception {
+        mvc
+                .perform(
+                        post("/post/comment/post/{post_id}", 2L)
+                                .contentType(MediaType.APPLICATION_JSON)
+                                .content("""
+                                        {
+                                           "memberId": 7,
+                                           "postId": 2,
+                                           "role": "mentor",
+                                           "comment": "댓글 내용"
+                                         }
+                                        """)
+                );
+
+
+        ResultActions resultActions = mvc
+                .perform(
+                        put("/post/comment/post/{post_id}/comment/", 2L)
+                                .contentType(MediaType.APPLICATION_JSON)
+                                .content("""
+                            {                        
+                                "commentId": 10,
+                                "content": "수정용 내용"
+                            }
+                            """)
+                )
+                .andDo(print());
+
+        resultActions
+                .andExpect(handler().handlerType(PostCommentController.class))
+                .andExpect(handler().methodName("updatePostComment"))
+                .andExpect(jsonPath("$.resultCode").value("200"))
+                .andExpect(jsonPath("$.msg").value("댓글 수정 성공"));
+    }
+
+    @Test
+    @DisplayName("댓글 수정 실패 - 권한 없는 사용자 ")
+    void t7() throws Exception {
+        ResultActions resultActions = mvc
+                .perform(
+                        put("/post/comment/post/{post_id}/comment/", 1L)
+                                .contentType(MediaType.APPLICATION_JSON)
+                                .content("""
+                            {                        
+                                "commentId": 1,
+                                "content": "수정용 내용"
+                            }
+                            """)
+                )
+                .andDo(print());
+
+        resultActions
+                .andExpect(handler().handlerType(PostCommentController.class))
+                .andExpect(handler().methodName("updatePostComment"))
+                .andExpect(jsonPath("$.resultCode").value("400"))
+                .andExpect(jsonPath("$.msg").value("수정 권한이 없습니다."));
+    }
+
+    @Test
+    @DisplayName("댓글 수정 실패 - Blank Content")
+    void t8() throws Exception {
+        ResultActions resultActions = mvc
+                .perform(
+                        put("/post/comment/post/{post_id}/comment/", 1L)
+                                .contentType(MediaType.APPLICATION_JSON)
+                                .content("""
+                            {                        
+                                "commentId": 1,
+                                "content": ""
+                            }
+                            """)
+                )
+                .andDo(print());
+
+        resultActions
+                .andExpect(handler().handlerType(PostCommentController.class))
+                .andExpect(handler().methodName("updatePostComment"))
+                .andExpect(jsonPath("$.resultCode").value("400-1"))
+                .andExpect(jsonPath("$.msg").value("content-NotBlank-공백일 수 없습니다."));
+    }
+
+}
diff --git a/back/src/test/java/com/back/domain/post/post/controller/InformationPostControllerTest.java b/back/src/test/java/com/back/domain/post/post/controller/InformationPostControllerTest.java
new file mode 100644
index 00000000..e4d82433
--- /dev/null
+++ b/back/src/test/java/com/back/domain/post/post/controller/InformationPostControllerTest.java
@@ -0,0 +1,421 @@
+package com.back.domain.post.post.controller;
+
+import com.back.domain.member.member.entity.Member;
+import com.back.domain.member.member.service.MemberService;
+import com.back.domain.post.post.entity.Post;
+import com.back.domain.post.post.service.PostService;
+import com.back.global.security.SecurityUser;
+import jakarta.transaction.Transactional;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.http.MediaType;
+import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
+import org.springframework.security.core.Authentication;
+import org.springframework.security.core.authority.SimpleGrantedAuthority;
+import org.springframework.security.core.context.SecurityContextHolder;
+import org.springframework.test.context.ActiveProfiles;
+import org.springframework.test.web.servlet.MockMvc;
+import org.springframework.test.web.servlet.ResultActions;
+
+import java.util.List;
+
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*;
+import static org.springframework.test.web.servlet.result.MockMvcResultHandlers.print;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;
+
+
+@ActiveProfiles("test")
+@SpringBootTest
+@AutoConfigureMockMvc
+@Transactional
+public class InformationPostControllerTest {
+
+    @Autowired
+    private PostService postService;
+
+    @Autowired
+    private MemberService memberService;
+
+    @Autowired
+    private MockMvc mvc;
+
+    @BeforeEach
+    void setUp() {
+        Member member = memberService.joinMentee("user1", "사용자1", "nickname19","password123", "");
+
+        // SecurityContext에 인증 정보 설정
+        SecurityUser securityUser = new SecurityUser(
+                member.getId(),
+                member.getEmail(),
+                member.getPassword(),
+                member.getName(),
+                member.getNickname(),
+                List.of(new SimpleGrantedAuthority("ROLE_" + member.getRole().name()))
+        );
+
+        Authentication auth = new UsernamePasswordAuthenticationToken(
+                securityUser,
+                null,
+                securityUser.getAuthorities()
+        );
+
+        SecurityContextHolder.getContext().setAuthentication(auth);
+    }
+
+    @Test
+    @DisplayName("게시글 생성")
+    void t1() throws Exception {
+        ResultActions resultActions = mvc
+                .perform(
+                        post("/post/infor")
+                                .contentType(MediaType.APPLICATION_JSON)
+                                .content("""
+                                        {
+                                            "memberId": 1,
+                                            "postType": "QUESTIONPOST",
+                                            "title": "테스트 제목",
+                                            "content": "테스트 내용"
+                                        }
+                                        """.stripIndent())
+                )
+                .andDo(print());
+
+        // 실제 생성된 게시글 조회 (실제 DB에서)
+        Post createdPost = postService.findById(4L);
+
+        resultActions
+                .andExpect(handler().handlerType(InformationPostController.class))
+                .andExpect(handler().methodName("createPost"))
+                .andExpect(status().isOk())
+                .andExpect(jsonPath("$.msg").value("게시글이 성공적으로 생성되었습니다."))
+                .andExpect(jsonPath("$.data").exists())
+                .andExpect(jsonPath("$.data.postId").value(createdPost.getId()))
+                .andExpect(jsonPath("$.data.title").value(createdPost.getTitle()));
+    }
+
+    @Test
+    @DisplayName("게시글 생성 실패 - 제목 null")
+    void t6() throws Exception {
+        ResultActions resultActions = mvc
+                .perform(
+                        post("/post/infor")
+                                .contentType(MediaType.APPLICATION_JSON)
+                                .content("""
+                                        {
+                                            "memberId": 1,
+                                            "postType": "INFORMATIONPOST",
+                                            "title": "",
+                                            "content": "테스트 내용"
+                                        }
+                                        """.stripIndent())
+                )
+                .andDo(print());
+
+
+        resultActions
+                .andExpect(handler().handlerType(InformationPostController.class))
+                .andExpect(handler().methodName("createPost"))
+
+                .andExpect(status().isBadRequest())
+                .andExpect(jsonPath("$.msg").value("title-NotBlank-제목은 null 혹은 공백일 수 없습니다."));
+    }
+
+    @Test
+    @DisplayName("일치하지 않는 postType")
+    void t2() throws Exception {
+        ResultActions resultActions = mvc
+                .perform(
+                        post("/post/infor")
+                                .contentType(MediaType.APPLICATION_JSON)
+                                .content("""
+                                        {
+                                            "memberId": 3,
+                                            "postType": "INFORMATIONPOST12",
+                                            "title": "테스트 제목",
+                                            "content": "테스트 내용"
+                                        }
+                                        """.stripIndent())
+                )
+                .andDo(print());
+
+        resultActions
+                .andExpect(handler().handlerType(InformationPostController.class))
+                .andExpect(handler().methodName("createPost"))
+                .andExpect(status().isBadRequest())
+                .andExpect(jsonPath("$.resultCode").value("400-2"))
+                .andExpect(jsonPath("$.msg").value("유효하지 않은 PostType입니다."));
+    }
+
+    @Test
+    @DisplayName("게시글 조회 - 페이징 처리")
+    void t3() throws Exception {
+        // 테스트용 게시글 먼저 생성
+        mvc.perform(
+                post("/post/infor")
+                        .contentType(MediaType.APPLICATION_JSON)
+                        .content("""
+                            {
+                                "memberId": 1,
+                                "postType": "INFORMATIONPOST",
+                                "title": "페이징 테스트 제목 1",
+                                "content": "페이징 테스트 내용 1"
+                            }
+                            """)
+        );
+
+        mvc.perform(
+                post("/post/infor")
+                        .contentType(MediaType.APPLICATION_JSON)
+                        .content("""
+                            {
+                                "memberId": 1,
+                                "postType": "INFORMATIONPOST",
+                                "title": "페이징 테스트 제목 2",
+                                "content": "페이징 테스트 내용 2"
+                            }
+                            """)
+        );
+
+        // 페이징 조회 테스트 - 기본값
+        ResultActions resultActions = mvc
+                .perform(
+                        get("/post/infor")
+                )
+                .andDo(print());
+
+        resultActions
+                .andExpect(handler().handlerType(InformationPostController.class))
+                .andExpect(handler().methodName("getPostWithPage"))
+                .andExpect(status().isOk())
+                .andExpect(jsonPath("$.data").exists())
+                .andExpect(jsonPath("$.data.posts").isArray())
+                .andExpect(jsonPath("$.data.currentPage").value(0))
+                .andExpect(jsonPath("$.data.totalElements").exists())
+                .andExpect(jsonPath("$.msg").value("게시글이 조회 되었습니다."));
+    }
+
+    @Test
+    @DisplayName("게시글 조회 - 페이징 처리 (파라미터 지정)")
+    void t3_1() throws Exception {
+        ResultActions resultActions = mvc
+                .perform(
+                        get("/post/infor")
+                                .param("page", "0")
+                                .param("size", "5")
+                )
+                .andDo(print());
+
+        resultActions
+                .andExpect(handler().handlerType(InformationPostController.class))
+                .andExpect(handler().methodName("getPostWithPage"))
+                .andExpect(status().isOk())
+                .andExpect(jsonPath("$.data.posts").isArray())
+                .andExpect(jsonPath("$.data.currentPage").value(0))
+                .andExpect(jsonPath("$.data.totalPage").exists())
+                .andExpect(jsonPath("$.data.hasNext").exists());
+    }
+
+    @Test
+    @DisplayName("게시글 조회 - 키워드 검색")
+    void t3_2() throws Exception {
+        // 검색 대상 게시글 생성
+        mvc.perform(
+                post("/post/infor")
+                        .contentType(MediaType.APPLICATION_JSON)
+                        .content("""
+                            {
+                                "memberId": 1,
+                                "postType": "INFORMATIONPOST",
+                                "title": "Spring Boot 검색용 제목",
+                                "content": "Spring Boot 검색용 내용"
+                            }
+                            """)
+        );
+
+        ResultActions resultActions = mvc
+                .perform(
+                        get("/post/infor")
+                                .param("keyword", "Spring")
+                                .param("page", "0")
+                                .param("size", "10")
+                )
+                .andDo(print());
+
+        resultActions
+                .andExpect(handler().handlerType(InformationPostController.class))
+                .andExpect(handler().methodName("getPostWithPage"))
+                .andExpect(status().isOk())
+                .andExpect(jsonPath("$.data.posts").isArray())
+                .andExpect(jsonPath("$.msg").value("게시글이 조회 되었습니다."));
+    }
+
+    @Test
+    @DisplayName("게시글 단건조회")
+    void t4() throws Exception {
+        ResultActions resultActions = mvc
+                .perform(
+                        get("/post/infor/{post_id}", 1L)
+                )
+                .andDo(print());
+
+
+        resultActions
+                .andExpect(handler().handlerType(InformationPostController.class))
+                .andExpect(handler().methodName("getSinglePost"))
+                .andExpect(status().isOk())
+                .andExpect(jsonPath("$.msg").value("게시글 단건 조회 성공"))
+                .andExpect(jsonPath("$.data.id").value(1L))
+                .andExpect(jsonPath("$.data.title").value("정보글 제목"))
+                .andExpect(jsonPath("$.data").exists());
+    }
+
+    @Test
+    @DisplayName("게시글 단건조회 실패 - 유효하지 않은 Id")
+    void t5() throws Exception {
+        ResultActions resultActions = mvc
+                .perform(
+                        get("/post/infor/{post_id}", 999L)
+                )
+                .andDo(print());
+
+        resultActions
+                .andExpect(handler().handlerType(InformationPostController.class))
+                .andExpect(handler().methodName("getSinglePost"))
+                .andExpect(jsonPath("$.resultCode").value("400"))
+                .andExpect(jsonPath("$.msg").value("해당 Id의 게시글이 없습니다."));
+    }
+
+    @Test
+    @DisplayName("게시글 삭제")
+    void t7() throws Exception {
+        mvc.perform(
+                post("/post/infor")
+                        .contentType(MediaType.APPLICATION_JSON)
+                        .content("""
+                            {
+                                "memberId": 1,
+                                "postType": "INFORMATIONPOST",
+                                "title": "삭제용 제목",
+                                "content": "삭제용 내용"
+                            }
+                            """)
+        );
+
+
+        ResultActions resultActions = mvc
+                .perform(
+                        delete("/post/infor/{post_id}", 7L)
+                )
+                .andDo(print());
+
+        resultActions
+                .andExpect(handler().handlerType(InformationPostController.class))
+                .andExpect(handler().methodName("removePost"))
+                .andExpect(jsonPath("$.resultCode").value("200"))
+                .andExpect(jsonPath("$.msg").value("게시글 삭제 성공"));
+    }
+
+    @Test
+    @DisplayName("게시글 삭제 실패 - 권한 없는 사용자")
+    void t8() throws Exception {
+        ResultActions resultActions = mvc
+                .perform(
+                        delete("/post/infor/{post_id}", 3L)
+                )
+                .andDo(print());
+
+        resultActions
+                .andExpect(handler().handlerType(InformationPostController.class))
+                .andExpect(handler().methodName("removePost"))
+                .andExpect(jsonPath("$.resultCode").value("400"))
+                .andExpect(jsonPath("$.msg").value("삭제 권한이 없습니다."));
+    }
+
+    @Test
+    @DisplayName("게시글 수정")
+    void t9() throws Exception {
+        mvc.perform(
+                post("/post/infor")
+                        .contentType(MediaType.APPLICATION_JSON)
+                        .content("""
+                            {
+                                "memberId": 1,
+                                "postType": "INFORMATIONPOST",
+                                "title": "삭제용 제목",
+                                "content": "삭제용 내용"
+                            }
+                            """)
+        );
+
+
+        ResultActions resultActions = mvc
+                .perform(
+                        put("/post/infor/{post_id}", 8L)
+                                .contentType(MediaType.APPLICATION_JSON)
+                                .content("""
+                            {                        
+                                "title": "수정용 제목",
+                                "content": "수정용 내용"
+                            }
+                            """)
+                )
+                .andDo(print());
+
+        resultActions
+                .andExpect(handler().handlerType(InformationPostController.class))
+                .andExpect(handler().methodName("updatePost"))
+                .andExpect(jsonPath("$.resultCode").value("200"))
+                .andExpect(jsonPath("$.msg").value("게시글 수정 성공"));
+    }
+
+    @Test
+    @DisplayName("게시글 수정 실패 - 권한 없는 사용자")
+    void t10() throws Exception {
+        ResultActions resultActions = mvc
+                .perform(
+                        put("/post/infor/{post_id}", 2L)
+                                .contentType(MediaType.APPLICATION_JSON)
+                                .content("""
+                            {                        
+                                "title": "수정용 제목",
+                                "content": "수정용 내용"
+                            }
+                            """)
+                )
+                .andDo(print());
+
+        resultActions
+                .andExpect(handler().handlerType(InformationPostController.class))
+                .andExpect(handler().methodName("updatePost"))
+                .andExpect(jsonPath("$.resultCode").value("400"))
+                .andExpect(jsonPath("$.msg").value("수정 권한이 없습니다."));
+    }
+
+    @Test
+    @DisplayName("게시글 수정 실패 - title blank")
+    void t11() throws Exception {
+        ResultActions resultActions = mvc
+                .perform(
+                        put("/post/infor/{post_id}", 6L)
+                                .contentType(MediaType.APPLICATION_JSON)
+                                .content("""
+                            {                        
+                                "title": "",
+                                "content": "수정용 내용"
+                            }
+                            """)
+                )
+                .andDo(print());
+
+        resultActions
+                .andExpect(handler().handlerType(InformationPostController.class))
+                .andExpect(handler().methodName("updatePost"))
+                .andExpect(jsonPath("$.resultCode").value("400-1"))
+                .andExpect(jsonPath("$.msg").value("title-NotBlank-제목은 null 혹은 공백일 수 없습니다."));
+    }
+
+}
diff --git a/back/src/test/java/com/back/domain/roadmap/task/controller/TaskControllerTest.java b/back/src/test/java/com/back/domain/roadmap/task/controller/TaskControllerTest.java
new file mode 100644
index 00000000..89599a6d
--- /dev/null
+++ b/back/src/test/java/com/back/domain/roadmap/task/controller/TaskControllerTest.java
@@ -0,0 +1,417 @@
+package com.back.domain.roadmap.task.controller;
+
+import com.back.domain.roadmap.task.entity.Task;
+import com.back.domain.roadmap.task.service.TaskService;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.http.MediaType;
+import org.springframework.security.test.context.support.WithMockUser;
+import org.springframework.test.context.ActiveProfiles;
+import org.springframework.test.web.servlet.MockMvc;
+import org.springframework.test.web.servlet.ResultActions;
+import org.springframework.transaction.annotation.Transactional;
+
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;
+import static org.springframework.test.web.servlet.result.MockMvcResultHandlers.print;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;
+
+@ActiveProfiles("test")
+@SpringBootTest
+@AutoConfigureMockMvc
+@Transactional
+@WithMockUser
+class TaskControllerTest {
+    @Autowired
+    private TaskService taskService;
+
+    @Autowired
+    private MockMvc mvc;
+
+    @BeforeEach
+    void setUp() {
+        // BaseInitData에 추가로 테스트용 데이터 생성
+        setupAdditionalTestData();
+    }
+
+    @Test
+    @DisplayName("키워드로 Task 검색 - Java 직접 매치")
+    void t1() throws Exception {
+        String keyword = "Java";
+
+        ResultActions resultActions = mvc
+                .perform(
+                        get("/tasks/search")
+                                .param("keyword", keyword)
+                                .contentType(MediaType.APPLICATION_JSON)
+                )
+                .andDo(print());
+
+        resultActions
+                .andExpect(handler().handlerType(TaskController.class))
+                .andExpect(handler().methodName("searchTasks"))
+                .andExpect(status().isOk())
+                .andExpect(jsonPath("$.resultCode").value("200"))
+                .andExpect(jsonPath("$.msg").value("Task 검색 성공"))
+                .andExpect(jsonPath("$.data").isArray())
+                .andExpect(jsonPath("$.data[0].id").exists())
+                .andExpect(jsonPath("$.data[0].id").isNumber())
+                .andExpect(jsonPath("$.data[0].name").exists())
+                .andExpect(jsonPath("$.data[0].name").isString())
+                //.andExpect(jsonPath("$.data.length()").value(2))
+                //.andExpect(jsonPath("$.data[*].name", hasItems("Java", "JavaScript")))
+        ;
+    }
+
+    @Test
+    @DisplayName("키워드로 Task 검색 - 한글 별칭으로 검색")
+    void t2() throws Exception {
+        String keyword = "자바";
+
+        ResultActions resultActions = mvc
+                .perform(
+                        get("/tasks/search")
+                                .param("keyword", keyword)
+                )
+                .andDo(print());
+
+        resultActions
+                .andExpect(handler().handlerType(TaskController.class))
+                .andExpect(handler().methodName("searchTasks"))
+                .andExpect(status().isOk())
+                .andExpect(jsonPath("$.resultCode").value("200"))
+                .andExpect(jsonPath("$.msg").value("Task 검색 성공"))
+                .andExpect(jsonPath("$.data").isArray())
+                //.andExpect(jsonPath("$.data.length()").value(2))
+                //.andExpect(jsonPath("$.data[*].name", hasItems("Java", "JavaScript")))
+        ;
+    }
+
+    @Test
+    @DisplayName("키워드로 Task 검색 - 대소문자 무시")
+    void t3() throws Exception {
+        String keyword = "REACT";
+
+        ResultActions resultActions = mvc
+                .perform(
+                        get("/tasks/search")
+                                .param("keyword", keyword)
+                )
+                .andDo(print());
+
+        resultActions
+                .andExpect(status().isOk())
+                .andExpect(jsonPath("$.resultCode").value("200"))
+                .andExpect(jsonPath("$.msg").value("Task 검색 성공"))
+                .andExpect(jsonPath("$.data").isArray())
+                //.andExpect(jsonPath("$.data.length()").value(1))
+                //.andExpect(jsonPath("$.data[0].name").value("React"))
+        ;
+    }
+
+    @Test
+    @DisplayName("키워드로 Task 검색 - 검색 결과 없음")
+    void t4() throws Exception {
+        String keyword = "nonexistent";
+
+        ResultActions resultActions = mvc
+                .perform(
+                        get("/tasks/search")
+                                .param("keyword", keyword)
+                )
+                .andDo(print());
+
+        resultActions
+                .andExpect(status().isOk())
+                .andExpect(jsonPath("$.resultCode").value("200"))
+                .andExpect(jsonPath("$.msg").value("Task 검색 성공"))
+                .andExpect(jsonPath("$.data").isArray())
+                .andExpect(jsonPath("$.data.length()").value(0));
+    }
+
+    @Test
+    @DisplayName("키워드로 Task 검색 - 빈 키워드")
+    void t5() throws Exception {
+        String keyword = "";
+
+        ResultActions resultActions = mvc
+                .perform(
+                        get("/tasks/search")
+                                .param("keyword", keyword)
+                )
+                .andDo(print());
+
+        resultActions
+                .andExpect(status().isOk())
+                .andExpect(jsonPath("$.resultCode").value("200"))
+                .andExpect(jsonPath("$.msg").value("검색 결과가 없습니다."))
+                .andExpect(jsonPath("$.data").isArray())
+                .andExpect(jsonPath("$.data.length()").value(0));
+    }
+
+    @Test
+    @DisplayName("키워드로 Task 검색 - 공백만 있는 키워드")
+    void t6() throws Exception {
+        String keyword = "   ";
+
+        ResultActions resultActions = mvc
+                .perform(
+                        get("/tasks/search")
+                                .param("keyword", keyword)
+                )
+                .andDo(print());
+
+        resultActions
+                .andExpect(status().isOk())
+                .andExpect(jsonPath("$.resultCode").value("200"))
+                .andExpect(jsonPath("$.msg").value("검색 결과가 없습니다."))
+                .andExpect(jsonPath("$.data").isArray())
+                .andExpect(jsonPath("$.data.length()").value(0));
+    }
+
+    @Test
+    @DisplayName("키워드로 Task 검색 - null 키워드")
+    void t7() throws Exception {
+        ResultActions resultActions = mvc
+                .perform(
+                        get("/tasks/search")
+                        // keyword 파라미터 없음
+                )
+                .andDo(print());
+
+        // @RequestParam으로 필수 파라미터가 없으면 400 에러
+        resultActions
+                .andExpect(status().isBadRequest());
+    }
+
+    @Test
+    @DisplayName("키워드로 Task 검색 - 앞뒤 공백 제거")
+    void t8() throws Exception {
+        String keywordWithSpaces = "  java  ";
+
+        ResultActions resultActions = mvc
+                .perform(
+                        get("/tasks/search")
+                                .param("keyword", keywordWithSpaces)
+                )
+                .andDo(print());
+
+        resultActions
+                .andExpect(status().isOk())
+                .andExpect(jsonPath("$.resultCode").value("200"))
+                .andExpect(jsonPath("$.msg").value("Task 검색 성공"))
+                .andExpect(jsonPath("$.data").isArray())
+                //.andExpect(jsonPath("$.data.length()").value(2))
+                //.andExpect(jsonPath("$.data[*].name", hasItems("Java", "JavaScript")))
+        ;
+    }
+
+    @Test
+    @DisplayName("키워드로 Task 검색 - 특수문자 포함")
+    void t9() throws Exception {
+        String keyword = "C++";
+
+        ResultActions resultActions = mvc
+                .perform(
+                        get("/tasks/search")
+                                .param("keyword", keyword)
+                )
+                .andDo(print());
+
+        resultActions
+                .andExpect(status().isOk())
+                .andExpect(jsonPath("$.resultCode").value("200"))
+                .andExpect(jsonPath("$.msg").value("Task 검색 성공"))
+                .andExpect(jsonPath("$.data").isArray())
+                .andExpect(jsonPath("$.data.length()").value(1))
+                .andExpect(jsonPath("$.data[0].name").value("C++"));
+    }
+
+    @Test
+    @DisplayName("키워드로 Task 검색 - pending alias는 결과에서 제외")
+    void t10() throws Exception {
+        String keyword = "미지";
+
+        ResultActions resultActions = mvc
+                .perform(
+                        get("/tasks/search")
+                                .param("keyword", keyword)
+                )
+                .andDo(print());
+
+        resultActions
+                .andExpect(status().isOk())
+                .andExpect(jsonPath("$.resultCode").value("200"))
+                .andExpect(jsonPath("$.msg").value("Task 검색 성공"))
+                .andExpect(jsonPath("$.data").isArray())
+                .andExpect(jsonPath("$.data.length()").value(0));
+    }
+
+    @Test
+    @DisplayName("Pending Alias 생성 - 성공")
+    void t11() throws Exception {
+        String requestBody = """
+            {
+                "taskName": "새로운기술"
+            }
+            """;
+
+        ResultActions resultActions = mvc
+                .perform(
+                        post("/tasks/aliases/pending")
+                                .contentType(MediaType.APPLICATION_JSON)
+                                .content(requestBody)
+                )
+                .andDo(print());
+
+        resultActions
+                .andExpect(handler().handlerType(TaskController.class))
+                .andExpect(handler().methodName("createPendingAlias"))
+                .andExpect(status().isCreated())
+                .andExpect(jsonPath("$.resultCode").value("201"))
+                .andExpect(jsonPath("$.msg").value("새로운 Pending Alias 등록 성공. 관리자 검토 후 매칭 또는 새로운 Task로 등록됩니다."))
+                .andExpect(jsonPath("$.data").exists())
+                .andExpect(jsonPath("$.data.aliasId").exists())
+                .andExpect(jsonPath("$.data.aliasId").isNumber())
+                .andExpect(jsonPath("$.data.aliasName").value("새로운기술"))
+                .andExpect(jsonPath("$.data.createTime").exists());
+    }
+
+    @Test
+    @DisplayName("Pending Alias 생성 - 이미 등록된 Task와 중복")
+    void t12() throws Exception {
+        String requestBody = """
+            {
+                "taskName": "Java"
+            }
+            """;
+
+        ResultActions resultActions = mvc
+                .perform(
+                        post("/tasks/aliases/pending")
+                                .contentType(MediaType.APPLICATION_JSON)
+                                .content(requestBody)
+                )
+                .andDo(print());
+
+        resultActions
+                .andExpect(handler().handlerType(TaskController.class))
+                .andExpect(handler().methodName("createPendingAlias"))
+                .andExpect(status().isBadRequest())
+                .andExpect(jsonPath("$.resultCode").value("400"))
+                .andExpect(jsonPath("$.msg").value("이미 등록된 task입니다."));
+    }
+
+    @Test
+    @DisplayName("Pending Alias 생성 - 이미 등록된 Task의 별칭과 중복")
+    void t13() throws Exception {
+        String requestBody = """
+            {
+                "taskName": "자바"
+            }
+            """;
+
+        ResultActions resultActions = mvc
+                .perform(
+                        post("/tasks/aliases/pending")
+                                .contentType(MediaType.APPLICATION_JSON)
+                                .content(requestBody)
+                )
+                .andDo(print());
+
+        resultActions
+                .andExpect(handler().handlerType(TaskController.class))
+                .andExpect(handler().methodName("createPendingAlias"))
+                .andExpect(status().isBadRequest())
+                .andExpect(jsonPath("$.resultCode").value("400"))
+                .andExpect(jsonPath("$.msg").value("이미 등록된 task의 별칭입니다."));
+    }
+
+    @Test
+    @DisplayName("Pending Alias 생성 - 이미 제안된 Pending Alias와 중복")
+    void t14() throws Exception {
+        // Given: 먼저 pending alias를 하나 생성
+        taskService.createPendingAlias("중복테스트");
+
+        String requestBody = """
+            {
+                "taskName": "중복테스트"
+            }
+            """;
+
+        ResultActions resultActions = mvc
+                .perform(
+                        post("/tasks/aliases/pending")
+                                .contentType(MediaType.APPLICATION_JSON)
+                                .content(requestBody)
+                )
+                .andDo(print());
+
+        resultActions
+                .andExpect(handler().handlerType(TaskController.class))
+                .andExpect(handler().methodName("createPendingAlias"))
+                .andExpect(status().isBadRequest())
+                .andExpect(jsonPath("$.resultCode").value("400"))
+                .andExpect(jsonPath("$.msg").value("이미 제안된 task입니다."));
+    }
+
+    @Test
+    @DisplayName("Pending Alias 생성 - 유효성 검사 실패 (빈 문자열)")
+    void t15() throws Exception {
+        String requestBody = """
+            {
+                "taskName": ""
+            }
+            """;
+
+        ResultActions resultActions = mvc
+                .perform(
+                        post("/tasks/aliases/pending")
+                                .contentType(MediaType.APPLICATION_JSON)
+                                .content(requestBody)
+                )
+                .andDo(print());
+
+        resultActions
+                .andExpect(handler().handlerType(TaskController.class))
+                .andExpect(handler().methodName("createPendingAlias"))
+                .andExpect(status().isBadRequest());
+        // @Valid 검증 실패로 400 에러 발생 예상
+    }
+
+    @Test
+    @DisplayName("Pending Alias 생성 - 유효성 검사 실패 (null)")
+    void t16() throws Exception {
+        String requestBody = """
+            {
+                "taskName": null
+            }
+            """;
+
+        ResultActions resultActions = mvc
+                .perform(
+                        post("/tasks/aliases/pending")
+                                .contentType(MediaType.APPLICATION_JSON)
+                                .content(requestBody)
+                )
+                .andDo(print());
+
+        resultActions
+                .andExpect(status().isBadRequest());
+        // @NotBlank 검증 실패
+    }
+
+    private void setupAdditionalTestData() {
+        // 추가 테스트용 Task 생성
+        Task cppTask = taskService.create("C++");
+        taskService.createAlias(cppTask, "씨플플");
+
+        // Pending alias 생성
+        taskService.createPendingAlias("미지의 task");
+    }
+
+}
\ No newline at end of file
diff --git a/back/src/test/java/com/back/domain/roadmap/task/service/TaskServiceTest.java b/back/src/test/java/com/back/domain/roadmap/task/service/TaskServiceTest.java
new file mode 100644
index 00000000..748d3c7b
--- /dev/null
+++ b/back/src/test/java/com/back/domain/roadmap/task/service/TaskServiceTest.java
@@ -0,0 +1,372 @@
+package com.back.domain.roadmap.task.service;
+
+import com.back.domain.roadmap.task.dto.TaskAliasDto;
+import com.back.domain.roadmap.task.entity.Task;
+import com.back.domain.roadmap.task.entity.TaskAlias;
+import com.back.global.exception.ServiceException;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.data.domain.Pageable;
+import org.springframework.test.context.ActiveProfiles;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.*;
+
+@ActiveProfiles("test")
+@SpringBootTest
+@Transactional
+class TaskServiceTest {
+    @Autowired
+    private TaskService taskService;
+
+    @Test
+    @DisplayName("Task 생성 - 성공")
+    void t1() {
+        // Given
+        String taskName = "test task";
+
+        // When
+        Task createdTask = taskService.create(taskName);
+
+        // Then
+        assertThat(createdTask).isNotNull();
+        assertThat(createdTask.getId()).isNotNull();
+        assertThat(createdTask.getName()).isEqualTo(taskName);
+    }
+
+    @Test
+    @DisplayName("TaskAlias 생성 - 성공")
+    void t2() {
+        // Given
+        Task task = taskService.create("test task");
+        String aliasName = "test alias";
+
+        // When
+        TaskAlias createdAlias = taskService.createAlias(task, aliasName);
+
+        // Then
+        assertThat(createdAlias).isNotNull();
+        assertThat(createdAlias.getId()).isNotNull();
+        assertThat(createdAlias.getName()).isEqualTo(aliasName);
+        assertThat(createdAlias.getTask()).isEqualTo(task);
+        assertThat(createdAlias.getTask().getId()).isEqualTo(task.getId());
+    }
+
+    @Test
+    @DisplayName("키워드 검색 - Task 이름으로 검색")
+    void t3() {
+        // Given
+        String keyword = "Java";
+
+        // When
+        List<Task> results = taskService.searchByKeyword(keyword);
+
+        // Then
+        assertThat(results).isNotEmpty();
+        assertThat(results).anyMatch(task -> task.getName().contains(keyword));
+    }
+
+    @Test
+    @DisplayName("키워드 검색 - TaskAlias로 검색")
+    void t4() {
+        // Given
+        String keyword = "자바"; // initData에서 Java의 별칭으로 설정됨
+
+        // When
+        List<Task> results = taskService.searchByKeyword(keyword);
+
+        // Then
+        assertThat(results).isNotEmpty();
+        // 자바라는 별칭을 가진 Task가 검색되어야 함
+    }
+
+    @Test
+    @DisplayName("키워드 검색 - 결과 없음")
+    void t5() {
+        // Given
+        String keyword = "존재하지 않는 기술";
+
+        // When
+        List<Task> results = taskService.searchByKeyword(keyword);
+
+        // Then
+        assertThat(results).isEmpty();
+    }
+
+    @Test
+    @DisplayName("Pending Alias 생성 - 성공")
+    void t6() {
+        // Given
+        String aliasName = "new task";
+
+        // When
+        TaskAlias pendingAlias = taskService.createPendingAlias(aliasName);
+
+        // Then
+        assertThat(pendingAlias).isNotNull();
+        assertThat(pendingAlias.getId()).isNotNull();
+        assertThat(pendingAlias.getName()).isEqualTo(aliasName);
+        assertThat(pendingAlias.getTask()).isNull(); // pending 상태
+    }
+
+    @Test
+    @DisplayName("Pending Alias 생성 실패 - 이미 등록된 Task")
+    void t7() {
+        // Given
+        String existingTaskName = "Java"; // initData에 존재
+
+        // When & Then
+        assertThatThrownBy(() -> taskService.createPendingAlias(existingTaskName))
+                .isInstanceOf(ServiceException.class)
+                .hasMessage("400 : 이미 등록된 task입니다.");
+    }
+
+    @Test
+    @DisplayName("Pending Alias 생성 실패 - 이미 등록된 TaskAlias")
+    void t8() {
+        // Given
+        String existingAliasName = "자바"; // initData에 존재
+
+        // When & Then
+        assertThatThrownBy(() -> taskService.createPendingAlias(existingAliasName))
+                .isInstanceOf(ServiceException.class)
+                .hasMessage("400 : 이미 등록된 task의 별칭입니다.");
+    }
+
+    @Test
+    @DisplayName("Pending Alias 생성 실패 - 이미 제안된 Pending Alias")
+    void t9() {
+        // Given
+        String aliasName = "중복 테스트";
+        taskService.createPendingAlias(aliasName);
+
+        // When & Then
+        assertThatThrownBy(() -> taskService.createPendingAlias(aliasName))
+                .isInstanceOf(ServiceException.class)
+                .hasMessage("400 : 이미 제안된 task입니다.");
+    }
+
+    @Test
+    @DisplayName("Pending Alias 목록 조회 - 페이징")
+    void t10() {
+        // Given
+        taskService.createPendingAlias("test1");
+        taskService.createPendingAlias("test2");
+        taskService.createPendingAlias("test3");
+
+        Pageable pageable = PageRequest.of(0, 2);
+
+        // When
+        Page<TaskAliasDto> result = taskService.getPendingTaskAliases(pageable);
+
+        // Then
+        assertThat(result).isNotNull();
+        assertThat(result.getContent()).isNotEmpty();
+        assertThat(result.getContent()).hasSizeLessThanOrEqualTo(2);
+        assertThat(result.getContent()).allMatch(dto -> dto.aliasId() != null);
+        assertThat(result.getContent()).allMatch(dto -> dto.aliasName() != null);
+    }
+
+    @Test
+    @DisplayName("Pending Alias를 기존 Task와 연결 - 성공")
+    void t11() {
+        // Given
+        Task existingTask = taskService.create("기존 task");
+        TaskAlias pendingAlias = taskService.createPendingAlias("연결 테스트");
+
+        // When
+        TaskAlias linkedAlias = taskService.linkPendingAlias(pendingAlias.getId(), existingTask.getId());
+
+        // Then
+        assertThat(linkedAlias).isNotNull();
+        assertThat(linkedAlias.getTask()).isNotNull();
+        assertThat(linkedAlias.getTask().getId()).isEqualTo(existingTask.getId());
+        assertThat(linkedAlias.getTask().getName()).isEqualTo("기존 task");
+        assertThat(linkedAlias.getName()).isEqualTo("연결 테스트");
+    }
+
+    @Test
+    @DisplayName("Pending Alias를 기존 Task와 연결 실패 - 존재하지 않는 Alias")
+    void t12() {
+        // Given
+        Long nonExistentAliasId = 99999L;
+        Task existingTask = taskService.create("기존 task");
+
+        // When & Then
+        assertThatThrownBy(() -> taskService.linkPendingAlias(nonExistentAliasId, existingTask.getId()))
+                .isInstanceOf(ServiceException.class)
+                .hasMessage("404 : 해당 별칭이 존재하지 않습니다.");
+    }
+
+    @Test
+    @DisplayName("Pending Alias를 기존 Task와 연결 실패 - 존재하지 않는 Task")
+    void t13() {
+        // Given
+        TaskAlias pendingAlias = taskService.createPendingAlias("연결 테스트");
+        Long nonExistentTaskId = 99999L;
+
+        // When & Then
+        assertThatThrownBy(() -> taskService.linkPendingAlias(pendingAlias.getId(), nonExistentTaskId))
+                .isInstanceOf(ServiceException.class)
+                .hasMessage("404 : 해당 Task가 존재하지 않습니다.");
+    }
+
+    @Test
+    @DisplayName("Pending Alias를 기존 Task와 연결 실패 - 이미 연결된 Alias")
+    void t14() {
+        // Given
+        Task existingTask = taskService.create("기존 task");
+        TaskAlias pendingAlias = taskService.createPendingAlias("연결 테스트");
+        taskService.linkPendingAlias(pendingAlias.getId(), existingTask.getId()); // 먼저 연결
+
+        Task anotherTask = taskService.create("다른 task");
+
+        // When & Then
+        assertThatThrownBy(() -> taskService.linkPendingAlias(pendingAlias.getId(), anotherTask.getId()))
+                .isInstanceOf(ServiceException.class)
+                .hasMessage("400 : 이미 연결된 별칭입니다.");
+    }
+
+    @Test
+    @DisplayName("Pending Alias를 새로운 Task로 생성 - 성공")
+    void t15() {
+        // Given
+        TaskAlias pendingAlias = taskService.createPendingAlias("new task");
+
+        // When
+        Task createdTask = taskService.createTaskFromPending(pendingAlias.getId());
+
+        // Then
+        assertThat(createdTask).isNotNull();
+        assertThat(createdTask.getId()).isNotNull();
+        assertThat(createdTask.getName()).isEqualTo("new task");
+    }
+
+    @Test
+    @DisplayName("Pending Alias를 새로운 Task로 생성 실패 - 존재하지 않는 Alias")
+    void t16() {
+        // Given
+        Long nonExistentAliasId = 99999L;
+
+        // When & Then
+        assertThatThrownBy(() -> taskService.createTaskFromPending(nonExistentAliasId))
+                .isInstanceOf(ServiceException.class)
+                .hasMessage("404 : 해당 별칭이 존재하지 않습니다.");
+    }
+
+    @Test
+    @DisplayName("Pending Alias를 새로운 Task로 생성 실패 - 이미 연결된 Alias")
+    void t17() {
+        // Given
+        Task existingTask = taskService.create("기존 task");
+        TaskAlias pendingAlias = taskService.createPendingAlias("연결 테스트");
+        taskService.linkPendingAlias(pendingAlias.getId(), existingTask.getId()); // 먼저 연결
+
+        // When & Then
+        assertThatThrownBy(() -> taskService.createTaskFromPending(pendingAlias.getId()))
+                .isInstanceOf(ServiceException.class)
+                .hasMessage("400 : 이미 연결된 별칭입니다.");
+    }
+
+    @Test
+    @DisplayName("Pending Alias를 새로운 Task로 생성 실패 - 동일한 이름의 Task 이미 존재")
+    void t18() {
+        // Given
+        TaskAlias pendingAlias = taskService.createPendingAlias("중복 task"); // 먼저 pending alias 생성
+        taskService.create("중복 task"); // 그 다음에 동일한 이름의 Task 생성
+
+
+        // When & Then
+        assertThatThrownBy(() -> taskService.createTaskFromPending(pendingAlias.getId()))
+                .isInstanceOf(ServiceException.class)
+                .hasMessage("400 : 이미 존재하는 Task 이름입니다.");
+    }
+
+    @Test
+    @DisplayName("Pending Alias 삭제 - 성공")
+    void t19() {
+        // Given
+        TaskAlias pendingAlias = taskService.createPendingAlias("삭제 테스트");
+
+        // When & Then
+        assertThatCode(() -> taskService.deletePendingAlias(pendingAlias.getId()))
+                .doesNotThrowAnyException();
+    }
+
+    @Test
+    @DisplayName("Pending Alias 삭제 실패 - 존재하지 않는 Alias")
+    void t20() {
+        // Given
+        Long nonExistentAliasId = 99999L;
+
+        // When & Then
+        assertThatThrownBy(() -> taskService.deletePendingAlias(nonExistentAliasId))
+                .isInstanceOf(ServiceException.class)
+                .hasMessage("404 : 해당 별칭이 존재하지 않습니다.");
+    }
+
+    @Test
+    @DisplayName("Pending Alias 삭제 실패 - 연결된 Alias는 삭제 불가")
+    void t21() {
+        // Given
+        Task existingTask = taskService.create("기존 task");
+        TaskAlias pendingAlias = taskService.createPendingAlias("연결 테스트");
+        taskService.linkPendingAlias(pendingAlias.getId(), existingTask.getId()); // 연결
+
+        // When & Then
+        assertThatThrownBy(() -> taskService.deletePendingAlias(pendingAlias.getId()))
+                .isInstanceOf(ServiceException.class)
+                .hasMessage("400 : 연결된 별칭은 삭제할 수 없습니다.");
+    }
+
+    @Test
+    @DisplayName("Task 개수 조회")
+    void t22() {
+        // Given
+        long initialCount = taskService.count();
+        taskService.create("count test1");
+        taskService.create("count test2");
+
+        // When
+        long currentCount = taskService.count();
+
+        // Then
+        assertThat(currentCount).isEqualTo(initialCount + 2);
+    }
+
+    @Test
+    @DisplayName("키워드 검색 - 대소문자 무시")
+    void t23() {
+        // Given
+        String keyword = "JAVA"; // 대문자로 검색
+
+        // When
+        List<Task> results = taskService.searchByKeyword(keyword);
+
+        // Then
+        assertThat(results).isNotEmpty();
+        assertThat(results).anyMatch(task ->
+                task.getName().toLowerCase().contains(keyword.toLowerCase()));
+    }
+
+    @Test
+    @DisplayName("키워드 검색 - 부분 문자열 매칭")
+    void t24() {
+        // Given
+        String keyword = "Sp"; // "Spring"의 일부
+
+        // When
+        List<Task> results = taskService.searchByKeyword(keyword);
+
+        // Then
+        assertThat(results).isNotEmpty();
+        assertThat(results.getFirst().getName()).isEqualTo("Spring Boot");
+
+    }
+}
\ No newline at end of file
diff --git a/back/src/test/java/com/back/fixture/MemberFixture.java b/back/src/test/java/com/back/fixture/MemberFixture.java
new file mode 100644
index 00000000..8d3bd3c7
--- /dev/null
+++ b/back/src/test/java/com/back/fixture/MemberFixture.java
@@ -0,0 +1,75 @@
+package com.back.fixture;
+
+import com.back.domain.member.member.entity.Member;
+
+public class MemberFixture {
+    private String email = "test@example.com";
+    private String password = "password123";
+    private String name = "Test User";
+    private String nickname = "Test Nickname";
+    private Member.Role role = Member.Role.MENTEE;
+    private Long id = null;
+
+    private static MemberFixture builder() {
+        return new MemberFixture();
+    }
+
+    public static Member createDefault() {
+        return builder().build();
+    }
+
+    public static Member create(Long id, String email, String name, String password, Member.Role role) {
+        return builder()
+            .withId(id)
+            .withEmail(email)
+            .withName(name)
+            .withPassword(password)
+            .withRole(role)
+            .build();
+    }
+
+    public static Member create(String email, String name, String password) {
+        return builder()
+            .withEmail(email)
+            .withName(name)
+            .withPassword(password)
+            .build();
+    }
+
+    public MemberFixture withEmail(String email) {
+        this.email = email;
+        return this;
+    }
+
+    public MemberFixture withPassword(String password) {
+        this.password = password;
+        return this;
+    }
+
+    public MemberFixture withName(String name) {
+        this.name = name;
+        return this;
+    }
+
+    public MemberFixture withRole(Member.Role role) {
+        this.role = role;
+        return this;
+    }
+
+    public MemberFixture withId(Long id) {
+        this.id = id;
+        return this;
+    }
+
+    public MemberFixture withNickname(String nickname) {
+        this.nickname = nickname;
+        return this;
+    }
+
+    public Member build() {
+        if (id != null) {
+            return new Member(id, email, name, nickname, role);
+        }
+        return new Member(email, password, name, nickname, role);
+    }
+}
\ No newline at end of file
diff --git a/back/src/test/java/com/back/fixture/MemberTestFixture.java b/back/src/test/java/com/back/fixture/MemberTestFixture.java
new file mode 100644
index 00000000..fadbee19
--- /dev/null
+++ b/back/src/test/java/com/back/fixture/MemberTestFixture.java
@@ -0,0 +1,83 @@
+package com.back.fixture;
+
+import com.back.domain.member.member.entity.Member;
+import com.back.domain.member.member.repository.MemberRepository;
+import com.back.domain.member.mentee.entity.Mentee;
+import com.back.domain.member.mentee.repository.MenteeRepository;
+import com.back.domain.member.mentor.entity.Mentor;
+import com.back.domain.member.mentor.repository.MentorRepository;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.security.crypto.password.PasswordEncoder;
+import org.springframework.stereotype.Component;
+
+@Component
+public class MemberTestFixture {
+    @Autowired
+    private MemberRepository memberRepository;
+    @Autowired private MentorRepository mentorRepository;
+    @Autowired private MenteeRepository menteeRepository;
+    @Autowired private PasswordEncoder passwordEncoder;
+
+    private int counter = 0;
+
+    // ===== Member =====
+
+    public Member createMember(String email, String name, String nickName, Member.Role role) {
+        Member member = new Member(
+            email,
+            passwordEncoder.encode("password123"),
+            name,
+            nickName,
+            role
+        );
+        return memberRepository.save(member);
+    }
+
+    public Member createMentorMember(String email, String name, String nickName) {
+        return createMember(email, name, nickName, Member.Role.MENTOR);
+    }
+
+    public Member createMentorMember() {
+        return createMentorMember("mentor" + (++counter) + "@test.com", "멘토" + counter, "멘토 닉네임" + counter);
+    }
+
+    public Member createMenteeMember(String email, String name, String nickName) {
+        return createMember(email, name, nickName, Member.Role.MENTEE);
+    }
+
+    public Member createMenteeMember() {
+        return createMenteeMember("mentee" + (++counter) + "@test.com", "멘티" + counter, "멘티 닉네임" + counter);
+    }
+
+
+    // ===== Mentor =====
+
+    public Mentor createMentor(Member member, Long jobId, Double rate, Integer careerYears) {
+        Mentor mentor = Mentor.builder()
+            .member(member)
+            .jobId(jobId)
+            .rate(rate)
+            .careerYears(careerYears)
+            .build();
+        return mentorRepository.save(mentor);
+    }
+
+    public Mentor createMentor(Member member) {
+        return createMentor(member, 1L, 4.5, 5);
+    }
+
+
+    // ===== Mentee =====
+
+    public Mentee createMentee(Member member, Long jobId) {
+        Mentee mentee = Mentee.builder()
+            .member(member)
+            .jobId(jobId)
+            .build();
+        return menteeRepository.save(mentee);
+    }
+
+    public Mentee createMentee(Member member) {
+        return createMentee(member, 1L);
+    }
+}
\ No newline at end of file
diff --git a/back/src/test/java/com/back/fixture/MentoringFixture.java b/back/src/test/java/com/back/fixture/MentoringFixture.java
new file mode 100644
index 00000000..cf7a4d11
--- /dev/null
+++ b/back/src/test/java/com/back/fixture/MentoringFixture.java
@@ -0,0 +1,111 @@
+package com.back.fixture;
+
+import com.back.domain.member.mentee.entity.Mentee;
+import com.back.domain.member.mentor.entity.Mentor;
+import com.back.domain.mentoring.mentoring.entity.Mentoring;
+import com.back.domain.mentoring.mentoring.repository.MentoringRepository;
+import com.back.domain.mentoring.reservation.entity.Reservation;
+import com.back.domain.mentoring.reservation.repository.ReservationRepository;
+import com.back.domain.mentoring.slot.entity.MentorSlot;
+import com.back.domain.mentoring.slot.repository.MentorSlotRepository;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+import java.time.LocalDateTime;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.IntStream;
+
+@Component
+public class MentoringFixture {
+    @Autowired private MentoringRepository mentoringRepository;
+    @Autowired private MentorSlotRepository mentorSlotRepository;
+    @Autowired private ReservationRepository reservationRepository;
+
+    private int counter = 0;
+
+    // ===== Mentoring =====
+
+    public Mentoring createMentoring(Mentor mentor, String title, String bio, List<String> tags) {
+        Mentoring mentoring = Mentoring.builder()
+            .mentor(mentor)
+            .title(title)
+            .bio(bio)
+            .tags(tags)
+            .build();
+        return mentoringRepository.save(mentoring);
+    }
+
+    public Mentoring createMentoring(Mentor mentor) {
+        return createMentoring(
+            mentor,
+            "테스트 멘토링 " + (++counter),
+            "테스트 설명",
+            List.of("Spring", "Java")
+        );
+    }
+
+    // TODO: saveAll로 변경 필요
+    public List<Mentoring> createMentorings(Mentor mentor, int count) {
+        return IntStream.range(0, count)
+            .mapToObj(i -> createMentoring(mentor))
+            .toList();
+    }
+
+
+    // ===== MentorSlot =====
+
+    public MentorSlot createMentorSlot(Mentor mentor, LocalDateTime startDateTime, LocalDateTime endDateTime) {
+        MentorSlot mentorSlot = MentorSlot.builder()
+            .mentor(mentor)
+            .startDateTime(startDateTime)
+            .endDateTime(endDateTime)
+            .build();
+        return mentorSlotRepository.save(mentorSlot);
+    }
+
+    public MentorSlot createMentorSlot(Mentor mentor) {
+        LocalDateTime baseDateTime = LocalDateTime.of(2025, 9, 30, 10, 0);
+        return createMentorSlot(mentor,baseDateTime, baseDateTime.minusHours(1));
+    }
+
+    public List<MentorSlot> createMentorSlots(Mentor mentor, LocalDateTime baseDateTime, int days, int slots) {
+        List<MentorSlot> mentorSlots = new ArrayList<>();
+
+        // days 반복
+        for(int day = 0; day < days; day++) {
+            LocalDateTime weekStart = baseDateTime.plusDays(day);
+
+            // 30분 단위 슬롯
+            for(int slot = 0; slot < slots; slot++) {
+                LocalDateTime startDateTime = weekStart.plusMinutes(slot * 30L);
+                LocalDateTime endDateTime = startDateTime.plusMinutes(30L);
+
+                MentorSlot mentorSlot = MentorSlot.builder()
+                    .mentor(mentor)
+                    .startDateTime(startDateTime)
+                    .endDateTime(endDateTime)
+                    .build();
+                mentorSlots.add(mentorSlot);
+            }
+        }
+        return mentorSlotRepository.saveAll(mentorSlots);
+    }
+
+
+    // ===== Reservation =====
+
+    public Reservation createReservation(Mentoring mentoring, Mentee mentee, MentorSlot slot, String preQuestion) {
+        Reservation reservation = Reservation.builder()
+            .mentoring(mentoring)
+            .mentee(mentee)
+            .mentorSlot(slot)
+            .preQuestion(preQuestion)
+            .build();
+        return reservationRepository.save(reservation);
+    }
+
+    public Reservation createReservation(Mentoring mentoring, Mentee mentee, MentorSlot slot) {
+        return createReservation(mentoring, mentee, slot, "멘토링 전 질문 사항");
+    }
+}
\ No newline at end of file
diff --git a/back/src/test/java/com/back/fixture/NewsFixture.java b/back/src/test/java/com/back/fixture/NewsFixture.java
new file mode 100644
index 00000000..fa60cfab
--- /dev/null
+++ b/back/src/test/java/com/back/fixture/NewsFixture.java
@@ -0,0 +1,76 @@
+package com.back.fixture;
+
+import com.back.domain.file.entity.Video;
+import com.back.domain.member.member.entity.Member;
+import com.back.domain.news.comment.entity.Comment;
+import com.back.domain.news.news.entity.News;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.springframework.test.util.ReflectionTestUtils;
+
+public class NewsFixture {
+    private Long id;
+    private Member member = MemberFixture.createDefault();
+    private String title = "Sample News Title";
+    private Video video = VideoFixture.createDefault();
+    private String content = "This is a sample news content.";
+    private List<Comment> comments = new ArrayList<>();
+    private Integer likes = 0;
+
+    private static NewsFixture builder() {
+        return new NewsFixture();
+    }
+
+    public static News createDefault() {
+        return builder().build();
+    }
+
+    public static News create(Long id, Member member, String title) {
+        News news = News.create(member, title, VideoFixture.createDefault(), "content");
+        ReflectionTestUtils.setField(news, "id", id);
+        return news;
+    }
+
+    public NewsFixture withId(Long id) {
+        this.id = id;
+        return this;
+    }
+
+    public NewsFixture withMember(Member member) {
+        this.member = member;
+        return this;
+    }
+
+    public NewsFixture withTitle(String title) {
+        this.title = title;
+        return this;
+    }
+
+    public NewsFixture withVideo(Video video) {
+        this.video = video;
+        return this;
+    }
+
+    public NewsFixture withContent(String content) {
+        this.content = content;
+        return this;
+    }
+
+    public NewsFixture withLikes(Integer likes) {
+        this.likes = likes;
+        return this;
+    }
+
+    public NewsFixture withComments(List<Comment> comments) {
+        this.comments = comments;
+        return this;
+    }
+
+    public News build() {
+        News news = News.create(member, title, video, content);
+        news.getComment().addAll(comments);
+        return news;
+    }
+}
diff --git a/back/src/test/java/com/back/fixture/VideoFixture.java b/back/src/test/java/com/back/fixture/VideoFixture.java
new file mode 100644
index 00000000..d2890aa4
--- /dev/null
+++ b/back/src/test/java/com/back/fixture/VideoFixture.java
@@ -0,0 +1,91 @@
+package com.back.fixture;
+
+import com.back.domain.file.entity.Video;
+
+import java.util.UUID;
+
+public class VideoFixture {
+    private String uuid = UUID.randomUUID().toString();
+    private String transcodingResults = """
+                {
+                  "1080p": {
+                    "file_path": "/path/to/1080p/video.mpd",
+                    "status": "COMPLETED",
+                    "size_mb": 150
+                  },
+                  "720p": {
+                    "file_path": "/path/to/720p/video.mpd",
+                    "status": "IN_PROGRESS",
+                    "size_mb": 80
+                  },
+                  "480p": {
+                    "file_path": "/path/to/480p/video.mpd",
+                    "status": "FAILED",
+                    "size_mb": 40
+                  }
+                }
+                """;
+    private String originalPath = "/videos/original.mp4";
+    private String originalFileName = "original.mp4";
+    private Integer duration = 120;
+    private Long fileSize = 1024L * 1024L * 10; // 10MB
+
+    private static VideoFixture builder() {
+        return new VideoFixture();
+    }
+
+    public static Video createDefault() {
+        return builder().build();
+    }
+    public static Video create(String uuid, String transcodingResults, String originalPath, String originalFileName, Integer duration, Long fileSize) {
+        return builder()
+                .withUuid(uuid)
+                .withTranscodingResults(transcodingResults)
+                .withOriginalPath(originalPath)
+                .withOriginalFileName(originalFileName)
+                .withDuration(duration)
+                .withFileSize(fileSize)
+                .build();
+    }
+
+    public VideoFixture withUuid(String uuid) {
+        this.uuid = uuid;
+        return this;
+    }
+
+    public VideoFixture withTranscodingResults(String transcodingResults) {
+        this.transcodingResults = transcodingResults;
+        return this;
+    }
+
+    public VideoFixture withOriginalPath(String originalPath) {
+        this.originalPath = originalPath;
+        return this;
+    }
+
+    public VideoFixture withOriginalFileName(String originalFileName) {
+        this.originalFileName = originalFileName;
+        return this;
+    }
+
+    public VideoFixture withDuration(Integer duration) {
+        this.duration = duration;
+        return this;
+    }
+
+    public VideoFixture withFileSize(Long fileSize) {
+        this.fileSize = fileSize;
+        return this;
+    }
+
+    public Video build() {
+        return Video.create(
+                uuid,
+                transcodingResults,
+                originalPath,
+                originalFileName,
+                duration,
+                fileSize
+        );
+    }
+}
\ No newline at end of file
diff --git a/docker-compose.yml b/docker-compose.yml
new file mode 100644
index 00000000..80a2439a
--- /dev/null
+++ b/docker-compose.yml
@@ -0,0 +1,18 @@
+version: "3.8"
+
+services:
+  minio:
+    image: quay.io/minio/minio:latest
+    container_name: minio
+    ports:
+      - "9000:9000"   # S3 API
+      - "9001:9001"   # Web Console
+    environment:
+      MINIO_ROOT_USER: minioadmin
+      MINIO_ROOT_PASSWORD: minioadmin
+    volumes:
+      - minio-data:/data
+    command: server /data --console-address ":9001"
+
+volumes:
+  minio-data: