diff --git a/README.md b/README.md
new file mode 100644
index 00000000..5cb46a50
--- /dev/null
+++ b/README.md
@@ -0,0 +1,143 @@
+# 🎫 축제의 민족
+
+## 📌 프로젝트 개요
+
+이 프로젝트는 제한된 리소스 환경(AWS t3.small EC2 인스턴스 2대, RDS, Redis)에서 안정적인 운영을 목표로 하는 고성능 페스티벌 티켓 예매 시스템입니다. 순간적인 대규모 트래픽 상황에서도
+안정적으로 동작하도록 설계되었으며, 효율적인 대기열 관리와 비동기 처리를 통해 사용자 경험을 최적화합니다.
+
+### 프로젝트 목표
+
+- 초당 1,000건 이상의 주문 처리
+- 평균 응답 시간 100ms 이하
+- 시스템 가용성 99.9% 이상
+
+## 🚀 핵심 기능
+
+1. **실시간 대기열 시스템**: Redis 기반의 공정한 대기열 관리
+2. **안정적인 결제 처리**: 비동기 방식의 결제 처리 및 실시간 상태 조회
+3. **효율적인 재고 관리**: Redis를 활용한 실시간 재고 추적
+4. **비동기 주문 처리**: 인메모리 큐 시스템을 통한 주문 처리 최적화
+
+## 🛠 기술 스택
+
+<p align="center">
+  <img src="https://img.shields.io/badge/java-%23ED8B00.svg?style=for-the-badge&logo=java&logoColor=white" alt="Java" />
+  <img src="https://img.shields.io/badge/spring-%236DB33F.svg?style=for-the-badge&logo=spring&logoColor=white" alt="Spring" />
+  <img src="https://img.shields.io/badge/MySQL-00000F?style=for-the-badge&logo=mysql&logoColor=white" alt="MySQL" />
+  <img src="https://img.shields.io/badge/redis-%23DD0031.svg?style=for-the-badge&logo=redis&logoColor=white" alt="Redis" />
+  <img src="https://img.shields.io/badge/gradle-02303A?style=for-the-badge&logo=gradle&logoColor=white" alt="Gradle" />
+  <img src="https://img.shields.io/badge/grafana-%23F46800.svg?style=for-the-badge&logo=grafana&logoColor=white" alt="Grafana" />
+  <img src="https://img.shields.io/badge/Prometheus-E6522C?style=for-the-badge&logo=Prometheus&logoColor=white" alt="Prometheus" />
+  <img src="https://img.shields.io/badge/k6-7D64FF?style=for-the-badge&logo=k6&logoColor=white" alt="k6" />
+</p>
+
+## 📐 아키텍처
+
+![아키텍처.png](img.png)
+
+## 🔧 핵심 컴포넌트
+
+### 1. 대기열 시스템 (WaitOrderService)
+
+- 원리: 청크 기반의 대기열 관리 시스템
+- 대기열 관리:
+   - Redis Set을 사용하여 각 티켓에 대한 대기열 유지
+   - 사용자 진입 시 현재 대기열의 크기를 기반으로 대기 순서 할당
+- 입장 관리:
+   - passChunkSize 단위로 입장 가능한 범위 관리
+   - 주기적으로 입장 가능 범위를 passChunkSize만큼 증가시켜 순차적 입장 허용
+- 입장 가능 여부 확인:
+   - 사용자의 대기 순서가 현재 입장 가능 범위 내에 있는지 확인
+   - 재고 여부도 함께 체크하여 입장 가능 여부 결정
+
+### 2. 결제 시스템 (PurchaseFacadeService, PaymentService)
+
+- 원리: 비동기 결제 처리 및 상태 관리
+- 결제 프로세스:
+   - 결제 요청 시 UUID 기반의 결제 ID 생성 후 비동기로 결제 처리 시작
+   - CompletableFuture를 사용하여 비동기 결제 처리 구현
+- 상태 관리:
+   - Caffeine 캐시를 사용하여 결제 상태 관리
+   - 결제 ID를 키로 사용하여 결제 정보 및 상태 저장
+- 결제 완료 후 처리:
+   - 결제 성공 시 QueueService를 통해 구매 정보 처리
+   - 결제 실패 시 CompensationService를 통해 재고 및 상태 롤백
+
+### 3. 재고 관리 (TicketStockCountRedisRepository)
+
+- 원리: Redis를 활용한 실시간 재고 관리
+- 재고 관리:
+   - Redis에 각 티켓의 재고 수량 저장
+   - 원자적 감소 연산을 사용하여 동시성 문제 해결
+- 재고 동기화:
+   - TicketScheduleService를 통해 주기적으로 Redis의 재고 정보 업데이트
+   - 판매 시작 전 또는 진행 중인 티켓의 재고 정보만 Redis에 유지
+
+### 4. 주문 처리 (QueueService)
+
+- 원리: 인메모리 큐를 활용한 비동기 주문 처리
+- 주문 접수:
+   - InMemoryQueue에 구매 데이터(PurchaseData) 저장
+   - 큐가 가득 찼을 경우 지수 백오프를 적용한 재시도 로직 구현
+- 주문 처리:
+   - 주기적으로(5초마다) 큐에서 배치 단위로 주문 데이터 처리
+   - 배치 크기는 큐의 현재 크기에 따라 동적으로 조정
+- 데이터 일관성:
+   - 주문 정보와 체크인 정보를 트랜잭션으로 묶어 일괄 처리
+   - JDBC batch update를 사용하여 데이터베이스 연산 최적화
+- 장애 복구:
+   - 서버 재시작 시 로그 파일을 분석하여 미처리된 주문 복구
+   - 처리 실패한 주문에 대한 재시도 메커니즘 구현
+
+## 📈 성능 최적화 전략
+
+1. **인메모리 캐싱 및 데이터 관리**
+   - Redis를 활용한 대기열, 재고, 결제 상태 관리
+   - Caffeine 캐시를 이용한 애플리케이션 레벨 캐싱
+   - 캐시 워밍으로 콜드 스타트 문제 해결 및 초기 응답 시간 개선
+
+2. **비동기 및 병렬 처리**
+   - CompletableFuture를 이용한 비동기 결제 처리
+   - 주문 처리를 위한 커스텀 인메모리 큐 구현
+   - 배치 처리를 통한 데이터베이스 쓰기 최적화
+
+3. **데이터베이스 최적화**
+   - Skip Lock 적용으로 동시성 제어 및 성능 향상 (`SELECT ... FOR UPDATE SKIP LOCKED`)
+   - 커넥션 풀 최적화 (HikariCP 튜닝)
+   - 인덱스 최적화 및 쿼리 튜닝
+   - JDBC 배치 업데이트를 통한 벌크 연산 효율화
+
+4. **대기열 시스템 설계**
+   - Redis Sorted Set을 활용한 공정한 대기열 관리
+   - 청크 단위의 입장 처리로 시스템 부하 분산
+   - 동적 대기열 크기 조정으로 리소스 활용 최적화
+
+5. **네트워크 및 응답 최적화**
+   - JSON 페이로드 최소화로 네트워크 부하 감소
+   - 응답 데이터 압축 적용
+   - Keep-Alive 연결 활용으로 연결 비용 감소
+
+6. **시스템 안정성 및 복구 전략**
+   - 적절한 타임아웃 설정 및 서킷 브레이커 패턴 적용
+   - 지수 백오프를 활용한 재시도 로직 구현
+   - 장애 상황 대비 복구 메커니즘 구현 (로그 기반 복구)
+
+7. **모니터링 및 성능 분석**
+   - Grafana와 Prometheus를 활용한 실시간 시스템 모니터링
+   - 사용자 정의 메트릭을 통한 비즈니스 로직 모니터링
+   - 성능 병목 지점 식별 및 지속적인 개선
+
+## 👥 팀 소개
+
+저희는 **팀 twoDari**입니다. 사용자와 축제를 이어주는 다리 역할을 합니다.
+
+| 이름  | 역할  | 주요 기여                                | GitHub                                           |
+|-----|-----|--------------------------------------|--------------------------------------------------|
+| 김현종 | 백엔드 | MySQL비동기 처리, 배치 처리, 프론트엔드 화면 구성      | [@bellringstar](https://github.com/bellringstar) |
+| 김규원 | 백엔드 | 캐싱전략, Redis를 사용한 대기열, 프론트엔드 화면 구성    | [@kkyu0718](https://github.com/kkyu0718)         |
+| 김현준 | 백엔드 | devops, 스케쥴링 작업, 다양한 모듈 간 연계 및 성능 개선 | [@HyeonJun0530](https://github.com/HyeonJun0530) |
+| 박민지 | 백엔드 | Redis를 사용한 대기열 로직, 프로젝트 모듈화          | [@minnim1010](https://github.com/minnim1010)     |
+
+## 📊 성능 테스트 결과
+
+![test_result.png](img_1.png)
\ No newline at end of file
diff --git a/backend/README.md b/backend/README.md
deleted file mode 100644
index e3ccfd35..00000000
--- a/backend/README.md
+++ /dev/null
@@ -1,40 +0,0 @@
-#  축제의 민족
-
-### 1. 🎊 서비스 소개
-축제의 민족은 선착순 티켓팅 기반 이벤트 개최 서비스입니다. 
-
----
-
-### 2. 👬 팀 소개
-
-안녕하세요, 사용자와 축제를 이어주는 다리, 팀 Dari입니다! 
-
-- 김현종
-- 김규원
-- 김현준
-- 박민지
-
----
-
-### 3. 💻 핵심 기능
-
-- **다양한 축제 정보를 제공합니다.**
-- **축제 관리 조직을 만들어 새로운 축제를 개최할 수 있습니다.**
-- **새로운 축제의 참여자들을 선착순 기반으로 모집할 수 있습니다.** 
-
----
-
-### 4. 🎮 기술 스택
-- **Spring Boot**
-- **Spring MVC**
-- **Spring Data JPA**
-- **queryDSL**
-- **Spring REST docs**
-
-- **AWS S3**
-- **AWS EC2**
-- **AWS RDS**
-  
----
-
----
diff --git a/backend/api-server/src/main/java/com/wootecam/festivals/domain/festival/dto/FestivalCreateRequest.java b/backend/api-server/src/main/java/com/wootecam/festivals/domain/festival/dto/FestivalCreateRequest.java
index ba0cd87d..a743b5f0 100644
--- a/backend/api-server/src/main/java/com/wootecam/festivals/domain/festival/dto/FestivalCreateRequest.java
+++ b/backend/api-server/src/main/java/com/wootecam/festivals/domain/festival/dto/FestivalCreateRequest.java
@@ -14,10 +14,8 @@
 import static com.wootecam.festivals.domain.festival.util.FestivalValidConstant.TITLE_BLANK_MESSAGE;
 import static com.wootecam.festivals.domain.festival.util.FestivalValidConstant.TITLE_SIZE_MESSAGE;
 
-import com.fasterxml.jackson.databind.annotation.JsonSerialize;
 import com.wootecam.festivals.domain.festival.entity.Festival;
 import com.wootecam.festivals.domain.member.entity.Member;
-import com.wootecam.festivals.global.utils.CustomLocalDateTimeSerializer;
 import jakarta.validation.constraints.AssertTrue;
 import jakarta.validation.constraints.Future;
 import jakarta.validation.constraints.NotBlank;
@@ -33,12 +31,10 @@ public record FestivalCreateRequest(@NotBlank(message = TITLE_BLANK_MESSAGE)
                                     @Size(max = MAX_DESCRIPTION_LENGTH, message = DESCRIPTION_SIZE_MESSAGE)
                                     String description,
 
-                                    @JsonSerialize(using = CustomLocalDateTimeSerializer.class)
                                     @NotNull(message = START_TIME_NULL_MESSAGE)
                                     @Future(message = START_TIME_FUTURE_MESSAGE)
                                     LocalDateTime startTime,
 
-                                    @JsonSerialize(using = CustomLocalDateTimeSerializer.class)
                                     @NotNull(message = END_TIME_NULL_MESSAGE)
                                     @Future(message = END_TIME_FUTURE_MESSAGE)
                                     LocalDateTime endTime) {
diff --git a/backend/api-server/src/main/java/com/wootecam/festivals/domain/festival/entity/Festival.java b/backend/api-server/src/main/java/com/wootecam/festivals/domain/festival/entity/Festival.java
index dc979930..198c4411 100644
--- a/backend/api-server/src/main/java/com/wootecam/festivals/domain/festival/entity/Festival.java
+++ b/backend/api-server/src/main/java/com/wootecam/festivals/domain/festival/entity/Festival.java
@@ -3,7 +3,6 @@
 import com.wootecam.festivals.domain.festival.util.FestivalValidator;
 import com.wootecam.festivals.domain.member.entity.Member;
 import com.wootecam.festivals.global.audit.BaseEntity;
-import com.wootecam.festivals.global.utils.DateTimeUtils;
 import jakarta.persistence.Column;
 import jakarta.persistence.Entity;
 import jakarta.persistence.EnumType;
@@ -74,8 +73,8 @@ private Festival(Member admin, String title, String description, String festival
         this.title = title;
         this.description = description;
         this.festivalImg = festivalImg;
-        this.startTime = DateTimeUtils.normalizeDateTime(startTime);
-        this.endTime = DateTimeUtils.normalizeDateTime(endTime);
+        this.startTime = startTime;
+        this.endTime = endTime;
         this.festivalPublicationStatus =
                 festivalPublicationStatus == null ? FestivalPublicationStatus.PUBLISHED : festivalPublicationStatus;
         this.festivalProgressStatus =
diff --git a/backend/api-server/src/main/java/com/wootecam/festivals/domain/festival/repository/FestivalRepository.java b/backend/api-server/src/main/java/com/wootecam/festivals/domain/festival/repository/FestivalRepository.java
index 8f13364e..2c051bc6 100644
--- a/backend/api-server/src/main/java/com/wootecam/festivals/domain/festival/repository/FestivalRepository.java
+++ b/backend/api-server/src/main/java/com/wootecam/festivals/domain/festival/repository/FestivalRepository.java
@@ -32,11 +32,11 @@ public interface FestivalRepository extends JpaRepository<Festival, Long> {
             )
             FROM Festival f
             JOIN f.admin a
-            WHERE (f.startTime > :startTime OR (f.startTime = :startTime AND f.id < :id))
+            WHERE (f.startTime > :startTime OR (f.startTime = :startTime AND f.id > :id))
                 AND f.isDeleted = false
                 AND f.festivalPublicationStatus != 'DRAFT'
                 AND f.startTime > :now
-            ORDER BY f.startTime ASC, f.id ASC
+            ORDER BY f.startTime ASC, f.id DESC
             """)
     List<FestivalListResponse> findUpcomingFestivalsBeforeCursor(@Param("startTime") LocalDateTime startTime,
                                                                  @Param("id") long id,
diff --git a/backend/api-server/src/main/java/com/wootecam/festivals/domain/festival/service/FestivalService.java b/backend/api-server/src/main/java/com/wootecam/festivals/domain/festival/service/FestivalService.java
index 05204493..cb1d0223 100644
--- a/backend/api-server/src/main/java/com/wootecam/festivals/domain/festival/service/FestivalService.java
+++ b/backend/api-server/src/main/java/com/wootecam/festivals/domain/festival/service/FestivalService.java
@@ -18,6 +18,7 @@
 import java.util.List;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
+import org.springframework.cache.annotation.CacheEvict;
 import org.springframework.cache.annotation.Cacheable;
 import org.springframework.data.domain.PageRequest;
 import org.springframework.data.domain.Pageable;
@@ -44,6 +45,7 @@ public class FestivalService {
      * @return 생성된 축제의 ID를 포함한 응답 DTO
      */
     @Transactional
+    @CacheEvict(value = "festivalsFirstPage")
     public FestivalIdResponse createFestival(FestivalCreateRequest requestDto, Long adminId) {
         Member admin = memberRepository.findById(adminId)
                 .orElseThrow(() -> new ApiException(GlobalErrorCode.INVALID_REQUEST_PARAMETER, "유효하지 않는 멤버입니다."));
@@ -99,7 +101,8 @@ public FestivalResponse getFestivalDetail(Long festivalId) {
             value = "festivalsFirstPage",
             key = "#cursorTime + '_' + #cursorId + '_' + #pageSize",
             condition = "#cursorTime == null && #cursorId == null && #pageSize > 0"
-    )    public KeySetPageResponse<FestivalListResponse> getFestivals(LocalDateTime cursorTime,
+    )
+    public KeySetPageResponse<FestivalListResponse> getFestivals(LocalDateTime cursorTime,
                                                                  Long cursorId,
                                                                  int pageSize) {
         LocalDateTime now = DateTimeUtils.normalizeDateTime(LocalDateTime.now());
@@ -107,21 +110,19 @@ public FestivalResponse getFestivalDetail(Long festivalId) {
 
         List<FestivalListResponse> festivals = festivalRepository.findUpcomingFestivalsBeforeCursor(
                 cursorTime != null ? cursorTime : now,
-                cursorId != null ? cursorId : Long.MAX_VALUE,
+                cursorId != null ? cursorId : 0L,  // 변경: Long.MAX_VALUE 대신 0L 사용
                 now,
                 pageRequest);
 
         boolean hasNext = festivals.size() > pageSize;
         List<FestivalListResponse> pageContent = hasNext ? festivals.subList(0, pageSize) : festivals;
 
-        LocalDateTime nextCursorTime = null;
-        Long nextCursorId = null;
+        Cursor nextCursor = null;
         if (hasNext) {
             FestivalListResponse lastFestival = pageContent.get(pageContent.size() - 1);
-            nextCursorTime = lastFestival.startTime();
-            nextCursorId = lastFestival.festivalId();
+            nextCursor = new Cursor(lastFestival.startTime(), lastFestival.festivalId());
         }
 
-        return new KeySetPageResponse<>(pageContent, new Cursor(nextCursorTime, nextCursorId), hasNext);
+        return new KeySetPageResponse<>(pageContent, nextCursor, hasNext);
     }
 }
diff --git a/backend/api-server/src/main/java/com/wootecam/festivals/domain/ticket/entity/Ticket.java b/backend/api-server/src/main/java/com/wootecam/festivals/domain/ticket/entity/Ticket.java
index 0d7f1a5b..8b7b84b0 100644
--- a/backend/api-server/src/main/java/com/wootecam/festivals/domain/ticket/entity/Ticket.java
+++ b/backend/api-server/src/main/java/com/wootecam/festivals/domain/ticket/entity/Ticket.java
@@ -100,4 +100,9 @@ public Purchase createPurchase(Member member) {
                 .purchaseStatus(PurchaseStatus.PURCHASED)
                 .build();
     }
+
+    public boolean isSaleOnTime(LocalDateTime now) {
+        return (startSaleTime.isEqual(now) || startSaleTime.isBefore(now)) && ((endSaleTime.isEqual(now)
+                || endSaleTime.isAfter(now)));
+    }
 }
diff --git a/backend/api-server/src/main/java/com/wootecam/festivals/domain/ticket/repository/TicketStockJdbcRepository.java b/backend/api-server/src/main/java/com/wootecam/festivals/domain/ticket/repository/TicketStockJdbcRepository.java
index 710ed8d5..f9d44fc9 100644
--- a/backend/api-server/src/main/java/com/wootecam/festivals/domain/ticket/repository/TicketStockJdbcRepository.java
+++ b/backend/api-server/src/main/java/com/wootecam/festivals/domain/ticket/repository/TicketStockJdbcRepository.java
@@ -3,6 +3,7 @@
 import com.wootecam.festivals.domain.ticket.entity.TicketStock;
 import java.sql.PreparedStatement;
 import java.sql.SQLException;
+import java.sql.Timestamp;
 import java.util.List;
 import lombok.RequiredArgsConstructor;
 import org.springframework.jdbc.core.BatchPreparedStatementSetter;
@@ -16,13 +17,16 @@ public class TicketStockJdbcRepository {
     private final JdbcTemplate jdbcTemplate;
 
     public void saveTicketStocks(List<TicketStock> ticketStocks) {
-        String sql = "INSERT INTO ticket_stock (ticket_id) VALUES (?)";
+        String sql = "INSERT INTO ticket_stock (ticket_id, created_at, updated_at) VALUES (?, ?, ?)";
+        Timestamp now = new Timestamp(System.currentTimeMillis());
 
         jdbcTemplate.batchUpdate(sql, new BatchPreparedStatementSetter() {
             @Override
             public void setValues(PreparedStatement ps, int index) throws SQLException {
                 TicketStock ticketStock = ticketStocks.get(index);
                 ps.setLong(1, ticketStock.getTicket().getId());
+                ps.setTimestamp(2, now);
+                ps.setTimestamp(3, now);
             }
 
             @Override
diff --git a/backend/api-server/src/main/java/com/wootecam/festivals/domain/ticket/service/TicketService.java b/backend/api-server/src/main/java/com/wootecam/festivals/domain/ticket/service/TicketService.java
index f651f3e6..bf8f1c60 100644
--- a/backend/api-server/src/main/java/com/wootecam/festivals/domain/ticket/service/TicketService.java
+++ b/backend/api-server/src/main/java/com/wootecam/festivals/domain/ticket/service/TicketService.java
@@ -9,12 +9,18 @@
 import com.wootecam.festivals.domain.ticket.dto.TicketResponse;
 import com.wootecam.festivals.domain.ticket.entity.Ticket;
 import com.wootecam.festivals.domain.ticket.entity.TicketStock;
+import com.wootecam.festivals.domain.ticket.repository.CurrentTicketWaitRedisRepository;
+import com.wootecam.festivals.domain.ticket.repository.TicketInfoRedisRepository;
 import com.wootecam.festivals.domain.ticket.repository.TicketRepository;
+import com.wootecam.festivals.domain.ticket.repository.TicketStockCountRedisRepository;
 import com.wootecam.festivals.domain.ticket.repository.TicketStockJdbcRepository;
 import com.wootecam.festivals.global.exception.type.ApiException;
+import com.wootecam.festivals.global.utils.TimeProvider;
+import java.time.LocalDateTime;
 import java.util.List;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
+import org.springframework.cache.annotation.CacheEvict;
 import org.springframework.cache.annotation.Cacheable;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
@@ -32,6 +38,12 @@ public class TicketService {
     private final FestivalRepository festivalRepository;
     private final TicketCacheService ticketCacheService;
 
+    private final TicketInfoRedisRepository ticketInfoRedisRepository;
+    private final TicketStockCountRedisRepository ticketStockCountRedisRepository;
+    private final CurrentTicketWaitRedisRepository currentTicketWaitRedisRepository;
+
+    private final TimeProvider timeProvider;
+
     /**
      * 티켓 생성
      *
@@ -40,6 +52,7 @@ public class TicketService {
      * @return 생성된 티켓의 ID
      */
     @Transactional
+    @CacheEvict(value = "ticketList", key = "#festivalId")
     public TicketIdResponse createTicket(Long festivalId, TicketCreateRequest request) {
         log.debug("티켓 생성 요청 - 축제 ID: {}", festivalId);
 
@@ -60,6 +73,17 @@ public TicketIdResponse createTicket(Long festivalId, TicketCreateRequest reques
         TicketIdResponse response = new TicketIdResponse(newTicket.getId());
         log.debug("티켓 생성 완료 - 티켓 ID: {}", response.ticketId());
 
+        LocalDateTime now = timeProvider.getCurrentTime();
+        if (newTicket.isSaleOnTime(now) || now.plusMinutes(10).isAfter(newTicket.getStartSaleTime())
+                || now.minusMinutes(1).isAfter(newTicket.getStartSaleTime())) {
+            ticketInfoRedisRepository.setTicketInfo(newTicket.getId(), newTicket.getStartSaleTime(),
+                    newTicket.getEndSaleTime());
+            currentTicketWaitRedisRepository.addCurrentTicketWait(newTicket.getId());
+            ticketStockCountRedisRepository.setTicketStockCount(newTicket.getId(), (long) newTicket.getQuantity());
+
+            log.debug("티켓 정보 redis 업데이트 완료 - 티켓 ID: {}, 판매 시작 시각: {}, 판매 종료 시각: {}", newTicket.getId(),
+                    newTicket.getStartSaleTime(), newTicket.getEndSaleTime());
+        }
         return response;
     }
 
diff --git a/backend/api-server/src/main/java/com/wootecam/festivals/global/config/RedisConfig.java b/backend/api-server/src/main/java/com/wootecam/festivals/global/config/RedisConfig.java
deleted file mode 100644
index d8de043f..00000000
--- a/backend/api-server/src/main/java/com/wootecam/festivals/global/config/RedisConfig.java
+++ /dev/null
@@ -1,36 +0,0 @@
-package com.wootecam.festivals.global.config;
-
-
-import org.springframework.beans.factory.annotation.Value;
-import org.springframework.context.annotation.Bean;
-import org.springframework.context.annotation.Configuration;
-import org.springframework.data.redis.connection.RedisConnectionFactory;
-import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
-import org.springframework.data.redis.core.RedisTemplate;
-import org.springframework.data.redis.serializer.StringRedisSerializer;
-
-@Configuration
-public class RedisConfig {
-
-    @Value("${spring.data.redis.host}")
-    private String redisHost;
-
-    @Value("${spring.data.redis.port}")
-    private int redisPort;
-
-    @Bean
-    public RedisConnectionFactory redisConnectionFactory() {
-        return new LettuceConnectionFactory(redisHost, redisPort);
-    }
-
-    @Bean
-    public RedisTemplate<String, String> redisTemplate() {
-        RedisTemplate<String, String> redisTemplate = new RedisTemplate<>();
-        redisTemplate.setConnectionFactory(redisConnectionFactory());
-        redisTemplate.setKeySerializer(new StringRedisSerializer());
-        redisTemplate.setValueSerializer(new StringRedisSerializer());
-        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
-        redisTemplate.setHashValueSerializer(new StringRedisSerializer());
-        return redisTemplate;
-    }
-}
diff --git a/backend/api-server/src/main/java/com/wootecam/festivals/global/queue/service/QueueService.java b/backend/api-server/src/main/java/com/wootecam/festivals/global/queue/service/QueueService.java
index b2615171..e54ca0e8 100644
--- a/backend/api-server/src/main/java/com/wootecam/festivals/global/queue/service/QueueService.java
+++ b/backend/api-server/src/main/java/com/wootecam/festivals/global/queue/service/QueueService.java
@@ -14,7 +14,6 @@
 import com.wootecam.festivals.global.queue.dto.PurchaseData;
 import com.wootecam.festivals.global.queue.exception.QueueFullException;
 import com.wootecam.festivals.global.utils.TimeProvider;
-import jakarta.annotation.PostConstruct;
 import java.io.BufferedReader;
 import java.io.File;
 import java.io.FileReader;
@@ -95,7 +94,7 @@ public void addPurchase(PurchaseData purchaseData) {
     }
 
     // 주기적으로 큐의 구매 데이터를 처리하는 메서드
-    @Scheduled(fixedRate = 5000) // 5초마다 실행
+    @Scheduled(fixedRate = 3000) // 3초마다 실행
     public void processPurchases() {
         int batchSize = calculateOptimalBatchSize();
         List<PurchaseData> batch = queue.pollBatch(batchSize);
@@ -277,7 +276,7 @@ private void synchronizeTicketStock() {
 
     }
 
-    @PostConstruct
+    //    @PostConstruct
     public void recoverQueue() {
         log.debug("Starting queue recovery process");
         Set<PurchaseData> addedPurchases = new HashSet<>();
diff --git a/backend/api-server/src/test/java/com/wootecam/festivals/domain/ticket/service/TicketServiceTest.java b/backend/api-server/src/test/java/com/wootecam/festivals/domain/ticket/service/TicketServiceTest.java
index ddcd1edc..4dec8a69 100644
--- a/backend/api-server/src/test/java/com/wootecam/festivals/domain/ticket/service/TicketServiceTest.java
+++ b/backend/api-server/src/test/java/com/wootecam/festivals/domain/ticket/service/TicketServiceTest.java
@@ -12,8 +12,12 @@
 import com.wootecam.festivals.domain.ticket.dto.TicketIdResponse;
 import com.wootecam.festivals.domain.ticket.dto.TicketListResponse;
 import com.wootecam.festivals.domain.ticket.entity.Ticket;
+import com.wootecam.festivals.domain.ticket.entity.TicketInfo;
 import com.wootecam.festivals.domain.ticket.entity.TicketStock;
+import com.wootecam.festivals.domain.ticket.repository.CurrentTicketWaitRedisRepository;
+import com.wootecam.festivals.domain.ticket.repository.TicketInfoRedisRepository;
 import com.wootecam.festivals.domain.ticket.repository.TicketRepository;
+import com.wootecam.festivals.domain.ticket.repository.TicketStockCountRedisRepository;
 import com.wootecam.festivals.domain.ticket.repository.TicketStockRepository;
 import com.wootecam.festivals.global.exception.type.ApiException;
 import com.wootecam.festivals.utils.SpringBootTestConfig;
@@ -25,6 +29,7 @@
 import org.junit.jupiter.api.Test;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.data.redis.core.RedisTemplate;
 
 @SpringBootTest
 class TicketServiceTest extends SpringBootTestConfig {
@@ -44,9 +49,22 @@ class TicketServiceTest extends SpringBootTestConfig {
     @Autowired
     private TicketStockRepository ticketStockRepository;
 
+    @Autowired
+    private TicketInfoRedisRepository ticketInfoRedisRepository;
+
+    @Autowired
+    private TicketStockCountRedisRepository ticketStockCountRedisRepository;
+
+    @Autowired
+    private CurrentTicketWaitRedisRepository currentTicketWaitRedisRepository;
+
+    @Autowired
+    private RedisTemplate<String, String> redisTemplate;
+
     @BeforeEach
     void setUp() {
         clear();
+        redisTemplate.getConnectionFactory().getConnection().flushAll();
     }
 
     @Nested
@@ -82,11 +100,65 @@ void it_returns_ticket_id_when_ticket_is_created() {
             TicketIdResponse ticketIdResponse = ticketService.createTicket(saveFestival.getId(), ticketCreateRequest);
             Optional<Ticket> findTicket = ticketRepository.findById(ticketIdResponse.ticketId());
             // Then
+            Long newTicketId = ticketIdResponse.ticketId();
+
             assertAll(
                     () -> assertThat(ticketIdResponse).isNotNull(),
                     () -> assertThat(findTicket.isPresent()).isTrue(),
-                    () -> assertThat(ticketStockRepository.findAll()).hasSize(findTicket.get().getQuantity())
-            );
+                    () -> assertThat(ticketStockRepository.findAll()).hasSize(findTicket.get().getQuantity()),
+                    () -> {
+                        TicketInfo ticketInfo = ticketInfoRedisRepository.getTicketInfo(newTicketId);
+                        assertThat(ticketInfo.startSaleTime()).isEqualTo(findTicket.get().getStartSaleTime());
+                        assertThat(ticketInfo.endSaleTime()).isEqualTo(findTicket.get().getEndSaleTime());
+                    },
+                    () -> assertThat(ticketStockCountRedisRepository.getTicketStockCount(newTicketId)).isEqualTo(
+                            findTicket.get().getQuantity()),
+                    () -> assertThat(currentTicketWaitRedisRepository.getCurrentTicketWait()).contains(newTicketId));
+        }
+
+        @Test
+        @DisplayName("앞으로 10분 이내 판매되는 티켓 생성에 성공하면 redis에 정보를 업데이트한다.")
+        void it_returns_ticket_id_when_ticket_in_sale_10_min_is_created_() {
+            // Given
+            LocalDateTime now = LocalDateTime.now();
+
+            Member admin = Member.builder()
+                    .name("관리자")
+                    .profileImg("기관 이미지")
+                    .email("eamil@emai.com")
+                    .build();
+
+            Festival festival = Festival.builder()
+                    .admin(admin)
+                    .title("페스티벌 이름")
+                    .description("페스티벌 설명")
+                    .startTime(now.plusDays(3))
+                    .endTime(now.plusDays(7))
+                    .build();
+            memberRepository.save(admin);
+            Festival saveFestival = festivalRepository.save(festival);
+
+            TicketCreateRequest ticketCreateRequest = new TicketCreateRequest("티켓 이름", "티켓 설명", 10000L, 100,
+                    now.plusMinutes(10), now.plusDays(6), now.plusDays(10));
+
+            // When
+            TicketIdResponse ticketIdResponse = ticketService.createTicket(saveFestival.getId(), ticketCreateRequest);
+            Optional<Ticket> findTicket = ticketRepository.findById(ticketIdResponse.ticketId());
+            // Then
+            Long newTicketId = ticketIdResponse.ticketId();
+
+            assertAll(
+                    () -> assertThat(ticketIdResponse).isNotNull(),
+                    () -> assertThat(findTicket.isPresent()).isTrue(),
+                    () -> assertThat(ticketStockRepository.findAll()).hasSize(findTicket.get().getQuantity()),
+                    () -> {
+                        TicketInfo ticketInfo = ticketInfoRedisRepository.getTicketInfo(newTicketId);
+                        assertThat(ticketInfo.startSaleTime()).isEqualTo(findTicket.get().getStartSaleTime());
+                        assertThat(ticketInfo.endSaleTime()).isEqualTo(findTicket.get().getEndSaleTime());
+                    },
+                    () -> assertThat(ticketStockCountRedisRepository.getTicketStockCount(newTicketId)).isEqualTo(
+                            findTicket.get().getQuantity()),
+                    () -> assertThat(currentTicketWaitRedisRepository.getCurrentTicketWait()).contains(newTicketId));
         }
 
         @Test
diff --git a/frontend/src/pages/admin/FestivalManagement.js b/frontend/src/pages/admin/FestivalManagement.js
index 37c9cdb4..e0218a45 100644
--- a/frontend/src/pages/admin/FestivalManagement.js
+++ b/frontend/src/pages/admin/FestivalManagement.js
@@ -100,7 +100,6 @@ const FestivalManagement = () => {
       }
       const response = await apiClient.patch(`/festivals/${festivalId}/tickets/${scannedData.ticketId}/checkins/${scannedData.checkinId}`);
       setModalMessage('체크인이 완료되었습니다.');
-      setActiveTab('purchasers');  // 체크인 후 구매자 목록으로 이동
     } catch (error) {
       if (error.response && error.response.data.errorCode === 'CI-0002') {
         setModalMessage('이미 체크인된 티켓입니다.');
diff --git a/frontend/src/pages/admin/TicketManagement.js b/frontend/src/pages/admin/TicketManagement.js
index d3f28341..4895b2d4 100644
--- a/frontend/src/pages/admin/TicketManagement.js
+++ b/frontend/src/pages/admin/TicketManagement.js
@@ -169,8 +169,8 @@ const TicketManagement = ({ festivalId }) => {
       fetchTickets(); // 티켓 목록 갱신
       setError('');
     } catch (error) {
-      console.error('티켓 생성에 실패했습니다:', error);
-      setError('티켓 생성에 실패했습니다. 다시 시도해주세요.');
+      console.error('티켓 생성에 실패했습니다:', error.response.data.message);
+      setError(error.response.data.message);
     }
   };
 
diff --git a/frontend/src/pages/festival/FestivalList.js b/frontend/src/pages/festival/FestivalList.js
index f4222b2f..b4ae4c01 100644
--- a/frontend/src/pages/festival/FestivalList.js
+++ b/frontend/src/pages/festival/FestivalList.js
@@ -48,12 +48,19 @@ const useFestivals = () => {
     try {
       const params = {
         pageSize: '4',
-        ...(cursor && !isInitialLoad ? { time: cursor.time, id: cursor.id.toString() } : {})
+        ...(cursor && !isInitialLoad ? { 
+          time: cursor.time, 
+          id: cursor.id.toString()
+        } : {})
       };
 
-      const response = await apiClient.get(`/festivals`, {params});
+      console.log('Fetching festivals with params:', params);
+
+      const response = await apiClient.get(`/festivals`, { params });
       const { data } = response.data;
 
+      console.log('API response:', data);
+
       setFestivals((prev) => {
         const newFestivals = isInitialLoad ? data.content : [...prev, ...data.content];
         return newFestivals.filter((festival, index, self) =>
@@ -107,6 +114,7 @@ export default function FestivalList() {
 
   useEffect(() => {
     if (inView && hasMore && !isLoading && retryCount < 3) {
+      console.log('Triggering load more', { inView, hasMore, isLoading, retryCount });
       debouncedLoadMore();
     }
   }, [inView, hasMore, isLoading, debouncedLoadMore, retryCount]);
diff --git a/frontend/src/pages/festival/TicketQueuePage.js b/frontend/src/pages/festival/TicketQueuePage.js
index e9ae6672..991c7fa6 100644
--- a/frontend/src/pages/festival/TicketQueuePage.js
+++ b/frontend/src/pages/festival/TicketQueuePage.js
@@ -1,9 +1,10 @@
 import React, { useState, useEffect, useCallback } from 'react';
 import { useParams, useNavigate } from 'react-router-dom';
-import { Loader2 } from 'lucide-react';
+import { Loader2, AlertCircle } from 'lucide-react';
 import waitClient from '../../utils/waitClient'
 import { useRecoilState } from 'recoil';
 import { waitOrdersState } from '../../utils/atoms';
+import { Button } from '../../components/ui/button';
 
 const TicketQueuePage = () => {
     const { festivalId, ticketId } = useParams();
@@ -11,11 +12,27 @@ const TicketQueuePage = () => {
     const [waitOrders, setWaitOrders] = useRecoilState(waitOrdersState);
     const [relativeWaitOrder, setRelativeWaitOrder] = useState(null);
     const [error, setError] = useState(null);
+    const [isSoldOut, setIsSoldOut] = useState(false);
+
+    // 로컬 스토리지 키 생성 함수
+    const getStorageKey = useCallback((ticketId) => `waitOrder_${ticketId}`, []);
+
+    // 로컬 스토리지에서 대기 순서를 가져오는 함수
+    const getWaitOrder = useCallback((ticketId) => {
+        const key = getStorageKey(ticketId);
+        return localStorage.getItem(key);
+    }, [getStorageKey]);
+
+    // 로컬 스토리지에 대기 순서를 설정하는 함수
+    const setWaitOrder = useCallback((ticketId, order) => {
+        const key = getStorageKey(ticketId);
+        localStorage.setItem(key, order);
+    }, [getStorageKey]);
 
     const checkQueueStatus = useCallback(async () => {
         try {
             const url = `/festivals/${festivalId}/tickets/${ticketId}/purchase/wait`;
-            const currentWaitOrder = waitOrders[ticketId];
+            const currentWaitOrder = getWaitOrder(ticketId);
             const fullUrl = currentWaitOrder ? `${url}?waitOrder=${currentWaitOrder}` : url;
 
             const response = await waitClient.get(fullUrl);
@@ -26,20 +43,21 @@ const TicketQueuePage = () => {
             setRelativeWaitOrder(relativeWaitOrder);
 
             if (!currentWaitOrder) {
-                setWaitOrders(prev => ({
-                    ...prev,
-                    [ticketId]: absoluteWaitOrder
-                }));
+                setWaitOrder(ticketId, absoluteWaitOrder);
             }
 
             if (purchasable) {
                 navigate(`/festivals/${festivalId}/tickets/${ticketId}/purchase`);
             }
         } catch (err) {
-            setError('대기열 상태 확인 중 오류가 발생했습니다.');
-            console.error('대기열 상태 확인 오류:', err);
+            if (err.response && err.response.data.errorCode === 'WT-0005') {
+                setIsSoldOut(true);
+            } else {
+                setError('대기열 상태 확인 중 오류가 발생했습니다.');
+                console.error('대기열 상태 확인 오류:', err);
+            }
         }
-    }, [festivalId, ticketId, navigate, waitOrders, setWaitOrders]);
+    }, [festivalId, ticketId, navigate, getWaitOrder, setWaitOrder]);
 
     useEffect(() => {
         checkQueueStatus();
@@ -47,6 +65,35 @@ const TicketQueuePage = () => {
         return () => clearInterval(intervalId);
     }, [checkQueueStatus]);
 
+    useEffect(() => {
+        console.log("waitOrders", waitOrders)
+    }, [waitOrders]);
+
+
+    if (isSoldOut) {
+        return (
+            <div className="max-w-2xl mx-auto p-4">
+                <div className="bg-yellow-100 border-l-4 border-yellow-500 text-yellow-700 p-4 mb-4" role="alert">
+                    <div className="flex">
+                        <div className="py-1">
+                            <AlertCircle className="h-6 w-6 text-yellow-500 mr-4" />
+                        </div>
+                        <div>
+                            <p className="font-bold">티켓 매진</p>
+                            <p className="text-sm">죄송합니다. 현재 이 티켓은 매진되었습니다.</p>
+                        </div>
+                    </div>
+                </div>
+                <Button 
+                    onClick={() => navigate(`/festivals/${festivalId}`)}
+                    className="w-full bg-teal-500 hover:bg-teal-600 text-white"
+                >
+                    축제 상세 페이지로 돌아가기
+                </Button>
+            </div>
+        );
+    }
+
     if (error) {
         return (
             <div className="bg-red-100 border border-red-400 text-red-700 px-4 py-3 rounded relative" role="alert">
diff --git a/frontend/src/pages/my/PurchasedTickets.js b/frontend/src/pages/my/PurchasedTickets.js
index a2bfab76..d5560c64 100644
--- a/frontend/src/pages/my/PurchasedTickets.js
+++ b/frontend/src/pages/my/PurchasedTickets.js
@@ -46,9 +46,9 @@ export default function PurchasedTickets() {
     }
   }, [inView, hasMore, isLoading, loadMoreTickets]);
 
-  const openTicketDetail = async (purchaseId) => {
+  const openTicketDetail = async (ticketId) => {
     try {
-      const response = await apiClient.get(`/member/tickets/${purchaseId}`);
+      const response = await apiClient.get(`/member/tickets/${ticketId}`);
       setSelectedTicket(response.data.data);
       setIsOpen(true);
     } catch (error) {
@@ -110,13 +110,11 @@ export default function PurchasedTickets() {
               <p className="text-sm text-gray-600 mb-2">
                 {new Date(ticket.startTime).toLocaleDateString()} ~ {new Date(ticket.endTime).toLocaleDateString()}
               </p>
-              <p className="text-sm font-semibold mb-2">
-                {ticket.isCheckin ? '체크인 완료' : '미체크인'}
-              </p>
+
               <button 
-                onClick={() => openTicketDetail(ticket.purchaseId)}
+                onClick={() => openTicketDetail(ticket.ticketId)}
                 className={`w-full px-4 py-2 text-white rounded transition-colors ${
-                  ticket.isCheckin ? 'bg-gray-500 hover:bg-gray-600' : 'bg-teal-500 hover:bg-teal-600'
+                  ticket.isCheckedIn ? 'bg-gray-500 hover:bg-gray-600' : 'bg-teal-500 hover:bg-teal-600'
                 }`}
               >
                 티켓 보기
diff --git a/img.png b/img.png
new file mode 100644
index 00000000..837bbef5
Binary files /dev/null and b/img.png differ
diff --git a/img_1.png b/img_1.png
new file mode 100644
index 00000000..65781bcb
Binary files /dev/null and b/img_1.png differ