diff --git a/build.gradle b/build.gradle
index df7db9334..a2fd964cf 100644
--- a/build.gradle
+++ b/build.gradle
@@ -21,9 +21,25 @@ dependencies {
     implementation 'org.springframework.boot:spring-boot-starter-jdbc'
     implementation 'org.springframework.boot:spring-boot-starter-thymeleaf'
     implementation 'org.springframework.boot:spring-boot-starter-web'
+    implementation 'org.springframework.boot:spring-boot-starter-validation'
+    implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
+    implementation 'io.jsonwebtoken:jjwt-api:0.12.6'
+    implementation 'jakarta.persistence:jakarta.persistence-api:3.1.0'
+    implementation 'org.mindrot:jbcrypt:0.4'
+    implementation 'com.github.ulisesbocchio:jasypt-spring-boot-starter:3.0.5'
+    implementation 'org.springframework.boot:spring-boot-starter-webflux'
+    implementation 'org.springdoc:springdoc-openapi-starter-webmvc-ui:2.3.0'
+    compileOnly 'org.projectlombok:lombok:1.18.34'
+    annotationProcessor 'org.projectlombok:lombok:1.18.34'
+    testCompileOnly 'org.projectlombok:lombok:1.18.34'
+    testAnnotationProcessor 'org.projectlombok:lombok:1.18.34'
+    runtimeOnly 'io.jsonwebtoken:jjwt-impl:0.12.6'
+    runtimeOnly 'io.jsonwebtoken:jjwt-jackson:0.12.6'
     runtimeOnly 'com.h2database:h2'
     testImplementation 'org.springframework.boot:spring-boot-starter-test'
     testRuntimeOnly 'org.junit.platform:junit-platform-launcher'
+    testImplementation 'org.mockito:mockito-core:3.12.4'
+    testImplementation 'org.mockito:mockito-junit-jupiter:3.12.4'
 }
 
 tasks.named('test') {
diff --git a/src/main/java/gift/component/LoginMember.java b/src/main/java/gift/component/LoginMember.java
new file mode 100644
index 000000000..2169ebe25
--- /dev/null
+++ b/src/main/java/gift/component/LoginMember.java
@@ -0,0 +1,9 @@
+package gift.component;
+
+import java.lang.annotation.*;
+
+@Target(ElementType.PARAMETER)
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+public @interface LoginMember {
+}
diff --git a/src/main/java/gift/component/LoginMemberArgumentResolver.java b/src/main/java/gift/component/LoginMemberArgumentResolver.java
new file mode 100644
index 000000000..d7dbc8b5a
--- /dev/null
+++ b/src/main/java/gift/component/LoginMemberArgumentResolver.java
@@ -0,0 +1,52 @@
+package gift.component;
+
+import gift.service.MemberService;
+import io.jsonwebtoken.Claims;
+import io.jsonwebtoken.Jwts;
+import io.jsonwebtoken.security.Keys;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.core.MethodParameter;
+import org.springframework.stereotype.Component;
+import org.springframework.web.bind.support.WebDataBinderFactory;
+import org.springframework.web.context.request.NativeWebRequest;
+import org.springframework.web.method.support.HandlerMethodArgumentResolver;
+import org.springframework.web.method.support.ModelAndViewContainer;
+
+import jakarta.servlet.http.HttpServletRequest;
+
+import java.nio.charset.StandardCharsets;
+
+@Component
+public class LoginMemberArgumentResolver implements HandlerMethodArgumentResolver {
+
+    private final MemberService memberService;
+
+    @Value("${jwt.secret}")
+    private String secretKey;
+
+    public LoginMemberArgumentResolver(MemberService memberService) {
+        this.memberService = memberService;
+    }
+
+    @Override
+    public boolean supportsParameter(MethodParameter parameter) {
+        return parameter.getParameterAnnotation(LoginMember.class) != null;
+    }
+
+    @Override
+    public Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer, NativeWebRequest webRequest, WebDataBinderFactory binderFactory) {
+        HttpServletRequest request = (HttpServletRequest) webRequest.getNativeRequest();
+        String authorizationHeader = request.getHeader("Authorization");
+        if (authorizationHeader != null && authorizationHeader.startsWith("Bearer ")) {
+            String token = authorizationHeader.substring(7);
+            Claims claims = Jwts.parser()
+                .verifyWith(Keys.hmacShaKeyFor(secretKey.getBytes(StandardCharsets.UTF_8)))
+                .build()
+                .parseSignedClaims(token)
+                .getPayload();
+            Long memberId = Long.parseLong(claims.getSubject());
+            return memberService.findById(memberId).orElseThrow(() -> new RuntimeException("Member not found"));
+        }
+        throw new RuntimeException("Invalid token");
+    }
+}
diff --git a/src/main/java/gift/config/JasyptConfig.java b/src/main/java/gift/config/JasyptConfig.java
new file mode 100644
index 000000000..0c6587414
--- /dev/null
+++ b/src/main/java/gift/config/JasyptConfig.java
@@ -0,0 +1,22 @@
+package gift.config;
+
+import org.jasypt.encryption.StringEncryptor;
+import org.jasypt.encryption.pbe.StandardPBEStringEncryptor;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.beans.factory.annotation.Value;
+
+@Configuration
+public class JasyptConfig {
+
+    @Value("${jasypt.encryptor.password}")
+    private String encryptorPassword;
+
+    @Bean("jasyptStringEncryptor")
+    public StringEncryptor stringEncryptor() {
+        StandardPBEStringEncryptor encryptor = new StandardPBEStringEncryptor();
+        encryptor.setPassword(encryptorPassword);
+        encryptor.setAlgorithm("PBEWithMD5AndDES");
+        return encryptor;
+    }
+}
diff --git a/src/main/java/gift/config/OpenApiConfig.java b/src/main/java/gift/config/OpenApiConfig.java
new file mode 100644
index 000000000..0bd43c19c
--- /dev/null
+++ b/src/main/java/gift/config/OpenApiConfig.java
@@ -0,0 +1,18 @@
+package gift.config;
+
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springdoc.core.models.GroupedOpenApi;
+import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
+
+@Configuration
+public class OpenApiConfig implements WebMvcConfigurer {
+
+    @Bean
+    public GroupedOpenApi publicApi() {
+        return GroupedOpenApi.builder()
+            .group("public")
+            .pathsToMatch("/api/**")
+            .build();
+    }
+}
diff --git a/src/main/java/gift/config/WebConfig.java b/src/main/java/gift/config/WebConfig.java
new file mode 100644
index 000000000..34e9d21ff
--- /dev/null
+++ b/src/main/java/gift/config/WebConfig.java
@@ -0,0 +1,36 @@
+package gift.config;
+
+import gift.component.LoginMemberArgumentResolver;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.web.method.support.HandlerMethodArgumentResolver;
+import org.springframework.web.servlet.config.annotation.CorsRegistry;
+import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
+
+import java.util.List;
+
+@Configuration
+public class WebConfig implements WebMvcConfigurer {
+
+    private final LoginMemberArgumentResolver loginMemberArgumentResolver;
+
+    public WebConfig(LoginMemberArgumentResolver loginMemberArgumentResolver) {
+        this.loginMemberArgumentResolver = loginMemberArgumentResolver;
+    }
+
+    @Override
+    public void addArgumentResolvers(List<HandlerMethodArgumentResolver> resolvers) {
+        resolvers.add(loginMemberArgumentResolver);
+    }
+
+    @Override
+    public void addCorsMappings(CorsRegistry registry) {
+        registry.addMapping("/**")
+            .allowedOrigins(
+                "http://localhost:8080",
+                "http://3.39.251.25"
+            )
+            .allowedMethods("*")
+            .allowedHeaders("*")
+            .allowCredentials(true);
+    }
+}
diff --git a/src/main/java/gift/controller/AdminController.java b/src/main/java/gift/controller/AdminController.java
new file mode 100644
index 000000000..50bb4872b
--- /dev/null
+++ b/src/main/java/gift/controller/AdminController.java
@@ -0,0 +1,37 @@
+package gift.controller;
+
+import gift.model.Product;
+import gift.service.ProductService;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.data.domain.Pageable;
+import org.springframework.stereotype.Controller;
+import org.springframework.ui.Model;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+
+@Controller
+@RequestMapping("/admin/products")
+public class AdminController {
+
+    private final ProductService productService;
+
+    public AdminController(ProductService productService) {
+        this.productService = productService;
+    }
+
+    @GetMapping("")
+    public String showProducts(Model model,
+                               @RequestParam(defaultValue = "0") int page,
+                               @RequestParam(defaultValue = "10") int size) {
+        Pageable pageable = PageRequest.of(page, size);
+        Page<Product> productPage = productService.getProducts(pageable, null);
+
+        model.addAttribute("products", productPage.getContent());
+        model.addAttribute("currentPage", page);
+        model.addAttribute("pageSize", size);
+        model.addAttribute("totalPages", productPage.getTotalPages());
+        return "products_admin";
+    }
+}
diff --git a/src/main/java/gift/controller/CategoryController.java b/src/main/java/gift/controller/CategoryController.java
new file mode 100644
index 000000000..ebb839fb4
--- /dev/null
+++ b/src/main/java/gift/controller/CategoryController.java
@@ -0,0 +1,61 @@
+package gift.controller;
+
+import gift.dto.ApiResponse;
+import gift.model.Category;
+import gift.service.CategoryService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+
+@RestController
+@RequestMapping("/api/categories")
+public class CategoryController {
+
+    private final CategoryService categoryService;
+
+    @Autowired
+    public CategoryController(CategoryService categoryService) {
+        this.categoryService = categoryService;
+    }
+
+    @GetMapping
+    public ResponseEntity<ApiResponse<List<Category>>> getAllCategories() {
+        List<Category> categories = categoryService.getAllCategories();
+        ApiResponse<List<Category>> response = new ApiResponse<>(true, "Categories retrieved successfully", categories, null);
+        return new ResponseEntity<>(response, HttpStatus.OK);
+    }
+
+    @PostMapping
+    public ResponseEntity<ApiResponse<Category>> createCategory(@RequestBody Category category) {
+        Category createdCategory = categoryService.createCategory(category);
+        ApiResponse<Category> response = new ApiResponse<>(true, "Category created successfully", createdCategory, null);
+        return new ResponseEntity<>(response, HttpStatus.CREATED);
+    }
+
+    @PutMapping("/{id}")
+    public ResponseEntity<ApiResponse<Category>> updateCategory(@PathVariable Long id, @RequestBody Category updatedCategory) {
+        try {
+            Category category = categoryService.updateCategory(id, updatedCategory);
+            ApiResponse<Category> response = new ApiResponse<>(true, "Category updated successfully", category, null);
+            return new ResponseEntity<>(response, HttpStatus.OK);
+        } catch (RuntimeException e) {
+            ApiResponse<Category> response = new ApiResponse<>(false, "Category not found", null, "404");
+            return new ResponseEntity<>(response, HttpStatus.NOT_FOUND);
+        }
+    }
+
+    @DeleteMapping("/{id}")
+    public ResponseEntity<ApiResponse<Void>> deleteCategory(@PathVariable Long id) {
+        try {
+            categoryService.deleteCategory(id);
+            ApiResponse<Void> response = new ApiResponse<>(true, "Category deleted successfully", null, null);
+            return new ResponseEntity<>(response, HttpStatus.NO_CONTENT);
+        } catch (RuntimeException e) {
+            ApiResponse<Void> response = new ApiResponse<>(false, "Category not found", null, "404");
+            return new ResponseEntity<>(response, HttpStatus.NOT_FOUND);
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/gift/controller/KakaoAuthController.java b/src/main/java/gift/controller/KakaoAuthController.java
new file mode 100644
index 000000000..2295e51d8
--- /dev/null
+++ b/src/main/java/gift/controller/KakaoAuthController.java
@@ -0,0 +1,41 @@
+package gift.controller;
+
+import gift.dto.ApiResponse;
+import gift.dto.UserInfo;
+import gift.service.KakaoAuthService;
+import gift.service.UserService;
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpSession;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RestController;
+
+@RestController
+public class KakaoAuthController {
+
+    private final KakaoAuthService kakaoAuthService;
+    private final UserService userService;
+
+    public KakaoAuthController(KakaoAuthService kakaoAuthService, UserService userService) {
+        this.kakaoAuthService = kakaoAuthService;
+        this.userService = userService;
+    }
+
+    @GetMapping("/oauth/kakao")
+    public ApiResponse<String> kakaoLogin(@RequestParam("code") String authorizationCode, HttpServletRequest request) {
+        try {
+            String accessToken = kakaoAuthService.getAccessToken(authorizationCode);
+            UserInfo userInfo = kakaoAuthService.getUserInfo(accessToken);
+
+            HttpSession session = request.getSession();
+            session.setAttribute("accessToken", accessToken);
+            session.setAttribute("userInfo", userInfo);
+
+            userService.saveUser(accessToken, userInfo);
+
+            return new ApiResponse<>(true, "Access token retrieved successfully", accessToken, null);
+        } catch (Exception e) {
+            return new ApiResponse<>(true, "Access token retrieved successfully", null, null);
+        }
+    }
+}
diff --git a/src/main/java/gift/controller/LoginController.java b/src/main/java/gift/controller/LoginController.java
new file mode 100644
index 000000000..83ddef17a
--- /dev/null
+++ b/src/main/java/gift/controller/LoginController.java
@@ -0,0 +1,18 @@
+package gift.controller;
+
+import org.springframework.stereotype.Controller;
+import org.springframework.web.bind.annotation.GetMapping;
+
+@Controller
+public class LoginController {
+
+    @GetMapping("/login")
+    public String login() {
+        return "login";
+    }
+
+    @GetMapping("/order")
+    public String order() {
+        return "order";
+    }
+}
diff --git a/src/main/java/gift/controller/MemberController.java b/src/main/java/gift/controller/MemberController.java
new file mode 100644
index 000000000..82e829974
--- /dev/null
+++ b/src/main/java/gift/controller/MemberController.java
@@ -0,0 +1,45 @@
+package gift.controller;
+
+import gift.dto.ApiResponse;
+import gift.model.Member;
+import gift.service.MemberService;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+@RestController
+@RequestMapping("api/members")
+public class MemberController {
+
+    private final MemberService memberService;
+
+    public MemberController(MemberService memberService) {
+        this.memberService = memberService;
+    }
+
+    @PostMapping("/register")
+    public ResponseEntity<ApiResponse<String>> register(@RequestBody Member member) {
+        return memberService.registerMember(member)
+            .map(token -> {
+                ApiResponse<String> response = new ApiResponse<>(true, "Member registered successfully", token, null);
+                return new ResponseEntity<>(response, HttpStatus.OK);
+            })
+            .orElseGet(() -> {
+                ApiResponse<String> response = new ApiResponse<>(false, "Registration failed", null, "500");
+                return new ResponseEntity<>(response, HttpStatus.INTERNAL_SERVER_ERROR);
+            });
+    }
+
+    @PostMapping("/login")
+    public ResponseEntity<ApiResponse<String>> login(@RequestBody Member member) {
+        return memberService.login(member.getEmail(), member.getPassword())
+            .map(token -> {
+                ApiResponse<String> response = new ApiResponse<>(true, "Login successful", token, null);
+                return new ResponseEntity<>(response, HttpStatus.OK);
+            })
+            .orElseGet(() -> {
+                ApiResponse<String> response = new ApiResponse<>(false, "Invalid email or password", null, "403");
+                return new ResponseEntity<>(response, HttpStatus.FORBIDDEN);
+            });
+    }
+}
diff --git a/src/main/java/gift/controller/OptionController.java b/src/main/java/gift/controller/OptionController.java
new file mode 100644
index 000000000..3e0b6be66
--- /dev/null
+++ b/src/main/java/gift/controller/OptionController.java
@@ -0,0 +1,87 @@
+package gift.controller;
+
+import gift.dto.ApiResponse;
+import gift.model.Option;
+import gift.service.OptionService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+import java.util.NoSuchElementException;
+
+@RestController
+@RequestMapping("/api/products")
+public class OptionController {
+
+    private final OptionService optionService;
+
+    @Autowired
+    public OptionController(OptionService optionService) {
+        this.optionService = optionService;
+    }
+
+    @PostMapping("/{productId}/options")
+    public ResponseEntity<ApiResponse<Option>> addOptionToProduct(@PathVariable Long productId, @RequestBody Option option) {
+        try {
+            Option createdOption = optionService.addOptionToProduct(productId, option);
+            ApiResponse<Option> response = new ApiResponse<>(true, "Option added successfully", createdOption, null);
+            return new ResponseEntity<>(response, HttpStatus.CREATED);
+        } catch (IllegalArgumentException e) {
+            ApiResponse<Option> response = new ApiResponse<>(false, e.getMessage(), null, "400");
+            return new ResponseEntity<>(response, HttpStatus.BAD_REQUEST);
+        } catch (NoSuchElementException e) {
+            ApiResponse<Option> response = new ApiResponse<>(false, e.getMessage(), null, "404");
+            return new ResponseEntity<>(response, HttpStatus.NOT_FOUND);
+        } catch (Exception ex) {
+            ApiResponse<Option> response = new ApiResponse<>(false, "Failed to add option: " + ex.getMessage(), null, "500");
+            return new ResponseEntity<>(response, HttpStatus.INTERNAL_SERVER_ERROR);
+        }
+    }
+
+    @GetMapping("/{productId}/options")
+    public ResponseEntity<ApiResponse<List<Option>>> getOptionsByProduct(@PathVariable Long productId) {
+        try {
+            List<Option> options = optionService.getOptionsByProduct(productId);
+            ApiResponse<List<Option>> response = new ApiResponse<>(true, "Options retrieved successfully", options, null);
+            return new ResponseEntity<>(response, HttpStatus.OK);
+        } catch (NoSuchElementException e) {
+            ApiResponse<List<Option>> response = new ApiResponse<>(false, e.getMessage(), null, "404");
+            return new ResponseEntity<>(response, HttpStatus.NOT_FOUND);
+        }
+    }
+
+    @PutMapping("/{productId}/options/{optionId}")
+    public ResponseEntity<ApiResponse<Option>> updateOption(@PathVariable Long productId, @PathVariable Long optionId, @RequestBody Option option) {
+        try {
+            Option updatedOption = optionService.updateOption(productId, optionId, option);
+            ApiResponse<Option> response = new ApiResponse<>(true, "Option updated successfully", updatedOption, null);
+            return new ResponseEntity<>(response, HttpStatus.OK);
+        } catch (IllegalArgumentException e) {
+            ApiResponse<Option> response = new ApiResponse<>(false, e.getMessage(), null, "400");
+            return new ResponseEntity<>(response, HttpStatus.BAD_REQUEST);
+        } catch (NoSuchElementException e) {
+            ApiResponse<Option> response = new ApiResponse<>(false, e.getMessage(), null, "404");
+            return new ResponseEntity<>(response, HttpStatus.NOT_FOUND);
+        } catch (Exception ex) {
+            ApiResponse<Option> response = new ApiResponse<>(false, "Failed to update option: " + ex.getMessage(), null, "500");
+            return new ResponseEntity<>(response, HttpStatus.INTERNAL_SERVER_ERROR);
+        }
+    }
+
+    @DeleteMapping("/{productId}/options/{optionId}")
+    public ResponseEntity<ApiResponse<Void>> deleteOption(@PathVariable Long productId, @PathVariable Long optionId) {
+        try {
+            optionService.deleteOption(productId, optionId);
+            ApiResponse<Void> response = new ApiResponse<>(true, "Option deleted successfully", null, null);
+            return new ResponseEntity<>(response, HttpStatus.NO_CONTENT);
+        } catch (NoSuchElementException e) {
+            ApiResponse<Void> response = new ApiResponse<>(false, e.getMessage(), null, "404");
+            return new ResponseEntity<>(response, HttpStatus.NOT_FOUND);
+        } catch (Exception ex) {
+            ApiResponse<Void> response = new ApiResponse<>(false, "Failed to delete option: " + ex.getMessage(), null, "500");
+            return new ResponseEntity<>(response, HttpStatus.INTERNAL_SERVER_ERROR);
+        }
+    }
+}
diff --git a/src/main/java/gift/controller/OrderController.java b/src/main/java/gift/controller/OrderController.java
new file mode 100644
index 000000000..dcb3794f9
--- /dev/null
+++ b/src/main/java/gift/controller/OrderController.java
@@ -0,0 +1,104 @@
+package gift.controller;
+
+import gift.dto.ApiResponse;
+import gift.model.Order;
+import gift.model.Option;
+import gift.model.Member;
+import gift.repository.OptionRepository;
+import gift.repository.WishRepository;
+import gift.repository.MemberRepository;
+import gift.service.OrderService;
+import gift.service.KakaoMessageService;
+import gift.service.KakaoAuthService;
+import gift.service.impl.KakaoMessageServiceImpl;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.Parameter;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import org.springframework.beans.factory.annotation.Autowired;
+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.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+import reactor.core.publisher.Mono;
+
+import java.util.Map;
+
+@Tag(name = "Order API", description = "주문 관련 API")
+@RestController
+@RequestMapping("/api/orders")
+public class OrderController {
+
+    private final OrderService orderService;
+    private final OptionRepository optionRepository;
+    private final WishRepository wishRepository;
+    private final MemberRepository memberRepository;
+    private final KakaoMessageService kakaoMessageService;
+    private final KakaoAuthService kakaoAuthService;
+
+    @Autowired
+    public OrderController(OrderService orderService, OptionRepository optionRepository, WishRepository wishRepository, MemberRepository memberRepository, KakaoAuthService kakaoAuthService) {
+        this.orderService = orderService;
+        this.optionRepository = optionRepository;
+        this.wishRepository = wishRepository;
+        this.memberRepository = memberRepository;
+        this.kakaoMessageService = new KakaoMessageServiceImpl();
+        this.kakaoAuthService = kakaoAuthService;
+    }
+
+    @Operation(summary = "주문 생성", description = "주문을 생성하고 결과를 반환합니다.")
+    @PostMapping
+    public ResponseEntity<ApiResponse<Order>> createOrder(
+        @Parameter(description = "카카오 인증 토큰", required = true) @RequestHeader("Authorization") String kakaoToken,
+        @Parameter(description = "주문 정보", required = true) @RequestBody Order order) {
+        try {
+            String accessToken = kakaoToken.replace("Bearer ", "");
+            Option option = optionRepository.findById(order.getOptionId())
+                .orElseThrow(() -> new IllegalArgumentException("Invalid option ID"));
+            order.setOption(option);
+
+            String email = kakaoAuthService.getUserInfo(accessToken).getEmail();
+            Member member = memberRepository.findByEmail(email)
+                .orElseThrow(() -> new IllegalArgumentException("Invalid member email"));
+
+            Order createdOrder = orderService.createOrder(order, member);
+            option.subtractQuantity(order.getQuantity());
+            optionRepository.save(option);
+
+            wishRepository.deleteByMemberAndProduct(member, option.getProduct());
+
+            kakaoMessageService.sendMessage(kakaoToken, "주문 내역: " + createdOrder.toString());
+
+            return ResponseEntity.status(201).body(new ApiResponse<>(true, "Order created successfully", createdOrder, null));
+        } catch (IllegalArgumentException e) {
+            return ResponseEntity.status(400).body(new ApiResponse<>(false, e.getMessage(), null, "400"));
+        } catch (Exception e) {
+            e.printStackTrace();
+            return ResponseEntity.status(500).body(new ApiResponse<>(false, "Failed to create order", null, e.getMessage()));
+        }
+    }
+
+    @Operation(summary = "주문 목록 조회", description = "주문 목록을 페이지 단위로 조회합니다.")
+    @GetMapping
+    public ResponseEntity<ApiResponse<Page<Order>>> getOrders(
+        @PageableDefault(size = 10, sort = "orderDateTime", direction = Sort.Direction.DESC) Pageable pageable) {
+        try {
+            Page<Order> orders = orderService.getOrders(pageable);
+            ApiResponse<Page<Order>> response = new ApiResponse<>(true, "Orders retrieved successfully", orders, null);
+            return ResponseEntity.ok(response);
+        } catch (Exception e) {
+            e.printStackTrace();
+            return ResponseEntity.status(500).body(new ApiResponse<>(false, "Failed to retrieve orders", null, e.getMessage()));
+        }
+    }
+
+    @Operation(summary = "카카오 메시지 전송", description = "카카오 메시지를 발송합니다.")
+    @PostMapping("/sendMessage")
+    public Mono<ResponseEntity<String>> sendMessage(
+        @Parameter(description = "카카오 인증 토큰", required = true) @RequestHeader("Authorization") String kakaoToken,
+        @Parameter(description = "메시지 내용", required = true) @RequestBody Map<String, String> requestBody) {
+        String message = requestBody.get("message");
+        return kakaoMessageService.sendMessage(kakaoToken, message);
+    }
+}
diff --git a/src/main/java/gift/controller/ProductController.java b/src/main/java/gift/controller/ProductController.java
new file mode 100644
index 000000000..f9319e851
--- /dev/null
+++ b/src/main/java/gift/controller/ProductController.java
@@ -0,0 +1,141 @@
+package gift.controller;
+
+import gift.dto.ApiResponse;
+import gift.exception.ForbiddenWordException;
+import gift.exception.ProductNotFoundException;
+import gift.model.Product;
+import gift.service.ProductService;
+import jakarta.validation.Valid;
+import org.springframework.beans.factory.annotation.Autowired;
+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.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+import java.util.Map;
+
+@RestController
+@RequestMapping("/api/products")
+public class ProductController {
+
+    private final ProductService productService;
+
+    @Autowired
+    public ProductController(ProductService productService) {
+        this.productService = productService;
+    }
+
+    @GetMapping
+    public ResponseEntity<ApiResponse<Page<Product>>> getAllProducts(
+        @PageableDefault(size = 10, sort = "name", direction = Sort.Direction.ASC) Pageable pageable,
+        @RequestParam(required = false) Long categoryId) {
+        Page<Product> products = productService.getProducts(pageable, categoryId);
+        ApiResponse<Page<Product>> response = new ApiResponse<>(true, "All products retrieved successfully.", products, null);
+        return ResponseEntity.ok(response);
+    }
+
+    @GetMapping("/{id}")
+    public ResponseEntity<ApiResponse<Product>> getProductById(@PathVariable Long id) {
+        try {
+            Product product = productService.getProductById(id);
+            ApiResponse<Product> response = new ApiResponse<>(true, "Product retrieved successfully.", product, null);
+            return ResponseEntity.ok(response);
+        } catch (ProductNotFoundException ex) {
+            ApiResponse<Product> response = new ApiResponse<>(false, ex.getMessage(), null, "404");
+            return ResponseEntity.status(HttpStatus.NOT_FOUND).body(response);
+        }
+    }
+
+    @PostMapping
+    public ResponseEntity<ApiResponse<Product>> createProduct(@Valid @RequestBody Product product) {
+        try {
+            productService.createProduct(product);
+            ApiResponse<Product> response = new ApiResponse<>(true, "Product created successfully.", product, null);
+            return ResponseEntity.status(HttpStatus.CREATED).body(response);
+        } catch (ForbiddenWordException ex) {
+            ApiResponse<Product> response = new ApiResponse<>(false, ex.getMessage(), null, "400");
+            return ResponseEntity.status(HttpStatus.BAD_REQUEST).body(response);
+        } catch (Exception ex) {
+            ApiResponse<Product> response = new ApiResponse<>(false, "Failed to create product.", null, "500");
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(response);
+        }
+    }
+
+    @PutMapping("/{id}")
+    public ResponseEntity<ApiResponse<Product>> updateProduct(@PathVariable Long id, @Valid @RequestBody Product product) {
+        try {
+            productService.updateProduct(id, product);
+            Product updatedProduct = productService.getProductById(id);
+            ApiResponse<Product> response = new ApiResponse<>(true, "Product updated successfully.", updatedProduct, null);
+            return ResponseEntity.ok(response);
+        } catch (ProductNotFoundException ex) {
+            ApiResponse<Product> response = new ApiResponse<>(false, ex.getMessage(), null, "404");
+            return ResponseEntity.status(HttpStatus.NOT_FOUND).body(response);
+        } catch (ForbiddenWordException ex) {
+            ApiResponse<Product> response = new ApiResponse<>(false, ex.getMessage(), null, "400");
+            return ResponseEntity.status(HttpStatus.BAD_REQUEST).body(response);
+        } catch (Exception ex) {
+            ApiResponse<Product> response = new ApiResponse<>(false, "Failed to update product.", null, "500");
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(response);
+        }
+    }
+
+    @DeleteMapping("/{id}")
+    public ResponseEntity<ApiResponse<Void>> deleteProduct(@PathVariable Long id) {
+        try {
+            productService.deleteProduct(id);
+            ApiResponse<Void> response = new ApiResponse<>(true, "Product deleted successfully.", null, null);
+            return ResponseEntity.noContent().build();
+        } catch (ProductNotFoundException ex) {
+            ApiResponse<Void> response = new ApiResponse<>(false, ex.getMessage(), null, "404");
+            return ResponseEntity.status(HttpStatus.NOT_FOUND).body(response);
+        } catch (Exception ex) {
+            ApiResponse<Void> response = new ApiResponse<>(false, "Failed to delete product.", null, "500");
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(response);
+        }
+    }
+
+    @PatchMapping("/{id}")
+    public ResponseEntity<ApiResponse<Product>> patchProduct(@PathVariable Long id, @RequestBody Map<String, Object> updates) {
+        try {
+            productService.patchProduct(id, updates);
+            Product updatedProduct = productService.getProductById(id);
+            ApiResponse<Product> response = new ApiResponse<>(true, "Product patched successfully.", updatedProduct, null);
+            return ResponseEntity.ok(response);
+        } catch (ProductNotFoundException ex) {
+            ApiResponse<Product> response = new ApiResponse<>(false, ex.getMessage(), null, "404");
+            return ResponseEntity.status(HttpStatus.NOT_FOUND).body(response);
+        } catch (ForbiddenWordException ex) {
+            ApiResponse<Product> response = new ApiResponse<>(false, ex.getMessage(), null, "400");
+            return ResponseEntity.status(HttpStatus.BAD_REQUEST).body(response);
+        } catch (Exception ex) {
+            ApiResponse<Product> response = new ApiResponse<>(false, "Failed to patch product.", null, "500");
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(response);
+        }
+    }
+
+    @PatchMapping
+    public ResponseEntity<ApiResponse<List<Product>>> patchProducts(@RequestBody List<Map<String, Object>> updatesList) {
+        List<Product> updatedProducts = productService.patchProducts(updatesList);
+        int originalCount = updatesList.size();
+        int updateCount = updatedProducts.size();
+        ApiResponse<List<Product>> response;
+
+        if (updateCount == originalCount) {
+            response = new ApiResponse<>(true, "All products patched successfully.", updatedProducts, null);
+            return ResponseEntity.ok(response);
+        }
+
+        if (updateCount > 0) {
+            response = new ApiResponse<>(true, "Some products patched successfully.", updatedProducts, null);
+            return ResponseEntity.status(HttpStatus.PARTIAL_CONTENT).body(response);
+        }
+
+        response = new ApiResponse<>(false, "No products patched.", null, "500");
+        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(response);
+    }
+}
diff --git a/src/main/java/gift/controller/WishController.java b/src/main/java/gift/controller/WishController.java
new file mode 100644
index 000000000..a200b9168
--- /dev/null
+++ b/src/main/java/gift/controller/WishController.java
@@ -0,0 +1,78 @@
+package gift.controller;
+
+import gift.component.LoginMember;
+import gift.dto.ApiResponse;
+import gift.dto.WishDTO;
+import gift.model.Member;
+import gift.model.Product;
+import gift.model.Wish;
+import gift.service.ProductService;
+import gift.service.WishService;
+import org.springframework.beans.factory.annotation.Autowired;
+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.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.Map;
+
+@RestController
+@RequestMapping("/api/wishes")
+public class WishController {
+
+    private final WishService wishService;
+    private final ProductService productService;
+
+    @Autowired
+    public WishController(WishService wishService, ProductService productService) {
+        this.wishService = wishService;
+        this.productService = productService;
+    }
+
+    @GetMapping
+    public ResponseEntity<ApiResponse<Page<WishDTO>>> getWishes(
+        @LoginMember Member member,
+        @PageableDefault(size = 10, sort = "createdDate", direction = Sort.Direction.DESC) Pageable pageable) {
+        Page<Wish> wishes = wishService.getWishesByMemberId(member.getId(), pageable);
+        Page<WishDTO> wishDTOs = wishes.map(wish -> new WishDTO(wish.getId(), wish.getMember().getId(), wish.getProduct().getId()));
+        ApiResponse<Page<WishDTO>> response = new ApiResponse<>(true, "Wishes retrieved successfully.", wishDTOs, null);
+        return ResponseEntity.ok(response);
+    }
+
+    @PostMapping
+    public ResponseEntity<ApiResponse<WishDTO>> addWish(@RequestBody Map<String, Long> wishRequest, @LoginMember Member member) {
+        try {
+            Long productId = wishRequest.get("productId");
+            Product product = productService.getProductById(productId);
+            Wish wish = new Wish();
+            wish.setMember(member);
+            wish.setProduct(product);
+            Wish savedWish = wishService.addWish(wish);
+            WishDTO wishDTO = new WishDTO(savedWish.getId(), savedWish.getMember().getId(), savedWish.getProduct().getId());
+            ApiResponse<WishDTO> response = new ApiResponse<>(true, "Wish added successfully.", wishDTO, null);
+            return ResponseEntity.status(HttpStatus.CREATED).body(response);
+        } catch (Exception ex) {
+            ApiResponse<WishDTO> response = new ApiResponse<>(false, "Failed to add wish: " + ex.getMessage(), null, "500");
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(response);
+        }
+    }
+
+    @DeleteMapping("/{id}")
+    public ResponseEntity<ApiResponse<Void>> removeWish(@PathVariable Long id, @LoginMember Member member) {
+        try {
+            boolean removed = wishService.removeWish(id, member.getId());
+            if (removed) {
+                ApiResponse<Void> response = new ApiResponse<>(true, "Wish removed successfully.", null, null);
+                return ResponseEntity.ok(response);
+            }
+            ApiResponse<Void> response = new ApiResponse<>(false, "Wish not found or not owned by member.", null, "404");
+            return ResponseEntity.status(HttpStatus.NOT_FOUND).body(response);
+        } catch (Exception ex) {
+            ApiResponse<Void> response = new ApiResponse<>(false, "Failed to remove wish: " + ex.getMessage(), null, "500");
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(response);
+        }
+    }
+}
diff --git a/src/main/java/gift/dto/ApiResponse.java b/src/main/java/gift/dto/ApiResponse.java
new file mode 100644
index 000000000..3db75bed6
--- /dev/null
+++ b/src/main/java/gift/dto/ApiResponse.java
@@ -0,0 +1,15 @@
+package gift.dto;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
+public class ApiResponse<T> {
+    private boolean success;
+    private String message;
+    private T data;
+    private String errorCode;
+}
\ No newline at end of file
diff --git a/src/main/java/gift/dto/UserInfo.java b/src/main/java/gift/dto/UserInfo.java
new file mode 100644
index 000000000..0b7311ad8
--- /dev/null
+++ b/src/main/java/gift/dto/UserInfo.java
@@ -0,0 +1,18 @@
+package gift.dto;
+
+public class UserInfo {
+
+    private String email;
+
+    public UserInfo(String email) {
+        this.email = email;
+    }
+
+    public String getEmail() {
+        return email;
+    }
+
+    public void setEmail(String email) {
+        this.email = email;
+    }
+}
diff --git a/src/main/java/gift/dto/WishDTO.java b/src/main/java/gift/dto/WishDTO.java
new file mode 100644
index 000000000..8f1946d44
--- /dev/null
+++ b/src/main/java/gift/dto/WishDTO.java
@@ -0,0 +1,40 @@
+package gift.dto;
+
+public class WishDTO {
+
+    private Long id;
+    private Long memberId;
+    private Long productId;
+
+    public WishDTO() {}
+
+    public WishDTO(Long id, Long memberId, Long productId) {
+        this.id = id;
+        this.memberId = memberId;
+        this.productId = productId;
+    }
+
+    public Long getId() {
+        return id;
+    }
+
+    public void setId(Long id) {
+        this.id = id;
+    }
+
+    public Long getMemberId() {
+        return memberId;
+    }
+
+    public void setMemberId(Long memberId) {
+        this.memberId = memberId;
+    }
+
+    public Long getProductId() {
+        return productId;
+    }
+
+    public void setProductId(Long productId) {
+        this.productId = productId;
+    }
+}
diff --git a/src/main/java/gift/exception/ForbiddenWordException.java b/src/main/java/gift/exception/ForbiddenWordException.java
new file mode 100644
index 000000000..55c506ecf
--- /dev/null
+++ b/src/main/java/gift/exception/ForbiddenWordException.java
@@ -0,0 +1,7 @@
+package gift.exception;
+
+public class ForbiddenWordException extends RuntimeException {
+    public ForbiddenWordException(String message) {
+        super(message);
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/gift/exception/GlobalExceptionHandler.java b/src/main/java/gift/exception/GlobalExceptionHandler.java
new file mode 100644
index 000000000..b0352fe89
--- /dev/null
+++ b/src/main/java/gift/exception/GlobalExceptionHandler.java
@@ -0,0 +1,43 @@
+package gift.exception;
+
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.validation.FieldError;
+import org.springframework.web.bind.MethodArgumentNotValidException;
+import org.springframework.web.bind.annotation.ControllerAdvice;
+import org.springframework.web.bind.annotation.ExceptionHandler;
+
+import java.util.HashMap;
+import java.util.Map;
+
+@ControllerAdvice
+public class GlobalExceptionHandler {
+
+    @ExceptionHandler(ProductNotFoundException.class)
+    public ResponseEntity<Map<String, Object>> handleProductNotFoundException(ProductNotFoundException ex) {
+        Map<String, Object> response = new HashMap<>();
+        response.put("message", ex.getMessage());
+        return ResponseEntity.status(HttpStatus.NOT_FOUND).body(response);
+    }
+
+    @ExceptionHandler(MethodArgumentNotValidException.class)
+    public ResponseEntity<Map<String, Object>> handleValidationExceptions(MethodArgumentNotValidException ex) {
+        Map<String, Object> errors = new HashMap<>();
+        ex.getBindingResult().getAllErrors().forEach((error) -> {
+            String fieldName = ((FieldError) error).getField();
+            String errorMessage = error.getDefaultMessage();
+            errors.put(fieldName, errorMessage);
+        });
+        Map<String, Object> response = new HashMap<>();
+        response.put("errors", errors);
+        response.put("message", "Validation failed");
+        return ResponseEntity.status(HttpStatus.BAD_REQUEST).body(response);
+    }
+
+    @ExceptionHandler(ForbiddenWordException.class)
+    public ResponseEntity<Map<String, Object>> handleIllegalArgumentException(ForbiddenWordException ex) {
+        Map<String, Object> response = new HashMap<>();
+        response.put("message", ex.getMessage());
+        return ResponseEntity.status(HttpStatus.BAD_REQUEST).body(response);
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/gift/exception/ProductNotFoundException.java b/src/main/java/gift/exception/ProductNotFoundException.java
new file mode 100644
index 000000000..824005b33
--- /dev/null
+++ b/src/main/java/gift/exception/ProductNotFoundException.java
@@ -0,0 +1,7 @@
+package gift.exception;
+
+public class ProductNotFoundException extends RuntimeException {
+    public ProductNotFoundException(String message) {
+        super(message);
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/gift/model/AccessToken.java b/src/main/java/gift/model/AccessToken.java
new file mode 100644
index 000000000..28864788f
--- /dev/null
+++ b/src/main/java/gift/model/AccessToken.java
@@ -0,0 +1,40 @@
+package gift.model;
+
+import jakarta.persistence.*;
+import lombok.Getter;
+import lombok.Setter;
+
+import java.time.LocalDateTime;
+
+@Setter
+@Getter
+@Entity
+@Table(name = "access_token")
+public class AccessToken {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "member_id", nullable = false)
+    private Member member;
+
+    @Column(nullable = false)
+    private String provider;
+
+    @Column(nullable = false)
+    private String token;
+
+    @Column(nullable = false)
+    private LocalDateTime expiryDate;
+
+    public AccessToken() {}
+
+    public AccessToken(Member member, String provider, String token, LocalDateTime expiryDate) {
+        this.member = member;
+        this.provider = provider;
+        this.token = token;
+        this.expiryDate = expiryDate;
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/gift/model/Category.java b/src/main/java/gift/model/Category.java
new file mode 100644
index 000000000..6ee1626dc
--- /dev/null
+++ b/src/main/java/gift/model/Category.java
@@ -0,0 +1,77 @@
+package gift.model;
+
+import jakarta.persistence.*;
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.Size;
+import lombok.Getter;
+import lombok.Setter;
+
+@Entity
+@Table(name = "category", uniqueConstraints = @UniqueConstraint(name = "uk_category", columnNames = "name"))
+public class Category {
+
+    @Getter
+    @Setter
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @NotBlank
+    @Size(max = 255)
+    @Column(nullable = false, unique = true)
+    private String name;
+
+    @NotBlank
+    @Size(max = 7)
+    @Column(nullable = false)
+    private String color;
+
+    @NotBlank
+    @Size(max = 255)
+    @Column(name = "image_url", nullable = false)
+    private String imageUrl;
+
+    @Size(max = 255)
+    private String description;
+
+    public Category() {}
+
+    public Category(String name, String color, String imageUrl, String description) {
+        this.name = name;
+        this.color = color;
+        this.imageUrl = imageUrl;
+        this.description = description;
+    }
+
+    public @NotBlank @Size(max = 255) String getName() {
+        return name;
+    }
+
+    public void setName(@NotBlank @Size(max = 255) String name) {
+        this.name = name;
+    }
+
+    public @NotBlank @Size(max = 7) String getColor() {
+        return color;
+    }
+
+    public void setColor(@NotBlank @Size(max = 7) String color) {
+        this.color = color;
+    }
+
+    public @NotBlank @Size(max = 255) String getImageUrl() {
+        return imageUrl;
+    }
+
+    public void setImageUrl(@NotBlank @Size(max = 255) String imageUrl) {
+        this.imageUrl = imageUrl;
+    }
+
+    public @Size(max = 255) String getDescription() {
+        return description;
+    }
+
+    public void setDescription(@Size(max = 255) String description) {
+        this.description = description;
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/gift/model/Member.java b/src/main/java/gift/model/Member.java
new file mode 100644
index 000000000..cbd868c69
--- /dev/null
+++ b/src/main/java/gift/model/Member.java
@@ -0,0 +1,59 @@
+package gift.model;
+
+import jakarta.persistence.*;
+import jakarta.validation.constraints.Email;
+import jakarta.validation.constraints.NotBlank;
+import lombok.Getter;
+import lombok.Setter;
+
+import java.util.List;
+
+@Setter
+@Getter
+@Entity
+@Table(name = "member")
+public class Member {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @Email
+    @NotBlank
+    @Column(nullable = false, unique = true)
+    private String email;
+
+    @Column(nullable = true)
+    private String password;
+
+    @Column(nullable = true)
+    private String oauthProvider;
+
+    @OneToMany(mappedBy = "member", cascade = CascadeType.ALL, orphanRemoval = true)
+    private List<AccessToken> accessTokens;
+
+    @OneToMany(mappedBy = "member", cascade = CascadeType.ALL, orphanRemoval = true)
+    private List<Wish> wishes;
+
+    @Column(nullable = false)
+    private int points = 0;
+
+    public Member() {}
+
+    public Member(@Email @NotBlank String email, String password, String oauthProvider) {
+        this.email = email;
+        this.password = password;
+        this.oauthProvider = oauthProvider;
+    }
+
+    public void addPoints(int points) {
+        this.points += points;
+    }
+
+    public void subtractPoints(int points) {
+        if (this.points < points) {
+            throw new IllegalArgumentException("Not enough points");
+        }
+        this.points -= points;
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/gift/model/Option.java b/src/main/java/gift/model/Option.java
new file mode 100644
index 000000000..72c170068
--- /dev/null
+++ b/src/main/java/gift/model/Option.java
@@ -0,0 +1,75 @@
+package gift.model;
+
+import com.fasterxml.jackson.annotation.JsonBackReference;
+import jakarta.persistence.*;
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.NotNull;
+import jakarta.validation.constraints.Pattern;
+import jakarta.validation.constraints.Size;
+import jakarta.validation.constraints.Min;
+import jakarta.validation.constraints.Max;
+import lombok.Getter;
+import lombok.Setter;
+
+@Entity
+@Table(name = "option")
+public class Option {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @NotBlank
+    @Size(max = 50)
+    @Pattern(regexp = "^[a-zA-Z0-9가-힣\\(\\)\\[\\]\\+\\-\\&\\/\\_\\s]*$")
+    @Column(nullable = false, length = 50)
+    private String name;
+
+    @NotNull
+    @Min(1)
+    @Max(99999999)
+    @Column(nullable = false)
+    private Integer quantity;
+
+    @Getter
+    @Setter
+    @JsonBackReference
+    @ManyToOne
+    @JoinColumn(name = "product_id", nullable = false)
+    private Product product;
+
+    public Option() {}
+
+    public Option(String name, Integer quantity, Product product) {
+        this.name = name;
+        this.quantity = quantity;
+        this.product = product;
+    }
+
+    public @NotBlank @Size(max = 50) @Pattern(regexp = "^[a-zA-Z0-9가-힣\\(\\)\\[\\]\\+\\-\\&\\/\\_\\s]*$") String getName() {
+        return name;
+    }
+
+    public Long getId() {
+        return id;
+    }
+
+    public void setName(@NotBlank @Size(max = 50) @Pattern(regexp = "^[a-zA-Z0-9가-힣\\(\\)\\[\\]\\+\\-\\&\\/\\_\\s]*$") String name) {
+        this.name = name;
+    }
+
+    public @NotNull @Min(1) @Max(99999999) Integer getQuantity() {
+        return quantity;
+    }
+
+    public void setQuantity(@NotNull @Min(1) @Max(99999999) Integer quantity) {
+        this.quantity = quantity;
+    }
+
+    public void subtractQuantity(int quantity) {
+        if (this.quantity < quantity) {
+            throw new IllegalArgumentException("Insufficient quantity");
+        }
+        this.quantity -= quantity;
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/gift/model/Order.java b/src/main/java/gift/model/Order.java
new file mode 100644
index 000000000..457a8a741
--- /dev/null
+++ b/src/main/java/gift/model/Order.java
@@ -0,0 +1,62 @@
+package gift.model;
+
+import jakarta.persistence.*;
+import lombok.Getter;
+import lombok.Setter;
+
+import java.time.LocalDateTime;
+
+@Setter
+@Getter
+@Entity
+@Table(name = "orders")
+public class Order {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @Transient
+    private Long optionId;
+
+    @ManyToOne
+    @JoinColumn(name = "option_id", nullable = false)
+    private Option option;
+
+    @Column(nullable = false)
+    private int quantity;
+
+    @Column(nullable = true, length = 255)
+    private String message;
+
+    @Column(name = "order_date_time", nullable = false)
+    private LocalDateTime orderDateTime;
+
+    @Column(nullable = false)
+    private boolean cashReceipt;
+
+    @Column(nullable = true)
+    private String phoneNumber;
+
+    @Column(nullable = false)
+    private int paymentAmount;
+
+    @Column(nullable = false)
+    private int pointsUsed;
+
+    @Override
+    public String toString() {
+        return "Order{" +
+            "id=" + id +
+            ", optionId=" + optionId +
+            ", option=" + (option != null ? option.getId() : "null") +
+            ", quantity=" + quantity +
+            ", message='" + message + '\'' +
+            ", orderDateTime=" + orderDateTime +
+            ", cashReceipt=" + cashReceipt +
+            ", phoneNumber='" + phoneNumber + '\'' +
+            ", paymentAmount=" + paymentAmount +
+            ", pointsUsed=" + pointsUsed +
+            '}';
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/gift/model/Product.java b/src/main/java/gift/model/Product.java
new file mode 100644
index 000000000..3ccdaa694
--- /dev/null
+++ b/src/main/java/gift/model/Product.java
@@ -0,0 +1,98 @@
+package gift.model;
+
+import com.fasterxml.jackson.annotation.JsonManagedReference;
+import jakarta.persistence.*;
+import jakarta.validation.constraints.NotEmpty;
+import jakarta.validation.constraints.NotNull;
+import jakarta.validation.constraints.Pattern;
+import jakarta.validation.constraints.Size;
+
+import java.util.List;
+
+@Entity
+@Table(name = "product")
+public class Product {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @NotNull(message = "상품 이름은 필수 입력 값입니다.")
+    @Size(max = 15, message = "상품 이름은 최대 15자까지 입력할 수 있습니다.")
+    @Pattern(regexp = "^[a-zA-Z0-9가-힣\\(\\)\\[\\]\\+\\-\\&\\/\\_\\s]*$", message = "상품 이름에 허용되지 않는 문자가 포함되어 있습니다.")
+    @Column(nullable = false, length = 15)
+    private String name;
+
+    @Column(nullable = false)
+    private Integer price;
+
+    @Column(name = "image_url", nullable = false)
+    private String imageUrl;
+
+    @ManyToOne
+    @JoinColumn(name = "category_id", nullable = false)
+    private Category category;
+
+    @NotEmpty
+    @JsonManagedReference
+    @OneToMany(mappedBy = "product", cascade = CascadeType.ALL, orphanRemoval = true)
+    private List<Option> options;
+
+    public Product() {}
+
+    public Product(String name, Integer price, String imageUrl, Category category,  List<Option> options) {
+        this.name = name;
+        this.price = price;
+        this.imageUrl = imageUrl;
+        this.category = category;
+        this.options = options;
+    }
+
+    public Long getId() {
+        return id;
+    }
+
+    public void setId(Long id) {
+        this.id = id;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public Integer getPrice() {
+        return price;
+    }
+
+    public void setPrice(Integer price) {
+        this.price = price;
+    }
+
+    public String getImageUrl() {
+        return imageUrl;
+    }
+
+    public void setImageUrl(String imageUrl) {
+        this.imageUrl = imageUrl;
+    }
+
+    public Category getCategory() {
+        return category;
+    }
+
+    public void setCategory(Category category) {
+        this.category = category;
+    }
+
+    public List<Option> getOptions() {
+        return options;
+    }
+
+    public void setOptions(List<Option> options) {
+        this.options = options;
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/gift/model/Wish.java b/src/main/java/gift/model/Wish.java
new file mode 100644
index 000000000..b154e593a
--- /dev/null
+++ b/src/main/java/gift/model/Wish.java
@@ -0,0 +1,49 @@
+package gift.model;
+
+import jakarta.persistence.*;
+
+@Entity
+@Table(name = "wish")
+public class Wish {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @ManyToOne
+    @JoinColumn(name = "member_id", nullable = false)
+    private Member member;
+
+    @ManyToOne
+    @JoinColumn(name = "product_id", nullable = false)
+    private Product product;
+
+    public Wish() {}
+
+    public Wish(Member member, Product product) {
+        this.member = member;
+        this.product = product;
+    }
+
+    public Long getId() {
+        return id;
+    }
+
+    public void setId(Long id) {
+        this.id = id;
+    }
+
+    public Member getMember() { return member; }
+
+    public void setMember(Member member) {
+        this.member = member;
+    }
+
+    public Product getProduct() {
+        return product;
+    }
+
+    public void setProduct(Product product) {
+        this.product = product;
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/gift/repository/AccessTokenRepository.java b/src/main/java/gift/repository/AccessTokenRepository.java
new file mode 100644
index 000000000..ead4dc18c
--- /dev/null
+++ b/src/main/java/gift/repository/AccessTokenRepository.java
@@ -0,0 +1,7 @@
+package gift.repository;
+
+import gift.model.AccessToken;
+import org.springframework.data.jpa.repository.JpaRepository;
+
+public interface AccessTokenRepository extends JpaRepository<AccessToken, Long>{
+}
diff --git a/src/main/java/gift/repository/CategoryRepository.java b/src/main/java/gift/repository/CategoryRepository.java
new file mode 100644
index 000000000..61285ab83
--- /dev/null
+++ b/src/main/java/gift/repository/CategoryRepository.java
@@ -0,0 +1,7 @@
+package gift.repository;
+
+import gift.model.Category;
+import org.springframework.data.jpa.repository.JpaRepository;
+
+public interface CategoryRepository extends JpaRepository<Category, Long> {
+}
\ No newline at end of file
diff --git a/src/main/java/gift/repository/MemberRepository.java b/src/main/java/gift/repository/MemberRepository.java
new file mode 100644
index 000000000..c93d60f6b
--- /dev/null
+++ b/src/main/java/gift/repository/MemberRepository.java
@@ -0,0 +1,9 @@
+package gift.repository;
+
+import gift.model.Member;
+import org.springframework.data.jpa.repository.JpaRepository;
+import java.util.Optional;
+
+public interface MemberRepository extends JpaRepository<Member, Long> {
+    Optional<Member> findByEmail(String email);
+}
\ No newline at end of file
diff --git a/src/main/java/gift/repository/OptionRepository.java b/src/main/java/gift/repository/OptionRepository.java
new file mode 100644
index 000000000..52d5cd3fe
--- /dev/null
+++ b/src/main/java/gift/repository/OptionRepository.java
@@ -0,0 +1,11 @@
+package gift.repository;
+
+import gift.model.Option;
+import gift.model.Product;
+import org.springframework.data.jpa.repository.JpaRepository;
+
+import java.util.List;
+
+public interface OptionRepository extends JpaRepository<Option, Long> {
+    List<Option> findAllByProduct(Product product);
+}
diff --git a/src/main/java/gift/repository/OrderRepository.java b/src/main/java/gift/repository/OrderRepository.java
new file mode 100644
index 000000000..ea79d47eb
--- /dev/null
+++ b/src/main/java/gift/repository/OrderRepository.java
@@ -0,0 +1,7 @@
+package gift.repository;
+
+import gift.model.Order;
+import org.springframework.data.jpa.repository.JpaRepository;
+
+public interface OrderRepository extends JpaRepository<Order, Long> {
+}
diff --git a/src/main/java/gift/repository/ProductRepository.java b/src/main/java/gift/repository/ProductRepository.java
new file mode 100644
index 000000000..0ad729922
--- /dev/null
+++ b/src/main/java/gift/repository/ProductRepository.java
@@ -0,0 +1,10 @@
+package gift.repository;
+
+import gift.model.Product;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.jpa.repository.JpaRepository;
+
+public interface ProductRepository extends JpaRepository<Product, Long> {
+    Page<Product> findAllByCategoryId(Long categoryId, Pageable pageable);
+}
diff --git a/src/main/java/gift/repository/WishRepository.java b/src/main/java/gift/repository/WishRepository.java
new file mode 100644
index 000000000..ef986a6ae
--- /dev/null
+++ b/src/main/java/gift/repository/WishRepository.java
@@ -0,0 +1,16 @@
+package gift.repository;
+
+import gift.model.Wish;
+import gift.model.Member;
+import gift.model.Product;
+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 WishRepository extends JpaRepository<Wish, Long> {
+    Page<Wish> findAllByMemberId(Long memberId, Pageable pageable);
+    Optional<Wish> findByIdAndMemberId(Long id, Long memberId);
+    void deleteByMemberAndProduct(Member member, Product product);
+}
diff --git a/src/main/java/gift/service/AuthService.java b/src/main/java/gift/service/AuthService.java
new file mode 100644
index 000000000..21c75118c
--- /dev/null
+++ b/src/main/java/gift/service/AuthService.java
@@ -0,0 +1,8 @@
+package gift.service;
+
+import gift.dto.UserInfo;
+
+public interface AuthService {
+    String getAccessToken(String authorizationCode);
+    UserInfo getUserInfo(String accessToken);
+}
diff --git a/src/main/java/gift/service/CategoryService.java b/src/main/java/gift/service/CategoryService.java
new file mode 100644
index 000000000..0aaec3c8c
--- /dev/null
+++ b/src/main/java/gift/service/CategoryService.java
@@ -0,0 +1,12 @@
+package gift.service;
+
+import gift.model.Category;
+
+import java.util.List;
+
+public interface CategoryService {
+    List<Category> getAllCategories();
+    Category createCategory(Category category);
+    Category updateCategory(Long id, Category updatedCategory);
+    void deleteCategory(Long id);
+}
diff --git a/src/main/java/gift/service/KakaoAuthService.java b/src/main/java/gift/service/KakaoAuthService.java
new file mode 100644
index 000000000..d1526da34
--- /dev/null
+++ b/src/main/java/gift/service/KakaoAuthService.java
@@ -0,0 +1,4 @@
+package gift.service;
+
+public interface KakaoAuthService extends AuthService {
+}
\ No newline at end of file
diff --git a/src/main/java/gift/service/KakaoMessageService.java b/src/main/java/gift/service/KakaoMessageService.java
new file mode 100644
index 000000000..6d328d379
--- /dev/null
+++ b/src/main/java/gift/service/KakaoMessageService.java
@@ -0,0 +1,8 @@
+package gift.service;
+
+import org.springframework.http.ResponseEntity;
+import reactor.core.publisher.Mono;
+
+public interface KakaoMessageService {
+    Mono<ResponseEntity<String>> sendMessage(String accessToken, String message);
+}
diff --git a/src/main/java/gift/service/MemberService.java b/src/main/java/gift/service/MemberService.java
new file mode 100644
index 000000000..23bf6d325
--- /dev/null
+++ b/src/main/java/gift/service/MemberService.java
@@ -0,0 +1,10 @@
+package gift.service;
+
+import gift.model.Member;
+import java.util.Optional;
+
+public interface MemberService {
+    Optional<String> registerMember(Member member);
+    Optional<String> login(String email, String password);
+    Optional<Member> findById(Long id);
+}
diff --git a/src/main/java/gift/service/OptionService.java b/src/main/java/gift/service/OptionService.java
new file mode 100644
index 000000000..84e5cc854
--- /dev/null
+++ b/src/main/java/gift/service/OptionService.java
@@ -0,0 +1,12 @@
+package gift.service;
+
+import gift.model.Option;
+
+import java.util.List;
+
+public interface OptionService {
+    Option addOptionToProduct(Long productId, Option option);
+    Option updateOption(Long productId, Long optionId, Option option);
+    void deleteOption(Long productId, Long optionId);
+    List<Option> getOptionsByProduct(Long productId);
+}
\ No newline at end of file
diff --git a/src/main/java/gift/service/OrderService.java b/src/main/java/gift/service/OrderService.java
new file mode 100644
index 000000000..b9a895c83
--- /dev/null
+++ b/src/main/java/gift/service/OrderService.java
@@ -0,0 +1,11 @@
+package gift.service;
+
+import gift.model.Member;
+import gift.model.Order;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+
+public interface OrderService {
+    Order createOrder(Order order, Member member);
+    Page<Order> getOrders(Pageable pageable);
+}
diff --git a/src/main/java/gift/service/ProductService.java b/src/main/java/gift/service/ProductService.java
new file mode 100644
index 000000000..4f6a1f36a
--- /dev/null
+++ b/src/main/java/gift/service/ProductService.java
@@ -0,0 +1,18 @@
+package gift.service;
+
+import gift.model.Product;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+
+import java.util.List;
+import java.util.Map;
+
+public interface ProductService {
+    Page<Product> getProducts(Pageable pageable, Long categoryId);
+    Product getProductById(Long id);
+    boolean createProduct(Product product);
+    boolean updateProduct(Long id, Product product);
+    boolean patchProduct(Long id, Map<String, Object> updates);
+    List<Product> patchProducts(List<Map<String, Object>> updatesList);
+    boolean deleteProduct(Long id);
+}
diff --git a/src/main/java/gift/service/UserService.java b/src/main/java/gift/service/UserService.java
new file mode 100644
index 000000000..65fec9658
--- /dev/null
+++ b/src/main/java/gift/service/UserService.java
@@ -0,0 +1,7 @@
+package gift.service;
+
+import gift.dto.UserInfo;
+
+public interface UserService {
+    void saveUser(String accessToken, UserInfo userInfo);
+}
diff --git a/src/main/java/gift/service/WishService.java b/src/main/java/gift/service/WishService.java
new file mode 100644
index 000000000..52e406853
--- /dev/null
+++ b/src/main/java/gift/service/WishService.java
@@ -0,0 +1,11 @@
+package gift.service;
+
+import gift.model.Wish;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+
+public interface WishService {
+    Page<Wish> getWishesByMemberId(Long memberId, Pageable pageable);
+    Wish addWish(Wish wish);
+    boolean removeWish(Long id, Long memberId);
+}
diff --git a/src/main/java/gift/service/impl/CategoryServiceImpl.java b/src/main/java/gift/service/impl/CategoryServiceImpl.java
new file mode 100644
index 000000000..b3baae0a5
--- /dev/null
+++ b/src/main/java/gift/service/impl/CategoryServiceImpl.java
@@ -0,0 +1,40 @@
+package gift.service.impl;
+
+import gift.model.Category;
+import gift.repository.CategoryRepository;
+import gift.service.CategoryService;
+import org.springframework.stereotype.Service;
+
+import java.util.List;
+
+@Service
+public class CategoryServiceImpl implements CategoryService {
+
+    private final CategoryRepository categoryRepository;
+
+    public CategoryServiceImpl(CategoryRepository categoryRepository) {
+        this.categoryRepository = categoryRepository;
+    }
+
+    public List<Category> getAllCategories() {
+        return categoryRepository.findAll();
+    }
+
+    public Category createCategory(Category category) {
+        return categoryRepository.save(category);
+    }
+
+    public Category updateCategory(Long id, Category updatedCategory) {
+        return categoryRepository.findById(id).map(category -> {
+            category.setName(updatedCategory.getName());
+            category.setColor(updatedCategory.getColor());
+            category.setImageUrl(updatedCategory.getImageUrl());
+            category.setDescription(updatedCategory.getDescription());
+            return categoryRepository.save(category);
+        }).orElseThrow(() -> new RuntimeException("Category not found"));
+    }
+
+    public void deleteCategory(Long id) {
+        categoryRepository.deleteById(id);
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/gift/service/impl/KakaoAuthServiceImpl.java b/src/main/java/gift/service/impl/KakaoAuthServiceImpl.java
new file mode 100644
index 000000000..a6c58973a
--- /dev/null
+++ b/src/main/java/gift/service/impl/KakaoAuthServiceImpl.java
@@ -0,0 +1,78 @@
+package gift.service.impl;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import gift.dto.UserInfo;
+import gift.service.KakaoAuthService;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.http.HttpHeaders;
+import org.springframework.http.HttpMethod;
+import org.springframework.http.MediaType;
+import org.springframework.http.RequestEntity;
+import org.springframework.http.ResponseEntity;
+import org.springframework.stereotype.Service;
+import org.springframework.util.LinkedMultiValueMap;
+import org.springframework.util.MultiValueMap;
+import org.springframework.web.client.RestTemplate;
+
+import java.net.URI;
+
+@Service
+public class KakaoAuthServiceImpl implements KakaoAuthService {
+
+    @Value("${kakao.client-id}")
+    private String clientId;
+
+    @Value("${kakao.redirect-uri}")
+    private String redirectUri;
+
+    private final String tokenUrl = "https://kauth.kakao.com/oauth/token";
+    private final String userInfoUrl = "https://kapi.kakao.com/v2/user/me";
+
+    @Override
+    public String getAccessToken(String authorizationCode) {
+        RestTemplate restTemplate = new RestTemplate();
+
+        HttpHeaders headers = new HttpHeaders();
+        headers.setContentType(MediaType.APPLICATION_FORM_URLENCODED);
+
+        MultiValueMap<String, String> body = new LinkedMultiValueMap<>();
+        body.add("grant_type", "authorization_code");
+        body.add("client_id", clientId);
+        body.add("redirect_uri", redirectUri);
+        body.add("code", authorizationCode);
+
+        RequestEntity<MultiValueMap<String, String>> requestEntity = new RequestEntity<>(body, headers, HttpMethod.POST, URI.create(tokenUrl));
+        ResponseEntity<String> response = restTemplate.exchange(requestEntity, String.class);
+
+        try {
+            ObjectMapper objectMapper = new ObjectMapper();
+            JsonNode rootNode = objectMapper.readTree(response.getBody());
+            return rootNode.path("access_token").asText();
+        } catch (Exception e) {
+            throw new RuntimeException("Failed to get access token", e);
+        }
+    }
+
+    @Override
+    public UserInfo getUserInfo(String accessToken) {
+        RestTemplate restTemplate = new RestTemplate();
+
+        HttpHeaders headers = new HttpHeaders();
+        headers.setBearerAuth(accessToken);
+
+        RequestEntity<Void> requestEntity = new RequestEntity<>(headers, HttpMethod.GET, URI.create(userInfoUrl));
+        ResponseEntity<String> response = restTemplate.exchange(requestEntity, String.class);
+
+        try {
+            ObjectMapper objectMapper = new ObjectMapper();
+            JsonNode rootNode = objectMapper.readTree(response.getBody());
+            JsonNode kakaoAccount = rootNode.path("kakao_account");
+            String email = kakaoAccount.path("email").asText();
+
+            return new UserInfo(email);
+        } catch (Exception e) {
+            throw new RuntimeException("Failed to get user info", e);
+        }
+    }
+}
diff --git a/src/main/java/gift/service/impl/KakaoMessageServiceImpl.java b/src/main/java/gift/service/impl/KakaoMessageServiceImpl.java
new file mode 100644
index 000000000..1e0c2efa4
--- /dev/null
+++ b/src/main/java/gift/service/impl/KakaoMessageServiceImpl.java
@@ -0,0 +1,59 @@
+package gift.service.impl;
+
+import gift.service.KakaoMessageService;
+import org.springframework.http.HttpHeaders;
+import org.springframework.http.MediaType;
+import org.springframework.http.ResponseEntity;
+import org.springframework.stereotype.Service;
+import org.springframework.util.LinkedMultiValueMap;
+import org.springframework.util.MultiValueMap;
+import org.springframework.web.reactive.function.client.WebClient;
+import reactor.core.publisher.Mono;
+
+@Service
+public class KakaoMessageServiceImpl implements KakaoMessageService {
+
+    private final WebClient webClient;
+
+    public KakaoMessageServiceImpl() {
+        this.webClient = WebClient.builder()
+            .baseUrl("https://kapi.kakao.com")
+            .build();
+    }
+
+    @Override
+    public Mono<ResponseEntity<String>> sendMessage(String accessToken, String message) {
+        HttpHeaders headers = createHeaders(accessToken);
+        MultiValueMap<String, String> body = createMessageBody(message);
+
+        return webClient.post()
+            .uri("/v2/api/talk/memo/default/send")
+            .headers(httpHeaders -> httpHeaders.addAll(headers))
+            .bodyValue(body)
+            .retrieve()
+            .toEntity(String.class);
+    }
+
+    public HttpHeaders createHeaders(String accessToken) {
+        HttpHeaders headers = new HttpHeaders();
+        headers.add("Authorization", accessToken);
+        headers.setContentType(MediaType.APPLICATION_FORM_URLENCODED);
+        return headers;
+    }
+
+    public MultiValueMap<String, String> createMessageBody(String message) {
+        String templateObject = "{"
+            + "\"object_type\": \"text\","
+            + "\"text\": \"" + message + "\","
+            + "\"link\": {"
+            + "  \"web_url\": \"https://developers.kakao.com\","
+            + "  \"mobile_web_url\": \"https://developers.kakao.com\""
+            + "},"
+            + "\"button_title\": \"바로 확인\""
+            + "}";
+
+        MultiValueMap<String, String> body = new LinkedMultiValueMap<>();
+        body.add("template_object", templateObject);
+        return body;
+    }
+}
diff --git a/src/main/java/gift/service/impl/MemberServiceImpl.java b/src/main/java/gift/service/impl/MemberServiceImpl.java
new file mode 100644
index 000000000..a462645a5
--- /dev/null
+++ b/src/main/java/gift/service/impl/MemberServiceImpl.java
@@ -0,0 +1,62 @@
+package gift.service.impl;
+
+import gift.model.Member;
+import gift.repository.MemberRepository;
+import gift.service.MemberService;
+import io.jsonwebtoken.Jwts;
+import io.jsonwebtoken.security.Keys;
+import org.mindrot.jbcrypt.BCrypt;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Service;
+
+import java.util.Optional;
+
+@Service
+public class MemberServiceImpl implements MemberService {
+
+    private final MemberRepository memberRepository;
+
+    @Value("${jwt.secret}")
+    private String secretKey;
+
+    public MemberServiceImpl(MemberRepository memberRepository) {
+        this.memberRepository = memberRepository;
+    }
+
+    @Override
+    public Optional<String> registerMember(Member member) {
+        String hashedPassword = BCrypt.hashpw(member.getPassword(), BCrypt.gensalt());
+        member.setPassword(hashedPassword);
+        Member savedMember = memberRepository.save(member);
+
+        String token = Jwts.builder()
+            .subject(savedMember.getId().toString())
+            .claim("email", savedMember.getEmail())
+            .signWith(Keys.hmacShaKeyFor(secretKey.getBytes()))
+            .compact();
+
+        return Optional.of(token);
+    }
+
+    @Override
+    public Optional<String> login(String email, String password) {
+        Optional<Member> memberOptional = memberRepository.findByEmail(email);
+        if (memberOptional.isPresent()) {
+            Member member = memberOptional.get();
+            if (BCrypt.checkpw(password, member.getPassword())) {
+                String jws = Jwts.builder()
+                    .subject(member.getId().toString())
+                    .claim("email", member.getEmail())
+                    .signWith(Keys.hmacShaKeyFor(secretKey.getBytes()))
+                    .compact();
+                return Optional.of(jws);
+            }
+        }
+        return Optional.empty();
+    }
+
+    @Override
+    public Optional<Member> findById(Long id) {
+        return memberRepository.findById(id);
+    }
+}
diff --git a/src/main/java/gift/service/impl/OptionServiceImpl.java b/src/main/java/gift/service/impl/OptionServiceImpl.java
new file mode 100644
index 000000000..9d960aece
--- /dev/null
+++ b/src/main/java/gift/service/impl/OptionServiceImpl.java
@@ -0,0 +1,85 @@
+package gift.service.impl;
+
+import gift.model.Option;
+import gift.model.Product;
+import gift.repository.OptionRepository;
+import gift.repository.ProductRepository;
+import gift.service.OptionService;
+import jakarta.transaction.Transactional;
+import org.springframework.stereotype.Service;
+
+import java.util.List;
+import java.util.NoSuchElementException;
+
+@Service
+public class OptionServiceImpl implements OptionService {
+
+    private final OptionRepository optionRepository;
+    private final ProductRepository productRepository;
+
+    public OptionServiceImpl(OptionRepository optionRepository, ProductRepository productRepository) {
+        this.optionRepository = optionRepository;
+        this.productRepository = productRepository;
+    }
+
+    @Override
+    @Transactional
+    public Option addOptionToProduct(Long productId, Option option) {
+        Product product = productRepository.findById(productId)
+            .orElseThrow(() -> new NoSuchElementException("상품이 존재하지 않습니다."));
+        option.setProduct(product);
+        List<Option> options = optionRepository.findAllByProduct(product);
+        validateOption(options, option);
+        return optionRepository.save(option);
+    }
+
+    @Override
+    public List<Option> getOptionsByProduct(Long productId) {
+        Product product = productRepository.findById(productId)
+            .orElseThrow(() -> new NoSuchElementException("상품이 존재하지 않습니다."));
+        return optionRepository.findAllByProduct(product);
+    }
+
+    @Override
+    @Transactional
+    public Option updateOption(Long productId, Long optionId, Option updatedOption) {
+        Product product = productRepository.findById(productId)
+            .orElseThrow(() -> new NoSuchElementException("상품이 존재하지 않습니다."));
+        return optionRepository.findById(optionId)
+            .map(existingOption -> {
+                existingOption.setName(updatedOption.getName());
+                existingOption.setQuantity(updatedOption.getQuantity());
+                existingOption.setProduct(product);
+                return optionRepository.save(existingOption);
+            })
+            .orElseThrow(() -> new NoSuchElementException("옵션이 존재하지 않습니다."));
+    }
+
+    @Override
+    @Transactional
+    public void deleteOption(Long productId, Long optionId) {
+        if (!productRepository.existsById(productId)) {
+            throw new NoSuchElementException("상품이 존재하지 않습니다.");
+        }
+        if (!optionRepository.existsById(optionId)) {
+            throw new NoSuchElementException("옵션이 존재하지 않습니다.");
+        }
+        optionRepository.deleteById(optionId);
+    }
+
+    @Transactional
+    public void subtractOptionQuantity(Long optionId, int quantity) {
+        Option option = optionRepository.findById(optionId)
+            .orElseThrow(() -> new NoSuchElementException("옵션이 존재하지 않습니다."));
+        option.subtractQuantity(quantity);
+        optionRepository.save(option);
+    }
+
+    private void validateOption(List<Option> options, Option newOption) {
+        for (Option option : options) {
+            if (option.getName().equals(newOption.getName())) {
+                throw new IllegalArgumentException("옵션 이름이 중복됩니다: " + newOption.getName());
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/gift/service/impl/OrderServiceImpl.java b/src/main/java/gift/service/impl/OrderServiceImpl.java
new file mode 100644
index 000000000..693bfafcf
--- /dev/null
+++ b/src/main/java/gift/service/impl/OrderServiceImpl.java
@@ -0,0 +1,70 @@
+package gift.service.impl;
+
+import gift.model.Order;
+import gift.model.Member;
+import gift.model.Option;
+import gift.repository.OrderRepository;
+import gift.repository.OptionRepository;
+import gift.service.OrderService;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.stereotype.Service;
+
+import java.math.BigDecimal;
+import java.time.LocalDateTime;
+
+@Service
+public class OrderServiceImpl implements OrderService {
+
+    private final OrderRepository orderRepository;
+    private final OptionRepository optionRepository;
+
+    public OrderServiceImpl(OrderRepository orderRepository, OptionRepository optionRepository) {
+        this.orderRepository = orderRepository;
+        this.optionRepository = optionRepository;
+    }
+
+    @Override
+    public Order createOrder(Order order, Member member) {
+        order.setOrderDateTime(LocalDateTime.now());
+
+        Option option = order.getOption();
+
+        int unitPrice = option.getProduct().getPrice();
+        int originalTotalPrice = unitPrice * order.getQuantity();
+
+        if (originalTotalPrice >= 50000) {
+            originalTotalPrice *= 0.9; // 10% 할인
+        }
+
+        int pointsToUse = order.getPointsUsed();
+        int paymentAmount = originalTotalPrice;
+        if (pointsToUse > 0) {
+            if (member.getPoints() < pointsToUse) {
+                throw new IllegalArgumentException("Not enough points");
+            }
+            member.subtractPoints(pointsToUse);
+            paymentAmount -= pointsToUse;
+        }
+
+        order.setPaymentAmount(paymentAmount);
+
+        int pointsToAdd = (int) Math.round(paymentAmount * 0.01);
+        member.addPoints(pointsToAdd);
+
+        if (order.isCashReceipt()) {
+            issueCashReceipt(order.getPhoneNumber(), BigDecimal.valueOf(paymentAmount));
+        }
+
+        return orderRepository.save(order);
+    }
+
+    private void issueCashReceipt(String phoneNumber, BigDecimal amount) {
+        System.out.println("현금영수증 발행 완료: 전화번호=" + phoneNumber + ", 금액=" + amount);
+    }
+
+    @Override
+    public Page<Order> getOrders(Pageable pageable) {
+        return orderRepository.findAll(pageable);
+    }
+}
diff --git a/src/main/java/gift/service/impl/ProductServiceImpl.java b/src/main/java/gift/service/impl/ProductServiceImpl.java
new file mode 100644
index 000000000..2bf4aeb52
--- /dev/null
+++ b/src/main/java/gift/service/impl/ProductServiceImpl.java
@@ -0,0 +1,161 @@
+package gift.service.impl;
+
+import gift.exception.ForbiddenWordException;
+import gift.exception.ProductNotFoundException;
+import gift.model.Category;
+import gift.model.Option;
+import gift.model.Product;
+import gift.repository.CategoryRepository;
+import gift.repository.OptionRepository;
+import gift.repository.ProductRepository;
+import gift.service.ProductService;
+import jakarta.transaction.Transactional;
+import jakarta.validation.Valid;
+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.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+@Service
+public class ProductServiceImpl implements ProductService {
+
+    private final ProductRepository productRepository;
+    private final CategoryRepository categoryRepository;
+    private final OptionRepository optionRepository;
+
+    public ProductServiceImpl(ProductRepository productRepository, CategoryRepository categoryRepository, OptionRepository optionRepository) {
+        this.productRepository = productRepository;
+        this.categoryRepository = categoryRepository;
+        this.optionRepository = optionRepository;
+    }
+
+    @Override
+    public Page<Product> getProducts(Pageable pageable, Long categoryId) {
+        if (categoryId != null) {
+            return productRepository.findAllByCategoryId(categoryId, pageable);
+        }
+        return productRepository.findAll(pageable);
+    }
+
+    @Override
+    public Product getProductById(Long id) {
+        return productRepository.findById(id)
+            .orElseThrow(() -> new ProductNotFoundException("Product not found with id: " + id));
+    }
+
+    @Override
+    public boolean createProduct(@Valid Product product) {
+        if (product.getName().contains("카카오")) {
+            throw new ForbiddenWordException("상품 이름에 '카카오'가 포함된 경우 담당 MD와 협의가 필요합니다.");
+        }
+        Product savedProduct = productRepository.save(product);
+
+        // 옵션을 추가하는 로직
+        if (product.getOptions() != null && !product.getOptions().isEmpty()) {
+            for (Option option : product.getOptions()) {
+                option.setProduct(savedProduct);
+                optionRepository.save(option);
+            }
+        }
+        return true;
+    }
+
+    @Override
+    public boolean updateProduct(Long id, @Valid Product product) {
+        if (product.getName().contains("카카오")) {
+            throw new ForbiddenWordException("상품 이름에 '카카오'가 포함된 경우 담당 MD와 협의가 필요합니다.");
+        }
+        return productRepository.findById(id)
+            .map(existingProduct -> {
+                existingProduct.setName(product.getName());
+                existingProduct.setPrice(product.getPrice());
+                existingProduct.setImageUrl(product.getImageUrl());
+                existingProduct.setCategory(product.getCategory());
+
+                optionRepository.deleteAll(existingProduct.getOptions());
+                for (Option option : product.getOptions()) {
+                    option.setProduct(existingProduct);
+                    optionRepository.save(option);
+                }
+
+                productRepository.save(existingProduct);
+                return true;
+            })
+            .orElse(false);
+    }
+
+    @Override
+    @Transactional
+    public boolean patchProduct(Long id, Map<String, Object> updates) {
+        return productRepository.findById(id)
+            .map(existingProduct -> {
+                applyUpdates(existingProduct, updates);
+                productRepository.save(existingProduct);
+                return true;
+            })
+            .orElse(false);
+    }
+
+    @Override
+    @Transactional
+    public List<Product> patchProducts(List<Map<String, Object>> updatesList) {
+        List<Product> updatedProducts = new ArrayList<>();
+        for (Map<String, Object> updates : updatesList) {
+            try {
+                Long id = ((Number) updates.get("id")).longValue();
+                if (patchProduct(id, updates)) {
+                    updatedProducts.add(productRepository.findById(id).orElseThrow());
+                }
+            } catch (ProductNotFoundException | ForbiddenWordException ignored) {
+            }
+        }
+        return updatedProducts;
+    }
+
+    private void applyUpdates(Product product, Map<String, Object> updates) {
+        updates.forEach((key, value) -> {
+            if (!"id".equals(key)) {
+                updateProductField(product, key, value);
+            }
+        });
+        if (product.getName().contains("카카오")) {
+            throw new ForbiddenWordException("상품 이름에 '카카오'가 포함된 경우 담당 MD와 협의가 필요합니다.");
+        }
+    }
+
+    private void updateProductField(Product product, String key, Object value) {
+        if ("name".equals(key)) {
+            product.setName((String) value);
+            return;
+        }
+        if ("price".equals(key)) {
+            product.setPrice((Integer) value);
+            return;
+        }
+        if ("imageUrl".equals(key)) {
+            product.setImageUrl((String) value);
+            return;
+        }
+        if ("category".equals(key)) {
+            Long categoryId = Long.valueOf((String) value);
+            Category category = categoryRepository.findById(categoryId)
+                .orElseThrow(() -> new IllegalArgumentException("Invalid category ID: " + categoryId));
+            product.setCategory(category);
+            return;
+        }
+        throw new IllegalArgumentException("Invalid field: " + key);
+    }
+
+    @Override
+    public boolean deleteProduct(Long id) {
+        if (!productRepository.existsById(id)) {
+            throw new ProductNotFoundException("Product not found with id: " + id);
+        }
+        productRepository.deleteById(id);
+        return true;
+    }
+}
diff --git a/src/main/java/gift/service/impl/UserServiceImpl.java b/src/main/java/gift/service/impl/UserServiceImpl.java
new file mode 100644
index 000000000..a3b2540d4
--- /dev/null
+++ b/src/main/java/gift/service/impl/UserServiceImpl.java
@@ -0,0 +1,40 @@
+package gift.service.impl;
+
+import gift.model.AccessToken;
+import gift.model.Member;
+import gift.repository.AccessTokenRepository;
+import gift.repository.MemberRepository;
+import gift.service.UserService;
+import gift.dto.UserInfo;
+import org.springframework.stereotype.Service;
+
+import java.time.LocalDateTime;
+import java.util.Optional;
+
+@Service
+public class UserServiceImpl implements UserService {
+
+    private final MemberRepository memberRepository;
+    private final AccessTokenRepository accessTokenRepository;
+
+    public UserServiceImpl(MemberRepository memberRepository, AccessTokenRepository accessTokenRepository) {
+        this.memberRepository = memberRepository;
+        this.accessTokenRepository = accessTokenRepository;
+    }
+
+    @Override
+    public void saveUser(String accessToken, UserInfo userInfo) {
+        Optional<Member> memberOptional = memberRepository.findByEmail(userInfo.getEmail());
+        Member member;
+        if (memberOptional.isPresent()) {
+            member = memberOptional.get();
+        }
+        else {
+            member = new Member(userInfo.getEmail(), null, "kakao");
+            memberRepository.save(member);
+        }
+
+        AccessToken token = new AccessToken(member, "kakao", accessToken, LocalDateTime.now().plusHours(1));
+        accessTokenRepository.save(token);
+    }
+}
diff --git a/src/main/java/gift/service/impl/WishServiceImpl.java b/src/main/java/gift/service/impl/WishServiceImpl.java
new file mode 100644
index 000000000..576f354e1
--- /dev/null
+++ b/src/main/java/gift/service/impl/WishServiceImpl.java
@@ -0,0 +1,38 @@
+package gift.service.impl;
+
+import gift.model.Wish;
+import gift.repository.WishRepository;
+import gift.service.WishService;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.stereotype.Service;
+
+@Service
+public class WishServiceImpl implements WishService {
+
+    private final WishRepository wishRepository;
+
+    public WishServiceImpl(WishRepository wishRepository) {
+        this.wishRepository = wishRepository;
+    }
+
+    @Override
+    public Page<Wish> getWishesByMemberId(Long memberId, Pageable pageable) {
+        return wishRepository.findAllByMemberId(memberId, pageable);
+    }
+
+    @Override
+    public Wish addWish(Wish wish) {
+        return wishRepository.save(wish);
+    }
+
+    @Override
+    public boolean removeWish(Long id, Long memberId) {
+        return wishRepository.findByIdAndMemberId(id, memberId)
+            .map(wish -> {
+                wishRepository.delete(wish);
+                return true;
+            })
+            .orElse(false);
+    }
+}
diff --git a/src/main/resources/application.properties b/src/main/resources/application.properties
index 3d16b65f4..a5d4d53d6 100644
--- a/src/main/resources/application.properties
+++ b/src/main/resources/application.properties
@@ -1 +1,13 @@
 spring.application.name=spring-gift
+spring.h2.console.enabled=true
+spring.datasource.url=jdbc:h2:mem:step3
+spring.datasource.username=sa
+spring.sql.init.mode=always
+spring.sql.init.schema-locations=classpath:schema.sql
+spring.sql.init.data-locations=classpath:data.sql
+spring.jpa.hibernate.ddl-auto=none
+jwt.secret=ENC(NlnSYmloxk66BpbC3mOS/vnnxxkZq8GbrRi7dfbOikssvNXNmi9mWJ21iHxVKs7YK6F+HGuCaQQ=)
+jasypt.encryptor.password=Jv9e@2LbXp!8xQ4Zh3#BmA^Wt7kP0Ty
+
+kakao.client-id=c64daff95e3e970a2437628da335af31
+kakao.redirect-uri=http://3.39.251.25:8080/oauth/kakao
diff --git a/src/main/resources/data.sql b/src/main/resources/data.sql
new file mode 100644
index 000000000..8be191177
--- /dev/null
+++ b/src/main/resources/data.sql
@@ -0,0 +1,16 @@
+DELETE FROM category;
+
+INSERT INTO category (name, color, image_url, description) VALUES
+('교환권', '#FF5733', 'https://example.com/image1.png', '교환권 설명'),
+('상품권', '#33FF57', 'https://example.com/image2.png', '상품권 설명'),
+('뷰티', '#3357FF', 'https://example.com/image3.png', '뷰티 설명'),
+('패션', '#FF33A1', 'https://example.com/image4.png', '패션 설명'),
+('식품', '#A133FF', 'https://example.com/image5.png', '식품 설명'),
+('리빙/도서', '#33FFA1', 'https://example.com/image6.png', '리빙/도서 설명'),
+('레저/스포츠', '#FF5733', 'https://example.com/image7.png', '레저/스포츠 설명'),
+('아티스트/캐릭터', '#FF33A1', 'https://example.com/image8.png', '아티스트/캐릭터 설명'),
+('유아동/반려', '#A133FF', 'https://example.com/image9.png', '유아동/반려 설명'),
+('디지털/가전', '#33FFA1', 'https://example.com/image10.png', '디지털/가전 설명'),
+('카카오프렌즈', '#FF5733', 'https://example.com/image11.png', '카카오프렌즈 설명'),
+('트렌드 선물', '#33FF57', 'https://example.com/image12.png', '트렌드 선물 설명'),
+('백화점', '#3357FF', 'https://example.com/image13.png', '백화점 설명');
\ No newline at end of file
diff --git a/src/main/resources/schema.sql b/src/main/resources/schema.sql
new file mode 100644
index 000000000..0c87bdd16
--- /dev/null
+++ b/src/main/resources/schema.sql
@@ -0,0 +1,71 @@
+create table if not exists member (
+    id              BIGINT          not null AUTO_INCREMENT,
+    email           VARCHAR(255)    not null,
+    password        VARCHAR(255),
+    oauth_provider  VARCHAR(255),
+    points          INT             NOT NULL DEFAULT 0,
+    PRIMARY KEY     (id),
+    UNIQUE          (email)
+);
+
+create table if not exists access_token (
+    id              BIGINT          not null AUTO_INCREMENT,
+    member_id       BIGINT          not null,
+    provider        VARCHAR(255)    not null,
+    token           VARCHAR(255)    not null,
+    expiry_date     TIMESTAMP       not null,
+    PRIMARY KEY     (id),
+    FOREIGN KEY     (member_id)     REFERENCES member(id)
+);
+
+create table if not exists category (
+    id              BIGINT          not null AUTO_INCREMENT,
+    name            VARCHAR(255)    not null,
+    color           VARCHAR(7)      not null,
+    image_url       VARCHAR(255)    not null,
+    description     VARCHAR(255),
+    PRIMARY KEY     (id),
+    UNIQUE          (name)
+);
+
+create table if not exists product (
+    id              BIGINT          not null AUTO_INCREMENT,
+    name            VARCHAR(15)     not null,
+    price           INTEGER         not null,
+    image_url       VARCHAR(255)    not null,
+    category_id     BIGINT          not null,
+    PRIMARY KEY     (id),
+    FOREIGN KEY     (category_id)   REFERENCES category(id)
+);
+
+create table if not exists option (
+    id              BIGINT          not null AUTO_INCREMENT,
+    name            VARCHAR(50)     not null,
+    quantity        INTEGER         not null,
+    product_id      BIGINT          not null,
+    PRIMARY KEY     (id),
+    FOREIGN KEY     (product_id)    REFERENCES product(id)
+);
+
+create table if not exists wish (
+    id              BIGINT          not null AUTO_INCREMENT,
+    member_id       BIGINT          not null,
+    product_id      BIGINT          not null,
+    PRIMARY KEY     (id),
+    FOREIGN KEY     (member_id)     REFERENCES member(id),
+    FOREIGN KEY     (product_id)    REFERENCES product(id)
+);
+
+CREATE TABLE IF NOT EXISTS orders (
+    id              BIGINT          NOT NULL AUTO_INCREMENT,
+    option_id       BIGINT          NOT NULL,
+    quantity        INT             NOT NULL,
+    message         VARCHAR(255),
+    order_date_time TIMESTAMP       NOT NULL,
+    cash_receipt    BOOLEAN         NOT NULL,
+    phone_number    VARCHAR(20),
+    payment_amount  INT             NOT NULL,
+    points_used     INT             NOT NULL,
+    PRIMARY KEY     (id),
+    FOREIGN KEY     (option_id)     REFERENCES option(id)
+);
\ No newline at end of file
diff --git a/src/main/resources/static/css/styles.css b/src/main/resources/static/css/styles.css
new file mode 100644
index 000000000..fa2725006
--- /dev/null
+++ b/src/main/resources/static/css/styles.css
@@ -0,0 +1,140 @@
+body {
+    font-family: Arial, sans-serif;
+    background-color: #f8f9fa;
+    margin: 0;
+    padding: 20px;
+}
+
+h1 {
+    color: #343a40;
+}
+
+.container {
+    display: flex;
+    justify-content: flex-end;
+    align-items: center;
+    margin-bottom: 20px;
+}
+
+.table-container {
+    width: 100%;
+}
+
+table {
+    width: 100%;
+    border-collapse: collapse;
+    margin-bottom: 20px;
+}
+
+table, th, td {
+    border: 1px solid #dee2e6;
+}
+
+th, td {
+    padding: 12px;
+    text-align: left;
+}
+
+th {
+    background-color: #343a40;
+    color: white;
+    text-align: center;
+}
+
+tr:nth-child(even) {
+    background-color: #f2f2f2;
+}
+
+button {
+    padding: 10px 20px;
+    margin: 5px;
+    border: none;
+    color: white;
+    cursor: pointer;
+    border-radius: 5px;
+    text-align: center;
+}
+
+button:hover {
+    opacity: 0.8;
+}
+
+button.add-btn {
+    background-color: #ffa500;
+}
+
+button.edit-btn, button.save-btn {
+    background-color: #28a745;
+}
+
+button.delete-btn {
+    background-color: #dc3545;
+}
+
+button:disabled {
+    background-color: #6c757d;
+}
+
+.edit-input {
+    width: 100%;
+    box-sizing: border-box;
+    padding: 10px;
+    margin: 5px 0;
+}
+
+.button-group {
+    display: flex;
+    justify-content: center;
+    gap: 10px;
+}
+
+td[colspan="6"] {
+    text-align: center;
+}
+
+.actions-column {
+    width: 200px;
+    text-align: center;
+}
+
+.pagination {
+    display: flex;
+    justify-content: center;
+    align-items: center;
+    margin-top: 20px;
+}
+
+.pagination a {
+    padding: 10px 20px;
+    margin: 5px;
+    border: none;
+    color: white;
+    background-color: #007bff;
+    cursor: pointer;
+    border-radius: 5px;
+    text-decoration: none;
+    text-align: center;
+    display: inline-block;
+}
+
+.pagination a:hover {
+    background-color: #0056b3;
+}
+
+.form-group {
+    display: flex;
+    align-items: center;
+    margin-bottom: 15px;
+}
+
+.form-group label {
+    flex: 0 0 100px;
+    margin-bottom: 0;
+}
+
+.form-group input {
+    flex: 1;
+    padding: 8px;
+    box-sizing: border-box;
+}
+
diff --git a/src/main/resources/static/js/product-management.js b/src/main/resources/static/js/product-management.js
new file mode 100644
index 000000000..83df8e10f
--- /dev/null
+++ b/src/main/resources/static/js/product-management.js
@@ -0,0 +1,136 @@
+$(document).ready(function() {
+    function loadCategories(callback) {
+        $.ajax({
+            url: '/api/categories',
+            type: 'GET',
+            success: function(response) {
+                if (response.success && response.data.length > 0) {
+                    callback(response.data);
+                } else {
+                    alert("No categories found.");
+                }
+            },
+            error: function() {
+                alert("Error fetching categories.");
+            }
+        });
+    }
+
+    $("#addProductBtn").click(function() {
+        loadCategories(function(categories) {
+            let categorySelect = $('#category');
+            categorySelect.empty();
+            categories.forEach(function(category) {
+                categorySelect.append(new Option(category.name, category.id));
+            });
+        });
+
+        $("#addProductModal").dialog({
+            modal: true,
+            width: 400,
+            buttons: {
+                "Add": function() {
+                    let name = $("#name").val();
+                    let price = $("#price").val();
+                    let imageUrl = $("#imageUrl").val();
+                    let categoryId = $("#category").val();
+
+                    if (name && price && imageUrl && categoryId) {
+                        let newProduct = {
+                            name: name,
+                            price: price,
+                            imageUrl: imageUrl,
+                            category: { id: categoryId }
+                        };
+
+                        $.ajax({
+                            url: '/api/products',
+                            type: 'POST',
+                            contentType: 'application/json',
+                            data: JSON.stringify(newProduct),
+                            success: function() {
+                                window.location.href = '/admin/products';
+                            },
+                            error: function() {
+                                alert("Error adding product.");
+                            }
+                        });
+                    } else {
+                        alert("All fields are required!");
+                    }
+                },
+                "Cancel": function() {
+                    $(this).dialog("close");
+                }
+            }
+        });
+    });
+
+    $(".edit-btn").click(function() {
+        let row = $(this).closest("tr");
+        row.find(".display-text").hide();
+        row.find(".edit-input").show();
+        $(this).hide();
+        row.find(".save-btn").show();
+
+        let categorySelect = row.find(".edit-input").eq(3);
+        let currentCategoryId = row.find(".display-text").eq(3).data("category-id");
+
+        loadCategories(function(categories) {
+            categorySelect.empty();
+            categories.forEach(function(category) {
+                let option = new Option(category.name, category.id);
+                if (category.id == currentCategoryId) {
+                    option.selected = true;
+                }
+                categorySelect.append(option);
+            });
+        });
+    });
+
+    $(document).on("click", ".save-btn", function() {
+        let row = $(this).closest("tr");
+        let id = row.data("id");
+        let name = row.find(".edit-input").eq(0).val();
+        let price = row.find(".edit-input").eq(1).val();
+        let imageUrl = row.find(".edit-input").eq(2).val();
+        let categoryId = row.find(".edit-input").eq(3).val();
+
+        let updatedProduct = {
+            id: id,
+            name: name,
+            price: price,
+            imageUrl: imageUrl,
+            category: { id: categoryId }
+        };
+
+        $.ajax({
+            url: '/api/products/' + id,
+            type: 'PUT',
+            contentType: 'application/json',
+            data: JSON.stringify(updatedProduct),
+            success: function() {
+                window.location.href = '/admin/products';
+            },
+            error: function() {
+                alert("Error updating product.");
+            }
+        });
+    });
+
+    $(document).on("click", ".delete-btn", function() {
+        let row = $(this).closest("tr");
+        let id = row.data("id");
+
+        $.ajax({
+            url: '/api/products/' + id,
+            type: 'DELETE',
+            success: function() {
+                window.location.href = '/admin/products';
+            },
+            error: function() {
+                alert("Error deleting product.");
+            }
+        });
+    });
+});
diff --git a/src/main/resources/templates/login.html b/src/main/resources/templates/login.html
new file mode 100644
index 000000000..9f756084e
--- /dev/null
+++ b/src/main/resources/templates/login.html
@@ -0,0 +1,24 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <title>Kakao Login</title>
+    <style>
+        .kakao-login-btn {
+            display: inline-block;
+            background-color: #FEE500;
+            color: #000000;
+            padding: 10px 20px;
+            border-radius: 5px;
+            text-decoration: none;
+            font-weight: bold;
+        }
+    </style>
+</head>
+<body>
+<h1>Login with Kakao</h1>
+<a href="https://kauth.kakao.com/oauth/authorize?response_type=code&redirect_uri=http://3.39.251.25:8080/oauth/kakao&client_id=c64daff95e3e970a2437628da335af31" class="kakao-login-btn">
+    Login with Kakao
+</a>
+</body>
+</html>
diff --git a/src/main/resources/templates/order.html b/src/main/resources/templates/order.html
new file mode 100644
index 000000000..43656553a
--- /dev/null
+++ b/src/main/resources/templates/order.html
@@ -0,0 +1,89 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <title>Order Page</title>
+</head>
+<body>
+<h1>Place an Order</h1>
+<form id="orderForm">
+    <label for="optionId">Option ID:</label>
+    <input type="number" id="optionId" name="optionId" required>
+    <br>
+    <label for="quantity">Quantity:</label>
+    <input type="number" id="quantity" name="quantity" required>
+    <br>
+    <label for="message">Message:</label>
+    <textarea id="message" name="message" required></textarea>
+    <br>
+    <button type="submit">Place Order</button>
+</form>
+
+<script>
+    document.getElementById('orderForm').addEventListener('submit', function(event) {
+        event.preventDefault();
+        const optionId = document.getElementById('optionId').value;
+        const quantity = document.getElementById('quantity').value;
+        const message = document.getElementById('message').value;
+        const accessToken = sessionStorage.getItem('accessToken');
+
+        if (!accessToken) {
+            alert('Access token is missing. Please log in.');
+            return;
+        }
+
+        const order = {
+            optionId: optionId,
+            quantity: quantity,
+            message: message
+        };
+
+        fetch('/api/orders', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Authorization': 'Bearer ' + accessToken
+            },
+            body: JSON.stringify(order)
+        })
+            .then(response => response.json())
+            .then(data => {
+                if (data.success) {
+                    alert('Order placed successfully');
+                    // Send the message
+                    sendMessage(data.data.id, message, accessToken);
+                } else {
+                    alert('Failed to place order: ' + data.message);
+                }
+            })
+            .catch(error => {
+                console.error('Error:', error);
+                alert('Failed to place order: ' + error.message);
+            });
+    });
+
+    function sendMessage(orderId, message, accessToken) {
+        fetch('/api/orders/sendMessage', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Authorization': 'Bearer ' + accessToken
+            },
+            body: JSON.stringify({ message: `Order ID: ${orderId}, Message: ${message}` })
+        })
+            .then(response => response.json())
+            .then(data => {
+                if (data.success) {
+                    alert('Message sent successfully');
+                } else {
+                    alert('Failed to send message: ' + data.message);
+                }
+            })
+            .catch(error => {
+                console.error('Error:', error);
+                alert('Failed to send message: ' + error.message);
+            });
+    }
+</script>
+</body>
+</html>
diff --git a/src/main/resources/templates/products_admin.html b/src/main/resources/templates/products_admin.html
new file mode 100644
index 000000000..c7ed97c21
--- /dev/null
+++ b/src/main/resources/templates/products_admin.html
@@ -0,0 +1,98 @@
+<!DOCTYPE html>
+<html xmlns:th="http://www.thymeleaf.org" lang="ko">
+<head>
+    <title>Management Products</title>
+    <link rel="stylesheet" type="text/css" href="/css/styles.css">
+    <script src="https://code.jquery.com/jquery-3.6.0.min.js"></script>
+    <link rel="stylesheet" href="https://code.jquery.com/ui/1.12.1/themes/base/jquery-ui.css">
+    <script src="https://code.jquery.com/ui/1.12.1/jquery-ui.min.js"></script>
+    <style>
+        .edit-input {
+            display: none;
+        }
+    </style>
+</head>
+<body>
+<h1>Management Products_부산대 BE_박민재</h1>
+<div class="container">
+    <button id="addProductBtn" class="add-btn">Add New Product</button>
+</div>
+<div class="table-container">
+    <table>
+        <thead>
+        <tr>
+            <th>ID</th>
+            <th>Name</th>
+            <th>Price</th>
+            <th>ImageUrl</th>
+            <th>Category</th>
+            <th class="actions-column">Actions</th>
+        </tr>
+        </thead>
+        <tbody>
+        <tr th:if="${#lists.isEmpty(products)}">
+            <td colspan="6">데이터가 존재하지 않습니다</td>
+        </tr>
+        <tr th:each="product : ${products}" th:attr="data-id=${product.id}">
+            <td th:text="${product.id}">0</td>
+            <td>
+                <span class="display-text" th:text="${product.name}">Sample Name</span>
+                <input class="edit-input" type="text" th:value="${product.name}" />
+            </td>
+            <td>
+                <span class="display-text" th:text="${product.price}">0.0</span>
+                <input class="edit-input" type="text" th:value="${product.price}" />
+            </td>
+            <td>
+                <span class="display-text" th:text="${product.imageUrl}">Sample Url</span>
+                <input class="edit-input" type="text" th:value="${product.imageUrl}" />
+            </td>
+            <td>
+                <span class="display-text" th:text="${product.category.name}">Sample Category</span>
+                <select class="edit-input" style="display: none;"></select>
+            </td>
+            <td class="actions-column">
+                <div class="button-group">
+                    <button class="edit-btn">Edit</button>
+                    <button class="save-btn" style="display: none;">Save</button>
+                    <button class="delete-btn">Delete</button>
+                </div>
+            </td>
+        </tr>
+        </tbody>
+    </table>
+</div>
+<div class="pagination">
+    <span th:if="${currentPage > 0}">
+        <a th:href="@{/admin/products(page=${currentPage - 1}, size=${pageSize})}">Previous</a>
+    </span>
+    <span th:if="${currentPage < totalPages - 1}">
+        <a th:href="@{/admin/products(page=${currentPage + 1}, size=${pageSize})}">Next</a>
+    </span>
+</div>
+
+<!-- Add Product Modal -->
+<div id="addProductModal" title="Add New Product" style="display: none;">
+    <form id="addProductForm">
+        <div class="form-group">
+            <label for="name">Name:</label>
+            <input type="text" id="name" name="name" />
+        </div>
+        <div class="form-group">
+            <label for="price">Price:</label>
+            <input type="text" id="price" name="price" />
+        </div>
+        <div class="form-group">
+            <label for="imageUrl">ImageUrl:</label>
+            <input type="text" id="imageUrl" name="imageUrl" />
+        </div>
+        <div class="form-group">
+            <label for="category">Category:</label>
+            <select id="category" name="category"></select>
+        </div>
+    </form>
+</div>
+
+<script src="/js/product-management.js"></script>
+</body>
+</html>
diff --git a/src/test/java/gift/controller/ProductControllerTest.java b/src/test/java/gift/controller/ProductControllerTest.java
new file mode 100644
index 000000000..237a8bdc0
--- /dev/null
+++ b/src/test/java/gift/controller/ProductControllerTest.java
@@ -0,0 +1,212 @@
+package gift.controller;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import gift.exception.ForbiddenWordException;
+import gift.exception.ProductNotFoundException;
+import gift.model.Category;
+import gift.model.Option;
+import gift.model.Product;
+import gift.service.ProductService;
+import gift.service.MemberService;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest;
+import org.springframework.boot.test.mock.mockito.MockBean;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.PageImpl;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.data.domain.Pageable;
+import org.springframework.http.MediaType;
+import org.springframework.test.web.servlet.MockMvc;
+
+import java.util.Arrays;
+import java.util.List;
+
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyLong;
+import static org.mockito.Mockito.*;
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;
+
+@WebMvcTest(ProductController.class)
+@ExtendWith(MockitoExtension.class)
+public class ProductControllerTest {
+
+    @Autowired
+    private MockMvc mockMvc;
+
+    @MockBean
+    private ProductService productService;
+
+    @MockBean
+    private MemberService memberService;
+
+    @Autowired
+    private ObjectMapper objectMapper;
+
+    private Product testProduct;
+    private Category testCategory;
+    private Option option1;
+    private Option option2;
+
+    @BeforeEach
+    public void setUp() {
+        testCategory = new Category();
+        testCategory.setId(1L);
+        testCategory.setName("Test Category");
+        testCategory.setColor("#FFFFFF");
+        testCategory.setImageUrl("http://example.com/image.jpg");
+
+        testProduct = new Product();
+        testProduct.setId(1L);
+        testProduct.setName("Test Product");
+        testProduct.setPrice(1000);
+        testProduct.setImageUrl("http://example.com/product_image.jpg");
+        testProduct.setCategory(testCategory);
+
+        option1 = new Option();
+        option1.setName("Option 1");
+        option1.setQuantity(10);
+        option1.setProduct(testProduct);
+
+        option2 = new Option();
+        option2.setName("Option 2");
+        option2.setQuantity(20);
+        option2.setProduct(testProduct);
+
+        testProduct.setOptions(Arrays.asList(option1, option2));
+    }
+
+    @Test
+    public void testGetAllProducts_Success() throws Exception {
+        Pageable pageable = PageRequest.of(0, 10);
+        Page<Product> products = new PageImpl<>(List.of(testProduct), pageable, 1);
+
+        when(productService.getProducts(any(Pageable.class), any())).thenReturn(products);
+
+        mockMvc.perform(get("/api/products")
+                .param("categoryId", "1")
+                .param("page", "0")
+                .param("size", "10")
+                .param("sort", "name,asc")
+                .contentType(MediaType.APPLICATION_JSON))
+            .andExpect(status().isOk())
+            .andExpect(jsonPath("$.success").value(true))
+            .andExpect(jsonPath("$.data.content[0].name").value(testProduct.getName()));
+    }
+
+    @Test
+    public void testGetProductById_Success() throws Exception {
+        when(productService.getProductById(anyLong())).thenReturn(testProduct);
+
+        mockMvc.perform(get("/api/products/{id}", testProduct.getId())
+                .contentType(MediaType.APPLICATION_JSON))
+            .andExpect(status().isOk())
+            .andExpect(jsonPath("$.success").value(true))
+            .andExpect(jsonPath("$.data.name").value(testProduct.getName()));
+    }
+
+    @Test
+    public void testGetProductById_NotFound() throws Exception {
+        when(productService.getProductById(anyLong())).thenThrow(new ProductNotFoundException("Product not found"));
+
+        mockMvc.perform(get("/api/products/{id}", 99L)
+                .contentType(MediaType.APPLICATION_JSON))
+            .andExpect(status().isNotFound())
+            .andExpect(jsonPath("$.success").value(false))
+            .andExpect(jsonPath("$.message").value("Product not found"))
+            .andExpect(jsonPath("$.errorCode").value("404"));
+    }
+
+    @Test
+    public void testCreateProduct_Success() throws Exception {
+        when(productService.createProduct(any(Product.class))).thenReturn(true);
+
+        mockMvc.perform(post("/api/products")
+                .contentType(MediaType.APPLICATION_JSON)
+                .content(objectMapper.writeValueAsString(testProduct)))
+            .andExpect(status().isCreated())
+            .andExpect(jsonPath("$.success").value(true))
+            .andExpect(jsonPath("$.data.name").value(testProduct.getName()));
+    }
+
+    @Test
+    public void testCreateProduct_ForbiddenWord() throws Exception {
+        testProduct.setName("카카오 상품");
+        when(productService.createProduct(any(Product.class)))
+            .thenThrow(new ForbiddenWordException("상품 이름에 '카카오'가 포함된 경우 담당 MD와 협의가 필요합니다."));
+
+        mockMvc.perform(post("/api/products")
+                .contentType(MediaType.APPLICATION_JSON)
+                .content(objectMapper.writeValueAsString(testProduct)))
+            .andExpect(status().isBadRequest())  // 400을 예상
+            .andExpect(jsonPath("$.success").value(false))
+            .andExpect(jsonPath("$.message").value("상품 이름에 '카카오'가 포함된 경우 담당 MD와 협의가 필요합니다."))
+            .andExpect(jsonPath("$.errorCode").value("400"));  // 올바른 경로 사용
+    }
+
+    @Test
+    public void testUpdateProduct_Success() throws Exception {
+        Product updatedProduct = new Product();
+        updatedProduct.setId(1L);
+        updatedProduct.setName("Updated Product");
+        updatedProduct.setPrice(1200);
+        updatedProduct.setImageUrl("http://example.com/updated_product_image.jpg");
+        updatedProduct.setCategory(testCategory);
+        updatedProduct.setOptions(Arrays.asList(option1, option2));
+
+        when(productService.updateProduct(anyLong(), any(Product.class))).thenReturn(true);
+        when(productService.getProductById(anyLong())).thenReturn(updatedProduct);
+
+        mockMvc.perform(put("/api/products/{id}", testProduct.getId())
+                .contentType(MediaType.APPLICATION_JSON)
+                .content(objectMapper.writeValueAsString(updatedProduct)))
+            .andExpect(status().isOk())
+            .andExpect(jsonPath("$.success").value(true))
+            .andExpect(jsonPath("$.data.name").value("Updated Product"));
+    }
+
+    @Test
+    public void testUpdateProduct_NotFound() throws Exception {
+        doThrow(new ProductNotFoundException("Product not found with id: 99"))
+            .when(productService).updateProduct(eq(99L), any(Product.class));
+
+        Product updatedProduct = new Product();
+        updatedProduct.setName("Updated Product");
+        updatedProduct.setPrice(1200);
+        updatedProduct.setImageUrl("http://example.com/updated_product_image.jpg");
+        updatedProduct.setCategory(testCategory);
+        updatedProduct.setOptions(Arrays.asList(option1, option2));
+
+        mockMvc.perform(put("/api/products/{id}", 99L)
+                .contentType(MediaType.APPLICATION_JSON)
+                .content(objectMapper.writeValueAsString(updatedProduct)))
+            .andExpect(status().isNotFound())
+            .andExpect(jsonPath("$.success").value(false))
+            .andExpect(jsonPath("$.message").value("Product not found with id: 99"));
+    }
+
+    @Test
+    public void testDeleteProduct_Success() throws Exception {
+        when(productService.deleteProduct(anyLong())).thenReturn(true);
+
+        mockMvc.perform(delete("/api/products/{id}", testProduct.getId())
+                .contentType(MediaType.APPLICATION_JSON))
+            .andExpect(status().isNoContent());
+    }
+
+    @Test
+    public void testDeleteProduct_NotFound() throws Exception {
+        doThrow(new ProductNotFoundException("Product not found with id: 99"))
+            .when(productService).deleteProduct(99L);
+
+        mockMvc.perform(delete("/api/products/{id}", 99L)
+                .contentType(MediaType.APPLICATION_JSON))
+            .andExpect(status().isNotFound())
+            .andExpect(jsonPath("$.success").value(false))
+            .andExpect(jsonPath("$.message").value("Product not found with id: 99"));
+    }
+}
diff --git a/src/test/java/gift/repository/MemberRepositoryTest.java b/src/test/java/gift/repository/MemberRepositoryTest.java
new file mode 100644
index 000000000..e051a77a5
--- /dev/null
+++ b/src/test/java/gift/repository/MemberRepositoryTest.java
@@ -0,0 +1,60 @@
+package gift.repository;
+
+import gift.model.Member;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.AfterEach;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.util.Optional;
+
+@DataJpaTest
+public class MemberRepositoryTest {
+
+    @Autowired
+    private MemberRepository memberRepository;
+
+    private Member testMember;
+
+    @BeforeEach
+    public void setUp() {
+        testMember = new Member();
+        testMember.setEmail("test@example.com");
+        testMember.setPassword("password");
+        memberRepository.save(testMember);
+    }
+
+    @AfterEach
+    public void tearDown() {
+        memberRepository.deleteAll();
+    }
+
+    @Test
+    public void testFindByEmail_Success() {
+        Optional<Member> foundMember = memberRepository.findByEmail("test@example.com");
+        assertThat(foundMember).isPresent();
+        assertThat(foundMember.get().getEmail()).isEqualTo(testMember.getEmail());
+    }
+
+    @Test
+    public void testFindByEmail_NotFound() {
+        Optional<Member> foundMember = memberRepository.findByEmail("notfound@example.com");
+        assertThat(foundMember).isNotPresent();
+    }
+
+    @Test
+    public void testSaveMember() {
+        Member newMember = new Member();
+        newMember.setEmail("new@example.com");
+        newMember.setPassword("newpassword");
+
+        Member savedMember = memberRepository.save(newMember);
+
+        assertThat(savedMember).isNotNull();
+        assertThat(savedMember.getId()).isNotNull();
+        assertThat(savedMember.getEmail()).isEqualTo("new@example.com");
+    }
+}
diff --git a/src/test/java/gift/repository/ProductRepositoryTest.java b/src/test/java/gift/repository/ProductRepositoryTest.java
new file mode 100644
index 000000000..650ce184a
--- /dev/null
+++ b/src/test/java/gift/repository/ProductRepositoryTest.java
@@ -0,0 +1,112 @@
+package gift.repository;
+
+import gift.model.Category;
+import gift.model.Option;
+import gift.model.Product;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.data.domain.Pageable;
+import org.springframework.test.context.ActiveProfiles;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.Optional;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+@DataJpaTest
+@ActiveProfiles("test")
+public class ProductRepositoryTest {
+
+    @Autowired
+    private ProductRepository productRepository;
+
+    @Autowired
+    private CategoryRepository categoryRepository;
+
+    @Autowired
+    private OptionRepository optionRepository;
+
+    private Product testProduct;
+    private Category testCategory;
+
+    @BeforeEach
+    public void setUp() {
+        testCategory = new Category();
+        testCategory.setName("Test Category");
+        testCategory.setColor("#FFFFFF");
+        testCategory.setImageUrl("http://example.com/image.jpg");
+        testCategory.setDescription("This is a test category.");
+        categoryRepository.save(testCategory);
+
+        testProduct = new Product();
+        testProduct.setName("Test Product");
+        testProduct.setPrice(1000);
+        testProduct.setImageUrl("http://example.com/product_image.jpg");
+        testProduct.setCategory(testCategory);
+
+        Option option1 = new Option();
+        option1.setName("Option 1");
+        option1.setQuantity(10);
+        option1.setProduct(testProduct);
+
+        Option option2 = new Option();
+        option2.setName("Option 2");
+        option2.setQuantity(20);
+        option2.setProduct(testProduct);
+
+        testProduct.setOptions(Arrays.asList(option1, option2));
+
+        productRepository.save(testProduct);
+        optionRepository.save(option1);
+        optionRepository.save(option2);
+    }
+
+    @Test
+    public void testFindById_Success() {
+        Optional<Product> foundProduct = productRepository.findById(testProduct.getId());
+        assertThat(foundProduct).isPresent();
+        assertThat(foundProduct.get().getName()).isEqualTo(testProduct.getName());
+    }
+
+    @Test
+    public void testFindByCategoryId_Success() {
+        Pageable pageable = PageRequest.of(0, 10);
+        List<Product> products = productRepository.findAllByCategoryId(testCategory.getId(), pageable).getContent();
+        assertThat(products).isNotEmpty();
+        assertThat(products.getFirst().getCategory().getId()).isEqualTo(testCategory.getId());
+    }
+
+    @Test
+    public void testSaveProduct_Success() {
+        Product newProduct = new Product();
+        newProduct.setName("New Product");
+        newProduct.setPrice(2000);
+        newProduct.setImageUrl("http://example.com/new_product_image.jpg");
+        newProduct.setCategory(testCategory);
+
+        Option newOption = new Option();
+        newOption.setName("New Option");
+        newOption.setQuantity(5);
+        newOption.setProduct(newProduct);
+
+        newProduct.setOptions(List.of(newOption));
+
+        productRepository.save(newProduct);
+        optionRepository.save(newOption);
+
+        Optional<Product> savedProduct = productRepository.findById(newProduct.getId());
+        assertThat(savedProduct).isPresent();
+        assertThat(savedProduct.get().getName()).isEqualTo("New Product");
+    }
+
+    @Test
+    public void testDeleteProduct_Success() {
+        productRepository.deleteById(testProduct.getId());
+        Optional<Product> deletedProduct = productRepository.findById(testProduct.getId());
+        assertThat(deletedProduct).isNotPresent();
+    }
+}
diff --git a/src/test/java/gift/repository/WishRepositoryTest.java b/src/test/java/gift/repository/WishRepositoryTest.java
new file mode 100644
index 000000000..af8391cbf
--- /dev/null
+++ b/src/test/java/gift/repository/WishRepositoryTest.java
@@ -0,0 +1,91 @@
+package gift.repository;
+
+import gift.model.*;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest;
+import org.springframework.data.domain.Pageable;
+import org.springframework.test.context.ActiveProfiles;
+
+import java.util.Collections;
+import java.util.Optional;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+@DataJpaTest
+@ActiveProfiles("test") // 테스트 프로파일 사용
+public class WishRepositoryTest {
+
+    @Autowired
+    private WishRepository wishRepository;
+
+    @Autowired
+    private MemberRepository memberRepository;
+
+    @Autowired
+    private ProductRepository productRepository;
+
+    private Wish testWish;
+    private Member testMember;
+    private Product testProduct;
+    private Option testOption;
+    private Category testCategory;
+
+    @BeforeEach
+    public void setUp() {
+        testCategory = new Category();
+        testCategory.setId(1L);
+        testCategory.setName("Test Category");
+        testCategory.setColor("#FFFFFF");
+        testCategory.setImageUrl("http://example.com/image.jpg");
+
+        // 멤버 생성
+        testMember = new Member();
+        testMember.setEmail("test@example.com");
+        testMember.setPassword("password");
+        memberRepository.save(testMember);
+
+        // 제품 생성
+        testProduct = new Product();
+        testProduct.setName("Test Product");
+        testProduct.setPrice(1000);
+        testProduct.setImageUrl("http://example.com/image.jpg");
+        testProduct.setCategory(testCategory);
+
+        // 옵션 생성
+        testOption = new Option();
+        testOption.setName("Test Option");
+        testOption.setQuantity(10);
+        testOption.setProduct(testProduct);
+
+        // 제품에 옵션 설정
+        testProduct.setOptions(Collections.singletonList(testOption));
+        productRepository.save(testProduct);
+
+        // 위시 생성
+        testWish = new Wish();
+        testWish.setMember(testMember);
+        testWish.setProduct(testProduct);
+        wishRepository.save(testWish);
+    }
+
+    @Test
+    public void testFindAllByMemberId_Success() {
+        assertThat(wishRepository.findAllByMemberId(testMember.getId(), Pageable.unpaged()).getContent()).hasSize(1);
+    }
+
+    @Test
+    public void testFindByIdAndMemberId_Success() {
+        Optional<Wish> foundWish = wishRepository.findByIdAndMemberId(testWish.getId(), testMember.getId());
+        assertThat(foundWish).isPresent();
+        assertThat(foundWish.get().getProduct().getName()).isEqualTo(testProduct.getName());
+    }
+
+    @Test
+    public void testDeleteByMemberAndProduct_Success() {
+        wishRepository.deleteByMemberAndProduct(testMember, testProduct);
+        Optional<Wish> deletedWish = wishRepository.findById(testWish.getId());
+        assertThat(deletedWish).isNotPresent();
+    }
+}
diff --git a/src/test/java/gift/service/impl/MemberServiceImplTest.java b/src/test/java/gift/service/impl/MemberServiceImplTest.java
new file mode 100644
index 000000000..eedbb05b6
--- /dev/null
+++ b/src/test/java/gift/service/impl/MemberServiceImplTest.java
@@ -0,0 +1,126 @@
+package gift.service.impl;
+
+import gift.model.Member;
+import gift.repository.MemberRepository;
+import io.jsonwebtoken.Claims;
+import io.jsonwebtoken.Jwts;
+import io.jsonwebtoken.security.Keys;
+import org.junit.jupiter.api.BeforeEach;
+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.mindrot.jbcrypt.BCrypt;
+
+import java.lang.reflect.Field;
+import java.nio.charset.StandardCharsets;
+import java.util.Optional;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyLong;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.BDDMockito.given;
+import static org.mockito.Mockito.when;
+
+@ExtendWith(MockitoExtension.class)
+public class MemberServiceImplTest {
+
+    @Mock
+    private MemberRepository memberRepository;
+
+    @InjectMocks
+    private MemberServiceImpl memberService;
+
+    private Member testMember;
+
+    private final String secretKey = "ThisIsASecretKeyForJwtTokenThatIsVerySecure1234567890";
+
+    @BeforeEach
+    public void setUp() throws Exception {
+        testMember = new Member();
+        testMember.setId(1L);
+        testMember.setEmail("test@example.com");
+        testMember.setPassword(BCrypt.hashpw("password", BCrypt.gensalt()));
+
+        Field secretKeyField = MemberServiceImpl.class.getDeclaredField("secretKey");
+        secretKeyField.setAccessible(true);
+        secretKeyField.set(memberService, secretKey);
+    }
+
+    @Test
+    public void testRegisterMember_Success() {
+        given(memberRepository.save(any(Member.class))).willReturn(testMember);
+
+        Optional<String> tokenOptional = memberService.registerMember(testMember);
+
+        assertThat(tokenOptional).isPresent();
+        String token = tokenOptional.get();
+
+        Claims claims = Jwts.parser()
+            .verifyWith(Keys.hmacShaKeyFor(secretKey.getBytes(StandardCharsets.UTF_8)))
+            .build()
+            .parseSignedClaims(token)
+            .getPayload();
+
+        assertThat(claims.getSubject()).isEqualTo(testMember.getId().toString());
+        assertThat(claims.get("email")).isEqualTo(testMember.getEmail());
+    }
+
+    @Test
+    public void testLogin_Success() {
+        when(memberRepository.findByEmail(anyString())).thenReturn(Optional.of(testMember));
+
+        Optional<String> tokenOptional = memberService.login("test@example.com", "password");
+
+        assertThat(tokenOptional).isPresent();
+        String token = tokenOptional.get();
+
+        Claims claims = Jwts.parser()
+            .verifyWith(Keys.hmacShaKeyFor(secretKey.getBytes(StandardCharsets.UTF_8)))
+            .build()
+            .parseSignedClaims(token)
+            .getPayload();
+
+        assertThat(claims.getSubject()).isEqualTo(testMember.getId().toString());
+        assertThat(claims.get("email")).isEqualTo(testMember.getEmail());
+    }
+
+    @Test
+    public void testLogin_InvalidPassword() {
+        when(memberRepository.findByEmail(anyString())).thenReturn(Optional.of(testMember));
+
+        Optional<String> tokenOptional = memberService.login("test@example.com", "wrongpassword");
+
+        assertThat(tokenOptional).isNotPresent();
+    }
+
+    @Test
+    public void testLogin_EmailNotFound() {
+        when(memberRepository.findByEmail(anyString())).thenReturn(Optional.empty());
+
+        Optional<String> tokenOptional = memberService.login("notfound@example.com", "password");
+
+        assertThat(tokenOptional).isNotPresent();
+    }
+
+    @Test
+    public void testFindById_Success() {
+        when(memberRepository.findById(anyLong())).thenReturn(Optional.of(testMember));
+
+        Optional<Member> foundMember = memberService.findById(1L);
+
+        assertThat(foundMember).isPresent();
+        assertThat(foundMember.get().getEmail()).isEqualTo(testMember.getEmail());
+    }
+
+    @Test
+    public void testFindById_NotFound() {
+        when(memberRepository.findById(anyLong())).thenReturn(Optional.empty());
+
+        Optional<Member> foundMember = memberService.findById(999L);
+
+        assertThat(foundMember).isNotPresent();
+    }
+}
diff --git a/src/test/java/gift/service/impl/ProductServiceImplTest.java b/src/test/java/gift/service/impl/ProductServiceImplTest.java
new file mode 100644
index 000000000..bc49df81b
--- /dev/null
+++ b/src/test/java/gift/service/impl/ProductServiceImplTest.java
@@ -0,0 +1,130 @@
+package gift.service.impl;
+
+import gift.exception.ForbiddenWordException;
+import gift.model.Category;
+import gift.model.Option;
+import gift.model.Product;
+import gift.repository.OptionRepository;
+import gift.repository.ProductRepository;
+import org.junit.jupiter.api.BeforeEach;
+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.Arrays;
+import java.util.Optional;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyLong;
+import static org.mockito.Mockito.*;
+
+@ExtendWith(MockitoExtension.class)
+public class ProductServiceImplTest {
+
+    @Mock
+    private ProductRepository productRepository;
+
+    @Mock
+    private OptionRepository optionRepository;
+
+    @InjectMocks
+    private ProductServiceImpl productService;
+
+    private Product testProduct;
+    private Category testCategory;
+    private Option option1;
+    private Option option2;
+
+    public ProductServiceImplTest() {
+    }
+
+    @BeforeEach
+    public void setUp() {
+        testCategory = new Category();
+        testCategory.setId(1L);
+        testCategory.setName("Test Category");
+        testCategory.setColor("#FFFFFF");
+        testCategory.setImageUrl("http://example.com/image.jpg");
+
+        testProduct = new Product();
+        testProduct.setId(1L);
+        testProduct.setName("Test Product");
+        testProduct.setPrice(1000);
+        testProduct.setImageUrl("http://example.com/product_image.jpg");
+        testProduct.setCategory(testCategory);
+
+        option1 = new Option();
+        option1.setName("Option 1");
+        option1.setQuantity(10);
+        option1.setProduct(testProduct);
+
+        option2 = new Option();
+        option2.setName("Option 2");
+        option2.setQuantity(20);
+        option2.setProduct(testProduct);
+
+        testProduct.setOptions(Arrays.asList(option1, option2));
+    }
+
+    @Test
+    public void testCreateProduct_Success() {
+        when(productRepository.save(any(Product.class))).thenReturn(testProduct);
+        when(optionRepository.save(any(Option.class))).thenAnswer(invocation -> invocation.getArgument(0));
+
+        boolean success = productService.createProduct(testProduct);
+
+        assertThat(success).isTrue();
+        verify(productRepository, times(1)).save(any(Product.class));
+        verify(optionRepository, times(2)).save(any(Option.class));
+    }
+
+    @Test
+    public void testCreateProduct_ForbiddenWord() {
+        testProduct.setName("카카오 상품");
+
+        assertThatThrownBy(() -> productService.createProduct(testProduct))
+            .isInstanceOf(ForbiddenWordException.class)
+            .hasMessage("상품 이름에 '카카오'가 포함된 경우 담당 MD와 협의가 필요합니다.");
+    }
+
+    @Test
+    public void testUpdateProduct_Success() {
+        when(productRepository.findById(anyLong())).thenReturn(Optional.of(testProduct));
+        when(productRepository.save(any(Product.class))).thenReturn(testProduct);
+        when(optionRepository.save(any(Option.class))).thenAnswer(invocation -> invocation.getArgument(0));
+
+        Product updatedProduct = new Product();
+        updatedProduct.setName("Updated Product");
+        updatedProduct.setPrice(1200);
+        updatedProduct.setImageUrl("http://example.com/updated_product_image.jpg");
+        updatedProduct.setCategory(testCategory);
+        updatedProduct.setOptions(Arrays.asList(option1, option2));
+
+        boolean success = productService.updateProduct(testProduct.getId(), updatedProduct);
+
+        assertThat(success).isTrue();
+        verify(productRepository, times(1)).findById(anyLong());
+        verify(productRepository, times(1)).save(any(Product.class));
+        verify(optionRepository, times(2)).save(any(Option.class));
+        verify(optionRepository, times(1)).deleteAll(anyIterable());
+    }
+
+    @Test
+    public void testUpdateProduct_NotFound() {
+        when(productRepository.findById(anyLong())).thenReturn(Optional.empty());
+
+        Product updatedProduct = new Product();
+        updatedProduct.setName("Updated Product");
+
+        boolean success = productService.updateProduct(1L, updatedProduct);
+
+        assertThat(success).isFalse();
+        verify(productRepository, times(1)).findById(anyLong());
+        verify(productRepository, never()).save(any(Product.class));
+        verify(optionRepository, never()).deleteAll(anyIterable());
+    }
+}