diff --git a/00_Raw/Agile Environments.md b/00_Raw/Agile Environments.md
new file mode 100644
index 00000000..dbf3a829
--- /dev/null
+++ b/00_Raw/Agile Environments.md	
@@ -0,0 +1,47 @@
+# [[Agile Environments]]
+
+## 📌 Brief Summary
+Agile Environments(애자일 환경)는 요구사항이 지속적으로 변화하는 프로젝트나 스타트업 환경을 의미합니다 [1]. 이러한 환경에서는 미래에 필요할지도 모르는 복잡한 기능을 미리 개발하기보다는 오직 현재의 요구사항에 집중하는 것이 핵심입니다 [2]. 따라서 각 기능을 독립적으로 생성하고 구현할 수 있는 유연하고 모듈화된 접근 방식이 매우 적합합니다 [3].
+
+## 📖 Core 소스에 관련 정보가 부족합니다.Content
+애자일 환경(Agile Environments)과 관련하여 제공된 소스에서 다루고 있는 구체적인 설명은 다음과 같습니다. 
+
+* **YAGNI 원칙의 중요성**: 애자일 환경에서는 "You Aren't Gonna Need It (YAGNI)" 원칙이 특히 필수적으로 작용합니다 [2]. 변화하는 요구사항을 가진 스타트업이나 애자일 프로젝트에서는, 미래의 사용 사례를 대비하여 복잡한 기능을 미리 구축하는 것을 피해야 합니다 [1, 2]. 개발팀은 오직 현재의 요구사항에만 집중함으로써 나중에 유지보수해야 할 복잡성과 사용되지 않는 코드(dead code)의 양을 최소화할 수 있습니다 [2].
+* **기능 기반 구조(Feature-Based Structure)의 적합성**: 프론트엔드 아키텍처 측면에서 기능 기반 폴더 구조는 애자일 개발 방법론과 매우 잘 맞습니다 [3]. 이 구조에서는 각각의 기능(feature)이 독립적으로 분리되어 생성 및 구현될 수 있기 때문에, 애자일 환경에서 요구하는 유연성과 병렬적인 개발을 효과적으로 지원합니다 [3].
+* *참고: 주어진 소스에는 개발 원칙(YAGNI) 및 폴더 구조(Feature-Based)와 애자일의 연관성만 언급되어 있으며, 스크럼이나 스프린트 등 애자일 환경 자체의 전반적인 프로세스나 이론에 대해서는 소스에 관련 정보가 부족합니다.*
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+- [[YAGNI]]
+  - 연결 이유: 애자일 환경에서 미래의 불확실한 기능을 미리 만들지 않고 현재의 요구사항에 집중하도록 이끄는 가장 핵심적인 개발 원칙입니다 [1, 2].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 애자일 환경에서 불필요한 코드(Dead Code)의 생성을 방지하고 유지보수 비용을 최소화하는 구체적인 판단 기준을 이해할 수 있습니다 [2].
+- [[Feature-Based Structure]]
+  - 연결 이유: 애자일 방법론과 가장 잘 어울리는 아키텍처 패턴으로, 코드 베이스를 기능 단위로 분리하여 독립적인 개발을 가능하게 합니다 [3].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 애자일 팀이 요구사항 변경에 맞춰 여러 기능을 독립적으로 확장하고 개발할 때 파일과 폴더를 어떻게 구성해야 하는지 이해할 수 있습니다 [3].
+- [[Startup Projects]]
+  - 연결 이유: 애자일 환경과 마찬가지로 요구사항이 지속적으로 변화하는 특성을 공유하며, YAGNI 원칙이 강하게 적용되는 대표적인 비즈니스 환경입니다 [1].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 애자일 원칙이 실무에서 어떠한 형태의 프로젝트 규모나 상황(빠른 변화와 유연성 요구)에서 주로 채택되는지 파악할 수 있습니다 [1].
+
+### Deeper Research Questions
+- 애자일 환경에서 YAGNI 원칙을 엄격하게 적용하여 당장의 기능만 개발할 때, 향후 시스템이 확장되면서 발생할 수 있는 기술 부채(Technical Debt)는 어떻게 관리해야 하는가?
+- 요구사항이 끊임없이 변화하는 애자일 프로젝트에서 Feature-Based Structure가 기존의 파일 유형 기반 구조(File-Type Based Structure)보다 팀 협업 및 유지보수에 유리한 구체적 이유는 무엇인가?
+- 스타트업 프로젝트의 초기 단계에서 애자일 원칙(YAGNI, KISS 등)을 적용할 때와, 엔터프라이즈 환경으로 확장(Scaling)될 때 아키텍처 원칙(SOLID 등)의 적용 비중은 어떻게 변화해야 하는가?
+- 기능(Feature)을 독립적으로 분리하여 개발하는 애자일 환경에서, 여러 기능 간에 공유되는 교차 의존성(Cross-cutting concerns)은 구조적으로 어떻게 해결해야 하는가?
+- 애자일 환경의 '현재 요구사항에 대한 집중'과 '장기적인 소프트웨어 아키텍처의 견고함' 사이의 균형을 맞추기 위한 개발 거버넌스는 어떻게 구축해야 하는가?
+
+### Practical Application Contexts
+- **Implementation:** 주어진 스토리나 태스크의 요구사항을 충족하는 데 필요한 최소한의 코드만 우선적으로 구현합니다 (오버엔지니어링 금지) [2].
+- **System Design:** 프로젝트 폴더와 모듈을 기능(Feature)을 중심으로 설계하여, 요구사항이 변경되더라도 다른 기능에 미치는 영향을 최소화하고 독립적인 배포 및 테스트가 가능하게 합니다 [3].
+- **Operation / Maintenance:** 언젠가 쓰일 것이라 예상하고 작성한 불필요한 코드를 배제함으로써, 운영 단계에서 팀이 관리하고 파악해야 할 레거시 코드의 복잡성을 대폭 낮춥니다 [2].
+- **Learning Path:** 애자일 환경에 합류하기 위해 YAGNI 원칙의 적용법과 Feature-Sliced Design과 같은 최신 기능 단위의 모듈형 아키텍처 패턴을 학습합니다 [2, 3].
+- **My Project Relevance:** 잦은 기획 변경이 예상되는 초기 단계의 스타트업 프로젝트나 애자일 조직을 세팅할 때, 초기 개발 속도를 높이면서도 변경에 유연하게 대응하기 위한 가이드라인으로 직결됩니다 [1, 3].
+
+### Adjacent Topics
+- [[SOLID Principles]]
+  - 확장 방향: 애자일 환경에서 당장의 기능을 단순하게 개발(YAGNI)하면서도, 장기적으로 애플리케이션의 규모가 커졌을 때 코드를 어떻게 유지보수 가능하게 설계할지 객체 지향적/구조적 관점에서 이해를 확장할 수 있습니다 [1, 4].
+- [[Clean Code]]
+  - 확장 방향: 빠른 변화와 반복 개발(Iteration)이 일어나는 애자일 환경 속에서, 여러 명의 개발자가 코드를 쉽게 읽고 협업할 수 있도록 하는 기본적인 코드 품질 유지 기법으로 확장이 가능합니다 [4, 5].
+
+---
+*Last updated: 2026-04-30*
\ No newline at end of file
diff --git a/00_Raw/Branching Strategies.md b/00_Raw/Branching Strategies.md
new file mode 100644
index 00000000..0c39642f
--- /dev/null
+++ b/00_Raw/Branching Strategies.md	
@@ -0,0 +1,71 @@
+# [[Branching Strategies]]
+
+## 📌 Brief 소Summary
+Branching Strategies(브랜칭 전략)는 소프트웨어 개발 과정에서 코드 변경 사항을 관리하고 팀원 간의 협업을 조율하기 위해 버전 관리 시스템(Git 등)에서 브랜치를 생성, 병합, 유지보수하는 규칙과 워크플로우를 의미합니다. 팀의 규모와 프로젝트 요구사항에 따라 Git Flow, GitHub Flow, Trunk-Based Development, Feature Branch Workflow 등 다양한 전략이 사용됩니다. 명확한 브랜칭 전략의 도입은 메인 코드베이스의 안정성을 보장하고 병합 충돌을 방지하며 코드 리뷰와 추적성을 강화하는 핵심 역할을 합니다 [1-3].
+
+## 📖 Core Content
+*   **주요 브랜칭 전략 유형**
+    *   **Feature Branch Workflow (기능 브랜치 워크플로우):** 2~5명 규모의 소규모 팀에 가장 초보자 친화적이고 충돌이 적은 워크플로우입니다 [4]. `main` 브랜치는 항상 안정적이고 배포 가능한 상태를 유지하며, 새로운 기능이나 버그 수정 시 `main`에서 파생된 짧은 수명의 브랜치를 생성합니다 [5]. 개발 완료 후 Pull Request(PR)를 열고 최소 1명 이상의 동료 리뷰와 테스트를 거친 후 Squash Merge 방식으로 병합합니다 [6, 7].
+    *   **Trunk-Based Development (트렁크 기반 개발):** 강력한 CI(지속적 통합) 환경을 갖춘 숙련된 팀에 적합한 가벼운 방식입니다 [8, 9]. 수명이 매우 짧은 기능 브랜치를 사용하거나 메인 브랜치에 작은 변경 사항을 자주 커밋합니다. 오버헤드가 최소화되고 피드백이 빠르며 대규모 병합 충돌을 피할 수 있습니다 [8, 10].
+    *   **Git Flow:** 정기적인 릴리스 일정을 가진 대규모 프로젝트에 유용합니다 [9]. 하지만 기능 브랜치 외에도 `develop`, `release` 등 관리해야 할 브랜치가 많아 소규모 팀에게는 무겁고 과도한 복잡성을 유발할 수 있습니다 [9, 11, 12].
+    *   **GitHub Flow:** `main` 브랜치로 기능 브랜치를 직접 병합하는 단순화된 구조로, Git Flow보다 빠르고 지속적인 배포 환경에 적합합니다 [11, 13].
+
+*   **모든 전략에 적용되는 모범 사례 (Best Practices)**
+    *   **티켓 ID 및 명명 규칙 사용:** 브랜치 이름과 커밋 메시지에 요구사항 추적을 위한 티켓 ID(예: `feature/PROJ-123-user-auth`)를 포함해야 합니다 [14, 15]. 브랜치 이름은 케밥 케이스(kebab-case)를 사용하고 짧고 명확하게 작성합니다 [16, 17].
+    *   **원자적 커밋 (Atomic Commits):** 하나의 커밋에는 하나의 논리적 변경 사항만 포함하여 코드 리뷰와 히스토리 추적을 단순화합니다 [7, 18].
+    *   **Conventional Commits 규칙:** 커밋 메시지는 `feat:`, `fix:`, `chore:` 등의 표준화된 접두사를 사용하여 변경의 목적을 명확히 합니다 [19-21].
+    *   **PR 및 병합 규칙:** 코드를 절대 `main`에 직접 푸시해서는 안 되며, 반드시 PR을 통한 리뷰를 거쳐야 합니다 [6, 22]. 병합 후에는 사용이 끝난 브랜치를 즉시 삭제하여 저장소를 정리합니다 [6, 23].
+
+*   **전략 간 마이그레이션 방법**
+    *   프로젝트가 변화함에 따라 전략도 진화할 수 있습니다. 예를 들어 통합 속도를 높이려면 Feature Branch에서 Trunk-Based(기능 플래그 사용 및 수명 단축)로 전환하고, 더 많은 체계가 필요하다면 GitHub Flow에서 Git Flow(`develop` 브랜치 및 릴리스 브랜치 추가)로 마이그레이션할 수 있습니다 [11, 12].
+
+## ⚖️ Trade-offs & Caveats
+*   **구조적 오버헤드 vs. 안정성:** Git Flow는 구조가 명확하고 정기적인 릴리스에 강점이 있지만, 브랜치의 수가 많아 유지보수 비용(오버헤드)이 높습니다 [9]. 반면 Feature Branch나 Trunk-Based 방식은 프로세스가 가벼운 대신 메인 브랜치의 보호(`main` 브랜치 직접 푸시 금지, 엄격한 코드 리뷰 등) 규칙이 강제되지 않으면 코드가 쉽게 깨질 위험이 있습니다 [6, 22].
+*   **기능 브랜치의 수명(Long-lived branches) 문제:** 기능 브랜치나 GitHub Flow를 사용할 때, 브랜치의 수명이 몇 주 이상 길어지면 다른 작업자와의 코드 분기가 심해져 거대한 병합 충돌(Merge conflicts)이 발생할 수 있습니다 [17]. 따라서 매일 `main`의 최신 변경 사항을 Pull 하거나 Rebase하여 충돌을 예방해야 합니다 [7].
+*   **Trunk-Based 개발의 의존성:** 빠른 병합을 지향하는 Trunk-Based Development는 지속적이고 자동화된 테스트 환경(CI)과 미완성 기능을 프로덕션에서 숨기기 위한 기능 플래그(Feature Flags) 구현 등 기술적 뒷받침이 필수적입니다 [9, 11].
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+
+#### [관계 유형 A: 아키텍처/기반 방법론]
+- [[Feature Branch Workflow]]
+  - 연결 이유: 소규모 3~5인 개발 팀에 가장 추천되는 단순하고 직관적인 브랜칭 전략의 기반 개념입니다.
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 메인 브랜치를 오염시키지 않고 새로운 기능을 격리된 환경에서 개발하고 병합하는 방법론을 이해할 수 있습니다.
+- [[Trunk-Based Development]]
+  - 연결 이유: 무거운 워크플로우를 탈피하여 브랜치 생명주기를 극한으로 줄이고 빠른 통합을 중시하는 최신 트렌드 모델입니다.
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: CI/CD 환경에서의 잦은 소규모 배포 방식과 충돌 최소화 전략을 학습할 수 있습니다.
+- [[Git Flow]]
+  - 연결 이유: 브랜칭 전략의 고전적이고 체계적인 형태로서, 대형 프로젝트의 정기적 버저닝 관리를 위해 설계되었습니다.
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: `develop`, `release`, `hotfix` 등 개발 파이프라인에 따른 브랜치의 역할 분리 기법을 이해할 수 있습니다.
+
+#### [관계 유형 B: 구현/활용 도구 및 규칙]
+- [[Pull Request & Code Review]]
+  - 연결 이유: 브랜칭 전략이 안전하게 동작하기 위해 모든 병합 전에 필수적으로 거쳐야 하는 품질 검증 관문입니다.
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 팀원 간의 비동기적 피드백 수렴, 시각적 검증, 그리고 CI 통과를 전제로 한 안전한 병합 과정을 배울 수 있습니다.
+- [[Conventional Commits]]
+  - 연결 이유: 브랜치 병합 내역을 추적하고 가독성을 높이기 위해 전 세계적으로 통용되는 커밋 메시지 작성 표준입니다.
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: `feat(scope): message` 와 같은 형식의 구문을 통해 코드 히스토리 파악 및 문서 자동화를 어떻게 이룰 수 있는지 이해할 수 있습니다.
+
+### Deeper Research Questions
+- Trunk-Based Development를 성공적으로 적용하기 위해 필수적인 자동화 테스트 환경(CI)과 기능 플래그(Feature flags)의 구현 전략은 무엇인가?
+- 소규모 팀이 단일 `main` 브랜치 전략을 사용할 때, 예기치 않은 버그가 배포되는 것을 막기 위한 GitHub 저장소의 브랜치 보호 규칙(Branch Protection Rules) 최적화 방법은 무엇인가?
+- 장기 체류 브랜치(Long-lived branch)에서 발생하는 거대한 병합 충돌을 피하기 위해 `main` 브랜치의 최신 내용을 가져올 때 `merge`와 `rebase` 중 어떤 방식이 이력 관리에 더 효과적인가?
+- 원자적 커밋(Atomic Commits)을 강제하는 정책이 Pull Request 리뷰 시간과 버그 추적성에 어떠한 정량적/정성적 영향을 미치는가?
+- Git Flow 방식에서 GitHub Flow 방식으로 팀의 워크플로우를 마이그레이션할 때 예상되는 혼란 요소와 이를 해결하기 위한 CI/CD 파이프라인의 재구성 방법은 무엇인가?
+
+### Practical Application Contexts
+- **Implementation:** 새로운 기능 개발을 시작할 때, 최신 `main` 브랜치에서 `feature/티켓ID-간단한-설명` 이름으로 브랜치를 파생하고, 원자적 단위로 작은 커밋을 자주 기록합니다.
+- **System Design:** 프론트엔드 모듈 아키텍처 설계 시, 독립적인 피처(Feature) 폴더별로 브랜치를 나누어 개발함으로써 특정 코드 영역 밖으로 병합 충돌의 폭발 반경(Blast radius)이 퍼지지 않도록 합니다.
+- **Operation / Maintenance:** 브랜치가 `main`으로 병합되는 즉시 GitHub Action 등 CI 서버에서 자동으로 린트(ESLint), 테스트(Jest), 포맷팅을 수행하도록 방어막을 구축하여 메인 브랜치의 배포 가능한 상태를 영구적으로 유지합니다.
+- **Learning Path:** Git의 기초 명령어를 습득한 후, 소규모 팀 단위의 Feature Branch Workflow를 실습하고, 이후 CI/CD 도구를 연동한 Trunk-Based 환경으로 발전하는 순서로 학습합니다.
+- **My Project Relevance:** 3~5인 규모의 프로젝트에서 무거운 Git Flow의 도입을 지양하고, '단기 기능 브랜치 → PR 및 1인 이상 피어 리뷰 승인 → Squash Merge 및 브랜치 즉시 삭제'라는 단순화된 룰을 적용하여 개발 속도와 코드 품질을 동시에 챙깁니다.
+
+### Adjacent Topics
+- [[Continuous Integration / Continuous Deployment (CI/CD)]]
+  - 확장 방향: 브랜칭 전략에 의해 트리거(Trigger)되어 실행되는 빌드, 테스트, 배포 파이프라인의 자동화 프로세스를 깊이 알아봅니다.
+- [[Feature-Sliced Design (FSD)]]
+  - 확장 방향: 도메인과 기능 단위로 코드를 분리하는 프론트엔드 아키텍처 방법론으로, 브랜치를 기능별로 나눌 때 충돌을 물리적으로 최소화하는 코드 구조 설계법을 탐구합니다.
+
+---
+*Last updated: 2026-04-30*
\ No newline at end of file
diff --git a/00_Raw/Code Review.md b/00_Raw/Code Review.md
new file mode 100644
index 00000000..5436d57b
--- /dev/null
+++ b/00_Raw/Code Review.md	
@@ -0,0 +1,56 @@
+# [[Code Review]]
+
+## 📌 Brief Summary
+코드 리뷰(Code Review)는 개발자가 작성한 코드를 메인 브랜치에 병합하기 전에 팀원(동료)이 검토하여 승인하는 품질 관리 및 협업 프로세스입니다 [1, 2]. 주로 Pull Request(PR) 단계를 통해 이루어지며, 단독으로 잘못된 코드가 병합되는 것을 방지하고 팀 내 빠른 피드백 루프를 형성합니다 [1]. 최근 프론트엔드 환경에서는 단순한 코드 검토를 넘어 Storybook과 같은 도구를 CI 파이프라인과 결합한 '시각적 리뷰(Visual Review)'로 확장되어 의도치 않은 UI 변경을 방지하는 역할도 수행합니다 [3].
+
+## 📖 Core 소스에 기반한 Core Content
+- **동료 검토(Peer Review)의 역할 및 이점**: 개발자는 기능 브랜치(feature branch)에서 작업을 마친 후 병합을 위한 Pull Request(PR)를 생성하며, 이때 최소 1명 이상의 팀원에게 검토와 승인을 받아야 합니다 [1, 4]. 리뷰어는 변경된 코드에 대해 코멘트를 남기며, 작성자가 이를 수정하고 재푸시(push)하여 최종 승인을 받으면 병합이 이루어집니다 [5]. 이는 단일 개발자의 실수로 인한 잘못된 병합을 막고, 팀원 간의 건전한 리뷰 습관과 협업을 촉진합니다 [1, 6].
+- **효율적인 PR 에티켓**: 원활한 코드 리뷰를 위해서는 PR을 작게 유지하고 단일 작업(Single task)에 집중하는 것이 모범 사례입니다 [2]. 리뷰어가 한 번에 2,000줄 이상의 방대한 코드를 검사하도록 요구해서는 안 되며, PR 규모가 작을수록 더 빠르고 철저하게 검토될 수 있습니다 [2, 7].
+- **시각적 리뷰(Visual Review)의 도입**: 프론트엔드 개발의 PR 프로세스에서는 코드의 논리 검토뿐만 아니라 시각적 회귀(Visual Regression) 검토가 필수가 되었습니다 [3]. 개발자는 Storybook을 활용해 컴포넌트를 분리하여 구축하고, Chromatic이나 Happo 등의 도구를 CI 파이프라인에 통합합니다 [3, 8]. 
+- **자동화된 시각적 회귀 감지**: PR이 열리면 이 도구들이 여러 브라우저 및 뷰포트 환경에서 자동으로 모든 UI 상태의 스크린샷을 캡처하고 이전 기준선(baseline)과 비교합니다 [9, 10]. 레이아웃이나 색상 등에 의도치 않은 변경 사항이 발견되면 PR에 해당 사항이 수동 검토 대상으로 표시(flagged)되어 버그가 프로덕션 환경으로 배포되는 것을 차단합니다 [3]. 더불어, 시각적 검토 도구는 시각적 변경 사항과 함께 새로운 접근성 위반(accessibility violations)까지 포착할 수 있습니다 [9, 11].
+
+## ⚖️ Trade-offs & Caveats
+- **리뷰 병목 현상 및 복잡도 증가**: 한 번에 수천 줄에 달하는 큰 규모의 코드(PR)를 리뷰하도록 요청할 경우, 리뷰어가 코드를 철저히 감사(audit)하기 어려워 리뷰 속도와 품질이 모두 저하되는 문제가 발생합니다 [2]. 이를 피하기 위해서는 PR을 매우 작게 나누어 지속적으로 리뷰해야 하므로, 개발자는 작업 단위를 세밀하게 쪼개야 하는 추가적인 노력이 필요합니다 [2, 7].
+- **시각적 테스트의 불안정성(Flake) 이슈**: 시각적 리뷰를 위해 스크린샷 기반 테스트를 도입할 때, 컴포넌트의 기능적 변경이 없더라도 압축 노이즈, 안티앨리어싱, 비동기 에셋(폰트 등), 애니메이션 등으로 인해 미세한 픽셀 차이가 발생하여 오류로 처리되는 거짓 양성(False positive) 문제가 생길 수 있습니다 [8, 12]. 이를 해결하기 위해 색상 오차 허용 범위(color-delta tolerance)를 설정하거나 애니메이션을 음소거하는 등의 추가적인 구성(Configuration)과 관리가 요구됩니다 [8, 12, 13].
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+
+#### [협업 및 형상 관리 워크플로우]
+- [[Pull Request (PR)]]
+  - 연결 이유: 코드 리뷰가 실질적으로 요청되고, 검토 피드백이 오가는 핵심 플랫폼이자 단위입니다 [1, 2].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 브랜치 병합 전 품질 관리 게이트로서의 기능과 짧고 명확한 작업 단위 분할의 중요성을 파악할 수 있습니다.
+
+- [[Feature Branch Workflow]]
+  - 연결 이유: 코드 리뷰 시스템을 쉽게 도입하기 위한 가장 기본적이고 충돌이 적은 브랜치 전략입니다 [14, 15].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 메인 브랜치를 항상 안정적으로 유지하면서, 각각의 태스크를 독립된 브랜치에서 작업하고 리뷰를 통해 검증하는 전체 흐름을 이해할 수 있습니다.
+
+#### [자동화 및 품질 검증 도구]
+- [[Visual Regression Testing]]
+  - 연결 이유: 프론트엔드 코드 리뷰 시 육안으로 확인하기 힘든 의도치 않은 레이아웃/색상 변경을 자동화 도구가 시각적으로 찾아내어 리뷰어에게 제시합니다 [3, 9].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: Chromatic이나 Happo를 CI 파이프라인과 결합하여 PR 리뷰의 정확도를 높이고 안정적인 UI를 배포하는 프로세스를 배울 수 있습니다.
+
+### Deeper Research Questions
+
+- PR의 크기를 작게 유지하고 단일 작업(Single task)에 집중하도록 논리적으로 작업을 분할하는 가장 효과적인 방법론과 기준은 무엇인가?
+- 대규모 팀에서 쏟아지는 수많은 PR과 코드 리뷰 요청을 병목 현상 없이 효율적으로 처리하고 배포 속도를 유지하기 위한 전략은 무엇인가?
+- 시각적 회귀 테스트(Visual Regression Testing) 시 발생하는 미세한 렌더링 차이(Flake)를 방지하고 신뢰할 수 있는 기준선(Baseline)을 유지하기 위한 구체적인 구성 최적화 방법은 무엇인가?
+- 코드 리뷰 시 시각적 회귀(Visual changes) 감지뿐만 아니라, 접근성 테스트(Accessibility tests)를 함께 자동화했을 때 얻게 되는 이점과 이를 처리하는 내부 동작 원리는 무엇인가?
+- 기능 분기(Feature branch)의 수명이 길어졌을 때 발생하는 리뷰 및 병합 충돌 문제를 해결하고, 지속적으로 짧은 주기의 리뷰를 유도하는 문화는 어떻게 정착시킬 수 있는가?
+
+### Practical Application Contexts
+
+- **Implementation:** 코드를 커밋하고 PR을 생성할 때, 리뷰어가 쉽게 코드를 파악할 수 있도록 200줄 미만의 작은 단위로 변경 사항을 쪼개어 올리고 무엇이 왜 변경되었는지 명확히 명시해야 합니다 [2, 7].
+- **System Design:** 프론트엔드 설계 시 Storybook을 활용하여 모든 UI 컴포넌트의 다양한 상태(loading, error 등)를 캡슐화해 두면, 코드 리뷰 시에 이 상태들을 자동으로 스크린샷으로 찍어 검증할 수 있는 기반 시스템이 만들어집니다 [16].
+- **Operation / Maintenance:** CI/CD 파이프라인 단계에 Chromatic이나 Happo 같은 도구를 연동시켜, 팀원이 PR을 생성할 때마다 시각적 변동 사항(diff)이나 접근성 위반 내역이 PR 체크 리스트에 배지로 자동 보고되도록 운영 환경을 구축합니다 [17].
+- **Learning Path:** Git의 기초적인 브랜치 사용법을 배운 후, 팀 협업의 핵심인 PR 생성 및 리뷰 요청 과정(GitHub Flow 등)을 익히고, 나아가 시각적 테스팅 도구가 PR에 어떻게 피드백을 주는지를 실습해보는 흐름으로 학습할 수 있습니다 [8, 18].
+- **My Project Relevance:** 소규모 3인 팀 프로젝트를 진행할 때 복잡한 Git-Flow 대신 기능 브랜치 워크플로우를 채택하고, 코드 병합 시 반드시 1명 이상의 피어 리뷰(Peer review)를 받도록 규칙을 정해 버그 없는 안정적 메인 브랜치를 유지할 수 있습니다 [1, 14].
+
+### Adjacent Topics
+
+- [[Continuous Integration (CI)]]
+  - 확장 방향: PR이 올라왔을 때 코드 리뷰를 돕기 위해 사전에 테스트 통과 여부, 빌드 성공 여부 등을 자동으로 검사해주는 자동화 파이프라인의 구축에 대해 학습할 수 있습니다 [7, 19].
+
+---
+*Last updated: 2026-04-30*
\ No newline at end of file
diff --git a/00_Raw/Code Splitting.md b/00_Raw/Code Splitting.md
new file mode 100644
index 00000000..96aa31b1
--- /dev/null
+++ b/00_Raw/Code Splitting.md	
@@ -0,0 +1,58 @@
+# [[Code Splitting]]
+
+## 📌 Brief Summary
+큰 자바스크립트 번들을 더 작은 청크(chunk) 단위로 나누어 사용자가 필요로 할 때(on demand) 로드하는 프로세스입니다 [1, 2]. 모든 애플리케이션 코드를 초기에 한 번에 다운로드하는 대신, 필요한 파일만 먼저 불러오게 하여 초기 번들 크기를 극적으로 줄일 수 있습니다 [2, 3]. 결과적으로 초기 페이지 로드 속도를 향상시키고, 애플리케이션의 체감 성능을 개선하는 핵심적인 프론트엔드 최적화 기법입니다 [1, 4].
+
+## 📖 Core Content
+* **라우트 기반 분할 (Route-level Code Splitting):** 가장 일반적이고 효과적인 접근 방식입니다. 사용자가 특정 라우트로 이동할 때만 해당 페이지의 코드를 다운로드하도록 하여 초기 로딩 시 불필요한 코드 다운로드를 방지합니다 [1, 2, 5].
+* **컴포넌트 수준 지연 로딩 (Component-level Lazy Loading):** 차트, 지도, 리치 텍스트 에디터처럼 크고 무거운 컴포넌트나 드물게 사용되는 모달, 설정 패널 등을 렌더링이 필요한 시점에만 로드하도록 분리합니다 [6, 7]. React에서는 `React.lazy()`와 동적 임포트(dynamic imports), 그리고 `<Suspense>`를 활용해 이를 쉽게 구현할 수 있습니다 [4, 6, 8].
+* **벤더 라이브러리 분할 (Vendor Splitting):** Vite(내부적으로 Rollup 사용) 등의 번들러를 사용할 때 `manualChunks` 옵션을 통해 React 코어 라이브러리나 차트 등 무거운 벤더 코드를 별도의 파일로 분할합니다 [5, 9, 10]. 벤더 라이브러리는 자주 변경되지 않기 때문에 브라우저 캐싱 효율을 극대화할 수 있습니다 [5, 11].
+* **번들러의 자동화 지원:** 최신 번들러(Webpack, Vite)는 코드 내에 작성된 동적 임포트(`import()`)를 감지하면 자동으로 해당 코드를 별도의 청크로 분리합니다 [4, 6].
+
+## ⚖️ Trade-offs & Caveats
+* **필수 컴포넌트에 대한 오남용 금지:** 페이지에 즉시 필요한 스크롤 없이 볼 수 있는(above-the-fold) 핵심 컴포넌트나, 렌더링 속도가 빨라야 하는 요소에는 지연 로딩과 코드 분할을 피해야 합니다 [7]. 오히려 첫 화면을 그리는 시간을 지연시킬 수 있습니다.
+* **사용자 경험 저하 방지 (Fallback UI 필요):** 코드를 동적으로 불러오는 동안 네트워크 지연이 발생할 수 있습니다. 따라서 `<Suspense>`를 사용해 모듈이 로드되는 동안 스피너나 스켈레톤과 같은 Fallback UI를 제공해야 합니다 [5, 8]. 
+* **네트워크 요청 증가의 위험:** 너무 잘게 코드를 분할하면 오히려 수많은 네트워크 요청이 발생해 오버헤드가 발생할 수 있습니다. 따라서 번들 크기를 시각적으로 분석할 수 있는 `rollup-plugin-visualizer` 등의 도구를 사용해 500kB 이상의 큰 청크를 타겟으로 식별하고 적절하게 분할해야 합니다 [12, 13].
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+
+#### [아키텍처/기반 기술]
+- [[Lazy Loading]]
+  - 연결 이유: 코드 분할이 번들을 쪼개는 행위라면, 지연 로딩(Lazy Loading)은 그 쪼개진 코드를 필요 시점에 로드하는 기술적 방법론입니다 [2, 3].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 분할된 코드가 언제 브라우저로 전송되고 애플리케이션에 병합되는지 이해할 수 있습니다 [8].
+- [[Core Web Vitals]]
+  - 연결 이유: 코드 분할을 적용하는 주된 성능적 목적은 초기 자바스크립트 실행을 최소화하여 LCP(Largest Contentful Paint)와 INP(Interaction to Next Paint) 같은 핵심 웹 지표를 향상시키는 데 있습니다 [1, 8, 14].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 최적화 결과가 실제 사용자의 체감 성능 및 페이지 측정 지표에 어떻게 긍정적 영향을 주는지 평가할 수 있습니다 [15].
+
+#### [구현/활용 도구]
+- [[React.lazy() and Suspense]]
+  - 연결 이유: React 애플리케이션에서 컴포넌트 레벨 및 라우트 레벨의 동적 코드 분할을 구현하기 위해 사용하는 공식 API입니다 [6, 8].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 동적 임포트 처리 과정에서의 비동기 UI 렌더링 흐름과 예외(지연) 처리 방식을 배울 수 있습니다 [5].
+- [[Vite (Rollup)]]
+  - 연결 이유: 개발 및 프로덕션 환경에서 자바스크립트 애플리케이션을 번들링하고 실제 물리적인 청크 파일들로 분리해 내는 도구입니다 [9, 11].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 번들러의 `manualChunks` 설정을 통해 어떻게 벤더 라이브러리와 애플리케이션 코드를 효율적으로 나누어 브라우저 캐싱을 활용할 수 있는지 이해할 수 있습니다 [5].
+
+### Deeper Research Questions
+- 라우트 기반 분할과 컴포넌트 기반 분할을 어느 정도 비율로 적용해야 초기 렌더링 성능과 이후 탐색 시의 네트워크 지연 간의 균형을 이룰 수 있는가?
+- Vite나 Webpack 환경에서 `manualChunks`를 설정할 때, 브라우저의 HTTP/2 및 HTTP/3 다중화(multiplexing) 환경을 고려한 가장 이상적인 청크 개수와 크기는 무엇인가?
+- 동적 청크(chunk)를 로드하는 도중 사용자의 네트워크 연결이 끊기거나 에러가 발생할 경우, React Error Boundaries와 결합하여 어떻게 안정적인 Fallback 경험을 설계할 것인가?
+- 코드 분할로 인해 컴포넌트가 지연 로드될 때, 해당 컴포넌트가 의존하는 상태(Context, Zustand 등)는 로드 시점에 어떻게 동기화되는가?
+- Above-the-fold UI에 잘못 지연 로딩을 적용했을 때 LCP 점수에 미치는 악영향을 확인하려면 브라우저 개발자 도구의 성능(Performance) 패널에서 어떤 지표를 중점적으로 모니터링해야 하는가?
+
+### Practical Application Contexts
+- **Implementation:** React 코드에서 `import { Chart } from 'chart.js'`와 같은 정적 임포트를 제거하고, `const HeavyComponent = React.lazy(() => import('./HeavyComponent'))`로 감싸서 특정 버튼이 눌리거나 라우트가 전환될 때 렌더링되게 구현합니다 [4, 6, 8].
+- **System Design:** 아키텍처 설계 시, 모든 코드가 포함된 하나의 `index.js` 모놀리스 번들 대신, Vite의 `vite.config.ts`에서 `manualChunks` 설정을 통해 React 코어 및 무거운 서드파티 라이브러리를 별개의 캐싱 가능한 청크로 분리하도록 설계합니다 [5, 10].
+- **Operation / Maintenance:** CI/CD 파이프라인이나 로컬 빌드 과정에 `rollup-plugin-visualizer` 등의 번들 분석 도구를 연결하여 시각적 트리맵을 확인하고, 500kB를 초과하는 거대 청크가 발견되면 추가적인 분할 대상을 식별하여 최적화합니다 [4, 12, 13].
+- **Learning Path:** 우선 React의 번들링 개념을 이해한 후, 동적 임포트 구문 활용 -> `React.lazy()` 및 `<Suspense>` 적용 -> 라우터에 코드 분할 결합 -> 번들 분석기 및 Core Web Vitals 측정을 통한 효과 검증 순서로 지식을 확장합니다 [6, 8].
+- **My Project Relevance:** 프로젝트 규모가 커짐에 따라 메인 자바스크립트 번들이 수 메가바이트 단위로 무거워져 모바일 기기 등에서 로딩 속도 저하 현상이 보일 경우, 즉각적으로 라우트 기반 코드 분할과 차트/에디터 등 무거운 UI의 지연 로딩을 도입하여 LCP 문제를 해결할 수 있습니다 [3, 14, 16].
+
+### Adjacent Topics
+- [[Tree Shaking]]
+  - 확장 방향: 코드 분할이 필요한 코드를 '쪼개어' 가져오는 방식이라면, 트리 쉐이킹은 사용되지 않는 죽은 코드(Dead Code) 자체를 번들에서 '제거'하여 초기 번들 크기를 줄이는 상호 보완적인 최적화 기법입니다 [17, 18].
+- [[Server Components (Next.js)]]
+  - 확장 방향: 클라이언트 사이드의 코드 분할에서 더 나아가, 아예 정적인 UI 렌더링을 서버에서 처리하여 클라이언트로 보내는 자바스크립트 번들의 양 자체를 획기적으로 줄이거나 제거하는 최신 아키텍처 접근법입니다 [19-21].
+
+---
+*Last updated: 2026-04-30*
\ No newline at end of file
diff --git a/00_Raw/Concurrent Features.md b/00_Raw/Concurrent Features.md
new file mode 100644
index 00000000..2c5c54ed
--- /dev/null
+++ b/00_Raw/Concurrent Features.md	
@@ -0,0 +1,56 @@
+# [[Concurrent Features]]
+
+## 📌 Brief Summary
+Concurrent Features는 React 18부터 도입된 기능으로, 렌더링 작업을 일시 중지(pause), 중단(interrupt), 재개(resume)할 수 있게 해주는 기능입니다 [1]. 이를 통해 중요한 사용자 상호작용(클릭, 타이핑 등)의 우선순위를 높이고, 상대적으로 느린 업데이트(대용량 필터링 등)를 지연시킬 수 있습니다 [1]. 결과적으로 앱의 실제 연산 속도 자체를 마법처럼 빠르게 만드는 것은 아니지만, 인지되는 속도(perceived speed)를 최적화하여 사용자 인터페이스를 반응성 있게 유지합니다 [2].
+
+## 📖 Core Content
+*   **동시성 렌더링(Concurrent Rendering)의 원리:** 최신 버전의 React에서 기본적으로 동작하는 방식으로, 렌더링 작업의 우선순위를 지정하여 중요도가 높은 상호작용이 렌더링에 의해 차단(block)되지 않고 즉시 반응하도록 돕습니다 [1].
+*   **`useTransition`을 통한 우선순위 제어:** 특정 상태 업데이트를 '긴급하지 않은(non-urgent)' 것으로 표시하여 지연시키는 훅(Hook)입니다 [3]. 실시간 검색 결과나 대용량 데이터 필터링 시, 사용자의 타이핑 같은 입력은 즉각적으로 반응하게 하면서 무거운 렌더링 처리는 뒤로 미룰 수 있습니다 [3]. 또한 `isPending` 상태를 활용해 입력 즉각성을 막지 않고 로딩 스피너나 스켈레톤 UI를 표시할 수도 있습니다 [3].
+*   **`useDeferredValue`를 통한 값 참조 지연:** `useTransition`이 업데이트를 언제 발생시킬지를 관리한다면, `useDeferredValue`는 무거운 값을 언제 '읽을지'를 제어합니다 [4]. 입력과 같은 UI 변경은 즉시 반영하면서, 파생되는 무거운 로직 적용은 살짝 지연시켜 실시간 폼(form) 등에서 발생하는 끊김 현상(jank)을 줄여줍니다 [4].
+*   **프레임워크 지원 환경:** 2025년 기준 Next.js(App Router), Remix, Vite + React 18+ 환경 등 대부분의 풀스택 및 번들러 프레임워크에서 기본적으로 동시성 렌더링 기능이 통합되어 지원됩니다 [2].
+
+## ⚖️ Trade-offs & Caveats
+*   **성능 향상의 본질적 한계:** 이 기능들은 앱의 실제 연산 속도를 물리적으로 높여주는 것이 아니라 "인지되는 속도(perceived speed)"를 우선시하는 기능입니다 [2]. 백그라운드 작업이 계속 진행되는 동안 UI의 반응성을 유지할 뿐, 실행해야 할 연산량 자체가 줄어드는 것은 아닙니다 [2].
+*   **선별적 사용 요구:** 모든 컴포넌트에 전역적으로 사용해서는 안 되며, 주로 '상호작용이 많은 뷰(interactive views)'에 선별적으로 적용해야 합니다 [4]. 
+*   **호환성 문제:** 렌더링을 차단하는(render-blocking) 구식 패턴(가드가 없는 클래스 컴포넌트 등)이나 오래된 상태 관리 라이브러리와 섞어서 사용하면 정상적으로 동작하지 않거나 성능 문제를 야기할 수 있습니다 [4].
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+
+#### [관계 유형 A: 아키텍처/기반 기술]
+- [[useTransition]]
+  - 연결 이유: 상태 업데이트를 긴급하지 않은 것으로 표시하여 지연시킬 수 있는 Concurrent Feature의 핵심 요소입니다 [3].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: React가 렌더링 우선순위를 조정하여 사용자 입력 반응성을 잃지 않게 유지하는 구체적인 메커니즘.
+
+- [[useDeferredValue]]
+  - 연결 이유: 비용이 큰 파생 데이터의 렌더링 반영 시점을 지연시켜 UI 끊김을 막는 또 다른 주요 요소입니다 [4].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 상태의 업데이트 시점이 아닌, 계산된 값을 읽어 들이는 시점을 분리하는 최적화 전략.
+
+#### [관계 유형 B: 구현/활용 도구]
+- [[Suspense]]
+  - 연결 이유: Concurrent Feature(특히 `useTransition`)와 결합하여 무거운 렌더링이나 데이터가 로드되는 동안 Fallback UI를 유연하게 표시하는 데 사용됩니다 [4].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 비동기 로딩 상태에서 사용자 경험(UX)을 부드럽게 설계하는 선언적 UI 패턴.
+
+### Deeper Research Questions
+- Concurrent Rendering이 동작할 때 브라우저의 메인 스레드는 내부적으로 어떻게 작업을 일시 중지하고 재개(pause, interrupt, resume)하는가?
+- `useTransition`과 `useDeferredValue`는 구체적으로 어떤 상황에서 각각 선택적으로 사용되어야 하며, 두 가지를 함께 사용할 때 발생하는 제약 사항은 없는가?
+- 구식 상태 관리 라이브러리(outdated state libraries)가 Concurrent Features와 섞였을 때 충돌이 발생하는 기술적 원리는 무엇인가?
+- 인지되는 속도(perceived speed)를 개선하기 위해 Concurrent 기능을 과도하게 사용했을 때 발생하는 메모리나 스케줄링 오버헤드는 어느 정도인가?
+- Next.js나 Remix 같은 최신 프레임워크는 내부적으로 Concurrent Features를 어떻게 활용하여 스트리밍(streaming) 업데이트와 같은 성능 향상을 이끌어내는가?
+
+### Practical Application Contexts
+- **Implementation:** 실시간 검색창, 타입어헤드(Typeahead) 입력기, 복잡한 데이터 그리드 필터링 등 사용자 입력이 발생할 때마다 무거운 UI를 다시 그려야 하는 곳에 구현하여 입력이 버벅이지 않도록 만듭니다 [3, 4].
+- **System Design:** 사용자의 즉각적인 피드백이 필요한 뷰와, 백그라운드에서 지연 렌더링되어도 무방한 컴포넌트를 분리하여 시스템 구조 및 우선순위를 기획합니다 [4].
+- **Operation / Maintenance:** 애플리케이션 프로파일링 중 입력 지연(Input Lag)이 빈번하게 보고되는 부분을 찾아내고, 해당 부분에 렌더링 차단 패턴이 없는지 점검하여 Concurrent 기능을 점진적으로 도입합니다 [4, 5].
+- **Learning Path:** 단순한 React Hook(`useState`, `useEffect`)의 렌더링 과정을 이해한 후, 메모이제이션 최적화(`React.memo`, `useCallback`)를 배우고, 최종적으로 렌더링의 우선순위를 제어하는 고급 최적화 과정으로 Concurrent 기능을 학습합니다.
+- **My Project Relevance:** 검색 필터가 많은 대시보드나 실시간 데이터 시각화 차트를 구축할 때 UI 스레드가 멈추는 것을 방지하여 사용자 경험을 크게 개선하는 데 직접적으로 적용될 수 있습니다.
+
+### Adjacent Topics
+- [[Server Components]]
+  - 확장 방향: 클라이언트에서 렌더링을 지연시키거나 최적화하는 것을 넘어, 무거운 렌더링 작업 자체를 서버로 완전히 옮겨 클라이언트의 자바스크립트 번들 크기와 실행 부담을 근본적으로 줄이는 방법론 탐구 [6, 7].
+- [[Code Splitting & Lazy Loading]]
+  - 확장 방향: 화면의 렌더링 과정을 매끄럽게 하는 것을 넘어, 초기 애플리케이션 로딩 시 네트워크를 통해 다운로드하는 코드의 양 자체를 분할하여 초기 응답성(Time to Interactive)을 향상시키는 전략 탐구 [8, 9].
+
+---
+*Last updated: 2026-04-30*
\ No newline at end of file
diff --git a/00_Raw/Concurrent Rendering in React 18+.md b/00_Raw/Concurrent Rendering in React 18+.md
new file mode 100644
index 00000000..b20eeb11
--- /dev/null
+++ b/00_Raw/Concurrent Rendering in React 18+.md	
@@ -0,0 +1,62 @@
+# [[Concurrent Rendering in React 18+]]
+
+## 📌 Brief Summary
+React 18+의 동시성 렌더링(Concurrent Rendering)은 React가 렌더링 작업을 일시 중지, 중단 및 재개할 수 있도록 하는 강력한 기능입니다 [1]. 이를 통해 개발자는 업데이트 발생 시기와 방식을 세밀하게 제어할 수 있으며, 사용자의 상호작용성을 저하시키지 않으면서도 화면이 멈추지 않는 더 부드럽고 반응성 높은 애플리케이션을 구축할 수 있습니다 [1, 2].
+
+## 📖 Core Content
+
+**동시성 렌더링의 개념과 이점**
+*   React 18부터 도입된 동시성 기능은 렌더링 작업의 우선순위를 동적으로 지정할 수 있게 해줍니다. 렌더링 작업을 차단하지 않고, 느린 데이터 필터링 업데이트 등을 지연시키는 동시에 클릭이나 타이핑과 같은 중요한 사용자 상호작용에 즉각적으로 반응하도록 렌더링을 일시 중지하거나 재개할 수 있습니다 [1]. 이는 최신 React 버전의 기본 동작으로 내장되어 있습니다 [1].
+
+**주요 동시성 훅(Hooks)**
+*   **`useTransition`:** 특정 상태 업데이트를 '긴급하지 않은(non-urgent)' 것으로 표시하여 지연시킬 수 있는 훅입니다 [3]. 실시간 검색 결과 표시, 대규모 데이터 세트 필터링, 복잡한 차트 및 테이블 렌더링과 같은 무거운 작업이 사용자의 즉각적인 상호작용을 차단하지 못하게 합니다 [3]. 제공되는 `isPending` 상태를 활용하여 메인 스레드를 차단하지 않고 로딩 스피너나 스켈레톤 UI를 표시할 수 있습니다 [3].
+*   **`useDeferredValue`:** `useTransition`이 업데이트를 트리거하는 시점을 제어한다면, `useDeferredValue`는 비용이 많이 드는 값을 *읽고 적용하는 시점*을 지연시킵니다 [4]. 검색창의 입력 값 등 UI 변경 사항은 즉시 반영하면서, 파생되는 무거운 계산 로직은 약간 지연시켜 실시간 폼이나 인터페이스에서의 화면 끊김(Jank) 현상을 줄여줍니다 [4].
+
+**사용 모범 사례 및 프레임워크 지원**
+*   동시성 기능은 앱의 모든 곳이 아닌 '상호작용이 집중된 뷰'에 전략적으로 사용해야 합니다 [4]. 데이터가 로드되는 동안 대체 UI를 자연스럽게 보여주기 위해 `Suspense`와 결합하는 것이 권장됩니다 [4]. 
+*   주의할 점은 구식 상태 관리 라이브러리나 렌더링을 차단하는 패턴(예: 가드 로직이 없는 오래된 클래스 컴포넌트)과 혼용해서는 안 된다는 것입니다 [4]. 
+*   이러한 기능들은 연산 속도 자체를 물리적으로 높이는 것이 아니라, 백그라운드에서 작업이 계속되는 동안 UI가 반응하도록 유지함으로써 '체감 속도(perceived speed)'를 우선시하는 도구입니다 [4].
+*   2025년 기준 Next.js(App Router), Remix, Vite + React 18 등 대부분의 최신 풀스택 프레임워크는 기본적으로 이 동시성 렌더링을 완전히 통합하여 지원하고 있습니다 [5].
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+
+- [[useTransition]]
+  - 연결 이유: 동시성 렌더링 환경에서 특정 상태 업데이트를 '긴급하지 않은 작업'으로 명시적으로 분류하기 위해 사용되는 핵심 훅입니다 [3].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 상태 업데이트의 우선순위를 낮추어 사용자 입력에 대한 메인 스레드 차단을 방지하는 구체적인 제어 방법.
+
+- [[useDeferredValue]]
+  - 연결 이유: 연산 비용이 높은 값의 화면 적용 시점을 늦추어 UI의 즉각적인 체감 반응성을 향상시키는 동시성 기능이기 때문입니다 [4].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 사용자 입력(타이핑 등)의 즉각적인 반영과 무거운 파생 데이터 렌더링 간의 처리 시점을 분리하는 메커니즘.
+
+- [[Suspense]]
+  - 연결 이유: 동시성 훅(`useTransition` 등)과 결합하여 비동기 처리나 지연된 렌더링이 완료되기 전까지 자연스러운 대체 UI(Fallback UI)를 표시하는 역할을 합니다 [4].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 비동기 데이터 로딩 과정에서 동시성 렌더링을 활용한 부드러운 사용자 경험(UX) 설계 방식.
+
+### Deeper Research Questions
+
+- React의 동시성 렌더링 엔진은 내부적으로 긴급 업데이트와 지연 업데이트의 우선순위를 어떤 스케줄링 알고리즘으로 관리하는가?
+- `useTransition`과 `useDeferredValue`를 복잡한 단일 컴포넌트 내에서 함께 사용할 때 발생할 수 있는 렌더링 엣지 케이스나 성능적 트레이드오프는 무엇인가?
+- 구식 상태 관리 라이브러리(Context API를 잘못 사용하는 경우 등)가 React 18의 동시성 렌더링 패턴을 방해할 때 발생하는 정확한 기술적 원리(예: Tearing 현상)는 무엇인가?
+- 동시성 렌더링의 도입이 브라우저의 INP(Interaction to Next Paint)와 TBT(Total Blocking Time) 지표 최적화에 수학적으로 어떤 연관성을 가지는가?
+- 동시성 렌더링으로 인해 렌더링 트리가 중단(Interrupt)되고 폐기된 후 다시 시작될 때, 불필요한 메모리 누수를 방지하기 위한 React의 내부 최적화 메커니즘은 무엇인가?
+
+### Practical Application Contexts
+
+- **Implementation:** 라이브 검색 결과창, 대규모 데이터 세트 필터링 기능 구현 시 `useTransition`과 `useDeferredValue`를 적극 활용하여 입력 중 발생하는 화면 멈춤(Jank) 방지 [3, 4].
+- **System Design:** 아키텍처 설계 시 기본적으로 동시성 렌더링이 활성화된 Next.js App Router나 Remix와 같은 최신 React 프레임워크를 도입하여 반응성 이점을 극대화 [5].
+- **Operation / Maintenance:** 기존 레거시 코드베이스에서 렌더링을 차단하는 요소(오래된 클래스 컴포넌트 등)를 리팩토링하고, 동시성 기능이 충돌 없이 작동할 수 있도록 유지보수 환경 개선 [4].
+- **Learning Path:** 전통적인 '동기적 렌더링(Synchronous Rendering)' 모델이 가진 한계를 벗어나, 작업 단위의 일시 중지와 재개가 가능한 렌더링 패러다임으로 개발자의 사고 방식을 전환.
+- **My Project Relevance:** 현재 진행 중인 서비스 내 무거운 대시보드 화면이나 복잡한 검색 인터페이스에서 사용자가 직접 체감하는 '인식 속도(Perceived Speed)'를 최적화하는 아키텍처 개선 지표로 활용 [3, 4].
+
+### Adjacent Topics
+
+- [[React Server Components]]
+  - 확장 방향: 동시성 렌더링과 함께 Next.js App Router 환경의 핵심 성능 최적화 축을 이루며, 클라이언트 측 자바스크립트 번들을 획기적으로 줄여주는 서버 컴포넌트의 렌더링 원리 탐구 [5, 6].
+
+- [[Core Web Vitals (INP/TBT)]]
+  - 확장 방향: 동시성 렌더링 기능 적용이 웹의 핵심 반응성 지표인 INP 및 TBT를 어떻게 개선하는지 실제 성능 측정 툴(Chrome DevTools, Lighthouse) 데이터와 연계하여 조사 [7-9].
+
+---
+*Last updated: 2026-04-30*
\ No newline at end of file
diff --git a/00_Raw/Context API.md b/00_Raw/Context API.md
new file mode 100644
index 00000000..b0dfba57
--- /dev/null
+++ b/00_Raw/Context API.md	
@@ -0,0 +1,46 @@
+# [[Context API]]
+
+## 📌 Brief Summary
+Context API는 React에 내장된 상태 공유 솔루션으로, 컴포넌트 트리의 모든 레벨을 통해 명시적으로 props를 전달하지 않고도 데이터를 전송할 수 있게 해주는 기능입니다 [1, 2]. 이는 독립적인 상태 관리 도구라기보다는 데이터를 전달하는 브로드캐스트 전송 메커니즘에 가깝습니다 [3, 4]. 주로 테마, 다국어 설정 등 변경이 거의 없는 정적인 데이터를 전역적으로 공유할 때 적합하게 사용됩니다 [5, 6].
+
+## 📖 Core Content
+* **작동 방식 및 구조:** Context API는 `React.createContext()`를 호출하여 생성되며, 상태 값을 제공하는 `Provider`와 데이터를 읽는 `Consumer`(실무에서는 주로 `useContext` 훅)로 구성됩니다 [4]. Provider는 값을 브로드캐스트하고, 트리의 어느 깊이에 있든 `useContext`를 호출하여 해당 값을 읽을 수 있습니다 [4]. 단, 상태 자체를 관리하려면 `useState`나 `useReducer`와 같은 훅과 반드시 함께 사용해야 합니다 [4, 7].
+* **성능적 한계와 리렌더링 폭포:** Context의 가장 큰 단점은 성능 관리입니다 [8]. Context로 전달되는 값 중 일부만 변경되더라도, 해당 Context를 구독하는 **모든 컴포넌트가 리렌더링**됩니다 [8, 9]. React는 특정 데이터 부분만 사용하는 컴포넌트를 구별해 내지 못하므로, 상태 변경이 잦은 대규모 애플리케이션에서는 전체 대시보드가 수 초간 멈추는 등 심각한 성능 병목을 초래할 수 있습니다 [1, 10].
+* **구조적 최적화 전략:** 이러한 리렌더링 문제를 피하기 위해 애플리케이션의 모든 상태를 하나의 'Global Context'에 담는 안티 패턴을 피해야 합니다 [11, 12]. 대신 `ThemeContext`, `NotificationContext`처럼 상태를 여러 개의 작은 도메인별 Context로 분리하고, 커스텀 훅과 Selector 패턴을 활용해 필요한 값만 스코프를 좁혀 사용하는 것이 권장됩니다 [12, 13].
+* **사용의 적합성:** 테마(라이트/다크 모드), 언어 환경 설정, 기능 플래그 등 **변경 빈도가 매우 낮고 정적인 데이터**를 공유하거나 외부 종속성을 추가하고 싶지 않은 작은 프로젝트 및 라이브러리 개발에 완벽한 선택입니다 [5, 6, 14]. 반면, 실시간 데이터, 자주 업데이트되는 장바구니, 복잡한 비동기 작업이 필요한 경우에는 Context를 피하고 Zustand나 Redux를 사용하는 것이 좋습니다 [15-18].
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+- [[Prop Drilling]]
+  - 연결 이유: 부모 컴포넌트에서 깊게 중첩된 자식 컴포넌트로 데이터를 전달하기 위해 불필요한 중간 컴포넌트들을 거쳐야 하는 패턴입니다 [2]. 
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: Context API가 탄생하게 된 근본적인 배경과, 데이터를 어떻게 트리 아래로 "건너뛰어" 전달하는지 그 목적을 이해할 수 있습니다 [2, 19].
+- [[useContext]]
+  - 연결 이유: Context API의 Provider가 제공하는 브로드캐스트 값을 읽기 위해 개별 컴포넌트 내부에서 호출하는 React의 내장 훅입니다 [4].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 구독(Subscription)이 발생하는 정확한 지점과, 값이 변경될 때 어떤 컴포넌트에서 리렌더링이 트리거되는지 렌더링 동작 원리를 파악할 수 있습니다 [8].
+- [[Zustand]]
+  - 연결 이유: Context API의 리렌더링 한계와 보일러플레이트를 극복하기 위해 자주 비교되고 채택되는 경량 상태 관리 라이브러리입니다 [20, 21].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: Zustand의 'Selector 패턴'이 어떻게 특정 상태 슬라이스만 구독하게 하여 Context API의 "전체 리렌더링" 문제를 해결하는지 성능 최적화의 차이를 비교할 수 있습니다 [8, 10].
+
+### Deeper Research Questions
+- Context API와 외부 상태 관리 라이브러리(Zustand, Redux)를 동일한 애플리케이션 내에서 효율적으로 혼용(Hybrid)하기 위해, 정적 상태와 동적 상태를 분리하는 최적의 아키텍처 설계 기준은 무엇인가?
+- Context API의 "브로드캐스트" 특성으로 인한 불필요한 리렌더링을 방지하기 위해 도메인별로 Context를 쪼갤 때, 코드의 유지보수성을 잃지 않으면서도 성능을 잡을 수 있는 적절한 분리 입도(Granularity)는 어느 정도인가?
+- `use-context-selector`와 같은 외부 라이브러리를 사용하여 Context API의 리렌더링 문제를 우회하는 방식은, 처음부터 Zustand나 Redux를 도입하는 것과 비교하여 도입 비용 및 장기적 확장성 측면에서 어떤 장단점을 가지는가?
+- 의존성 주입(Dependency Injection)의 목적으로 Context API를 사용할 때, 테스트 환경(Jest 등)이나 Storybook에서 Provider 모킹(Mocking)을 설계할 때 발생할 수 있는 취약점과 해결책은 무엇인가?
+- 대규모 애플리케이션에서 무분별한 `useEffect`와 Context API가 결합되었을 때 발생하는 '리렌더링 폭풍(Re-render storm)'을 React DevTools Profiler로 진단하고 리팩토링하는 구체적인 과정은 어떻게 되는가?
+
+### Practical Application Contexts
+- **Implementation:** React 프로젝트에서 `React.createContext()`로 테마나 로케일 정보를 정의하고, 최상위 레이어(`app/` 또는 최상위 컴포넌트)를 `Provider`로 감싼 뒤, 내부 컴포넌트에서 `useContext`를 통해 해당 설정값을 불러와 UI에 즉각적으로 적용합니다 [4, 22, 23].
+- **System Design:** 아키텍처 설계 시 상태의 '변경 빈도'에 따라 저장소를 이원화합니다. 다크모드, 로그인 여부 같은 정적인 설정은 Context API에 배치하고, 장바구니나 실시간 알림처럼 수시로 변하는 데이터는 Zustand나 Redux 같은 외부 스토어에 배치하여 불필요한 렌더링 전파를 방지합니다 [24].
+- **Operation / Maintenance:** 성능 프로파일링 시 사용자 인터랙션 이후 대시보드가 일시적으로 멈추는 현상이 발견되면, React DevTools의 Profiler를 이용해 원인을 분석합니다. 원인이 단일 Context 업데이트에 의한 수백 개 컴포넌트의 리렌더링으로 확인될 경우, Context를 잘게 쪼개거나 다른 상태 관리 도구로 마이그레이션하는 유지보수 결정을 내립니다 [1, 25].
+- **Learning Path:** React 상태 관리를 처음 배우는 단계에서, 컴포넌트 간 Props 전달의 피로도를 줄이는 첫 번째 도구로 학습됩니다. 이후 실제 복잡한 앱을 만들며 한계를 경험하고, Redux의 보일러플레이트 구조나 Zustand의 독립된 스토어 개념을 자연스럽게 받아들이게 하는 핵심 학습 경로입니다 [14, 26, 27].
+- **My Project Relevance:** 기존 코드베이스에 'Global Context' 안티 패턴(모든 상태를 한 곳에 몰아넣은 형태)이 존재하지 않는지 점검하고 [11], 렌더링 병목이 있는 경우 `useMemo`, `useCallback`과 함께 Context를 책임별로 분할하는 리팩토링 목표와 직접적으로 연관됩니다 [1, 12].
+
+### Adjacent Topics
+- [[React.memo]]
+  - 확장 방향: Context API에 의해 발생하는 불필요한 하위 컴포넌트 렌더링을 방지하기 위한 얕은 비교(Shallow Compare) 최적화 도구로, 렌더링 성능 최적화(Performance Optimization) 기법 전반으로의 이해를 확장합니다 [28, 29].
+- [[Concurrent Rendering]]
+  - 확장 방향: React 18의 동시성 렌더링 기능(`useTransition`, `useDeferredValue`)을 통해 무거운 컴포넌트 렌더링을 어떻게 지연시키고 애플리케이션의 반응성을 개선할 수 있는지 상태 업데이트 흐름으로 탐구를 확장합니다 [6, 30].
+
+---
+*Last updated: 2026-04-30*
\ No newline at end of file
diff --git a/00_Raw/Debugging Frontend Applications.md b/00_Raw/Debugging Frontend Applications.md
new file mode 100644
index 00000000..51a64a0b
--- /dev/null
+++ b/00_Raw/Debugging Frontend Applications.md	
@@ -0,0 +1,74 @@
+# [[Debugging Frontend Applications]]
+
+## 📌 Brief Summary
+프론트엔드 디버깅은 웹 애플리케이션에서 발생하는 자바스크립트 런타임 에러, 메모리 누수, 그리고 불필요한 리렌더링과 같은 성능 저하 요인을 식별하고 해결하는 과정입니다 [1-3]. Chrome DevTools와 같은 브라우저 내장 도구부터 React DevTools, 그리고 Sentry나 LogRocket과 같은 프로덕션 클라우드 로깅 도구를 활용하여 문제의 근본 원인을 추적합니다 [4-7]. 효과적인 디버깅 전략과 에러 핸들링 아키텍처는 애플리케이션의 안정성을 보장하고 사용자 경험을 최적화하는 데 필수적입니다 [8-10].
+
+## 📖 Core Content
+
+*   **메모리 누수(Memory Leaks) 탐지 및 해결:** 
+    *   메모리 누수는 할당된 메모리가 더 이상 필요하지 않음에도 해제되지 않을 때 발생하며, 앱 속도 저하와 브라우저 탭 충돌을 유발합니다 [2, 11]. 
+    *   Chrome DevTools의 Task Manager를 통해 실시간 JavaScript 메모리 사용량을 확인하고, Performance 탭의 기록을 통해 시간 경과에 따른 메모리 증가 패턴을 시각화할 수 있습니다 [12, 13].
+    *   Memory 패널의 **Heap Snapshots**을 사용하여 스냅샷 간의 차이(Delta)를 비교함으로써, DOM에서 제거되었으나 자바스크립트 참조가 남아있는 'Detached DOM nodes'를 식별할 수 있습니다 [14-17]. 또한, **Allocation Timeline**을 통해 새로운 메모리가 언제 할당되는지 추적하여 누수 후보를 찾아냅니다 [18, 19].
+*   **React 컴포넌트 및 성능 디버깅:**
+    *   **리렌더링 원인 추적:** React DevTools의 Profiler를 사용해 어떤 컴포넌트가 언제, 왜 렌더링되었는지 파악할 수 있으며, 개발 전용 라이브러리인 `why-did-you-render`를 통해 실제 props나 상태 변경 없이 발생하는 불필요한 리렌더링을 콘솔 경고로 확인할 수 있습니다 [7, 20].
+    *   **React Error Boundaries:** React 애플리케이션에서는 Error Boundary라는 클래스 컴포넌트를 활용하여 하위 컴포넌트 트리의 렌더링, 생명주기 메서드, 생성자에서 발생하는 에러를 포착합니다 [1]. 이는 UI를 위한 `try-catch` 블록 역할을 하며, 앱 전체가 충돌하는 대신 Fallback UI를 표시하여 앱의 나머지 부분을 상호작용 가능한 상태로 유지합니다 [1, 8, 10].
+*   **상태 관리 도구와 디버깅 편의성:**
+    *   상태 관리 도구의 선택은 디버깅 경험에 큰 영향을 미칩니다. Context API는 상태 변경 기록 추적이나 시간 여행(Time-travel) 디버깅이 불가능하여 버그 원인을 파악하기 어렵습니다 [21]. 반면, Redux는 Redux DevTools를 통해 어떤 액션이 언제 디스패치되었는지 확인하고, 상태 이력을 검사 및 재생(Replay)할 수 있어 복잡한 비동기 에러를 신속하게 디버깅할 수 있습니다 [21, 22].
+*   **프로덕션 환경 모니터링 및 로깅:**
+    *   배포된 프로덕션 앱에서는 Sentry, LogRocket, Datadog RUM 등의 클라우드 로깅 툴을 통해 사용자가 경험하는 에러를 모니터링합니다 [23-25].
+    *   Sentry는 지능형 에러 그룹화(Error grouping)와 에러 발생 전의 콘솔 로그, 네트워크 요청 등을 보여주는 빵부스러기(Breadcrumb) 트레일을 제공합니다 [4, 25]. LogRocket은 사용자의 전체 화면을 녹화하듯 DOM 및 Redux/Vuex 상태 변화까지 캡처하는 세션 리플레이(Session replay) 기능으로 상세한 디버깅 컨텍스트를 제공합니다 [5]. Datadog RUM은 프론트엔드 에러를 백엔드 분산 트레이싱(Distributed tracing)과 상관관계 지어(Correlation) 복잡한 시스템의 에러를 파악하게 해줍니다 [24].
+
+## ⚖️ Trade-offs & Caveats
+
+*   **클라우드 로깅 도구의 성능 및 비용 문제:** 모니터링 도구들은 렌더링 성능 및 번들 크기에 직접적인 영향을 미칩니다. 일부 도구 구현 시 최대 120ms의 추가 로드 시간이 발생할 수 있습니다 [26]. 또한, Datadog과 같은 툴은 로그 수집(Ingest)과 검색을 위한 인덱싱(Index)에 대해 이중 과금 구조를 가지고 있어 규모가 커질수록 비용이 매우 가파르게 증가하는 단점이 있습니다 [27, 28].
+*   **세션 리플레이와 개인정보 침해 (Privacy Concerns):** LogRocket처럼 '모든 것을 캡처'하는 세션 리플레이 방식은 기본적으로 강력한 디버깅 정보를 제공하지만, 민감한 사용자 데이터까지 녹화될 수 있는 심각한 개인정보 침해 우려가 동반됩니다. 따라서 별도의 마스킹 및 설정 작업이 강제됩니다 [5, 29, 30].
+*   **Error Boundaries의 한계:** 선언적인 UI 에러 처리에 강력하지만, 이벤트 핸들러 내부의 에러, `setTimeout` 같은 비동기 코드, 서버 사이드 렌더링(SSR), 그리고 Error Boundary 자체에서 발생한 에러는 포착하지 못합니다. 이러한 부분은 전통적인 자바스크립트의 `try/catch` 블록으로 디버깅 및 예외 처리를 해야 하는 제약이 있습니다 [31, 32].
+*   **React Compiler 도입에 따른 디버깅 난이도 증가:** 코드를 자동으로 최적화해주는 React Compiler는 내부 로직이 블랙박스(Black box) 형태로 동작합니다. 개발자는 최적화된 부분과 그 이유에 대한 가시성을 잃게 되며, 예기치 않은 리렌더링 발생 시 코드상의 `React.memo`나 `useCallback` 호출을 확인하는 대신 React DevTools Profiler에 전적으로 의존해 조사해야 하므로 디버깅 난이도가 상승합니다 [33].
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+
+#### [관계 유형 A (브라우저 및 성능 분석 기반 도구)]
+- [[Chrome DevTools]]
+  - 연결 이유: 자바스크립트 힙 메모리와 DOM의 상태를 프로파일링하여 메모리 누수를 진단하는 가장 근본적인 프론트엔드 디버깅 도구이기 때문입니다 [6, 34].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 브라우저의 가비지 컬렉션(GC) 동작 원리, 분리된 DOM 노드(Detached DOM nodes)와 클로저(Closure)가 메모리를 점유하여 성능을 저하시키는 원리를 시각적으로 이해할 수 있습니다 [2, 14, 17, 35].
+
+#### [관계 유형 B (React 컴포넌트 및 에러 핸들링 도구)]
+- [[React Error Boundaries]]
+  - 연결 이유: 렌더링 및 생명주기 도중 발생하는 컴포넌트 런타임 에러를 디버깅/핸들링하여 "하얀 화면(White screen of death)"을 막아주는 React만의 고유한 방어적 디버깅 패턴입니다 [1, 36].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 선언적(Declarative) UI 트리의 에러 전파 방식과, 명령형(Imperative) 이벤트 핸들러에서 `try-catch`를 사용해야 하는 아키텍처적 차이를 명확히 구분할 수 있습니다 [32].
+- [[React DevTools Profiler]]
+  - 연결 이유: 어떤 컴포넌트가 언제, 왜 리렌더링되었는지를 측정(Profiling)하여 렌더링 병목 현상을 디버깅하는 필수 도구입니다 [7, 37].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: React의 렌더링 라이프사이클, 불필요한 상태 및 props 변경 추적, 그리고 React Compiler 도입 전후의 렌더링 패스(Render pass) 차이를 검증하는 방법을 배울 수 있습니다 [7, 38].
+
+#### [관계 유형 C (프로덕션 환경 관측성 도구)]
+- [[Session Replay & Distributed Tracing]]
+  - 연결 이유: 로컬에서 재현이 불가능한 프로덕션 에러를 추적하기 위해 사용자의 브라우저 상호작용(Sentry, LogRocket)과 백엔드 데이터 흐름(Datadog)을 연결하여 디버깅 단서를 찾는 핵심 개념입니다 [5, 24, 39].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 풀스택 환경에서의 엔드투엔드(End-to-End) 성능 모니터링 한계와 프론트엔드 에러가 백엔드 서비스에 미치는 연관 관계를 깊게 이해할 수 있습니다 [24, 25].
+
+### Deeper Research Questions
+
+- Chrome DevTools의 Heap Snapshot 분석에서 'Shallow size'와 'Retained size'의 차이는 프론트엔드 메모리 관리 측면에서 어떻게 해석되며, 디버깅 시 어떤 기준표가 되는가? [40]
+- React Error Boundary가 이벤트 핸들러나 비동기 코드의 에러를 잡지 못하는 아키텍처적 이유는 무엇이며, 이를 보완하여 전체 애플리케이션의 에러를 효과적으로 캡처하기 위한 최적의 로깅 패턴은 무엇인가? [31, 32]
+- Sentry, LogRocket, Datadog RUM 등 클라우드 기반 로깅 도구가 프론트엔드 번들 크기 증가 및 초기 렌더링 성능 지연(최대 120ms 추가 로드)에 미치는 영향을 최소화하기 위한 설정 및 로드 전략은 무엇인가? [26, 41]
+- Redux DevTools의 시간 여행(Time-travel) 디버깅 원리는 무엇이며, 왜 Context API나 Zustand보다 복잡한 비동기 상태의 버그를 더 빠르고 정확하게 찾아낼 수 있는가? [21, 22]
+- React Compiler 도입 이후 자동화된 메모이제이션 과정에서 발생하는 렌더링 이슈(예: Library Compatibility 문제로 인한 참조 변경)를 디버깅하기 위해 React Profiler를 어떻게 활용해야 하는가? [33, 42, 43]
+
+### Practical Application Contexts
+
+- **Implementation:** 개발자는 `why-did-you-render` 라이브러리를 프로젝트에 연동해, 로컬 개발 시 불필요한 컴포넌트 렌더링 원인을 콘솔 경고를 통해 즉각적으로 파악하고 코드를 수정할 수 있습니다 [20, 44].
+- **System Design:** 프론트엔드 시스템 설계 시 대시보드, 차트, 복잡한 폼 등 장애 발생 확률이 높은 UI 컴포넌트 각각에 독립적인 `Error Boundary`를 배치해 하나의 위젯 결함이 전체 앱의 마비를 가져오지 않도록 설계합니다 [8, 45, 46].
+- **Operation / Maintenance:** 프로덕션 단계에서는 Sentry나 LogRocket과 같은 관측성(Observability) 툴을 통합하여, 오류 로그 발생 시 사용자가 클릭한 이벤트와 화면의 상태(Session Replay)를 실시간으로 확인하고 빠르게 이슈를 대응(Hotfix)합니다 [5, 25, 47].
+- **Learning Path:** 주니어 프론트엔드 개발자가 메모리 누수를 학습할 때, Chrome DevTools의 Memory 탭을 사용해 스냅샷을 찍고 DOM 노드가 자바스크립트 변수에 의해 참조되어 가비지 컬렉션되지 않는 상황(Detached Elements)을 실습합니다 [14, 15, 17].
+- **My Project Relevance:** React 프로젝트에서 전역 상태를 설계할 때, 단순 설정(Theme 등)은 디버깅이 단순한 Context API로, 변경이 잦고 상태 추적이 중요한 요소는 DevTools를 지원하는 Redux나 Zustand를 도입하여 디버깅 용이성을 확보합니다 [22, 48, 49].
+
+### Adjacent Topics
+
+- [[State Management Architecture]]
+  - 확장 방향: 상태 관리 라이브러리(Redux, Zustand, Context API 등)의 아키텍처적 선택이 상태 변화 추적성과 DevTools 디버깅 퀄리티에 어떤 영향을 미치는지 분석 [21, 22, 49].
+- [[Frontend Performance Optimization]]
+  - 확장 방향: 디버깅을 통해 발견한 메모리 누수와 불필요한 컴포넌트 렌더링(Re-renders) 문제를 실질적인 성능 최적화 기법(가상화, 코드 스플리팅)으로 해결하여 Core Web Vitals를 개선하는 방향 [20, 50].
+
+---
+*Last updated: 2026-04-30*
\ No newline at end of file
diff --git a/00_Raw/Engineering Scalable Frontend Systems.md b/00_Raw/Engineering Scalable Frontend Systems.md
new file mode 100644
index 00000000..387ef5fb
--- /dev/null
+++ b/00_Raw/Engineering Scalable Frontend Systems.md	
@@ -0,0 +1,84 @@
+# [[Engineering Scalable Frontend Systems]]
+
+## 📌 Brief Summary
+확장 가능한 프론트엔드 시스템(Engineering Scalable Frontend Systems)은 단순한 스크립트 실행을 넘어 유지보수성, 고성능, 견고성을 갖춘 분산 소프트웨어 아키텍처를 구축하는 것을 의미합니다 [1]. 이는 기술적 파일 기반 폴더 구조에서 기능 중심(Feature-Based) 및 도메인 기반 설계로의 전환을 요구하며, 엄격한 코드 컨벤션과 거버넌스를 동반합니다 [2, 3]. 또한 프론트엔드 개발에 SOLID와 같은 소프트웨어 공학 원칙을 결합하고, 서버/클라이언트 상태의 분리, 그리고 빌드 타임 및 런타임 성능 최적화를 통해 예측 가능한 성장을 가능하게 합니다 [1, 4, 5].
+
+## 📖 Core Content
+
+*   **아키텍처 및 폴더 구조의 진화**
+    기존의 컴포넌트, 훅, 스타일 등을 파일 타입별로 모아두는 구조는 앱이 커질수록 인지 부하를 높이고 확장을 어렵게 만듭니다 [2, 6]. 2025년의 프론트엔드 시스템은 비즈니스 도메인과 기능(Feature)을 중심으로 코드를 응집시키는 구조를 표준으로 삼고 있습니다 [3, 7]. 특히 **Feature-Sliced Design (FSD)** 같은 아키텍처는 코드를 횡단 관심사별 레이어(shared, entities, features, widgets, pages, app)로 나누고, 상위 계층에서 하위 계층으로만 접근할 수 있는 엄격한 단방향 의존성 규칙을 강제합니다 [8-10]. 각 슬라이스는 `index.ts`를 통해 퍼블릭 API(Public API)만 외부에 노출하여 내부 구현을 캡슐화합니다 [4, 11, 12].
+*   **소프트웨어 공학 원칙의 적용 (SOLID & Clean Code)**
+    프론트엔드 코드의 유지보수성을 위해 SOLID, DRY, KISS, YAGNI 원칙이 적용됩니다 [4, 13].
+    *   단일 책임 원칙(SRP)에 따라 너무 많은 작업을 수행하는 대형 컴포넌트(예: 300줄 이상)는 데이터 패칭, 상태 관리, UI 렌더링 등의 책임에 맞게 더 작고 독립적인 단위로 분리되어야 합니다 [14].
+    *   개방-폐쇄 원칙(OCP)은 기존 컴포넌트 소스를 수정하지 않고 `children` prop이나 Render Props 패턴을 이용한 컴포넌트 합성(Composition)으로 기능을 확장하는 방식으로 구현됩니다 [15, 16].
+    *   중복을 줄이는 DRY 원칙은 공통 로직을 커스텀 훅으로 분리하는 것을 권장하지만, 지나친 추상화는 코드 파악을 어렵게 하므로 단순성을 유지하는 KISS 원칙과 균형을 이루어야 합니다 [17].
+*   **상태 관리 패러다임의 세분화**
+    거대한 단일 상태 저장소(예: 과거의 Redux)에 의존하기보다는 데이터의 성격에 따라 최적의 도구를 선택하여 상태를 파편화 및 전문화합니다 [5].
+    *   **전역 애플리케이션 상태:** Context API는 값이 변경될 때마다 하위 컴포넌트 전체를 리렌더링하는 한계가 있으므로 [18, 19], 상태 변경이 잦고 규모가 큰 앱에서는 부분 구독(Selector)을 지원하여 렌더링 성능을 최적화하는 **Zustand**나 **Jotai**가 선호됩니다 [5, 20, 21].
+    *   **서버 상태 (API Layer):** API에서 가져온 데이터는 캐싱, 동기화, 로딩/에러 사이클 관리가 필요하므로, 클라이언트 상태와 명확히 분리하여 **TanStack Query (React Query)** 등의 라이브러리로 관리합니다 [18, 22].
+*   **성능 엔지니어링 및 빌드 최적화**
+    초기 로딩 시간과 Core Web Vitals 최적화를 위해 다양한 기법이 적용됩니다 [23, 24].
+    *   **빌드/컴파일 타임:** Vite와 같은 도구를 사용하여 개발 환경에서는 네이티브 ES 모듈을 제공하고, 프로덕션에서는 Rollup의 `manualChunks`를 활용해 용량이 큰 벤더 라이브러리(React, Recharts 등)를 분할 캐싱하여 캐시 효율을 높입니다 [23, 25-27]. 또한 **React Compiler**의 도입으로 컴파일러가 자동으로 코드의 리렌더링 방지(메모이제이션)를 처리하여 수동 최적화(`useMemo`, `useCallback`)의 오류를 줄여줍니다 [25, 28, 29].
+    *   **런타임 최적화:** 동적 임포트를 이용한 라우트 및 컴포넌트 레벨의 코드 스플리팅(Code Splitting & Lazy Loading), 그리고 수천 개의 리스트 아이템 렌더링 시 DOM 비대를 막는 가상화(Virtualization) 기술이 필수적으로 요구됩니다 [30-32].
+*   **복원력(Resilience) 및 시스템 거버넌스**
+    견고한 시스템은 런타임 오류가 전체 앱의 크래시로 이어지는 것을 막습니다. UI의 불안정한 영역이나 서드파티 위젯은 **Error Boundaries**로 감싸 폴백 UI를 제공하여 안정성을 보장합니다 [33-35]. 또한, 메모리 누수 방지를 위한 DevTools 힙 스냅샷 디버깅과 Sentry, LogRocket 같은 클라우드 도구를 이용한 프로덕션 에러 모니터링이 활용됩니다 [36-38]. 협업 차원에서는 일관된 네이밍 규칙(예: 파일명은 kebab-case, 컴포넌트는 PascalCase)과 ESLint, Prettier, Husky를 통한 자동화된 거버넌스, 그리고 Storybook을 활용한 시각적 회귀 테스트가 코드 품질을 보장합니다 [39-41].
+
+## ⚖️ Trade-offs & Caveats
+*   **Feature-Sliced Design (FSD)의 초기 도입 비용 및 복잡성:** FSD는 확장성과 모듈화에 뛰어나지만 러닝 커브가 높으며, 작은 규모의 프로젝트에서는 오버엔지니어링으로 느껴질 수 있습니다 [42, 43]. 또한 '인증(Auth)' 같은 횡단 관심사(Cross-cutting concerns)를 정확히 어떤 기능이나 슬라이스에 배치할지 경계를 설정하는 것이 어려워 팀 내 규칙 합의와 지속적인 문서화가 요구됩니다 [44, 45].
+*   **React Compiler 적용의 제약:** React Compiler가 자동 메모이제이션을 수행하여 성능을 높여주지만, 이는 블랙박스로 동작하기 때문에 예기치 않게 리렌더링이 발생했을 때 원인을 디버깅하기 더 어려워질 수 있습니다 [46]. 또한 매 렌더링마다 새로운 객체 참조를 반환하는 서드파티 라이브러리와 충돌할 수 있으며, 레거시 코드베이스의 경우 React의 불변성 및 부수 효과 규칙(Rules of React)을 엄격히 준수하도록 대대적인 리팩토링이 선행되어야 합니다 [28, 47, 48].
+*   **Context API vs. 외부 상태 관리 라이브러리의 트레이드오프:** Context API는 내장 기능이므로 의존성을 추가하지 않는 장점이 있지만, 변경이 잦은 상태에 사용할 경우 불필요한 하위 컴포넌트의 연쇄 리렌더링을 유발하는 치명적인 성능 병목을 발생시킵니다 [19, 20]. 반대로 Zustand나 TanStack Query를 도입하면 리렌더링 문제를 해결할 수 있으나, 시스템에 새로운 라이브러리 의존성과 학습 곡선이 추가됩니다 [21, 49].
+*   **DRY와 KISS 원칙의 상충:** 중복을 줄이기(DRY) 위해 공통 로직을 고차 컴포넌트(HOC)나 커스텀 훅으로 지나치게 추상화하면, 코드가 원래의 단순한 형태보다 이해하고 디버깅하기 훨씬 어려워져 결국 KISS 원칙을 위배하게 되는 부작용이 발생할 수 있습니다 [17].
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+
+#### [관계 유형 A: 아키텍처 및 시스템 구조 (Architecture & Structural Design)]
+*   `[[Feature-Sliced Design (FSD)]]`
+    *   연결 이유: 현대 프론트엔드의 모듈화 및 확장성을 해결하기 위해 널리 채택되는 아키텍처 방법론의 핵심이기 때문입니다 [9, 10].
+    *   이 개념을 통해 더 깊게 이해할 수 있는 부분: 비즈니스 도메인 기반의 코드 분할, 엄격한 단방향 의존성 규칙 적용 방법, 그리고 퍼블릭 API를 통한 모듈 캡슐화 원리 [4, 8, 50].
+*   `[[Error Boundaries]]`
+    *   연결 이유: 부분적인 UI 런타임 에러가 시스템 전체의 장애(White screen of death)로 확산되는 것을 방지하는 구조적 안전 장치이기 때문입니다 [33, 34].
+    *   이 개념을 통해 더 깊게 이해할 수 있는 부분: 렌더링 트리에서 컴포넌트 결함을 격리하는 원리와 시스템 복원력을 높이는 에러 처리 전략 [33, 35].
+
+#### [관계 유형 B: 상태 관리 패러다임 (State Management Paradigms)]
+*   `[[Zustand vs Context API]]`
+    *   연결 이유: 전역 상태 관리에서 성능과 확장성을 결정짓는 가장 빈번한 아키텍처 결정 지점이기 때문입니다 [5, 19].
+    *   이 개념을 통해 더 깊게 이해할 수 있는 부분: Context API의 브로드캐스트 렌더링 문제점과 이를 해결하기 위한 Zustand의 구독/선택자(Selector) 기반 렌더링 최적화 기법 [19, 20, 51].
+*   `[[TanStack Query (React Query)]]`
+    *   연결 이유: 클라이언트 상태와 서버 상태(Server State)를 구조적으로 분리하여 API 데이터 처리의 병목을 없애주기 때문입니다 [18, 22].
+    *   이 개념을 통해 더 깊게 이해할 수 있는 부분: 데이터 캐싱, 백그라운드 동기화 및 API 계층의 관심사 분리(Separation of Concerns) [18, 22].
+
+#### [관계 유형 C: 성능 및 빌드 최적화 (Performance & Build Optimization)]
+*   `[[React Compiler]]`
+    *   연결 이유: 수동 메모이제이션의 복잡성을 줄이고 빌드 타임에 컴포넌트 렌더링 성능을 자동으로 최적화하는 최신 핵심 도구이기 때문입니다 [25, 28, 29].
+    *   이 개념을 통해 더 깊게 이해할 수 있는 부분: 선언적 UI 프레임워크에서의 빌드 타임 최적화 한계 및 React의 규칙(Rules of React)이 강제하는 불변성의 중요성 [52, 53].
+*   `[[Code Splitting & Lazy Loading]]`
+    *   연결 이유: 초기 로드(First Paint) 속도 향상과 JavaScript 번들 크기를 제어하는 확장 가능한 시스템의 필수 성능 전략이기 때문입니다 [30, 31, 54].
+    *   이 개념을 통해 더 깊게 이해할 수 있는 부분: Vite나 Webpack 같은 번들러 환경에서 동적 임포트를 통한 라우트 단위 분할 및 무거운 벤더 청크(`manualChunks`)의 캐싱 분리 전략 [26, 27, 31].
+
+### Deeper Research Questions
+
+*   거대한 모놀리식 구조 혹은 단일 파일 타입(components/, hooks/) 기반의 레거시 React 앱을 Feature-Sliced Design(FSD) 아키텍처로 점진적으로 리팩토링할 때 고려해야 할 최적의 마이그레이션 전략은 무엇인가?
+*   React Compiler가 도입되어 컴포넌트의 리렌더링을 자동으로 제어하게 된다면, 개발자는 더 이상 `useMemo`나 `useCallback`을 작성할 필요가 완전히 없어지는가? 혹은 여전히 수동 메모이제이션이 필수적인 엣지 케이스는 무엇인가?
+*   Zustand와 같은 클라이언트 상태 관리와 TanStack Query와 같은 서버 상태 관리 라이브러리를 동시 사용할 때, 두 상태 사이의 데이터 동기화와 의존성 주입은 어떻게 설계해야 응집도를 높일 수 있는가?
+*   프론트엔드 성능 최적화 중 메모리 누수(Memory Leak)를 예방하기 위해 Chrome DevTools 힙 스냅샷에서 식별되는 '분리된 DOM 노드(Detached DOM Nodes)'와 클로저(Closure) 잔류 문제를 프로덕션에서 어떻게 모니터링하고 방지할 수 있는가?
+*   Vite를 활용한 빌드 시 대규모 벤더 라이브러리로 인한 번들 사이즈 경고("Large Chunks")를 근본적으로 해결하기 위해 `manualChunks` 설정을 어떻게 분할해야 브라우저의 병렬 다운로드 및 캐싱 효율을 극대화할 수 있는가?
+
+### Practical Application Contexts
+
+*   **Implementation:** 신규 도메인 기능을 구현할 때 로직, UI, 커스텀 훅을 하나의 피처(Feature) 폴더에 응집시키고 다른 피처에서의 직접 임포트를 제한하여 철저히 캡슐화된 코드를 작성합니다 [3, 4]. 빈번히 발생하는 이벤트나 렌더링 로직 안에서는 인라인 익명 함수 사용을 지양하고 불필요한 재할당을 막습니다 [55, 56].
+*   **System Design:** 시스템 초기 아키텍처를 설계할 때 상태의 유형을 명확히 분류하여, 자주 바뀌지 않는 테마/설정은 Context API에, 상호작용이 잦은 장바구니/UI 상태는 Zustand에, 서버 데이터는 TanStack Query에 위임하는 다층적 상태 트리를 설계합니다 [5, 18, 57].
+*   **Operation / Maintenance:** 프로덕션 배포 후 Sentry, LogRocket, Datadog과 같은 가시성(Observability) 및 클라우드 로깅 도구를 연동해 사용자 세션을 리플레이하고 런타임 오류 및 메모리 누수 이슈를 사전에 탐지합니다 [36, 37].
+*   **Learning Path:** React 기초(useState, Props)와 컴포넌트 분리(SOLID, Clean Code) 개념을 숙지한 후, 점진적으로 Context API의 한계를 체험하고 Zustand로 마이그레이션하는 과정을 거치며 렌더링 최적화와 메모이제이션의 원리를 학습합니다 [4, 14, 58].
+*   **My Project Relevance:** 현재 유지보수 중인 거대한 React 프로젝트가 있다면, 컴포넌트 트리 상단에 무분별하게 배치된 Context Provider를 걷어내고 Zustand 기반의 부분 구독 패턴으로 리팩토링하거나 [21], Storybook 및 Chromatic을 CI 파이프라인에 도입하여 PR 단계에서 시각적 회귀 테스트(Visual Test)를 자동화하여 품질을 개선할 수 있습니다 [41, 59].
+
+### Adjacent Topics
+
+*   `[[Core Web Vitals]]`
+    *   확장 방향: LCP(Largest Contentful Paint), INP(Interaction to Next Paint), CLS(Cumulative Layout Shift) 등 구글이 정의한 사용자 경험 중심의 성능 측정 지표를 이해하고, 앞서 다룬 코드 스플리팅, 레이지 로딩, 렌더링 최적화 기법이 실제 사용자 체감 속도 향상에 어떻게 직결되는지 심층 분석하는 방향으로 연구할 수 있습니다 [23, 60, 61].
+*   `[[Git Branching Strategies & CI/CD Governance]]`
+    *   확장 방향: 복잡한 프론트엔드 시스템을 다수의 개발자가 협업하여 구축할 때 충돌을 최소화하고 릴리스 안정성을 높이기 위한 GitHub Flow, Trunk-Based Development 등의 브랜칭 전략과, ESLint/Prettier 자동화, Conventional Commits를 활용한 배포 파이프라인(CI/CD) 통제 방법을 확장해서 조사할 수 있습니다 [62-64].
+
+---
+*Last updated: 2026-04-30*
\ No newline at end of file
diff --git a/00_Raw/Folder Structure Best Practices.md b/00_Raw/Folder Structure Best Practices.md
new file mode 100644
index 00000000..c340d218
--- /dev/null
+++ b/00_Raw/Folder Structure Best Practices.md	
@@ -0,0 +1,69 @@
+# [[Folder Structure Best Practices]]
+
+## 📌 Brief Summary
+React 등 프론트엔드 프로젝트에서 코드의 유지보수성, 확장성, 그리고 협업 효율성을 높이기 위해 파일과 디렉터리를 체계적으로 구성하는 방법론입니다 [1]. 현대적인 애플리케이션에서는 과거의 파일 유형 기반(유형별 분류) 구조에서 벗어나, 기능(Feature)이나 도메인 중심으로 관련된 로직을 묶는 하이브리드 또는 기능 기반 방식이 모범 사례로 권장됩니다 [2, 3]. 이를 통해 UI, 비즈니스 로직, 상태 관리 등의 관심사를 명확히 분리하고 프로젝트가 커짐에 따라 발생하는 기술 부채를 최소화할 수 있습니다 [4].
+
+## 📖 Core 소스 Content
+
+*   **구조의 진화와 한계:** 
+    *   초기 소규모 프로젝트는 주로 모든 컴포넌트를 `components` 폴더에, 모든 훅을 `hooks` 폴더에 넣는 플랫(Flat) 구조나 파일 유형 기반 구조로 시작합니다 [5, 6].
+    *   하지만 앱의 규모가 커지면 단일 기능을 수정하기 위해 여러 폴더를 넘나들어야 하므로, 개발 속도가 느려지고 디버깅이 어려워지며 코드베이스가 복잡해지는 한계가 발생합니다 [3, 6, 7].
+*   **기능 기반(Feature-based) 및 하이브리드 구조:** 
+    *   2025년 기준 가장 권장되는 접근 방식은 파일 유형이 아닌 비즈니스 기능이나 모듈을 중심으로 폴더를 구성하는 것입니다 [2, 8, 9].
+    *   각 기능(Feature)은 캡슐화되어 다른 기능과 독립적으로 작동할 수 있으므로, 규모 확장 시 기존 코드에 영향을 주지 않고 새로운 기능을 매끄럽게 추가할 수 있습니다 [8, 10].
+*   **권장 디렉터리 구성 (src/ 하위):**
+    *   `assets/`: 이미지, 폰트 등 정적 미디어 리소스 보관 [11, 12].
+    *   `components/`: 여러 기능에서 공통으로 재사용되는 도메인에 구애받지 않는 UI 요소 (예: 버튼, 모달, 네비게이션 바 등) [2, 12, 13].
+    *   `features/` (또는 `modules/`): 인증(Auth), 대시보드(Dashboard) 등 도메인별 비즈니스 로직. 이 폴더 내부에는 해당 기능에만 쓰이는 컴포넌트, 훅, API 등을 캡슐화하여 보관합니다 [2, 9, 13].
+    *   `hooks/`: 폼 처리, 데이터 페칭 등 앱 전반에서 재사용 가능한 커스텀 훅 [9, 14].
+    *   `pages/` (또는 `routes/`): 라우팅에 매핑되는 페이지 레벨 컴포넌트 [15, 16].
+    *   `services/`: 서드파티 서비스 연동이나 API 요청 등 외부 통신 로직 [16, 17].
+    *   `store/` (또는 `context/`): Redux, Zustand, Context API를 활용하는 전역 상태 관리 로직 [14-16].
+    *   `utils/`: 날짜 포맷팅, 데이터 유효성 검사 등 상태를 가지지 않는 유틸리티 함수 [17, 18].
+    *   `styles/`: 글로벌 CSS, 테마(Theme) 등 전역 스타일링 파일 [18, 19].
+    *   `types/`: TypeScript 사용 시 전역으로 사용되는 타입 및 인터페이스 보관 [18].
+    *   `config/`: 환경 변수나 애플리케이션 전역 설정(API 기본 URL 등) 관리 [18, 20].
+*   **Feature-Sliced Design (FSD):** 
+    *   기능 기반 폴더 구조보다 더 엄격하게 의존성의 방향을 통제하는 프론트엔드 아키텍처 방법론입니다 [21].
+    *   `shared` -> `entities` -> `features` -> `widgets` -> `pages` -> `app` 이라는 고정된 다층 계층(Layer)을 가집니다 [22, 23].
+    *   상위 계층은 하위 계층의 코드를 가져올 수 있지만(Import), 하위 계층은 상위 계층을 참조할 수 없는 단방향 의존성 규칙을 통해 순환 의존성을 방지합니다 [22, 24].
+*   **Next.js 환경에서의 라우트 그룹 (Route Groups):**
+    *   Next.js 프로젝트에서는 괄호를 사용한 폴더명 `(folderName)` 방식을 통해, 실제 URL 경로에는 영향을 주지 않으면서도 관련 기능이나 논리에 따라 라우트를 깔끔하게 그룹화할 수 있습니다 [25-27].
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+- [[Feature-Sliced Design]]
+  - 연결 이유: 대규모 React 애플리케이션의 폴더 구조를 구축하기 위해 고안된 전문적인 프론트엔드 아키텍처 방법론이기 때문입니다 [21].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 폴더 간의 단방향 의존성 규칙과 각 폴더(Layer, Slice, Segment)가 담당해야 하는 역할의 엄격한 분리 방식 [22, 28].
+
+- [[Separation of Concerns]] (관심사의 분리)
+  - 연결 이유: 폴더 구조를 설계하는 근본적인 목적이 UI 렌더링, 전역 상태 관리, 데이터 통신(API) 등의 책임을 각기 다른 위치로 분리하는 데 있기 때문입니다 [4, 29].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: `services/`, `store/`, `components/` 등의 폴더를 분리하여 단일 책임 원칙(SRP)을 프론트엔드 아키텍처 전반에 적용하는 방법 [4, 30].
+
+- [[Naming Conventions]] (명명 규칙)
+  - 연결 이유: 일관된 폴더 및 파일 명명 규칙(예: 폴더명은 kebab-case, 컴포넌트는 PascalCase)은 폴더 구조 내에서 파일을 예측 가능하게 찾고 충돌을 방지하는 핵심 규칙이기 때문입니다 [31-33].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 다양한 운영체제와 CI/CD 파이프라인에서 빌드 에러를 방지하고 팀 내 코드 가독성을 유지하는 방법 [34, 35].
+
+### Deeper Research Questions
+- 기능 기반(Feature-based) 폴더 구조에서 각 기능이 상호작용해야 할 때 발생하는 교차 관심사(Cross-cutting concerns)나 공유 의존성을 어떻게 관리하고 해결할 수 있는가?
+- 레거시 파일 유형 기반(File-type based) React 프로젝트를 기능 기반 혹은 Feature-Sliced Design으로 점진적으로 마이그레이션하기 위한 가장 안전하고 효율적인 단계는 무엇인가?
+- Feature-Sliced Design의 단방향 의존성 원칙을 ESLint와 같은 정적 분석 도구로 자동 강제화(Governance)하는 방법은 무엇인가?
+- 폴더 구조를 모듈화할 때 발생하는 파일 중첩 문제와 이를 피하기 위한 적절한 인덱스(Barrel) 파일 사용 전략의 장단점은 무엇인가?
+- 상태 관리 라이브러리(Context API, Zustand, Redux 등)의 종류에 따라 권장되는 `store/` 폴더 내부의 구조는 어떻게 달라져야 하는가?
+
+### Practical Application Contexts
+- **Implementation:** React 컴포넌트를 생성할 때, 모든 요소를 `components/` 폴더에 넣지 않고 특정 도메인(예: 인증)에만 쓰이는 요소는 `features/auth/components/`로 격리하여 캡슐화를 실천합니다.
+- **System Design:** 프로젝트 초기 세팅 단계에서 비즈니스 도메인을 분석하여 어떤 코드가 전역(`shared/` 또는 `components/`)에 속하고 어떤 코드가 로컬(`features/`)에 속할지 기준을 마련합니다.
+- **Operation / Maintenance:** 기능에 버그가 발생했을 때, 해당 기능의 폴더(`features/feature-name/`)만 확인하면 UI, 상태, API 요청 로직이 모여 있어 디버깅 및 유지보수 속도가 크게 향상됩니다.
+- **Learning Path:** 처음에는 단순한 플랫 구조로 React를 학습한 후, 컴포넌트가 30개 이상으로 늘어나는 시점에 기능 기반 폴더 구조를 도입하여 아키텍처 설계 역량을 기를 수 있습니다.
+- **My Project Relevance:** 현재 진행 중이거나 리팩토링해야 할 React 코드베이스에서, 거대해진 `components/` 폴더를 도메인 단위의 `features/` 폴더로 나누고 재사용 불가 로직들을 분리하는 데 직접적으로 적용됩니다.
+
+### Adjacent Topics
+- [[State Management]]
+  - 확장 방향: 전역 상태(Global State)와 로컬 상태(Local State)를 어디에 보관해야 하는지, Zustand와 같은 도구가 `store/` 폴더의 구조를 어떻게 단순화하는지 확장하여 조사할 수 있습니다.
+- [[Code Splitting]] (코드 스플리팅)
+  - 확장 방향: 라우트 혹은 폴더(Feature) 단위로 코드 스플리팅과 지연 로딩(Lazy Loading)을 적용하여 초기 번들 크기를 줄이고 성능을 최적화하는 전략과 연결됩니다.
+
+---
+*Last updated: 2026-04-30*
\ No newline at end of file
diff --git a/00_Raw/Frontend Performance Debugging.md b/00_Raw/Frontend Performance Debugging.md
new file mode 100644
index 00000000..e8479bfa
--- /dev/null
+++ b/00_Raw/Frontend Performance Debugging.md	
@@ -0,0 +1,72 @@
+# [[Frontend Performance Debugging]]
+
+## 📌 Brief Summary
+프론트엔드 성능 디버깅(Frontend Performance Debugging)은 웹 애플리케이션의 메모리 누수, 불필요한 리렌더링, 잦은 가비지 컬렉션 등으로 인해 발생하는 성능 저하와 응답 지연을 식별하고 해결하는 과정입니다 [1-3]. 개발자는 브라우저의 내장 개발자 도구(Chrome DevTools)를 활용해 메모리 상태와 컴포넌트 렌더링 비용을 로컬에서 분석합니다 [4, 5]. 더 나아가 프로덕션 환경에서는 클라우드 기반 로깅 및 모니터링 도구를 사용하여 실제 사용자의 세션과 에러를 추적함으로써 복잡한 성능 병목의 근본 원인을 파악합니다 [6-8].
+
+## 📖 Core 소스 Content
+**메모리 문제 진단 (Memory Issues Diagnosis)**
+프론트엔드 성능 저하의 주요 원인 중 하나는 메모리 누수(Memory Leak)와 메모리 팽창(Memory Bloat)입니다. 자바스크립트에서는 사용이 끝난 메모리를 가비지 컬렉터가 회수하지만, DOM 노드가 문서에서 제거된 후에도 자바스크립트 참조가 남아있는 '분리된 DOM 노드(Detached DOM Nodes)', 누적된 이벤트 리스너, 클로저(Closure)에 의해 유지되는 참조 등이 메모리 누수를 유발합니다 [2, 9, 10]. Chrome DevTools의 Task Manager를 통해 실시간 DOM 노드와 JS 힙(Heap) 메모리 증가를 확인하고, Memory 패널의 Heap Snapshot을 비교하여 분리된 DOM 트리를 식별하며, Allocation Timeline을 사용해 언제 새로운 메모리가 할당되는지 추적할 수 있습니다 [4, 11, 12]. 빈번한 가비지 컬렉션은 스크립트 실행을 자주 일시 정지시켜 화면의 끊김(Jank)을 발생시킵니다 [1].
+
+**React 컴포넌트 렌더링 프로파일링 (React Rendering Profiling)**
+React 애플리케이션에서는 상태(State), 프로퍼티(Props), 컨텍스트(Context) 변경 또는 부모 컴포넌트의 렌더링에 의해 리렌더링이 트리거됩니다 [13]. 불필요한 리렌더링은 메인 스레드를 차단하고 상호작용 시간을 지연시킵니다 [3]. 이를 디버깅하기 위해 React DevTools Profiler를 사용하여 어떤 컴포넌트가 언제, 왜 렌더링되었는지, 얼마나 시간이 걸렸는지(Flamegraph 뷰 등)를 분석합니다 [5, 14]. 또한, 개발 환경 전용 라이브러리인 `why-did-you-render`를 활용하면 실제 상태나 prop 변경 없이 발생하는 리렌더링에 대한 콘솔 경고를 받을 수 있습니다 [15, 16].
+
+**프로덕션 관측성과 클라우드 로깅 (Production Observability and Logging)**
+로컬 환경을 넘어 실제 운영 환경의 성능을 디버깅하기 위해 Sentry, LogRocket, Datadog RUM, SigNoz와 같은 프론트엔드 클라우드 로깅 도구가 사용됩니다 [17, 18]. 이 도구들은 단순한 에러 로깅을 넘어 사용자가 에러나 성능 저하를 겪기 직전의 행동을 비디오처럼 다시 볼 수 있는 세션 리플레이(Session Replay), 프론트엔드 에러를 백엔드 트레이스와 연관 지어 분석하는 분산 트레이싱(Distributed Tracing), 그리고 실제 사용자의 Core Web Vitals(LCP, FID, INP 등) 모니터링 기능을 제공하여 맹점 없는 디버깅을 가능하게 합니다 [7, 8, 19-21].
+
+## ⚖️ Trade-offs & Caveats
+* **모니터링 도구의 성능 최적화 반대 급부:** LogRocket이나 Sentry 같은 강력한 로깅 및 성능 모니터링 도구들을 클라이언트 사이드에 탑재하면 자바스크립트 번들 사이즈가 커지고 성능에 영향을 미칩니다. 일부 도구는 최대 120ms의 추가 로드 시간을 발생시킬 수 있으므로 1초가 중요한 서비스에서는 가벼운 옵션을 선택해야 합니다 [22-24].
+* **세션 리플레이와 프라이버시 문제:** 모든 사용자 세션과 DOM/상태 변화를 기록하는 도구(예: LogRocket)의 기본 '모두 캡처' 방식은 민감한 개인정보를 노출할 위험이 있습니다. 이를 방지하기 위해 마스킹 설정을 수동으로 엄격히 구성해야 하는 관리 비용이 발생합니다 [19, 23, 25, 26].
+* **비용과 가시성의 타협 (Cost vs. Visibility):** Datadog과 같은 대규모 옵저버빌리티 플랫폼은 수집(Ingestion)과 색인(Indexing) 단계에서 이중 과금 모델을 사용하여 트래픽이 많은 경우 엄청난 비용이 발생합니다. 비용 절감을 위해 로그의 20%만 색인하게 되면, 실제 장애 발생 시 디버깅에 필요한 데이터의 80%가 검색되지 않는 트레이드오프가 발생합니다 [27-29].
+* **최적화 기법 자체의 오버헤드:** `React.memo()`, `useCallback`, `useMemo`와 같은 최적화 훅은 이전 참조값을 메모리에 저장하고 비교하는 오버헤드를 발생시킵니다. 렌더링 비용보다 비교 비용이 더 큰 가벼운 컴포넌트에 남용하면 오히려 성능을 저하시키는 원인이 됩니다 [30, 31].
+* **컴파일러 자동화로 인한 디버깅 난이도 상승:** React Compiler 같은 빌드 타임 자동 메모이제이션 도구를 사용하면 명시적인 훅 작성을 줄일 수 있지만, 컴파일러가 블랙박스로 작동하므로 예기치 않은 리렌더링이 발생할 경우 코드 상에서 원인을 찾기 어려워 React DevTools Profiler에 전적으로 의존해야 하는 단점이 있습니다 [32].
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+
+#### [관계 유형 A (로컬 디버깅 및 분석 도구)]
+- [[Chrome DevTools Memory Profiler]]
+  - 연결 이유: 자바스크립트 애플리케이션의 메모리 누수와 객체 보존 상태를 프로파일링하는 브라우저 내장 도구.
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: Heap Snapshots 비교, Allocation Timeline을 통한 메모리 할당 추적, Detached DOM tree 파악 기법 [9, 12, 33].
+- [[React DevTools Profiler]]
+  - 연결 이유: React 특유의 렌더링 사이클과 성능 병목을 시각화하는 핵심 도구.
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 컴포넌트 렌더링 소요 시간, 렌더링 발생 원인(Props/State 변경 여부 판별) [5, 14].
+
+#### [관계 유형 B (프로덕션 관측성 및 모니터링)]
+- [[Frontend Cloud Logging Tools]]
+  - 연결 이유: Sentry, LogRocket, Datadog RUM, SigNoz 등 배포 이후 발생하는 성능 저하와 버그를 추적하는 플랫폼.
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 프로덕션 레벨에서의 세션 리플레이, 자동 에러 그룹화, 엔드투엔드 분산 트레이싱, Core Web Vitals 추적 [7, 8, 20, 21, 34].
+
+#### [관계 유형 C (아키텍처 및 안티패턴)]
+- [[JavaScript Memory Leaks]]
+  - 연결 이유: 애플리케이션 성능을 점진적으로 파괴하는 현상으로 메모리 팽창, 가비지 컬렉션 등과 연관.
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 클로저 잔류 참조(Closure-Retained References), 해제되지 않은 이벤트 리스너의 동작 메커니즘 [2, 10, 35].
+- [[React Re-render Optimization]]
+  - 연결 이유: React의 렌더링 특성상 발생하는 메인 스레드 블로킹 문제를 해결하기 위한 코드 레벨 기법.
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 참조 안정성(Reference stability), 익명 함수의 부작용, `useMemo` 및 `useCallback`의 올바른 활용법 [36-38].
+
+### Deeper Research Questions
+
+- 프론트엔드 모니터링 시 수집하는 Sentry, LogRocket 등의 툴이 유발하는 성능 저하(번들 사이즈 및 실행 오버헤드)를 최소화하면서도 Core Web Vitals 등 유의미한 디버깅 데이터를 수집하는 최적의 설정 전략은 무엇인가?
+- JavaScript 환경의 Allocation Timeline 상에서 빈번하게 발생하는 가비지 컬렉션(GC) 스파이크와 실제 브라우저의 메인 스레드 멈춤 현상(Jank/INP 저하) 간의 상관관계를 어떻게 정량적으로 프로파일링할 수 있는가?
+- React Compiler가 자동화하는 영역과 서드파티 라이브러리(예: 항상 새로운 객체를 반환하는 `useLocation`, `useMutation`)로 인해 컴파일러가 최적화를 우회하는 경우, 이 충돌을 디버깅하고 해결하는 구체적인 패턴은 무엇인가?
+- Puppeteer 기반의 Automated Memory Testing을 CI/CD 파이프라인에 통합하여, Detached DOM node나 Event Listener 누적과 같은 메모리 누수를 프로덕션 배포 전에 차단하는 방법은 무엇인가?
+- Context API 사용 시 발생하는 광범위한 리렌더링 문제를 해결하기 위해 Zustand와 같은 외부 상태 관리 도구의 'Selector' 패턴을 사용할 때, 디버깅 과정에서 Redux DevTools 연동이 제공하는 구체적인 이점은 무엇인가?
+
+### Practical Application Contexts
+
+- **Implementation:** React 컴포넌트 마운트 해제 시 `useEffect` 클린업 함수를 작성하여 이벤트 리스너를 제거함으로써 메모리 누수를 방지하고, 로컬 개발 환경에서 `why-did-you-render` 라이브러리를 추가하여 불필요한 리렌더링을 콘솔 경고로 조기 감지한다 [15, 39].
+- **System Design:** 초기 프론트엔드 아키텍처 설계 단계부터 SigNoz(OpenTelemetry 기반)나 Sentry와 같은 로깅 도구 도입을 인프라 구성 요소로 결정하고, 사용자 정보 보호를 위해 세션 캡처 시 민감 데이터 마스킹 정책을 사전 설계한다 [21, 25, 26, 40].
+- **Operation / Maintenance:** 프로덕션 환경에서 시간이 지남에 따라 앱이 무거워지거나 느려진다는 사용자 제보가 들어올 경우, Chrome DevTools Memory 패널의 Heap Snapshot을 통해 분리된 DOM 노드가 점진적으로 누적되는지 검사하고 원인 코드를 수정한다 [1, 9, 41].
+- **Learning Path:** 우선 JavaScript 가비지 컬렉터의 동작 원리와 메모리 누수 패턴을 학습한 뒤, Chrome DevTools의 Task Manager와 Memory 패널 사용법을 익히고, 최종적으로 React Profiler와 프로덕션 로깅 도구 활용법으로 학습을 확장한다.
+- **My Project Relevance:** 현재 진행하는 React 기반 대시보드 프로젝트에서 테이블 데이터나 차트 업데이트 시 화면 멈춤이 발생할 경우, Chrome DevTools Performance 탭을 통해 스크립트 실행 시간을 확인하고 React Profiler를 붙여 불필요하게 리렌더링되는 자식 컴포넌트를 식별, `React.memo` 또는 식별자(Key)를 수정하는 최적화 작업에 직접 적용할 수 있다.
+
+### Adjacent Topics
+
+- [[Core Web Vitals]]
+  - 확장 방향: 프론트엔드 성능 최적화와 디버깅의 궁극적인 성과 지표이자 기준점이 되는 실제 사용자 체감 속도 지표(LCP, FID, INP, CLS 등) 심층 탐구 [8].
+- [[React Server Components (RSC)]]
+  - 확장 방향: Next.js 환경에서 클라이언트 측 자바스크립트 번들 사이즈 자체를 줄이고 상호작용 없는 UI를 서버에서 렌더링함으로써 근본적인 클라이언트 디버깅 요소 및 리렌더링 비용을 제거하는 아키텍처 [42, 43].
+
+---
+*Last updated: 2026-04-30*
\ No newline at end of file
diff --git a/00_Raw/Git Workflow.md b/00_Raw/Git Workflow.md
new file mode 100644
index 00000000..5dc64fac
--- /dev/null
+++ b/00_Raw/Git Workflow.md	
@@ -0,0 +1,75 @@
+# [[Git Workflow]]
+
+## 📌 Brief Summary
+Git Workflow(깃 워크플로우)는 팀 환경에서 코드 변경 사항을 관리하고 협업하기 위한 체계적이고 구조화된 접근 방식입니다 [1, 2]. 이는 기능 브랜치(Feature-branch), 트렁크 기반(Trunk-based), Git Flow 등 다양한 전략을 포괄하며, 충돌을 방지하고 `main` 브랜치의 배포 가능 상태를 보장하는 것을 목표로 합니다 [2-4]. 일관된 브랜치 명명 규칙, 커밋 메시지 규약, 풀 리퀘스트(PR)와 리뷰 절차를 도입함으로써 잠재적인 혼돈을 예측 가능한 릴리스 흐름으로 전환할 수 있습니다 [1, 5, 6].
+
+## 📖 Core Content
+*   **주요 브랜칭 전략 (Main Branching Strategies):**
+    *   **Feature-Branch Workflow (기능 브랜치 워크플로우):** 주 브랜치(`main`)를 항상 안정적이고 배포 가능한 상태로 유지하며, 새로운 작업이나 버그 수정마다 짧은 수명의 기능 브랜치(예: `feature/login`)를 생성하여 작업합니다 [3, 4, 7]. 소규모 팀에 매우 적합하며, 오버헤드 없이 코드를 안전하게 통합할 수 있습니다 [4, 8].
+    *   **Trunk-Based Development (트렁크 기반 개발):** 강력한 CI(지속적 통합) 환경을 갖춘 경험 많은 팀에 적합한 방식으로, 아주 짧은 수명의 브랜치를 사용해 자주 `main`에 코드를 병합하여 통합 속도를 높입니다 [8, 9].
+    *   **Git Flow:** `develop` 및 `release` 등 다수의 브랜치를 운영하며 스케줄된 릴리스를 관리하는 대규모 프로젝트에 적합하지만, 소규모 팀에게는 너무 복잡하고 무거울 수 있습니다 [8, 10].
+    *   **GitHub Flow:** 기능을 기능 브랜치에서 작업한 뒤 풀 리퀘스트를 통해 리뷰받고 병합하여, `main`에서 바로 배포하는 방식입니다 [11, 12].
+
+*   **명명 규칙 및 추적성 (Naming Conventions & Traceability):**
+    *   **브랜치 이름:** 브랜치 목적을 명확히 하기 위해 `feature/`, `bugfix/`와 같은 접두사를 사용하며, 티켓 ID를 함께 포함(예: `feature/PROJ-123-user-auth`)하여 이슈 트래커와의 추적성을 확보해야 합니다 [13-15]. 
+    *   **커밋 메시지:** `type(scope): description` 형태를 따르는 "Conventional Commits" 규약을 사용하는 것이 좋습니다 [6, 16]. 예를 들어 새로운 기능은 `feat:`, 버그 수정은 `fix:`, 문서 수정은 `docs:` 등으로 시작하여 변경의 의도를 명확히 합니다 [6, 16].
+
+*   **풀 리퀘스트와 병합 (Pull Requests & Merging):**
+    *   `main` 브랜치에 직접 푸시(Push)하는 것을 금지하고, 반드시 풀 리퀘스트(PR)를 생성하여 최소 1명 이상의 동료에게 코드 리뷰를 받아야 합니다 [13, 17].
+    *   코드 리뷰 속도와 품질을 위해 PR은 작고 논리적인 단일 변경 사항(Atomic Commits) 단위로 유지해야 합니다 [16, 18].
+    *   병합 시에는 스쿼시 병합(Squash merge)을 사용하여 커밋 히스토리를 깔끔하게 유지하고, 병합이 완료된 기능 브랜치는 자동으로 삭제하여 리포지토리를 정리합니다 [17-19].
+
+## ⚖️ Trade-offs & Caveats
+*   **구조의 복잡성 vs. 팀의 규모:** Git Flow는 대규모의 복잡한 릴리스 계획을 안전하게 관리할 수 있지만, 프로세스 오버헤드가 크고 병합 지연을 초래합니다 [8, 20]. 반면, Feature-Branch 워크플로우나 Trunk-Based 방식은 소규모 팀이 빠르고 가볍게 움직일 수 있도록 돕지만, 규모가 커지거나 엄격한 릴리스 버전 관리가 필요한 경우 한계에 부딪힐 수 있어 워크플로우를 진화(Migration)시켜야 합니다 [8, 10].
+*   **기능 브랜치의 수명과 충돌:** 기능 브랜치 방식의 가장 큰 부작용은 브랜치의 수명이 길어질 경우 메인 브랜치와의 차이가 커져 심각한 병합 충돌(Merge Conflict)이 발생한다는 점입니다 [20, 21]. 이를 피하기 위해 개발자는 자주 `main` 브랜치를 풀(Pull) 받거나 리베이스(Rebase)하여 최신 상태를 동기화하는 부가적인 작업을 수행해야 합니다 [19, 20].
+*   **완전한 추적성의 대가:** 모든 브랜치와 커밋에 티켓 ID 부여를 강제하면 버그 추적이나 리뷰에 있어 컨텍스트 확보에는 탁월하나 [5, 22], 아주 단순하고 사소한 코드 수정 작업에도 반드시 티켓을 생성하고 절차를 밟아야 하는 속도 저하의 단점이 발생합니다 [23].
+*   **Trunk-Based 전환의 전제 조건:** Trunk-Based Development로 전환하여 빠른 통합의 이점을 얻고자 한다면, 코드의 불안정성을 감추기 위한 기능 토글(Feature flags) 기법과 병합 전 결함을 잡아낼 강력한 테스트 자동화(CI)가 필수적으로 요구된다는 제약 사항이 있습니다 [12].
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+
+#### [관계 유형 A (아키텍처/기반 기술)]
+- `[[Trunk-Based Development]]`
+  - 연결 이유: Git Workflow를 구성하는 핵심 전략 중 하나로, 빠른 통합을 목적으로 하는 방법론입니다 [2].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 짧은 수명의 브랜치, 빈번한 병합, 기능 플래그(Feature Flags) 활용이 프로젝트 배포 속도에 어떻게 기여하는지 이해할 수 있습니다 [9, 12].
+
+- `[[Git Flow]]`
+  - 연결 이유: 구조가 복잡한 대규모 프로젝트의 릴리스를 관리하기 위해 만들어진 전통적 브랜칭 모델입니다 [2, 10].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: `develop`, `release`, `hotfix` 등 다중 브랜치 전략이 왜 오버헤드를 유발하면서도 엔터프라이즈 환경에서 사용되는지 파악할 수 있습니다 [8, 10].
+
+#### [관계 유형 B (구현/활용 도구)]
+- `[[Conventional Commits]]`
+  - 연결 이유: 팀의 일관된 코드베이스 히스토리 관리를 위해 Git 커밋 메시지 작성에 적용되는 업계 표준 규칙입니다 [6, 16].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: `feat:`, `fix:`, `chore:`와 같은 접두사가 리뷰어의 코드 이해도를 어떻게 높이고 자동화된 릴리스에 기여하는지 배울 수 있습니다 [6, 16].
+
+- `[[Pull Requests (PR)]]`
+  - 연결 이유: 브랜치의 코드를 `main`으로 병합하기 전, 협업 팀원들이 코드를 검토하는 핵심 관문입니다 [13, 16].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 브랜치 보호 설정, 동료 리뷰 요구(1 review required), 지속적 통합(CI) 체크가 시스템 안정성 유지에 어떻게 필수적으로 작용하는지 이해할 수 있습니다 [16, 17].
+
+- `[[Ticket IDs (Traceability)]]`
+  - 연결 이유: 코드의 변경 사항이 어떤 비즈니스 요구사항(예: Jira 티켓)에 의해 발생했는지를 연결하는 도구적 장치입니다 [5, 22].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: `PROJ-123` 형태의 티켓 번호를 브랜치와 커밋에 삽입함으로써 리뷰어에게 맥락을 제공하고, 문서화 및 작업 추적(Traceability)을 어떻게 달성하는지 알 수 있습니다 [5, 22].
+
+### Deeper Research Questions
+- 소규모 팀이 성장하여 복잡성이 증가할 때, Feature Branch Workflow에서 Git Flow로 안전하게 마이그레이션하려면 어떤 절차와 팀 내 교육이 필요한가?
+- Trunk-Based Development를 효과적으로 도입하기 위해 CI/CD(지속적 통합/배포) 파이프라인에서 반드시 구성해야 하는 자동화 테스트 조건은 무엇인가?
+- Conventional Commits 시스템과 연동하여 자동 릴리스 노트를 작성하고 시맨틱 버저닝(Semantic Versioning)을 구현하는 기술적 원리는 어떻게 작동하는가?
+- 다수의 작업자가 겹치는 영역을 수정할 때 발생하는 Merge Conflict를 예방하기 위해, 'Atomic Commits'와 '자주 병합하기' 원칙은 실무에서 어떻게 구체적으로 적용되어야 하는가?
+- 코드 리뷰의 병목 현상을 방지하기 위해 PR의 규모를 작게(예: 200줄 이하) 유지하면서도 논리적인 기능 단위를 훼손하지 않는 코드 분할 기법은 무엇인가?
+
+### Practical Application Contexts
+- **Implementation:** 새로운 작업을 시작할 때 무조건 `git checkout -b feature/티켓ID-작업명`으로 독립적인 브랜치를 파고, 완료 후 `feat:` 등의 규칙을 따른 커밋 메시지를 작성한 뒤 `main` 브랜치에 PR을 생성합니다 [6, 7, 13, 22].
+- **System Design:** GitHub와 같은 호스팅 플랫폼에서 `main` 브랜치 보호(Branch Protection) 옵션을 활성화하여 직접 푸시를 막고, CI 빌드 통과와 최소 1인의 승인이 있어야 병합되도록 시스템을 설계합니다 [17].
+- **Operation / Maintenance:** 브랜치가 병합될 때마다 스쿼시 병합(Squash and merge)을 강제하여 커밋 히스토리를 단일 항목으로 압축하고, 병합 후 남은 브랜치를 자동 삭제(Auto-delete) 설정하여 저장소를 깔끔하게 운영합니다 [17-19].
+- **Learning Path:** Git에 입문하는 소규모 프로젝트의 경우, 복잡한 `develop` 브랜치 없이 `main` 브랜치 하나와 기능 브랜치들로만 구성된 가벼운 워크플로우(Feature-Branch Workflow)를 먼저 학습하고 체화하는 것이 권장됩니다 [4, 8].
+- **My Project Relevance:** 현재 진행하는 3인 규모의 프로젝트 등에서는 Git Flow의 무거운 절차를 피하고, 항상 배포 가능한 안정적인 `main` 브랜치를 기준으로 짧은 기능 브랜치를 생성하여 빠른 리뷰와 피드백을 주고받는 방식을 즉각 도입할 수 있습니다 [4, 8].
+
+### Adjacent Topics
+- `[[CI/CD (Continuous Integration/Continuous Deployment)]]`
+  - 확장 방향: PR을 생성하거나 병합할 때 코드를 자동으로 테스트하고 빌드, 배포하는 인프라 파이프라인 구성 방법론으로 확장하여 조사.
+- `[[Semantic Versioning (SemVer)]]`
+  - 확장 방향: Git 태그(Tag)와 Conventional Commits를 활용하여 소프트웨어의 버전을 체계적이고 일관성 있게 부여하는 방법으로 확장.
+
+---
+*Last updated: 2026-04-30*
\ No newline at end of file
diff --git a/00_Raw/GitHub Flow.md b/00_Raw/GitHub Flow.md
new file mode 100644
index 00000000..2214b4bc
--- /dev/null
+++ b/00_Raw/GitHub Flow.md	
@@ -0,0 +1,64 @@
+# [[GitHub Flow]]
+
+## 📌 Brief Summary
+GitHub Flow는 복잡한 Git Flow의 대안으로 사용되는 가볍고 단순한 브랜치 기반 워크플로우입니다 [1, 2]. 이 방식은 항상 배포 가능한 상태(deployable)를 유지하는 `main` 브랜치를 중심으로 작동하며, 개발자는 새로운 작업을 위해 짧은 주기의 기능 브랜치(feature branch)를 생성합니다 [3-5]. 변경된 코드는 동료의 코드 리뷰와 CI/CD 테스트를 모두 통과한 후 오직 Pull Request(PR)를 통해서만 `main`에 병합됩니다 [1, 6].
+
+## 📖 Core Content
+* **안정적인 `main` 브랜치 유지**
+  GitHub Flow의 핵심은 `main` (또는 `master`) 브랜치가 항상 안정적이고 언제든 배포 가능한 상태여야 한다는 점입니다 [3-5]. 개발자는 어떠한 경우에도 `main` 브랜치에 직접 커밋(direct commit)해서는 안 됩니다 [1, 6, 7].
+* **기능 브랜치(Feature Branch) 기반 작업**
+  모든 새로운 기능 개발, 버그 수정, 문서 작업 등은 `main`에서 파생된 짧은 수명(short-lived)의 전용 브랜치에서 수행되어야 합니다 [3-5]. 브랜치 이름은 `feature/user-auth` 또는 `bugfix/login-error`와 같이 설명적이어야 하며, 가능하면 티켓 ID(예: `PROJ-123`)를 포함하여 추적성을 높이는 것이 좋습니다 [8, 9].
+* **Pull Request (PR) 및 코드 리뷰**
+  작업이 완료되면 `main` 브랜치로 병합하기 위해 PR을 생성합니다 [6, 10]. 병합 전에는 반드시 최소 1명 이상의 팀원에게 코드 리뷰(Peer Review)를 받아야 하며, CI/CD 환경에서의 자동화 테스트를 통과해야 합니다 [1, 6, 8]. 이는 혼자서 잘못된 코드를 병합하는 것을 방지하는 안전장치입니다 [8].
+* **병합 규칙과 정리**
+  커밋 히스토리를 깔끔하게 유지하기 위해 PR을 병합할 때는 'Squash Merge' 방식을 주로 사용합니다 [6, 7, 11]. 성공적으로 병합된 이후에는 불필요한 브랜치가 쌓이지 않도록 기능 브랜치를 즉시 삭제(auto-delete)합니다 [6, 8, 11].
+* **워크플로우 마이그레이션 (Migration)**
+  팀이 기존의 복잡한 Git Flow에서 GitHub Flow로 전환하여 통합 속도를 높이고 단순화하려면, 릴리스 브랜치(release branch) 생성을 중단하고, `develop` 브랜치를 `main`으로 통합한 뒤, `main` 브랜치에서 직접 배포하도록 CI/CD 파이프라인을 업데이트해야 합니다 [2]. 반대로 프로젝트의 구조가 더 복잡해지면 `develop` 브랜치 등을 추가해 Git Flow로 되돌아갈 수도 있습니다 [12].
+
+## ⚖️ Trade-offs & Caveats
+* **병합 코드의 즉각적인 리스크**: `main` 브랜치가 유일한 배포 기준점이 되므로, 리뷰나 테스트가 누락되어 버그가 포함된 코드가 병합될 경우 프로덕션(운영) 환경에 치명적인 영향을 미칠 수 있습니다 [13, 14]. 따라서 강력한 CI/CD 자동화 환경과 Branch Protection Rule(보호 규칙)이 필수적으로 뒷받침되어야 합니다 [1, 6].
+* **브랜치 수명 관리의 어려움**: 기능 브랜치가 너무 오래 유지(Long-lived)되면 `main` 브랜치와의 차이가 벌어져 심각한 병합 충돌(Merge Conflict)이 발생합니다 [13, 15]. 이를 방지하기 위해 개발자는 매일 작업 전 `main` 브랜치의 최신 상태를 당겨오고(pull/rebase) 변경 사항을 작게 유지하는 규율을 엄격히 지켜야 합니다 [11, 13].
+* **대규모/정기 릴리스 프로젝트에서의 한계**: 정해진 일정에 따라 버전을 묶어서 배포해야 하거나, 유지보수해야 할 과거 릴리스 버전이 여러 개인 대규모 프로젝트의 경우, 릴리스 브랜치가 없는 GitHub Flow는 구조적 한계를 가집니다. 이 경우에는 무겁더라도 Git Flow가 더 적합할 수 있습니다 [12, 16].
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+
+#### [관계 유형 A: 아키텍처/기반 기술 (개발 워크플로우)]
+- [[Git Flow]]
+  - 연결 이유: GitHub Flow와 자주 비교되는 분기 전략으로, 프로젝트의 복잡성에 따라 두 전략 사이를 마이그레이션하는 경우가 많습니다 [2, 12].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: `develop`, `release`, `hotfix` 브랜치를 사용하는 Git Flow를 이해함으로써, 상대적으로 GitHub Flow가 생략한 구조적 복잡성과 그에 따른 속도/단순성의 이점을 명확히 비교할 수 있습니다.
+- [[Trunk-Based Development]]
+  - 연결 이유: 소규모 팀에서 빠르고 충돌 없는 병합을 위해 도입할 수 있는 또 다른 경량 워크플로우입니다 [3, 16].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 극단적으로 짧은 생명주기의 브랜치를 사용하거나 메인에 빈번히 직접 병합하는 철학을 통해 CI(지속적 통합)의 본질을 더 깊게 이해할 수 있습니다.
+
+#### [관계 유형 B: 구현/활용 도구]
+- [[Pull Request]]
+  - 연결 이유: GitHub Flow에서 코드 병합을 수행하고 팀원 간의 협업 및 리뷰를 진행하는 가장 핵심적인 메커니즘입니다 [8, 10].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 코드 품질 통제, 피어 리뷰(Peer Review)의 역할 및 CI/CD 훅(Hook)이 작동하는 방식을 구체적으로 이해할 수 있습니다.
+- [[CI/CD]]
+  - 연결 이유: `main` 브랜치를 항상 배포 가능한 상태로 유지하기 위해 배후에서 코드를 검증하는 필수 자동화 파이프라인입니다 [1, 6].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 왜 수동 병합이 위험한지, PR 리뷰가 끝난 코드가 어떻게 안전하게 프로덕션 레벨까지 배포되는지의 전 과정을 파악할 수 있습니다.
+
+### Deeper Research Questions
+- Git Flow 기반 프로젝트에서 GitHub Flow로 마이그레이션할 때, 기존의 버전 관리 체계 및 배포 자동화 파이프라인을 어떻게 재설계해야 하는가?
+- GitHub Flow 환경에서 기능이 미완성된 상태로 `main`에 병합되어야 할 때, Feature Flag(기능 토글)를 어떻게 효과적으로 활용할 수 있는가?
+- 팀 규모가 3~5인에서 20인 이상으로 급격히 성장할 때, GitHub Flow의 한계점은 구체적으로 어떻게 나타나며 어떤 시점에 워크플로우를 전환해야 하는가?
+- 커밋 히스토리를 정리하기 위해 권장되는 Squash Merge 방식이 장기적인 버그 추적성(Traceability) 관점에서는 어떤 단점을 가질 수 있는가?
+- Branch Protection을 통해 '최소 1인의 리뷰'와 'CI 통과'를 강제할 때, 코드 리뷰 병목 현상을 해결하기 위한 프로세스적 최적화 방법은 무엇인가?
+
+### Practical Application Contexts
+- **Implementation:** 개발자는 JIRA 등에서 할당받은 티켓 ID를 기반으로 `feature/PROJ-123-login` 형식의 브랜치를 따고, 한 가지 논리적 변경사항만 담은 Atomic Commit을 수행한 뒤 PR을 생성합니다.
+- **System Design:** GitHub/GitLab 등의 레포지토리 설정에서 `main` 브랜치에 대해 직접 푸시(Direct Push)를 차단하고, Status Check(테스트 통과) 및 지정된 리뷰어의 Approve를 강제하는 보호 규칙(Branch Protection)을 설계합니다.
+- **Operation / Maintenance:** CI/CD 파이프라인이 `main` 브랜치의 변경을 감지하면 자동으로 프로덕션에 배포되도록 구성하고, 저장소의 깔끔한 관리를 위해 병합된 브랜치는 시스템에서 자동 삭제되도록 설정합니다.
+- **Learning Path:** Git 브랜치 기초 명령어 숙지 -> 1기능 1브랜치 원칙 실습 -> PR 작성 및 동료 리뷰 경험 -> 자동화된 CI/CD와의 연동 이해의 순서로 협업 능력을 성장시킬 수 있습니다.
+- **My Project Relevance:** 3~5명의 소규모 팀에서 충돌을 최소화하면서도 빠른 피드백과 릴리스가 필요한 현재 프로젝트 상황에, 불필요한 절차를 없애고 안정성을 보장하는 가장 이상적인 협업 모델로 적용할 수 있습니다.
+
+### Adjacent Topics
+- [[Conventional Commits]]
+  - 확장 방향: 커밋 메시지를 `feat:`, `fix:`, `chore:` 등의 규격으로 통일함으로써, PR 내용의 가독성을 높이고 향후 릴리스 노트를 자동화하는 방향으로 지식을 확장할 수 있습니다.
+- [[Issue Tracking System]]
+  - 확장 방향: 코드 구현(GitHub)과 요구사항 정의(JIRA, Linear 등)를 연결하여 프로젝트 관리 수준을 높이고 변경 사항의 비즈니스 맥락(Traceability)을 추적하는 방법론으로 확장됩니다.
+
+---
+*Last updated: 2026-04-30*
\ No newline at end of file
diff --git a/00_Raw/Large-scale Application Refactoring.md b/00_Raw/Large-scale Application Refactoring.md
new file mode 100644
index 00000000..57dc756e
--- /dev/null
+++ b/00_Raw/Large-scale Application Refactoring.md	
@@ -0,0 +1,66 @@
+# [[Large-scale Application Refactoring]]
+
+## 📌 Brief Summary
+대규모 애플리케이션 리팩토링은 코드의 동작 방식을 보존하면서 내부 구조를 개선하여 오래된 코드베이스의 유지보수성과 확장성을 회복하는 과정이다 [1]. 이는 단순히 코드를 '수정'하는 것이 아니라, 복잡한 비즈니스 로직을 분리하고 구조적 결합도를 낮추는 것을 목표로 한다 [2]. 성공적인 리팩토링을 위해서는 점진적인 접근 방식, 엄격한 아키텍처 적용, 그리고 코드 변경을 뒷받침할 수 있는 테스트 구축이 필수적이다 [1, 3].
+
+## 📖 Core Content
+
+*   **점진적 마이그레이션 전략 (Incremental Migration):** 대규모 애플리케이션을 한 번에 전면 재작성(Rewrite)하는 것은 리스크가 매우 크기 때문에, "재작성이 아닌 리팩토링" 전략이 권장된다 [1]. 예를 들어 상태 관리 도구를 Context API에서 Zustand로 마이그레이션할 때, 알림과 같은 단순한 유틸리티 스토어부터 시작해 결제 흐름과 같은 복잡한 도메인으로 한 번에 하나의 스토어씩 점진적으로 이동해야 한다 [1].
+*   **기능 및 도메인 기반 구조로의 개편:** 레거시 앱에서 흔히 쓰이는 파일 타입 기반 구조(components, hooks 등을 따로 모으는 방식)는 앱이 커질수록 탐색과 유지보수를 어렵게 만든다 [4, 5]. 따라서 비즈니스 기능별로 코드를 모으는 기능 기반 구조나, 단방향 의존성을 강제하는 엄격한 계층 모델인 Feature-Sliced Design(FSD)으로 폴더 구조를 재편하는 것이 핵심적인 리팩토링 목표가 된다 [6-8].
+*   **커스텀 훅을 통한 로직 캡슐화:** 현대 React 리팩토링의 기본 단위는 커스텀 훅이다 [9]. 복잡한 데이터 페칭이나 폼 핸들링 로직을 거대한 UI 컴포넌트에서 추출하여 `useFetch`, `useForm` 등의 훅으로 분리하면, UI와 비즈니스 로직이 격리되어 더 빠르고 독립적인 유닛 테스트가 가능해진다 [9, 10].
+*   **테스트를 통한 안전망 확보:** 코드를 본격적으로 수정하기 전에 테스트(Unit Test, UI Test 등)를 작성하는 것이 최우선 방어선이다 [3, 11, 12]. 기존 기능이 깨지지 않았는지 검증할 뿐만 아니라, 테스트 코드를 작성하는 과정 자체가 개발자가 기존 애플리케이션의 비즈니스 로직과 흐름을 깊이 이해하도록 강제하는 학습 도구가 된다 [13, 14].
+*   **레거시 안티패턴 및 스택 제거:** 효율적인 구조를 위해 불필요하게 렌더링을 유발하는 다수의 `useEffect`를 제거하고, 클라이언트와 서버 상태를 분리하기 위해 TanStack Query와 같은 도구를 도입해야 한다 [15]. 또한, 가능할 경우 클래스 기반 컴포넌트를 함수형 컴포넌트와 훅으로 변환하고, 일관성 없는 CSS 적용 방식을 하나로 통일하는 작업도 수반된다 [15, 16].
+
+## ⚖️ Trade-offs & Caveats
+*   **DRY와 KISS 원칙의 충돌:** 중복을 제거하려는 DRY(Don't Repeat Yourself) 원칙을 과도하게 적용할 경우, 추상화가 지나치게 복잡해져 코드를 단순하게 유지해야 하는 KISS(Keep It Simple, Stupid) 원칙을 위반하게 된다 [17]. 따라서 특정 패턴이 세 번 반복될 때까지 기다렸다가 추상화를 진행하는 것이 조기 최적화로 인한 부작용을 막는 방법이다 [17].
+*   **재작성(Rewrite) vs 리팩토링(Refactoring)의 기로:** 리팩토링 대상인 앱의 규모가 비교적 작다면 처음부터 새로 앱을 구축하는 것이 오히려 효율적일 수 있다 [11]. 그러나 대형 앱의 경우 전체 재작성은 위험이 커서 점진적 마이그레이션을 해야 하는데, 이 경우 전환 기간 동안 두 가지 다른 기술이나 아키텍처 패턴이 공존해야 하는 과도기적 기술 부채를 감당해야 한다 [1].
+*   **컴파일러 자동화 도입의 장벽:** React Compiler와 같이 성능 최적화(메모이제이션)를 자동화해 주는 도구를 도입하면 수동 최적화 코드를 지워 코드를 간결하게 만들 수 있다 [18]. 하지만 기술 부채가 많은 레거시 코드베이스의 경우, 기존 코드가 'React의 규칙(Rules of React)'을 광범위하게 위반하고 있다면 컴파일러가 제대로 작동하지 않으므로, 도입 전 대대적인 사전 리팩토링이 선행되어야 하는 제약이 따른다 [19].
+*   **공유(Shared) 모듈의 비대화:** 기능 기반 아키텍처(예: FSD)로 분리할 때, 공통으로 쓰이는 코드를 무분별하게 'Shared' 계층에 넣으면 해당 계층이 복잡한 스파게티 코드가 되고 변경 시 영향 범위(Blast Radius)가 기하급수적으로 커지는 위험이 있다 [20, 21]. 
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+
+#### [아키텍처 및 기반 원칙]
+- [[Feature-Sliced Design]]
+  - 연결 이유: 대규모 코드베이스의 스파게티화를 해결하고, 도메인/기능 중심의 단방향 의존성 규칙을 부여하여 확장 가능한 구조를 만드는 리팩토링의 궁극적 목표 모델이기 때문이다 [7, 22].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 기능(Feature)과 계층(Layer)을 어떻게 나누고 캡슐화하여 서로 간의 의존성 결합을 끊어내는지에 대한 실무적 아키텍처 구조 [6, 23].
+
+- [[SOLID Principles]]
+  - 연결 이유: 단일 책임 원칙(SRP) 등을 통해 거대한 컴포넌트가 가지는 여러 책임을 분리하고, 함수나 컴포넌트를 테스트 가능하게 잘게 쪼개는 리팩토링의 핵심 이론적 배경이기 때문이다 [24, 25].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 기능적 컴포넌트 내에서 인터페이스(Props)를 어떻게 분리하고, 확장에 열려있으면서 수정에는 닫힌 코드 작성을 구현하는 방법 [25, 26].
+
+#### [구현 및 활용 도구]
+- [[Unit Testing]]
+  - 연결 이유: 레거시 코드 구조를 변경할 때 기능이 망가지지 않았음을 보장하는 첫 번째 단계이자 가장 중요한 안전망 역할을 수행하기 때문이다 [3, 12].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 코드를 어떻게 더 작고 논리적인 블록 단위로 나누어(Triangulation) 의존성 없이 독립적으로 검증할 수 있는지에 대한 방법론 [9, 12].
+
+- [[Custom Hooks]]
+  - 연결 이유: 리액트 컴포넌트 내부에 복잡하게 얽힌 상태와 사이드 이펙트 로직을 외부로 추출하는 리팩토링의 주된 단위이자 도구이기 때문이다 [9].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: UI 렌더링 책임과 비즈니스 데이터 처리 책임을 어떻게 물리적으로 격리하여 코드 재사용성을 높일 수 있는지의 원리 [9, 10].
+
+### Deeper Research Questions
+
+- 리팩토링 과정에서 Feature-Sliced Design(FSD) 아키텍처를 도입할 때, 여러 기능(Feature)에서 동시에 요구되는 교차 관심사(Cross-cutting concerns) 로직은 어떤 방식으로 분리하여 관리해야 하는가?
+- 테스트 코드가 전무한 거대한 레거시 React 앱을 리팩토링할 때, 어떤 부분(예: 공통 유틸, UI 컴포넌트, 전역 상태 등)부터 우선순위를 두고 테스트 커버리지를 확보해야 하는가?
+- 대규모 애플리케이션의 Context API 기반 전역 상태를 Zustand 등 현대적 상태 관리 도구로 점진적으로 마이그레이션할 때 발생하는 상태 동기화 문제는 어떻게 해결할 수 있는가?
+- 기존의 수동 메모이제이션(`useMemo`, `useCallback`) 코드가 많은 레거시 앱에 React Compiler를 도입하기 위해 코드 내의 'Rules of React' 위반 사항을 추적하고 검증하는 효과적인 자동화 프로세스는 무엇인가?
+- 클래스형 컴포넌트를 함수형 컴포넌트와 커스텀 훅 구조로 리팩토링할 때 발생할 수 있는 메모리 누수(Memory Leaks) 패턴을 감지하고 방지하는 디버깅 전략론은 무엇인가?
+
+### Practical Application Contexts
+
+- **Implementation:** 거대한 폼 처리나 API 페칭 로직이 뷰와 결합하여 300줄이 넘어가는 기존 컴포넌트를, 단일 책임 원칙(SRP)에 따라 순수 뷰 컴포넌트와 비즈니스 로직을 담은 커스텀 훅으로 추출하여 다시 연결한다 [9, 25].
+- **System Design:** 폴더 구조를 `components/`, `hooks/` 같은 파일 유형 구분이 아닌, 비즈니스 도메인(예: 인증, 결제)을 중심으로 모은 기능 기반 혹은 FSD 기반 폴더 계층 구조로 전면 재설계한다 [8, 27].
+- **Operation / Maintenance:** ESLint와 Husky 등의 도구를 파이프라인에 구축하여 리팩토링된 코드가 상위 계층을 잘못 참조하는 역의존성(Reverse dependency)을 발생시키거나 코드 컨벤션이 어긋나지 않도록 엄격히 통제한다 [28].
+- **Learning Path:** 리팩토링해야 할 코드를 파악하기 전, 먼저 작은 빈 프로젝트나 '토이 앱'을 만들어 리팩토링에 도입할 새로운 기술(React의 최신 기능 등)의 기초를 실습하여 개념을 확립한다 [29].
+- **My Project Relevance:** 다른 개발자들이 작성한 레거시 코드를 인계받아 논문 프로젝트용으로 리팩토링해야 하는 경우, 먼저 기존 로직을 파악하기 위한 유닛 테스트를 작성한 후, 무분별하게 혼용된 CSS 스타일 정책을 하나로 통일시키고 불필요한 전역 상태를 지역 상태로 전환하는 실무 프로세스를 진행한다 [14, 16, 30, 31].
+
+### Adjacent Topics
+
+- [[Web Performance Optimization]]
+  - 확장 방향: 리팩토링 작업과 병행하여 번들 사이즈 감소(코드 스플리팅), 리렌더링 최적화, 불필요한 렌더 블로킹 제거 등을 통해 애플리케이션의 런타임 및 로딩 속도를 향상하는 전략적 기법을 탐구한다.
+- [[State Management Fragmentation]]
+  - 확장 방향: 레거시 앱의 거대한 단일 전역 상태를 분석하여 로컬 컴포넌트 상태, 전역 UI 상태, 서버 캐시 상태, URL 상태 등으로 파편화 및 전문화하여 각각에 맞는 도구(Zustand, React Query 등)로 이관하는 설계 방법론을 조사한다.
+
+---
+*Last updated: 2026-04-30*
\ No newline at end of file
diff --git a/00_Raw/Lazy Loading.md b/00_Raw/Lazy Loading.md
new file mode 100644
index 00000000..8756a85b
--- /dev/null
+++ b/00_Raw/Lazy Loading.md	
@@ -0,0 +1,63 @@
+# [[Lazy Loading]]
+
+## 📌 Brief Summary
+Lazy Loading은 리소스나 코드 청크를 애플리케이션 초기 구동 시 한 번에 로드하지 않고, 사용자가 실제로 필요로 하는 시점에 비동기적으로 불러오는 성능 최적화 기법입니다 [1, 2]. 프론트엔드 환경에서는 초기 JavaScript 번들 크기를 최대 20~70%까지 줄여 초기 페이지 로드 시간을 획기적으로 향상시킵니다 [3]. 주로 경로(Route) 기반 컴포넌트, 무거운 UI 위젯(차트 등), 뷰포트 하단의 이미지 등에 적용되어 앱의 전반적인 반응성과 Core Web Vitals 지표를 개선합니다 [4, 5].
+
+## 📖 Core Content
+*   **JavaScript 코드 스플리팅과 동적 임포트(Dynamic Imports)**: Lazy Loading은 대규모 애플리케이션을 온디맨드(on-demand)로 로드할 수 있는 더 작은 청크(chunk)로 분할하는 코드 스플리팅(Code Splitting) 기법의 핵심입니다 [2]. 동적 임포트를 통해 Vite나 Webpack 같은 빌드 툴이 렌더링에 당장 필요하지 않은 코드를 메인 번들에서 분리하여 독립적인 파일로 만듭니다 [1, 6, 7].
+*   **React 환경에서의 구현 (`React.lazy` 및 `Suspense`)**: React 애플리케이션에서는 `React.lazy()` 함수를 통해 컴포넌트의 지연 로딩을 활성화합니다 [8]. 모듈이 네트워크를 통해 다운로드되는 동안 화면이 멈추거나 비어 보이지 않도록, `<Suspense>`를 감싸서 로딩 스피너와 같은 대체 UI(Fallback UI)를 렌더링합니다 [7, 8]. 
+*   **라우트 레벨 및 컴포넌트 레벨 지연 로딩**: 가장 일반적인 방식은 라우트 레벨에서 적용하는 것으로, 사용자가 특정 페이지로 네비게이션할 때만 해당 페이지의 JavaScript 청크가 다운로드되도록 합니다 [2, 7]. 컴포넌트 단위로는 서드파티 통합 기능(비디오 플레이어, PDF 뷰어 등)이나 차트, 리치 텍스트 에디터 같이 무거운 UI 블록에 적용하여 메인 번들을 최소화합니다 [5, 6].
+*   **이미지(Media) 최적화**: JavaScript 코드뿐 아니라 미디어 리소스에도 Lazy Loading이 널리 쓰입니다 [4]. HTML `<img>` 태그에 네이티브 속성인 `loading="lazy"`를 추가하면, 스크롤을 통해 사용자의 뷰포트에 도달하기 전까지 이미지를 다운로드하지 않으므로 초기 페이지 로딩의 오버헤드를 줄입니다 [4].
+
+## ⚖️ Trade-offs & Caveats
+*   **초기 뷰포트(Above-the-fold) 콘텐츠 적용 금지**: 지연 로딩은 스크롤 없이 처음 화면에 바로 보여야 하는 핵심 콘텐츠(Above-the-fold)나 즉시 상호작용해야 하는 렌더링이 빠른 요소에는 절대 적용해서는 안 됩니다 [5]. 이를 적용할 경우 초기 페인트 시간이 느려지고 사용자 경험이 심각하게 저하됩니다 [5, 9].
+*   **사용자 인터랙션 시 일시적 지연 발생**: 지연 로딩된 기능이나 페이지에 사용자가 처음 접근할 때, 브라우저는 필요한 스크립트 청크를 그제야 네트워크로 요청합니다 [7, 8, 10]. 이로 인해 약간의 대기 시간이 발생할 수 있으므로 `<Suspense>`를 통한 폴백 상태를 세심하게 디자인해야 합니다 [8, 11].
+*   **과도한 파편화(Over-fragmentation) 주의**: 크기가 작고 가벼운 기능까지 모두 지연 로딩으로 분리할 경우, 오히려 브라우저의 네트워크 요청 횟수가 급증하고 관리해야 할 로딩 상태(`Suspense`)가 많아져 성능 및 개발 효율을 떨어뜨릴 수 있습니다 [5, 12].
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+
+#### [아키텍처/기반 기술]
+- [[Code Splitting]]
+  - 연결 이유: Lazy Loading이 가능하도록 애플리케이션의 단일 JavaScript 번들을 여러 개의 작은 청크 단위로 나누는 근본적인 기반 기술이기 때문입니다 [2, 13].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 모던 프론트엔드 환경에서 빌드 툴(Vite, Webpack)이 런타임 최적화를 위해 코드를 어떻게 분할하고 관리하는지 이해할 수 있습니다 [6, 7].
+
+- [[Dynamic Imports]]
+  - 연결 이유: 자바스크립트 모듈을 파일의 최상단에서 정적으로 불러오지 않고, 실행 중에 비동기적으로 불러오기 위해 `import()` 문법을 사용하는 방식입니다 [1, 7].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 라우트 전환이나 특정 이벤트 발생 시점에 필요한 코드만 네트워크로 호출하는 런타임 메커니즘을 파악할 수 있습니다 [7].
+
+#### [구현/활용 도구]
+- [[React Suspense]]
+  - 연결 이유: `React.lazy()`를 이용해 지연 로딩을 수행할 때, 청크가 로드되기 전까지 렌더링을 일시 중지하고 Fallback UI를 화면에 그려주는 핵심 컴포넌트입니다 [7, 8].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 비동기 UI 로딩 시 사용자 경험(UX)을 부드럽게 유지하기 위한 렌더링 제어 및 로딩 상태 설계 패턴을 배울 수 있습니다 [8, 11].
+
+- [[Vite manualChunks]]
+  - 연결 이유: Vite를 통해 빌드할 때, 변경이 잦지 않은 무거운 벤더 라이브러리(React 코어 등)를 Lazy Loading의 청크 분할 전략과 결합해 별도 파일로 독립시키는 환경 설정입니다 [7, 14].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 브라우저 캐싱 전략을 극대화하고, 초기 번들 용량 경고("Large Chunks") 문제를 해결하는 구체적인 번들러 최적화 방법을 학습할 수 있습니다 [7, 15].
+
+### Deeper Research Questions
+
+- React 18의 동시성 렌더링(Concurrent Rendering) 기능인 `useTransition` 등은 지연 로딩 시 발생하는 UI 멈춤 현상을 어떻게 보완할 수 있는가? [16, 17]
+- 사용자 경험 저하를 막기 위해 지연 로딩되는 컴포넌트를 사용자가 클릭하기 직전에 미리 가져오는 Prefetching 전략은 어떻게 구현하는가? [18, 19]
+- Next.js의 클라이언트 컴포넌트 지연 로딩과 서버 컴포넌트(RSC) 아키텍처는 초기 번들 최적화 측면에서 어떤 차이점과 시너지를 가지는가? [5, 20, 21]
+- 무거운 UI 블록을 지연 로딩할 때, `rollup-plugin-visualizer`와 같은 번들 분석 도구를 통해 지연 로딩 대상을 어떻게 효과적으로 식별하고 우선순위를 정할 수 있는가? [10, 12]
+- 네이티브 브라우저 기능인 `loading="lazy"` 속성과 JavaScript 기반의 Intersection Observer API를 활용한 미디어 지연 로딩의 성능 최적화 한계점과 Trade-off는 무엇인가? [4]
+
+### Practical Application Contexts
+
+- **Implementation:** React 코드 상단의 무거운 외부 컴포넌트(예: 에디터, 차트 등) import 문을 지우고, `const Dashboard = React.lazy(() => import('./Dashboard'));`와 같이 변경한 후 렌더링 영역을 `<Suspense fallback={<Spinner/>}>`로 감쌉니다 [1, 6-8].
+- **System Design:** 프론트엔드 라우팅 및 아키텍처 설계 시부터, 필수 초기 진입 화면(Above-the-fold)은 즉시 로드하고, 관리자 패널이나 잘 쓰이지 않는 라우트는 분리하여 Code Splitting되도록 시스템의 번들링 전략을 구상합니다 [5, 12, 14].
+- **Operation / Maintenance:** 운영 중인 서비스가 무거워지거나 Vite 빌드 시 "500 kB 초과 청크" 경고가 뜰 경우, 번들 분석 도구를 사용해 메인 번들에서 분리 가능한 무거운 벤더나 특정 라우트를 식별해 점진적으로 Lazy Loading을 적용합니다 [10, 12, 15].
+- **Learning Path:** React 기초 렌더링 사이클 학습 ➔ JavaScript 모듈 및 번들러 구조 이해 ➔ `React.lazy`와 `Suspense`를 통한 라우트 스플리팅 적용 ➔ Chrome 성능 탭과 Web Vitals로 실제 로드 속도 측정 및 검증 [13, 22, 23].
+- **My Project Relevance:** 웹 애플리케이션의 규모가 커짐에 따라 필연적으로 증가하는 JavaScript 페이로드 문제를 해결하고, FCP(First Contentful Paint)와 TTI(Time to Interactive) 등 핵심 성능 지표를 방어하기 위한 필수적인 렌더링 최적화 전략입니다 [3, 8].
+
+### Adjacent Topics
+
+- [[Core Web Vitals]]
+  - 확장 방향: 지연 로딩이 검색 엔진 최적화(SEO) 및 사용자 경험 지표인 FCP, LCP(Largest Contentful Paint), INP(Interaction to Next Paint) 수치를 실제로 얼마나 개선하는지 측정 및 분석하는 관점으로 확장할 수 있습니다 [3, 23, 24].
+- [[Server Components (RSC)]]
+  - 확장 방향: 클라이언트 사이드의 자바스크립트 크기를 줄이기 위한 또 다른 현대적 패러다임으로, 클라이언트에서 실행될 코드를 아예 서버에서 렌더링하고 HTML로만 보내는 방식과 Lazy Loading과의 역할을 비교/대조합니다 [20, 21].
+
+---
+*Last updated: 2026-04-30*
\ No newline at end of file
diff --git a/00_Raw/Next.js App Router.md b/00_Raw/Next.js App Router.md
new file mode 100644
index 00000000..43ddac1f
--- /dev/null
+++ b/00_Raw/Next.js App Router.md	
@@ -0,0 +1,54 @@
+# [[Next.js App Router]]
+
+## 📌 Brief Summary
+Next.js App Router는 Next.js(버전 13 이후)에서 도입된 최신 라우팅 및 아키텍처 시스템으로, React Server Components(RSC)를 기본적으로 지원하여 클라이언트 측 자바스크립트 전송량을 줄이고 초기 로딩 속도를 향상시킵니다 [1, 2]. 이 시스템은 `app` 디렉토리를 기반으로 동작하며, `page.js`, `layout.js`와 같은 특수 파일들을 통해 직관적이고 구조화된 라우팅을 제공합니다 [3, 4].
+
+## 📖 Core Content
+
+*   **특수 파일을 활용한 구조적 라우팅**: Next.js App Router는 라우트 구성 및 관리를 위해 특수 파일 명명 규칙을 사용합니다. 라우트는 `page.js`로, 공유 레이아웃은 `layout.js`로, 사용자 정의 에러는 `error.js`로, 로딩 상태는 `loading.js`로 정의하여 애플리케이션의 동작을 제어합니다 [3].
+*   **동적 라우트 및 라우트 그룹**: 동적인 경로 처리를 위해 `[param]`을 사용하고, 포괄적(catch-all) 라우트 처리를 위해 `[...param]`을 지원합니다 [3]. 또한 URL 구조에 영향을 주지 않고 논리적으로 라우트를 그룹화할 수 있도록 괄호를 사용하는 라우트 그룹(예: `(folderName)`) 기능을 제공하여, 기능별 또는 팀별로 코드를 깔끔하게 조직할 수 있습니다 [5].
+*   **React Server Components (RSC) 통합**: App Router는 서버 컴포넌트를 기반으로 동작합니다. 이를 통해 정적이거나 데이터 주도적인(read-only) UI는 클라이언트 측 자바스크립트 없이 서버에서만 렌더링할 수 있어 자바스크립트 번들 크기와 Hydration 소요 시간을 극대화하여 줄여줍니다 [2, 6, 7].
+*   **클라이언트와 서버의 역할 분리**: 서버 컴포넌트에서는 상태(state), `useEffect`, 클라이언트 전용 라이브러리를 사용할 수 없습니다 [8]. 따라서 상호작용이 즉각적으로 필요한 UI(모달, 입력창 등)에만 파일 상단에 `use client` 지시어를 선언하여 클라이언트 컴포넌트로 만들고, 나머지는 서버 컴포넌트로 분리하는 아키텍처 패턴이 필수적입니다 [7, 9].
+*   **동시성 렌더링(Concurrent Rendering) 완벽 지원**: App Router는 React 18의 동시성 기능과 완벽하게 통합되어 있습니다. `useTransition` 및 서버 컴포넌트와 함께 사용하여 사용자 인터페이스의 응답성을 떨어뜨리지 않고 백그라운드 작업을 효과적으로 처리할 수 있습니다 [10].
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+
+- [[React Server Components]]
+  - 연결 이유: Next.js App Router 아키텍처의 핵심 기반으로, 번들 크기를 줄이고 데이터 페칭 성능을 향상시키는 역할을 합니다 [1, 2].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 클라이언트 측 렌더링 코드와 서버 측 렌더링 코드 간의 명확한 경계 구분 및 Hydration 최소화 전략 [6, 7, 9].
+
+- [[Route Groups]]
+  - 연결 이유: App Router 내에서 URL 경로를 변경하지 않고도 폴더 구조를 논리적으로 조직할 수 있게 해주는 핵심 폴더 라우팅 패턴입니다 [5, 11].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 복잡한 애플리케이션에서 별도의 레이아웃을 가진 섹션(예: 마케팅 페이지와 상점 페이지)을 충돌 없이 독립적으로 분리하는 방법 [5, 11].
+
+- [[Concurrent Rendering]]
+  - 연결 이유: Next.js App Router가 기본적으로 완벽하게 지원하는 React의 렌더링 메커니즘으로, 렌더링 작업을 일시 중지, 중단 및 재개할 수 있게 해줍니다 [10, 12].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: `useTransition` 및 `useDeferredValue` 훅을 통해 무거운 렌더링 시에도 사용자 입력 반응성(UX)을 높게 유지하는 원리 [13, 14].
+
+### Deeper Research Questions
+
+- 여러 개의 루트 레이아웃을 가진 Route Groups 환경에서 최상위 `layout.js`가 없을 때, 다른 루트 레이아웃 간의 네비게이션 시 발생하는 전체 페이지 로드(full page load)의 내부 메커니즘은 무엇인가? [11]
+- App Router에서 `[param]` 형태의 동적 라우트와 Route Group 간의 경로 중복(예: `(marketing)/about/page.tsx`와 `(shop)/about/page.tsx`) 충돌 시, Next.js의 라우트 해석 우선순위는 어떻게 결정되는가? [11]
+- 기존 Pages Router 방식과 비교하여 App Router의 React Server Components는 데이터 페칭 시 어떻게 'Double Fetching' 문제를 해결하고 성능을 최적화하는가? [7, 8]
+- 클라이언트 컴포넌트(`use client`)와 서버 컴포넌트가 혼합된 형태의 트리에서, 서버 컴포넌트가 클라이언트 컴포넌트를 `children`으로 전달하거나 임포트할 때 적용되는 직렬화 규칙 및 한계점은 무엇인가? [6, 7, 9]
+- 특수 라우팅 파일 중 `error.js`가 React Error Boundary로서 동작할 때 서버 컴포넌트 오류와 클라이언트 컴포넌트 오류를 각각 처리하는 흐름은 어떻게 구분되는가? [3]
+
+### Practical Application Contexts
+
+- **Implementation:** 라우트를 구현할 때는 `kebab-case` 명명 규칙을 적용한 폴더(예: `auth-provider.tsx`)를 생성하여 라우팅하고, 대시보드처럼 정적인 레이아웃은 서버 컴포넌트로 두면서 `AddToCartButton` 같이 상호작용이 필요한 위젯만 `use client` 컴포넌트로 임포트하여 구현합니다 [4, 7, 15].
+- **System Design:** 애플리케이션 코드를 조직할 때, 기능별(Feature-Based) 폴더 구조를 사용하여 컴포넌트, 페이지, 유틸리티를 한 기능 폴더(예: `features/auth/`)에 모으고, 이를 다시 `Route Groups`를 통해 모듈화된 아키텍처로 설계합니다 [5, 16, 17].
+- **Operation / Maintenance:** 초기 자바스크립트 번들 용량이 커져 INP(Interaction to Next Paint)와 TTI(Time to Interactive) 등 코어 웹 바이탈 수치가 저하될 때, 어떤 컴포넌트가 불필요하게 클라이언트 사이드로 로드되었는지 파악하여 서버 컴포넌트로 마이그레이션 하는 유지보수를 진행합니다 [6, 18].
+- **Learning Path:** 우선 React의 렌더링 모델 트리거 요인과 상태 변화 원리를 숙지하고 [19], 이후 React 18의 동시성 훅(`useTransition`) 동작을 실습한 뒤 [12, 13], Next.js App Router의 Server Components를 통한 서버/클라이언트 경계 개념을 배우는 순서로 접근해야 합니다 [2, 7].
+- **My Project Relevance:** 소스에 관련 정보가 부족합니다.
+
+### Adjacent Topics
+
+- [[Code Splitting & Lazy Loading]]
+  - 확장 방향: App Router의 Server Components뿐만 아니라, `React.lazy`와 `Suspense`를 결합하여 라우트 및 무거운 컴포넌트(차트, 에디터 등)를 필요한 순간에만 로드하도록 최적화하는 기법으로의 이해 확장 [20, 21].
+- [[React Context API Optimization]]
+  - 확장 방향: App Router 환경 하의 클라이언트 컴포넌트 내에서 불가피하게 전역 상태를 쓸 때, Context의 광범위한 리렌더링 이슈를 회피하기 위해 컨텍스트를 분리하거나 Zustand, Jotai 등의 외부 라이브러리를 도입하는 방향으로 학습 확장 [22-24].
+
+---
+*Last updated: 2026-04-30*
\ No newline at end of file
diff --git a/00_Raw/Prop Drilling.md b/00_Raw/Prop Drilling.md
new file mode 100644
index 00000000..aea73383
--- /dev/null
+++ b/00_Raw/Prop Drilling.md	
@@ -0,0 +1,56 @@
+# [[Prop Drilling]]
+
+## 📌 Brief Summary
+Prop Drilling은 실제로 해당 데이터가 필요하지 않은 여러 중간 컴포넌트들을 거쳐 계층적으로 데이터를 전달하는 안티 패턴을 의미합니다 [1]. 주로 깊게 중첩된 하위 컴포넌트에 상태나 데이터를 전달해야 할 때 발생합니다 [1]. React 생태계에서는 이 문제를 해결하기 위해 내장된 Context API나 외부 상태 관리 라이브러리를 활용합니다 [1, 2].
+
+## 📖 Core Content
+*   **작동 방식 및 원인:** Prop Drilling은 데이터를 부모 컴포넌트에서 깊이 중첩된 자식 컴포넌트로 전달하기 위해, 중간에 위치한 모든 컴포넌트의 props를 통해 데이터를 통과시키는 방식입니다 [1].
+*   **구조적 문제점:** 이 패턴은 중간 컴포넌트들이 자신에게 필요 없는 데이터를 단지 전달(transport)하기 위한 목적으로 취급하게 만들며, 이는 코드의 복잡성을 높이고 유지보수를 어렵게 만듭니다 [1].
+*   **React의 내장 해결책:** React는 이러한 현상을 해결하기 위해 'Context API'를 도입했습니다. 이를 통해 컴포넌트 트리의 모든 레벨을 거치지 않고도 전역 관심사(global concerns) 데이터를 직접적으로 하위 컴포넌트와 공유할 수 있습니다 [1, 3, 4].
+*   **파생 상태 처리의 한계:** Redux나 Zustand가 파생 상태를 위한 선택자(derived selectors)를 지원하는 것과 달리, Context는 파생 상태를 관리할 때 여전히 Prop Drilling 방식에 의존하게 되거나 불필요한 리렌더링을 피하기 어려운 기능적 한계가 있습니다 [5].
+
+## ⚖️ Trade-offs & Caveats
+Prop Drilling을 피하기 위해 가장 먼저 고려되는 Context API는 빈번하게 변경되는 상태를 다룰 때 심각한 성능 제약(Trade-off)을 동반합니다 [6, 7]. Context 값의 일부만 변경되어도 해당 Context를 구독하는 모든 컴포넌트가 불필요하게 전체 리렌더링(re-render)을 수행하게 됩니다 [6, 8]. 
+
+따라서 장바구니나 실시간 데이터 등 빈번하게 변경되는 상태에 대해 Prop Drilling을 피하겠다고 무작정 Context API를 사용하면 애플리케이션의 성능 저하(Re-render storm)를 초래할 수 있습니다 [9, 10]. 이러한 경우에는 선택자(Selector) 기능을 통해 필요한 상태 변경 시에만 리렌더링을 발생시키는 Zustand나 Redux를 사용하는 것이 최적화 측면에서 필수적인 반대 급부의 해결책이 됩니다 [7, 11].
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+
+#### [기반 기술/해결책]
+- [[Context API]]
+  - 연결 이유: Prop Drilling 문제를 해결하기 위해 React에서 자체적으로 도입한 내장 데이터 전달 메커니즘이기 때문입니다 [1].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: props를 일일이 넘기지 않고 컴포넌트 트리에 데이터를 브로드캐스트하는 원리와 그에 따른 리렌더링 한계를 이해할 수 있습니다 [6, 12].
+
+#### [상태 관리 도구/대안]
+- [[Zustand]]
+  - 연결 이유: Prop Drilling의 대안인 Context API가 갖는 리렌더링 성능 문제를 극복할 수 있는 경량 상태 관리 라이브러리이기 때문입니다 [2, 7].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 선택자(Selector) 패턴을 활용해 필요한 상태의 변경에만 컴포넌트를 리렌더링하도록 스마트하게 구독(subscribe)하는 구조를 이해할 수 있습니다 [7, 13].
+- [[Redux]]
+  - 연결 이유: 대규모 애플리케이션에서 Prop Drilling을 방지하고 상태를 일관성 있게 관리하기 위한 산업 표준 상태 컨테이너 도구이기 때문입니다 [5, 14].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 파생 선택자(derived selectors)가 존재함으로써 Prop Drilling 없이 복잡한 상태와 비동기 로직을 어떻게 효율적으로 다루는지 파악할 수 있습니다 [5, 15].
+
+### Deeper Research Questions
+
+- Prop Drilling을 피하기 위해 Context API를 사용할 때 발생하는 불필요한 리렌더링(re-renders) 문제는 어떤 방식으로 최적화할 수 있는가? [6, 8]
+- Redux와 Zustand가 제공하는 '선택자(Selector)' 기능은 Prop Drilling 방식과 비교하여 파생 상태(derived state)를 처리할 때 어떠한 아키텍처적 이점을 제공하는가? [5, 7]
+- Context API가 아닌 Zustand나 Redux 같은 전문적인 상태 관리 도구를 도입하여 Prop Drilling을 해결해야 하는 애플리케이션의 복잡도 및 컴포넌트 렌더링 빈도의 정확한 기준점은 무엇인가? [10, 11]
+- Prop Drilling을 단순히 회피하기 위해 모든 상태를 전역 컨텍스트(Global Context for Everything)에 넣는 안티 패턴은 시스템 아키텍처에 어떤 부작용을 일으키는가? [16, 17]
+- 전역 상태가 아닌 지역 컴포넌트 트리 내에서 발생하는 Prop Drilling을 해결하기 위해, 컴포넌트 합성(Component Composition)이나 클린 코드 원칙을 적용하는 방법은 무엇인가? [18, 19]
+
+### Practical Application Contexts
+
+- **Implementation:** 깊게 중첩된 하위 컴포넌트에 데이터를 전달할 때, 중간 컴포넌트들이 불필요한 props를 거치지 않도록 `React.createContext()`를 활용해 데이터 제공자(Provider)와 소비자(Consumer)를 분리하여 구현합니다 [1, 12].
+- **System Design:** 테마나 언어 설정과 같은 정적인 전역 관심사(global concerns)에 대한 Prop Drilling을 방지하기 위해서는 Context API를 설계에 반영하지만, 상태 변경이 잦은 영역은 Zustand나 Redux 기반의 스마트 알림 시스템(smart notification system) 구조로 설계하여 관심사와 성능을 모두 챙깁니다 [4, 13, 20].
+- **Operation / Maintenance:** 성능 모니터링 툴(예: React DevTools Profiler)을 통해 Prop Drilling을 우회하고자 도입한 Context가 리렌더링 폭풍(re-render storm)을 일으키는지 추적하고, 병목 발생 시 Selector를 지원하는 상태 관리 도구로 점진적 마이그레이션(Incremental Migration)을 수행합니다 [8, 9, 21].
+- **Learning Path:** React 입문 시 데이터 흐름의 기본인 Prop Drilling의 불편함을 먼저 경험하고, 이를 해결하는 Context API를 학습한 후, 최종적으로 대규모 앱을 위한 Zustand나 Redux로 발전해 나가는 형태의 학습 경로를 밟는 것이 권장됩니다 [22].
+- **My Project Relevance:** 소스에 관련 정보가 부족합니다.
+
+### Adjacent Topics
+
+- [[Re-renders]]
+  - 확장 방향: Prop Drilling을 피하기 위한 수단(Context API)이 초래하는 부작용인 불필요한 렌더링을 방지하기 위한 메모이제이션(`React.memo`, `useMemo`, `useCallback`) 등 React 런타임 성능 최적화 기법으로의 이해 확장이 필요합니다 [3, 6, 23].
+
+---
+*Last updated: 2026-04-30*
\ No newline at end of file
diff --git a/00_Raw/Re-renders Optimization.md b/00_Raw/Re-renders Optimization.md
new file mode 100644
index 00000000..be2c3213
--- /dev/null
+++ b/00_Raw/Re-renders Optimization.md	
@@ -0,0 +1,54 @@
+# [[Re-renders Optimization]]
+
+## 📌 Brief Summary
+Re-renders Optimization은 React 애플리케이션에서 불필요한 컴포넌트 업데이트를 최소화하여 성능, 반응성 및 사용자 경험을 향상시키는 과정입니다 [1, 2]. 주로 상태(state), 속성(props), 컨텍스트(context)의 변경으로 인해 발생하는 과도한 렌더링을 타겟으로 합니다 [3]. 이를 위해 수동 메모이제이션, 상태 관리 최적화, 가상화 기법, 그리고 React Compiler와 같은 최신 자동화 도구를 활용하여 병목 현상을 방지합니다 [4-6].
+
+## 📖 Core Content
+*   **리렌더링의 원인과 성능적 영향:**
+    React 컴포넌트는 내부 상태(state) 변경, 속성(props) 변경, 구독 중인 컨텍스트(context) 값 변경, 혹은 부모 컴포넌트가 리렌더링될 때 업데이트됩니다 [3]. 불필요한 리렌더링이 누적되면 UI 반응성 저하, 메모리 사용량 증가, 상호작용성(TTI) 지연 등을 초래하며, 깊은 컴포넌트 트리에서는 스크립팅 시간을 30~60%까지 증가시킬 수 있습니다 [2].
+*   **수동 메모이제이션 (Manual Memoization):**
+    `React.memo()`를 사용하면 props가 변경되지 않은 경우 이전 렌더링 결과를 재사용하여 렌더링 횟수를 30~50%가량 줄일 수 있습니다 [7, 8]. 이와 함께 `useCallback`과 `useMemo` 훅을 사용하여 객체나 함수의 참조 동등성(Reference Equality)을 유지해야 자식 컴포넌트의 불필요한 렌더링을 막을 수 있습니다 [9, 10]. 단, 무분별한 사용은 비교 연산의 오버헤드를 발생시키므로 프로파일링을 통해 확인된 병목 구간에만 적용해야 합니다 [11, 12].
+*   **컨텍스트 최적화 (Context Optimization):**
+    React의 기본 Context API는 값의 일부만 변경되어도 해당 컨텍스트를 구독하는 모든 컴포넌트를 리렌더링합니다 [13, 14]. 이를 해결하기 위해 컨텍스트를 작은 도메인 단위로 쪼개거나 [15], 선택자(Selector)를 통해 상태의 특정 조각이 변경될 때만 리렌더링을 트리거하는 Zustand, Jotai 등의 외부 상태 관리 라이브러리를 사용하는 것이 권장됩니다 [16-18].
+*   **React Compiler의 도입:**
+    빌드 타임 최적화 도구인 React Compiler는 수동 메모이제이션(`useMemo`, `useCallback`, `React.memo`) 코드를 작성하지 않아도 컴파일 단계에서 자동으로 캐싱 로직을 삽입합니다 [4, 19]. 컴포넌트 전체가 아닌 개별 JSX 요소 단위로 세분화하여 메모이제이션을 수행함으로써, 코드의 가독성을 높이고 불필요한 렌더링을 원천적으로 차단합니다 [19, 20].
+*   **렌더링 패턴 및 동시성 최적화:**
+    수백 개 이상의 항목을 렌더링하는 대규모 리스트에서는 고유하고 안정적인 `key` 속성을 부여하고, 화면에 보이는 항목만 렌더링하는 가상화(Windowing) 라이브러리(예: `react-window`)를 적용하여 DOM 오버헤드를 줄여야 합니다 [6, 21]. 또한 JSX 내부에 익명 함수를 직접 작성하면 매 렌더링마다 새로운 참조가 생성되므로 지양해야 합니다 [22, 23]. 부가적으로 `useTransition` 및 `useDeferredValue`와 같은 동시성 기능을 활용해 무거운 업데이트를 지연시키고 사용자 입력에 대한 UI 반응성을 우선순위에 둘 수 있습니다 [24, 25].
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+- [[React Compiler]]
+  - 연결 이유: 개발자가 수동으로 리렌더링을 최적화하던 기존 방식을 대체하여, 빌드 타임에 자동으로 메모이제이션을 적용하는 2025년 기준 핵심 기술이기 때문입니다 [4].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 컴포넌트 전체가 아닌 개별 JSX 요소와 연산이 어떻게 독립적으로 캐싱되는지의 원리와 서드파티 라이브러리 호환성 한계 [19, 26].
+
+- [[State Management (Zustand vs Context)]]
+  - 연결 이유: 불필요한 전체 리렌더링을 유발하는 Context API의 구조적 한계를 Zustand의 선택자(Selector) 패턴이 어떻게 극복하여 렌더링을 최적화하는지 설명하기 때문입니다 [13, 17].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 자주 변경되는 전역 상태 관리에서 React 렌더링 사이클 외부의 스토어가 어떻게 컴포넌트 렌더링을 정밀하게 제어하는지 [17, 27].
+
+- [[Memoization (useMemo, useCallback)]]
+  - 연결 이유: React의 얕은 비교(Shallow comparison) 특성을 극복하고 참조 동등성을 유지하여 `React.memo`와 결합한 리렌더링 최적화의 기반이 되기 때문입니다 [10].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 무분별한 메모이제이션이 오히려 렌더링 비용보다 큰 성능 오버헤드를 유발하는 이유와 올바른 적용 조건 [11, 12].
+
+### Deeper Research Questions
+- React Compiler가 적용된 환경에서 기존 `React.memo`, `useMemo`, `useCallback`으로 작성된 수동 메모이제이션 코드는 어떤 방식으로 리팩토링되거나 공존해야 하는가?
+- Context API를 다수의 작은 도메인으로 분할하는 아키텍처와 Zustand를 도입하여 선택자를 사용하는 아키텍처 간의 렌더링 성능 및 유지보수성 트레이드오프는 무엇인가?
+- 대규모 리스트에서 안정적인 `key` 속성 부여와 가상화(Windowing) 기법을 함께 적용할 때, DOM 노드 관리와 메모리 가비지 컬렉션 측면에서 내부적으로 어떤 최적화가 발생하는가?
+- JSX 내 익명 함수 사용이 유발하는 참조 변경(Reference change) 문제를 `useCallback` 외에 컴포넌트 외부 선언 방식 등으로 해결할 때 발생하는 상태 접근성 제약은 어떻게 극복할 수 있는가?
+- `useTransition`과 `useDeferredValue`를 활용한 동시성 렌더링(Concurrent rendering)이 리렌더링을 차단하지 않고 지연시킬 때, 무거운 연산이 메인 스레드를 점유하는 한계는 어떻게 보완할 수 있는가?
+
+### Practical Application Contexts
+- **Implementation:** 무거운 컴포넌트나 자식에게 전달되는 함수/객체 prop에 대해 `React.memo()`, `useCallback`, `useMemo`를 선택적으로 적용하여 리렌더링을 방지합니다 [7, 10]. 대규모 리스트 구현 시 `react-window`를 사용합니다 [6].
+- **System Design:** 애플리케이션의 전역 상태를 설계할 때, 테마나 다국어처럼 변경이 적은 정적 데이터는 Context API를, 알림이나 장바구니처럼 빈번하게 변경되는 동적 데이터는 부분 구독(Selector)을 지원하는 외부 상태 라이브러리(Zustand 등)로 설계하여 렌더링 범위를 제한합니다 [18, 28, 29].
+- **Operation / Maintenance:** React DevTools Profiler, `why-did-you-render` 라이브러리, Chrome DevTools Performance Tab을 활용하여 프로덕션 배포 전 및 운영 중에 불필요한 리렌더링과 그 원인을 지속적으로 측정하고 개선합니다 [30-32].
+- **Learning Path:** React의 기본 렌더링 동작 원리(상태, props, 참조 동등성)를 먼저 학습하고 수동 메모이제이션의 비용을 이해한 뒤, 동시성 기능(Concurrent Features)과 React Compiler를 통한 자동화 최적화 패러다임으로 지식을 확장합니다 [5].
+- **My Project Relevance:** 현재 유지보수하거나 새로 구축하는 React 프로젝트에서 성능 저하를 겪고 있다면, 익명 함수 인라인 작성 패턴을 수정하고, 불필요한 거대 Context를 분리하며, 식별 가능한 병목 지점에 프로파일링 기반의 메모이제이션을 적용해 즉각적인 성능 개선을 이룰 수 있습니다 [5, 15, 22].
+
+### Adjacent Topics
+- [[Core Web Vitals (INP, FCP, TTI)]]
+  - 확장 방향: 프론트엔드 코드의 리렌더링 최적화가 실제 사용자의 체감 성능을 측정하는 지표(특히 Interaction to Next Paint)에 브라우저 레벨에서 어떤 영향을 미치는지 확장하여 조사합니다 [2, 33].
+- [[Code Splitting & Lazy Loading]]
+  - 확장 방향: 컴포넌트 업데이트 시점(리렌더링)의 최적화뿐만 아니라, 컴포넌트 최초 로드 시점의 번들 크기를 줄여 초기 렌더링 성능을 극대화하는 `React.lazy`와 동적 임포트 기법을 함께 학습합니다 [34].
+
+---
+*Last updated: 2026-04-30*
\ No newline at end of file
diff --git a/00_Raw/React 18 Concurrent Features.md b/00_Raw/React 18 Concurrent Features.md
new file mode 100644
index 00000000..a5c653e9
--- /dev/null
+++ b/00_Raw/React 18 Concurrent Features.md	
@@ -0,0 +1,50 @@
+# [[React 18 Concurrent Features]]
+
+## 📌 Brief Summary
+React 18 Concurrent Features(동시성 기능)는 업데이트가 발생하는 시점과 방식을 제어하여 응답성을 희생하지 않으면서도 더 매끄러운 앱을 구축할 수 있게 해주는 기능이다 [1]. 이 렌더링 모델은 React가 렌더링 작업을 일시 중지(pause), 중단(interrupt), 재개(resume)할 수 있도록 허용하여 중요도에 따른 업데이트 우선순위 지정을 가능하게 한다 [2]. 대표적인 훅(Hook)인 `useTransition`과 `useDeferredValue`를 통해 느린 렌더링이 중요한 사용자 상호작용을 차단하지 못하게 방지할 수 있다 [3, 4].
+
+## 📖 Core Content
+*   **동시성 렌더링의 원리와 장점**
+    동시성 렌더링은 무거운 필터 업데이트와 같은 작업은 지연시키면서, 클릭이나 타이핑 등 중요하고 즉각적인 상호작용을 우선적으로 처리할 수 있게 한다 [2]. 최신 버전의 React에서는 개발자가 수동으로 활성화할 필요 없이 기본 동작으로 내장되어 작동한다 [2]. 이 기능은 앱을 실제로 더 빠르게 만든다기보다는, 백그라운드 작업이 진행되는 동안 UI의 응답성을 유지하여 사용자가 느끼는 체감 속도(perceived speed)를 우선시한다 [4].
+*   **`useTransition` (UX 응답성 우선순위 지정)**
+    이 훅은 특정 업데이트를 '비긴급(non-urgent)'으로 표시하는 역할을 한다 [3]. 예를 들어 라이브 검색 결과나 대규모 데이터를 필터링할 때, 렌더링 처리가 느려지더라도 사용자의 타이핑이나 클릭 같은 중요한 상호작용이 차단되지 않는다 [3]. 처리 대기 중인 상태(`isPending`)를 활용하여 렌더링을 차단하지 않고 로딩 스피너나 스켈레톤 상태를 표시할 수 있다 [3].
+*   **`useDeferredValue` (파생 데이터 처리 지연)**
+    `useTransition`이 업데이트가 트리거되는 시점을 제어한다면, `useDeferredValue`는 무거운 값을 '읽는(read)' 시점을 제어한다 [4]. 사용자의 타이핑과 같은 UI 변경은 즉각적으로 반영하되, 파생된 무거운 연산이나 필터링 로직은 약간 지연시켜 적용해야 할 때 이상적인 방법이다 [4]. 주로 검색 상자, Typeahead 입력기, 실시간 폼 등에서 끊김 현상(jank)을 줄이는 데 사용된다 [4].
+*   **모범 사례 및 프레임워크 생태계 지원**
+    동시성 기능은 앱의 모든 곳이 아닌 '인터랙티브 뷰'에 한정하여 사용해야 한다 [4]. 데이터가 로드되는 동안 대체 UI를 표시하기 위해 `Suspense`와 결합하는 것이 권장되며, 구형 상태 관리 라이브러리나 렌더링을 차단하는 안티 패턴과 함께 사용하는 것은 피해야 한다 [4]. 2025년 기준 Next.js(App Router), Remix, Vite 기반 환경 등 대다수의 풀스택 프레임워크가 동시성 렌더링을 기본적으로 연동하고 지원한다 [5].
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+- [[useTransition]]
+  - 연결 이유: React 18 동시성 기능의 핵심 훅으로, 비긴급 업데이트를 지연시키는 구체적인 구현체이다 [3].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 라이브 검색이나 필터링 시 렌더링 병목 현상을 방지하고, 어떻게 비긴급 작업과 긴급 상호작용(타이핑 등)을 분리하는지 이해할 수 있다 [3].
+- [[useDeferredValue]]
+  - 연결 이유: 값의 읽기를 지연시켜 UI 업데이트와 연산 부하를 분리하는 동시성 기능의 또 다른 핵심 훅이다 [4].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 즉각적인 UI 반영이 필요한 부분과 지연시켜도 무방한 무거운 계산(derived data)을 어떻게 나누어 처리하는지 알 수 있다 [4].
+- [[Suspense]]
+  - 연결 이유: 동시성 훅(`useTransition` 등)과 결합하여 백그라운드 렌더링이 진행되거나 데이터가 로드될 때 스켈레톤(fallback UI)을 보여줄 수 있도록 설계된 기능이다 [4].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 지연 중인 렌더링 상태에서 사용자의 경험(UX)을 어떻게 부드럽게 이어갈 수 있는지 이해할 수 있다 [4].
+
+### Deeper Research Questions
+- `useTransition`과 `useDeferredValue`를 사용할 때 React 내부적으로 메인 스레드의 유휴 시간(idle time)을 어떻게 판단하여 작업을 중단 및 재개하는가?
+- 구형 상태 관리 라이브러리나 클래스 기반 컴포넌트를 동시성 기능과 혼용했을 때 구체적으로 어떤 렌더링 차단 충돌이나 예외가 발생하는가?
+- 동시성 렌더링을 적용했을 때 Interaction to Next Paint (INP)나 Total Blocking Time (TBT)과 같은 Core Web Vitals 지표가 수치상으로 어떻게 변화하는가?
+- Next.js의 App Router와 결합된 동시성 렌더링에서, 서버 컴포넌트(Server Components)와 클라이언트 컴포넌트 간의 렌더링 우선순위는 어떻게 관리되는가?
+- `isPending` 속성을 활용해 대체 UI(스켈레톤, 스피너)를 구현할 때 시각적 깜빡임을 최소화하기 위한 이상적인 지연 시간 설계 패턴은 무엇인가?
+
+### Practical Application Contexts
+- **Implementation:** 라이브 검색 결과 렌더링이나 수천 개의 항목이 있는 데이터 목록을 필터링할 때 `useTransition`을 도입하여 입력창의 입력이 지연되지 않도록 구현한다 [3].
+- **System Design:** 검색 상자, Typeahead 입력기, 또는 실시간 폼을 설계할 때 즉각적인 입력 렌더링과 연산이 무거운 데이터 렌더링 간의 영향을 차단하기 위해 `useDeferredValue` 아키텍처를 도입한다 [4].
+- **Operation / Maintenance:** Chrome DevTools의 Performance 탭과 Web Vitals 지표를 통해 긴 작업(Long tasks)이 동시성 렌더링 덕분에 성공적으로 쪼개져 메인 스레드 차단을 줄였는지 지속적으로 모니터링한다 [6, 7].
+- **Learning Path:** React의 기본 렌더링 모델(props 및 state 변경에 따른 리렌더링 트리거)을 명확히 이해한 다음, 동시성 기능을 통해 이러한 렌더링 사이클이 어떻게 일시 중지되고 재개될 수 있는지 학습을 확장한다 [2, 8].
+- **My Project Relevance:** 현재 진행 중인 프로젝트에서 데이터가 많은 차트나 테이블 필터링 시 UI가 끊기는(Jank) 현상이 있다면, 이 동시성 기능 훅을 도입하여 즉각적인 클릭/입력 응답성을 확보할 수 있다 [3, 4].
+
+### Adjacent Topics
+- [[React Performance Optimization]]
+  - 확장 방향: 동시성 렌더링 외에도 불필요한 리렌더링 자체를 막는 `React.memo`, `useCallback`, `useMemo` 활용법과 같은 다양한 React 성능 최적화 기법 전반으로 지식을 확장할 수 있다 [9-11].
+- [[Server Components]]
+  - 확장 방향: Next.js에서 동시성 기능과 함께 성능 향상의 양대 축을 이루는 기능으로, 클라이언트 측 JavaScript를 전송하지 않고 서버에서 렌더링을 완료하여 번들 크기를 줄이는 전략을 학습할 수 있다 [12, 13].
+
+---
+*Last updated: 2026-04-30*
\ No newline at end of file
diff --git a/00_Raw/React Application Scaling.md b/00_Raw/React Application Scaling.md
new file mode 100644
index 00000000..3baf9301
--- /dev/null
+++ b/00_Raw/React Application Scaling.md	
@@ -0,0 +1,29 @@
+# [[React Application Scaling]]
+
+## 📌 Brief Summary
+리액트 애플리케이션 스케일링(React Application Scaling)은 애플리케이션의 크기와 복잡성이 증가함에 따라 발생하는 아키텍처, 성능, 상태 관리, 그리고 협업 문제를 체계적으로 해결하는 과정입니다 [1-3]. 이는 단순히 렌더링 속도를 높이는 것을 넘어, 비즈니스 로직과 UI의 결합을 막고, 예측 가능한 폴더 구조를 도입하며, 불필요한 리렌더링과 번들 크기를 최적화하는 것을 포함합니다 [2-5]. 결과적으로 대규모 팀이 안정적이고 유지보수하기 쉬운 프론트엔드 시스템을 구축할 수 있도록 돕는 핵심 엔지니어링 패러다임입니다 [3, 6].
+
+## 📖 Core Content
+*   **구조적 아키텍처 및 폴더 구성 (Architectural Paradigms):**
+    초기 리액트 앱은 컴포넌트나 훅을 기술적 파일 타입(Type-Based)으로 분리하지만, 앱이 커지면 기능 기반(Feature-Based) 또는 도메인 주도 구조로 전환해야 확장성을 확보할 수 있습니다 [7, 8]. 특히 **FSD(Feature-Sliced Design)**는 애플리케이션을 `app`, `pages`, `widgets`, `features`, `entities`, `shared` 등의 계층화된 슬라이스로 나누고, 하위 계층만 참조하도록 하는 단방향 의존성을 강제하여 코드 결합도를 낮추고 리팩토링을 용이하게 합니다 [9-11].
+*   **상태 관리 아키텍처 (State Management Evolution):**
+    단일한 전역 상태 도구에서 벗어나 데이터 특성에 맞는 도구를 선택해야 합니다 [12]. 테마나 로케일처럼 정적이고 변경이 적은 데이터는 Context API가 적합합니다 [13]. 반면 빈번하게 변경되는 동적 상태는 선택자(Selector) 패턴을 통해 리렌더링을 방지하는 Zustand가 유리하며, 복잡한 비동기 로직과 대규모 팀 협업에는 구조를 강제하는 Redux가 권장됩니다 [14-17]. 서버 상태 처리는 TanStack Query와 같은 API 계층용 도구로 완전히 분리해야 합니다 [16, 18].
+*   **성능 및 번들링 최적화 (Performance & Bundling):**
+    리액트는 상태나 프롭스가 변경될 때마다 하위 트리를 리렌더링합니다 [19]. 이를 방지하기 위해 `React.memo`, `useCallback`, `useMemo`를 전략적으로 사용하여 참조 안정성(Reference Equality)을 유지해야 합니다 [20, 21]. 초기 로딩 속도 개선을 위해서는 `React.lazy`와 라우트 레벨의 코드 스플리팅을 적용하고, Vite의 `manualChunks`를 활용해 React 코어 등 무거운 벤더 라이브러리를 별도 파일로 분리하여 캐싱 효율을 높입니다 [22-25]. 최근에는 React Compiler를 도입해 빌드 타임에 자동 메모이제이션을 수행하는 기법도 활용됩니다 [26-29].
+*   **코드 품질 및 복원력 (Quality & Resilience):**
+    SOLID, DRY, KISS, YAGNI 원칙을 준수하여 컴포넌트를 단일 책임(SRP)을 갖도록 간결하게 유지합니다 [30-32]. 파일명은 운영체제 호환성을 위해 `kebab-case`를, 리액트 컴포넌트는 `PascalCase`를 사용하는 등 네이밍 컨벤션을 통일합니다 [33-36]. 또한 특정 컴포넌트의 렌더링 오류가 전체 앱을 다운시키는 것을 막기 위해 에러 바운더리(Error Boundaries)를 중요 UI 섹션마다 배치하여 Fallback UI를 제공하는 복원력 있는 설계가 필수적입니다 [37-39].
+
+## ⚖️ Trade-offs & Caveats
+*   **과도한 엔지니어링 (Over-Engineering):** FSD나 Redux와 같은 고도화된 아키텍처와 상태 관리 도구를 소규모 프로젝트나 경험이 적은 팀에 도입하면, 학습 곡선이 크게 상승하고 불필요한 보일러플레이트 코드가 양산되어 오히려 개발 속도를 늦출 수 있습니다 [40-43].
+*   **메모이제이션의 오용에 따른 성능 저하:** `React.memo`나 `useMemo`를 무분별하게 사용하면, 이전 props 및 상태를 비교하는 과정에서 발생하는 연산 비용이 렌더링 비용 자체를 초과하여 오히려 애플리케이션의 성능을 악화시킬 수 있습니다 [44, 45].
+*   **React Compiler의 가시성 저하 및 호환성 제약:** 자동화된 최적화 도구인 React Compiler는 블랙박스처럼 작동하므로 성능 병목 발생 시 디버깅이 더 까다로워집니다 [46]. 또한 매 렌더링 시 의도적으로 불안정한 참조를 반환하는 서드파티 라이브러리(예: React Router, TanStack Query 일부 훅)와는 최적화 호환이 깨질 수 있으며, React 규칙을 지키지 않은 레거시 코드베이스에서는 적용이 어렵습니다 [47, 48].
+*   **Context API의 리렌더링 폭풍 (Re-render Storm):** Context API를 빈번하게 변하는 데이터 관리에 사용하면, 데이터 중 일부분만 변경되더라도 해당 컨텍스트를 구독하는 모든 하위 컴포넌트가 불필요하게 리렌더링되는 치명적인 성능 병목 현상을 유발합니다 [49, 50].
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+
+#### [아키텍처 및 폴더 구조 (Architecture & Structure)]
+- [[Feature-Sliced Design (FSD)]]
+  - 연결 이유: 확장 가능한 리액트 앱을 구축하기 위한 핵심 도메인 주도 아키텍처 방법론입니다.
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 기능, 위젯, 엔티티를 분리하고 단방향 의존성 규칙을 강제하여 결
\ No newline at end of file
diff --git a/00_Raw/React Codebase Refactoring.md b/00_Raw/React Codebase Refactoring.md
new file mode 100644
index 00000000..53140358
--- /dev/null
+++ b/00_Raw/React Codebase Refactoring.md	
@@ -0,0 +1,64 @@
+# [[React Codebase Refactoring]]
+
+## 📌 Brief Summary
+React 코드베이스 리팩토링은 기존 앱의 외부 동작을 변경하지 않으면서 유지보수성, 성능, 가독성을 향상시키기 위해 코드를 재설계하고 정리하는 과정입니다. 대규모 React 앱에서 자주 발생하는 논리 결합, 불필요한 재렌더링, 전역 상태의 남용 등의 아키텍처 문제를 해결하는 데 중점을 둡니다. 성공적인 리팩토링을 위해서는 단위 테스트로 안전망을 확보한 후, 컴포넌트 책임 분리, TypeScript 도입, 상태 관리 도구의 현대화를 점진적으로 수행하는 것이 권장됩니다 [1-3].
+
+## 📖 Core Content
+*   **테스트 주도 접근 (Test-Driven Approach):** 리팩토링 도중 기존 기능이 손상되는 것을 방지하기 위해 가장 먼저 단위 테스트(Unit Test)나 UI 테스트 스위트를 작성해야 합니다. 이를 통해 코드의 기존 동작을 보장하며 안전하게 수정할 수 있습니다 [2, 4, 5].
+*   **점진적 마이그레이션 (Incremental Migration):** 전체 코드를 한 번에 재작성(Rewrite)하는 것은 위험도가 높으므로, 점진적인 접근이 필요합니다. 예를 들어 Context API에서 Zustand로 상태 관리를 변경할 때, 하나의 스토어나 기능 단위로 단계별 마이그레이션을 진행해야 비즈니스 개발의 중단 없이 아키텍처를 현대화할 수 있습니다 [1].
+*   **구조 및 컴포넌트 책임 분리 (Separation of Concerns):** 300줄 이상의 방대한 컴포넌트는 단일 책임 원칙(SRP)에 따라 더 작고 초점이 맞춰진 컴포넌트로 분리해야 합니다 [6, 7]. 데이터 페칭이나 폼 처리와 같은 비즈니스 로직은 커스텀 훅(Custom Hooks)으로 추출하여 UI 컴포넌트와 완전히 분리하는 것이 좋습니다 [8, 9].
+*   **상태 관리의 현대화:** 과거의 거대한 단일 전역 상태를 역할에 맞게 분리해야 합니다. API에서 가져오는 '서버 상태'는 TanStack Query(React Query)와 같은 데이터 페칭 라이브러리에 위임하고, '클라이언트 상태'는 Zustand와 같은 가벼운 라이브러리나 지역 상태(Local State)를 활용하여 관리하도록 개선해야 합니다 [10-12].
+*   **도구 및 컨벤션의 적용:** JavaScript 기반 코드는 TypeScript로 마이그레이션하여 타입 안정성을 확보하는 것이 좋습니다 [3, 11]. 또한, ESLint와 같은 도구를 도입해 코드 포맷팅과 아키텍처 규칙(예: 모듈 간 의존성 규칙)을 자동으로 강제해야 하며, 인라인 스타일이나 여러 방식이 혼재된 CSS를 한 가지 방식(예: CSS Modules, Tailwind 등)으로 통일해야 합니다 [13-15].
+*   **과거의 패턴 제거:** 클래스형 컴포넌트가 있다면 함수형 컴포넌트와 훅(Hooks)으로 교체해야 합니다 [11]. 최신 React(예: React 19)나 React Compiler를 사용하는 환경이라면 불필요한 `useEffect`, `useMemo`, `useCallback` 등을 제거하여 코드를 더욱 간결하게 만들 수 있습니다 [11, 16, 17].
+
+## ⚖️ Trade-offs & Caveats
+*   **추상화의 함정과 오버엔지니어링 (KISS vs DRY):** DRY(Don't Repeat Yourself) 원칙을 따르기 위해 성급하게 공통 로직을 추상화하면, 코드가 원래의 반복된 코드보다 더 복잡해지고 이해하기 어려워지는 부작용이 발생할 수 있습니다. 전문가들은 패턴이 3번 이상 반복될 때까지 기다렸다가 추상화(Custom Hook 등)를 진행할 것을 권장합니다 [18].
+*   **TypeScript 채택의 인지적 부하:** 리팩토링 시 TypeScript를 도입하는 것은 장기적 안정성을 보장하지만, 경험이 부족한 개발팀에게는 새로운 복잡성 레이어로 작용하여 초기에 생산성을 늦출 수 있습니다. 따라서 강제 도입보다는 개별 파일부터 점진적으로 전환하는 것이 추천됩니다 [3].
+*   **아키텍처 도입 비용:** Feature-Sliced Design(FSD)과 같이 엄격한 계층 구조를 강제하는 아키텍처로 폴더 구조를 리팩토링하는 것은 큰 학습 곡선과 설정 비용을 수반합니다. 팀 전체의 이해도가 없으면 오히려 시스템이 엉망이 되거나 소규모 프로젝트에서는 과도한 설계(Overkill)가 될 수 있습니다 [19-21].
+*   **완전 재작성(Rewrite)의 위험성:** 프로젝트가 매우 작다면 아예 처음부터 새로 작성하는 것이 빠를 수도 있으나 [4], 일반적인 환경에서는 기존 기능을 그대로 유지하면서 코드를 개선해야 하므로 전면 재작성보다는 안전성을 담보한 점진적 리팩토링이 필수적입니다 [1].
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+
+#### [관계 유형 A (아키텍처/기반 기술)]
+- [[Feature-Sliced Design]]
+  - 연결 이유: 리팩토링 과정에서 기술 단위(Component, Hooks 등)로 흩어진 기존 폴더 구조를 기능(Feature) 중심으로 모듈화하고 재편할 때 기준이 되는 현대적인 프론트엔드 아키텍처론입니다 [22, 23].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 확장성을 위한 단방향 의존성 규칙과 도메인 중심의 코드 캡슐화 설계 방법.
+- [[SOLID Principles]]
+  - 연결 이유: 거대한 React 컴포넌트를 작게 분리하고 인터페이스를 구성할 때, 단일 책임 원칙(SRP)과 같은 클린 코드의 기반 지침을 제공합니다 [6, 24].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 리액트 컴포넌트의 책임을 올바르게 분리하고 유지보수하기 쉬운 추상화를 설계하는 기준.
+
+#### [관계 유형 B (구현/활용 도구)]
+- [[TanStack Query]]
+  - 연결 이유: 기존의 비효율적인 Context API나 거대한 Redux 스토어를 리팩토링할 때, 서버 상태(캐싱, 동기화 등)를 깔끔하게 분리해 주는 핵심 도구입니다 [10, 11].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 서버 데이터 페칭 로직의 분리와 컴포넌트 내 복잡한 상태 관리 감소 방법.
+- [[Zustand]]
+  - 연결 이유: 불필요한 재렌더링을 유발하는 기존의 Context API 기반 상태 관리를 리팩토링할 때 주로 도입되는 경량 클라이언트 상태 관리 라이브러리입니다 [1, 25].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 상태 선택자(Selector)를 통한 렌더링 최적화 구조 및 보일러플레이트 없는 상태 관리 로직 작성법.
+- [[Unit Testing]]
+  - 연결 이유: 리팩토링 시 코드를 변경하더라도 기존의 비즈니스 로직이 파괴되지 않음을 보장하기 위해 리팩토링 작업에 선행되어야 하는 기술입니다 [2, 5].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 기존 코드를 검증 가능한 형태로 쪼개고 안전성을 확보하는 실질적인 엔지니어링 절차.
+
+### Deeper Research Questions
+- 레거시 React 앱에서 Context API를 Zustand로 점진적으로 마이그레이션할 때(Incremental Migration), 상태 충돌을 방지하기 위한 가장 안전한 전략은 무엇인가?
+- 대규모 리팩토링 진행 시, Feature-Sliced Design(FSD) 아키텍처를 도입할 때 기존 컴포넌트 간의 결합(Cross-cutting concerns)을 어떻게 계층적으로 분리할 수 있는가?
+- React Compiler 환경이 도입되었을 때, 리팩토링 시 기존 코드에 남용된 `useMemo`와 `useCallback`을 제거하는 것이 런타임 성능 및 코드 가독성에 어떤 구체적인 이점을 주는가?
+- 비즈니스 로직이 혼재된 거대한 폼(Form) 컴포넌트를 리팩토링할 때 단일 책임 원칙(SRP)과 YAGNI 원칙 간의 균형을 맞추는 기준은 무엇인가?
+- 대규모 TypeScript 마이그레이션을 진행할 때 개발 생산성 저하를 방지하면서 점진적 타입 정의를 적용하는 모범 사례는 무엇인가?
+
+### Practical Application Contexts
+- **Implementation:** 비대해진 React 컴포넌트에서 API 호출과 상태 관리 로직을 분리하여 Custom Hook으로 작성하고, ESLint를 도입하여 코드 컨벤션과 아키텍처 규칙 위반을 린트(Lint) 단계에서 차단합니다.
+- **System Design:** 프로젝트의 파일 디렉토리 구조를 단순한 기능별(File-type based) 분류에서 Feature-Sliced Design과 같은 도메인/비즈니스 중심의 계층형 구조로 재설계합니다.
+- **Operation / Maintenance:** 서비스를 중단하지 않기 위해 한 번에 모든 시스템을 바꾸지 않고, 하나의 스토어나 특정 기능 모듈 단위로 리팩토링을 수행하는 점진적 접근법을 운영합니다.
+- **Learning Path:** React 기초 습득 ➔ Clean Code 및 SOLID 원칙 이해 ➔ 상태 관리의 세분화(서버 데이터 vs UI 상태) ➔ 단위 테스트 작성 ➔ 점진적 리팩토링 적용 순으로 엔지니어링 역량을 확장합니다.
+- **My Project Relevance:** 현재 유지보수하고 있는 복잡한 레거시 React 프로젝트의 성능 및 유지보수성 저하 원인을 분석하고, 컴포넌트 분리와 상태 관리 라이브러리(Zustand, React Query) 교체 작업을 체계적으로 기획할 때 직접 적용할 수 있습니다.
+
+### Adjacent Topics
+- [[Web Performance Optimization]]
+  - 확장 방향: 리팩토링의 궁극적 결과물 중 하나인 초기 로딩 속도 향상, 렌더링 최적화, 그리고 불필요한 번들 사이즈를 줄이는 코드 스플리팅(Code Splitting) 기법 등으로 개념을 확장하여 학습할 수 있습니다.
+- [[Git Workflow & CI/CD]]
+  - 확장 방향: 대규모 리팩토링 시 발생할 수 있는 브랜치 충돌 방지와 코드 리뷰 자동화, 그리고 Pull Request 과정에서 Visual Regression Testing을 연동하는 등 협업 전략으로 확장할 수 있습니다.
+
+---
+*Last updated: 2026-04-30*
\ No newline at end of file
diff --git a/00_Raw/React DevTools Profiler.md b/00_Raw/React DevTools Profiler.md
new file mode 100644
index 00000000..0ed6a720
--- /dev/null
+++ b/00_Raw/React DevTools Profiler.md	
@@ -0,0 +1,52 @@
+# [[React DevTools Profiler]]
+
+## 📌 Brief Summary
+React DevTools Profiler는 React 애플리케이션의 렌더링 성능을 측정하고 최적화 대상을 식별하기 위해 React DevTools에 내장된 프로파일링 및 디버깅 도구이다 [1]. 이 도구는 어떤 컴포넌트가 언제, 얼마나 오래 렌더링되었는지, 그리고 어떤 요인(props, state 변경 등)이 렌더링을 유발했는지 파악하는 데 사용된다 [1, 2]. 주로 로컬 개발 환경에서 성능 병목 현상을 식별하고 불필요한 리렌더링을 찾아내는 데 핵심적으로 활용된다 [3].
+
+## 📖 Core Content
+* **렌더링 추적 및 시각화**: Profiler는 특정 props나 상태(state) 변경 등 컴포넌트의 렌더링이 발생한 정확한 원인을 추적할 수 있게 해준다 [1, 2]. 플레임그래프(Flamegraph)와 순위 뷰(Ranked views)를 제공하여 성능 병목 지점을 시각적으로 쉽게 식별할 수 있도록 돕는다 [2].
+* **최적화 필요성 검증 (측정 기반 최적화)**: `React.memo`와 같은 메모이제이션 기술을 적용하기 전에, 컴포넌트의 리렌더링 비용이 최적화 오버헤드를 감수할 만큼 큰지 측정하는 데 사용된다 [4]. 또한, 메모이제이션된 컴포넌트 내의 prop 변경을 추적하여 자식 컴포넌트가 불필요하게 리렌더링되는지 파악할 수 있다 [5]. "측정하지 않았다면 최적화하지 말라"는 원칙에 따라, 프로파일링은 성능 핫스팟에만 집중하도록 돕는다 [2, 6].
+* **React Compiler 시각화**: React Compiler가 적용된 환경에서는 Profiler 탭에서 자동 최적화된 컴포넌트에 `Memo ✨` 배지가 표시된다 [7, 8]. 입력값이 변경되지 않아 리렌더링을 건너뛴 자식 컴포넌트는 회색으로 표시되며, 마우스를 올리면 자동 메모이제이션 및 리렌더링 생략 여부를 확인하는 툴팁이 나타난다 [8].
+* **블랙박스 환경에서의 디버깅 필수성**: React Compiler 도입 시 기존의 명시적인 `React.memo`, `useMemo`, `useCallback` 호출이 코드에서 사라져 렌더링 제어가 블랙박스처럼 작동하게 된다 [9]. 따라서 예상치 못한 리렌더링 문제가 발생했을 때, 이를 코드 상에서 확인하는 대신 Profiler를 통해 직접 조사해야 하므로 그 중요성이 더욱 커진다 [9].
+
+## ⚖️ Trade-offs & Caveats
+* **해석상의 주의점 (`Memo ✨` 배지의 함정)**: Profiler 탭에서 확인할 수 있는 `Memo ✨` 배지는 다소 오해를 불러일으킬 수 있다 [10]. 이 배지는 React Compiler가 해당 컴포넌트를 처리(Compile)했음을 나타낼 뿐, 최적화가 완벽하게 성공했음을 의미하지는 않는다 [10]. 컴포넌트에 배지가 표시되어 있더라도, 인라인 객체나 함수와 같은 불안정한 참조를 가진 props가 전달된다면 컴파일러가 리렌더링을 막지 못해 여전히 매번 렌더링이 발생할 수 있다 [10].
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+
+#### [관계 유형 A: 아키텍처/기반 기술]
+- [[React Compiler]]
+  - 연결 이유: React Compiler가 빌드 타임에 주입한 자동 메모이제이션 로직의 성공 여부와 렌더링 스킵 결과를 Profiler를 통해 시각적으로 확인할 수 있다 [7-9].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 명시적인 메모이제이션 코드 없이도 렌더링 성능이 최적화되는 원리와, 블랙박스화된 렌더링 메커니즘을 디버깅하는 방법 [9, 11].
+
+#### [관계 유형 B: 구현/활용 도구]
+- [[React.memo]]
+  - 연결 이유: Profiler를 통해 특정 컴포넌트의 렌더링 빈도와 비용을 측정한 뒤, 그 결과에 따라 `React.memo` 적용이 성능 향상에 실질적인 도움이 될지 판단할 수 있다 [4].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 얕은 비교(Shallow comparison)의 원리와 프로파일링 데이터에 기반한 전략적 메모이제이션 방법 [4, 12, 13].
+- [[useCallback & useMemo]]
+  - 연결 이유: Profiler에서 자식 컴포넌트가 참조(Reference) 변경 때문에 계속 리렌더링되는 것을 발견했다면, 이 훅들을 사용하여 참조 안정성(Reference stability)을 확보할 수 있다 [5, 14].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 함수나 객체의 참조 동일성이 컴포넌트 렌더링 트리에 미치는 직접적인 영향 [14].
+
+### Deeper Research Questions
+- React DevTools Profiler의 플레임그래프(Flamegraph)와 순위 뷰(Ranked view)를 어떻게 분석해야 성능 병목 현상을 가장 빠르고 정확하게 찾아낼 수 있는가?
+- 명시적인 메모이제이션 훅이 제거되는 React Compiler 환경에서, Profiler를 통한 성능 디버깅 워크플로우는 기존과 구체적으로 어떻게 달라지는가?
+- Profiler를 통해 식별된 불필요한 렌더링 문제를 해결할 때, 어떤 상황에서 구조 재설계(예: Context API 대신 Zustand 도입)가 단순한 메모이제이션 적용보다 더 나은 선택이 되는가?
+- 로컬 환경의 Profiler에서 관찰되는 렌더링 시간과 프로덕션 환경의 실제 사용자 체감 성능(Core Web Vitals의 INP 등) 간의 차이를 어떻게 보정하여 분석할 수 있는가?
+
+### Practical Application Contexts
+- **Implementation:** 렌더링 최적화 코드를 무작정 추가하기 전에, Profiler를 실행하여 실제 렌더링 빈도와 실행 시간을 측정함으로써 렌더링이 무거운(expensive) 컴포넌트를 정확히 식별한다 [4, 6].
+- **System Design:** Context API의 값이 변경될 때 얼마나 많은 자식 컴포넌트가 불필요하게 렌더링되는지 확인하고, 글로벌 상태 관리 라이브러리(Zustand 등) 도입이나 상태 도메인 분리의 기술적 타당성을 검증한다 [15-18].
+- **Operation / Maintenance:** 레거시 코드베이스를 유지보수하거나 새로운 기능을 릴리스한 직후, 플레임그래프를 정기적으로 리뷰하여 의도치 않은 성능 회귀(Regression)를 식별하고 관리한다 [19].
+- **Learning Path:** React 입문자나 팀원들이 Props, State, Context가 변경될 때 컴포넌트가 어떻게 반응하고 재렌더링되는지를 시각적으로 보여줌으로써 렌더링 모델을 깊게 이해시킨다 [1, 20].
+- **My Project Relevance:** 화면 내 대용량 리스트나 복잡한 필터를 조작할 때 발생하는 지연 현상(Jank)의 원인이 렌더링 시간 자체인지, 아니면 불필요한 연쇄 리렌더링 때문인지 진단하고 해결책을 마련한다 [21, 22].
+
+### Adjacent Topics
+- [[why-did-you-render]]
+  - 확장 방향: Profiler와 결합하여 사용할 수 있는 라이브러리로, 실제 데이터 변경이 없음에도 불구하고 컴포넌트가 리렌더링된 '정확한 이유'를 콘솔에 경고 형태로 남겨주어 디버깅을 더욱 쉽게 만들어주는 도구에 대해 조사한다 [3, 23].
+- [[Chrome DevTools Performance Tab]]
+  - 확장 방향: Profiler가 알려주는 React 내부의 렌더링 속도 이외에, 프레임 드롭이나 메인 스레드를 막는 무거운 자바스크립트 실행, 레이아웃 이동 등 브라우저 레벨의 전체적인 성능 분석으로 시야를 확장한다 [3, 23].
+
+---
+*Last updated: 2026-04-30*
\ No newline at end of file
diff --git a/00_Raw/React Frontend Architecture.md b/00_Raw/React Frontend Architecture.md
new file mode 100644
index 00000000..76200a99
--- /dev/null
+++ b/00_Raw/React Frontend Architecture.md	
@@ -0,0 +1,64 @@
+# [[React Frontend Architecture]]
+
+## 📌 Brief Summary
+React 프론트엔드 아키텍처는 확장 가능하고 유지보수하기 쉬운 애플리케이션을 구축하기 위한 구조적 뼈대이자 조직화 방법론이다 [1, 2]. 기존의 기술적 파일 단위 분리에서 벗어나, 비즈니스 도메인과 기능(Feature-Based)을 중심으로 코드를 구성하여 결합도를 낮추고 응집도를 높이는 것을 목표로 한다 [3-5]. 이를 통해 무분별한 비즈니스 로직의 UI 누수를 막고 명확한 상태 소유권을 확립하며, 팀과 코드베이스가 성장함에 따라 시스템이 예측 가능하게 확장할 수 있도록 돕는다 [6-8].
+
+## 📖 Core Content
+
+*   **폴더 구조와 모듈화의 진화**: 과거에는 컴포넌트, 훅, 스타일 등을 파일 유형별로 그룹화했으나, 프로젝트가 커질수록 논리적 기능이 파편화되어 탐색과 확장이 어려웠다 [4, 9]. 2025년 기준 프론트엔드 업계 표준은 비즈니스 기능을 중심으로 코드를 묶는 '기능 기반(Feature-Based)' 구조로 전환되었다 [5, 10]. 특정 기능과 관련된 컴포넌트, 훅, API 로직 등을 단일 디렉토리에 캡슐화함으로써 모듈의 독립성과 확장성을 크게 향상시킨다 [11, 12].
+*   **기능 분할 설계 (Feature-Sliced Design, FSD)**: FSD는 도메인 주도 설계(DDD)와 모듈형 아키텍처를 결합한 프론트엔드 전용 방법론이다 [3, 13]. 애플리케이션을 `app`, `pages`, `widgets`, `features`, `entities`, `shared`의 계층(Layer)으로 나누고, 상위 계층은 하위 계층에만 의존할 수 있다는 엄격한 '단방향 의존성' 규칙을 강제한다 [11, 14, 15]. 각 슬라이스는 `index.ts` 형태의 'Public API'를 통해서만 외부에 기능과 컴포넌트를 노출하여 내부 구현을 안전하게 캡슐화한다 [16-18].
+*   **상태 관리 아키텍처의 세분화**: 단일 모놀리식 스토어(예: 대규모 Redux)에 의존하던 방식에서 벗어나, 데이터의 성격에 따라 최적의 도구를 선택하도록 상태 관리가 파편화되었다 [19, 20]. 서버에서 가져오는 데이터인 '서버 상태'는 TanStack Query(React Query)를 이용해 캐싱 및 네트워크 로직을 격리하고, 테마나 설정 등 정적인 '전역 상태'는 Context API로, 장바구니나 실시간 데이터처럼 빈번하게 변하는 상태는 Zustand나 Jotai 등 선택적 렌더링을 지원하는 도구로 관리한다 [20-24].
+*   **소프트웨어 공학 원칙의 적용 (SOLID & Clean Code)**: React의 함수형 컴포넌트 개발에도 단일 책임 원칙(SRP)을 적용하여, 컴포넌트가 커지면 상태 관리, 데이터 페칭, 렌더링 등 각기 다른 책임을 가진 작은 컴포넌트로 분리해야 한다 [25, 26]. 중복을 피하는 DRY 원칙을 통해 공통 로직을 커스텀 훅으로 추출하면서도, 코드를 단순하게 유지하는 KISS 원칙과 미래를 위한 과도한 최적화를 피하는 YAGNI 원칙 간의 균형을 맞추는 것이 핵심이다 [27, 28].
+*   **명명 규칙과 거버넌스 도구**: 폴더와 파일 시스템은 OS 환경에 따른 오류를 방지하기 위해 `kebab-case`를, React 컴포넌트는 `PascalCase`를, 변수와 함수는 `camelCase`를 사용하는 것이 보편적인 컨벤션이다 [29-33]. 이러한 규칙과 아키텍처 의존성 경계는 ESLint나 Prettier, Husky와 같은 도구를 활용해 빌드 타임 및 커밋 단계에서 자동으로 강제(Linting)된다 [30, 34].
+
+## ⚖️ Trade-offs & Caveats
+
+*   **FSD 및 기능 기반 모듈화의 복잡성 오버헤드**: Feature-Sliced Design은 구조적 안정성을 제공하지만 "무엇이 하나의 기능(Feature)인가?"를 정의하는 경계를 설정하기 매우 까다롭다는 근본적 어려움이 있다 [35]. 인증(Auth)과 같은 교차 관심사(Cross-cutting concern)는 여러 기능에 걸쳐 있어 적절한 계층을 찾기 모호하며 [35, 36], 엄격한 분할 규칙을 소규모 프로젝트에 도입하면 오히려 불필요한 폴더 구조와 오버엔지니어링으로 인한 개발 속도 저하를 초래할 수 있다 [12, 37]. 또한, 규칙을 제대로 숙지하지 않으면 모든 코드를 'Shared' 계층에 쏟아부어 최악의 파급 효과를 낳는 스파게티 코드가 될 위험이 존재한다 [38, 39].
+*   **추상화(DRY)와 단순함(KISS)의 상충**: DRY 원칙에 집착하여 코드 중복을 무조건 피하려고 하면, 수많은 예외 처리와 분기를 포함하는 거대하고 복잡한 커스텀 훅이나 컴포넌트가 탄생하게 된다 [27]. 이러한 과도한 추상화는 단순한 코드 반복보다 가독성과 유지보수성을 떨어뜨려 KISS 원칙을 위반하는 반대 급부를 낳으므로, 명확한 패턴이 3번 이상 반복될 때까지는 추상화를 미루는 것이 권장된다 [27, 40, 41].
+*   **상태 관리 도구 선택에 따른 부작용**: React 내장 Context API는 외부 의존성 없이 상태를 주입할 수 있지만, 상태값의 일부만 변경되어도 해당 컨텍스트를 구독하는 모든 하위 컴포넌트가 강제로 리렌더링된다는 치명적인 성능 제약이 있다 [42, 43]. 반대로 Redux는 명확한 구조와 강력한 디버깅 툴을 제공하지만, 보일러플레이트 코드의 폭발적 증가를 동반하여 소규모 팀이나 간단한 애플리케이션에서는 과도한 기술 부채로 작용할 수 있다 [44, 45].
+*   **성능 최적화 기법의 숨은 비용**: `React.memo`, `useMemo`, `useCallback`은 불필요한 리렌더링을 막아주지만 그 자체가 공짜는 아니다 [46]. 이전 Props나 의존성 배열을 메모리에 저장하고 변경 여부를 얕은 비교(Shallow compare)하는 연산 비용이 추가된다 [46]. 만약 렌더링 비용이 매우 싼 컴포넌트에 사용하거나 불안정한 참조값(인라인 함수, 객체)을 지속적으로 전달하여 리렌더링 차단에 실패한다면, 최적화 코드 자체가 오히려 애플리케이션을 더 느리게 만드는 부작용이 발생한다 [46, 47].
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+
+#### [아키텍처 및 디자인 패턴]
+- [[Feature-Sliced Design]]
+  - 연결 이유: 현대 React 애플리케이션의 모듈화 및 계층화를 위해 고안된 가장 대표적이고 구체적인 프론트엔드 아키텍처 방법론이기 때문 [3, 13].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 도메인 기반 분할, 단방향 의존성 규칙 적용 방법, 그리고 Public API를 통한 컴포넌트의 캡슐화 원리 [14, 16, 17].
+- [[SOLID Principles]]
+  - 연결 이유: 확장 가능한 프론트엔드 구조를 짜기 위해 클래스 기반 OOP를 넘어 React의 함수형 컴포넌트에도 적용해야 하는 근본적인 소프트웨어 설계 원칙이기 때문 [17, 48].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 단일 책임 원칙(SRP)을 이용한 비대해진 컴포넌트의 리팩토링 방식 및 개방-폐쇄 원칙(OCP)을 활용한 UI 컴포넌트 합성(Composition) 전략 [25, 49].
+
+#### [상태 관리 및 최적화 전략]
+- [[State Management]]
+  - 연결 이유: 아키텍처 내에서 데이터(서버 데이터, 로컬 상태, 전역 UI 상태)의 성격에 따라 책임과 저장소를 어떻게 나눌지 결정하는 핵심 분야이기 때문 [20, 50].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: Context API의 렌더링 한계를 돌파하기 위한 Zustand/Jotai의 Selector 패턴 작동 원리 및 TanStack Query를 활용한 서버 상태 격리 기법 [21, 43, 51].
+- [[Performance Optimization]]
+  - 연결 이유: 대규모 아키텍처가 실제로 사용자 브라우저에서 효율적으로 동작하기 위해 필수적으로 수반되어야 하는 성능 지표(Web Vitals) 관리 방법이기 때문 [52, 53].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 지연 로딩(Lazy Loading) 및 코드 스플리팅을 통한 초기 번들 사이즈 최적화, 그리고 동시성 렌더링(Concurrent Rendering) 훅의 활용법 [54-56].
+
+### Deeper Research Questions
+- Feature-Sliced Design(FSD)에서 인증(Auth)이나 분석(Analytics) 같은 도메인 간의 교차 관심사(Cross-cutting concerns)가 발생할 때, 결합도를 높이지 않고 주입/공유하는 가장 이상적인 방법은 무엇인가?
+- React Compiler가 프로젝트에 성공적으로 도입되어 수동 메모이제이션 로직(`useMemo`, `useCallback`)이 대거 삭제될 때, 프론트엔드 폴더 구조와 코드 응집도에 어떤 형태의 구조적 변화가 일어날 수 있는가?
+- 서버 상태(Server State) 관리 라이브러리와 클라이언트 글로벌 상태(Client State) 도구를 완벽히 분리한 아키텍처에서, 두 상태가 불가피하게 동기화되거나 상호작용해야 하는 엣지 케이스를 깨끗하게 처리하는 패턴은 무엇인가?
+- 대규모 엔터프라이즈 환경에서 Micro-Frontends 아키텍처와 Feature-Sliced Design은 어떻게 호환되며, 각 독립 서비스 간의 중복 코드(Shared 레이어) 문제를 어떻게 통제할 수 있는가?
+- 복잡도 높은 순수 함수형 React 컴포넌트에 의존성 역전 원칙(DIP)을 적용할 때, 컨텍스트(Context API)나 프롭 드릴링(Prop Drilling)을 피하면서 활용할 수 있는 현대적인 제어 역전(IoC) 구현 패턴은 무엇이 있는가?
+
+### Practical Application Contexts
+
+- **Implementation:** 기술적 파일 유형(컴포넌트, 훅) 중심의 디렉토리 구조에서 벗어나, `src/features/` 내에 특정 비즈니스 로직(예: 장바구니, 유저 프로필)에 연관된 UI, API 통신, 로컬 훅을 캡슐화하여 구현한다 [5, 11, 57]. 
+- **System Design:** 모놀리식 글로벌 스토어 설계 지양. API 캐싱 및 서버 데이터는 TanStack Query를 사용해 비즈니스 로직 경계로 분리하고, 다크 모드 같은 앱 설정은 Context API로, 실시간 UI 상태 변경은 Zustand 등으로 쪼개어 시스템 데이터 흐름을 최적화한다 [20, 21, 24].
+- **Operation / Maintenance:** 런타임 크래시에 대비하기 위해 Error Boundary 컴포넌트를 앱의 최상단뿐 아니라 불안정한 서드파티 위젯이나 개별 라우트 단위에 감싸, 특정 모듈의 에러가 앱 전체의 "화이트 스크린" 장애로 번지는 것을 차단한다 [58-60].
+- **Learning Path:** React 기초 문법 및 렌더링 원리 파악 -> 컴포넌트 재사용과 SRP 원칙(SOLID) 학습 -> 기능 기반 폴더 구조 및 FSD 적용 방식 이해 -> 번들 최적화 및 렌더링 리팩토링 스킬 향상의 흐름으로 역량을 발전시킨다 [6, 17, 25].
+- **My Project Relevance:** 기존 코드베이스의 `components/` 폴더에 수십 개의 컴포넌트가 방치되어 있거나, `useCallback` 등이 과도하게 사용된 경우, 이를 비즈니스 도메인 단위의 폴더로 재배치하고 프로파일러(Profiler)를 통해 실제 병목 지점을 측정한 뒤 최적화를 진행하는 아키텍처 리팩토링에 직결된다 [12, 61, 62].
+
+### Adjacent Topics
+
+- [[Micro-Frontends]]
+  - 확장 방향: 단일 React SPA 아키텍처의 한계를 넘어, 독립적으로 배포 및 관리 가능한 여러 프론트엔드 팀과 서비스를 하나로 조율하는 엔터프라이즈급 인프라 확장 관점으로 연결 [3, 63].
+- [[Observability and Monitoring]]
+  - 확장 방향: 설계한 아키텍처가 실제 프로덕션 환경에서 어떻게 동작하고 어디서 병목을 일으키는지 측정하기 위한 구조적 로깅, 성능 프로파일링(Web Vitals), 그리고 Sentry를 활용한 세션 모니터링 기법으로 확장 [64-66].
+
+--- 
+*Last updated: 2026-04-30*
\ No newline at end of file
diff --git a/00_Raw/React Scalability.md b/00_Raw/React Scalability.md
new file mode 100644
index 00000000..6bd3e18d
--- /dev/null
+++ b/00_Raw/React Scalability.md	
@@ -0,0 +1,67 @@
+# [[React Scalability]]
+
+## 📌 Brief Summary
+React Scalability(React 확장성)는 기능, 팀 규모, 비즈니스 로직의 복잡성이 증가함에 따라 애플리케이션의 성능, 유지보수성, 예측 가능한 성장을 유지하는 능력을 의미합니다. 단순히 컴포넌트를 렌더링하는 것을 넘어, 결합도를 낮추고 응집도를 높이는 아키텍처 설계, 상태 관리의 최적화, 그리고 코드 스플리팅과 렌더링 성능 최적화를 포괄합니다. 확장 가능한 React 시스템은 명확한 폴더 구조(예: Feature-Sliced Design)와 엄격한 관심사 분리를 통해 코드베이스가 자체적인 무게로 인해 붕괴되는 것을 방지합니다. [1-4]
+
+## 📖 Core Content
+- **아키텍처 및 폴더 구조의 진화:** React는 기본적으로 아키텍처를 강제하지 않기 때문에, 프로젝트가 커지면 비즈니스 로직이 UI에 스며들고 의존성이 엉키는 아키텍처 붕괴가 발생하기 쉽습니다 [2]. 과거의 파일 유형별 폴더 구조(components, hooks, styles 등)는 규모가 커질수록 유지보수를 어렵게 만듭니다 [5, 6]. 확장 가능한 애플리케이션을 위해서는 도메인/기능 중심으로 코드를 구성하는 Feature-Based 구조 또는 **Feature-Sliced Design(FSD)**과 같은 방법론이 필수적입니다. FSD는 앱을 layers(app, pages, widgets, features, entities, shared)로 나누고 단방향 의존성 규칙과 퍼블릭 API 캡슐화를 강제하여 모듈의 독립성을 보장합니다 [7-11].
+- **클린 코드와 소프트웨어 엔지니어링 원칙:** 대규모 React 시스템에서는 SOLID, DRY, KISS, YAGNI와 같은 원칙이 적용되어야 합니다. 단일 책임 원칙(SRP)에 따라 거대한 컴포넌트는 작고 집중된 컴포넌트로 분리되어야 하며 [12], DRY 원칙을 통해 공통 로직은 커스텀 훅으로 추출하여 재사용성을 높여야 합니다 [13]. 더불어 파일 및 컴포넌트 명명 규칙(예: 파일은 kebab-case, 컴포넌트는 PascalCase)을 일관되게 유지하고 ESLint를 통해 아키텍처 경계를 강제하는 것이 대규모 팀 협업에 필수적입니다 [14, 15].
+- **규모에 따른 상태 관리 전략:** 애플리케이션이 커지면 단일 전역 상태만으로는 부족하며 상태의 역할에 따라 도구가 분리됩니다 [16]. React의 Context API는 값이 변경될 때마다 하위 컴포넌트 전체를 리렌더링시키므로 업데이트가 잦은 상태 관리에는 적합하지 않습니다 [17, 18]. 중간 규모의 앱에서는 Selector 패턴을 통해 불필요한 리렌더링을 막는 Zustand가 유용하며 [19-21], 500개 이상의 컴포넌트가 있는 대규모 앱이나 비동기 작업이 복잡한 경우 일관된 패턴과 강력한 디버깅을 제공하는 Redux가 산업 표준으로 작용합니다 [22, 23]. 서버 상태 관리는 TanStack Query(React Query) 등으로 클라이언트 상태와 분리하여 처리합니다 [20, 24].
+- **성능 엔지니어링 (Performance Optimization):** 확장 가능한 앱은 런타임 성능과 로딩 속도 최적화가 필수적입니다. `React.lazy`와 동적 임포트(Dynamic Imports)를 활용한 라우트 및 컴포넌트 레벨의 코드 스플리팅은 초기 번들 크기를 획기적으로 줄여줍니다 [25-27]. 또한 Vite의 `manualChunks`를 이용해 자주 변경되지 않는 Vendor 라이브러리를 분리하여 캐싱 효율을 높여야 합니다 [28-30]. 런타임 시에는 대규모 리스트를 위한 Virtualization(가상화) 처리, 안정적인 참조 유지를 위한 `useCallback`과 `useMemo` 사용, 그리고 React 18의 동시성 기능(`useTransition`, `useDeferredValue`)을 활용해 메인 스레드의 응답성을 유지합니다 [31-34].
+
+## ⚖️ Trade-offs & Caveats
+- **아키텍처의 오버헤드:** Feature-Sliced Design이나 도메인 기반 구조를 도입하면 컴포넌트가 '기능'인지 '위젯'인지 구분하기 위한 의미론적 논의가 필요해지는 등 초기 학습 곡선과 오버헤드가 발생합니다 [35, 36]. 소규모 프로젝트에서는 이러한 구조가 오히려 과도한 복잡성(Overkill)을 초래할 수 있습니다 [37].
+- **메모이제이션의 비용:** `React.memo`, `useMemo`, `useCallback`을 남용하면 오히려 성능이 저하될 수 있습니다. React가 이전 props를 저장하고 비교하는 작업에 오버헤드가 발생하며, 컴포넌트 렌더링 비용이 매우 작은 경우 이 비교 작업이 렌더링 자체보다 더 많은 비용을 소모할 수 있습니다 [38, 39]. 
+- **상태 관리 도구의 유연성 vs 보일러플레이트:** Zustand의 극단적인 유연성은 규율 없이 사용될 경우 팀원마다 서로 다른 비동기 처리 패턴을 작성하게 만드는 등 혼란을 야기할 수 있습니다 [19, 40]. 반면 Redux는 초기에 작성해야 하는 보일러플레이트가 매우 많아 개발 속도를 늦추지만, 대규모 팀에서는 오히려 이 구조가 버그를 방지하는 기능으로 작용합니다 [22, 41].
+- **React Compiler와 서드파티 라이브러리 호환성:** React Compiler를 도입하면 수동 메모이제이션의 필요성을 크게 줄일 수 있지만, `useMutation`이나 `useLocation`처럼 렌더링 시마다 의도적으로 새로운 객체를 반환하는 서드파티 라이브러리 훅과 함께 사용할 경우 캐싱 체인이 끊어지고 리렌더링이 발생하는 한계가 있습니다 [42, 43].
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+
+#### [아키텍처/기반 기술]
+- [[Feature-Sliced Design]]
+  - 연결 이유: React의 한계인 구체적인 아키텍처 부재를 해결하기 위해 설계된 대규모 프론트엔드 방법론입니다.
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 레이어(Layer) 간의 단방향 의존성 원칙과 Public API를 활용한 모듈의 캡슐화 및 결합도 최소화 방법.
+- [[SOLID Principles]]
+  - 연결 이유: 확장 가능하고 유지보수가 쉬운 React 코드를 작성하기 위한 핵심 소프트웨어 엔지니어링 원칙입니다.
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 거대한 컴포넌트를 단일 책임 원칙(SRP)에 따라 작은 기능으로 분리하고, 커스텀 훅을 활용하여 로직을 재사용하는 구조적 사고.
+
+#### [구현/활용 도구]
+- [[State Management Libraries (Redux, Zustand, Context API)]]
+  - 연결 이유: 애플리케이션의 크기와 상태 업데이트 빈도에 따라 적절한 도구를 선택하는 것은 확장성에 지대한 영향을 미칩니다.
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 불필요한 리렌더링 방지를 위한 Selector 패턴의 동작 원리와, 대규모 프로젝트에서 강제되는 상태 관리 아키텍처의 중요성.
+- [[Code Splitting & Lazy Loading]]
+  - 연결 이유: 코드가 비대해짐에 따라 발생하는 성능 저하(번들 크기 증가)를 해결하기 위한 핵심 런타임 최적화 기법입니다.
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: `React.lazy`와 Vite의 `manualChunks`를 이용한 번들 크기 축소 및 브라우저 캐싱 전략.
+- [[React Error Boundaries]]
+  - 연결 이유: 대규모 앱에서 하나의 결함 있는 컴포넌트로 인해 전체 애플리케이션이 붕괴되는 것을 막아주는 안전 장치입니다.
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 런타임 렌더링 에러를 격리(Isolate)하고 폴백(Fallback) UI를 제공하여 시스템 복원력을 높이는 방법.
+
+### Deeper Research Questions
+
+- 대규모 팀 환경에서 Feature-Sliced Design을 적용할 때, 'Shared' 레이어가 비대해지고 기능 간 교차 관심사(Cross-cutting concerns)가 얽히는 문제를 어떻게 관리해야 하는가?
+- React Context API에서 발생하는 리렌더링 폭포(Re-render storm) 문제를 해결하기 위해 Zustand의 Selector 패턴은 내부적으로 구독(Subscription) 모델을 어떻게 다르게 처리하는가?
+- React Compiler의 자동 메모이제이션 기능이 도입됨에 따라 기존 레거시 코드베이스의 기술 부채(예: Rules of React 위반 사항)는 컴파일 최적화 과정에서 어떠한 부작용을 일으킬 수 있는가?
+- Vite의 `manualChunks`를 사용하여 거대한 번들을 분리할 때, 벤더 라이브러리(React core, UI Kits 등)의 특성에 따른 최적의 청크 분할 및 브라우저 캐싱 전략은 무엇인가?
+- 대규모 리스트 데이터를 렌더링할 때 가상화(Virtualization)를 적용하지 않으면 브라우저 메모리 할당(Detached DOM nodes 등) 측면에서 어떤 치명적인 문제가 발생하는가?
+
+### Practical Application Contexts
+
+- **Implementation:** 프로젝트 초기 설정 시 기술 파일 단위(components, hooks) 구조를 피하고, 도메인/기능 중심의 폴더 구조를 설계합니다. 파일명은 운영체제 간 충돌 방지를 위해 kebab-case로, 컴포넌트는 PascalCase로 일관되게 명명합니다.
+- **System Design:** 전역 상태(Zustand/Redux), 서버 상태(TanStack Query), 로컬 상태(useState)의 책임을 명확히 분리합니다. 잦은 업데이트가 발생하는 상태는 컴포넌트 트리의 최상단 Context에 두는 것을 피합니다.
+- **Operation / Maintenance:** Sentry나 LogRocket과 같은 프론트엔드 모니터링 도구와 React Error Boundaries를 결합하여, 프로덕션 환경에서 발생하는 컴포넌트 렌더링 에러를 캡처하고 앱의 크래시를 방지합니다.
+- **Learning Path:** 단순한 React 문법 학습을 넘어, 상태 관리 도구별 렌더링 최적화 차이를 분석하고 Chrome DevTools 프로파일러를 사용하여 렌더링 병목을 확인하는 습관을 길러 아키텍트 수준으로 성장합니다.
+- **My Project Relevance:** 현재 유지보수 중인 React 애플리케이션에서 무거운 서드파티 라이브러리로 인해 메인 번들 크기가 비대해진 상황이라면, `React.lazy` 기반의 라우트 레벨 스플리팅과 Vite `manualChunks` 적용을 검토할 수 있습니다.
+
+### Adjacent Topics
+
+- [[Server Components (Next.js)]]
+  - 확장 방향: 클라이언트 측으로 전송되는 JavaScript 번들 자체를 제거하여 하이드레이션(Hydration) 오버헤드를 줄이고 확장성과 성능을 동시에 잡는 최신 렌더링 패러다임.
+- [[Memory Leak Detection in JavaScript]]
+  - 확장 방향: 확장 가능한 애플리케이션에서 장시간 사용 시 성능을 저하시키는 Detached DOM Nodes나 이벤트 리스너 누수 등을 Chrome DevTools Heap Snapshot을 통해 디버깅하는 방법.
+- [[Git Branching Workflows for Small & Large Teams]]
+  - 확장 방향: 규모가 확장되는 프론트엔드 팀이 충돌 없이 코드를 통합하기 위해 사용하는 GitHub Flow, Trunk-Based Development 및 PR(Pull Request) 리뷰 에티켓.
+
+---
+*Last updated: 2026-04-30*
\ No newline at end of file
diff --git a/00_Raw/React.lazy().md b/00_Raw/React.lazy().md
new file mode 100644
index 00000000..afb49c8c
--- /dev/null
+++ b/00_Raw/React.lazy().md
@@ -0,0 +1,65 @@
+# [[React.lazy()]]
+
+## 📌 Brief Summary
+`React.lazy()`는 리액트(React)에서 컴포넌트를 필요한 시점에 동적으로 불러올 수 있게 해주는 내장 함수입니다 [1]. 이 기능을 동적 임포트(Dynamic Imports)와 결합하면 거대한 자바스크립트 번들을 더 작은 청크(Chunk)로 나눌 수 있습니다 [2, 3]. 결과적으로 사용자가 앱에 처음 접근할 때 다운로드해야 하는 초기 자바스크립트 페이로드 크기를 대폭 줄여 앱의 초기 로드 속도와 전반적인 성능을 크게 향상시킵니다 [2-4].
+
+## 📖 Core Content
+*   **코드 스플리팅(Code Splitting)과 번들 사이즈 감소:**
+    초기 로드 시 모든 코드를 한 번에 불러오면 번들 크기가 비대해져 성능 저하가 발생합니다 [5]. `React.lazy()`를 사용하면 거대한 애플리케이션 코드를 잘게 쪼개어, 특정 라우트나 컴포넌트가 렌더링될 때만 해당 코드를 네트워크를 통해 다운로드하도록 구성할 수 있습니다 [1, 6, 7].
+*   **Suspense와의 결합:**
+    `React.lazy()`로 불러오는 컴포넌트는 반드시 `<Suspense>` 컴포넌트로 감싸주어야 합니다 [1, 3]. `<Suspense>`는 모듈이 로드되는 동안 사용자에게 보여줄 대체 UI(예: 로딩 스피너)를 `fallback` 속성을 통해 정의하여 사용자 경험을 매끄럽게 만듭니다 [1, 3, 8].
+*   **적용 대상(Use Cases):**
+    *   **라우트 기반 컴포넌트(Route-based components):** 사용자가 특정 페이지로 이동할 때만 해당 페이지 코드를 로드합니다 [8, 9].
+    *   **사용 빈도가 낮은 뷰:** 관리자 화면이나 설정 패널처럼 드물게 사용되는 화면에 적용합니다 [9].
+    *   **무거운 UI 블록 및 서드파티 통합 기능:** 차트, 지도, 리치 텍스트 에디터, 비디오 플레이어 등 용량이 큰 위젯을 렌더링할 때 유용합니다 [3, 9, 10].
+*   **빌드 도구와의 자동 통합:**
+    Vite나 Webpack과 같은 최신 번들러는 `React.lazy(() => import('./Component'))` 문법을 자동으로 인식하여 해당 컴포넌트를 별도의 파일(청크)로 분리해 컴파일합니다 [2, 3, 8].
+
+## ⚖️ Trade-offs & Caveats
+*   **어보브 더 폴드(Above-the-fold) 요소 적용 금지:** 사용자가 페이지에 진입하자마자 즉시 보아야 하는 필수적인 컴포넌트나 빠르게 렌더링되어야 하는 요소에 `React.lazy()`를 적용하면 안 됩니다 [9]. 이를 지연 로딩할 경우 불필요한 네트워크 지연이 발생하여 오히려 체감 성능과 사용자 경험이 하락합니다 [9].
+*   **레이아웃 시프트 및 사용자 경험 저하:** 비동기 로딩 중 `<Suspense>`의 `fallback`이 화면에 나타나면서, 로딩이 끝난 후 본래 컴포넌트로 전환될 때 레이아웃이 밀리거나 깜빡거리는 현상이 발생할 수 있습니다 [1, 11].
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+
+#### [아키텍처/기반 기술]
+- [[Code Splitting]]
+  - 연결 이유: `React.lazy()`의 존재 목적이자 근본적인 성능 최적화 기법입니다 [6].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 초기 렌더링 시 불필요한 자바스크립트 번들 크기를 줄여 로딩 성능을 최적화하는 애플리케이션 구조 원리.
+- [[Dynamic Imports]]
+  - 연결 이유: `React.lazy()` 함수 내부에서 비동기적으로 모듈을 로드하기 위해 사용하는 표준 자바스크립트 문법(`import()`)입니다 [2, 3, 8].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 브라우저가 특정 코드가 실행되어야 할 시점에 네트워크 요청을 생성하여 모듈을 가져오는 메커니즘.
+
+#### [구현/활용 도구]
+- [[Suspense]]
+  - 연결 이유: `React.lazy()`로 분리된 코드가 백그라운드에서 다운로드되는 동안 앱이 멈추지 않도록 로딩 UI를 처리하기 위해 필수적으로 결합되는 리액트 기능입니다 [1, 3].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 비동기 렌더링 흐름에서 로딩 상태(Loading State)를 컴포넌트 트리 상단에서 선언적으로 처리하는 방법.
+- [[Vite/Rollup]]
+  - 연결 이유: 소스 코드에 작성된 `React.lazy()` 구문을 분석하여 빌드 타임에 물리적으로 개별 자바스크립트 파일(청크)로 분할해 내는 도구들입니다 [2, 8].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 모듈 번들러가 코드 스플리팅을 인식하고 프로덕션 환경의 정적 에셋으로 변환하여 캐싱 효율을 높이는 과정.
+
+### Deeper Research Questions
+- `React.lazy()`를 활용한 클라이언트 사이드 코드 스플리팅과 서버 사이드에서 이루어지는 [[React Server Components]]의 성능 최적화 방식은 어떻게 다르며 서로 어떻게 보완될 수 있는가?
+- `<Suspense>`로 감싸진 지연 로딩 컴포넌트가 로드될 때 발생하는 Cumulative Layout Shift (CLS)를 최소화하기 위한 구체적인 UI 패턴과 전략은 무엇인가?
+- 모바일 환경 등 네트워크 속도가 느린 곳에서 `React.lazy()`로 분리된 청크를 불러올 때, 에러가 발생한 경우(예: 배포 후 이전 해시 청크 삭제됨) 이를 Error Boundary로 어떻게 우아하게 복구할 수 있는가?
+- 사용자가 컴포넌트를 요청하기 전(예: 링크에 마우스를 올리는 시점)에 `React.lazy()`로 분리된 청크를 미리 가져오는 프리패치(Prefetching/Preloading) 전략은 어떻게 구현하는가?
+- Vite의 `manualChunks` 설정과 `React.lazy()`를 동시에 활용하여, 핵심 벤더 라이브러리 캐싱과 페이지별 지연 로딩을 결합하는 최적의 빌드 전략은 무엇인가?
+
+### Practical Application Contexts
+- **Implementation:** React 코드 상단에 모듈을 정적 임포트하는 대신, `const LazyComponent = React.lazy(() => import('./LazyComponent'))`로 선언하고, 렌더 트리에 사용할 때 `<Suspense fallback={<Spinner/>}> <LazyComponent/> </Suspense>` 형태로 감싸 구현합니다 [1, 3].
+- **System Design:** 애플리케이션의 라우팅 레이어 설계 시, 모든 라우트를 초기 번들에 묶지 않고 각 페이지 또는 무거운 차트/에디터와 같은 독립적 도메인을 분리하는 기준으로 설계 기준을 수립합니다 [8, 9].
+- **Operation / Maintenance:** `rollup-plugin-visualizer`나 Webpack Bundle Analyzer 등의 도구를 이용해 빌드 후 500KB가 넘어가는 큰 청크(Large chunks)가 있는지 모니터링하고, 발견 시 `React.lazy()`를 사용해 지연 로딩 가능한 부분으로 잘라냅니다 [7, 12, 13].
+- **Learning Path:** React 컴포넌트 생명주기와 렌더링에 대한 이해 → 번들 크기가 성능에 미치는 영향 파악 → `React.lazy`와 `Suspense`를 통한 클라이언트 로딩 최적화 → 더 나아가 서버 사이드 렌더링(SSR) 및 서버 컴포넌트로 확장하는 경로로 학습을 진행합니다.
+- **My Project Relevance:** 현재 유지보수 중인 프로젝트에 모달, 어드민 설정 패널 등 즉시 보이지 않는 컴포넌트들이 메인 번들에 포함되어 있다면, 이를 `React.lazy()`로 리팩토링하여 Time To Interactive (TTI) 지표를 당장 개선하는 데 적용할 수 있습니다.
+
+### Adjacent Topics
+- [[Core Web Vitals]]
+  - 확장 방향: `React.lazy()`를 적용했을 때 First Contentful Paint (FCP)와 Interaction to Next Paint (INP) 같은 구글의 웹 성능 지표가 어떻게 개선되는지 확인하는 방향으로 연구 확장 [1, 5].
+- [[manualChunks]]
+  - 확장 방향: `React.lazy()`에 의한 스플리팅 외에, React 코어나 서드파티 라이브러리들(vendor)을 별도 분리해 브라우저 캐싱을 고도화하는 빌드 도구 수준의 수동 제어 기법 파악 [8, 14].
+- [[React Server Components (RSC)]]
+  - 확장 방향: 자바스크립트를 클라이언트로 아예 보내지 않고 서버에서 렌더링하여 성능을 극대화하는 최신 Next.js 패러다임과 클라이언트 단의 `React.lazy`를 비교 [9, 15].
+
+---
+*Last updated: 2026-04-30*
\ No newline at end of file
diff --git a/00_Raw/Real User Monitoring (RUM).md b/00_Raw/Real User Monitoring (RUM).md
new file mode 100644
index 00000000..fafa3074
--- /dev/null
+++ b/00_Raw/Real User Monitoring (RUM).md	
@@ -0,0 +1,62 @@
+# [[Real User Monitoring (RUM)]]
+
+## 📌 Brief 시 Summary
+Real User Monitoring (RUM)은 다양한 기기와 네트워크 조건에서 사용자가 경험하는 실제 성능과 상호작용을 추적하는 모니터링 방식입니다 [1]. 합성 테스트(Synthetic testing)가 놓칠 수 있는 실제 성능 문제를 파악하는 데 필수적이며 [1], 프론트엔드의 사용자 액션과 백엔드의 인프라 트레이스를 연결하여 전체 시스템에 대한 가시성을 제공합니다 [2].
+
+## 📖 Core Content
+*   **실제 사용자 경험 추적:** RUM은 개발 환경이나 인위적인 합성 테스트 환경에서는 포착하기 어려운 다양한 기기, 브라우저 환경 및 네트워크 조건에서의 실제 사용자 경험 데이터를 수집합니다 [1]. 이를 통해 특정 기기나 브라우저에서만 발생하는 오류를 효과적으로 식별할 수 있습니다 [3].
+*   **엔드투엔드(End-to-End) 트레이싱:** Datadog RUM 등의 도구를 사용하면 프론트엔드와 백엔드 간의 모니터링 격차를 줄일 수 있습니다. 프론트엔드에서 발생한 에러를 클릭하면, 백엔드 서비스, 데이터베이스 및 서드파티 API에 이르는 전체 요청 과정을 분산 트레이싱(Distributed tracing)을 통해 추적할 수 있어 복잡한 시스템의 디버깅을 돕습니다 [2].
+*   **통합 관측성(Unified Observability):** 최신 모니터링 플랫폼에서 RUM은 프론트엔드의 오류 로그뿐만 아니라 인프라 모니터링, 백엔드 APM(Application Performance Monitoring) 등과 한곳에서 결합되어 활용됩니다 [4].
+*   **비용 및 라이선스 모델:** 1,000명의 유저를 대상으로 할 때 기본적인 RUM 기능은 월 $15~$30 수준으로 시작할 수 있으나, 데이터 수집량에 따라 비용이 청구되는 사용량 기반 가격 정책을 따릅니다 [5].
+
+## ⚖️ Trade-offs & Caveats
+*   **데이터 규모에 따른 과도한 비용 청구:** RUM 플랫폼(예: Datadog)은 데이터 수집(Ingest)과 검색을 위한 인덱싱(Index)을 분리하여 요금을 부과하는 '이중 요금제'를 채택하는 경우가 많습니다. 트래픽이 높은 서비스에서는 비용이 기하급수적으로 증가할 수 있으며, 이로 인해 비용 절감을 위해 로그의 20%만 인덱싱하게 되면 장애 발생 시 80%의 주요 디버깅 데이터를 검색할 수 없는 상황에 놓일 수 있습니다 [5, 6].
+*   **프라이버시 및 보안 문제:** 세션 리플레이(Session replay) 등 사용자의 모든 행동을 기록하는 RUM 도구는 민감한 개인정보를 수집할 위험이 있습니다. 엄격해지는 개인정보 보호 규제를 준수하기 위해 민감 데이터를 자동 마스킹하도록 설정하는 데 많은 시간이 소요될 수 있습니다 [7-9].
+*   **초기 로드 성능 저하 (성능 오버헤드):** 프론트엔드에 삽입되는 RUM 추적 스크립트는 번들 크기를 증가시킵니다. 일부 도구의 경우 로드 시간을 최대 120ms까지 지연시킬 수 있으므로, 1초가 중요한 이커머스 등의 사이트에서는 경량화된 옵션을 신중히 선택해야 합니다 [10].
+*   **도입 및 학습 곡선:** 풀스택 관측 플랫폼과 결합된 RUM 도구는 단순 프론트엔드 로깅만 필요한 작은 팀에게는 지나친 오버엔지니어링(Overkill)이 될 수 있으며, 전체 플랫폼을 이해하는 데 가파른 학습 곡선이 요구됩니다 [6, 11].
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+
+#### [관계 유형 A (아키텍처/기반 기술)]
+- [[Synthetic Testing]]
+  - 연결 이유: RUM과 대비되는 모니터링 개념으로, 가상 환경에서 애플리케이션의 성능을 시뮬레이션하여 측정합니다 [1].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 시뮬레이션 데이터와 실제 사용자 경험(RUM) 데이터가 어떻게 상호보완적으로 작용하여 성능 병목 현상을 찾아내는지 이해할 수 있습니다.
+- [[Distributed Tracing]]
+  - 연결 이유: RUM 도구가 프론트엔드의 사용자 동작을 백엔드의 서비스 요청과 연관 짓기 위해 사용하는 핵심 메커니즘입니다 [2, 4, 12].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 마이크로서비스 아키텍처 환경에서 클라이언트 에러의 근본 원인을 백엔드 데이터베이스나 외부 API까지 어떻게 추적하는지 원리를 파악할 수 있습니다.
+- [[Core Web Vitals]]
+  - 연결 이유: RUM을 통해 주로 측정하고 최적화하려는 대상인 실제 사용자 중심의 로딩 속도, 상호작용, 시각적 안정성 지표입니다 [13, 14].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: RUM 데이터가 웹 성능 최적화의 기준(LCP, FID, CLS, INP)과 어떻게 매핑되어 사용자 경험(UX)을 수치화하는지 이해할 수 있습니다.
+
+#### [관계 유형 B (구현/활용 도구)]
+- [[Datadog RUM]]
+  - 연결 이유: 소스에서 엔드투엔드 프론트엔드-백엔드 모니터링을 연결해 주는 대표적인 RUM 플랫폼으로 소개되었습니다 [2].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 대규모 분산 시스템에서 RUM을 활용하는 구체적인 사례와, 인덱싱 비용 최적화(Trade-off) 전략의 중요성을 학습할 수 있습니다.
+- [[Session Replay]]
+  - 연결 이유: 사용자의 상태 변경, 콘솔 로그, 네트워크 요청 등을 마치 화면 녹화처럼 재현하는 RUM의 고급 디버깅 기능입니다 [7, 12, 15].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 스택 트레이스만으로 찾기 힘든 복잡한 사용자 상호작용 오류의 디버깅 방법론과 이에 따른 프라이버시 설정의 중요성을 알 수 있습니다.
+
+### Deeper Research Questions
+- 가상 환경의 성능을 시뮬레이션하는 합성 테스트(Synthetic Testing)와 비교할 때, RUM만이 독점적으로 식별할 수 있는 실제 기기/네트워크 기반의 성능 이슈 패턴은 무엇인가?
+- Datadog과 같은 RUM 솔루션을 활용할 때, 대규모 트래픽 하에서 가시성 손실 없이 데이터 수집(Ingest)과 인덱싱(Indexing) 비용의 트레이드오프를 극복할 수 있는 로그 필터링 전략은 무엇인가?
+- RUM 에이전트의 삽입이 자바스크립트 번들 크기 및 초기 페이지 로드 속도(최대 120ms 추가)에 미치는 성능 오버헤드를 최소화하는 아키텍처 설계 방법은 무엇인가?
+- 글로벌 프라이버시 규제를 준수하면서 Session Replay를 포함한 RUM 데이터를 수집하기 위해, 민감한 DOM 요소나 사용자 입력을 어떻게 효과적으로 마스킹(Masking)할 수 있는가?
+- 프론트엔드 React 컴포넌트에서 발생한 에러를 RUM 데이터와 결합하고, 백엔드의 OpenTelemetry 분산 트레이스와 연결(Trace ID 공유 등)하여 전체 마이크로서비스 흐름에서 근본 원인을 파악하는 구체적인 파이프라인 구축 방법은 무엇인가?
+
+### Practical Application Contexts
+- **Implementation:** React 애플리케이션의 엔트리 포인트에 Datadog이나 Sentry와 같은 RUM 모니터링 SDK를 통합하고, Core Web Vitals 및 세션별 성능 지표를 자동으로 수집하도록 초기화합니다.
+- **System Design:** 사용자의 브라우저에서 발생한 프론트엔드 로그와 API 요청 헤더에 트레이스 ID를 삽입하여, 백엔드 로깅 시스템과 매칭시키는 '엔드투엔드(End-to-End) 모니터링 아키텍처'를 설계합니다.
+- **Operation / Maintenance:** 월별 모니터링 비용(특히 데이터 인덱싱 비용)을 모니터링하여 불필요한 이벤트는 샘플링하고, 데이터 마스킹 규칙을 지속적으로 관리해 GDPR 등의 개인정보 보호 정책을 위반하지 않도록 유지보수합니다.
+- **Learning Path:** 먼저 React의 기본 에러 처리(Error Boundaries)와 브라우저 DevTools를 사용한 메모리 누수 측정을 익힌 후, 프로덕션 환경의 실시간 사용자 데이터를 수집하는 RUM과 백엔드 분산 트레이싱을 학습하여 풀스택 관측성(Observability) 역량을 기릅니다.
+- **My Project Relevance:** 현재 진행 중인 프론트엔드 프로젝트에서 사용자 이탈률이 높은 특정 화면의 병목 지점을 찾기 위해, RUM을 적용하여 실제 모바일 기기와 3G/LTE 환경에서의 INP(Interaction to Next Paint)와 렌더링 지연을 측정 및 개선할 때 활용합니다.
+
+### Adjacent Topics
+- [[OpenTelemetry]]
+  - 확장 방향: 특정 벤더에 종속되지 않고(No vendor lock-in) 오픈 스탠다드 프로토콜을 이용해 RUM, 메트릭, 로그 데이터를 수집하고 백엔드와 연결하는 아키텍처로 지식을 확장할 수 있습니다 [16, 17].
+- [[Error Boundaries]]
+  - 확장 방향: React 애플리케이션 내에서 UI 렌더링 중 발생하는 런타임 에러를 캡처하여 전체 앱의 크래시를 방지하는 개념으로, 여기서 포착된 에러를 RUM 시스템에 보고하는 방식으로 연계할 수 있습니다 [18-20].
+
+---
+*Last updated: 2026-04-30*
\ No newline at end of file
diff --git a/00_Raw/Redux.md b/00_Raw/Redux.md
new file mode 100644
index 00000000..332910b5
--- /dev/null
+++ b/00_Raw/Redux.md
@@ -0,0 +1,53 @@
+# [[Redux]]
+
+## 📌 Brief Summary
+Redux는 예측 가능한 상태 컨테이너로, 불변성을 유지하는 업데이트, 액션 디스패치(action dispatch), 그리고 리듀서(reducer)를 통해 전역 상태를 관리하는 산업 표준 라이브러리이다 [1]. 주로 복잡한 파생 및 계산된 상태가 존재하거나 500개 이상의 컴포넌트를 다루는 대규모 애플리케이션에서 일관된 개발 패턴을 강제하기 위해 채택된다 [2]. RTK Query와 Redux DevTools 같은 성숙한 생태계를 통해 비동기 상태 관리의 복잡성을 줄이고 강력한 디버깅 기능을 제공한다 [2-4].
+
+## 📖 Core 대Content
+*   **상태 관리 아키텍처와 구조화**: Redux는 불변성을 기반으로 상태를 관리하며, 액션과 리듀서 패턴을 통해 애플리케이션의 복잡한 상태 로직을 제어한다 [1]. 모던 프론트엔드 폴더 구조에서 Redux 슬라이스(Redux slices)와 글로벌 상태 관련 로직은 전담 디렉토리인 `store/`에 배치된다 [5-7]. 10명 이상의 개발자가 협업하는 조직이나 이커머스, 금융 시스템과 같이 미션 크리티컬한 데이터 무결성이 중요한 프로젝트에서 코드 작성의 일관성을 강제하는 뼈대 역할을 한다 [2].
+*   **성능 최적화 및 상태 구독**: 내장된 React Context API는 상태의 일부만 변경되어도 해당 컨텍스트를 구독하는 모든 컴포넌트에 무차별적인 리렌더링을 유발하는 반면, Redux는 구독 로직과 렌더링을 명확히 분리한다 [3, 8-10]. 선택자(Selector)를 사용해 필요한 파생 상태만 컴포넌트에 공급하여 성능과 최적화를 보장한다 [3].
+*   **비동기 데이터 관리 (RTK Query 도입)**: 과거 Redux는 비동기 처리에 막대한 양의 보일러플레이트 코드(Thunk, Saga 등)가 필요했으나, 현재는 RTK Query를 통해 문제를 해결한다 [2, 4]. RTK Query는 데이터 캐싱, 중복 요청 제거, 자동 데이터 재요청 기능 등을 기본으로 제공하여 비동기 작업 코드를 획기적으로 줄여준다 [4]. 
+*   **디버깅과 추적성**: Redux의 가장 큰 차별점은 브라우저의 Redux DevTools를 활용한 '시간 여행 디버깅(Time-Travel Debugging)'이다 [2, 3]. 상태 변화 이력을 과거로 돌려보거나 액션을 재현할 수 있어, 심야에 발생하는 복잡한 운영 환경의 비동기 버그도 몇 분 내에 시각적으로 파악하게 해준다 [3, 11, 12].
+*   **한계점 및 주의사항**: Redux는 도입 시 막대한 보일러플레이트, 정규화된 상태 관리의 난해함, 미들웨어 순서 오류, 그리고 깨지기 쉬운 선택자 메모이제이션 등의 한계를 가진다 [13]. 또한 모든 상태를 하나의 큰 리듀서에 몰아넣는 "God Reducer" 구조나 팀 단위의 액션 결합(Action Coupling)은 대표적인 안티 패턴으로 지적된다 [13, 14]. 최신 트렌드에서는 이와 같은 단일(monolithic) 스토어 구조의 복잡성을 피하기 위해 클라이언트 상태와 서버 상태를 분리하는 등 보다 파편화된 방식으로 진화하고 있다 [15].
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+- [[Context API]]
+  - 연결 이유: Redux와 자주 비교되는 React의 내장 상태 공유 기능으로, 소규모 애플리케이션의 테마나 언어 설정 등을 관리하기 적합하지만, 상태 변경 시 발생하는 대규모 리렌더링 폭풍(Re-render Storm)을 유발하여 대규모 앱에서 Redux가 필요한 당위성을 제공한다 [8, 9, 16].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 상태 구독 아키텍처의 차이가 React 컴포넌트의 리렌더링 성능에 미치는 치명적인 영향성 [8, 10].
+
+- [[Zustand]]
+  - 연결 이유: Redux의 무거운 보일러플레이트와 Context API의 성능 문제 사이에서 적절한 타협점을 제공하는 경량 상태 관리 라이브러리이다 [17-19]. 
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 상태 관리 라이브러리의 과도한 유연성(Zustand)이 팀 단위 협업에서 어떻게 비동기 패턴의 파편화와 혼란을 야기할 수 있는지, 대조적으로 Redux의 엄격한 구조가 갖는 방어적 이점 [1, 11, 18, 20].
+
+- [[RTK Query]]
+  - 연결 이유: Redux Toolkit(RTK) 생태계에 포함된 데이터 패칭 및 캐싱 도구이다 [4].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: Redux가 어떻게 단순한 클라이언트 상태 관리를 넘어 서버 API 응답(캐싱, 무효화, 재요청)이라는 현대적인 요구사항을 보일러플레이트 없이 소화하는지 파악 [4, 21].
+
+- [[Time-Travel Debugging]]
+  - 연결 이유: Redux DevTools가 제공하는 고유의 강력한 기능으로, 언제 어떤 액션이 디스패치되어 상태가 어떻게 변경되었는지 기록하고 되감는 기술이다 [2, 3].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 5년 이상 지속되는 엔터프라이즈 애플리케이션에서 아키텍처의 디버깅 역량이 개발자의 생산성 및 장애 대응에 미치는 영향 [11, 12].
+
+### Deeper Research Questions
+- Redux의 상태 구독 및 선택자(selector) 패턴은 내부적으로 Context API와 어떻게 다르게 설계되어 부분 상태 변경 시 불필요한 리렌더링을 차단하는가?
+- RTK Query를 통한 Redux 비동기 상태 관리는 Zustand 환경에서 사용자가 직접 구현하는 비동기 캐싱 패턴과 비교해 어떠한 아키텍처적 안정성을 담보하는가?
+- "God Reducer" 안티 패턴이 대규모 React 코드베이스 내비게이션 및 성능 최적화에 미치는 치명적인 부작용은 무엇인가?
+- 프론트엔드 상태 관리가 과거의 거대한 단일 스토어 방식에서 '서버 상태'와 '클라이언트 로컬 상태'로 파편화(Fragmentation)되는 최신 트렌드 속에서, Redux의 적정 사용 범위는 어떻게 재조정되었는가?
+- 10명 이상의 시니어 및 주니어 개발자가 혼재된 팀에서 Redux의 보일러플레이트는 개발 속도를 저하시키는 부채인가, 아니면 버그를 사전에 방지하는 구조적 방어막인가?
+
+### Practical Application Contexts
+- **Implementation:** React 프로젝트의 `store/` 또는 `features/` 디렉토리에 도메인별 Redux slice를 배치하여 전역 상태 및 비동기 데이터를 선언하고 액션과 병합하여 관리한다 [5-7].
+- **System Design:** 장기 유지보수가 요구되는 대규모 엔터프라이즈 시스템(이커머스 결제 등 데이터 흐름이 중요한 500개 컴포넌트 이상의 앱)에서 파생 상태 처리와 팀 개발 패턴 강제화 목적으로 채택한다 [2, 12, 13, 22].
+- **Operation / Maintenance:** 프로덕션 환경이나 디버깅 시 Redux DevTools를 연동하여 특정 UI 버그나 비동기 데이터 꼬임 현상을 시각적인 액션 히스토리를 통해 단시간에 해결한다 [11, 12].
+- **Learning Path:** 프론트엔드 교육 시, Context API의 근본 원리와 한계를 먼저 학습하고, Zustand의 생산성을 경험한 뒤, 엔터프라이즈 표준이자 가장 복잡도가 높은 Redux의 패턴과 구조적 이점을 최종적으로 학습하는 단계적 접근이 요구된다 [23].
+- **My Project Relevance:** 글로벌 상태가 다수의 컴포넌트에 복잡하게 얽혀 있거나, 팀원 간 동일한 비동기/상태 관리 구조를 강제하여 파편화를 막아야 하는 애플리케이션을 구축할 때 핵심적인 기술 스택으로 검토될 수 있다 [1, 12].
+
+### Adjacent Topics
+- [[Server State Management (TanStack Query 등)]]
+  - 확장 방향: 클라이언트 전역 상태와 구별되는 "서버 데이터(API 캐싱, 동기화, 로딩/에러 사이클)"만을 전문적으로 처리하는 모던 라이브러리와 Redux의 역할 비교 및 연동 방안 탐색 [24, 25].
+- [[React Rendering Optimization]]
+  - 확장 방향: 상태 관리 라이브러리의 선택과 별개로, React 컴포넌트 생명주기 및 메모이제이션(`useMemo`, `useCallback`, `React.memo`)이 애플리케이션 퍼포먼스에 미치는 원리와 프로파일링 방법 탐색 [26-28].
+
+---
+*Last updated: 2026-04-30*
\ No newline at end of file
diff --git a/00_Raw/Rollup.md b/00_Raw/Rollup.md
new file mode 100644
index 00000000..5a38f732
--- /dev/null
+++ b/00_Raw/Rollup.md
@@ -0,0 +1,57 @@
+# [[Rollup]]
+
+## 📌 Brief Summary
+Rollup은 2025년 기준 최신 프론트엔드 빌드 도구인 Vite의 프로덕션 빌드를 백그라운드에서 담당하는 모듈 번들러입니다 [1]. 개발 단계에서는 네이티브 ES 모듈(ESM)을 사용하는 Vite가 실제 배포 시점에는 Rollup으로 전환하여 애플리케이션 코드를 병합하고 최적화합니다 [1, 2]. 자동 코드 분할(Code Splitting)과 사용하지 않는 코드를 제거하는 트리 쉐이킹(Tree-shaking) 기능을 통해 매우 최적화된 최종 에셋을 생성하는 것이 핵심 역할입니다 [1].
+
+## 📖 Core 대Content
+*   **Vite와의 하이브리드 아키텍처:** Vite는 로컬 개발 시에는 번들링 없이 네이티브 ESM으로 코드를 제공하여 극도로 빠른 시작과 HMR(Hot Module Replacement)을 지원하지만, 프로덕션 배포 시에는 Rollup을 사용하여 최적화된 번들(Bundled build)을 생성하는 하이브리드 방식을 취합니다 [1].
+*   **번들 최적화 및 트리 쉐이킹 (Tree-shaking):** Rollup은 프로덕션 빌드 시 애플리케이션 내에서 사용되지 않는 코드를 자동으로 제거(Tree-shaking)하고 효율적으로 코드를 분할하여 최적화된 에셋을 제공합니다 [1]. 
+*   **청크 수동 제어 (`manualChunks`):** 기본 설정 상태에서 Rollup은 애플리케이션 코드와 `node_modules`의 모든 종속성을 단일 파일(`index.js`)로 묶어 거대한 번들을 생성할 수 있습니다 [3]. 이를 해결하기 위해 대규모 프로젝트에서는 Rollup 옵션 중 `manualChunks`를 세밀하게 설정하여, 자주 변경되지 않는 무거운 벤더 라이브러리(React 코어, Recharts, Lodash, 아이콘 등)를 별도의 청크 파일로 분리하는 것이 권장됩니다 [4-6]. 
+*   **캐시 효율성 개선:** `manualChunks`를 통해 벤더 라이브러리를 분리하면, 해당 라이브러리는 자주 변경되지 않기 때문에 여러 번 배포하더라도 브라우저가 이를 캐시하여 재사용할 수 있으므로 초기 로드 성능이 크게 향상됩니다 [5-7].
+
+## ⚖️ Trade-offs & Caveats
+*   **초기 설정 부족 시 대용량 번들 발생:** 기본 설정으로 둘 경우 애플리케이션의 모든 종속성이 하나의 파일에 Eager Import 되어 결합될 수 있습니다 [3]. 이는 미니파이(Minification) 후에도 500kB를 초과하는 대규모 청크(Large Chunks)를 생성하여, 다운로드 시간을 지연시키고 저사양 기기에서 파싱 및 컴파일에 무리를 줄 수 있습니다 [3, 8, 9].
+*   **캐시 무효화(Cache Invalidation) 문제:** 단일 거대 번들로 빌드할 경우 애플리케이션의 작은 코드 하나만 수정하더라도 전체 번들이 새로 해시(Hash)되어 사용자는 모든 JavaScript 파일을 다시 다운로드해야 하는 비효율성이 발생합니다 [9]. 이를 방지하려면 `manualChunks` 설정과 `React.lazy`를 결합한 라우트 기반 코드 분할 등 추가적인 최적화 작업이 강제됩니다 [3, 6].
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+
+#### [아키텍처/기반 기술]
+- [[Vite]]
+  - 연결 이유: Rollup은 Vite의 아키텍처 내에서 프로덕션 배포 시 최적화된 빌드를 수행하는 내부 엔진으로 작동합니다 [1].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 개발 모드(ESM)와 배포 모드(Rollup)를 다르게 가져가는 Vite의 하이브리드 번들링 아키텍처 전략을 이해할 수 있습니다 [1, 2].
+- [[Tree-shaking]]
+  - 연결 이유: Rollup이 배포용 코드를 최적화할 때 사용하지 않는 코드를 덜어내는 핵심 메커니즘입니다 [1].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: ES 모듈 기반 라이브러리 사용이 왜 최종 번들 사이즈 최적화에 필수적인지 파악할 수 있습니다 [10].
+
+#### [구현/활용 도구]
+- [[manualChunks]]
+  - 연결 이유: Rollup을 사용하여 거대한 메인 번들을 세분화된 벤더 청크(Vendor chunk)로 쪼갤 때 사용되는 핵심 설정입니다 [4-6].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 브라우저 캐싱을 극대화하기 위해 코드를 성격(변경 빈도)에 따라 분리하는 최적화 전략을 배울 수 있습니다 [6, 7].
+- [[Code Splitting]]
+  - 연결 이유: Rollup의 기능과 React의 지연 로딩(`React.lazy`)을 결합하여 구현되는 성능 최적화 기법입니다 [3, 11].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 초기 페이로드(Payload)를 줄이고 Core Web Vitals를 개선하는 런타임 최적화 방법을 학습할 수 있습니다 [9, 12].
+
+### Deeper Research Questions
+- Vite는 왜 개발 환경에서는 Rollup을 사용하지 않고 네이티브 ESM을 사용하며, 프로덕션 빌드에서만 Rollup을 도입하는 아키텍처를 선택했는가?
+- Rollup의 Tree-shaking 메커니즘은 빌드 시 어떤 방식으로 데드 코드(Dead code)를 식별하고 최종 번들에서 제외하는가?
+- `manualChunks`를 사용하여 벤더(Vendor) 파일을 분할할 때 발생하는 모듈 간 중복 포함 문제를 방지하는 설정 방법은 무엇인가?
+- Rollup이 생성한 번들 크기를 시각적으로 분석하기 위해 `rollup-plugin-visualizer`가 제공하는 데이터는 실제 성능 개선에 어떻게 활용되는가?
+- Rollup의 빌드 최적화가 FCP, LCP, INP 등 Core Web Vitals 지표 향상에 미치는 구체적인 인과관계는 무엇인가?
+
+### Practical Application Contexts
+- **Implementation:** `vite.config.js` 내부에 `build.rollupOptions.output.manualChunks`를 구성하여 `react`, `react-dom` 등의 라이브러리를 별도의 파일로 강제 분리합니다 [4, 6].
+- **System Design:** 프론트엔드 프로덕션 시스템 설계 시, 자주 변하지 않는 서드파티 라이브러리와 비즈니스 로직을 분리하여 CDN 캐시 히트율을 높이도록 설계합니다 [5, 6].
+- **Operation / Maintenance:** CI/CD 파이프라인에서 "500 kB 이상의 청크" 경고가 발생할 경우, `rollup-plugin-visualizer`를 통해 번들 상태를 점검하고 분할 설정을 업데이트합니다 [8, 13, 14].
+- **Learning Path:** React 최적화 학습 시, 단순히 `React.lazy()`만 배우는 것을 넘어 번들러(Rollup) 레벨에서의 코드 청킹(Chunking) 원리를 함께 학습합니다 [3, 6].
+- **My Project Relevance:** Vite 기반 React 애플리케이션을 Vercel이나 AWS 서버에 배포하기 전에 빌드 속도 및 초기 다운로드 속도를 개선하기 위한 필수 점검 단계로 활용합니다 [2, 11].
+
+### Adjacent Topics
+- [[ES Modules (ESM)]]
+  - 확장 방향: Rollup의 프로덕션 빌드 이전, Vite가 개발 환경에서 코드 변경 사항을 즉각적으로 브라우저에 반영하는 원리 파악 [1, 15].
+- [[Core Web Vitals]]
+  - 확장 방향: Rollup의 번들 분할 및 경량화 작업이 LCP(Largest Contentful Paint)나 INP(Interaction to Next Paint)와 같은 브라우저 성능 측정 지표를 어떻게 개선하는지 조사 [9, 14].
+
+---
+*Last updated: 2026-04-30*
\ No newline at end of file
diff --git a/00_Raw/Scalable Frontend Systems.md b/00_Raw/Scalable Frontend Systems.md
new file mode 100644
index 00000000..57f7da94
--- /dev/null
+++ b/00_Raw/Scalable Frontend Systems.md	
@@ -0,0 +1,65 @@
+# [[Scalable Frontend Systems]]
+
+## 📌 Brief Summary
+대규모 프론트엔드 시스템(Scalable Frontend Systems)은 높은 유지보수성, 고성능, 확장성을 보장하기 위해 기존의 단순한 스크립트 실행을 넘어 정교하게 분산된 소프트웨어 아키텍처를 도입한 시스템입니다 [1]. 기능별 또는 도메인 중심의 모듈형 폴더 구조를 사용하며, SOLID와 같은 클린 코드 원칙을 준수하고 애플리케이션 상태와 서버 상태를 분리하여 관리합니다 [2-4]. 더불어 자동화된 빌드 최적화, 예측 가능한 렌더링 최적화, 정교한 에러 처리 및 협업 워크플로우를 결합하여 애플리케이션이 안정적으로 성장할 수 있도록 지원합니다 [1, 5].
+
+## 📖 Core Content
+
+*   **아키텍처 패러다임과 폴더 구조:** 확장성을 달성하기 위해서는 파일을 파일의 유형(components, hooks 등)별로 모아두는 구조에서 기능(Feature)이나 도메인 중심으로 구조를 개편해야 합니다 [2, 6]. 특히 Feature-Sliced Design (FSD)은 코드 계층을 Scope와 책임에 따라 분할(shared, entities, features, widgets, pages, app)하고, 하위 계층이 상위 계층을 참조하지 못하게 하는 단방향 의존성과 캡슐화된 Public API 규칙을 강제하여 결합도(Coupling)를 극적으로 낮춥니다 [7-10].
+*   **소프트웨어 엔지니어링 원칙 적용:** 확장 가능한 React 시스템은 컴포넌트가 하나의 역할만 하도록 분리하는 단일 책임 원칙(SRP)을 비롯하여 개방/폐쇄 원칙(OCP), DRY, KISS, YAGNI 등의 SOLID 및 클린 코드 원칙을 적용합니다 [3, 11]. 이로 인해 코드의 예측 가능성이 향상되고 불필요한 조기 최적화나 복잡성이 제거됩니다 [12].
+*   **상태 관리의 파편화 (State Management):** 하나의 거대한 Redux 스토어에 의존하기보다, 데이터의 성격에 맞는 도구를 선택하는 방식으로 진화했습니다 [13]. 불필요한 전역 렌더링을 방지하기 위해 Context API 대신 선택자(Selector) 패턴을 지원하는 Zustand 등을 전역 상태 관리에 사용하며, API에서 가져오는 서버 상태는 캐싱과 동기화를 위해 TanStack Query(React Query)로 분리합니다 [4, 14].
+*   **성능 엔지니어링 및 렌더링 최적화:** 초기의 거대한 JavaScript 번들 사이즈를 줄이기 위해 `React.lazy`와 Suspense를 활용한 라우트 및 컴포넌트 수준의 코드 스플리팅(Code Splitting)이 필수적입니다 [15-17]. 성능 병목을 일으키는 무의미한 리렌더링을 피하기 위해 `React.memo`, `useCallback`, `useMemo`를 적재적소에 사용하거나, React Compiler와 같은 빌드 타임 도구를 도입해 메모이제이션을 자동화합니다 [18-21]. 데이터가 방대한 목록의 경우 가상화(Virtualization/Windowing)를 도입하여 DOM 부하를 줄입니다 [22].
+*   **복원력(Resilience)과 모니터링:** 전체 애플리케이션의 렌더링 크래시를 방지하기 위해 불안정한 UI 영역(써드파티 위젯 등)을 Error Boundary로 감싸서 격리합니다 [23, 24]. 브라우저 메모리 탭의 Heap Snapshot을 통해 메모리 누수를 디버깅하고, 배포 이후에는 Sentry, LogRocket, Datadog과 같은 클라우드 관측(Observability) 도구를 사용해 프로덕션 환경의 사용자 에러 및 세션을 실시간 모니터링합니다 [25-27].
+*   **팀 협업 및 거버넌스 규칙:** 윈도우/리눅스 환경 차이로 인한 CI 빌드 에러를 막기 위해 파일명에 kebab-case를 강제하거나(컴포넌트 이름은 PascalCase 적용), ESLint 및 Git Hooks를 통해 아키텍처 규칙 및 코드 포맷을 자동 검증합니다 [28-30]. Git-flow, GitHub Flow 등 소규모/대규모 팀 규모에 맞는 명확한 브랜치 전략과 티켓 ID 기반 추적 관리를 함께 사용합니다 [31, 32].
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+
+- [[Feature-Sliced Design (FSD)]]
+  - 연결 이유: 확장 가능한 프론트엔드 아키텍처에서 빈번하게 발생하는 '비즈니스 로직 얽힘' 문제를 해결하기 위해 도입된 핵심적인 컴포넌트/디렉토리 분할 방법론입니다 [33, 34].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 단방향 의존성 흐름, 계층별(Layered) 분할, 캡슐화를 통한 Public API 인터페이스 설계 원리 [7, 9].
+
+- [[State Management Fragmentation (상태 관리 파편화)]]
+  - 연결 이유: 대규모 애플리케이션에서 단일 스토어나 Context API만으로는 리렌더링 성능 최적화가 불가능해짐에 따라, 전역 상태(Zustand), 서버 상태(React Query), 로컬 상태로 역할을 분리하여 관리하는 트렌드입니다 [4, 13, 35].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 불필요한 렌더링 방지 원리(Zustand의 선택자 패턴)와 서버/클라이언트 데이터 간의 캐싱 및 동기화 전략 [4, 14].
+
+- [[React Compiler]]
+  - 연결 이유: 개발자가 수동으로 수행하던 `useMemo`, `useCallback`, `React.memo` 등의 메모이제이션을 빌드 타임에 자동으로 처리해 주어, 깔끔한 코드를 유지하면서 성능 확장을 가능케 하는 최신 도구입니다 [19, 36].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: React의 렌더링 최적화 한계 및 Rules of React 준수 중요성, 써드파티 라이브러리와의 호환성 문제 [37, 38].
+
+- [[Error Boundaries]]
+  - 연결 이유: 시스템의 크기가 커질 때 단일 컴포넌트의 오류가 전체 앱의 '화이트 스크린' 크래시로 이어지지 않게 UI의 일부분만 대체(Fallback)하여 시스템 복원력(Resilience)을 보장하는 장치입니다 [23, 24, 39].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 클래스형 컴포넌트 생명주기를 활용한 런타임 에러 포착 원리 및 대규모 UI 보호 전략 [40, 41].
+
+- [[Code Splitting & Lazy Loading (코드 분할과 지연 로딩)]]
+  - 연결 이유: 프론트엔드 코드가 비대해지면서 초기 로딩 속도(TTI, LCP)를 최적화하기 위해 필수적으로 요구되는 기술로, Vite나 React.lazy를 통해 필요한 시점에만 모듈을 다운로드하게 합니다 [15, 17, 42].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 모듈 번들러의 청크(Chunk) 분리 원리 및 브라우저 성능 최적화(Core Web Vitals)와 번들 사이즈의 상관관계 [43, 44].
+
+### Deeper Research Questions
+
+- Feature-Sliced Design (FSD) 아키텍처를 도입할 때, 여러 기능(Feature)이 공유해야 하는 교차 관심사(Cross-cutting concerns)나 하위 기능 결합 문제를 어떻게 계층 분리와 캡슐화를 훼손하지 않고 해결할 수 있는가? [45, 46]
+- React Context API가 야기하는 불필요한 렌더 트리 리렌더링 문제를 Zustand나 Redux 같은 상태 관리 라이브러리의 선택자(Selector) 패턴 및 외부 스토어 구독 방식과 비교했을 때, 성능과 확장성 측면에서 구체적인 차이는 무엇인가? [14, 35, 47]
+- Vite 빌드 환경에서 번들 크기 경고("Large Chunks")를 해결하기 위해 `manualChunks`와 `React.lazy`를 결합하여 코드 스플리팅을 구현할 때, 초기 렌더링 성능 개선과 브라우저 캐싱 효율은 각각 어떻게 작용하는가? [42, 48, 49]
+- Next.js의 React Server Components (RSC)를 채택함으로써 서버에서 미리 렌더링하고 클라이언트 측 JavaScript 페이로드를 줄이는 접근법이, 거대한 프론트엔드 앱의 확장성에 어떤 아키텍처적 패러다임 전환을 가져오는가? [50, 51]
+- React Compiler의 자동 메모이제이션 로직이 서드파티 훅(예: 불안정한 참조를 반환하는 훅)과 레거시 코드베이스의 기술 부채 환경에서 어떤 최적화 실패를 발생시키며, 이를 방지하기 위한 리팩토링 전략은 무엇인가? [38, 52]
+
+### Practical Application Contexts
+
+- **Implementation:** 거대한 React 프로젝트를 리팩토링할 때 파일을 파일 속성 단위가 아닌 FSD와 같은 기능(Feature) 및 도메인 구조로 마이그레이션합니다. 상태가 자주 변경되는 기능에는 Zustand 스토어를 적용하고, 서버 API 요청에는 TanStack Query를 도입하여 로컬 상태와 서버 상태를 완벽히 분리 구현합니다 [2, 10, 53].
+- **System Design:** 컴포넌트 간의 순환 참조나 강한 결합(Coupling)을 막기 위해 캡슐화된 `index.ts` 형태의 Public API 설계 패턴을 적용합니다. 렌더링 부하를 막기 위해 데이터 리스트에는 가상화(Virtualization) 설계를 도입합니다 [11, 22].
+- **Operation / Maintenance:** 프로덕션 배포 후 어플리케이션 크래시를 방지하기 위해 Error Boundary를 위젯 및 중요 UI 섹션마다 감싸며, LogRocket 또는 Sentry를 도입해 에러 추적 및 메모리 릭(Memory Leaks) 상황을 실시간으로 디버깅하고 유지보수합니다 [23, 26, 27].
+- **Learning Path:** 소규모 장난감 프로젝트로 React의 기초를 다진 후, Context API의 한계를 파악하고 Zustand 등 상태 관리를 배웁니다. 이후 단위 테스트 작성, Typescript 전환, 그리고 클린 코드 원칙(SOLID, DRY) 기반의 아키텍처링(Feature-Sliced Design) 최적화로 나아가는 단계적 학습을 거칩니다 [54-57].
+- **My Project Relevance:** 소스에 관련 정보가 부족합니다.
+
+### Adjacent Topics
+
+- [[Frontend Cloud Logging Tools (프론트엔드 클라우드 로깅 도구)]]
+  - 확장 방향: 확장 가능한 시스템이 프로덕션 단계에 들어갔을 때, Sentry나 Datadog, SigNoz 같은 모니터링 툴을 활용해 사용자 세션과 에러 로그를 연동하여 가시성(Observability)을 확보하는 방향으로 확장할 수 있습니다 [58-60].
+- [[Storybook Visual Regression Testing (Storybook 시각적 회귀 테스트)]]
+  - 확장 방향: 대규모 팀에서 UI 컴포넌트를 변경할 때, 기존 화면(baseline)의 레이아웃이나 픽셀이 의도치 않게 깨지는 것을 방지하기 위한 자동화된 시각적 회귀 검증(Happo, Chromatic) 및 CI 파이프라인 연동 방향으로 확장할 수 있습니다 [61-63].
+- [[Git Branching Strategies & Workflows (Git 브랜치 전략 및 워크플로우)]]
+  - 확장 방향: 어플리케이션 확장뿐만 아니라 참여하는 개발자 수가 많아질 때, Trunk-based 개발이나 GitHub Flow 등을 도입하여 충돌을 줄이고 티켓 기반 추적성을 확보하는 형상관리 방향으로 확장할 수 있습니다 [31, 64].
+
+---
+*Last updated: 2026-04-30*
\ No newline at end of file
diff --git a/00_Raw/Server State.md b/00_Raw/Server State.md
new file mode 100644
index 00000000..f224dedf
--- /dev/null
+++ b/00_Raw/Server State.md	
@@ -0,0 +1,57 @@
+# [[Server State]]
+
+## 📌 Brief Summary
+Server State(서버 상태)는 API를 통해 서버로부터 가져온 데이터 상태로, 클라이언트 측의 일반적인 애플리케이션 상태(Application State)와 근본적으로 다른 특성을 지닙니다 [1]. 이러한 상태는 비동기적으로 동작하며, 데이터의 최신화(신선도 유지), 동기화, 캐싱, 로딩 및 에러 주기에 대한 처리를 필수로 요구합니다 [1]. 최근의 프론트엔드 아키텍처에서는 이 서버 상태를 전역 클라이언트 상태와 명확히 분리하여, 특화된 전용 도구를 사용해 관리하는 것이 표준으로 자리 잡았습니다 [1, 2].
+
+## 📖 Core Content
+* **상태 분리 아키텍처:** 과거 단일 스토어(예: Redux)에서 모든 상태를 관리하던 패러다임에서 벗어나, 현대의 React 시스템에서는 '서버 상태(Server State)'와 '애플리케이션 상태(Application State)'를 구분하는 것이 가장 중요한 상태 관리의 변화로 꼽힙니다 [1, 3].
+* **Server State의 주요 요구사항:** 데이터가 외부(API)에 존재하므로, 이를 로컬에서 효율적으로 다루기 위해서는 중복 네트워크 요청을 줄이는 캐싱, 서버와의 데이터 동기화, 로딩 중이나 에러 발생 시의 UI 처리 사이클 관리가 필수적입니다 [1, 4].
+* **주요 관리 도구:** TanStack Query(React Query)와 RTK Query가 서버 상태 관리를 위한 사실상의 표준(de facto standard) 라이브러리로 활용됩니다 [1, 5]. 이러한 도구들은 무한 스크롤링, 낙관적 업데이트(optimistic updates)와 같은 복잡한 기능을 단순화하고, 강력한 캐싱 레이어를 통해 데이터의 신선도를 보장합니다 [4]. RTK Query의 경우 캐싱, 데이터 중복 제거, 자동 리패칭(refetching) 및 캐시 무효화를 기본적으로 제공합니다 [5].
+* **코드 구성 및 경계 설정:** 서버 상태를 다루는 API 레이어는 프로젝트 내에서 뚜렷한 경계로 구성되어야 합니다. 일반적으로 요청 선언부와 커스텀 훅(Custom Hooks)은 특정 기능(feature) 폴더 내에 함께 배치(colocated)되어, 네트워크 로직이 UI 컴포넌트와 분리되도록 설계해야 유지보수성이 높아집니다 [4].
+
+## ⚖️ Trade-offs & Caveats
+* **보일러플레이트 vs 일관성:** Zustand나 Context API처럼 매우 유연한 상태 관리 도구를 사용해 서버 상태 처리를 직접 구현할 경우, 캐싱이나 중복 제거 등의 기능을 직접 만들어야 하므로 수 주일의 작업이 낭비될 수 있으며, 팀원 간 비동기 로직 처리 방식이 파편화되는 부작용이 발생할 수 있습니다 [5-8]. 반면, RTK Query와 같은 도구를 사용하면 팀 내 일관성이 강제되지만, 초기 환경 설정에 대한 보일러플레이트 폭발 및 학습 곡선이라는 비용을 감수해야 합니다 [5, 9, 10].
+* **복잡성 관리:** 전용 서버 상태 관리 라이브러리는 비동기 코드의 많은 부분을 자동화하지만 복잡성 자체를 완전히 제거하는 것은 아니므로, 정규화된 데이터 등 앱의 규모와 복잡성에 알맞은 도구를 신중하게 선택해야 합니다 [10].
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+
+#### [관계 유형 A: 아키텍처/기반 기술]
+- [[Application State]]
+  - 연결 이유: Server State와 대비되는 클라이언트 측 전역/지역 상태를 의미하며, 이 두 가지를 분리하는 것이 최신 프론트엔드 상태 관리의 핵심입니다 [1, 2].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 데이터를 그 성격(클라이언트 독자 데이터 vs 외부 시스템 종속 데이터)에 따라 왜 분리해서 다루어야 하는지 아키텍처적 근거를 이해할 수 있습니다.
+
+#### [관계 유형 B: 구현/활용 도구]
+- [[TanStack Query]]
+  - 연결 이유: Server State 관리에 특화된 사실상의 표준(de facto standard) 라이브러리입니다 [1, 2].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 서버 상태 캐싱, 동기화, 로딩/에러 사이클 처리, 낙관적 업데이트 등이 실제 코드에서 어떻게 최적화되어 구현되는지 이해할 수 있습니다 [4].
+- [[RTK Query]]
+  - 연결 이유: Redux 생태계에서 비동기 서버 상태의 캐싱, 중복 제거, 캐시 무효화 등을 즉시 제공하여 보일러플레이트를 대폭 줄여주는 도구입니다 [5].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: API 통신이 매우 많고 복잡한 앱 환경에서 비동기 로직의 일관성을 어떻게 확보하는지 배울 수 있습니다 [5, 9].
+- [[Zustand]]
+  - 연결 이유: Server State 전용 라이브러리를 도입한 후, 남은 클라이언트 전역 상태(Application State) 관리를 위해 함께 결합하여 사용하는 것이 권장되는 경량 라이브러리입니다 [2].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 서버 상태와 클라이언트 상태를 각각 적합한 도구로 어떻게 조화롭게 운영할지 파악할 수 있습니다.
+
+### Deeper Research Questions
+- Server State와 Application State를 한 곳에서 관리할 때 생기는 성능 저하 및 유지보수성 하락의 구체적인 메커니즘은 무엇인가?
+- TanStack Query나 RTK Query는 내부적으로 캐시된 Server State 데이터의 신선도(freshness)를 어떻게 평가하고 만료(invalidate)시키는가?
+- Server State 도구를 사용해 무한 스크롤(Infinite Scrolling)과 낙관적 업데이트(Optimistic Updates)를 구현할 때의 데이터 흐름과 오류 복구(Rollback) 전략은 어떻게 구성되는가?
+- 비동기 데이터 통신 시 빈번하게 발생하는 로딩 및 에러 상태를 React의 Error Boundaries 및 Suspense와 결합하여 어떻게 우아하게(Graceful) 처리할 수 있는가?
+- 유연한 상태 관리 라이브러리(Zustand 등)를 이용해 Server State 캐싱 메커니즘을 직접 구현하려 할 때 겪는 메모리 누수 및 재렌더링 최적화의 한계는 무엇인가?
+
+### Practical Application Contexts
+- **Implementation:** React 컴포넌트 내에서 수동으로 `useEffect`와 `useState`를 조합해 데이터를 패칭하던 방식을 폐기하고, TanStack Query를 도입해 비동기 상태의 캐싱 및 라이프사이클 관리를 자동화합니다 [1, 2, 11, 12].
+- **System Design:** Feature-Sliced Design(FSD)과 같은 디렉토리 아키텍처에서, 도메인(Feature) 폴더 내부에 `api/` 또는 `hooks/` 폴더를 구성하여 해당 도메인에 속하는 Server State 요청 로직을 캡슐화합니다 [4, 13].
+- **Operation / Maintenance:** 브라우저 DevTools와 전용 도구(예: Redux DevTools)를 통해 어느 시점에 액션이 발생하고 네트워크 요청이 중복 제거되었는지 쉽게 추적 및 디버깅할 수 있습니다 [9, 14].
+- **Learning Path:** 클라이언트 전역 상태 관리(Context, Zustand)의 한계와 과도한 렌더링 문제를 학습한 뒤, API 호출 데이터를 관리하기 위한 Server State 패러다임 분리 필요성을 익히고, 최종적으로 TanStack Query 등의 최적화 도구를 학습합니다 [1, 3].
+- **My Project Relevance:** React 코드베이스 리팩토링 작업을 수행할 때, 기존 Redux 보일러플레이트 중 비동기 API 호출 부분을 TanStack Query로 전환(Server State)하고, 남은 클라이언트 전역 상태만 Zustand로 분리하여 코드의 복잡성을 낮추는 구조 개선에 직접 활용 가능합니다 [2].
+
+### Adjacent Topics
+- [[React Error Boundaries]]
+  - 확장 방향: Server State에서 API 요청 실패 등 런타임 에러가 발생했을 때, 애플리케이션 전체가 충돌하여 빈 화면이 나오지 않도록 폴백(Fallback) UI를 표시하고 복구하는 에러 처리 방법론으로 확장 [15, 16].
+- [[Feature-Sliced Design]]
+  - 확장 방향: 캡슐화된 Server State 훅과 API 레이어를 포함하여 프론트엔드 프로젝트의 전체 폴더 구조를 어떻게 도메인/기능 중심으로 확장성 있게 설계할 것인지에 대한 아키텍처 논의로 확장 [4, 17].
+
+---
+*Last updated: 2026-04-30*
\ No newline at end of file
diff --git a/00_Raw/Storybook.md b/00_Raw/Storybook.md
new file mode 100644
index 00000000..6d872c98
--- /dev/null
+++ b/00_Raw/Storybook.md
@@ -0,0 +1,66 @@
+# [[Storybook]]
+
+## 📌 Brief 주Summary
+Storybook은 프론트엔드 개발 시 UI 컴포넌트를 주 애플리케이션과 격리하여 개발하고 문서화할 수 있도록 돕는 도구입니다 [1-3]. 특히 개발된 컴포넌트의 다양한 상태(스토리)를 기반으로 자동화된 시각적 회귀 테스트(Visual Regression Testing) 및 상호작용 테스트(Interaction Testing)를 수행하여 의도치 않은 UI 변경이나 접근성 위반을 방지합니다 [4-6]. Pull Request 과정에 결합되어 안전한 UI 업데이트와 리뷰를 지원하는 필수적인 플랫폼으로 활용됩니다 [1, 7].
+
+## 📖 Core Content
+* **컴포넌트의 격리된 개발 및 문서화**
+  Storybook은 개발자가 메인 애플리케이션의 복잡한 비즈니스 로직이나 컨텍스트에서 벗어나 UI 컴포넌트를 독립적으로 구축할 수 있게 해줍니다 [1]. 이는 모노레포(Monorepo) 환경이나 기능 기반 아키텍처(Feature-Sliced Design 등)에서 각 기능을 독립적으로 개발하고 테스트할 때 매우 유용합니다 [3]. 이미 컴포넌트를 문서화하고 개발하는 용도로 Storybook을 사용 중이라면, 이를 기반으로 시각적 회귀 테스트를 도입하는 것이 가장 빠른 UI 검증 방법입니다 [2].
+
+* **시각적 회귀 테스트 (Visual Regression Testing)**
+  Storybook의 핵심 기능 중 하나는 각 스토리의 스냅샷을 캡처하고 이를 이전에 승인된 '베이스라인(Baseline)'과 비교하여 시각적 변경 사항을 감지하는 것입니다 [8]. 전통적인 스냅샷 테스트가 HTML 마크업 블롭을 비교하여 시각적 변화가 없음에도 오탐(false positive)을 발생시키는 것과 달리, Storybook의 시각적 테스트는 사용자가 실제로 경험하는 '렌더링된 픽셀'을 직접 비교하므로 훨씬 더 풍부하고 유지보수하기 쉽습니다 [9].
+
+* **상호작용 및 접근성 테스트 (Interaction & Accessibility Tests)**
+  Storybook은 컴포넌트의 외형뿐만 아니라 동작(Behavior)까지 검증할 수 있습니다. 상호작용 테스트를 통해 로딩, 에러, 호버, 메뉴 열림 등 다양한 UI 상태를 시뮬레이션할 수 있으며 [5], 이러한 상태 변화에 맞춰 스크린샷을 찍음으로써 행동 테스트와 시각적 검증을 동일한 워크플로우 내에서 처리할 수 있습니다 [5, 6]. 부가적으로 추가적인 테스트 코드 작성 없이도 접근성 회귀 테스트를 함께 수행할 수 있습니다 [4, 10].
+
+* **CI/CD 및 도구 통합 (CI/CD Integrations)**
+  Storybook은 Chromatic이나 Happo 같은 클라우드 서비스 도구들과 원활하게 통합됩니다 [1, 4, 8]. 이러한 도구를 CI 파이프라인에 연동하면, PR(Pull Request)이 생성될 때마다 Chrome, Firefox, Safari 등 다양한 실제 브라우저와 여러 뷰포트 크기에서 자동으로 스크린샷이 캡처되고 베이스라인과 비교됩니다 [1, 4, 11]. 이를 통해 리뷰어는 각 상태를 수동으로 확인할 필요 없이 변경된 부분(Diff)에만 집중하여 변경 사항을 승인(Accept)하거나 수정할 수 있습니다 [2, 12, 13].
+
+## ⚖️ Trade-offs & Caveats
+* **테스트의 불안정성(Flakiness) 및 노이즈 문제:** 시각적 테스트는 애니메이션, 비동기 자산(Asset), 폰트 로딩 등으로 인해 깨지기 쉽거나 불안정해질 수 있습니다 [10, 11]. 또한 이미지 압축 노이즈나 안티앨리어싱(anti-aliasing)과 같은 미세한 차이로 인해 실패할 수도 있습니다 [10, 14]. 이를 완화하기 위해 Happo 등은 애니메이션을 자동으로 무효화하고 비동기 자산을 대기하며, 시각적 변경에 대한 색상 허용 오차(color-delta tolerance)를 설정해야 하는 제약과 설정 오버헤드가 따릅니다 [11, 14].
+* **추가적인 리뷰 병목 및 CI 설정 오버헤드:** 시각적 테스트가 유효하려면 변경된 스크린샷이 의도된 것인지(새로운 베이스라인으로 수락) 아니면 버그인지 판단하는 팀원의 수동 리뷰 과정이 반드시 수반되어야 합니다 [12, 13]. 또한 CI/CD에서 원활하게 동작하도록 프로젝트 토큰 등 인증 환경 변수를 구성하고 파이프라인을 설정하는 초기 작업이 요구됩니다 [7].
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+
+#### [테스트 및 검증 기법 (Testing Methods)]
+- [[Visual Regression Testing]]
+  - 연결 이유: Storybook이 컴포넌트의 변경 사항을 픽셀 단위로 확인하기 위해 사용하는 핵심 테스트 방법론입니다 [4, 8].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: HTML 마크업을 비교하는 Snapshot Test의 한계점과 오탐(False Positive)의 원리, 그리고 픽셀 렌더링 기반 비교의 장점을 명확히 이해할 수 있습니다 [9].
+
+- [[Interaction Testing]]
+  - 연결 이유: 컴포넌트의 단순한 렌더링뿐만 아니라 유저의 행동(이벤트, 상태 등)을 시뮬레이션하여 다양한 UI 상태(로딩, 호버 등)를 검증하는 Storybook의 기능입니다 [5, 6].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 상태 전이에 따라 동적으로 변하는 UI를 어떻게 시각적 테스트와 결합하여 검증할 수 있는지 원리를 파악할 수 있습니다 [5].
+
+#### [통합 및 자동화 도구 (Integration Tools)]
+- [[Chromatic]]
+  - 연결 이유: Storybook 유지보수 팀이 만든 공식 클라우드 서비스로, 크로스 브라우저 시각적 테스트와 CI 통합을 네이티브로 지원합니다 [8, 15].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 클라우드 환경에서 베이스라인(Baseline) 이미지가 어떻게 저장, 비교, 동기화되는지 CI/CD 파이프라인 통합 과정을 이해할 수 있습니다 [7, 13].
+
+- [[Happo]]
+  - 연결 이유: Storybook과 통합되어 다중 브라우저 스크린샷 테스트 및 접근성 회귀 테스트를 병렬로 수행하는 시각적 테스트 도구입니다 [4].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: Flakiness 방지를 위해 애니메이션을 정지하거나 색상 오차 범위(color-delta tolerance)를 설정하여 시각적 노이즈를 줄이는 구체적 최적화 기법을 알 수 있습니다 [11, 14].
+
+### Deeper Research Questions
+- Storybook의 Visual Test와 전통적인 HTML Snapshot Test를 비교했을 때, 실제 대규모 프로젝트에서 발생하는 유지보수 오버헤드와 오탐(false positive) 비율의 차이는 어떠한가?
+- 애니메이션, 비동기 폰트 로딩 등으로 인해 발생하는 Visual Test의 Flakiness를 완전히 제어하기 위해 Chromatic이나 Happo는 어떤 렌더링 파이프라인 제어 기술을 사용하는가?
+- Storybook의 Interaction Test로 복잡한 사용자 여정(User Journey)을 시뮬레이션할 때, 상태별 스크린샷 캡처가 CI 빌드 시간에 미치는 영향과 이를 병렬화하여 최적화하는 전략은 무엇인가?
+- 모노레포(Monorepo) 환경이나 Feature-Sliced Design 아키텍처에서 수백 개의 기능 모듈이 각각 분리된 Storybook을 가질 때, 이를 통합적으로 빌드하고 시각적 회귀를 모니터링하는 베스트 프랙티스는 무엇인가?
+- Storybook을 사용한 시각적 접근성 테스트(Accessibility regression testing)가 실제 DOM 기반의 접근성 감사 도구(aXe 등)와 비교하여 갖는 한계점과 보완점은 무엇인가?
+
+### Practical Application Contexts
+- **Implementation:** React 등 UI 프레임워크 기반 프로젝트에서 복잡한 컴포넌트를 앱의 비즈니스 로직과 분리하여 `Button`, `Modal` 등의 요소를 독립적으로 렌더링하고, 호버 및 에러 상태의 Story를 작성합니다.
+- **System Design:** Feature-Sliced Design처럼 도메인과 피처가 뚜렷하게 나뉜 아키텍처를 도입할 때, 각 피처 폴더별로 Storybook 환경을 세팅하여 격리된 개발 및 테스트 구조를 설계합니다.
+- **Operation / Maintenance:** CI/CD 워크플로우에 Chromatic 또는 Happo를 연동하여, 팀원이 PR을 올릴 때마다 자동으로 시각적 변경 사항(Visual Diff)이 캡처되고 이를 리뷰어가 직접 확인 후 병합(Merge)하는 운영 프로세스를 구축합니다.
+- **Learning Path:** 기본 UI 컴포넌트 격리 개발 -> Story 작성을 통한 문서화 -> Interaction Test 작성 -> 자동화된 Visual Regression Test 구축으로 이어지는 프론트엔드 품질 보증 학습 경로에 사용됩니다.
+- **My Project Relevance:** 현재 유지보수 중인 애플리케이션의 리팩토링이나 새로운 디자인 시스템(UI 라이브러리) 구축 작업 시, 실수로 발생하는 CSS/레이아웃 깨짐을 사전에 방지하기 위한 안전장치로 도입할 수 있습니다.
+
+### Adjacent Topics
+- [[Pull Request Workflow]]
+  - 확장 방향: Storybook 시각적 테스트의 결과를 GitHub, GitLab 등의 리뷰 프로세스와 결합하여, 버그 없는 UI 코드를 배포하기 위한 협업 및 검증 파이프라인 구축 전략으로 확장합니다.
+- [[Feature-Sliced Design]]
+  - 확장 방향: 프론트엔드 코드를 기능(Feature) 단위로 분리할 때, Storybook을 이용해 각 기능의 UI 컴포넌트들을 메인 앱에 의존하지 않고 독립적으로 작동하게 만드는 설계 원칙으로 확장합니다.
+
+---
+*Last updated: 2026-04-30*
\ No newline at end of file
diff --git a/00_Raw/Team Collaboration.md b/00_Raw/Team Collaboration.md
new file mode 100644
index 00000000..cd5d477d
--- /dev/null
+++ b/00_Raw/Team Collaboration.md	
@@ -0,0 +1,70 @@
+# [[Team Collaboration]]
+
+## 📌 Brief Summary
+프론트엔드 개발에서 'Team Collaboration(팀 협업)'이란 다수의 개발자가 동일한 코드베이스에서 효율적으로 함께 작업할 수 있도록 지원하는 실천 방식, 아키텍처, 그리고 워크플로우를 의미한다 [1, 2]. 이는 일관된 폴더 구조, 명명 규칙, 상태 관리 패턴 및 Git 브랜칭 전략을 확립하여 개발자 간의 충돌과 소통 비용을 최소화하는 것을 목표로 한다 [2-4]. 성공적인 협업은 린팅이나 포매팅과 같은 자동화된 도구를 통한 엄격한 코드 거버넌스와 명확한 코드 리뷰 문화를 바탕으로 애플리케이션과 팀이 확장될 때 안정성을 유지하도록 돕는다 [5-7].
+
+## 📖 Core Content
+* **Git 워크플로우 및 브랜칭 전략:** 
+  소규모 팀에서는 오버헤드가 적으면서도 충돌을 방지하는 '기능 브랜치(Feature-branch) 워크플로우'나 '트렁크 기반(Trunk-based) 개발'이 주로 권장된다 [8-10]. 모든 작업은 `main` 브랜치에 직접 커밋하지 않고 짧은 수명의 기능 브랜치에서 진행되며, Pull Request(PR)와 최소 1명 이상의 동료 리뷰(Peer review) 및 테스트 통과 후 병합되어야 한다 [7, 11, 12]. 또한, 브랜치명과 커밋 메시지에 티켓 ID(예: `PROJ-123`)를 포함하면 요구사항과 코드 변경 이력 간의 추적성(Traceability)을 확보할 수 있다 [13, 14].
+* **아키텍처 및 폴더 구조의 표준화:** 
+  표준화된 폴더 구조(예: 기능 기반 구조 또는 Feature-Sliced Design)는 파일의 위치를 예측 가능하게 하여 팀 협업을 크게 향상시킨다 [2]. 구조가 잘 잡혀 있으면 개발자들이 파일을 찾는 시간을 줄이고, 팀원 간 불필요한 소통을 줄일 수 있으며, 신규 개발자의 온보딩이 빨라진다 [2, 15]. 또한 각 기능이 독립된 폴더로 격리되어 있어 서로의 코드를 간섭할 확률이 낮아진다 [16].
+* **명명 규칙(Naming Conventions) 및 자동화된 거버넌스:** 
+  컴포넌트 이름은 파스칼 케이스(PascalCase), 파일 및 폴더 이름은 케밥 케이스(kebab-case)를 사용하는 등 일관된 명명 규칙은 OS 환경 간의 빌드 오류를 방지하고 코드 가독성을 높인다 [17-19]. 더 나아가 수동 검사에 의존하기보다 ESLint, Prettier, Husky를 활용해 커밋 이전에 린팅, 포매팅 및 타입 검사를 자동으로 강제하는 것이 고품질 코드 협업의 기반이다 [6, 20, 21].
+* **상태 관리 도구와 팀 규모의 상관관계:** 
+  팀의 규모가 클수록(10명 이상) 구조를 강제하는 도구가 협업에 유리하다 [5]. Zustand와 같은 도구는 유연하고 빠르지만, 규율이 부족하면 개발자마다 비동기 작업을 다르게 처리하여 코드베이스에 혼란(integration chaos)을 초래할 수 있다 [22, 23]. 반면 Redux는 보일러플레이트가 많지만, 팀 전원이 동일한 방식으로 코드를 작성하게 만드는 '단일 진실 공급원'과 구조를 제공하여 대규모 협업에서 버그를 줄인다 [5, 24, 25].
+
+## ⚖️ Trade-offs & Caveats
+* **유연성 vs. 구조적 강제성 (상태 관리):** Zustand 같이 가벼운 상태 관리 라이브러리는 보일러플레이트가 적어 빠른 기능 개발(스타트업 등)에 적합하지만, 유연성이 너무 커서 팀이 커질 경우 파편화된 패턴을 낳을 수 있다 [22, 23, 26, 27]. 반면 Redux는 일관성을 강제하여 디버깅과 협업을 편하게 해주지만, 초기 설정과 구조화에 드는 시간이 소규모 팀에게는 과도한 오버헤드로 작용할 수 있다 [5, 24, 28].
+* **브랜칭 워크플로우의 무게감:** Git Flow는 예정된 릴리스를 관리하는 거대 프로젝트에는 유용하지만, 소규모 팀에게는 브랜치 관리 비용이 너무 커서 개발 속도를 늦출 수 있다 [8, 29]. 가벼운 Feature-branch 워크플로우나 Trunk-based 개발이 대안이지만, 이는 개발자들이 브랜치를 짧게 유지하고 빈번히 병합(Merge)하는 규율을 스스로 지켜야만 성공할 수 있다 [30, 31].
+* **초기 학습 곡선과 오버헤드:** Feature-Sliced Design(FSD) 같은 엄격한 아키텍처는 코드의 모듈화와 독립적 작업(병렬 작업)을 가능하게 하지만, 초기 도입 시 팀원 전체가 해당 방법론(Layer, Slice 등의 개념)을 이해하고 동의해야 하는 학습 비용이 발생한다 [32, 33]. 규칙에 대한 지식 공유와 문서화가 동반되지 않으면, 개발자들이 임의로 하위 폴더나 `/shared` 등에 코드를 쏟아부어 오히려 아키텍처가 망가지는 결과를 낳을 수 있다 [33].
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+
+#### [관계 유형 A (협업/코드 관리 프로세스)]
+- [[Git Branching Strategies]]
+  - 연결 이유: 다수의 개발자가 동시에 코드를 작성할 때 충돌을 방지하고 통합 과정을 관리하기 위한 핵심 규약이기 때문이다 [3, 34].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: Pull Request, 코드 리뷰, 브랜치 명명 규칙, Trunk-based 워크플로우 등 실제 팀 운영 방식 [7, 35].
+- [[Commit Message Conventions]]
+  - 연결 이유: 변경 사항의 의도와 작업 내역(버그 픽스, 기능 추가 등)을 다른 팀원들에게 명확히 전달하는 소통의 도구이기 때문이다 [36].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 티켓 ID 통합, `feat:`, `fix:`와 같은 접두사를 통한 변경 이력의 자동화 및 스캐닝 [14, 36, 37].
+
+#### [관계 유형 B (아키텍처 및 거버넌스 도구)]
+- [[Feature-Sliced Design]]
+  - 연결 이유: 코드를 기술적 계층이 아닌 비즈니스 기능(Feature) 중심으로 분리하여, 여러 팀이 서로 간섭 없이 독립적으로 작업할 수 있는 환경을 제공한다 [16, 38].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 도메인 주도 설계의 프론트엔드 적용, 명시적 퍼블릭 API를 통한 모듈 캡슐화와 결합도 낮추기 [38-40].
+- [[Automated Governance]]
+  - 연결 이유: 사람의 수동 확인에 의존하지 않고 ESLint, Prettier, Husky 등으로 코드 컨벤션과 아키텍처 룰(의존성 방향 등)을 시스템적으로 강제한다 [6, 20].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: CI/CD 파이프라인에서의 코드 품질 보증 및 팀원 간의 스타일 분쟁 방지 [20].
+- [[Redux vs Zustand in Teams]]
+  - 연결 이유: 팀의 규모(소규모 vs 엔터프라이즈)에 따라 상태 관리 도구의 선택이 협업의 일관성에 결정적인 영향을 미치기 때문이다 [5, 24, 27].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 개발자의 자율성 부여와 일관성 강제(Boilerplate) 사이의 아키텍처적 트레이드오프 [22, 41].
+
+### Deeper Research Questions
+
+- 소규모 팀(2~5인)에서 대규모 팀(10인 이상)으로 확장할 때 Git 워크플로우와 브랜칭 전략은 어떻게 진화해야 하는가?
+- Feature-Sliced Design(FSD)을 프로젝트에 도입할 때, 팀원들이 공통 모듈을 `/shared` 폴더에 무분별하게 추가하는 것을 방지할 수 있는 구체적인 거버넌스 전략은 무엇인가?
+- ESLint와 Husky를 활용한 자동화 거버넌스 설정 시, 개발 속도를 늦추지 않으면서 모듈 간 잘못된 의존성(상위 레이어 참조 등)을 원천 차단하는 최적의 규칙 구성은 무엇인가?
+- 상태 관리 라이브러리(Redux vs Zustand)의 선택이 팀원 간의 비동기 로직 및 데이터 패칭(Fetching) 패턴의 파편화에 미치는 실제 영향은 무엇인가?
+- Pull Request 기반의 협업 환경에서, 시각적 회귀 테스트 도구(예: Storybook, Chromatic)가 코드 리뷰의 병목 현상을 어떻게 해소할 수 있는가?
+
+### Practical Application Contexts
+
+- **Implementation:** 코드를 커밋하고 PR을 생성할 때, 반드시 정해진 Conventional Commits 규칙을 따르고 JIRA 등의 이슈 티켓 번호를 브랜치와 커밋에 기입하여 추적성을 보장한다 [14, 37].
+- **System Design:** 프로젝트 폴더 구조 설계 시 기술적 파일 타입(컴포넌트, 훅 등)의 나열이 아닌, 인증, 대시보드 등 기능(Feature) 도메인 단위로 격리시켜 각 기능별로 전담 개발자가 병렬로 작업할 수 있도록 한다 [2, 42, 43].
+- **Operation / Maintenance:** CI/CD 파이프라인과 Git Hooks(Husky)를 세팅하여, 누군가 컨벤션을 어긴 코드를 푸시하려고 할 때 사전에 린터와 포매터가 작동해 잘못된 코드가 원격 브랜치에 올라가는 것을 차단한다 [20].
+- **Learning Path:** 신규 입사자나 팀원이 배정되었을 때, `README`에 명시된 팀의 브랜칭 전략 규칙과 폴더 디렉토리 설계 의도를 먼저 학습하게 하여 프로젝트 온보딩 시간을 단축한다 [2, 44].
+- **My Project Relevance:** 다수의 프론트엔드 개발자가 함께 참여하는 리액트 프로젝트에서, 코드 충돌과 기술 부채를 방지하고 일관된 제품 품질을 유지하기 위해 필수적으로 수립해야 하는 협업 그라운드 룰(Ground Rules)이다.
+
+### Adjacent Topics
+
+- [[Code Review Practices]]
+  - 확장 방향: 작은 단위의 Pull Request 유지, 시각적 리뷰 도구의 도입, 효율적인 동료 피드백 제공 등 코드 리뷰 자체의 품질과 속도를 높이는 방법론 [37, 45].
+- [[CI/CD Pipelines]]
+  - 확장 방향: 팀원의 코드가 `main`에 병합되기 전, 자동으로 테스트와 린팅을 수행하고 배포까지 이어지는 인프라 및 데브옵스 환경 [7].
+- [[Visual Regression Testing]]
+  - 확장 방향: Storybook 및 Chromatic을 활용해 UI 변경 사항을 리뷰어가 시각적으로 직접 확인하고, 예기치 않은 레이아웃 깨짐을 방지하는 협업 기술 [45, 46].
+
+---
+*Last updated: 2026-04-30*
\ No newline at end of file
diff --git a/00_Raw/Version Control.md b/00_Raw/Version Control.md
new file mode 100644
index 00000000..2da5260d
--- /dev/null
+++ b/00_Raw/Version Control.md	
@@ -0,0 +1,69 @@
+# [[Version Control]]
+
+## 📌 Brief Summary
+버전 관리(Version Control)는 소규모부터 대규모 팀에 이르기까지 코드의 변경 사항을 추적하고, 병합 충돌을 방지하며 안정적인 배포를 가능하게 하는 필수적인 협업 도구 및 거버넌스 프로세스입니다 [1, 2]. 개발팀은 프로젝트 규모와 팀의 숙련도에 따라 Feature-Branch 워크플로우, Trunk-based 개발, Git Flow 등 다양한 브랜칭 전략을 선택하여 사용합니다 [3, 4]. 효과적인 버전 관리는 브랜치와 커밋에 티켓 ID 연동, 의미 있는 커밋 메시지 작성, 작고 빈번한 커밋, 그리고 엄격한 풀 리퀘스트(PR) 리뷰 등의 모범 사례를 준수하여 코드베이스의 품질과 추적성을 유지하는 것을 목표로 합니다 [2, 5].
+
+## 📖 Core Content
+* **주요 브랜칭 전략 (Branching Strategies)**
+  * **Feature-Branch Workflow**: 2~5인 규모의 소규모 팀에게 가장 권장되는 단순하고 충돌이 적은 방식입니다 [6]. `main` 브랜치는 항상 안정적이고 배포 가능한 상태를 유지하며, 각 기능이나 버그 수정은 `main`에서 분기된 짧은 수명의 개별 브랜치에서 진행됩니다 [6, 7].
+  * **Trunk-Based Development**: 짧은 기능 브랜치를 활용하여 메인 브랜치(Trunk)에 코드를 빠르고 빈번하게 병합하는 전략으로, 강력한 CI/CD 환경과 경험이 많은 팀에게 적합합니다 [8, 9].
+  * **Git Flow & GitHub Flow**: Git Flow는 별도의 릴리스 브랜치 등을 두어 스케줄에 따른 대규모 프로젝트를 관리하기 좋지만, 작은 팀에게는 절차가 무겁습니다 [9]. 반면 GitHub Flow는 더 단순하며 빠른 통합을 지향합니다 [10].
+
+* **명명 규칙 및 추적성 (Naming Conventions & Traceability)**
+  * **브랜치 명명 (Branch Naming)**: 브랜치 이름에는 작업의 유형과 티켓 ID, 짧은 설명을 포함하는 것(예: `feature/PROJ-123-user-auth`)이 권장되며, 일관성 있게 소문자와 하이픈을 사용해야 합니다 [11, 12].
+  * **커밋 메시지 (Commit Messages)**: 'Conventional Commits' 사양을 따라 `feat:`, `fix:`, `docs:`, `refactor:`, `chore:` 등의 접두사를 사용하여 변경 목적을 명확히 해야 합니다 [5, 13]. 커밋은 논리적인 단일 변경 사항만을 포함하는 '원자적 커밋(Atomic Commits)' 형태여야 합니다 [14].
+
+* **병합 및 리뷰 프로세스 (Merging and Code Review)**
+  * **Pull Request (PR)**: 코드를 `main`에 병합하기 전 반드시 PR을 열어 최소 1명 이상의 동료 리뷰를 거치고 CI 테스트를 통과해야 합니다 [15, 16]. 리뷰가 쉽게 진행되도록 PR은 작게 유지해야 합니다 [13].
+  * **충돌 예방 및 정리**: 병합 충돌을 피하기 위해 `main` 브랜치의 최신 변경 사항을 자주 가져와 동기화(pull/rebase)해야 하며, 병합할 때는 'Squash & Merge'를 사용하여 커밋 히스토리를 깔끔하게 유지하고 병합 후에는 사용한 브랜치를 자동 삭제하는 것이 좋습니다 [15, 17, 18].
+
+## ⚖️ Trade-offs & Caveats
+* **오버헤드 vs. 제어력**: Git Flow와 같이 구조화되고 무거운 프로세스는 대규모 애플리케이션의 릴리스 일정을 관리하기 좋지만, 소규모 팀에게는 프로세스 오버헤드가 너무 커서 개발 속도를 저하시킬 수 있습니다 [9, 19]. 반대로 너무 단순한 전략은 엄격한 제어가 필요한 대형 프로젝트에서 문제를 일으킬 수 있으므로 팀 규모와 요구사항에 맞춘 전략 선택이 필요합니다 [20].
+* **Trunk-Based 개발의 제약사항**: 병합 충돌을 최소화하고 빠른 피드백을 제공하지만, 개발팀의 높은 숙련도와 강력한 CI 검증 파이프라인이 전제되어야 합니다 [9]. 또한, 미완성된 기능이 병합될 위험이 있으므로 기능 플래그(Feature flags)를 추가로 도입해야 하는 제약이 발생합니다 [19].
+* **장기 브랜치(Long-lived Branches)의 반대급부**: 기능 개발을 위해 브랜치를 너무 오래 유지하면 병합 시점에 엄청난 코드 충돌(merge conflicts)을 처리해야 하는 위험이 있습니다 [12, 21]. 따라서 충돌을 방지하기 위해서는 작업자가 매일 `main` 브랜치와 동기화하는 지속적인 유지보수 노력을 기울여야 합니다 [18].
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+
+#### [워크플로우 및 방법론 (Workflow Strategies)]
+- [[Feature Branch Workflow]]
+  - 연결 이유: 버그 수정이나 새 기능 개발 시 `main`과 분리된 독립적이고 짧은 수명의 브랜치를 사용하는 전략이기 때문입니다. [6, 7]
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 어떻게 `main` 브랜치의 안정성을 훼손하지 않으면서도 다수의 개발자가 코드를 작성하고 충돌을 방지할 수 있는지 이해할 수 있습니다.
+- [[Trunk-Based Development]]
+  - 연결 이유: 모든 개발자가 빈번하게 짧은 주기로 메인 브랜치(Trunk)에 코드를 병합하는 방법론이기 때문입니다. [8, 9]
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 지속적 통합(CI)을 어떻게 보장하며, 장기 브랜치로 인해 발생하는 문제를 어떻게 회피하는지 파악할 수 있습니다.
+- [[Git Flow]]
+  - 연결 이유: 릴리스용 브랜치와 개발용 브랜치를 명확히 나누어 복잡한 프로젝트 릴리스를 관리하는 아키텍처이기 때문입니다. [9, 19]
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 팀의 규모와 배포 스케줄에 따라 워크플로우에 어떤 구조적 레이어를 추가해야 하는지 이해할 수 있습니다.
+
+#### [협업 및 품질 관리 (Quality Assurance & Collaboration)]
+- [[Pull Request (PR)]]
+  - 연결 이유: 코드를 주 브랜치에 병합하기 전, 변경 사항을 동료에게 검토받는 핵심 품질 통제 절차이기 때문입니다. [13, 16]
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 코드 리뷰와 CI 테스트 자동화가 어떻게 실제 코드 품질을 유지하고 팀 내 지식 공유를 돕는지 이해할 수 있습니다.
+- [[Conventional Commits]]
+  - 연결 이유: `feat:`, `fix:`와 같이 표준화된 접두사를 사용하여 커밋 메시지의 의도를 명확하게 만드는 구문 규칙이기 때문입니다. [5, 13]
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 커밋 히스토리를 통한 변경 사항 추적성 확보와 릴리스 노트 자동화에 어떻게 기여하는지 이해할 수 있습니다.
+
+### Deeper Research Questions
+- 소규모 팀(2~5명)이 성장하여 10명 이상의 대규모 조직이 될 때, Feature-Branch 워크플로우에서 Git Flow 등 더 복잡한 전략으로 마이그레이션하는 구체적이고 안전한 방법은 무엇인가? [9, 20]
+- Trunk-based 개발 환경에서 불완전한 코드를 배포하지 않기 위해 사용하는 기능 플래그(Feature Flags)는 버전 관리 및 브랜칭 전략의 복잡성에 어떤 영향을 미치는가? [19]
+- Pull Request 완료 시 'Squash & Merge' 방식과 'Merge Commit' 방식 간의 커밋 히스토리 가독성 및 롤백 용이성 차이는 어떻게 나타나는가? [15, 17, 18]
+- 브랜치 이름과 커밋 메시지에 티켓 ID를 의무적으로 포함하는 거버넌스는, 실제 이슈 트래킹 도구(예: JIRA) 및 CI/CD 파이프라인과 결합 시 어떤 자동화 혜택을 제공하는가? [2, 10]
+- 장기 기능 브랜치(Long-lived feature branches)로 인해 발생하는 거대한 병합 충돌을 피하기 위해 팀은 일일 작업에서 어떤 동기화 패턴을 습관화해야 하는가? [18, 21]
+
+### Practical Application Contexts
+- **Implementation:** 브랜치 생성 시 `feature/PROJ-123-user-auth`처럼 티켓 ID를 포함하는 명명 규칙을 적용하고, `feat: add login form` 등의 Conventional Commits 형식을 사용하여 구현 이력을 체계적으로 관리합니다 [10, 11].
+- **System Design:** 코드를 하나의 논리적 단위로 분리하는 원자적 커밋(Atomic Commits) 규칙을 도입하고, CI/CD 체크가 통과되고 1인 이상이 승인해야만 `main`에 병합 가능하도록 브랜치 보호(Branch Protection) 시스템을 설계합니다 [14, 15].
+- **Operation / Maintenance:** `main` 브랜치는 항상 안정적이고 배포 가능한(deployable) 상태를 유지하도록 운영하며, 병합 완료 후 사용이 끝난 기능 브랜치를 자동 삭제 설정하여 저장소를 깔끔하게 유지합니다 [7, 15, 18].
+- **Learning Path:** 처음에는 복잡한 룰 없이 단순한 Feature-Branch 워크플로우와 명확한 네이밍 규칙을 익히고, 숙련도가 높아지면 자동화된 CI 환경 하의 Trunk-Based 개발 또는 복잡한 버전 관리를 위한 Git Flow로 학습을 확장합니다 [9, 19, 20].
+- **My Project Relevance:** 프론트엔드/React 개발 프로젝트 등의 팀 단위 협업 시, 불필요한 절차 없이 코드 충돌을 최소화하고 추적 가능한 변경 내역을 보장하는 협업 기준을 마련하는 데 즉각적으로 활용할 수 있습니다 [1, 22].
+
+### Adjacent Topics
+- [[Continuous Integration / Continuous Deployment (CI/CD)]]
+  - 확장 방향: PR 단계에서 자동화된 테스트 및 린팅을 실행하고, 메인 브랜치 병합 시 배포를 자동화하여 버전 관리 도구와 어떻게 시너지를 내는지 조사. [1, 19]
+- [[Issue Tracking Systems]]
+  - 확장 방향: JIRA나 GitHub Issues 등의 도구가 Git의 티켓 ID 거버넌스와 결합되어 요구사항부터 코드 변경까지 어떻게 완벽한 추적성(Traceability)을 보장하는지 조사. [2, 23]
+
+---
+*Last updated: 2026-04-30*
\ No newline at end of file
diff --git a/00_Raw/Visual Regression Testing.md b/00_Raw/Visual Regression Testing.md
new file mode 100644
index 00000000..7711b648
--- /dev/null
+++ b/00_Raw/Visual Regression Testing.md	
@@ -0,0 +1,57 @@
+# [[Visual Regression Testing]]
+
+## 📌 Brief Summary
+시각적 회귀 테스트(Visual Regression Testing)는 스토리북(Storybook) 등의 도구로 렌더링된 컴포넌트의 픽셀 단위 스크린샷을 캡처하여 이전에 알려진 "정상(baseline)" 상태의 스크린샷과 자동으로 비교하는 테스트 방식이다 [1, 2]. 이를 통해 개발자는 풀 리퀘스트(PR) 과정에서 의도치 않은 UI 레이아웃, 색상, 타이포그래피 등의 시각적 변경이나 결함을 찾아낼 수 있다 [3-5]. HTML 마크업만 비교하는 기존의 스냅샷 테스트와 달리, 실제 사용자가 경험하는 화면 픽셀을 직접 검증하므로 추가적인 테스트 코드 작성이나 유지보수 부담을 줄이면서도 오탐(false positive)을 최소화할 수 있는 것이 특징이다 [1, 2].
+
+## 📖 Core Content
+*   **작동 원리 및 프로세스:** 시각적 회귀 테스트는 코드가 변경되었을 때 모든 스토리(story)를 실제 브라우저(Chrome, Firefox, Safari 등) 환경에서 렌더링하고, 해당 화면을 캡처하여 기존의 기준선(baseline)과 비교한다 [4, 6]. 만약 레이아웃이나 색상 등에 의도치 않은 변화가 감지되면 해당 차이점을 강조하여 PR에서 수동 검토를 거치게 함으로써 시각적 결함이 프로덕션으로 배포되는 것을 차단한다 [3, 6, 7]. 변경 사항이 의도된 것이라면 개발자가 새로운 기준선으로 승인(accept)하여 로컬 및 CI 환경에 동기화할 수 있다 [7, 8].
+*   **스냅샷 테스트(Snapshot Testing)와의 차이점:** 기존 스냅샷 테스트는 렌더링된 HTML 마크업 블록을 비교하기 때문에, 코드가 변경되었으나 사용자에게 보이는 실제 시각적 변경이 없는 경우에도 테스트가 실패하는 오탐(false positive)이 발생하기 쉽다 [2]. 반면 시각적 회귀 테스트는 렌더링된 픽셀 자체를 비교하므로 사용자가 실제로 경험하는 UI의 모양, 간격, 반응형 동작 등을 훨씬 더 정확하고 풍부하게 검증할 수 있다 [2, 5].
+*   **인터랙션(Interaction) 기반 상태 검증:** 컴포넌트의 로딩, 에러, 호버(hover), 메뉴 열림 등의 다양한 UI 상태를 검증하기 위해 스토리북의 인터랙션 테스트와 시각적 회귀 테스트를 결합할 수 있다 [9]. 인터랙션 테스트를 통해 컴포넌트를 특정 상태로 만든 후 스크린샷을 찍음으로써 동적인 행동에 대한 시각적 결함 유무까지 하나의 워크플로우 안에서 파악할 수 있다 [9, 10].
+*   **CI 파이프라인 자동화:** 이 테스트는 GitHub Actions, GitLab Pipelines 등 CI 환경과 원활하게 통합되어 풀 리퀘스트(PR)마다 자동으로 실행된다 [11, 12]. 테스트가 완료되면 PR에 UI 변경 사항에 대한 알림(badge)을 제공하여, 리뷰어가 모든 상태를 일일이 확인하는 대신 변경된 부분(diffs)에만 집중해서 리뷰할 수 있도록 돕는다 [6, 12].
+
+## ⚖️ Trade-offs & Caveats
+*   **미세한 픽셀 차이로 인한 노이즈(Flakiness):** 브라우저의 이미지 압축 노이즈나 안티앨리어싱(anti-aliasing) 처리 등 아주 미세한 픽셀 차이 때문에 실제로는 결함이 아님에도 불구하고 시각적 변경으로 감지되는 테스트 불안정성(Flake)이 발생할 수 있다 [11, 13]. 이를 방지하기 위해 시각적 테스트 도구에서는 색상 차이 허용치(color-delta tolerance) 임계값을 설정하여 해당 범주 아래의 차이는 노이즈로 무시하는 최적화 작업이 요구된다 [10, 13].
+*   **비동기 요소 및 애니메이션 제어의 필요성:** 컴포넌트에 포함된 애니메이션이나 비동기 에셋, 폰트 등이 완전히 렌더링되기 전에 스크린샷이 캡처되면 매번 다른 결과가 나와 일관된 테스트가 불가능해진다 [10, 11]. 따라서 시각적 회귀 테스트 도구(Happo 등)는 캡처 전 애니메이션을 자동으로 음소거(silence) 처리하거나 비동기 요소의 로딩을 강제로 기다려야 하는 기술적 제약과 추가 설정이 필요하다 [10, 11].
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+
+#### [테스트 및 검증 기술]
+- [[Snapshot Testing]]
+  - 연결 이유: 시각적 회귀 테스트와 대조되는 테스트 방식으로, 픽셀이 아닌 렌더링된 HTML 마크업 코드 덩어리를 비교한다 [2].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: HTML 구조 비교 방식이 왜 빈번하게 오탐(False Positive)을 발생시키는지, 그리고 픽셀 기반 비교가 유지보수에 왜 더 유리한지 명확하게 이해할 수 있다 [2].
+- [[Interaction Testing]]
+  - 연결 이유: 사용자의 상호작용이나 이벤트를 시뮬레이션하여 컴포넌트의 특정 UI 상태를 유도하는 테스트 방식이다 [5, 10].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 정적 UI 화면뿐만 아니라 로딩, 에러, 클릭 시 드롭다운 오픈 등 동적으로 변화하는 UI 상태를 시각적 회귀 테스트가 어떻게 캡처하고 검증하는지 파악할 수 있다 [9, 10].
+
+#### [구현 및 활용 도구]
+- [[Storybook]]
+  - 연결 이유: UI 컴포넌트를 애플리케이션의 복잡한 로직과 분리하여 격리된 환경에서 시각적으로 개발하고 문서화할 수 있게 해주는 도구이다 [3, 6].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 시각적 회귀 테스트가 전체 페이지 단위가 아닌 개별 컴포넌트의 상태(Story) 단위로 렌더링되고 기준선과 비교되는 아키텍처적 기반을 이해할 수 있다 [1].
+- [[Chromatic]] / [[Happo]]
+  - 연결 이유: Storybook과 연결되어 실제 브라우저 기반의 스크린샷 캡처, 베이스라인 픽셀 비교, CI/CD 연동 등을 수행하는 시각적 회귀 테스트 클라우드 서비스(도구)이다 [1, 3, 4].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 자동화된 시각적 회귀 테스트가 브라우저 간의 렌더링 차이를 어떻게 병렬로 처리하고 풀 리퀘스트(PR) 프로세스와 어떻게 상호작용하는지 확인할 수 있다 [4, 12].
+
+### Deeper Research Questions
+- Snapshot Testing에서 Visual Regression Testing으로 마이그레이션할 때, 대규모 컴포넌트 라이브러리 환경에서 초기 기준선(baseline) 구축 및 스토리지 유지보수 비용은 어떻게 최적화할 수 있는가?
+- Chromatic이나 Happo와 같은 도구가 크로스 브라우저(Chrome, Safari, Firefox 등)에서 동일한 컴포넌트를 렌더링할 때 발생하는 OS/브라우저 엔진별 미세한 렌더링 차이를 어떻게 처리하고 보정하는가?
+- 시각적 회귀 테스트 파이프라인을 CI/CD에 통합했을 때 빌드 시간 지연을 방지하기 위한 병렬 처리(Parallelization) 및 최적화 전략은 무엇인가?
+- 애니메이션 및 비동기 데이터를 많이 사용하는 복잡한 인터랙티브 컴포넌트에서 테스트의 불안정성(Flakiness)을 코드 레벨에서 근본적으로 제거하려면 컴포넌트를 어떻게 설계해야 하는가?
+- Visual Regression Testing과 Accessibility Regression Testing을 하나의 워크플로우로 결합했을 때, 접근성 위반 사항이 구체적으로 어떤 시각적 지표와 함께 리포트되며 PR 리뷰 프로세스는 어떻게 효율화되는가?
+
+### Practical Application Contexts
+- **Implementation:** Storybook으로 UI 컴포넌트를 개발한 후, Chromatic이나 Happo 등의 애드온을 설치하여 코드 변경 시마다 각 컴포넌트의 상태별 스크린샷을 자동으로 캡처하고 기준선과 비교하도록 설정한다 [4, 14].
+- **System Design:** 프론트엔드 아키텍처 설계 시, 비즈니스 로직과 UI를 철저히 분리하여 컴포넌트를 구축하고, 시각적 검증 시스템을 도입하여 대규모 팀이 동시에 개발하더라도 일관된 디자인 시스템이 훼손되지 않도록 방어 체계를 마련한다 [3, 4].
+- **Operation / Maintenance:** CI 파이프라인(GitHub Actions 등)에 시각적 테스트를 필수 단계로 추가하여, 변경된 디자인 코드가 PR에 올라올 때마다 의도치 않은 레이아웃 깨짐 현상을 자동으로 감지하고 리뷰어에게 시각적 Diff를 제공하여 운영 유지보수 부담을 줄인다 [3, 6, 12].
+- **Learning Path:** React 컴포넌트 기반 UI 작성 → Storybook을 활용한 컴포넌트 문서화 및 CDD(Component-Driven Development) → 인터랙션(Interaction) 테스트 작성 → 시각적 회귀 테스트 자동화 순으로 프론트엔드 품질 검증 파이프라인을 학습한다 [9, 15].
+- **My Project Relevance:** 프론트엔드 레거시 코드를 리팩토링하거나 수백 개의 화면에서 공유되는 코어 UI 라이브러리 버전을 업그레이드할 때, 다른 팀의 컴포넌트에서 발생하는 의도치 않은 파급 효과(Side Effect) 및 시각적 깨짐을 안전하게 감지하고 확신을 갖고 배포하는 데 핵심적인 역할을 한다 [3, 16].
+
+### Adjacent Topics
+- [[Accessibility Regression Testing]]
+  - 확장 방향: 시각적 테스트 워크플로우와 결합하여, 새로운 테스트 코드를 별도로 작성할 필요 없이 스크린샷 실행 단계에서 UI의 접근성 위반(명도 대비 부족, 키보드 포커스 누락 등)까지 동시에 자동 검증하는 영역으로 확장할 수 있다 [9, 10].
+- [[Continuous Integration (CI) Pipelines]]
+  - 확장 방향: GitHub Actions, CircleCI 등의 CI 도구에서 시각적 테스트 인프라가 어떻게 연동되며, 코드가 병합되기 전에 PR의 상태 체크(Status Check)를 필수로 제어하는 자동화 파이프라인 및 DevOps 프로세스로 학습을 넓힐 수 있다 [12].
+
+---
+*Last updated: 2026-04-30*
\ No newline at end of file
diff --git a/00_Raw/Vite + React 성능 최적화.md b/00_Raw/Vite + React 성능 최적화.md
new file mode 100644
index 00000000..5fbe3306
--- /dev/null
+++ b/00_Raw/Vite + React 성능 최적화.md	
@@ -0,0 +1,75 @@
+# [[Vite + React 성능 최적화]]
+
+## 📌 Brief Summary
+Vite와 React 환경에서 애플리케이션의 성능을 최적화하는 것은 초기 로딩 속도를 높이고 런타임 성능을 향상시켜 전반적인 사용자 경험을 개선하는 과정입니다. 개발 환경에서는 기본 ES 모듈(ESM)을, 운영 환경에서는 Rollup을 통한 번들링을 활용하는 Vite의 구조적 이점을 극대화하는 것이 핵심입니다. 주요 최적화 기법으로는 빠른 컴파일을 위한 SWC 도입, 동적 임포트를 통한 코드 분할, `manualChunks`를 활용한 무거운 벤더 라이브러리 분리, 그리고 번들 시각화 도구를 통한 불필요한 의존성 제거 등이 포함됩니다.
+
+## 📖 Core Content
+*   **Vite의 아키텍처 이해 및 SWC 활용**
+    개발 중에는 모든 코드를 미리 번들링하지 않고 브라우저에 네이티브 ES 모듈(ESM)로 직접 제공하여 매우 빠른 서버 시작과 HMR(Hot Module Replacement)을 달성합니다 [1, 2]. 컴파일 속도를 극대화하기 위해 기존의 Babel 대신 Rust 기반 컴파일러인 SWC(`@vitejs/plugin-react-swc`)를 채택하면, 커스텀 Babel 플러그인이 필요 없는 대규모 React 프로젝트에서 빌드 및 새로고침 시간을 획기적으로 줄일 수 있습니다 [3-5].
+*   **코드 분할(Code Splitting) 및 지연 로딩(Lazy Loading)**
+    초기 로드 속도를 높이고 LCP(Largest Contentful Paint)와 같은 웹 지표를 향상시키기 위해 무거운 번들을 여러 청크로 분할해야 합니다 [6, 7]. `React.lazy()`와 `<Suspense>`를 사용한 동적 임포트로 라우트 레벨이나 차트 등 큰 위젯을 사용자가 접근할 때만 로드하도록 설정하면 메인 번들의 크기를 대폭 줄일 수 있습니다 [6, 8-13].
+*   **`manualChunks`를 활용한 벤더 라이브러리 분할**
+    프로덕션 빌드 시 500kB 이상의 거대한 청크 경고를 해결하기 위해 `vite.config.js`의 Rollup 옵션에서 `manualChunks`를 설정합니다 [12, 14-17]. React 코어나 Lodash, 차트, 아이콘 등 잦은 변경이 없는 외부 라이브러리들을 별도의 파일로 분리하면, 브라우저가 변경되지 않은 코드를 장기간 캐싱(Long-term caching)할 수 있어 재방문 및 배포 시 로딩 효율이 향상됩니다 [12, 15, 18, 19].
+*   **의존성 사전 번들링(`optimizeDeps`)과 트리 쉐이킹**
+    대규모 앱이나 비정상적인 의존성 로딩으로 인한 성능 저하를 방지하기 위해 `optimizeDeps`를 명시적으로 제어할 수 있습니다 [5, 6]. 또한 불필요한 코드 로드를 막기 위해 `lodash` 대신 `lodash-es`처럼 트리 쉐이킹(Tree-shaking)이 지원되는 최신 ES 모듈 기반 라이브러리를 우선적으로 사용해야 합니다 [20].
+*   **번들 시각화 및 모니터링**
+    `rollup-plugin-visualizer` 플러그인을 연동하여 빌드 시 거대한 번들의 구성 요소를 시각적인 트리맵 형태로 분석합니다 [6, 13, 21]. 이를 통해 번들 내 차지하는 비중이 불필요하게 큰 코드를 찾아내어 제거하거나 지연 로딩으로 분리할 기회를 신속하게 파악할 수 있습니다 [13, 20, 22].
+
+## ⚖️ Trade-offs & Caveats
+*   **과도한 플러그인 사용:** Vite를 구성할 때 너무 많은 플러그인을 남용하면 개발 서버의 성능이 현저히 느려질 수 있으므로, 반드시 필요한 플러그인 위주로 가볍게 유지해야 합니다 [20].
+*   **캐싱 무효화 주의:** 모듈 로딩 성능을 위해 Vite는 브라우저 캐싱에 크게 의존하므로, 개발 시 브라우저 개발자 도구에서 캐시를 무효화(Disable cache)하면 성능이 급격하게 저하될 수 있습니다 [20].
+*   **지연 로딩의 과용 및 잘못된 배치:** 모든 컴포넌트에 지연 로딩을 남발하거나, 스크롤 없이 바로 보여야 하는 핵심(Above-the-fold) 요소나 즉시 렌더링해야 하는 UI까지 지연 로딩을 적용하면 초기 화면 표시가 지연되어 오히려 사용자 경험을 망칠 수 있습니다 [23, 24].
+*   **메모이제이션(`React.memo`, `useMemo` 등) 오버헤드:** 불필요한 리렌더링을 막기 위한 도구지만, 비교 연산과 이전 상태를 캐싱하는 메모리 비용이 발생합니다 [25]. 렌더링이 아주 빠르고 단순한 컴포넌트나, 전달되는 props가 빈번히 변경되는 경우(예: 인라인 객체, 함수 전달)에 사용하면 렌더링 자체보다 상태 비교 비용이 더 커져 성능이 오히려 악화될 수 있습니다 [25-28].
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+
+#### [관계 유형 A (아키텍처/기반 기술)]
+- [[네이티브 ES 모듈(ESM)]]
+  - 연결 이유: Vite가 개발 환경에서 코드 모듈을 서빙하는 방식의 핵심 기반 원리입니다.
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 번들러가 전체 앱을 매번 빌드하지 않고 변경된 모듈만 요청/로드함으로써 프로젝트 크기에 상관없이 빠른 HMR과 응답성을 유지하는 메커니즘을 파악할 수 있습니다 [1, 29, 30].
+
+- [[Rollup]]
+  - 연결 이유: Vite 환경에서 프로덕션 배포 시 코드를 하나로 모으고 최적화하는 데 사용되는 번들러입니다.
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: Vite의 설정 파일(`vite.config.js`)에서 `manualChunks` 등 Rollup 전용 빌드 옵션을 통해 어떻게 효율적인 정적 애셋(Asset)을 생성하고, 코드 분할과 트리 쉐이킹을 수행하는지 이해할 수 있습니다 [14, 18, 31, 32].
+
+#### [관계 유형 B (구현/활용 도구)]
+- [[SWC 컴파일러]]
+  - 연결 이유: Vite의 기본 구성을 확장해 속도를 향상시키기 위한 강력한 도구입니다.
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 과거 Babel이 처리하던 JSX/TypeScript 변환 작업을 Rust 기반의 빠른 도구(`@vitejs/plugin-react-swc`)로 교체하여 대형 React 애플리케이션의 재빌드 시간을 즉각적으로 단축시키는 방식을 파악할 수 있습니다 [1, 3, 5].
+
+- [[React.lazy & Suspense]]
+  - 연결 이유: React 내부에서 동적 임포트를 통한 컴포넌트 레벨 지연 로딩을 구현하기 위한 API입니다.
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 라우트나 무거운 모듈을 분리하고, 번들이 로드되는 동안 `<Suspense>`를 통해 폴백(Fallback) UI를 처리함으로써 초기 자바스크립트 페이로드 용량을 대폭 줄이는 실무 기법을 배울 수 있습니다 [6, 9, 11, 12, 33].
+
+- [[rollup-plugin-visualizer]]
+  - 연결 이유: 최적화 작업 전후로 번들 크기를 시각화하고 문제를 진단하는 필수 분석 플러그인입니다.
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 큰 청크가 왜 발생하는지, 어떤 외부 라이브러리(벤더)가 의도치 않게 용량을 과도하게 점유하는지 분석하여 `manualChunks`나 코드 교체를 결단하는 측정/디버깅 기반을 확립할 수 있습니다 [6, 13, 21].
+
+### Deeper Research Questions
+
+- 대규모 외부 패키지를 사용할 때 Vite의 `optimizeDeps`를 세밀하게 튜닝하려면 어떠한 기준과 설정 방식을 적용해야 하는가?
+- SWC 플러그인을 도입할 때 기존에 사용 중인 특정 커스텀 Babel 플러그인을 온전히 대체하거나 병행해서 사용해야 하는 경우의 한계 및 해결책은 무엇인가?
+- Rollup의 `manualChunks`로 무거운 라이브러리를 분리할 때, 브라우저가 병렬로 다운로드할 수 있는 한계점과 장기 캐싱(Long-term caching)의 이점을 고려한 최적의 분할 단위(Chunk size)는 어느 정도인가?
+- `React.lazy`와 `<Suspense>`를 라우트 레벨이 아닌 세부 컴포넌트 레벨(예: 무거운 모달 창이나 차트)에 광범위하게 적용할 때, 불필요한 로딩 상태 남발을 막고 자연스러운 사용자 경험을 유지하는 방법은 무엇인가?
+- 번들 시각화를 통해 발견된, 트리 쉐이킹이 전혀 적용되지 않는 레거시 라이브러리 의존성을 제거하거나 모던 라이브러리로 마이그레이션할 때 따라야 할 리팩토링 전략은 무엇인가?
+
+### Practical Application Contexts
+
+- **Implementation:** `vite.config.ts` 파일에서 SWC 플러그인 설정 및 `rollupOptions` 내 `manualChunks`를 직접 작성하여 React 런타임, 상태 관리 도구, 차트 라이브러리 등을 각각의 청크로 추출하도록 코드를 구현합니다.
+- **System Design:** 초기 아키텍처 수립 시, 라우트 별로 지연 로딩될 기능과 앱 구동 시 즉시 필요한 코어 레이어를 엄격하게 분리하여 코드 스플리팅을 전제로 한 컴포넌트 계층 트리를 설계합니다.
+- **Operation / Maintenance:** CI/CD 파이프라인에 `rollup-plugin-visualizer`의 결과를 리포트로 남기도록 구성하여, 팀원이 새로운 패키지를 추가할 때 메인 번들 크기가 비정상적으로 커지지 않는지 지속적으로 감시하고 유지보수합니다.
+- **Learning Path:** 우선 React의 렌더링 원리 및 프로파일러 사용법을 학습한 후, 빌드 툴(Vite/Rollup)의 번들링 메커니즘을 이해하고, 이후 지연 로딩 기법 및 번들 최적화 플러그인 실습으로 이어지는 로드맵을 구성합니다.
+- **My Project Relevance:** 거대한 자바스크립트 파일 전송으로 인해 렌더링이 지연되는 프로젝트나, 빌드 후 "500kB 초과" 경고가 뜨는 프론트엔드 환경에서 즉각적인 파일 분할과 캐싱 전략을 적용하여 페이지 로드 성능(FCP, LCP)을 가시적으로 개선할 수 있습니다.
+
+### Adjacent Topics
+
+- [[Core Web Vitals]]
+  - 확장 방향: Vite와 React 최적화를 통해 얻어낸 메인 번들 크기 감소 및 렌더링 속도 향상이 실제 사용자 체감 성능 지표(LCP, FID/INP 등)에 어떤 수치적 개선으로 나타나는지를 구체적으로 연구합니다 [11, 34, 35].
+
+- [[Concurrent Rendering (동시성 렌더링)]]
+  - 확장 방향: 로딩과 번들링 최적화뿐만 아니라, `useTransition` 및 `useDeferredValue` 훅을 이용하여 복잡한 데이터 변화 시에도 사용자 입력 등의 UI 반응성을 유지하는 런타임 차원의 성능 향상 전략으로 지식을 확장합니다 [36-38].
+
+---
+*Last updated: 2026-04-30*
\ No newline at end of file
diff --git a/00_Raw/Vite Build System.md b/00_Raw/Vite Build System.md
new file mode 100644
index 00000000..9ee03e7c
--- /dev/null
+++ b/00_Raw/Vite Build System.md	
@@ -0,0 +1,52 @@
+# [[Vite Build System]]
+
+## 📌 Brief Summary
+Vite는 현대 프론트엔드 애플리케이션(특히 React) 개발을 위한 새로운 산업 표준 빌드 도구로, 거의 즉각적인 서버 시작과 초고속 HMR(Hot Module Replacement)을 제공합니다 [1, 2]. 기존 번들러와 달리 개발 환경에서는 브라우저에 네이티브 ES 모듈 형태로 코드를 제공하고, 프로덕션 환경에서는 Rollup을 사용하여 고도로 최적화된 번들을 생성하는 하이브리드 아키텍처를 사용합니다 [3, 4]. 또한 SWC나 esbuild와 같은 Rust 기반 컴파일러를 활용하여 대규모 프로젝트에서도 빠르고 원활한 개발자 경험을 보장합니다 [3, 5, 6].
+
+## 📖 Core Content
+*   **하이브리드 아키텍처 (개발 및 프로덕션)**: Vite는 개발 시 모든 코드를 사전에 번들링하는 대신, 코드를 네이티브 ES 모듈(ESM) 형태로 브라우저에 직접 제공합니다 [2, 3]. 이 방식은 필요할 때 필요한 파일만 로드하므로 프로젝트 규모가 커져도 서버 시작 및 갱신 속도가 매우 빠릅니다 [3, 7]. 반면, 프로덕션 배포 시에는 내부적으로 Rollup을 사용하여 자동 코드 스플리팅, 미사용 코드 제거(Tree-shaking), 자산 최적화 등을 수행하여 성능이 뛰어난 번들을 생성합니다 [4, 8].
+*   **초고속 컴파일러 및 플러그인 활용**: Vite는 컴파일 속도를 높이기 위해 Rust 기반의 컴파일러인 SWC 또는 esbuild를 사용합니다 [3]. 기존 Babel 대신 `@vitejs/plugin-react-swc`를 사용하면 JSX 및 TypeScript 컴파일 속도가 비약적으로 향상되어 재빌드 시간이 단축됩니다 [5, 6, 9]. 이외에도 `vite-plugin-svgr`(SVG 컴포넌트화), `vite-plugin-pwa`와 같은 유연한 플러그인 생태계를 지원합니다 [10].
+*   **고급 구성 (vite.config.js)**: Vite는 `vite.config.js`를 통해 복잡한 프로젝트 설정을 제어할 수 있습니다. 예를 들어 경로 별칭(Path Aliases)을 설정하여 임포트를 깔끔하게 관리하거나, `VITE_` 접두사가 붙은 환경 변수만을 안전하게 노출하며, 개발 중 CORS 문제를 피하기 위한 내장 프록시 서버 설정을 지원합니다 [5, 9, 11].
+*   **성능 튜닝 및 대용량 청크(Chunk) 관리**: 대규모 앱에서는 무거운 벤더 라이브러리로 인해 메인 번들이 과도하게 커지는 문제("chunks are larger than 500 kB")가 발생할 수 있습니다 [12-14]. 이를 해결하기 위해 `manualChunks`를 사용하여 React, 차트 라이브러리 등 자주 변경되지 않는 벤더 코드를 별도의 파일로 분리해 브라우저 캐싱을 극대화합니다 [8, 11, 14-16]. 이와 함께 `React.lazy`와 `<Suspense>`를 이용한 라우트 레벨의 동적 임포트(코드 스플리팅)를 적용하고, `rollup-plugin-visualizer`로 번들 크기를 시각적으로 분석하여 불필요한 코드를 제거하는 것이 모범 사례입니다 [16-19].
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+- [[Native ES Modules (ESM)]]
+  - 연결 이유: Vite가 개발 환경에서 파일 전체를 사전 번들링하지 않고, 필요할 때 브라우저에 코드를 제공하는 핵심 메커니즘이기 때문입니다 [3, 7].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: Vite가 기존 도구(Webpack 등)에 비해 어떻게 초기 구동 속도와 HMR 응답성을 극적으로 단축할 수 있는지 그 원리를 파악할 수 있습니다 [2, 3].
+
+- [[Rollup]]
+  - 연결 이유: Vite가 프로덕션용 빌드를 생성할 때 내부적으로 채택하고 있는 번들러 도구이기 때문입니다 [4].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 프로덕션 환경에서 청크가 어떻게 나뉘며(`manualChunks`), 코드 스플리팅과 트리 쉐이킹을 통해 최적화된 정적 자산이 만들어지는 과정을 이해할 수 있습니다 [4, 8, 11].
+
+- [[SWC (Speedy Web Compiler)]]
+  - 연결 이유: Vite 환경에서 기존의 Babel을 대체하여 JSX와 TypeScript를 실시간에 가깝게 변환하는 Rust 기반 컴파일러 기술이기 때문입니다 [3, 5, 6].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 대규모 React 애플리케이션 개발 시 컴파일 속도와 핫 리로드 속도를 향상하는 기술적 배경을 깊이 이해할 수 있습니다 [3, 6].
+
+- [[Code Splitting & manualChunks]]
+  - 연결 이유: 대용량 메인 번들 문제를 해결하고, 초기 페이지 로드 속도를 높이기 위한 Vite 성능 최적화의 핵심 기법이기 때문입니다 [12, 14].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 동적 임포트와 결합하여 벤더 라이브러리(안정적인 코드)를 별도 파일로 캐싱하고 기능 단위로 청크를 나누는 전략을 학습할 수 있습니다 [8, 16].
+
+### Deeper Research Questions
+- 개발 환경의 네이티브 ESM 처리 방식과 프로덕션 환경의 Rollup 번들링 간의 아키텍처 차이가 런타임 동작이나 모듈 해석(Module Resolution)에 어떤 차이와 잠재적 버그를 유발할 수 있는가?
+- Vite의 `optimizeDeps`를 통한 사전 번들링(Pre-bundling) 프로세스는 거대한 외부 의존성 패키지를 로드할 때 브라우저의 네트워크 병목을 어떻게 해결하는가?
+- 대규모 React 앱을 마이그레이션 할 때 커스텀 Babel 플러그인을 사용 중인 환경에서 SWC 컴파일러(`@vitejs/plugin-react-swc`)로 전환할 때 발생하는 호환성 한계와 대안은 무엇인가?
+- `manualChunks`를 활용해 벤더 라이브러리를 세밀하게 분할할 때, 생성된 해시(hash) 파일명 기반의 장기 캐싱(Long-term Caching) 메커니즘은 브라우저에서 구체적으로 어떻게 최적화되는가?
+- `rollup-plugin-visualizer`를 통한 번들 시각화 이후, 의도치 않게 메인 청크에 포함된 과도한 트랜지티브 의존성(Transitive Dependencies)을 효과적으로 분리하는 구체적인 코드 레벨 패턴은 무엇인가?
+
+### Practical Application Contexts
+- **Implementation:** `vite.config.js`를 구성하여 `@vitejs/plugin-react-swc`를 도입하고, 상대 경로를 피하기 위한 경로 별칭(Path Aliases) 설정, `VITE_` 접두사를 이용한 안전한 환경 변수 바인딩, CORS를 우회하기 위한 프록시(Proxy) 설정을 적용합니다 [5, 9, 11].
+- **System Design:** 대규모 프론트엔드 시스템 설계 시, 무거운 초기 번들 크기 이슈를 방지하기 위해 Webpack 대신 Vite를 도입하고 개발(네이티브 ESM)과 프로덕션(Rollup 최적화)의 하이브리드 빌드 파이프라인을 구축합니다 [2-4, 8].
+- **Operation / Maintenance:** `rollup-plugin-visualizer`를 빌드 프로세스에 연동해 정기적으로 번들 크기를 모니터링하고, `manualChunks`를 유지보수하여 React 코어 같은 벤더 패키지의 브라우저 캐싱 이점을 유지합니다 [16-19].
+- **Learning Path:** 우선 Vite의 공식 스캐폴드 툴로 React 앱을 생성하여 기존 CRA(Create React App) 구조와의 차이를 체험한 후, 동적 임포트(`React.lazy`)와 `optimizeDeps` 등의 고급 설정 및 플러그인 확장을 점진적으로 학습합니다 [6, 7, 10, 16, 20].
+- **My Project Relevance:** 소스에 관련 정보가 부족합니다. (개인의 현재 진행 중인 특정 프로젝트에 대한 정보가 소스 텍스트에 포함되어 있지 않습니다.)
+
+### Adjacent Topics
+- [[React Server Components (RSC) & Next.js App Router]]
+  - 확장 방향: Vite를 이용한 빌드 툴 체인 최적화(CSR/SPA 성능 최적화)를 넘어, 클라이언트 측 자바스크립트 번들 자체를 전송하지 않고 서버에서 미리 렌더링하는 아키텍처 수준의 성능 최적화 패러다임으로 이해를 넓힙니다 [21-23].
+- [[Performance Metrics (Core Web Vitals)]]
+  - 확장 방향: Vite의 청크 최적화와 레이지 로딩 기법이 실제 사용자 체감 성능 지표인 FCP(First Contentful Paint), LCP(Largest Contentful Paint), INP(Interaction to Next Paint)에 어떤 직접적인 영향을 미치는지 연결하여 학습합니다 [13, 24, 25].
+
+---
+*Last updated: 2026-04-30*
\ No newline at end of file
diff --git a/00_Raw/Vite Build Tool.md b/00_Raw/Vite Build Tool.md
new file mode 100644
index 00000000..de593fe3
--- /dev/null
+++ b/00_Raw/Vite Build Tool.md	
@@ -0,0 +1,72 @@
+# [[Vite Build Tool]]
+
+## 📌 Brief 임무
+Vite는 현대 프론트엔드 애플리케이션(주로 React)을 위한 표준 빌드 도구로, 기존 Webpack 및 Create React App(CRA)을 대체하며 빠르게 자리 잡았습니다 [1, 2]. 이 도구는 개발 환경에서는 브라우저의 네이티브 ES 모듈(ESM)을 활용해 즉각적인 서버 시작과 초고속 HMR(Hot Module Replacement)을 제공합니다 [2-4]. 프로덕션 배포 시에는 내부적으로 Rollup을 사용하여 코드 스플리팅과 트리 쉐이킹이 적용된 고도로 최적화된 번들을 생성하는 하이브리드 아키텍처를 특징으로 합니다 [5, 6].
+
+## 📖 Core Content
+* **하이브리드 아키텍처 (Hybrid Architecture)**
+  * **개발 환경:** 코드를 사전에 전체 번들링하지 않고 브라우저에 네이티브 ES 모듈(ESM)로 직접 제공합니다. 필요한 파일만 로드되므로 프로젝트 크기가 커져도 개발 서버가 즉각적으로 반응합니다 [2-4].
+  * **프로덕션 환경:** 배포 시에는 Rollup을 사용하여 애플리케이션을 번들링하며, 자동 코드 스플리팅 및 사용하지 않는 코드를 제거하는 트리 쉐이킹(Tree-shaking)을 통해 최적화된 정적 에셋을 제공합니다 [5, 6].
+* **초고속 컴파일 및 사전 번들링 (Fast Compilation & Pre-bundling)**
+  * Vite는 esbuild나 최신 Rust 기반 트랜스포머인 SWC(Speedy Web Compiler)를 활용하여 JSX 및 TypeScript 파일을 사실상 즉시 컴파일합니다 [4, 7]. 기존 Babel을 SWC로 대체하면 핫 모듈 리로드 시간이 크게 단축됩니다 [8].
+  * 개발 중 새로고침 속도를 최적화하기 위해 종속성을 사전 번들링(Pre-bundling, `optimizeDeps`)합니다 [8].
+* **설정 및 플러그인 생태계 (Configuration & Plugins)**
+  * `vite.config.js`를 통해 경로 별칭(Path Aliases), CORS 문제를 방지하는 개발 서버 프록시, `VITE_` 접두사가 붙은 환경 변수 등을 유연하게 설정할 수 있습니다 [7, 9, 10].
+  * SVG를 React 컴포넌트로 가져오기 위한 `vite-plugin-svgr`, 오프라인 PWA 지원을 위한 `vite-plugin-pwa`, 번들 크기를 시각적으로 분석하는 `rollup-plugin-visualizer` 등 강력한 플러그인 생태계를 지원합니다 [11-13].
+* **번들 사이즈 최적화 (Bundle Optimization)**
+  * 기본적으로 Vite는 앱 코드와 모든 종속성(node_modules)을 하나의 `index.js`에 담아 빌드합니다. 이를 방지하기 위해 `vite.config.ts`의 Rollup 옵션에서 `manualChunks`를 설정하여 React 코어 라이브러리 등 무거운 벤더를 분리하고 브라우저 캐싱 효율을 높입니다 [6, 14, 15].
+  * `React.lazy()`와 `<Suspense>`를 결합한 라우트 레벨 동적 임포트를 통해 초기 메인 번들 크기를 극적으로 줄일 수 있습니다 [11, 14, 15].
+
+## ⚖️ Trade-offs & Caveats
+* **대형 청크 경고 및 초기 번들 비대화 (Large Chunks Warning):** Vite는 기본적으로 모든 종속성을 단일 파일로 빌드하기 때문에, 수동으로 코드 스플리팅을 하지 않으면 프로덕션 빌드 시 "500kB 초과" 경고가 발생할 수 있습니다. 이는 다운로드 시간을 지연시키고 낮은 성능의 모바일 기기에서 파싱 및 컴파일에 무리를 주어 FCP, LCP, INP와 같은 Core Web Vitals 지표를 악화시킬 수 있습니다 [14, 16, 17].
+* **개발자 도구 캐싱 의존성:** Vite는 모듈 로딩 성능을 위해 브라우저의 캐싱에 크게 의존합니다. 따라서 개발 중 브라우저 개발자 도구에서 "캐시 사용 안 함(Disable cache)"을 설정하면 개발 서버가 느려지는 부작용이 발생할 수 있습니다 [18].
+* **플러그인 남용으로 인한 성능 저하:** 과도한 플러그인 사용은 개발 서버의 속도를 저하시킬 수 있으므로, 구성을 최소화하고 필요한 플러그인만 유지해야 합니다 [18].
+* **사전 번들링 관리 필요성:** 규모가 크거나 특이한 외부 종속성의 경우, `optimizeDeps` 설정을 수동으로 제어하지 않으면 개발 환경에서 사전 번들링으로 인한 속도 저하가 발생할 수 있습니다 [8, 11].
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+
+#### [아키텍처/기반 기술]
+- [[Native ES Modules (ESM)]]
+  - 연결 이유: Vite가 개발 단계에서 빠른 구동 속도를 달성하기 위해 활용하는 브라우저의 기본 모듈 시스템입니다 [2, 4].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 과거 도구(Webpack)의 무거운 사전 번들링 방식과 대비되는 Vite의 '요청 시 제공(On-demand serving)' 메커니즘의 원리.
+
+- [[Rollup]]
+  - 연결 이유: Vite의 프로덕션 빌드를 담당하는 내부 번들러입니다 [5, 6].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 배포 환경에서 어떻게 `manualChunks`를 활용하여 번들을 분할하고, 트리 쉐이킹을 통해 최적화된 결과물을 도출하는지 그 과정 [10, 16].
+
+- [[SWC]]
+  - 연결 이유: 기존의 Babel을 대체하여 JSX와 TypeScript 컴파일을 엄청나게 빠른 속도로 처리하는 Rust 기반 트랜스포머입니다 [4, 7, 8].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: Vite 환경에서 React 애플리케이션의 핫 리로드와 빌드 퍼포먼스를 한 차원 끌어올리는 컴파일러의 역할.
+
+#### [최적화 기법]
+- [[Code Splitting & manualChunks]]
+  - 연결 이유: 500kB 이상의 거대한 메인 번들 경고 문제를 해결하기 위해 Vite/Rollup 환경에서 벤더 코드와 앱 코드를 나누는 핵심 기법입니다 [6, 14, 15].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 브라우저 병렬 다운로드와 효율적인 캐시 무효화 전략, 초기 페이로드 최소화 방법 [17, 19].
+
+### Deeper Research Questions
+
+- Vite의 네이티브 ESM 기반 개발 환경과 Rollup 기반 프로덕션 환경 사이의 차이로 인해, 런타임 또는 빌드 타임에 발생할 수 있는 호환성 문제나 예외 케이스는 무엇인가?
+- 대규모 애플리케이션에서 `optimizeDeps`를 통한 사전 번들링 메커니즘 최적화를 위해 구체적으로 어떤 기준을 가지고 종속성을 분리/포함해야 하는가?
+- `@vitejs/plugin-react-swc` 사용 시, 기존 Babel 생태계의 커스텀 플러그인들을 어떻게 이관하거나 대체해야 하는가?
+- `manualChunks`를 세밀하게 설정할 때 벤더 라이브러리의 중복 포함을 막고 가장 이상적인 청크 크기를 유지하는 전략은 무엇인가?
+- Vite 환경에서 라우트 레벨 지연 로딩(`React.lazy`) 적용 시 발생하는 워터폴(Waterfall) 네트워크 요청 문제를 방지하기 위해 `preload` 또는 `prefetch` 힌트를 어떻게 결합할 수 있는가?
+
+### Practical Application Contexts
+
+- **Implementation:** `npm create vite@latest`를 사용해 불필요한 설정 없는 가벼운 초기 구조를 생성하고, `vite.config.js`에 `@vitejs/plugin-react-swc`와 같은 플러그인, 경로 별칭(`@/components` 등), 백엔드 API 연동을 위한 proxy 설정을 구현합니다 [3, 7, 9, 10].
+- **System Design:** 프론트엔드 시스템 설계 시 개발 환경(빠른 피드백 루프 보장)과 배포 환경(고도의 압축 및 병렬 로드를 위한 모듈화 보장)에 다른 전략을 취하는 Vite의 하이브리드 철학을 아키텍처에 반영합니다 [5].
+- **Operation / Maintenance:** CI/CD 파이프라인이나 로컬 빌드 후 `rollup-plugin-visualizer` 플러그인을 활용하여 어떤 패키지가 메인 번들 용량을 차지하는지 시각적 트리맵으로 정기 점검하고 최적화합니다 [11, 13, 18].
+- **Learning Path:** 모듈 번들러의 발전 과정(Webpack -> ES Modules 네이티브 도입 -> Vite)을 학습한 후, 빌드 도구 차원의 최적화(`manualChunks`)와 React 프레임워크 차원의 최적화(`React.lazy`)가 결합되었을 때의 시너지를 이해하는 방향으로 학습을 진행합니다 [2, 6, 15].
+- **My Project Relevance:** Vite 빌드 시 "Some chunks are larger than 500 kB" 경고가 발생했을 때 당황하지 않고, 자주 변경되지 않는 벤더 코드(React 코어, 차트 라이브러리 등)를 분리하고 라우터 레벨에서 지연 로딩을 도입하여 다운로드 속도 및 FCP, LCP를 개선하는 데 직접적으로 적용합니다 [14-16].
+
+### Adjacent Topics
+
+- [[Webpack]]
+  - 확장 방향: Vite가 등장하기 전 업계 표준이었으나 시작 전 전체 번들링 과정으로 인해 무거운 구조를 가진 Webpack의 한계와 Vite와의 아키텍처 비교 [1, 2].
+- [[Core Web Vitals]]
+  - 확장 방향: Vite의 청크 분할 및 지연 로딩 기법이 실제 사용자 경험 지표인 FCP(First Contentful Paint), LCP(Largest Contentful Paint), INP(Interaction to Next Paint)에 어떻게 직결되는지 탐구 [17, 20].
+
+---
+*Last updated: 2026-04-30*
\ No newline at end of file
diff --git a/00_Raw/대규모 프론트엔드 애플리케이션.md b/00_Raw/대규모 프론트엔드 애플리케이션.md
new file mode 100644
index 00000000..b3e02b9e
--- /dev/null
+++ b/00_Raw/대규모 프론트엔드 애플리케이션.md	
@@ -0,0 +1,64 @@
+# [[대규모 프론트엔드 애플리케이션]]
+
+## 📌 Brief Summary
+대규모 프론트엔드 애플리케이션은 단순한 스크립트 실행을 넘어 확장성, 유지보수성, 고성능을 요구하는 고도로 정교한 분산 소프트웨어 시스템입니다. 비즈니스 로직과 UI의 분리, 명확한 상태 소유권, 엄격한 폴더 구조(Feature-Sliced Design 등)를 통해 아키텍처의 붕괴를 방지합니다. 또한, 코드 스플리팅, 자동 메모이제이션, 세분화된 상태 관리 도구를 활용하여 최적의 렌더링 성능과 사용자 경험을 유지하는 것이 핵심입니다.
+
+## 📖 Core Content
+
+*   **아키텍처 및 폴더 구조 (Architecture & Folder Structure)**
+    *   과거의 파일 타입 기반(MVC 등) 폴더 구조는 규모가 커질수록 로직이 파편화되는 한계가 있습니다. 대규모 앱에서는 비즈니스 기능별로 코드를 구성하는 **기능 기반(Feature-based)** 또는 **FSD(Feature-Sliced Design)** 아키텍처가 표준으로 자리 잡았습니다 [1-13].
+    *   FSD는 앱을 공유(shared), 엔티티(entities), 기능(features), 위젯(widgets), 페이지(pages), 앱(app) 등의 계층으로 나누고, **단방향 의존성 규칙**(하위 계층만 참조 가능)과 **Public API 규칙**(index.ts를 통한 캡슐화)을 강제하여 결합도를 낮춥니다 [6, 9, 10, 14, 15].
+*   **상태 관리의 파편화 (Fragmentation of Global State)**
+    *   거대한 단일 스토어(Monolithic Redux) 대신, 데이터 유형에 따라 최적의 도구를 선택합니다. 로컬 상태는 `useState`, 전역 애플리케이션 상태는 `Zustand`나 `Jotai`, 서버(API) 상태는 `TanStack Query`를 사용하여 캐싱 및 동기화를 처리합니다 [16-24].
+    *   특히 Context API는 값이 변할 때마다 모든 구독 컴포넌트를 리렌더링하는 '브로드캐스트' 방식이므로 정적 데이터(테마 등)에 적합하며, 자주 변경되는 동적 상태는 선택자(Selector) 패턴으로 불필요한 리렌더링을 방지하는 Zustand 등이 유리합니다 [16, 17, 25-28].
+*   **성능 최적화 (Performance Optimization)**
+    *   **빌드/런타임 최적화:** Vite와 Rollup을 활용하여 자주 변경되지 않는 벤더 라이브러리(React 등)를 `manualChunks`로 분리하여 캐시 효율을 높이고, `React.lazy`와 `Suspense`를 통해 라우트 또는 컴포넌트 단위의 코드 스플리팅을 구현합니다 [29-37].
+    *   **렌더링 성능:** React 19/2025 생태계에서는 수동 메모이제이션(React.memo, useMemo)의 한계를 극복하기 위해 **React Compiler**를 도입하여 빌드 타임에 자동으로 렌더링 최적화를 수행합니다. 대량의 리스트 데이터는 가상화(Virtualization) 기술을 통해 DOM 비대화를 막습니다 [30-32, 38-44].
+*   **복원력 및 디버깅 (Resilience & Debugging)**
+    *   런타임 에러로 인한 '백지 화면(White screen of death)'을 방지하기 위해 **에러 바운더리(Error Boundaries)**를 대시보드나 서드파티 위젯 등 불안정한 UI 섹션에 전략적으로 배치하여 Fallback UI를 제공합니다 [45-53].
+    *   메모리 누수(Detached DOM nodes 등)는 성능 저하의 주원인이므로 Chrome DevTools의 Heap Snapshot 및 Allocation Timeline을 통해 추적하며, 프로덕션 환경에서는 Sentry, LogRocket, Datadog 등의 가시성(Observability) 도구로 모니터링합니다 [54-63].
+*   **클린 코드 및 거버넌스 (Clean Code & Governance)**
+    *   React의 함수형 컴포넌트에도 SOLID 원칙(단일 책임 원칙, 개방-폐쇄 원칙 등), DRY, KISS, YAGNI 원칙이 적용됩니다. 컴포넌트는 단일 책임을 가져야 하며 과도한 추상화는 지양해야 합니다 [64-69].
+    *   운영체제 간 호환성 및 빌드 오류 방지를 위해 파일 및 폴더명은 `kebab-case`, 컴포넌트는 `PascalCase` 사용을 표준화하며, ESLint, Prettier, Husky를 통해 CI/CD 파이프라인에서 아키텍처 경계와 코드 품질을 자동 강제합니다 [70-73].
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+- [[Feature-Sliced Design (FSD)]]
+  - 연결 이유: 대규모 프론트엔드 프로젝트의 폴더 구조와 모듈 의존성을 통제하는 핵심 아키텍처 방법론입니다.
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 비즈니스 도메인과 UI를 어떻게 계층적으로 분리하고, 순환 참조 및 강한 결합을 어떻게 방지할 수 있는지 이해할 수 있습니다.
+- [[상태 관리 (State Management)]]
+  - 연결 이유: 대규모 앱에서는 전역 상태, 서버 상태, 로컬 상태를 명확히 분리해야 확장 및 성능 유지가 가능합니다.
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: Context API의 성능적 한계(리렌더링 폭풍)와 Zustand의 Selector 패턴, TanStack Query를 통한 서버 상태 캐싱 원리를 이해할 수 있습니다.
+- [[성능 최적화 (Performance Optimization)]]
+  - 연결 이유: 대규모 코드베이스는 필연적으로 번들 크기 증가와 렌더링 병목을 초래하므로 이를 제어하는 기술이 필수적입니다.
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: React Compiler의 자동화된 메모이제이션 원리, Vite의 manualChunks를 통한 번들 분할, React.lazy 기반의 코드 스플리팅 적용 방식을 파악할 수 있습니다.
+- [[에러 바운더리 (Error Boundaries)]]
+  - 연결 이유: 컴포넌트 하나의 오류가 전체 앱의 크래시로 이어지지 않게 막아주는 대규모 시스템의 필수 안전망입니다.
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 컴포넌트 트리 내에서 에러를 격리하는 원리와 런타임 에러를 우아하게 처리(Graceful degradation)하는 방법을 배울 수 있습니다.
+- [[메모리 누수 (Memory Leaks)]]
+  - 연결 이유: 앱 사용 시간이 길어질수록 성능을 심각하게 저하시키는 숨은 원인입니다.
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 클로저(Closure)나 Detached DOM에 의해 가비지 컬렉터가 메모리를 회수하지 못하는 구조적 원인과 DevTools를 활용한 디버깅 기법을 이해할 수 있습니다.
+
+### Deeper Research Questions
+- FSD(Feature-Sliced Design) 도입 시 '인증(Auth)'이나 '라우팅'과 같은 Cross-cutting concern(공통 관심사)은 계층(Layer) 구조의 어느 부분에 배치하고 어떻게 관리하는 것이 가장 적합한가?
+- React Compiler가 자동 메모이제이션을 수행할 때, 서드파티 라이브러리(예: 불안정한 객체 참조를 반환하는 커스텀 훅)와의 호환성 충돌 문제를 해결하기 위한 구체적 방안은 무엇인가?
+- 대규모 리스트 데이터를 렌더링할 때 Virtualization(윈도윙) 기술이 DOM 노드 증가를 막는 원리는 무엇이며, 이 과정에서 `key` 프롭(prop)이 성능에 미치는 정확한 영향은 무엇인가?
+- 프로덕션 환경의 프론트엔드 모니터링(Sentry, Datadog 등)이 제공하는 세션 리플레이(Session Replay) 기능이 개발자의 디버깅에 어떻게 기여하며, 이때 발생할 수 있는 민감 데이터 유출 및 번들 사이즈 증가라는 트레이드오프는 어떻게 극복하는가?
+- Zustand, Jotai와 같은 최신 상태 관리 라이브러리가 기존의 Redux나 Context API와 비교하여 동적/실시간 렌더링 최적화(예: 리렌더링 스킵)를 내부적으로 어떻게 구현하고 있는가?
+
+### Practical Application Contexts
+- **Implementation:** 파일과 폴더 네이밍 규칙(파일: kebab-case, 컴포넌트: PascalCase)을 통일하고, 300줄이 넘어가는 컴포넌트는 단일 책임 원칙(SRP)에 따라 더 작은 훅(Hook)과 서브 컴포넌트로 리팩토링합니다.
+- **System Design:** 프로젝트 설계 시 폴더 구조를 기술 스택(components, hooks) 기반이 아닌 비즈니스 도메인(features/auth, features/dashboard 등) 기반으로 구성하여 각 모듈의 캡슐화를 보장합니다.
+- **Operation / Maintenance:** 개별 서드파티 위젯이나 불안정한 UI 파트에 Error Boundary를 씌워 메인 서비스의 동작을 보장하며, Memory Profiler를 사용해 Detached DOM node 등 메모리 누수 요인을 정기적으로 감사(Audit)합니다.
+- **Learning Path:** 리액트 핵심 원리(렌더링 트리거 이해) → 폴더 구조/아키텍처(FSD) 설계 → 상태 관리 도구 비교 및 도입 → 웹 성능 지표(Core Web Vitals) 및 번들러(Vite) 최적화 도구 체득의 순서로 학습을 고도화합니다.
+- **My Project Relevance:** 팀 단위의 협업 시 ESLint, Prettier, Husky를 도입해 아키텍처 규칙(다른 Feature에 직접 접근 금지 등)을 자동 강제하고, 코드 리뷰 시 일관된 아키텍처 원칙을 기준으로 삼을 수 있습니다.
+
+### Adjacent Topics
+- [[마이크로 프론트엔드 (Micro-Frontends)]]
+  - 확장 방향: 단일 저장소(Monorepo) 및 모듈화의 한계를 넘어, 초대형 엔터프라이즈 환경에서 여러 팀이 프론트엔드를 독립적으로 배포하고 운영하기 위한 런타임 통합 아키텍처로 지식을 확장합니다.
+- [[시각적 회귀 테스트 (Visual Regression Testing)]]
+  - 확장 방향: Storybook을 활용한 컴포넌트 고립 개발을 넘어서, Happo, Chromatic 등의 도구를 통해 코드 변경이 UI나 접근성(Accessibility)에 의도치 않은 파괴적 영향을 미쳤는지 자동 검증하는 QA 고도화 영역으로 확장합니다.
+
+---
+*Last updated: 2026-04-30*
\ No newline at end of file
diff --git a/00_Raw/비동기 데이터 관리.md b/00_Raw/비동기 데이터 관리.md
new file mode 100644
index 00000000..a26dcf51
--- /dev/null
+++ b/00_Raw/비동기 데이터 관리.md	
@@ -0,0 +1,63 @@
+# [[비동기 데이터 관리]]
+
+## 📌 Brief Summary
+비동기 데이터 관리(서버 상태 관리)는 API에서 가져온 데이터를 클라이언트 측 애플리케이션 상태와 명확히 분리하여 처리하는 것을 의미합니다 [1]. 이는 네트워크 요청에 따른 데이터 캐싱, 동기화, 로딩 및 에러 사이클 관리를 포함하며, 현대 프론트엔드 시스템 아키텍처의 핵심 요소입니다 [1, 2]. 대규모 앱에서는 RTK Query나 TanStack Query(React Query)와 같은 특화된 도구를 사용하여 비동기 보일러플레이트를 줄이고 효율적인 캐시 관리를 수행합니다 [1, 3, 4].
+
+## 📖 Core Content
+
+*   **서버 상태와 클라이언트 상태의 분리:** 
+    최근 프론트엔드 아키텍처에서 가장 중요한 변화 중 하나는 "서버 상태(Server State)"를 "애플리케이션 상태"와 분리하는 것입니다. API에서 가져오는 데이터는 클라이언트 데이터와 근본적으로 다르며, 캐싱, 동기화, 로딩 및 에러 처리가 반드시 필요합니다 [1]. Zustand와 같이 유연한 상태 관리 라이브러리로 비동기(Async) 작업을 직접 다루게 되면, 팀원마다 콜백, 프로미스, 미들웨어 등 서로 다른 패턴을 사용하여 일관성이 떨어지고 유지보수가 어려워지는 한계가 발생할 수 있습니다 [3, 5].
+
+*   **비동기 데이터 관리 최적화 도구:** 
+    이러한 문제를 해결하기 위해 TanStack Query(React Query)와 RTK Query 같은 라이브러리가 사실상의 표준으로 자리 잡았습니다 [1]. 
+    *   **TanStack Query:** 강력한 캐싱 레이어를 제공하여 불필요한 네트워크 중복 요청을 줄이고 데이터의 최신 상태를 유지합니다. 무한 스크롤(infinite scrolling)이나 낙관적 업데이트(optimistic updates)와 같은 복잡한 비동기 기능을 단순하게 구현할 수 있습니다 [2].
+    *   **RTK Query:** Redux 생태계에서 비동기 작업이 많은 앱을 위해 캐싱, 중복 제거, 자동 데이터 재요청(refetching), 캐시 무효화 기능을 기본으로 제공하여 비동기 보일러플레이트 코드를 사실상 제거합니다 [3, 4].
+
+*   **구조적 분리와 아키텍처:**
+    API 계층은 일반적으로 독립적인 경계로 구성되며, 요청 선언부와 커스텀 훅(Custom Hooks)은 특정 기능(feature) 폴더 내에 함께 배치(colocate)됩니다. 이를 통해 네트워크 관련 비동기 로직을 UI 컴포넌트와 완벽히 디커플링(decoupling)하여 유지보수성을 향상시킵니다 [2].
+
+*   **성능 최적화 및 안정성:**
+    *   **디바운싱과 쓰로틀링:** 사용자 입력(예: 검색)에 의해 트리거되는 값비싼 비동기 API 호출은 디바운싱(debouncing)이나 쓰로틀링(throttling)을 통해 횟수를 제한해야 합니다. 이는 과도한 API 호출을 방지하여 클라이언트 성능을 향상시키고 서버 부하를 줄여줍니다 [6, 7].
+    *   **메모리 누수 방지:** 이벤트 리스너나 구독(subscriptions) 등 정리가 필요한 비동기 사이드 이펙트의 경우, 컴포넌트가 언마운트될 때 리소스를 해제하지 않으면 메모리 누수(memory leaks)가 발생할 수 있습니다. 이를 막기 위해 반드시 `useEffect`에서 클린업(cleanup) 함수를 반환해야 합니다 [8, 9].
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+- [[TanStack Query 및 RTK Query]]
+  - 연결 이유: 서버 상태(API 데이터) 관리에 있어 캐싱, 중복 요청 제거, 자동 재요청 등을 처리하기 위한 현대적인 필수 표준 도구로 소스에서 강조되고 있기 때문입니다 [1, 2, 4].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 비동기 데이터 관리에서 발생하는 보일러플레이트 감소 원리와 데이터 동기화 메커니즘.
+
+- [[서버 상태 (Server State)]]
+  - 연결 이유: API로부터 패치(fetch)되는 데이터는 클라이언트 상태와 성격이 완전히 달라 별도의 관리가 필요하다는 비동기 관리의 핵심 전제이기 때문입니다 [1].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 캐싱 로딩, 에러 사이클, 서버 데이터 최신화 기법.
+
+- [[디바운싱(Debouncing) 및 쓰로틀링(Throttling)]]
+  - 연결 이유: 잦은 사용자 이벤트로 인해 발생하는 무분별한 비동기 API 호출을 제어하여 성능을 최적화하는 구체적인 전략이기 때문입니다 [6, 7].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 프론트엔드에서의 네트워크 최적화 및 런타임 병목 현상 방지.
+
+- [[클린업 (Cleanup) 함수와 메모리 누수]]
+  - 연결 이유: 비동기 작업 완료 전 컴포넌트가 언마운트되었을 때 발생할 수 있는 자원 낭비와 메모리 누수를 막는 필수 규칙이기 때문입니다 [8, 9].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: React 생명주기(Lifecycle)와 결합된 안전한 비동기 처리 방법.
+
+### Deeper Research Questions
+- Zustand와 같은 가벼운 전역 상태 관리 라이브러리로 대규모 비동기 처리를 구현할 때 발생하는 아키텍처적 한계와 파편화 문제는 구체적으로 어떻게 나타나는가? [3, 5]
+- RTK Query가 제공하는 캐시 무효화(cache invalidation) 및 자동 데이터 재요청 기능의 내부 작동 방식은 무엇인가? [4]
+- TanStack Query를 활용하여 무한 스크롤 및 낙관적 업데이트를 구현할 때, 캐시 레이어는 어떻게 무결성을 보장하는가? [2]
+- Feature-Sliced Design 같은 모듈화된 폴더 구조에서 API 선언과 비동기 커스텀 훅은 어떤 방식으로 캡슐화되고 호출되는가? [2]
+- `useEffect` 내의 비동기 호출 시 메모리 누수를 잡기 위한 DevTools Heap Snapshot 분석 방법은 어떻게 적용되는가? [9]
+
+### Practical Application Contexts
+- **Implementation:** UI 컴포넌트 내부에서 비동기 로직을 직접 구현하지 않고, API 요청을 처리하는 네트워크 로직을 커스텀 훅으로 추출하여 `features/` 폴더 하위에 격리하여 구현합니다 [2, 10]. 또한 `useEffect`를 통한 구독 시 클린업 함수를 반드시 적용합니다 [8].
+- **System Design:** 프로젝트 설계 시 클라이언트 전역 상태(예: UI 테마, 언어)와 서버에서 불러오는 비동기 상태(예: 사용자 데이터, 알림)를 완전히 분리하여 각기 다른 도구(Zustand + TanStack Query)를 사용하도록 설계합니다 [1, 11].
+- **Operation / Maintenance:** Redux DevTools와 같은 도구를 활용하여 비동기 액션이 언제 호출되었고 서버 데이터가 어떻게 업데이트되었는지 타임트래블 디버깅(Time-travel debugging)을 진행하여 문제를 신속히 파악합니다 [12, 13].
+- **Learning Path:** 컴포넌트 단위의 `useState`/`useEffect`를 통한 데이터 패칭의 한계 학습 → 디바운싱/메모리 누수 방지 원리 이해 → 서버 상태와 클라이언트 상태의 차이 인지 → TanStack Query/RTK Query를 통한 전문적인 비동기 상태 관리 마스터로 이어집니다 [1, 3, 7, 8].
+- **My Project Relevance:** 실시간 알림, 방대한 데이터의 무한 스크롤, 사용자 검색 시의 자동완성(디바운스 적용) 기능 등 복잡한 API 기반 기능이 있는 프로젝트의 성능 및 아키텍처 개선에 직접 적용됩니다 [2, 6, 7].
+
+### Adjacent Topics
+- [[상태 관리 아키텍처 (State Management Architecture)]]
+  - 확장 방향: 비동기 데이터 관리(서버 상태)와 로컬 상태, 전역 애플리케이션 상태가 애플리케이션 내에서 어떻게 상호작용하고 조화롭게 구성되는지 확장해서 알아봅니다 [1, 14].
+- [[성능 프로파일링 및 렌더링 최적화 (Performance Profiling & Rendering Optimization)]]
+  - 확장 방향: 잘못된 비동기 데이터 처리가 어떻게 불필요한 리렌더링 폭풍(re-render storm)이나 병목을 일으키는지 파악하고, React Profiler를 통해 이를 어떻게 탐지하는지 알아봅니다 [15-17].
+
+---
+*Last updated: 2026-04-30*
\ No newline at end of file
diff --git a/00_Raw/프론트엔드 애플리케이션 렌더링 병목 개선.md b/00_Raw/프론트엔드 애플리케이션 렌더링 병목 개선.md
new file mode 100644
index 00000000..600727cc
--- /dev/null
+++ b/00_Raw/프론트엔드 애플리케이션 렌더링 병목 개선.md	
@@ -0,0 +1,70 @@
+# [[프론트엔드 애플리케이션 렌더링 병목 개선]]
+
+## 📌 Brief Summary
+프론트엔드 애플리케이션 렌더링 병목은 불필요하거나 과도한 컴포넌트 리렌더링으로 인해 UI 반응성이 떨어지고 상호작용 속도가 지연되는 현상을 의미합니다 [1, 2]. 이를 개선하기 위해서는 렌더링 트리거(상태, Props, Context 등)를 식별하고 메모이제이션, 리스트 가상화, 상태 분리, 동시성 렌더링(Concurrent Rendering) 기능 등을 활용해야 합니다 [3, 4]. 지속적인 프로파일링을 통해 렌더링 비용이 높은 부분을 측정하고 전략적으로 최적화를 적용하는 것이 핵심입니다 [5, 6].
+
+## 📖 Core Content
+* **렌더링 발생 원인 파악 및 프로파일링**
+  React 컴포넌트는 상태(State), Props, Context의 값이 변경되거나 부모 컴포넌트가 렌더링될 때 리렌더링됩니다 [4]. 이러한 불필요한 렌더링은 애플리케이션 트리가 깊을 경우 스크립팅 시간을 30~60% 증가시켜 성능을 저하시킬 수 있습니다 [2]. 따라서 React DevTools Profiler나 `why-did-you-render` 같은 도구를 사용해 렌더링 빈도와 비용을 측정한 뒤 최적화를 진행해야 합니다 [5, 7, 8].
+* **메모이제이션(Memoization)과 참조 안정성**
+  `React.memo()`, `useCallback`, `useMemo`를 적절히 활용하면 변경되지 않은 컴포넌트의 리렌더링을 막을 수 있습니다 [9, 10]. 단, JSX 내부에 익명 함수나 인라인 객체를 직접 정의하여 Props로 넘기면 얕은 비교(Shallow comparison) 특성상 매 렌더링마다 새로운 참조가 생성되어 메모이제이션이 무력화되므로 참조를 안정화해야 합니다 [10-12]. 
+* **React Compiler를 통한 자동화**
+  2025년 기준 React Compiler는 빌드 타임에 컴포넌트를 정적으로 분석하여 JSX 요소 단위까지 세밀하게 자동 메모이제이션을 적용합니다 [13, 14]. 이를 통해 수동 메모이제이션의 번거로움을 줄이고 렌더링 오버헤드를 방지할 수 있습니다 [15].
+* **Context API 최적화와 글로벌 상태 분리**
+  Context API는 값이 변할 때 해당 컨텍스트를 구독하는 모든 컴포넌트를 렌더링하는 "브로드캐스트 시스템"으로 작동하여 큰 병목을 유발합니다 [16, 17]. 이를 방지하기 위해 컨텍스트를 작은 도메인 단위로 쪼개거나, Zustand 등 특정 상태 슬라이스(Slice)만 선택적으로 구독(Selector)할 수 있는 가벼운 상태 관리 라이브러리를 사용하여 리렌더링을 제어해야 합니다 [16, 18-20].
+* **동시성 기능(Concurrent Features)의 활용**
+  `useTransition`을 사용해 중요하지 않은 업데이트를 지연시킴으로써 타이핑과 같은 즉각적인 상호작용이 차단되지 않게 하고, `useDeferredValue`로 무거운 파생 데이터의 렌더링을 미루어 UI의 반응성을 부드럽게 개선할 수 있습니다 [21-23].
+* **대규모 데이터 가상화(Virtualization) 및 리스트 최적화**
+  50~100개 이상의 항목이 있는 긴 목록은 다수의 DOM 노드 렌더링을 유발하여 병목을 만듭니다 [24, 25]. `react-window` 등의 라이브러리를 활용해 뷰포트에 보이는 항목만 렌더링하는 윈도윙(Windowing) 기법을 적용하고, 안정적이고 고유한 `key`를 부여하여 불필요한 DOM 재생성을 막아야 합니다 [25-27].
+
+## ⚖️ Trade-offs & Caveats
+* **메모이제이션 오버헤드:** `React.memo()`, `useCallback`, `useMemo`는 남용될 경우 성능을 오히려 악화시킬 수 있습니다 [28, 29]. 이전 Props와 새 Props를 비교하고 메모리를 할당하는 과정에 오버헤드가 발생하기 때문에, 렌더링 비용이 저렴한 컴포넌트에서는 렌더링 자체보다 비교 연산의 비용이 더 클 수 있습니다 [29].
+* **React Compiler의 제약 사항:** React Compiler는 자동 최적화를 제공하지만, 'Rules of React'를 엄격히 준수해야 정상 작동합니다 [30, 31]. 또한 매 렌더링마다 새로운 참조를 반환하는 일부 서드파티 라이브러리 훅(예: TanStack Query의 `useMutation` 등)과 함께 사용하면 메모이제이션 체인이 끊어지는 호환성 문제가 발생할 수 있습니다 [32, 33].
+* **Context API vs 외부 라이브러리 도입:** Context API는 서드파티 라이브러리 추가 없이 테마, 다국어 등 정적 데이터 관리에 용이하지만 [34], 잦은 상태 변경에는 성능 취약점이 있습니다 [35]. 그러나 이를 해결하기 위해 외부 상태 라이브러리(Zustand 등)를 무조건 도입하면 추가적인 번들 용량 증가 및 팀의 학습 곡선이 수반된다는 반대 급부가 있습니다 [36, 37].
+* **익명 함수 제거에 따른 코드 복잡도 증가:** 불필요한 리렌더링을 막고자 모든 인라인 함수를 외부로 빼거나 `useCallback`으로 감싸면 코드가 길어지고 가독성이 떨어질 수 있습니다 [38]. 컴포넌트가 작고 성능 영향이 없는 경우에는 익명 함수 사용이 실용적일 수 있습니다 [38].
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+
+#### [아키텍처/기반 기술]
+- [[Context API]]
+  - 연결 이유: 컴포넌트 트리 깊은 곳까지 상태를 전달할 수 있으나 구독 중인 모든 컴포넌트를 리렌더링시키는 특성상 렌더링 병목의 주요 원인이 됩니다 [17].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 브로드캐스트 기반 상태 관리의 한계와 리렌더링 발생 범위를 이해할 수 있습니다.
+- [[Concurrent Rendering]]
+  - 연결 이유: 렌더링 작업의 우선순위를 부여하고 중단/재개할 수 있는 기술로, `useTransition` 등을 통해 무거운 렌더링이 메인 스레드를 막는 병목 현상을 방지합니다 [21].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 반응성 지표(INP 등)를 개선하기 위한 렌더링 스케줄링 메커니즘을 이해할 수 있습니다.
+- [[React Compiler]]
+  - 연결 이유: 수동 메모이제이션의 한계를 극복하고 빌드 타임에 자동으로 JSX 요소 단위의 메모이제이션을 적용하여 렌더링 최적화를 달성합니다 [13, 14].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 최신 React의 렌더링 최적화가 런타임 제어에서 컴파일러 기반 정적 분석으로 넘어가는 기술적 진화를 이해할 수 있습니다.
+
+#### [구현/활용 도구]
+- [[Zustand]]
+  - 연결 이유: 셀렉터(Selector) 기능을 활용해 컴포넌트가 자신이 필요한 상태 조각(Slice)이 변경될 때만 리렌더링되도록 보장하여 병목을 줄이는 상태 관리 도구입니다 [18].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 전역 상태의 파편화 관리와 불필요한 리렌더링을 차단하는 구독 최적화 패턴을 학습할 수 있습니다.
+- [[List Virtualization (Windowing)]]
+  - 연결 이유: 대규모 리스트에서 사용자의 화면 뷰포트에 존재하는 DOM 노드만 제한적으로 렌더링하여 DOM 트리 비대화를 막습니다 [25, 26].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 다수의 데이터를 렌더링할 때 발생하는 메모리 및 레이아웃 페인팅 병목을 제어하는 원리를 이해할 수 있습니다.
+
+### Deeper Research Questions
+- React Compiler는 빌드 타임에 명시적인 의존성 배열 없이 어떻게 내부 JSX 노드별 캐싱 및 메모이제이션 단위를 결정하는가?
+- Context API의 브로드캐스트 리렌더링 문제를 해결하는 `use-context-selector`의 원리는 무엇이며, Zustand의 구독 최적화 방식과 구조적으로 어떻게 다른가?
+- `useTransition`과 `useDeferredValue`를 결합하여 사용할 때, 브라우저의 페인트 주기(Paint Cycle) 관점에서 컴포넌트 렌더링은 어떻게 스케줄링 및 지연되는가?
+- 대형 데이터를 처리할 때 List Virtualization과 함께 사용하는 스크롤 이벤트 디바운싱(Debouncing) 혹은 쓰로틀링(Throttling) 최적화의 기술적 한계점은 무엇인가?
+- 상태 관리 아키텍처 관점에서, Feature-Sliced Design(FSD)과 같이 횡단 관심사를 분리하는 폴더 및 구조적 설계가 애플리케이션의 리렌더링 범위를 제한하는 데 어떻게 기여하는가?
+
+### Practical Application Contexts
+- **Implementation:** Props로 전달하는 함수나 객체는 익명 생성(인라인)을 지양하고 `useCallback`이나 외부 선언으로 분리하여 참조 무결성을 유지합니다. 수백 개 이상의 항목을 렌더링할 경우 `react-window`와 같은 가상화 라이브러리를 의무적으로 도입합니다.
+- **System Design:** 빈번히 업데이트되는 상태(예: 알림 개수, 장바구니)는 Context API 대신 Zustand 등의 선택적 구독이 가능한 스토어에 배치하고, 정적 데이터(테마 등)는 Context를 활용하여 렌더링 전파 범위를 시스템 레벨에서 격리합니다.
+- **Operation / Maintenance:** `why-did-you-render` 패키지와 React DevTools의 Profiler 패널을 이용해 개발 과정에서 불필요하게 반복 렌더링되는 컴포넌트를 찾아내고, 프로덕션 환경에서는 Core Web Vitals(INP, FCP 등)를 추적하여 상호작용 지연이 있는지 모니터링합니다.
+- **Learning Path:** React의 렌더링 조건(State, Props, Parent) 이해 -> 수동 메모이제이션 도구 숙달 -> Context API의 성능 한계 체감 및 Zustand 활용 -> Concurrent Features 적용 -> React Compiler를 이용한 자동화 흐름으로 렌더링 최적화 지식을 확장합니다.
+- **My Project Relevance:** 현재 유지 보수하거나 신규 구축하는 React 웹 앱에서 스크롤 끊김이나 클릭 시 반응 지연이 발생할 때, 해당 개념을 기반으로 병목이 되는 컴포넌트의 렌더링 횟수를 측정하고 적절한 최적화 도구를 즉각 적용할 수 있습니다.
+
+### Adjacent Topics
+- [[Server Components (Next.js)]]
+  - 확장 방향: 브라우저에서의 렌더링 부하를 줄이기 위해 클라이언트 자바스크립트 번들을 최소화하고 서버에서 정적 UI를 렌더링하여 넘겨주는 아키텍처적 최적화에 대해 심도 있게 조사할 수 있습니다 [39-41].
+- [[JavaScript Memory Leaks]]
+  - 확장 방향: 과도한 렌더링 외에도 클로저나 분리된 DOM 노드에 의해 자바스크립트 메모리가 해제되지 않고 누적되어 성능 저하를 일으키는 메모리 누수 식별 및 해결 방법으로 이해를 확장합니다 [42-44].
+
+---
+*Last updated: 2026-04-30*
\ No newline at end of file
diff --git a/10_Wiki/Development/Code Splitting.md b/10_Wiki/Development/Code Splitting.md
new file mode 100644
index 00000000..96aa31b1
--- /dev/null
+++ b/10_Wiki/Development/Code Splitting.md	
@@ -0,0 +1,58 @@
+# [[Code Splitting]]
+
+## 📌 Brief Summary
+큰 자바스크립트 번들을 더 작은 청크(chunk) 단위로 나누어 사용자가 필요로 할 때(on demand) 로드하는 프로세스입니다 [1, 2]. 모든 애플리케이션 코드를 초기에 한 번에 다운로드하는 대신, 필요한 파일만 먼저 불러오게 하여 초기 번들 크기를 극적으로 줄일 수 있습니다 [2, 3]. 결과적으로 초기 페이지 로드 속도를 향상시키고, 애플리케이션의 체감 성능을 개선하는 핵심적인 프론트엔드 최적화 기법입니다 [1, 4].
+
+## 📖 Core Content
+* **라우트 기반 분할 (Route-level Code Splitting):** 가장 일반적이고 효과적인 접근 방식입니다. 사용자가 특정 라우트로 이동할 때만 해당 페이지의 코드를 다운로드하도록 하여 초기 로딩 시 불필요한 코드 다운로드를 방지합니다 [1, 2, 5].
+* **컴포넌트 수준 지연 로딩 (Component-level Lazy Loading):** 차트, 지도, 리치 텍스트 에디터처럼 크고 무거운 컴포넌트나 드물게 사용되는 모달, 설정 패널 등을 렌더링이 필요한 시점에만 로드하도록 분리합니다 [6, 7]. React에서는 `React.lazy()`와 동적 임포트(dynamic imports), 그리고 `<Suspense>`를 활용해 이를 쉽게 구현할 수 있습니다 [4, 6, 8].
+* **벤더 라이브러리 분할 (Vendor Splitting):** Vite(내부적으로 Rollup 사용) 등의 번들러를 사용할 때 `manualChunks` 옵션을 통해 React 코어 라이브러리나 차트 등 무거운 벤더 코드를 별도의 파일로 분할합니다 [5, 9, 10]. 벤더 라이브러리는 자주 변경되지 않기 때문에 브라우저 캐싱 효율을 극대화할 수 있습니다 [5, 11].
+* **번들러의 자동화 지원:** 최신 번들러(Webpack, Vite)는 코드 내에 작성된 동적 임포트(`import()`)를 감지하면 자동으로 해당 코드를 별도의 청크로 분리합니다 [4, 6].
+
+## ⚖️ Trade-offs & Caveats
+* **필수 컴포넌트에 대한 오남용 금지:** 페이지에 즉시 필요한 스크롤 없이 볼 수 있는(above-the-fold) 핵심 컴포넌트나, 렌더링 속도가 빨라야 하는 요소에는 지연 로딩과 코드 분할을 피해야 합니다 [7]. 오히려 첫 화면을 그리는 시간을 지연시킬 수 있습니다.
+* **사용자 경험 저하 방지 (Fallback UI 필요):** 코드를 동적으로 불러오는 동안 네트워크 지연이 발생할 수 있습니다. 따라서 `<Suspense>`를 사용해 모듈이 로드되는 동안 스피너나 스켈레톤과 같은 Fallback UI를 제공해야 합니다 [5, 8]. 
+* **네트워크 요청 증가의 위험:** 너무 잘게 코드를 분할하면 오히려 수많은 네트워크 요청이 발생해 오버헤드가 발생할 수 있습니다. 따라서 번들 크기를 시각적으로 분석할 수 있는 `rollup-plugin-visualizer` 등의 도구를 사용해 500kB 이상의 큰 청크를 타겟으로 식별하고 적절하게 분할해야 합니다 [12, 13].
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+
+#### [아키텍처/기반 기술]
+- [[Lazy Loading]]
+  - 연결 이유: 코드 분할이 번들을 쪼개는 행위라면, 지연 로딩(Lazy Loading)은 그 쪼개진 코드를 필요 시점에 로드하는 기술적 방법론입니다 [2, 3].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 분할된 코드가 언제 브라우저로 전송되고 애플리케이션에 병합되는지 이해할 수 있습니다 [8].
+- [[Core Web Vitals]]
+  - 연결 이유: 코드 분할을 적용하는 주된 성능적 목적은 초기 자바스크립트 실행을 최소화하여 LCP(Largest Contentful Paint)와 INP(Interaction to Next Paint) 같은 핵심 웹 지표를 향상시키는 데 있습니다 [1, 8, 14].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 최적화 결과가 실제 사용자의 체감 성능 및 페이지 측정 지표에 어떻게 긍정적 영향을 주는지 평가할 수 있습니다 [15].
+
+#### [구현/활용 도구]
+- [[React.lazy() and Suspense]]
+  - 연결 이유: React 애플리케이션에서 컴포넌트 레벨 및 라우트 레벨의 동적 코드 분할을 구현하기 위해 사용하는 공식 API입니다 [6, 8].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 동적 임포트 처리 과정에서의 비동기 UI 렌더링 흐름과 예외(지연) 처리 방식을 배울 수 있습니다 [5].
+- [[Vite (Rollup)]]
+  - 연결 이유: 개발 및 프로덕션 환경에서 자바스크립트 애플리케이션을 번들링하고 실제 물리적인 청크 파일들로 분리해 내는 도구입니다 [9, 11].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 번들러의 `manualChunks` 설정을 통해 어떻게 벤더 라이브러리와 애플리케이션 코드를 효율적으로 나누어 브라우저 캐싱을 활용할 수 있는지 이해할 수 있습니다 [5].
+
+### Deeper Research Questions
+- 라우트 기반 분할과 컴포넌트 기반 분할을 어느 정도 비율로 적용해야 초기 렌더링 성능과 이후 탐색 시의 네트워크 지연 간의 균형을 이룰 수 있는가?
+- Vite나 Webpack 환경에서 `manualChunks`를 설정할 때, 브라우저의 HTTP/2 및 HTTP/3 다중화(multiplexing) 환경을 고려한 가장 이상적인 청크 개수와 크기는 무엇인가?
+- 동적 청크(chunk)를 로드하는 도중 사용자의 네트워크 연결이 끊기거나 에러가 발생할 경우, React Error Boundaries와 결합하여 어떻게 안정적인 Fallback 경험을 설계할 것인가?
+- 코드 분할로 인해 컴포넌트가 지연 로드될 때, 해당 컴포넌트가 의존하는 상태(Context, Zustand 등)는 로드 시점에 어떻게 동기화되는가?
+- Above-the-fold UI에 잘못 지연 로딩을 적용했을 때 LCP 점수에 미치는 악영향을 확인하려면 브라우저 개발자 도구의 성능(Performance) 패널에서 어떤 지표를 중점적으로 모니터링해야 하는가?
+
+### Practical Application Contexts
+- **Implementation:** React 코드에서 `import { Chart } from 'chart.js'`와 같은 정적 임포트를 제거하고, `const HeavyComponent = React.lazy(() => import('./HeavyComponent'))`로 감싸서 특정 버튼이 눌리거나 라우트가 전환될 때 렌더링되게 구현합니다 [4, 6, 8].
+- **System Design:** 아키텍처 설계 시, 모든 코드가 포함된 하나의 `index.js` 모놀리스 번들 대신, Vite의 `vite.config.ts`에서 `manualChunks` 설정을 통해 React 코어 및 무거운 서드파티 라이브러리를 별개의 캐싱 가능한 청크로 분리하도록 설계합니다 [5, 10].
+- **Operation / Maintenance:** CI/CD 파이프라인이나 로컬 빌드 과정에 `rollup-plugin-visualizer` 등의 번들 분석 도구를 연결하여 시각적 트리맵을 확인하고, 500kB를 초과하는 거대 청크가 발견되면 추가적인 분할 대상을 식별하여 최적화합니다 [4, 12, 13].
+- **Learning Path:** 우선 React의 번들링 개념을 이해한 후, 동적 임포트 구문 활용 -> `React.lazy()` 및 `<Suspense>` 적용 -> 라우터에 코드 분할 결합 -> 번들 분석기 및 Core Web Vitals 측정을 통한 효과 검증 순서로 지식을 확장합니다 [6, 8].
+- **My Project Relevance:** 프로젝트 규모가 커짐에 따라 메인 자바스크립트 번들이 수 메가바이트 단위로 무거워져 모바일 기기 등에서 로딩 속도 저하 현상이 보일 경우, 즉각적으로 라우트 기반 코드 분할과 차트/에디터 등 무거운 UI의 지연 로딩을 도입하여 LCP 문제를 해결할 수 있습니다 [3, 14, 16].
+
+### Adjacent Topics
+- [[Tree Shaking]]
+  - 확장 방향: 코드 분할이 필요한 코드를 '쪼개어' 가져오는 방식이라면, 트리 쉐이킹은 사용되지 않는 죽은 코드(Dead Code) 자체를 번들에서 '제거'하여 초기 번들 크기를 줄이는 상호 보완적인 최적화 기법입니다 [17, 18].
+- [[Server Components (Next.js)]]
+  - 확장 방향: 클라이언트 사이드의 코드 분할에서 더 나아가, 아예 정적인 UI 렌더링을 서버에서 처리하여 클라이언트로 보내는 자바스크립트 번들의 양 자체를 획기적으로 줄이거나 제거하는 최신 아키텍처 접근법입니다 [19-21].
+
+---
+*Last updated: 2026-04-30*
\ No newline at end of file
diff --git a/10_Wiki/Development/Concurrent Features.md b/10_Wiki/Development/Concurrent Features.md
new file mode 100644
index 00000000..2c5c54ed
--- /dev/null
+++ b/10_Wiki/Development/Concurrent Features.md	
@@ -0,0 +1,56 @@
+# [[Concurrent Features]]
+
+## 📌 Brief Summary
+Concurrent Features는 React 18부터 도입된 기능으로, 렌더링 작업을 일시 중지(pause), 중단(interrupt), 재개(resume)할 수 있게 해주는 기능입니다 [1]. 이를 통해 중요한 사용자 상호작용(클릭, 타이핑 등)의 우선순위를 높이고, 상대적으로 느린 업데이트(대용량 필터링 등)를 지연시킬 수 있습니다 [1]. 결과적으로 앱의 실제 연산 속도 자체를 마법처럼 빠르게 만드는 것은 아니지만, 인지되는 속도(perceived speed)를 최적화하여 사용자 인터페이스를 반응성 있게 유지합니다 [2].
+
+## 📖 Core Content
+*   **동시성 렌더링(Concurrent Rendering)의 원리:** 최신 버전의 React에서 기본적으로 동작하는 방식으로, 렌더링 작업의 우선순위를 지정하여 중요도가 높은 상호작용이 렌더링에 의해 차단(block)되지 않고 즉시 반응하도록 돕습니다 [1].
+*   **`useTransition`을 통한 우선순위 제어:** 특정 상태 업데이트를 '긴급하지 않은(non-urgent)' 것으로 표시하여 지연시키는 훅(Hook)입니다 [3]. 실시간 검색 결과나 대용량 데이터 필터링 시, 사용자의 타이핑 같은 입력은 즉각적으로 반응하게 하면서 무거운 렌더링 처리는 뒤로 미룰 수 있습니다 [3]. 또한 `isPending` 상태를 활용해 입력 즉각성을 막지 않고 로딩 스피너나 스켈레톤 UI를 표시할 수도 있습니다 [3].
+*   **`useDeferredValue`를 통한 값 참조 지연:** `useTransition`이 업데이트를 언제 발생시킬지를 관리한다면, `useDeferredValue`는 무거운 값을 언제 '읽을지'를 제어합니다 [4]. 입력과 같은 UI 변경은 즉시 반영하면서, 파생되는 무거운 로직 적용은 살짝 지연시켜 실시간 폼(form) 등에서 발생하는 끊김 현상(jank)을 줄여줍니다 [4].
+*   **프레임워크 지원 환경:** 2025년 기준 Next.js(App Router), Remix, Vite + React 18+ 환경 등 대부분의 풀스택 및 번들러 프레임워크에서 기본적으로 동시성 렌더링 기능이 통합되어 지원됩니다 [2].
+
+## ⚖️ Trade-offs & Caveats
+*   **성능 향상의 본질적 한계:** 이 기능들은 앱의 실제 연산 속도를 물리적으로 높여주는 것이 아니라 "인지되는 속도(perceived speed)"를 우선시하는 기능입니다 [2]. 백그라운드 작업이 계속 진행되는 동안 UI의 반응성을 유지할 뿐, 실행해야 할 연산량 자체가 줄어드는 것은 아닙니다 [2].
+*   **선별적 사용 요구:** 모든 컴포넌트에 전역적으로 사용해서는 안 되며, 주로 '상호작용이 많은 뷰(interactive views)'에 선별적으로 적용해야 합니다 [4]. 
+*   **호환성 문제:** 렌더링을 차단하는(render-blocking) 구식 패턴(가드가 없는 클래스 컴포넌트 등)이나 오래된 상태 관리 라이브러리와 섞어서 사용하면 정상적으로 동작하지 않거나 성능 문제를 야기할 수 있습니다 [4].
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+
+#### [관계 유형 A: 아키텍처/기반 기술]
+- [[useTransition]]
+  - 연결 이유: 상태 업데이트를 긴급하지 않은 것으로 표시하여 지연시킬 수 있는 Concurrent Feature의 핵심 요소입니다 [3].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: React가 렌더링 우선순위를 조정하여 사용자 입력 반응성을 잃지 않게 유지하는 구체적인 메커니즘.
+
+- [[useDeferredValue]]
+  - 연결 이유: 비용이 큰 파생 데이터의 렌더링 반영 시점을 지연시켜 UI 끊김을 막는 또 다른 주요 요소입니다 [4].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 상태의 업데이트 시점이 아닌, 계산된 값을 읽어 들이는 시점을 분리하는 최적화 전략.
+
+#### [관계 유형 B: 구현/활용 도구]
+- [[Suspense]]
+  - 연결 이유: Concurrent Feature(특히 `useTransition`)와 결합하여 무거운 렌더링이나 데이터가 로드되는 동안 Fallback UI를 유연하게 표시하는 데 사용됩니다 [4].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 비동기 로딩 상태에서 사용자 경험(UX)을 부드럽게 설계하는 선언적 UI 패턴.
+
+### Deeper Research Questions
+- Concurrent Rendering이 동작할 때 브라우저의 메인 스레드는 내부적으로 어떻게 작업을 일시 중지하고 재개(pause, interrupt, resume)하는가?
+- `useTransition`과 `useDeferredValue`는 구체적으로 어떤 상황에서 각각 선택적으로 사용되어야 하며, 두 가지를 함께 사용할 때 발생하는 제약 사항은 없는가?
+- 구식 상태 관리 라이브러리(outdated state libraries)가 Concurrent Features와 섞였을 때 충돌이 발생하는 기술적 원리는 무엇인가?
+- 인지되는 속도(perceived speed)를 개선하기 위해 Concurrent 기능을 과도하게 사용했을 때 발생하는 메모리나 스케줄링 오버헤드는 어느 정도인가?
+- Next.js나 Remix 같은 최신 프레임워크는 내부적으로 Concurrent Features를 어떻게 활용하여 스트리밍(streaming) 업데이트와 같은 성능 향상을 이끌어내는가?
+
+### Practical Application Contexts
+- **Implementation:** 실시간 검색창, 타입어헤드(Typeahead) 입력기, 복잡한 데이터 그리드 필터링 등 사용자 입력이 발생할 때마다 무거운 UI를 다시 그려야 하는 곳에 구현하여 입력이 버벅이지 않도록 만듭니다 [3, 4].
+- **System Design:** 사용자의 즉각적인 피드백이 필요한 뷰와, 백그라운드에서 지연 렌더링되어도 무방한 컴포넌트를 분리하여 시스템 구조 및 우선순위를 기획합니다 [4].
+- **Operation / Maintenance:** 애플리케이션 프로파일링 중 입력 지연(Input Lag)이 빈번하게 보고되는 부분을 찾아내고, 해당 부분에 렌더링 차단 패턴이 없는지 점검하여 Concurrent 기능을 점진적으로 도입합니다 [4, 5].
+- **Learning Path:** 단순한 React Hook(`useState`, `useEffect`)의 렌더링 과정을 이해한 후, 메모이제이션 최적화(`React.memo`, `useCallback`)를 배우고, 최종적으로 렌더링의 우선순위를 제어하는 고급 최적화 과정으로 Concurrent 기능을 학습합니다.
+- **My Project Relevance:** 검색 필터가 많은 대시보드나 실시간 데이터 시각화 차트를 구축할 때 UI 스레드가 멈추는 것을 방지하여 사용자 경험을 크게 개선하는 데 직접적으로 적용될 수 있습니다.
+
+### Adjacent Topics
+- [[Server Components]]
+  - 확장 방향: 클라이언트에서 렌더링을 지연시키거나 최적화하는 것을 넘어, 무거운 렌더링 작업 자체를 서버로 완전히 옮겨 클라이언트의 자바스크립트 번들 크기와 실행 부담을 근본적으로 줄이는 방법론 탐구 [6, 7].
+- [[Code Splitting & Lazy Loading]]
+  - 확장 방향: 화면의 렌더링 과정을 매끄럽게 하는 것을 넘어, 초기 애플리케이션 로딩 시 네트워크를 통해 다운로드하는 코드의 양 자체를 분할하여 초기 응답성(Time to Interactive)을 향상시키는 전략 탐구 [8, 9].
+
+---
+*Last updated: 2026-04-30*
\ No newline at end of file
diff --git a/10_Wiki/Development/Concurrent Rendering in React 18+.md b/10_Wiki/Development/Concurrent Rendering in React 18+.md
new file mode 100644
index 00000000..b20eeb11
--- /dev/null
+++ b/10_Wiki/Development/Concurrent Rendering in React 18+.md	
@@ -0,0 +1,62 @@
+# [[Concurrent Rendering in React 18+]]
+
+## 📌 Brief Summary
+React 18+의 동시성 렌더링(Concurrent Rendering)은 React가 렌더링 작업을 일시 중지, 중단 및 재개할 수 있도록 하는 강력한 기능입니다 [1]. 이를 통해 개발자는 업데이트 발생 시기와 방식을 세밀하게 제어할 수 있으며, 사용자의 상호작용성을 저하시키지 않으면서도 화면이 멈추지 않는 더 부드럽고 반응성 높은 애플리케이션을 구축할 수 있습니다 [1, 2].
+
+## 📖 Core Content
+
+**동시성 렌더링의 개념과 이점**
+*   React 18부터 도입된 동시성 기능은 렌더링 작업의 우선순위를 동적으로 지정할 수 있게 해줍니다. 렌더링 작업을 차단하지 않고, 느린 데이터 필터링 업데이트 등을 지연시키는 동시에 클릭이나 타이핑과 같은 중요한 사용자 상호작용에 즉각적으로 반응하도록 렌더링을 일시 중지하거나 재개할 수 있습니다 [1]. 이는 최신 React 버전의 기본 동작으로 내장되어 있습니다 [1].
+
+**주요 동시성 훅(Hooks)**
+*   **`useTransition`:** 특정 상태 업데이트를 '긴급하지 않은(non-urgent)' 것으로 표시하여 지연시킬 수 있는 훅입니다 [3]. 실시간 검색 결과 표시, 대규모 데이터 세트 필터링, 복잡한 차트 및 테이블 렌더링과 같은 무거운 작업이 사용자의 즉각적인 상호작용을 차단하지 못하게 합니다 [3]. 제공되는 `isPending` 상태를 활용하여 메인 스레드를 차단하지 않고 로딩 스피너나 스켈레톤 UI를 표시할 수 있습니다 [3].
+*   **`useDeferredValue`:** `useTransition`이 업데이트를 트리거하는 시점을 제어한다면, `useDeferredValue`는 비용이 많이 드는 값을 *읽고 적용하는 시점*을 지연시킵니다 [4]. 검색창의 입력 값 등 UI 변경 사항은 즉시 반영하면서, 파생되는 무거운 계산 로직은 약간 지연시켜 실시간 폼이나 인터페이스에서의 화면 끊김(Jank) 현상을 줄여줍니다 [4].
+
+**사용 모범 사례 및 프레임워크 지원**
+*   동시성 기능은 앱의 모든 곳이 아닌 '상호작용이 집중된 뷰'에 전략적으로 사용해야 합니다 [4]. 데이터가 로드되는 동안 대체 UI를 자연스럽게 보여주기 위해 `Suspense`와 결합하는 것이 권장됩니다 [4]. 
+*   주의할 점은 구식 상태 관리 라이브러리나 렌더링을 차단하는 패턴(예: 가드 로직이 없는 오래된 클래스 컴포넌트)과 혼용해서는 안 된다는 것입니다 [4]. 
+*   이러한 기능들은 연산 속도 자체를 물리적으로 높이는 것이 아니라, 백그라운드에서 작업이 계속되는 동안 UI가 반응하도록 유지함으로써 '체감 속도(perceived speed)'를 우선시하는 도구입니다 [4].
+*   2025년 기준 Next.js(App Router), Remix, Vite + React 18 등 대부분의 최신 풀스택 프레임워크는 기본적으로 이 동시성 렌더링을 완전히 통합하여 지원하고 있습니다 [5].
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+
+- [[useTransition]]
+  - 연결 이유: 동시성 렌더링 환경에서 특정 상태 업데이트를 '긴급하지 않은 작업'으로 명시적으로 분류하기 위해 사용되는 핵심 훅입니다 [3].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 상태 업데이트의 우선순위를 낮추어 사용자 입력에 대한 메인 스레드 차단을 방지하는 구체적인 제어 방법.
+
+- [[useDeferredValue]]
+  - 연결 이유: 연산 비용이 높은 값의 화면 적용 시점을 늦추어 UI의 즉각적인 체감 반응성을 향상시키는 동시성 기능이기 때문입니다 [4].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 사용자 입력(타이핑 등)의 즉각적인 반영과 무거운 파생 데이터 렌더링 간의 처리 시점을 분리하는 메커니즘.
+
+- [[Suspense]]
+  - 연결 이유: 동시성 훅(`useTransition` 등)과 결합하여 비동기 처리나 지연된 렌더링이 완료되기 전까지 자연스러운 대체 UI(Fallback UI)를 표시하는 역할을 합니다 [4].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 비동기 데이터 로딩 과정에서 동시성 렌더링을 활용한 부드러운 사용자 경험(UX) 설계 방식.
+
+### Deeper Research Questions
+
+- React의 동시성 렌더링 엔진은 내부적으로 긴급 업데이트와 지연 업데이트의 우선순위를 어떤 스케줄링 알고리즘으로 관리하는가?
+- `useTransition`과 `useDeferredValue`를 복잡한 단일 컴포넌트 내에서 함께 사용할 때 발생할 수 있는 렌더링 엣지 케이스나 성능적 트레이드오프는 무엇인가?
+- 구식 상태 관리 라이브러리(Context API를 잘못 사용하는 경우 등)가 React 18의 동시성 렌더링 패턴을 방해할 때 발생하는 정확한 기술적 원리(예: Tearing 현상)는 무엇인가?
+- 동시성 렌더링의 도입이 브라우저의 INP(Interaction to Next Paint)와 TBT(Total Blocking Time) 지표 최적화에 수학적으로 어떤 연관성을 가지는가?
+- 동시성 렌더링으로 인해 렌더링 트리가 중단(Interrupt)되고 폐기된 후 다시 시작될 때, 불필요한 메모리 누수를 방지하기 위한 React의 내부 최적화 메커니즘은 무엇인가?
+
+### Practical Application Contexts
+
+- **Implementation:** 라이브 검색 결과창, 대규모 데이터 세트 필터링 기능 구현 시 `useTransition`과 `useDeferredValue`를 적극 활용하여 입력 중 발생하는 화면 멈춤(Jank) 방지 [3, 4].
+- **System Design:** 아키텍처 설계 시 기본적으로 동시성 렌더링이 활성화된 Next.js App Router나 Remix와 같은 최신 React 프레임워크를 도입하여 반응성 이점을 극대화 [5].
+- **Operation / Maintenance:** 기존 레거시 코드베이스에서 렌더링을 차단하는 요소(오래된 클래스 컴포넌트 등)를 리팩토링하고, 동시성 기능이 충돌 없이 작동할 수 있도록 유지보수 환경 개선 [4].
+- **Learning Path:** 전통적인 '동기적 렌더링(Synchronous Rendering)' 모델이 가진 한계를 벗어나, 작업 단위의 일시 중지와 재개가 가능한 렌더링 패러다임으로 개발자의 사고 방식을 전환.
+- **My Project Relevance:** 현재 진행 중인 서비스 내 무거운 대시보드 화면이나 복잡한 검색 인터페이스에서 사용자가 직접 체감하는 '인식 속도(Perceived Speed)'를 최적화하는 아키텍처 개선 지표로 활용 [3, 4].
+
+### Adjacent Topics
+
+- [[React Server Components]]
+  - 확장 방향: 동시성 렌더링과 함께 Next.js App Router 환경의 핵심 성능 최적화 축을 이루며, 클라이언트 측 자바스크립트 번들을 획기적으로 줄여주는 서버 컴포넌트의 렌더링 원리 탐구 [5, 6].
+
+- [[Core Web Vitals (INP/TBT)]]
+  - 확장 방향: 동시성 렌더링 기능 적용이 웹의 핵심 반응성 지표인 INP 및 TBT를 어떻게 개선하는지 실제 성능 측정 툴(Chrome DevTools, Lighthouse) 데이터와 연계하여 조사 [7-9].
+
+---
+*Last updated: 2026-04-30*
\ No newline at end of file
diff --git a/10_Wiki/Development/Context API.md b/10_Wiki/Development/Context API.md
new file mode 100644
index 00000000..b0dfba57
--- /dev/null
+++ b/10_Wiki/Development/Context API.md	
@@ -0,0 +1,46 @@
+# [[Context API]]
+
+## 📌 Brief Summary
+Context API는 React에 내장된 상태 공유 솔루션으로, 컴포넌트 트리의 모든 레벨을 통해 명시적으로 props를 전달하지 않고도 데이터를 전송할 수 있게 해주는 기능입니다 [1, 2]. 이는 독립적인 상태 관리 도구라기보다는 데이터를 전달하는 브로드캐스트 전송 메커니즘에 가깝습니다 [3, 4]. 주로 테마, 다국어 설정 등 변경이 거의 없는 정적인 데이터를 전역적으로 공유할 때 적합하게 사용됩니다 [5, 6].
+
+## 📖 Core Content
+* **작동 방식 및 구조:** Context API는 `React.createContext()`를 호출하여 생성되며, 상태 값을 제공하는 `Provider`와 데이터를 읽는 `Consumer`(실무에서는 주로 `useContext` 훅)로 구성됩니다 [4]. Provider는 값을 브로드캐스트하고, 트리의 어느 깊이에 있든 `useContext`를 호출하여 해당 값을 읽을 수 있습니다 [4]. 단, 상태 자체를 관리하려면 `useState`나 `useReducer`와 같은 훅과 반드시 함께 사용해야 합니다 [4, 7].
+* **성능적 한계와 리렌더링 폭포:** Context의 가장 큰 단점은 성능 관리입니다 [8]. Context로 전달되는 값 중 일부만 변경되더라도, 해당 Context를 구독하는 **모든 컴포넌트가 리렌더링**됩니다 [8, 9]. React는 특정 데이터 부분만 사용하는 컴포넌트를 구별해 내지 못하므로, 상태 변경이 잦은 대규모 애플리케이션에서는 전체 대시보드가 수 초간 멈추는 등 심각한 성능 병목을 초래할 수 있습니다 [1, 10].
+* **구조적 최적화 전략:** 이러한 리렌더링 문제를 피하기 위해 애플리케이션의 모든 상태를 하나의 'Global Context'에 담는 안티 패턴을 피해야 합니다 [11, 12]. 대신 `ThemeContext`, `NotificationContext`처럼 상태를 여러 개의 작은 도메인별 Context로 분리하고, 커스텀 훅과 Selector 패턴을 활용해 필요한 값만 스코프를 좁혀 사용하는 것이 권장됩니다 [12, 13].
+* **사용의 적합성:** 테마(라이트/다크 모드), 언어 환경 설정, 기능 플래그 등 **변경 빈도가 매우 낮고 정적인 데이터**를 공유하거나 외부 종속성을 추가하고 싶지 않은 작은 프로젝트 및 라이브러리 개발에 완벽한 선택입니다 [5, 6, 14]. 반면, 실시간 데이터, 자주 업데이트되는 장바구니, 복잡한 비동기 작업이 필요한 경우에는 Context를 피하고 Zustand나 Redux를 사용하는 것이 좋습니다 [15-18].
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+- [[Prop Drilling]]
+  - 연결 이유: 부모 컴포넌트에서 깊게 중첩된 자식 컴포넌트로 데이터를 전달하기 위해 불필요한 중간 컴포넌트들을 거쳐야 하는 패턴입니다 [2]. 
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: Context API가 탄생하게 된 근본적인 배경과, 데이터를 어떻게 트리 아래로 "건너뛰어" 전달하는지 그 목적을 이해할 수 있습니다 [2, 19].
+- [[useContext]]
+  - 연결 이유: Context API의 Provider가 제공하는 브로드캐스트 값을 읽기 위해 개별 컴포넌트 내부에서 호출하는 React의 내장 훅입니다 [4].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 구독(Subscription)이 발생하는 정확한 지점과, 값이 변경될 때 어떤 컴포넌트에서 리렌더링이 트리거되는지 렌더링 동작 원리를 파악할 수 있습니다 [8].
+- [[Zustand]]
+  - 연결 이유: Context API의 리렌더링 한계와 보일러플레이트를 극복하기 위해 자주 비교되고 채택되는 경량 상태 관리 라이브러리입니다 [20, 21].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: Zustand의 'Selector 패턴'이 어떻게 특정 상태 슬라이스만 구독하게 하여 Context API의 "전체 리렌더링" 문제를 해결하는지 성능 최적화의 차이를 비교할 수 있습니다 [8, 10].
+
+### Deeper Research Questions
+- Context API와 외부 상태 관리 라이브러리(Zustand, Redux)를 동일한 애플리케이션 내에서 효율적으로 혼용(Hybrid)하기 위해, 정적 상태와 동적 상태를 분리하는 최적의 아키텍처 설계 기준은 무엇인가?
+- Context API의 "브로드캐스트" 특성으로 인한 불필요한 리렌더링을 방지하기 위해 도메인별로 Context를 쪼갤 때, 코드의 유지보수성을 잃지 않으면서도 성능을 잡을 수 있는 적절한 분리 입도(Granularity)는 어느 정도인가?
+- `use-context-selector`와 같은 외부 라이브러리를 사용하여 Context API의 리렌더링 문제를 우회하는 방식은, 처음부터 Zustand나 Redux를 도입하는 것과 비교하여 도입 비용 및 장기적 확장성 측면에서 어떤 장단점을 가지는가?
+- 의존성 주입(Dependency Injection)의 목적으로 Context API를 사용할 때, 테스트 환경(Jest 등)이나 Storybook에서 Provider 모킹(Mocking)을 설계할 때 발생할 수 있는 취약점과 해결책은 무엇인가?
+- 대규모 애플리케이션에서 무분별한 `useEffect`와 Context API가 결합되었을 때 발생하는 '리렌더링 폭풍(Re-render storm)'을 React DevTools Profiler로 진단하고 리팩토링하는 구체적인 과정은 어떻게 되는가?
+
+### Practical Application Contexts
+- **Implementation:** React 프로젝트에서 `React.createContext()`로 테마나 로케일 정보를 정의하고, 최상위 레이어(`app/` 또는 최상위 컴포넌트)를 `Provider`로 감싼 뒤, 내부 컴포넌트에서 `useContext`를 통해 해당 설정값을 불러와 UI에 즉각적으로 적용합니다 [4, 22, 23].
+- **System Design:** 아키텍처 설계 시 상태의 '변경 빈도'에 따라 저장소를 이원화합니다. 다크모드, 로그인 여부 같은 정적인 설정은 Context API에 배치하고, 장바구니나 실시간 알림처럼 수시로 변하는 데이터는 Zustand나 Redux 같은 외부 스토어에 배치하여 불필요한 렌더링 전파를 방지합니다 [24].
+- **Operation / Maintenance:** 성능 프로파일링 시 사용자 인터랙션 이후 대시보드가 일시적으로 멈추는 현상이 발견되면, React DevTools의 Profiler를 이용해 원인을 분석합니다. 원인이 단일 Context 업데이트에 의한 수백 개 컴포넌트의 리렌더링으로 확인될 경우, Context를 잘게 쪼개거나 다른 상태 관리 도구로 마이그레이션하는 유지보수 결정을 내립니다 [1, 25].
+- **Learning Path:** React 상태 관리를 처음 배우는 단계에서, 컴포넌트 간 Props 전달의 피로도를 줄이는 첫 번째 도구로 학습됩니다. 이후 실제 복잡한 앱을 만들며 한계를 경험하고, Redux의 보일러플레이트 구조나 Zustand의 독립된 스토어 개념을 자연스럽게 받아들이게 하는 핵심 학습 경로입니다 [14, 26, 27].
+- **My Project Relevance:** 기존 코드베이스에 'Global Context' 안티 패턴(모든 상태를 한 곳에 몰아넣은 형태)이 존재하지 않는지 점검하고 [11], 렌더링 병목이 있는 경우 `useMemo`, `useCallback`과 함께 Context를 책임별로 분할하는 리팩토링 목표와 직접적으로 연관됩니다 [1, 12].
+
+### Adjacent Topics
+- [[React.memo]]
+  - 확장 방향: Context API에 의해 발생하는 불필요한 하위 컴포넌트 렌더링을 방지하기 위한 얕은 비교(Shallow Compare) 최적화 도구로, 렌더링 성능 최적화(Performance Optimization) 기법 전반으로의 이해를 확장합니다 [28, 29].
+- [[Concurrent Rendering]]
+  - 확장 방향: React 18의 동시성 렌더링 기능(`useTransition`, `useDeferredValue`)을 통해 무거운 컴포넌트 렌더링을 어떻게 지연시키고 애플리케이션의 반응성을 개선할 수 있는지 상태 업데이트 흐름으로 탐구를 확장합니다 [6, 30].
+
+---
+*Last updated: 2026-04-30*
\ No newline at end of file
diff --git a/10_Wiki/Development/Debugging Frontend Applications.md b/10_Wiki/Development/Debugging Frontend Applications.md
new file mode 100644
index 00000000..51a64a0b
--- /dev/null
+++ b/10_Wiki/Development/Debugging Frontend Applications.md	
@@ -0,0 +1,74 @@
+# [[Debugging Frontend Applications]]
+
+## 📌 Brief Summary
+프론트엔드 디버깅은 웹 애플리케이션에서 발생하는 자바스크립트 런타임 에러, 메모리 누수, 그리고 불필요한 리렌더링과 같은 성능 저하 요인을 식별하고 해결하는 과정입니다 [1-3]. Chrome DevTools와 같은 브라우저 내장 도구부터 React DevTools, 그리고 Sentry나 LogRocket과 같은 프로덕션 클라우드 로깅 도구를 활용하여 문제의 근본 원인을 추적합니다 [4-7]. 효과적인 디버깅 전략과 에러 핸들링 아키텍처는 애플리케이션의 안정성을 보장하고 사용자 경험을 최적화하는 데 필수적입니다 [8-10].
+
+## 📖 Core Content
+
+*   **메모리 누수(Memory Leaks) 탐지 및 해결:** 
+    *   메모리 누수는 할당된 메모리가 더 이상 필요하지 않음에도 해제되지 않을 때 발생하며, 앱 속도 저하와 브라우저 탭 충돌을 유발합니다 [2, 11]. 
+    *   Chrome DevTools의 Task Manager를 통해 실시간 JavaScript 메모리 사용량을 확인하고, Performance 탭의 기록을 통해 시간 경과에 따른 메모리 증가 패턴을 시각화할 수 있습니다 [12, 13].
+    *   Memory 패널의 **Heap Snapshots**을 사용하여 스냅샷 간의 차이(Delta)를 비교함으로써, DOM에서 제거되었으나 자바스크립트 참조가 남아있는 'Detached DOM nodes'를 식별할 수 있습니다 [14-17]. 또한, **Allocation Timeline**을 통해 새로운 메모리가 언제 할당되는지 추적하여 누수 후보를 찾아냅니다 [18, 19].
+*   **React 컴포넌트 및 성능 디버깅:**
+    *   **리렌더링 원인 추적:** React DevTools의 Profiler를 사용해 어떤 컴포넌트가 언제, 왜 렌더링되었는지 파악할 수 있으며, 개발 전용 라이브러리인 `why-did-you-render`를 통해 실제 props나 상태 변경 없이 발생하는 불필요한 리렌더링을 콘솔 경고로 확인할 수 있습니다 [7, 20].
+    *   **React Error Boundaries:** React 애플리케이션에서는 Error Boundary라는 클래스 컴포넌트를 활용하여 하위 컴포넌트 트리의 렌더링, 생명주기 메서드, 생성자에서 발생하는 에러를 포착합니다 [1]. 이는 UI를 위한 `try-catch` 블록 역할을 하며, 앱 전체가 충돌하는 대신 Fallback UI를 표시하여 앱의 나머지 부분을 상호작용 가능한 상태로 유지합니다 [1, 8, 10].
+*   **상태 관리 도구와 디버깅 편의성:**
+    *   상태 관리 도구의 선택은 디버깅 경험에 큰 영향을 미칩니다. Context API는 상태 변경 기록 추적이나 시간 여행(Time-travel) 디버깅이 불가능하여 버그 원인을 파악하기 어렵습니다 [21]. 반면, Redux는 Redux DevTools를 통해 어떤 액션이 언제 디스패치되었는지 확인하고, 상태 이력을 검사 및 재생(Replay)할 수 있어 복잡한 비동기 에러를 신속하게 디버깅할 수 있습니다 [21, 22].
+*   **프로덕션 환경 모니터링 및 로깅:**
+    *   배포된 프로덕션 앱에서는 Sentry, LogRocket, Datadog RUM 등의 클라우드 로깅 툴을 통해 사용자가 경험하는 에러를 모니터링합니다 [23-25].
+    *   Sentry는 지능형 에러 그룹화(Error grouping)와 에러 발생 전의 콘솔 로그, 네트워크 요청 등을 보여주는 빵부스러기(Breadcrumb) 트레일을 제공합니다 [4, 25]. LogRocket은 사용자의 전체 화면을 녹화하듯 DOM 및 Redux/Vuex 상태 변화까지 캡처하는 세션 리플레이(Session replay) 기능으로 상세한 디버깅 컨텍스트를 제공합니다 [5]. Datadog RUM은 프론트엔드 에러를 백엔드 분산 트레이싱(Distributed tracing)과 상관관계 지어(Correlation) 복잡한 시스템의 에러를 파악하게 해줍니다 [24].
+
+## ⚖️ Trade-offs & Caveats
+
+*   **클라우드 로깅 도구의 성능 및 비용 문제:** 모니터링 도구들은 렌더링 성능 및 번들 크기에 직접적인 영향을 미칩니다. 일부 도구 구현 시 최대 120ms의 추가 로드 시간이 발생할 수 있습니다 [26]. 또한, Datadog과 같은 툴은 로그 수집(Ingest)과 검색을 위한 인덱싱(Index)에 대해 이중 과금 구조를 가지고 있어 규모가 커질수록 비용이 매우 가파르게 증가하는 단점이 있습니다 [27, 28].
+*   **세션 리플레이와 개인정보 침해 (Privacy Concerns):** LogRocket처럼 '모든 것을 캡처'하는 세션 리플레이 방식은 기본적으로 강력한 디버깅 정보를 제공하지만, 민감한 사용자 데이터까지 녹화될 수 있는 심각한 개인정보 침해 우려가 동반됩니다. 따라서 별도의 마스킹 및 설정 작업이 강제됩니다 [5, 29, 30].
+*   **Error Boundaries의 한계:** 선언적인 UI 에러 처리에 강력하지만, 이벤트 핸들러 내부의 에러, `setTimeout` 같은 비동기 코드, 서버 사이드 렌더링(SSR), 그리고 Error Boundary 자체에서 발생한 에러는 포착하지 못합니다. 이러한 부분은 전통적인 자바스크립트의 `try/catch` 블록으로 디버깅 및 예외 처리를 해야 하는 제약이 있습니다 [31, 32].
+*   **React Compiler 도입에 따른 디버깅 난이도 증가:** 코드를 자동으로 최적화해주는 React Compiler는 내부 로직이 블랙박스(Black box) 형태로 동작합니다. 개발자는 최적화된 부분과 그 이유에 대한 가시성을 잃게 되며, 예기치 않은 리렌더링 발생 시 코드상의 `React.memo`나 `useCallback` 호출을 확인하는 대신 React DevTools Profiler에 전적으로 의존해 조사해야 하므로 디버깅 난이도가 상승합니다 [33].
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+
+#### [관계 유형 A (브라우저 및 성능 분석 기반 도구)]
+- [[Chrome DevTools]]
+  - 연결 이유: 자바스크립트 힙 메모리와 DOM의 상태를 프로파일링하여 메모리 누수를 진단하는 가장 근본적인 프론트엔드 디버깅 도구이기 때문입니다 [6, 34].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 브라우저의 가비지 컬렉션(GC) 동작 원리, 분리된 DOM 노드(Detached DOM nodes)와 클로저(Closure)가 메모리를 점유하여 성능을 저하시키는 원리를 시각적으로 이해할 수 있습니다 [2, 14, 17, 35].
+
+#### [관계 유형 B (React 컴포넌트 및 에러 핸들링 도구)]
+- [[React Error Boundaries]]
+  - 연결 이유: 렌더링 및 생명주기 도중 발생하는 컴포넌트 런타임 에러를 디버깅/핸들링하여 "하얀 화면(White screen of death)"을 막아주는 React만의 고유한 방어적 디버깅 패턴입니다 [1, 36].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 선언적(Declarative) UI 트리의 에러 전파 방식과, 명령형(Imperative) 이벤트 핸들러에서 `try-catch`를 사용해야 하는 아키텍처적 차이를 명확히 구분할 수 있습니다 [32].
+- [[React DevTools Profiler]]
+  - 연결 이유: 어떤 컴포넌트가 언제, 왜 리렌더링되었는지를 측정(Profiling)하여 렌더링 병목 현상을 디버깅하는 필수 도구입니다 [7, 37].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: React의 렌더링 라이프사이클, 불필요한 상태 및 props 변경 추적, 그리고 React Compiler 도입 전후의 렌더링 패스(Render pass) 차이를 검증하는 방법을 배울 수 있습니다 [7, 38].
+
+#### [관계 유형 C (프로덕션 환경 관측성 도구)]
+- [[Session Replay & Distributed Tracing]]
+  - 연결 이유: 로컬에서 재현이 불가능한 프로덕션 에러를 추적하기 위해 사용자의 브라우저 상호작용(Sentry, LogRocket)과 백엔드 데이터 흐름(Datadog)을 연결하여 디버깅 단서를 찾는 핵심 개념입니다 [5, 24, 39].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 풀스택 환경에서의 엔드투엔드(End-to-End) 성능 모니터링 한계와 프론트엔드 에러가 백엔드 서비스에 미치는 연관 관계를 깊게 이해할 수 있습니다 [24, 25].
+
+### Deeper Research Questions
+
+- Chrome DevTools의 Heap Snapshot 분석에서 'Shallow size'와 'Retained size'의 차이는 프론트엔드 메모리 관리 측면에서 어떻게 해석되며, 디버깅 시 어떤 기준표가 되는가? [40]
+- React Error Boundary가 이벤트 핸들러나 비동기 코드의 에러를 잡지 못하는 아키텍처적 이유는 무엇이며, 이를 보완하여 전체 애플리케이션의 에러를 효과적으로 캡처하기 위한 최적의 로깅 패턴은 무엇인가? [31, 32]
+- Sentry, LogRocket, Datadog RUM 등 클라우드 기반 로깅 도구가 프론트엔드 번들 크기 증가 및 초기 렌더링 성능 지연(최대 120ms 추가 로드)에 미치는 영향을 최소화하기 위한 설정 및 로드 전략은 무엇인가? [26, 41]
+- Redux DevTools의 시간 여행(Time-travel) 디버깅 원리는 무엇이며, 왜 Context API나 Zustand보다 복잡한 비동기 상태의 버그를 더 빠르고 정확하게 찾아낼 수 있는가? [21, 22]
+- React Compiler 도입 이후 자동화된 메모이제이션 과정에서 발생하는 렌더링 이슈(예: Library Compatibility 문제로 인한 참조 변경)를 디버깅하기 위해 React Profiler를 어떻게 활용해야 하는가? [33, 42, 43]
+
+### Practical Application Contexts
+
+- **Implementation:** 개발자는 `why-did-you-render` 라이브러리를 프로젝트에 연동해, 로컬 개발 시 불필요한 컴포넌트 렌더링 원인을 콘솔 경고를 통해 즉각적으로 파악하고 코드를 수정할 수 있습니다 [20, 44].
+- **System Design:** 프론트엔드 시스템 설계 시 대시보드, 차트, 복잡한 폼 등 장애 발생 확률이 높은 UI 컴포넌트 각각에 독립적인 `Error Boundary`를 배치해 하나의 위젯 결함이 전체 앱의 마비를 가져오지 않도록 설계합니다 [8, 45, 46].
+- **Operation / Maintenance:** 프로덕션 단계에서는 Sentry나 LogRocket과 같은 관측성(Observability) 툴을 통합하여, 오류 로그 발생 시 사용자가 클릭한 이벤트와 화면의 상태(Session Replay)를 실시간으로 확인하고 빠르게 이슈를 대응(Hotfix)합니다 [5, 25, 47].
+- **Learning Path:** 주니어 프론트엔드 개발자가 메모리 누수를 학습할 때, Chrome DevTools의 Memory 탭을 사용해 스냅샷을 찍고 DOM 노드가 자바스크립트 변수에 의해 참조되어 가비지 컬렉션되지 않는 상황(Detached Elements)을 실습합니다 [14, 15, 17].
+- **My Project Relevance:** React 프로젝트에서 전역 상태를 설계할 때, 단순 설정(Theme 등)은 디버깅이 단순한 Context API로, 변경이 잦고 상태 추적이 중요한 요소는 DevTools를 지원하는 Redux나 Zustand를 도입하여 디버깅 용이성을 확보합니다 [22, 48, 49].
+
+### Adjacent Topics
+
+- [[State Management Architecture]]
+  - 확장 방향: 상태 관리 라이브러리(Redux, Zustand, Context API 등)의 아키텍처적 선택이 상태 변화 추적성과 DevTools 디버깅 퀄리티에 어떤 영향을 미치는지 분석 [21, 22, 49].
+- [[Frontend Performance Optimization]]
+  - 확장 방향: 디버깅을 통해 발견한 메모리 누수와 불필요한 컴포넌트 렌더링(Re-renders) 문제를 실질적인 성능 최적화 기법(가상화, 코드 스플리팅)으로 해결하여 Core Web Vitals를 개선하는 방향 [20, 50].
+
+---
+*Last updated: 2026-04-30*
\ No newline at end of file
diff --git a/10_Wiki/Development/Engineering Scalable Frontend Systems.md b/10_Wiki/Development/Engineering Scalable Frontend Systems.md
new file mode 100644
index 00000000..387ef5fb
--- /dev/null
+++ b/10_Wiki/Development/Engineering Scalable Frontend Systems.md	
@@ -0,0 +1,84 @@
+# [[Engineering Scalable Frontend Systems]]
+
+## 📌 Brief Summary
+확장 가능한 프론트엔드 시스템(Engineering Scalable Frontend Systems)은 단순한 스크립트 실행을 넘어 유지보수성, 고성능, 견고성을 갖춘 분산 소프트웨어 아키텍처를 구축하는 것을 의미합니다 [1]. 이는 기술적 파일 기반 폴더 구조에서 기능 중심(Feature-Based) 및 도메인 기반 설계로의 전환을 요구하며, 엄격한 코드 컨벤션과 거버넌스를 동반합니다 [2, 3]. 또한 프론트엔드 개발에 SOLID와 같은 소프트웨어 공학 원칙을 결합하고, 서버/클라이언트 상태의 분리, 그리고 빌드 타임 및 런타임 성능 최적화를 통해 예측 가능한 성장을 가능하게 합니다 [1, 4, 5].
+
+## 📖 Core Content
+
+*   **아키텍처 및 폴더 구조의 진화**
+    기존의 컴포넌트, 훅, 스타일 등을 파일 타입별로 모아두는 구조는 앱이 커질수록 인지 부하를 높이고 확장을 어렵게 만듭니다 [2, 6]. 2025년의 프론트엔드 시스템은 비즈니스 도메인과 기능(Feature)을 중심으로 코드를 응집시키는 구조를 표준으로 삼고 있습니다 [3, 7]. 특히 **Feature-Sliced Design (FSD)** 같은 아키텍처는 코드를 횡단 관심사별 레이어(shared, entities, features, widgets, pages, app)로 나누고, 상위 계층에서 하위 계층으로만 접근할 수 있는 엄격한 단방향 의존성 규칙을 강제합니다 [8-10]. 각 슬라이스는 `index.ts`를 통해 퍼블릭 API(Public API)만 외부에 노출하여 내부 구현을 캡슐화합니다 [4, 11, 12].
+*   **소프트웨어 공학 원칙의 적용 (SOLID & Clean Code)**
+    프론트엔드 코드의 유지보수성을 위해 SOLID, DRY, KISS, YAGNI 원칙이 적용됩니다 [4, 13].
+    *   단일 책임 원칙(SRP)에 따라 너무 많은 작업을 수행하는 대형 컴포넌트(예: 300줄 이상)는 데이터 패칭, 상태 관리, UI 렌더링 등의 책임에 맞게 더 작고 독립적인 단위로 분리되어야 합니다 [14].
+    *   개방-폐쇄 원칙(OCP)은 기존 컴포넌트 소스를 수정하지 않고 `children` prop이나 Render Props 패턴을 이용한 컴포넌트 합성(Composition)으로 기능을 확장하는 방식으로 구현됩니다 [15, 16].
+    *   중복을 줄이는 DRY 원칙은 공통 로직을 커스텀 훅으로 분리하는 것을 권장하지만, 지나친 추상화는 코드 파악을 어렵게 하므로 단순성을 유지하는 KISS 원칙과 균형을 이루어야 합니다 [17].
+*   **상태 관리 패러다임의 세분화**
+    거대한 단일 상태 저장소(예: 과거의 Redux)에 의존하기보다는 데이터의 성격에 따라 최적의 도구를 선택하여 상태를 파편화 및 전문화합니다 [5].
+    *   **전역 애플리케이션 상태:** Context API는 값이 변경될 때마다 하위 컴포넌트 전체를 리렌더링하는 한계가 있으므로 [18, 19], 상태 변경이 잦고 규모가 큰 앱에서는 부분 구독(Selector)을 지원하여 렌더링 성능을 최적화하는 **Zustand**나 **Jotai**가 선호됩니다 [5, 20, 21].
+    *   **서버 상태 (API Layer):** API에서 가져온 데이터는 캐싱, 동기화, 로딩/에러 사이클 관리가 필요하므로, 클라이언트 상태와 명확히 분리하여 **TanStack Query (React Query)** 등의 라이브러리로 관리합니다 [18, 22].
+*   **성능 엔지니어링 및 빌드 최적화**
+    초기 로딩 시간과 Core Web Vitals 최적화를 위해 다양한 기법이 적용됩니다 [23, 24].
+    *   **빌드/컴파일 타임:** Vite와 같은 도구를 사용하여 개발 환경에서는 네이티브 ES 모듈을 제공하고, 프로덕션에서는 Rollup의 `manualChunks`를 활용해 용량이 큰 벤더 라이브러리(React, Recharts 등)를 분할 캐싱하여 캐시 효율을 높입니다 [23, 25-27]. 또한 **React Compiler**의 도입으로 컴파일러가 자동으로 코드의 리렌더링 방지(메모이제이션)를 처리하여 수동 최적화(`useMemo`, `useCallback`)의 오류를 줄여줍니다 [25, 28, 29].
+    *   **런타임 최적화:** 동적 임포트를 이용한 라우트 및 컴포넌트 레벨의 코드 스플리팅(Code Splitting & Lazy Loading), 그리고 수천 개의 리스트 아이템 렌더링 시 DOM 비대를 막는 가상화(Virtualization) 기술이 필수적으로 요구됩니다 [30-32].
+*   **복원력(Resilience) 및 시스템 거버넌스**
+    견고한 시스템은 런타임 오류가 전체 앱의 크래시로 이어지는 것을 막습니다. UI의 불안정한 영역이나 서드파티 위젯은 **Error Boundaries**로 감싸 폴백 UI를 제공하여 안정성을 보장합니다 [33-35]. 또한, 메모리 누수 방지를 위한 DevTools 힙 스냅샷 디버깅과 Sentry, LogRocket 같은 클라우드 도구를 이용한 프로덕션 에러 모니터링이 활용됩니다 [36-38]. 협업 차원에서는 일관된 네이밍 규칙(예: 파일명은 kebab-case, 컴포넌트는 PascalCase)과 ESLint, Prettier, Husky를 통한 자동화된 거버넌스, 그리고 Storybook을 활용한 시각적 회귀 테스트가 코드 품질을 보장합니다 [39-41].
+
+## ⚖️ Trade-offs & Caveats
+*   **Feature-Sliced Design (FSD)의 초기 도입 비용 및 복잡성:** FSD는 확장성과 모듈화에 뛰어나지만 러닝 커브가 높으며, 작은 규모의 프로젝트에서는 오버엔지니어링으로 느껴질 수 있습니다 [42, 43]. 또한 '인증(Auth)' 같은 횡단 관심사(Cross-cutting concerns)를 정확히 어떤 기능이나 슬라이스에 배치할지 경계를 설정하는 것이 어려워 팀 내 규칙 합의와 지속적인 문서화가 요구됩니다 [44, 45].
+*   **React Compiler 적용의 제약:** React Compiler가 자동 메모이제이션을 수행하여 성능을 높여주지만, 이는 블랙박스로 동작하기 때문에 예기치 않게 리렌더링이 발생했을 때 원인을 디버깅하기 더 어려워질 수 있습니다 [46]. 또한 매 렌더링마다 새로운 객체 참조를 반환하는 서드파티 라이브러리와 충돌할 수 있으며, 레거시 코드베이스의 경우 React의 불변성 및 부수 효과 규칙(Rules of React)을 엄격히 준수하도록 대대적인 리팩토링이 선행되어야 합니다 [28, 47, 48].
+*   **Context API vs. 외부 상태 관리 라이브러리의 트레이드오프:** Context API는 내장 기능이므로 의존성을 추가하지 않는 장점이 있지만, 변경이 잦은 상태에 사용할 경우 불필요한 하위 컴포넌트의 연쇄 리렌더링을 유발하는 치명적인 성능 병목을 발생시킵니다 [19, 20]. 반대로 Zustand나 TanStack Query를 도입하면 리렌더링 문제를 해결할 수 있으나, 시스템에 새로운 라이브러리 의존성과 학습 곡선이 추가됩니다 [21, 49].
+*   **DRY와 KISS 원칙의 상충:** 중복을 줄이기(DRY) 위해 공통 로직을 고차 컴포넌트(HOC)나 커스텀 훅으로 지나치게 추상화하면, 코드가 원래의 단순한 형태보다 이해하고 디버깅하기 훨씬 어려워져 결국 KISS 원칙을 위배하게 되는 부작용이 발생할 수 있습니다 [17].
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+
+#### [관계 유형 A: 아키텍처 및 시스템 구조 (Architecture & Structural Design)]
+*   `[[Feature-Sliced Design (FSD)]]`
+    *   연결 이유: 현대 프론트엔드의 모듈화 및 확장성을 해결하기 위해 널리 채택되는 아키텍처 방법론의 핵심이기 때문입니다 [9, 10].
+    *   이 개념을 통해 더 깊게 이해할 수 있는 부분: 비즈니스 도메인 기반의 코드 분할, 엄격한 단방향 의존성 규칙 적용 방법, 그리고 퍼블릭 API를 통한 모듈 캡슐화 원리 [4, 8, 50].
+*   `[[Error Boundaries]]`
+    *   연결 이유: 부분적인 UI 런타임 에러가 시스템 전체의 장애(White screen of death)로 확산되는 것을 방지하는 구조적 안전 장치이기 때문입니다 [33, 34].
+    *   이 개념을 통해 더 깊게 이해할 수 있는 부분: 렌더링 트리에서 컴포넌트 결함을 격리하는 원리와 시스템 복원력을 높이는 에러 처리 전략 [33, 35].
+
+#### [관계 유형 B: 상태 관리 패러다임 (State Management Paradigms)]
+*   `[[Zustand vs Context API]]`
+    *   연결 이유: 전역 상태 관리에서 성능과 확장성을 결정짓는 가장 빈번한 아키텍처 결정 지점이기 때문입니다 [5, 19].
+    *   이 개념을 통해 더 깊게 이해할 수 있는 부분: Context API의 브로드캐스트 렌더링 문제점과 이를 해결하기 위한 Zustand의 구독/선택자(Selector) 기반 렌더링 최적화 기법 [19, 20, 51].
+*   `[[TanStack Query (React Query)]]`
+    *   연결 이유: 클라이언트 상태와 서버 상태(Server State)를 구조적으로 분리하여 API 데이터 처리의 병목을 없애주기 때문입니다 [18, 22].
+    *   이 개념을 통해 더 깊게 이해할 수 있는 부분: 데이터 캐싱, 백그라운드 동기화 및 API 계층의 관심사 분리(Separation of Concerns) [18, 22].
+
+#### [관계 유형 C: 성능 및 빌드 최적화 (Performance & Build Optimization)]
+*   `[[React Compiler]]`
+    *   연결 이유: 수동 메모이제이션의 복잡성을 줄이고 빌드 타임에 컴포넌트 렌더링 성능을 자동으로 최적화하는 최신 핵심 도구이기 때문입니다 [25, 28, 29].
+    *   이 개념을 통해 더 깊게 이해할 수 있는 부분: 선언적 UI 프레임워크에서의 빌드 타임 최적화 한계 및 React의 규칙(Rules of React)이 강제하는 불변성의 중요성 [52, 53].
+*   `[[Code Splitting & Lazy Loading]]`
+    *   연결 이유: 초기 로드(First Paint) 속도 향상과 JavaScript 번들 크기를 제어하는 확장 가능한 시스템의 필수 성능 전략이기 때문입니다 [30, 31, 54].
+    *   이 개념을 통해 더 깊게 이해할 수 있는 부분: Vite나 Webpack 같은 번들러 환경에서 동적 임포트를 통한 라우트 단위 분할 및 무거운 벤더 청크(`manualChunks`)의 캐싱 분리 전략 [26, 27, 31].
+
+### Deeper Research Questions
+
+*   거대한 모놀리식 구조 혹은 단일 파일 타입(components/, hooks/) 기반의 레거시 React 앱을 Feature-Sliced Design(FSD) 아키텍처로 점진적으로 리팩토링할 때 고려해야 할 최적의 마이그레이션 전략은 무엇인가?
+*   React Compiler가 도입되어 컴포넌트의 리렌더링을 자동으로 제어하게 된다면, 개발자는 더 이상 `useMemo`나 `useCallback`을 작성할 필요가 완전히 없어지는가? 혹은 여전히 수동 메모이제이션이 필수적인 엣지 케이스는 무엇인가?
+*   Zustand와 같은 클라이언트 상태 관리와 TanStack Query와 같은 서버 상태 관리 라이브러리를 동시 사용할 때, 두 상태 사이의 데이터 동기화와 의존성 주입은 어떻게 설계해야 응집도를 높일 수 있는가?
+*   프론트엔드 성능 최적화 중 메모리 누수(Memory Leak)를 예방하기 위해 Chrome DevTools 힙 스냅샷에서 식별되는 '분리된 DOM 노드(Detached DOM Nodes)'와 클로저(Closure) 잔류 문제를 프로덕션에서 어떻게 모니터링하고 방지할 수 있는가?
+*   Vite를 활용한 빌드 시 대규모 벤더 라이브러리로 인한 번들 사이즈 경고("Large Chunks")를 근본적으로 해결하기 위해 `manualChunks` 설정을 어떻게 분할해야 브라우저의 병렬 다운로드 및 캐싱 효율을 극대화할 수 있는가?
+
+### Practical Application Contexts
+
+*   **Implementation:** 신규 도메인 기능을 구현할 때 로직, UI, 커스텀 훅을 하나의 피처(Feature) 폴더에 응집시키고 다른 피처에서의 직접 임포트를 제한하여 철저히 캡슐화된 코드를 작성합니다 [3, 4]. 빈번히 발생하는 이벤트나 렌더링 로직 안에서는 인라인 익명 함수 사용을 지양하고 불필요한 재할당을 막습니다 [55, 56].
+*   **System Design:** 시스템 초기 아키텍처를 설계할 때 상태의 유형을 명확히 분류하여, 자주 바뀌지 않는 테마/설정은 Context API에, 상호작용이 잦은 장바구니/UI 상태는 Zustand에, 서버 데이터는 TanStack Query에 위임하는 다층적 상태 트리를 설계합니다 [5, 18, 57].
+*   **Operation / Maintenance:** 프로덕션 배포 후 Sentry, LogRocket, Datadog과 같은 가시성(Observability) 및 클라우드 로깅 도구를 연동해 사용자 세션을 리플레이하고 런타임 오류 및 메모리 누수 이슈를 사전에 탐지합니다 [36, 37].
+*   **Learning Path:** React 기초(useState, Props)와 컴포넌트 분리(SOLID, Clean Code) 개념을 숙지한 후, 점진적으로 Context API의 한계를 체험하고 Zustand로 마이그레이션하는 과정을 거치며 렌더링 최적화와 메모이제이션의 원리를 학습합니다 [4, 14, 58].
+*   **My Project Relevance:** 현재 유지보수 중인 거대한 React 프로젝트가 있다면, 컴포넌트 트리 상단에 무분별하게 배치된 Context Provider를 걷어내고 Zustand 기반의 부분 구독 패턴으로 리팩토링하거나 [21], Storybook 및 Chromatic을 CI 파이프라인에 도입하여 PR 단계에서 시각적 회귀 테스트(Visual Test)를 자동화하여 품질을 개선할 수 있습니다 [41, 59].
+
+### Adjacent Topics
+
+*   `[[Core Web Vitals]]`
+    *   확장 방향: LCP(Largest Contentful Paint), INP(Interaction to Next Paint), CLS(Cumulative Layout Shift) 등 구글이 정의한 사용자 경험 중심의 성능 측정 지표를 이해하고, 앞서 다룬 코드 스플리팅, 레이지 로딩, 렌더링 최적화 기법이 실제 사용자 체감 속도 향상에 어떻게 직결되는지 심층 분석하는 방향으로 연구할 수 있습니다 [23, 60, 61].
+*   `[[Git Branching Strategies & CI/CD Governance]]`
+    *   확장 방향: 복잡한 프론트엔드 시스템을 다수의 개발자가 협업하여 구축할 때 충돌을 최소화하고 릴리스 안정성을 높이기 위한 GitHub Flow, Trunk-Based Development 등의 브랜칭 전략과, ESLint/Prettier 자동화, Conventional Commits를 활용한 배포 파이프라인(CI/CD) 통제 방법을 확장해서 조사할 수 있습니다 [62-64].
+
+---
+*Last updated: 2026-04-30*
\ No newline at end of file
diff --git a/10_Wiki/Development/Folder Structure Best Practices.md b/10_Wiki/Development/Folder Structure Best Practices.md
new file mode 100644
index 00000000..c340d218
--- /dev/null
+++ b/10_Wiki/Development/Folder Structure Best Practices.md	
@@ -0,0 +1,69 @@
+# [[Folder Structure Best Practices]]
+
+## 📌 Brief Summary
+React 등 프론트엔드 프로젝트에서 코드의 유지보수성, 확장성, 그리고 협업 효율성을 높이기 위해 파일과 디렉터리를 체계적으로 구성하는 방법론입니다 [1]. 현대적인 애플리케이션에서는 과거의 파일 유형 기반(유형별 분류) 구조에서 벗어나, 기능(Feature)이나 도메인 중심으로 관련된 로직을 묶는 하이브리드 또는 기능 기반 방식이 모범 사례로 권장됩니다 [2, 3]. 이를 통해 UI, 비즈니스 로직, 상태 관리 등의 관심사를 명확히 분리하고 프로젝트가 커짐에 따라 발생하는 기술 부채를 최소화할 수 있습니다 [4].
+
+## 📖 Core 소스 Content
+
+*   **구조의 진화와 한계:** 
+    *   초기 소규모 프로젝트는 주로 모든 컴포넌트를 `components` 폴더에, 모든 훅을 `hooks` 폴더에 넣는 플랫(Flat) 구조나 파일 유형 기반 구조로 시작합니다 [5, 6].
+    *   하지만 앱의 규모가 커지면 단일 기능을 수정하기 위해 여러 폴더를 넘나들어야 하므로, 개발 속도가 느려지고 디버깅이 어려워지며 코드베이스가 복잡해지는 한계가 발생합니다 [3, 6, 7].
+*   **기능 기반(Feature-based) 및 하이브리드 구조:** 
+    *   2025년 기준 가장 권장되는 접근 방식은 파일 유형이 아닌 비즈니스 기능이나 모듈을 중심으로 폴더를 구성하는 것입니다 [2, 8, 9].
+    *   각 기능(Feature)은 캡슐화되어 다른 기능과 독립적으로 작동할 수 있으므로, 규모 확장 시 기존 코드에 영향을 주지 않고 새로운 기능을 매끄럽게 추가할 수 있습니다 [8, 10].
+*   **권장 디렉터리 구성 (src/ 하위):**
+    *   `assets/`: 이미지, 폰트 등 정적 미디어 리소스 보관 [11, 12].
+    *   `components/`: 여러 기능에서 공통으로 재사용되는 도메인에 구애받지 않는 UI 요소 (예: 버튼, 모달, 네비게이션 바 등) [2, 12, 13].
+    *   `features/` (또는 `modules/`): 인증(Auth), 대시보드(Dashboard) 등 도메인별 비즈니스 로직. 이 폴더 내부에는 해당 기능에만 쓰이는 컴포넌트, 훅, API 등을 캡슐화하여 보관합니다 [2, 9, 13].
+    *   `hooks/`: 폼 처리, 데이터 페칭 등 앱 전반에서 재사용 가능한 커스텀 훅 [9, 14].
+    *   `pages/` (또는 `routes/`): 라우팅에 매핑되는 페이지 레벨 컴포넌트 [15, 16].
+    *   `services/`: 서드파티 서비스 연동이나 API 요청 등 외부 통신 로직 [16, 17].
+    *   `store/` (또는 `context/`): Redux, Zustand, Context API를 활용하는 전역 상태 관리 로직 [14-16].
+    *   `utils/`: 날짜 포맷팅, 데이터 유효성 검사 등 상태를 가지지 않는 유틸리티 함수 [17, 18].
+    *   `styles/`: 글로벌 CSS, 테마(Theme) 등 전역 스타일링 파일 [18, 19].
+    *   `types/`: TypeScript 사용 시 전역으로 사용되는 타입 및 인터페이스 보관 [18].
+    *   `config/`: 환경 변수나 애플리케이션 전역 설정(API 기본 URL 등) 관리 [18, 20].
+*   **Feature-Sliced Design (FSD):** 
+    *   기능 기반 폴더 구조보다 더 엄격하게 의존성의 방향을 통제하는 프론트엔드 아키텍처 방법론입니다 [21].
+    *   `shared` -> `entities` -> `features` -> `widgets` -> `pages` -> `app` 이라는 고정된 다층 계층(Layer)을 가집니다 [22, 23].
+    *   상위 계층은 하위 계층의 코드를 가져올 수 있지만(Import), 하위 계층은 상위 계층을 참조할 수 없는 단방향 의존성 규칙을 통해 순환 의존성을 방지합니다 [22, 24].
+*   **Next.js 환경에서의 라우트 그룹 (Route Groups):**
+    *   Next.js 프로젝트에서는 괄호를 사용한 폴더명 `(folderName)` 방식을 통해, 실제 URL 경로에는 영향을 주지 않으면서도 관련 기능이나 논리에 따라 라우트를 깔끔하게 그룹화할 수 있습니다 [25-27].
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+- [[Feature-Sliced Design]]
+  - 연결 이유: 대규모 React 애플리케이션의 폴더 구조를 구축하기 위해 고안된 전문적인 프론트엔드 아키텍처 방법론이기 때문입니다 [21].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 폴더 간의 단방향 의존성 규칙과 각 폴더(Layer, Slice, Segment)가 담당해야 하는 역할의 엄격한 분리 방식 [22, 28].
+
+- [[Separation of Concerns]] (관심사의 분리)
+  - 연결 이유: 폴더 구조를 설계하는 근본적인 목적이 UI 렌더링, 전역 상태 관리, 데이터 통신(API) 등의 책임을 각기 다른 위치로 분리하는 데 있기 때문입니다 [4, 29].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: `services/`, `store/`, `components/` 등의 폴더를 분리하여 단일 책임 원칙(SRP)을 프론트엔드 아키텍처 전반에 적용하는 방법 [4, 30].
+
+- [[Naming Conventions]] (명명 규칙)
+  - 연결 이유: 일관된 폴더 및 파일 명명 규칙(예: 폴더명은 kebab-case, 컴포넌트는 PascalCase)은 폴더 구조 내에서 파일을 예측 가능하게 찾고 충돌을 방지하는 핵심 규칙이기 때문입니다 [31-33].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 다양한 운영체제와 CI/CD 파이프라인에서 빌드 에러를 방지하고 팀 내 코드 가독성을 유지하는 방법 [34, 35].
+
+### Deeper Research Questions
+- 기능 기반(Feature-based) 폴더 구조에서 각 기능이 상호작용해야 할 때 발생하는 교차 관심사(Cross-cutting concerns)나 공유 의존성을 어떻게 관리하고 해결할 수 있는가?
+- 레거시 파일 유형 기반(File-type based) React 프로젝트를 기능 기반 혹은 Feature-Sliced Design으로 점진적으로 마이그레이션하기 위한 가장 안전하고 효율적인 단계는 무엇인가?
+- Feature-Sliced Design의 단방향 의존성 원칙을 ESLint와 같은 정적 분석 도구로 자동 강제화(Governance)하는 방법은 무엇인가?
+- 폴더 구조를 모듈화할 때 발생하는 파일 중첩 문제와 이를 피하기 위한 적절한 인덱스(Barrel) 파일 사용 전략의 장단점은 무엇인가?
+- 상태 관리 라이브러리(Context API, Zustand, Redux 등)의 종류에 따라 권장되는 `store/` 폴더 내부의 구조는 어떻게 달라져야 하는가?
+
+### Practical Application Contexts
+- **Implementation:** React 컴포넌트를 생성할 때, 모든 요소를 `components/` 폴더에 넣지 않고 특정 도메인(예: 인증)에만 쓰이는 요소는 `features/auth/components/`로 격리하여 캡슐화를 실천합니다.
+- **System Design:** 프로젝트 초기 세팅 단계에서 비즈니스 도메인을 분석하여 어떤 코드가 전역(`shared/` 또는 `components/`)에 속하고 어떤 코드가 로컬(`features/`)에 속할지 기준을 마련합니다.
+- **Operation / Maintenance:** 기능에 버그가 발생했을 때, 해당 기능의 폴더(`features/feature-name/`)만 확인하면 UI, 상태, API 요청 로직이 모여 있어 디버깅 및 유지보수 속도가 크게 향상됩니다.
+- **Learning Path:** 처음에는 단순한 플랫 구조로 React를 학습한 후, 컴포넌트가 30개 이상으로 늘어나는 시점에 기능 기반 폴더 구조를 도입하여 아키텍처 설계 역량을 기를 수 있습니다.
+- **My Project Relevance:** 현재 진행 중이거나 리팩토링해야 할 React 코드베이스에서, 거대해진 `components/` 폴더를 도메인 단위의 `features/` 폴더로 나누고 재사용 불가 로직들을 분리하는 데 직접적으로 적용됩니다.
+
+### Adjacent Topics
+- [[State Management]]
+  - 확장 방향: 전역 상태(Global State)와 로컬 상태(Local State)를 어디에 보관해야 하는지, Zustand와 같은 도구가 `store/` 폴더의 구조를 어떻게 단순화하는지 확장하여 조사할 수 있습니다.
+- [[Code Splitting]] (코드 스플리팅)
+  - 확장 방향: 라우트 혹은 폴더(Feature) 단위로 코드 스플리팅과 지연 로딩(Lazy Loading)을 적용하여 초기 번들 크기를 줄이고 성능을 최적화하는 전략과 연결됩니다.
+
+---
+*Last updated: 2026-04-30*
\ No newline at end of file
diff --git a/10_Wiki/Development/Frontend Performance Debugging.md b/10_Wiki/Development/Frontend Performance Debugging.md
new file mode 100644
index 00000000..e8479bfa
--- /dev/null
+++ b/10_Wiki/Development/Frontend Performance Debugging.md	
@@ -0,0 +1,72 @@
+# [[Frontend Performance Debugging]]
+
+## 📌 Brief Summary
+프론트엔드 성능 디버깅(Frontend Performance Debugging)은 웹 애플리케이션의 메모리 누수, 불필요한 리렌더링, 잦은 가비지 컬렉션 등으로 인해 발생하는 성능 저하와 응답 지연을 식별하고 해결하는 과정입니다 [1-3]. 개발자는 브라우저의 내장 개발자 도구(Chrome DevTools)를 활용해 메모리 상태와 컴포넌트 렌더링 비용을 로컬에서 분석합니다 [4, 5]. 더 나아가 프로덕션 환경에서는 클라우드 기반 로깅 및 모니터링 도구를 사용하여 실제 사용자의 세션과 에러를 추적함으로써 복잡한 성능 병목의 근본 원인을 파악합니다 [6-8].
+
+## 📖 Core 소스 Content
+**메모리 문제 진단 (Memory Issues Diagnosis)**
+프론트엔드 성능 저하의 주요 원인 중 하나는 메모리 누수(Memory Leak)와 메모리 팽창(Memory Bloat)입니다. 자바스크립트에서는 사용이 끝난 메모리를 가비지 컬렉터가 회수하지만, DOM 노드가 문서에서 제거된 후에도 자바스크립트 참조가 남아있는 '분리된 DOM 노드(Detached DOM Nodes)', 누적된 이벤트 리스너, 클로저(Closure)에 의해 유지되는 참조 등이 메모리 누수를 유발합니다 [2, 9, 10]. Chrome DevTools의 Task Manager를 통해 실시간 DOM 노드와 JS 힙(Heap) 메모리 증가를 확인하고, Memory 패널의 Heap Snapshot을 비교하여 분리된 DOM 트리를 식별하며, Allocation Timeline을 사용해 언제 새로운 메모리가 할당되는지 추적할 수 있습니다 [4, 11, 12]. 빈번한 가비지 컬렉션은 스크립트 실행을 자주 일시 정지시켜 화면의 끊김(Jank)을 발생시킵니다 [1].
+
+**React 컴포넌트 렌더링 프로파일링 (React Rendering Profiling)**
+React 애플리케이션에서는 상태(State), 프로퍼티(Props), 컨텍스트(Context) 변경 또는 부모 컴포넌트의 렌더링에 의해 리렌더링이 트리거됩니다 [13]. 불필요한 리렌더링은 메인 스레드를 차단하고 상호작용 시간을 지연시킵니다 [3]. 이를 디버깅하기 위해 React DevTools Profiler를 사용하여 어떤 컴포넌트가 언제, 왜 렌더링되었는지, 얼마나 시간이 걸렸는지(Flamegraph 뷰 등)를 분석합니다 [5, 14]. 또한, 개발 환경 전용 라이브러리인 `why-did-you-render`를 활용하면 실제 상태나 prop 변경 없이 발생하는 리렌더링에 대한 콘솔 경고를 받을 수 있습니다 [15, 16].
+
+**프로덕션 관측성과 클라우드 로깅 (Production Observability and Logging)**
+로컬 환경을 넘어 실제 운영 환경의 성능을 디버깅하기 위해 Sentry, LogRocket, Datadog RUM, SigNoz와 같은 프론트엔드 클라우드 로깅 도구가 사용됩니다 [17, 18]. 이 도구들은 단순한 에러 로깅을 넘어 사용자가 에러나 성능 저하를 겪기 직전의 행동을 비디오처럼 다시 볼 수 있는 세션 리플레이(Session Replay), 프론트엔드 에러를 백엔드 트레이스와 연관 지어 분석하는 분산 트레이싱(Distributed Tracing), 그리고 실제 사용자의 Core Web Vitals(LCP, FID, INP 등) 모니터링 기능을 제공하여 맹점 없는 디버깅을 가능하게 합니다 [7, 8, 19-21].
+
+## ⚖️ Trade-offs & Caveats
+* **모니터링 도구의 성능 최적화 반대 급부:** LogRocket이나 Sentry 같은 강력한 로깅 및 성능 모니터링 도구들을 클라이언트 사이드에 탑재하면 자바스크립트 번들 사이즈가 커지고 성능에 영향을 미칩니다. 일부 도구는 최대 120ms의 추가 로드 시간을 발생시킬 수 있으므로 1초가 중요한 서비스에서는 가벼운 옵션을 선택해야 합니다 [22-24].
+* **세션 리플레이와 프라이버시 문제:** 모든 사용자 세션과 DOM/상태 변화를 기록하는 도구(예: LogRocket)의 기본 '모두 캡처' 방식은 민감한 개인정보를 노출할 위험이 있습니다. 이를 방지하기 위해 마스킹 설정을 수동으로 엄격히 구성해야 하는 관리 비용이 발생합니다 [19, 23, 25, 26].
+* **비용과 가시성의 타협 (Cost vs. Visibility):** Datadog과 같은 대규모 옵저버빌리티 플랫폼은 수집(Ingestion)과 색인(Indexing) 단계에서 이중 과금 모델을 사용하여 트래픽이 많은 경우 엄청난 비용이 발생합니다. 비용 절감을 위해 로그의 20%만 색인하게 되면, 실제 장애 발생 시 디버깅에 필요한 데이터의 80%가 검색되지 않는 트레이드오프가 발생합니다 [27-29].
+* **최적화 기법 자체의 오버헤드:** `React.memo()`, `useCallback`, `useMemo`와 같은 최적화 훅은 이전 참조값을 메모리에 저장하고 비교하는 오버헤드를 발생시킵니다. 렌더링 비용보다 비교 비용이 더 큰 가벼운 컴포넌트에 남용하면 오히려 성능을 저하시키는 원인이 됩니다 [30, 31].
+* **컴파일러 자동화로 인한 디버깅 난이도 상승:** React Compiler 같은 빌드 타임 자동 메모이제이션 도구를 사용하면 명시적인 훅 작성을 줄일 수 있지만, 컴파일러가 블랙박스로 작동하므로 예기치 않은 리렌더링이 발생할 경우 코드 상에서 원인을 찾기 어려워 React DevTools Profiler에 전적으로 의존해야 하는 단점이 있습니다 [32].
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+
+#### [관계 유형 A (로컬 디버깅 및 분석 도구)]
+- [[Chrome DevTools Memory Profiler]]
+  - 연결 이유: 자바스크립트 애플리케이션의 메모리 누수와 객체 보존 상태를 프로파일링하는 브라우저 내장 도구.
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: Heap Snapshots 비교, Allocation Timeline을 통한 메모리 할당 추적, Detached DOM tree 파악 기법 [9, 12, 33].
+- [[React DevTools Profiler]]
+  - 연결 이유: React 특유의 렌더링 사이클과 성능 병목을 시각화하는 핵심 도구.
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 컴포넌트 렌더링 소요 시간, 렌더링 발생 원인(Props/State 변경 여부 판별) [5, 14].
+
+#### [관계 유형 B (프로덕션 관측성 및 모니터링)]
+- [[Frontend Cloud Logging Tools]]
+  - 연결 이유: Sentry, LogRocket, Datadog RUM, SigNoz 등 배포 이후 발생하는 성능 저하와 버그를 추적하는 플랫폼.
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 프로덕션 레벨에서의 세션 리플레이, 자동 에러 그룹화, 엔드투엔드 분산 트레이싱, Core Web Vitals 추적 [7, 8, 20, 21, 34].
+
+#### [관계 유형 C (아키텍처 및 안티패턴)]
+- [[JavaScript Memory Leaks]]
+  - 연결 이유: 애플리케이션 성능을 점진적으로 파괴하는 현상으로 메모리 팽창, 가비지 컬렉션 등과 연관.
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 클로저 잔류 참조(Closure-Retained References), 해제되지 않은 이벤트 리스너의 동작 메커니즘 [2, 10, 35].
+- [[React Re-render Optimization]]
+  - 연결 이유: React의 렌더링 특성상 발생하는 메인 스레드 블로킹 문제를 해결하기 위한 코드 레벨 기법.
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 참조 안정성(Reference stability), 익명 함수의 부작용, `useMemo` 및 `useCallback`의 올바른 활용법 [36-38].
+
+### Deeper Research Questions
+
+- 프론트엔드 모니터링 시 수집하는 Sentry, LogRocket 등의 툴이 유발하는 성능 저하(번들 사이즈 및 실행 오버헤드)를 최소화하면서도 Core Web Vitals 등 유의미한 디버깅 데이터를 수집하는 최적의 설정 전략은 무엇인가?
+- JavaScript 환경의 Allocation Timeline 상에서 빈번하게 발생하는 가비지 컬렉션(GC) 스파이크와 실제 브라우저의 메인 스레드 멈춤 현상(Jank/INP 저하) 간의 상관관계를 어떻게 정량적으로 프로파일링할 수 있는가?
+- React Compiler가 자동화하는 영역과 서드파티 라이브러리(예: 항상 새로운 객체를 반환하는 `useLocation`, `useMutation`)로 인해 컴파일러가 최적화를 우회하는 경우, 이 충돌을 디버깅하고 해결하는 구체적인 패턴은 무엇인가?
+- Puppeteer 기반의 Automated Memory Testing을 CI/CD 파이프라인에 통합하여, Detached DOM node나 Event Listener 누적과 같은 메모리 누수를 프로덕션 배포 전에 차단하는 방법은 무엇인가?
+- Context API 사용 시 발생하는 광범위한 리렌더링 문제를 해결하기 위해 Zustand와 같은 외부 상태 관리 도구의 'Selector' 패턴을 사용할 때, 디버깅 과정에서 Redux DevTools 연동이 제공하는 구체적인 이점은 무엇인가?
+
+### Practical Application Contexts
+
+- **Implementation:** React 컴포넌트 마운트 해제 시 `useEffect` 클린업 함수를 작성하여 이벤트 리스너를 제거함으로써 메모리 누수를 방지하고, 로컬 개발 환경에서 `why-did-you-render` 라이브러리를 추가하여 불필요한 리렌더링을 콘솔 경고로 조기 감지한다 [15, 39].
+- **System Design:** 초기 프론트엔드 아키텍처 설계 단계부터 SigNoz(OpenTelemetry 기반)나 Sentry와 같은 로깅 도구 도입을 인프라 구성 요소로 결정하고, 사용자 정보 보호를 위해 세션 캡처 시 민감 데이터 마스킹 정책을 사전 설계한다 [21, 25, 26, 40].
+- **Operation / Maintenance:** 프로덕션 환경에서 시간이 지남에 따라 앱이 무거워지거나 느려진다는 사용자 제보가 들어올 경우, Chrome DevTools Memory 패널의 Heap Snapshot을 통해 분리된 DOM 노드가 점진적으로 누적되는지 검사하고 원인 코드를 수정한다 [1, 9, 41].
+- **Learning Path:** 우선 JavaScript 가비지 컬렉터의 동작 원리와 메모리 누수 패턴을 학습한 뒤, Chrome DevTools의 Task Manager와 Memory 패널 사용법을 익히고, 최종적으로 React Profiler와 프로덕션 로깅 도구 활용법으로 학습을 확장한다.
+- **My Project Relevance:** 현재 진행하는 React 기반 대시보드 프로젝트에서 테이블 데이터나 차트 업데이트 시 화면 멈춤이 발생할 경우, Chrome DevTools Performance 탭을 통해 스크립트 실행 시간을 확인하고 React Profiler를 붙여 불필요하게 리렌더링되는 자식 컴포넌트를 식별, `React.memo` 또는 식별자(Key)를 수정하는 최적화 작업에 직접 적용할 수 있다.
+
+### Adjacent Topics
+
+- [[Core Web Vitals]]
+  - 확장 방향: 프론트엔드 성능 최적화와 디버깅의 궁극적인 성과 지표이자 기준점이 되는 실제 사용자 체감 속도 지표(LCP, FID, INP, CLS 등) 심층 탐구 [8].
+- [[React Server Components (RSC)]]
+  - 확장 방향: Next.js 환경에서 클라이언트 측 자바스크립트 번들 사이즈 자체를 줄이고 상호작용 없는 UI를 서버에서 렌더링함으로써 근본적인 클라이언트 디버깅 요소 및 리렌더링 비용을 제거하는 아키텍처 [42, 43].
+
+---
+*Last updated: 2026-04-30*
\ No newline at end of file
diff --git a/10_Wiki/Development/Large-scale Application Refactoring.md b/10_Wiki/Development/Large-scale Application Refactoring.md
new file mode 100644
index 00000000..57dc756e
--- /dev/null
+++ b/10_Wiki/Development/Large-scale Application Refactoring.md	
@@ -0,0 +1,66 @@
+# [[Large-scale Application Refactoring]]
+
+## 📌 Brief Summary
+대규모 애플리케이션 리팩토링은 코드의 동작 방식을 보존하면서 내부 구조를 개선하여 오래된 코드베이스의 유지보수성과 확장성을 회복하는 과정이다 [1]. 이는 단순히 코드를 '수정'하는 것이 아니라, 복잡한 비즈니스 로직을 분리하고 구조적 결합도를 낮추는 것을 목표로 한다 [2]. 성공적인 리팩토링을 위해서는 점진적인 접근 방식, 엄격한 아키텍처 적용, 그리고 코드 변경을 뒷받침할 수 있는 테스트 구축이 필수적이다 [1, 3].
+
+## 📖 Core Content
+
+*   **점진적 마이그레이션 전략 (Incremental Migration):** 대규모 애플리케이션을 한 번에 전면 재작성(Rewrite)하는 것은 리스크가 매우 크기 때문에, "재작성이 아닌 리팩토링" 전략이 권장된다 [1]. 예를 들어 상태 관리 도구를 Context API에서 Zustand로 마이그레이션할 때, 알림과 같은 단순한 유틸리티 스토어부터 시작해 결제 흐름과 같은 복잡한 도메인으로 한 번에 하나의 스토어씩 점진적으로 이동해야 한다 [1].
+*   **기능 및 도메인 기반 구조로의 개편:** 레거시 앱에서 흔히 쓰이는 파일 타입 기반 구조(components, hooks 등을 따로 모으는 방식)는 앱이 커질수록 탐색과 유지보수를 어렵게 만든다 [4, 5]. 따라서 비즈니스 기능별로 코드를 모으는 기능 기반 구조나, 단방향 의존성을 강제하는 엄격한 계층 모델인 Feature-Sliced Design(FSD)으로 폴더 구조를 재편하는 것이 핵심적인 리팩토링 목표가 된다 [6-8].
+*   **커스텀 훅을 통한 로직 캡슐화:** 현대 React 리팩토링의 기본 단위는 커스텀 훅이다 [9]. 복잡한 데이터 페칭이나 폼 핸들링 로직을 거대한 UI 컴포넌트에서 추출하여 `useFetch`, `useForm` 등의 훅으로 분리하면, UI와 비즈니스 로직이 격리되어 더 빠르고 독립적인 유닛 테스트가 가능해진다 [9, 10].
+*   **테스트를 통한 안전망 확보:** 코드를 본격적으로 수정하기 전에 테스트(Unit Test, UI Test 등)를 작성하는 것이 최우선 방어선이다 [3, 11, 12]. 기존 기능이 깨지지 않았는지 검증할 뿐만 아니라, 테스트 코드를 작성하는 과정 자체가 개발자가 기존 애플리케이션의 비즈니스 로직과 흐름을 깊이 이해하도록 강제하는 학습 도구가 된다 [13, 14].
+*   **레거시 안티패턴 및 스택 제거:** 효율적인 구조를 위해 불필요하게 렌더링을 유발하는 다수의 `useEffect`를 제거하고, 클라이언트와 서버 상태를 분리하기 위해 TanStack Query와 같은 도구를 도입해야 한다 [15]. 또한, 가능할 경우 클래스 기반 컴포넌트를 함수형 컴포넌트와 훅으로 변환하고, 일관성 없는 CSS 적용 방식을 하나로 통일하는 작업도 수반된다 [15, 16].
+
+## ⚖️ Trade-offs & Caveats
+*   **DRY와 KISS 원칙의 충돌:** 중복을 제거하려는 DRY(Don't Repeat Yourself) 원칙을 과도하게 적용할 경우, 추상화가 지나치게 복잡해져 코드를 단순하게 유지해야 하는 KISS(Keep It Simple, Stupid) 원칙을 위반하게 된다 [17]. 따라서 특정 패턴이 세 번 반복될 때까지 기다렸다가 추상화를 진행하는 것이 조기 최적화로 인한 부작용을 막는 방법이다 [17].
+*   **재작성(Rewrite) vs 리팩토링(Refactoring)의 기로:** 리팩토링 대상인 앱의 규모가 비교적 작다면 처음부터 새로 앱을 구축하는 것이 오히려 효율적일 수 있다 [11]. 그러나 대형 앱의 경우 전체 재작성은 위험이 커서 점진적 마이그레이션을 해야 하는데, 이 경우 전환 기간 동안 두 가지 다른 기술이나 아키텍처 패턴이 공존해야 하는 과도기적 기술 부채를 감당해야 한다 [1].
+*   **컴파일러 자동화 도입의 장벽:** React Compiler와 같이 성능 최적화(메모이제이션)를 자동화해 주는 도구를 도입하면 수동 최적화 코드를 지워 코드를 간결하게 만들 수 있다 [18]. 하지만 기술 부채가 많은 레거시 코드베이스의 경우, 기존 코드가 'React의 규칙(Rules of React)'을 광범위하게 위반하고 있다면 컴파일러가 제대로 작동하지 않으므로, 도입 전 대대적인 사전 리팩토링이 선행되어야 하는 제약이 따른다 [19].
+*   **공유(Shared) 모듈의 비대화:** 기능 기반 아키텍처(예: FSD)로 분리할 때, 공통으로 쓰이는 코드를 무분별하게 'Shared' 계층에 넣으면 해당 계층이 복잡한 스파게티 코드가 되고 변경 시 영향 범위(Blast Radius)가 기하급수적으로 커지는 위험이 있다 [20, 21]. 
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+
+#### [아키텍처 및 기반 원칙]
+- [[Feature-Sliced Design]]
+  - 연결 이유: 대규모 코드베이스의 스파게티화를 해결하고, 도메인/기능 중심의 단방향 의존성 규칙을 부여하여 확장 가능한 구조를 만드는 리팩토링의 궁극적 목표 모델이기 때문이다 [7, 22].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 기능(Feature)과 계층(Layer)을 어떻게 나누고 캡슐화하여 서로 간의 의존성 결합을 끊어내는지에 대한 실무적 아키텍처 구조 [6, 23].
+
+- [[SOLID Principles]]
+  - 연결 이유: 단일 책임 원칙(SRP) 등을 통해 거대한 컴포넌트가 가지는 여러 책임을 분리하고, 함수나 컴포넌트를 테스트 가능하게 잘게 쪼개는 리팩토링의 핵심 이론적 배경이기 때문이다 [24, 25].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 기능적 컴포넌트 내에서 인터페이스(Props)를 어떻게 분리하고, 확장에 열려있으면서 수정에는 닫힌 코드 작성을 구현하는 방법 [25, 26].
+
+#### [구현 및 활용 도구]
+- [[Unit Testing]]
+  - 연결 이유: 레거시 코드 구조를 변경할 때 기능이 망가지지 않았음을 보장하는 첫 번째 단계이자 가장 중요한 안전망 역할을 수행하기 때문이다 [3, 12].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 코드를 어떻게 더 작고 논리적인 블록 단위로 나누어(Triangulation) 의존성 없이 독립적으로 검증할 수 있는지에 대한 방법론 [9, 12].
+
+- [[Custom Hooks]]
+  - 연결 이유: 리액트 컴포넌트 내부에 복잡하게 얽힌 상태와 사이드 이펙트 로직을 외부로 추출하는 리팩토링의 주된 단위이자 도구이기 때문이다 [9].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: UI 렌더링 책임과 비즈니스 데이터 처리 책임을 어떻게 물리적으로 격리하여 코드 재사용성을 높일 수 있는지의 원리 [9, 10].
+
+### Deeper Research Questions
+
+- 리팩토링 과정에서 Feature-Sliced Design(FSD) 아키텍처를 도입할 때, 여러 기능(Feature)에서 동시에 요구되는 교차 관심사(Cross-cutting concerns) 로직은 어떤 방식으로 분리하여 관리해야 하는가?
+- 테스트 코드가 전무한 거대한 레거시 React 앱을 리팩토링할 때, 어떤 부분(예: 공통 유틸, UI 컴포넌트, 전역 상태 등)부터 우선순위를 두고 테스트 커버리지를 확보해야 하는가?
+- 대규모 애플리케이션의 Context API 기반 전역 상태를 Zustand 등 현대적 상태 관리 도구로 점진적으로 마이그레이션할 때 발생하는 상태 동기화 문제는 어떻게 해결할 수 있는가?
+- 기존의 수동 메모이제이션(`useMemo`, `useCallback`) 코드가 많은 레거시 앱에 React Compiler를 도입하기 위해 코드 내의 'Rules of React' 위반 사항을 추적하고 검증하는 효과적인 자동화 프로세스는 무엇인가?
+- 클래스형 컴포넌트를 함수형 컴포넌트와 커스텀 훅 구조로 리팩토링할 때 발생할 수 있는 메모리 누수(Memory Leaks) 패턴을 감지하고 방지하는 디버깅 전략론은 무엇인가?
+
+### Practical Application Contexts
+
+- **Implementation:** 거대한 폼 처리나 API 페칭 로직이 뷰와 결합하여 300줄이 넘어가는 기존 컴포넌트를, 단일 책임 원칙(SRP)에 따라 순수 뷰 컴포넌트와 비즈니스 로직을 담은 커스텀 훅으로 추출하여 다시 연결한다 [9, 25].
+- **System Design:** 폴더 구조를 `components/`, `hooks/` 같은 파일 유형 구분이 아닌, 비즈니스 도메인(예: 인증, 결제)을 중심으로 모은 기능 기반 혹은 FSD 기반 폴더 계층 구조로 전면 재설계한다 [8, 27].
+- **Operation / Maintenance:** ESLint와 Husky 등의 도구를 파이프라인에 구축하여 리팩토링된 코드가 상위 계층을 잘못 참조하는 역의존성(Reverse dependency)을 발생시키거나 코드 컨벤션이 어긋나지 않도록 엄격히 통제한다 [28].
+- **Learning Path:** 리팩토링해야 할 코드를 파악하기 전, 먼저 작은 빈 프로젝트나 '토이 앱'을 만들어 리팩토링에 도입할 새로운 기술(React의 최신 기능 등)의 기초를 실습하여 개념을 확립한다 [29].
+- **My Project Relevance:** 다른 개발자들이 작성한 레거시 코드를 인계받아 논문 프로젝트용으로 리팩토링해야 하는 경우, 먼저 기존 로직을 파악하기 위한 유닛 테스트를 작성한 후, 무분별하게 혼용된 CSS 스타일 정책을 하나로 통일시키고 불필요한 전역 상태를 지역 상태로 전환하는 실무 프로세스를 진행한다 [14, 16, 30, 31].
+
+### Adjacent Topics
+
+- [[Web Performance Optimization]]
+  - 확장 방향: 리팩토링 작업과 병행하여 번들 사이즈 감소(코드 스플리팅), 리렌더링 최적화, 불필요한 렌더 블로킹 제거 등을 통해 애플리케이션의 런타임 및 로딩 속도를 향상하는 전략적 기법을 탐구한다.
+- [[State Management Fragmentation]]
+  - 확장 방향: 레거시 앱의 거대한 단일 전역 상태를 분석하여 로컬 컴포넌트 상태, 전역 UI 상태, 서버 캐시 상태, URL 상태 등으로 파편화 및 전문화하여 각각에 맞는 도구(Zustand, React Query 등)로 이관하는 설계 방법론을 조사한다.
+
+---
+*Last updated: 2026-04-30*
\ No newline at end of file
diff --git a/10_Wiki/Development/Lazy Loading.md b/10_Wiki/Development/Lazy Loading.md
new file mode 100644
index 00000000..8756a85b
--- /dev/null
+++ b/10_Wiki/Development/Lazy Loading.md	
@@ -0,0 +1,63 @@
+# [[Lazy Loading]]
+
+## 📌 Brief Summary
+Lazy Loading은 리소스나 코드 청크를 애플리케이션 초기 구동 시 한 번에 로드하지 않고, 사용자가 실제로 필요로 하는 시점에 비동기적으로 불러오는 성능 최적화 기법입니다 [1, 2]. 프론트엔드 환경에서는 초기 JavaScript 번들 크기를 최대 20~70%까지 줄여 초기 페이지 로드 시간을 획기적으로 향상시킵니다 [3]. 주로 경로(Route) 기반 컴포넌트, 무거운 UI 위젯(차트 등), 뷰포트 하단의 이미지 등에 적용되어 앱의 전반적인 반응성과 Core Web Vitals 지표를 개선합니다 [4, 5].
+
+## 📖 Core Content
+*   **JavaScript 코드 스플리팅과 동적 임포트(Dynamic Imports)**: Lazy Loading은 대규모 애플리케이션을 온디맨드(on-demand)로 로드할 수 있는 더 작은 청크(chunk)로 분할하는 코드 스플리팅(Code Splitting) 기법의 핵심입니다 [2]. 동적 임포트를 통해 Vite나 Webpack 같은 빌드 툴이 렌더링에 당장 필요하지 않은 코드를 메인 번들에서 분리하여 독립적인 파일로 만듭니다 [1, 6, 7].
+*   **React 환경에서의 구현 (`React.lazy` 및 `Suspense`)**: React 애플리케이션에서는 `React.lazy()` 함수를 통해 컴포넌트의 지연 로딩을 활성화합니다 [8]. 모듈이 네트워크를 통해 다운로드되는 동안 화면이 멈추거나 비어 보이지 않도록, `<Suspense>`를 감싸서 로딩 스피너와 같은 대체 UI(Fallback UI)를 렌더링합니다 [7, 8]. 
+*   **라우트 레벨 및 컴포넌트 레벨 지연 로딩**: 가장 일반적인 방식은 라우트 레벨에서 적용하는 것으로, 사용자가 특정 페이지로 네비게이션할 때만 해당 페이지의 JavaScript 청크가 다운로드되도록 합니다 [2, 7]. 컴포넌트 단위로는 서드파티 통합 기능(비디오 플레이어, PDF 뷰어 등)이나 차트, 리치 텍스트 에디터 같이 무거운 UI 블록에 적용하여 메인 번들을 최소화합니다 [5, 6].
+*   **이미지(Media) 최적화**: JavaScript 코드뿐 아니라 미디어 리소스에도 Lazy Loading이 널리 쓰입니다 [4]. HTML `<img>` 태그에 네이티브 속성인 `loading="lazy"`를 추가하면, 스크롤을 통해 사용자의 뷰포트에 도달하기 전까지 이미지를 다운로드하지 않으므로 초기 페이지 로딩의 오버헤드를 줄입니다 [4].
+
+## ⚖️ Trade-offs & Caveats
+*   **초기 뷰포트(Above-the-fold) 콘텐츠 적용 금지**: 지연 로딩은 스크롤 없이 처음 화면에 바로 보여야 하는 핵심 콘텐츠(Above-the-fold)나 즉시 상호작용해야 하는 렌더링이 빠른 요소에는 절대 적용해서는 안 됩니다 [5]. 이를 적용할 경우 초기 페인트 시간이 느려지고 사용자 경험이 심각하게 저하됩니다 [5, 9].
+*   **사용자 인터랙션 시 일시적 지연 발생**: 지연 로딩된 기능이나 페이지에 사용자가 처음 접근할 때, 브라우저는 필요한 스크립트 청크를 그제야 네트워크로 요청합니다 [7, 8, 10]. 이로 인해 약간의 대기 시간이 발생할 수 있으므로 `<Suspense>`를 통한 폴백 상태를 세심하게 디자인해야 합니다 [8, 11].
+*   **과도한 파편화(Over-fragmentation) 주의**: 크기가 작고 가벼운 기능까지 모두 지연 로딩으로 분리할 경우, 오히려 브라우저의 네트워크 요청 횟수가 급증하고 관리해야 할 로딩 상태(`Suspense`)가 많아져 성능 및 개발 효율을 떨어뜨릴 수 있습니다 [5, 12].
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+
+#### [아키텍처/기반 기술]
+- [[Code Splitting]]
+  - 연결 이유: Lazy Loading이 가능하도록 애플리케이션의 단일 JavaScript 번들을 여러 개의 작은 청크 단위로 나누는 근본적인 기반 기술이기 때문입니다 [2, 13].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 모던 프론트엔드 환경에서 빌드 툴(Vite, Webpack)이 런타임 최적화를 위해 코드를 어떻게 분할하고 관리하는지 이해할 수 있습니다 [6, 7].
+
+- [[Dynamic Imports]]
+  - 연결 이유: 자바스크립트 모듈을 파일의 최상단에서 정적으로 불러오지 않고, 실행 중에 비동기적으로 불러오기 위해 `import()` 문법을 사용하는 방식입니다 [1, 7].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 라우트 전환이나 특정 이벤트 발생 시점에 필요한 코드만 네트워크로 호출하는 런타임 메커니즘을 파악할 수 있습니다 [7].
+
+#### [구현/활용 도구]
+- [[React Suspense]]
+  - 연결 이유: `React.lazy()`를 이용해 지연 로딩을 수행할 때, 청크가 로드되기 전까지 렌더링을 일시 중지하고 Fallback UI를 화면에 그려주는 핵심 컴포넌트입니다 [7, 8].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 비동기 UI 로딩 시 사용자 경험(UX)을 부드럽게 유지하기 위한 렌더링 제어 및 로딩 상태 설계 패턴을 배울 수 있습니다 [8, 11].
+
+- [[Vite manualChunks]]
+  - 연결 이유: Vite를 통해 빌드할 때, 변경이 잦지 않은 무거운 벤더 라이브러리(React 코어 등)를 Lazy Loading의 청크 분할 전략과 결합해 별도 파일로 독립시키는 환경 설정입니다 [7, 14].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 브라우저 캐싱 전략을 극대화하고, 초기 번들 용량 경고("Large Chunks") 문제를 해결하는 구체적인 번들러 최적화 방법을 학습할 수 있습니다 [7, 15].
+
+### Deeper Research Questions
+
+- React 18의 동시성 렌더링(Concurrent Rendering) 기능인 `useTransition` 등은 지연 로딩 시 발생하는 UI 멈춤 현상을 어떻게 보완할 수 있는가? [16, 17]
+- 사용자 경험 저하를 막기 위해 지연 로딩되는 컴포넌트를 사용자가 클릭하기 직전에 미리 가져오는 Prefetching 전략은 어떻게 구현하는가? [18, 19]
+- Next.js의 클라이언트 컴포넌트 지연 로딩과 서버 컴포넌트(RSC) 아키텍처는 초기 번들 최적화 측면에서 어떤 차이점과 시너지를 가지는가? [5, 20, 21]
+- 무거운 UI 블록을 지연 로딩할 때, `rollup-plugin-visualizer`와 같은 번들 분석 도구를 통해 지연 로딩 대상을 어떻게 효과적으로 식별하고 우선순위를 정할 수 있는가? [10, 12]
+- 네이티브 브라우저 기능인 `loading="lazy"` 속성과 JavaScript 기반의 Intersection Observer API를 활용한 미디어 지연 로딩의 성능 최적화 한계점과 Trade-off는 무엇인가? [4]
+
+### Practical Application Contexts
+
+- **Implementation:** React 코드 상단의 무거운 외부 컴포넌트(예: 에디터, 차트 등) import 문을 지우고, `const Dashboard = React.lazy(() => import('./Dashboard'));`와 같이 변경한 후 렌더링 영역을 `<Suspense fallback={<Spinner/>}>`로 감쌉니다 [1, 6-8].
+- **System Design:** 프론트엔드 라우팅 및 아키텍처 설계 시부터, 필수 초기 진입 화면(Above-the-fold)은 즉시 로드하고, 관리자 패널이나 잘 쓰이지 않는 라우트는 분리하여 Code Splitting되도록 시스템의 번들링 전략을 구상합니다 [5, 12, 14].
+- **Operation / Maintenance:** 운영 중인 서비스가 무거워지거나 Vite 빌드 시 "500 kB 초과 청크" 경고가 뜰 경우, 번들 분석 도구를 사용해 메인 번들에서 분리 가능한 무거운 벤더나 특정 라우트를 식별해 점진적으로 Lazy Loading을 적용합니다 [10, 12, 15].
+- **Learning Path:** React 기초 렌더링 사이클 학습 ➔ JavaScript 모듈 및 번들러 구조 이해 ➔ `React.lazy`와 `Suspense`를 통한 라우트 스플리팅 적용 ➔ Chrome 성능 탭과 Web Vitals로 실제 로드 속도 측정 및 검증 [13, 22, 23].
+- **My Project Relevance:** 웹 애플리케이션의 규모가 커짐에 따라 필연적으로 증가하는 JavaScript 페이로드 문제를 해결하고, FCP(First Contentful Paint)와 TTI(Time to Interactive) 등 핵심 성능 지표를 방어하기 위한 필수적인 렌더링 최적화 전략입니다 [3, 8].
+
+### Adjacent Topics
+
+- [[Core Web Vitals]]
+  - 확장 방향: 지연 로딩이 검색 엔진 최적화(SEO) 및 사용자 경험 지표인 FCP, LCP(Largest Contentful Paint), INP(Interaction to Next Paint) 수치를 실제로 얼마나 개선하는지 측정 및 분석하는 관점으로 확장할 수 있습니다 [3, 23, 24].
+- [[Server Components (RSC)]]
+  - 확장 방향: 클라이언트 사이드의 자바스크립트 크기를 줄이기 위한 또 다른 현대적 패러다임으로, 클라이언트에서 실행될 코드를 아예 서버에서 렌더링하고 HTML로만 보내는 방식과 Lazy Loading과의 역할을 비교/대조합니다 [20, 21].
+
+---
+*Last updated: 2026-04-30*
\ No newline at end of file
diff --git a/10_Wiki/Development/Next.js App Router.md b/10_Wiki/Development/Next.js App Router.md
new file mode 100644
index 00000000..43ddac1f
--- /dev/null
+++ b/10_Wiki/Development/Next.js App Router.md	
@@ -0,0 +1,54 @@
+# [[Next.js App Router]]
+
+## 📌 Brief Summary
+Next.js App Router는 Next.js(버전 13 이후)에서 도입된 최신 라우팅 및 아키텍처 시스템으로, React Server Components(RSC)를 기본적으로 지원하여 클라이언트 측 자바스크립트 전송량을 줄이고 초기 로딩 속도를 향상시킵니다 [1, 2]. 이 시스템은 `app` 디렉토리를 기반으로 동작하며, `page.js`, `layout.js`와 같은 특수 파일들을 통해 직관적이고 구조화된 라우팅을 제공합니다 [3, 4].
+
+## 📖 Core Content
+
+*   **특수 파일을 활용한 구조적 라우팅**: Next.js App Router는 라우트 구성 및 관리를 위해 특수 파일 명명 규칙을 사용합니다. 라우트는 `page.js`로, 공유 레이아웃은 `layout.js`로, 사용자 정의 에러는 `error.js`로, 로딩 상태는 `loading.js`로 정의하여 애플리케이션의 동작을 제어합니다 [3].
+*   **동적 라우트 및 라우트 그룹**: 동적인 경로 처리를 위해 `[param]`을 사용하고, 포괄적(catch-all) 라우트 처리를 위해 `[...param]`을 지원합니다 [3]. 또한 URL 구조에 영향을 주지 않고 논리적으로 라우트를 그룹화할 수 있도록 괄호를 사용하는 라우트 그룹(예: `(folderName)`) 기능을 제공하여, 기능별 또는 팀별로 코드를 깔끔하게 조직할 수 있습니다 [5].
+*   **React Server Components (RSC) 통합**: App Router는 서버 컴포넌트를 기반으로 동작합니다. 이를 통해 정적이거나 데이터 주도적인(read-only) UI는 클라이언트 측 자바스크립트 없이 서버에서만 렌더링할 수 있어 자바스크립트 번들 크기와 Hydration 소요 시간을 극대화하여 줄여줍니다 [2, 6, 7].
+*   **클라이언트와 서버의 역할 분리**: 서버 컴포넌트에서는 상태(state), `useEffect`, 클라이언트 전용 라이브러리를 사용할 수 없습니다 [8]. 따라서 상호작용이 즉각적으로 필요한 UI(모달, 입력창 등)에만 파일 상단에 `use client` 지시어를 선언하여 클라이언트 컴포넌트로 만들고, 나머지는 서버 컴포넌트로 분리하는 아키텍처 패턴이 필수적입니다 [7, 9].
+*   **동시성 렌더링(Concurrent Rendering) 완벽 지원**: App Router는 React 18의 동시성 기능과 완벽하게 통합되어 있습니다. `useTransition` 및 서버 컴포넌트와 함께 사용하여 사용자 인터페이스의 응답성을 떨어뜨리지 않고 백그라운드 작업을 효과적으로 처리할 수 있습니다 [10].
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+
+- [[React Server Components]]
+  - 연결 이유: Next.js App Router 아키텍처의 핵심 기반으로, 번들 크기를 줄이고 데이터 페칭 성능을 향상시키는 역할을 합니다 [1, 2].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 클라이언트 측 렌더링 코드와 서버 측 렌더링 코드 간의 명확한 경계 구분 및 Hydration 최소화 전략 [6, 7, 9].
+
+- [[Route Groups]]
+  - 연결 이유: App Router 내에서 URL 경로를 변경하지 않고도 폴더 구조를 논리적으로 조직할 수 있게 해주는 핵심 폴더 라우팅 패턴입니다 [5, 11].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 복잡한 애플리케이션에서 별도의 레이아웃을 가진 섹션(예: 마케팅 페이지와 상점 페이지)을 충돌 없이 독립적으로 분리하는 방법 [5, 11].
+
+- [[Concurrent Rendering]]
+  - 연결 이유: Next.js App Router가 기본적으로 완벽하게 지원하는 React의 렌더링 메커니즘으로, 렌더링 작업을 일시 중지, 중단 및 재개할 수 있게 해줍니다 [10, 12].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: `useTransition` 및 `useDeferredValue` 훅을 통해 무거운 렌더링 시에도 사용자 입력 반응성(UX)을 높게 유지하는 원리 [13, 14].
+
+### Deeper Research Questions
+
+- 여러 개의 루트 레이아웃을 가진 Route Groups 환경에서 최상위 `layout.js`가 없을 때, 다른 루트 레이아웃 간의 네비게이션 시 발생하는 전체 페이지 로드(full page load)의 내부 메커니즘은 무엇인가? [11]
+- App Router에서 `[param]` 형태의 동적 라우트와 Route Group 간의 경로 중복(예: `(marketing)/about/page.tsx`와 `(shop)/about/page.tsx`) 충돌 시, Next.js의 라우트 해석 우선순위는 어떻게 결정되는가? [11]
+- 기존 Pages Router 방식과 비교하여 App Router의 React Server Components는 데이터 페칭 시 어떻게 'Double Fetching' 문제를 해결하고 성능을 최적화하는가? [7, 8]
+- 클라이언트 컴포넌트(`use client`)와 서버 컴포넌트가 혼합된 형태의 트리에서, 서버 컴포넌트가 클라이언트 컴포넌트를 `children`으로 전달하거나 임포트할 때 적용되는 직렬화 규칙 및 한계점은 무엇인가? [6, 7, 9]
+- 특수 라우팅 파일 중 `error.js`가 React Error Boundary로서 동작할 때 서버 컴포넌트 오류와 클라이언트 컴포넌트 오류를 각각 처리하는 흐름은 어떻게 구분되는가? [3]
+
+### Practical Application Contexts
+
+- **Implementation:** 라우트를 구현할 때는 `kebab-case` 명명 규칙을 적용한 폴더(예: `auth-provider.tsx`)를 생성하여 라우팅하고, 대시보드처럼 정적인 레이아웃은 서버 컴포넌트로 두면서 `AddToCartButton` 같이 상호작용이 필요한 위젯만 `use client` 컴포넌트로 임포트하여 구현합니다 [4, 7, 15].
+- **System Design:** 애플리케이션 코드를 조직할 때, 기능별(Feature-Based) 폴더 구조를 사용하여 컴포넌트, 페이지, 유틸리티를 한 기능 폴더(예: `features/auth/`)에 모으고, 이를 다시 `Route Groups`를 통해 모듈화된 아키텍처로 설계합니다 [5, 16, 17].
+- **Operation / Maintenance:** 초기 자바스크립트 번들 용량이 커져 INP(Interaction to Next Paint)와 TTI(Time to Interactive) 등 코어 웹 바이탈 수치가 저하될 때, 어떤 컴포넌트가 불필요하게 클라이언트 사이드로 로드되었는지 파악하여 서버 컴포넌트로 마이그레이션 하는 유지보수를 진행합니다 [6, 18].
+- **Learning Path:** 우선 React의 렌더링 모델 트리거 요인과 상태 변화 원리를 숙지하고 [19], 이후 React 18의 동시성 훅(`useTransition`) 동작을 실습한 뒤 [12, 13], Next.js App Router의 Server Components를 통한 서버/클라이언트 경계 개념을 배우는 순서로 접근해야 합니다 [2, 7].
+- **My Project Relevance:** 소스에 관련 정보가 부족합니다.
+
+### Adjacent Topics
+
+- [[Code Splitting & Lazy Loading]]
+  - 확장 방향: App Router의 Server Components뿐만 아니라, `React.lazy`와 `Suspense`를 결합하여 라우트 및 무거운 컴포넌트(차트, 에디터 등)를 필요한 순간에만 로드하도록 최적화하는 기법으로의 이해 확장 [20, 21].
+- [[React Context API Optimization]]
+  - 확장 방향: App Router 환경 하의 클라이언트 컴포넌트 내에서 불가피하게 전역 상태를 쓸 때, Context의 광범위한 리렌더링 이슈를 회피하기 위해 컨텍스트를 분리하거나 Zustand, Jotai 등의 외부 라이브러리를 도입하는 방향으로 학습 확장 [22-24].
+
+---
+*Last updated: 2026-04-30*
\ No newline at end of file
diff --git a/10_Wiki/Development/Prop Drilling.md b/10_Wiki/Development/Prop Drilling.md
new file mode 100644
index 00000000..aea73383
--- /dev/null
+++ b/10_Wiki/Development/Prop Drilling.md	
@@ -0,0 +1,56 @@
+# [[Prop Drilling]]
+
+## 📌 Brief Summary
+Prop Drilling은 실제로 해당 데이터가 필요하지 않은 여러 중간 컴포넌트들을 거쳐 계층적으로 데이터를 전달하는 안티 패턴을 의미합니다 [1]. 주로 깊게 중첩된 하위 컴포넌트에 상태나 데이터를 전달해야 할 때 발생합니다 [1]. React 생태계에서는 이 문제를 해결하기 위해 내장된 Context API나 외부 상태 관리 라이브러리를 활용합니다 [1, 2].
+
+## 📖 Core Content
+*   **작동 방식 및 원인:** Prop Drilling은 데이터를 부모 컴포넌트에서 깊이 중첩된 자식 컴포넌트로 전달하기 위해, 중간에 위치한 모든 컴포넌트의 props를 통해 데이터를 통과시키는 방식입니다 [1].
+*   **구조적 문제점:** 이 패턴은 중간 컴포넌트들이 자신에게 필요 없는 데이터를 단지 전달(transport)하기 위한 목적으로 취급하게 만들며, 이는 코드의 복잡성을 높이고 유지보수를 어렵게 만듭니다 [1].
+*   **React의 내장 해결책:** React는 이러한 현상을 해결하기 위해 'Context API'를 도입했습니다. 이를 통해 컴포넌트 트리의 모든 레벨을 거치지 않고도 전역 관심사(global concerns) 데이터를 직접적으로 하위 컴포넌트와 공유할 수 있습니다 [1, 3, 4].
+*   **파생 상태 처리의 한계:** Redux나 Zustand가 파생 상태를 위한 선택자(derived selectors)를 지원하는 것과 달리, Context는 파생 상태를 관리할 때 여전히 Prop Drilling 방식에 의존하게 되거나 불필요한 리렌더링을 피하기 어려운 기능적 한계가 있습니다 [5].
+
+## ⚖️ Trade-offs & Caveats
+Prop Drilling을 피하기 위해 가장 먼저 고려되는 Context API는 빈번하게 변경되는 상태를 다룰 때 심각한 성능 제약(Trade-off)을 동반합니다 [6, 7]. Context 값의 일부만 변경되어도 해당 Context를 구독하는 모든 컴포넌트가 불필요하게 전체 리렌더링(re-render)을 수행하게 됩니다 [6, 8]. 
+
+따라서 장바구니나 실시간 데이터 등 빈번하게 변경되는 상태에 대해 Prop Drilling을 피하겠다고 무작정 Context API를 사용하면 애플리케이션의 성능 저하(Re-render storm)를 초래할 수 있습니다 [9, 10]. 이러한 경우에는 선택자(Selector) 기능을 통해 필요한 상태 변경 시에만 리렌더링을 발생시키는 Zustand나 Redux를 사용하는 것이 최적화 측면에서 필수적인 반대 급부의 해결책이 됩니다 [7, 11].
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+
+#### [기반 기술/해결책]
+- [[Context API]]
+  - 연결 이유: Prop Drilling 문제를 해결하기 위해 React에서 자체적으로 도입한 내장 데이터 전달 메커니즘이기 때문입니다 [1].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: props를 일일이 넘기지 않고 컴포넌트 트리에 데이터를 브로드캐스트하는 원리와 그에 따른 리렌더링 한계를 이해할 수 있습니다 [6, 12].
+
+#### [상태 관리 도구/대안]
+- [[Zustand]]
+  - 연결 이유: Prop Drilling의 대안인 Context API가 갖는 리렌더링 성능 문제를 극복할 수 있는 경량 상태 관리 라이브러리이기 때문입니다 [2, 7].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 선택자(Selector) 패턴을 활용해 필요한 상태의 변경에만 컴포넌트를 리렌더링하도록 스마트하게 구독(subscribe)하는 구조를 이해할 수 있습니다 [7, 13].
+- [[Redux]]
+  - 연결 이유: 대규모 애플리케이션에서 Prop Drilling을 방지하고 상태를 일관성 있게 관리하기 위한 산업 표준 상태 컨테이너 도구이기 때문입니다 [5, 14].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 파생 선택자(derived selectors)가 존재함으로써 Prop Drilling 없이 복잡한 상태와 비동기 로직을 어떻게 효율적으로 다루는지 파악할 수 있습니다 [5, 15].
+
+### Deeper Research Questions
+
+- Prop Drilling을 피하기 위해 Context API를 사용할 때 발생하는 불필요한 리렌더링(re-renders) 문제는 어떤 방식으로 최적화할 수 있는가? [6, 8]
+- Redux와 Zustand가 제공하는 '선택자(Selector)' 기능은 Prop Drilling 방식과 비교하여 파생 상태(derived state)를 처리할 때 어떠한 아키텍처적 이점을 제공하는가? [5, 7]
+- Context API가 아닌 Zustand나 Redux 같은 전문적인 상태 관리 도구를 도입하여 Prop Drilling을 해결해야 하는 애플리케이션의 복잡도 및 컴포넌트 렌더링 빈도의 정확한 기준점은 무엇인가? [10, 11]
+- Prop Drilling을 단순히 회피하기 위해 모든 상태를 전역 컨텍스트(Global Context for Everything)에 넣는 안티 패턴은 시스템 아키텍처에 어떤 부작용을 일으키는가? [16, 17]
+- 전역 상태가 아닌 지역 컴포넌트 트리 내에서 발생하는 Prop Drilling을 해결하기 위해, 컴포넌트 합성(Component Composition)이나 클린 코드 원칙을 적용하는 방법은 무엇인가? [18, 19]
+
+### Practical Application Contexts
+
+- **Implementation:** 깊게 중첩된 하위 컴포넌트에 데이터를 전달할 때, 중간 컴포넌트들이 불필요한 props를 거치지 않도록 `React.createContext()`를 활용해 데이터 제공자(Provider)와 소비자(Consumer)를 분리하여 구현합니다 [1, 12].
+- **System Design:** 테마나 언어 설정과 같은 정적인 전역 관심사(global concerns)에 대한 Prop Drilling을 방지하기 위해서는 Context API를 설계에 반영하지만, 상태 변경이 잦은 영역은 Zustand나 Redux 기반의 스마트 알림 시스템(smart notification system) 구조로 설계하여 관심사와 성능을 모두 챙깁니다 [4, 13, 20].
+- **Operation / Maintenance:** 성능 모니터링 툴(예: React DevTools Profiler)을 통해 Prop Drilling을 우회하고자 도입한 Context가 리렌더링 폭풍(re-render storm)을 일으키는지 추적하고, 병목 발생 시 Selector를 지원하는 상태 관리 도구로 점진적 마이그레이션(Incremental Migration)을 수행합니다 [8, 9, 21].
+- **Learning Path:** React 입문 시 데이터 흐름의 기본인 Prop Drilling의 불편함을 먼저 경험하고, 이를 해결하는 Context API를 학습한 후, 최종적으로 대규모 앱을 위한 Zustand나 Redux로 발전해 나가는 형태의 학습 경로를 밟는 것이 권장됩니다 [22].
+- **My Project Relevance:** 소스에 관련 정보가 부족합니다.
+
+### Adjacent Topics
+
+- [[Re-renders]]
+  - 확장 방향: Prop Drilling을 피하기 위한 수단(Context API)이 초래하는 부작용인 불필요한 렌더링을 방지하기 위한 메모이제이션(`React.memo`, `useMemo`, `useCallback`) 등 React 런타임 성능 최적화 기법으로의 이해 확장이 필요합니다 [3, 6, 23].
+
+---
+*Last updated: 2026-04-30*
\ No newline at end of file
diff --git a/10_Wiki/Development/Re-renders Optimization.md b/10_Wiki/Development/Re-renders Optimization.md
new file mode 100644
index 00000000..be2c3213
--- /dev/null
+++ b/10_Wiki/Development/Re-renders Optimization.md	
@@ -0,0 +1,54 @@
+# [[Re-renders Optimization]]
+
+## 📌 Brief Summary
+Re-renders Optimization은 React 애플리케이션에서 불필요한 컴포넌트 업데이트를 최소화하여 성능, 반응성 및 사용자 경험을 향상시키는 과정입니다 [1, 2]. 주로 상태(state), 속성(props), 컨텍스트(context)의 변경으로 인해 발생하는 과도한 렌더링을 타겟으로 합니다 [3]. 이를 위해 수동 메모이제이션, 상태 관리 최적화, 가상화 기법, 그리고 React Compiler와 같은 최신 자동화 도구를 활용하여 병목 현상을 방지합니다 [4-6].
+
+## 📖 Core Content
+*   **리렌더링의 원인과 성능적 영향:**
+    React 컴포넌트는 내부 상태(state) 변경, 속성(props) 변경, 구독 중인 컨텍스트(context) 값 변경, 혹은 부모 컴포넌트가 리렌더링될 때 업데이트됩니다 [3]. 불필요한 리렌더링이 누적되면 UI 반응성 저하, 메모리 사용량 증가, 상호작용성(TTI) 지연 등을 초래하며, 깊은 컴포넌트 트리에서는 스크립팅 시간을 30~60%까지 증가시킬 수 있습니다 [2].
+*   **수동 메모이제이션 (Manual Memoization):**
+    `React.memo()`를 사용하면 props가 변경되지 않은 경우 이전 렌더링 결과를 재사용하여 렌더링 횟수를 30~50%가량 줄일 수 있습니다 [7, 8]. 이와 함께 `useCallback`과 `useMemo` 훅을 사용하여 객체나 함수의 참조 동등성(Reference Equality)을 유지해야 자식 컴포넌트의 불필요한 렌더링을 막을 수 있습니다 [9, 10]. 단, 무분별한 사용은 비교 연산의 오버헤드를 발생시키므로 프로파일링을 통해 확인된 병목 구간에만 적용해야 합니다 [11, 12].
+*   **컨텍스트 최적화 (Context Optimization):**
+    React의 기본 Context API는 값의 일부만 변경되어도 해당 컨텍스트를 구독하는 모든 컴포넌트를 리렌더링합니다 [13, 14]. 이를 해결하기 위해 컨텍스트를 작은 도메인 단위로 쪼개거나 [15], 선택자(Selector)를 통해 상태의 특정 조각이 변경될 때만 리렌더링을 트리거하는 Zustand, Jotai 등의 외부 상태 관리 라이브러리를 사용하는 것이 권장됩니다 [16-18].
+*   **React Compiler의 도입:**
+    빌드 타임 최적화 도구인 React Compiler는 수동 메모이제이션(`useMemo`, `useCallback`, `React.memo`) 코드를 작성하지 않아도 컴파일 단계에서 자동으로 캐싱 로직을 삽입합니다 [4, 19]. 컴포넌트 전체가 아닌 개별 JSX 요소 단위로 세분화하여 메모이제이션을 수행함으로써, 코드의 가독성을 높이고 불필요한 렌더링을 원천적으로 차단합니다 [19, 20].
+*   **렌더링 패턴 및 동시성 최적화:**
+    수백 개 이상의 항목을 렌더링하는 대규모 리스트에서는 고유하고 안정적인 `key` 속성을 부여하고, 화면에 보이는 항목만 렌더링하는 가상화(Windowing) 라이브러리(예: `react-window`)를 적용하여 DOM 오버헤드를 줄여야 합니다 [6, 21]. 또한 JSX 내부에 익명 함수를 직접 작성하면 매 렌더링마다 새로운 참조가 생성되므로 지양해야 합니다 [22, 23]. 부가적으로 `useTransition` 및 `useDeferredValue`와 같은 동시성 기능을 활용해 무거운 업데이트를 지연시키고 사용자 입력에 대한 UI 반응성을 우선순위에 둘 수 있습니다 [24, 25].
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+- [[React Compiler]]
+  - 연결 이유: 개발자가 수동으로 리렌더링을 최적화하던 기존 방식을 대체하여, 빌드 타임에 자동으로 메모이제이션을 적용하는 2025년 기준 핵심 기술이기 때문입니다 [4].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 컴포넌트 전체가 아닌 개별 JSX 요소와 연산이 어떻게 독립적으로 캐싱되는지의 원리와 서드파티 라이브러리 호환성 한계 [19, 26].
+
+- [[State Management (Zustand vs Context)]]
+  - 연결 이유: 불필요한 전체 리렌더링을 유발하는 Context API의 구조적 한계를 Zustand의 선택자(Selector) 패턴이 어떻게 극복하여 렌더링을 최적화하는지 설명하기 때문입니다 [13, 17].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 자주 변경되는 전역 상태 관리에서 React 렌더링 사이클 외부의 스토어가 어떻게 컴포넌트 렌더링을 정밀하게 제어하는지 [17, 27].
+
+- [[Memoization (useMemo, useCallback)]]
+  - 연결 이유: React의 얕은 비교(Shallow comparison) 특성을 극복하고 참조 동등성을 유지하여 `React.memo`와 결합한 리렌더링 최적화의 기반이 되기 때문입니다 [10].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 무분별한 메모이제이션이 오히려 렌더링 비용보다 큰 성능 오버헤드를 유발하는 이유와 올바른 적용 조건 [11, 12].
+
+### Deeper Research Questions
+- React Compiler가 적용된 환경에서 기존 `React.memo`, `useMemo`, `useCallback`으로 작성된 수동 메모이제이션 코드는 어떤 방식으로 리팩토링되거나 공존해야 하는가?
+- Context API를 다수의 작은 도메인으로 분할하는 아키텍처와 Zustand를 도입하여 선택자를 사용하는 아키텍처 간의 렌더링 성능 및 유지보수성 트레이드오프는 무엇인가?
+- 대규모 리스트에서 안정적인 `key` 속성 부여와 가상화(Windowing) 기법을 함께 적용할 때, DOM 노드 관리와 메모리 가비지 컬렉션 측면에서 내부적으로 어떤 최적화가 발생하는가?
+- JSX 내 익명 함수 사용이 유발하는 참조 변경(Reference change) 문제를 `useCallback` 외에 컴포넌트 외부 선언 방식 등으로 해결할 때 발생하는 상태 접근성 제약은 어떻게 극복할 수 있는가?
+- `useTransition`과 `useDeferredValue`를 활용한 동시성 렌더링(Concurrent rendering)이 리렌더링을 차단하지 않고 지연시킬 때, 무거운 연산이 메인 스레드를 점유하는 한계는 어떻게 보완할 수 있는가?
+
+### Practical Application Contexts
+- **Implementation:** 무거운 컴포넌트나 자식에게 전달되는 함수/객체 prop에 대해 `React.memo()`, `useCallback`, `useMemo`를 선택적으로 적용하여 리렌더링을 방지합니다 [7, 10]. 대규모 리스트 구현 시 `react-window`를 사용합니다 [6].
+- **System Design:** 애플리케이션의 전역 상태를 설계할 때, 테마나 다국어처럼 변경이 적은 정적 데이터는 Context API를, 알림이나 장바구니처럼 빈번하게 변경되는 동적 데이터는 부분 구독(Selector)을 지원하는 외부 상태 라이브러리(Zustand 등)로 설계하여 렌더링 범위를 제한합니다 [18, 28, 29].
+- **Operation / Maintenance:** React DevTools Profiler, `why-did-you-render` 라이브러리, Chrome DevTools Performance Tab을 활용하여 프로덕션 배포 전 및 운영 중에 불필요한 리렌더링과 그 원인을 지속적으로 측정하고 개선합니다 [30-32].
+- **Learning Path:** React의 기본 렌더링 동작 원리(상태, props, 참조 동등성)를 먼저 학습하고 수동 메모이제이션의 비용을 이해한 뒤, 동시성 기능(Concurrent Features)과 React Compiler를 통한 자동화 최적화 패러다임으로 지식을 확장합니다 [5].
+- **My Project Relevance:** 현재 유지보수하거나 새로 구축하는 React 프로젝트에서 성능 저하를 겪고 있다면, 익명 함수 인라인 작성 패턴을 수정하고, 불필요한 거대 Context를 분리하며, 식별 가능한 병목 지점에 프로파일링 기반의 메모이제이션을 적용해 즉각적인 성능 개선을 이룰 수 있습니다 [5, 15, 22].
+
+### Adjacent Topics
+- [[Core Web Vitals (INP, FCP, TTI)]]
+  - 확장 방향: 프론트엔드 코드의 리렌더링 최적화가 실제 사용자의 체감 성능을 측정하는 지표(특히 Interaction to Next Paint)에 브라우저 레벨에서 어떤 영향을 미치는지 확장하여 조사합니다 [2, 33].
+- [[Code Splitting & Lazy Loading]]
+  - 확장 방향: 컴포넌트 업데이트 시점(리렌더링)의 최적화뿐만 아니라, 컴포넌트 최초 로드 시점의 번들 크기를 줄여 초기 렌더링 성능을 극대화하는 `React.lazy`와 동적 임포트 기법을 함께 학습합니다 [34].
+
+---
+*Last updated: 2026-04-30*
\ No newline at end of file
diff --git a/10_Wiki/Development/React 18 Concurrent Features.md b/10_Wiki/Development/React 18 Concurrent Features.md
new file mode 100644
index 00000000..a5c653e9
--- /dev/null
+++ b/10_Wiki/Development/React 18 Concurrent Features.md	
@@ -0,0 +1,50 @@
+# [[React 18 Concurrent Features]]
+
+## 📌 Brief Summary
+React 18 Concurrent Features(동시성 기능)는 업데이트가 발생하는 시점과 방식을 제어하여 응답성을 희생하지 않으면서도 더 매끄러운 앱을 구축할 수 있게 해주는 기능이다 [1]. 이 렌더링 모델은 React가 렌더링 작업을 일시 중지(pause), 중단(interrupt), 재개(resume)할 수 있도록 허용하여 중요도에 따른 업데이트 우선순위 지정을 가능하게 한다 [2]. 대표적인 훅(Hook)인 `useTransition`과 `useDeferredValue`를 통해 느린 렌더링이 중요한 사용자 상호작용을 차단하지 못하게 방지할 수 있다 [3, 4].
+
+## 📖 Core Content
+*   **동시성 렌더링의 원리와 장점**
+    동시성 렌더링은 무거운 필터 업데이트와 같은 작업은 지연시키면서, 클릭이나 타이핑 등 중요하고 즉각적인 상호작용을 우선적으로 처리할 수 있게 한다 [2]. 최신 버전의 React에서는 개발자가 수동으로 활성화할 필요 없이 기본 동작으로 내장되어 작동한다 [2]. 이 기능은 앱을 실제로 더 빠르게 만든다기보다는, 백그라운드 작업이 진행되는 동안 UI의 응답성을 유지하여 사용자가 느끼는 체감 속도(perceived speed)를 우선시한다 [4].
+*   **`useTransition` (UX 응답성 우선순위 지정)**
+    이 훅은 특정 업데이트를 '비긴급(non-urgent)'으로 표시하는 역할을 한다 [3]. 예를 들어 라이브 검색 결과나 대규모 데이터를 필터링할 때, 렌더링 처리가 느려지더라도 사용자의 타이핑이나 클릭 같은 중요한 상호작용이 차단되지 않는다 [3]. 처리 대기 중인 상태(`isPending`)를 활용하여 렌더링을 차단하지 않고 로딩 스피너나 스켈레톤 상태를 표시할 수 있다 [3].
+*   **`useDeferredValue` (파생 데이터 처리 지연)**
+    `useTransition`이 업데이트가 트리거되는 시점을 제어한다면, `useDeferredValue`는 무거운 값을 '읽는(read)' 시점을 제어한다 [4]. 사용자의 타이핑과 같은 UI 변경은 즉각적으로 반영하되, 파생된 무거운 연산이나 필터링 로직은 약간 지연시켜 적용해야 할 때 이상적인 방법이다 [4]. 주로 검색 상자, Typeahead 입력기, 실시간 폼 등에서 끊김 현상(jank)을 줄이는 데 사용된다 [4].
+*   **모범 사례 및 프레임워크 생태계 지원**
+    동시성 기능은 앱의 모든 곳이 아닌 '인터랙티브 뷰'에 한정하여 사용해야 한다 [4]. 데이터가 로드되는 동안 대체 UI를 표시하기 위해 `Suspense`와 결합하는 것이 권장되며, 구형 상태 관리 라이브러리나 렌더링을 차단하는 안티 패턴과 함께 사용하는 것은 피해야 한다 [4]. 2025년 기준 Next.js(App Router), Remix, Vite 기반 환경 등 대다수의 풀스택 프레임워크가 동시성 렌더링을 기본적으로 연동하고 지원한다 [5].
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+- [[useTransition]]
+  - 연결 이유: React 18 동시성 기능의 핵심 훅으로, 비긴급 업데이트를 지연시키는 구체적인 구현체이다 [3].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 라이브 검색이나 필터링 시 렌더링 병목 현상을 방지하고, 어떻게 비긴급 작업과 긴급 상호작용(타이핑 등)을 분리하는지 이해할 수 있다 [3].
+- [[useDeferredValue]]
+  - 연결 이유: 값의 읽기를 지연시켜 UI 업데이트와 연산 부하를 분리하는 동시성 기능의 또 다른 핵심 훅이다 [4].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 즉각적인 UI 반영이 필요한 부분과 지연시켜도 무방한 무거운 계산(derived data)을 어떻게 나누어 처리하는지 알 수 있다 [4].
+- [[Suspense]]
+  - 연결 이유: 동시성 훅(`useTransition` 등)과 결합하여 백그라운드 렌더링이 진행되거나 데이터가 로드될 때 스켈레톤(fallback UI)을 보여줄 수 있도록 설계된 기능이다 [4].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 지연 중인 렌더링 상태에서 사용자의 경험(UX)을 어떻게 부드럽게 이어갈 수 있는지 이해할 수 있다 [4].
+
+### Deeper Research Questions
+- `useTransition`과 `useDeferredValue`를 사용할 때 React 내부적으로 메인 스레드의 유휴 시간(idle time)을 어떻게 판단하여 작업을 중단 및 재개하는가?
+- 구형 상태 관리 라이브러리나 클래스 기반 컴포넌트를 동시성 기능과 혼용했을 때 구체적으로 어떤 렌더링 차단 충돌이나 예외가 발생하는가?
+- 동시성 렌더링을 적용했을 때 Interaction to Next Paint (INP)나 Total Blocking Time (TBT)과 같은 Core Web Vitals 지표가 수치상으로 어떻게 변화하는가?
+- Next.js의 App Router와 결합된 동시성 렌더링에서, 서버 컴포넌트(Server Components)와 클라이언트 컴포넌트 간의 렌더링 우선순위는 어떻게 관리되는가?
+- `isPending` 속성을 활용해 대체 UI(스켈레톤, 스피너)를 구현할 때 시각적 깜빡임을 최소화하기 위한 이상적인 지연 시간 설계 패턴은 무엇인가?
+
+### Practical Application Contexts
+- **Implementation:** 라이브 검색 결과 렌더링이나 수천 개의 항목이 있는 데이터 목록을 필터링할 때 `useTransition`을 도입하여 입력창의 입력이 지연되지 않도록 구현한다 [3].
+- **System Design:** 검색 상자, Typeahead 입력기, 또는 실시간 폼을 설계할 때 즉각적인 입력 렌더링과 연산이 무거운 데이터 렌더링 간의 영향을 차단하기 위해 `useDeferredValue` 아키텍처를 도입한다 [4].
+- **Operation / Maintenance:** Chrome DevTools의 Performance 탭과 Web Vitals 지표를 통해 긴 작업(Long tasks)이 동시성 렌더링 덕분에 성공적으로 쪼개져 메인 스레드 차단을 줄였는지 지속적으로 모니터링한다 [6, 7].
+- **Learning Path:** React의 기본 렌더링 모델(props 및 state 변경에 따른 리렌더링 트리거)을 명확히 이해한 다음, 동시성 기능을 통해 이러한 렌더링 사이클이 어떻게 일시 중지되고 재개될 수 있는지 학습을 확장한다 [2, 8].
+- **My Project Relevance:** 현재 진행 중인 프로젝트에서 데이터가 많은 차트나 테이블 필터링 시 UI가 끊기는(Jank) 현상이 있다면, 이 동시성 기능 훅을 도입하여 즉각적인 클릭/입력 응답성을 확보할 수 있다 [3, 4].
+
+### Adjacent Topics
+- [[React Performance Optimization]]
+  - 확장 방향: 동시성 렌더링 외에도 불필요한 리렌더링 자체를 막는 `React.memo`, `useCallback`, `useMemo` 활용법과 같은 다양한 React 성능 최적화 기법 전반으로 지식을 확장할 수 있다 [9-11].
+- [[Server Components]]
+  - 확장 방향: Next.js에서 동시성 기능과 함께 성능 향상의 양대 축을 이루는 기능으로, 클라이언트 측 JavaScript를 전송하지 않고 서버에서 렌더링을 완료하여 번들 크기를 줄이는 전략을 학습할 수 있다 [12, 13].
+
+---
+*Last updated: 2026-04-30*
\ No newline at end of file
diff --git a/10_Wiki/Development/React Application Scaling.md b/10_Wiki/Development/React Application Scaling.md
new file mode 100644
index 00000000..3baf9301
--- /dev/null
+++ b/10_Wiki/Development/React Application Scaling.md	
@@ -0,0 +1,29 @@
+# [[React Application Scaling]]
+
+## 📌 Brief Summary
+리액트 애플리케이션 스케일링(React Application Scaling)은 애플리케이션의 크기와 복잡성이 증가함에 따라 발생하는 아키텍처, 성능, 상태 관리, 그리고 협업 문제를 체계적으로 해결하는 과정입니다 [1-3]. 이는 단순히 렌더링 속도를 높이는 것을 넘어, 비즈니스 로직과 UI의 결합을 막고, 예측 가능한 폴더 구조를 도입하며, 불필요한 리렌더링과 번들 크기를 최적화하는 것을 포함합니다 [2-5]. 결과적으로 대규모 팀이 안정적이고 유지보수하기 쉬운 프론트엔드 시스템을 구축할 수 있도록 돕는 핵심 엔지니어링 패러다임입니다 [3, 6].
+
+## 📖 Core Content
+*   **구조적 아키텍처 및 폴더 구성 (Architectural Paradigms):**
+    초기 리액트 앱은 컴포넌트나 훅을 기술적 파일 타입(Type-Based)으로 분리하지만, 앱이 커지면 기능 기반(Feature-Based) 또는 도메인 주도 구조로 전환해야 확장성을 확보할 수 있습니다 [7, 8]. 특히 **FSD(Feature-Sliced Design)**는 애플리케이션을 `app`, `pages`, `widgets`, `features`, `entities`, `shared` 등의 계층화된 슬라이스로 나누고, 하위 계층만 참조하도록 하는 단방향 의존성을 강제하여 코드 결합도를 낮추고 리팩토링을 용이하게 합니다 [9-11].
+*   **상태 관리 아키텍처 (State Management Evolution):**
+    단일한 전역 상태 도구에서 벗어나 데이터 특성에 맞는 도구를 선택해야 합니다 [12]. 테마나 로케일처럼 정적이고 변경이 적은 데이터는 Context API가 적합합니다 [13]. 반면 빈번하게 변경되는 동적 상태는 선택자(Selector) 패턴을 통해 리렌더링을 방지하는 Zustand가 유리하며, 복잡한 비동기 로직과 대규모 팀 협업에는 구조를 강제하는 Redux가 권장됩니다 [14-17]. 서버 상태 처리는 TanStack Query와 같은 API 계층용 도구로 완전히 분리해야 합니다 [16, 18].
+*   **성능 및 번들링 최적화 (Performance & Bundling):**
+    리액트는 상태나 프롭스가 변경될 때마다 하위 트리를 리렌더링합니다 [19]. 이를 방지하기 위해 `React.memo`, `useCallback`, `useMemo`를 전략적으로 사용하여 참조 안정성(Reference Equality)을 유지해야 합니다 [20, 21]. 초기 로딩 속도 개선을 위해서는 `React.lazy`와 라우트 레벨의 코드 스플리팅을 적용하고, Vite의 `manualChunks`를 활용해 React 코어 등 무거운 벤더 라이브러리를 별도 파일로 분리하여 캐싱 효율을 높입니다 [22-25]. 최근에는 React Compiler를 도입해 빌드 타임에 자동 메모이제이션을 수행하는 기법도 활용됩니다 [26-29].
+*   **코드 품질 및 복원력 (Quality & Resilience):**
+    SOLID, DRY, KISS, YAGNI 원칙을 준수하여 컴포넌트를 단일 책임(SRP)을 갖도록 간결하게 유지합니다 [30-32]. 파일명은 운영체제 호환성을 위해 `kebab-case`를, 리액트 컴포넌트는 `PascalCase`를 사용하는 등 네이밍 컨벤션을 통일합니다 [33-36]. 또한 특정 컴포넌트의 렌더링 오류가 전체 앱을 다운시키는 것을 막기 위해 에러 바운더리(Error Boundaries)를 중요 UI 섹션마다 배치하여 Fallback UI를 제공하는 복원력 있는 설계가 필수적입니다 [37-39].
+
+## ⚖️ Trade-offs & Caveats
+*   **과도한 엔지니어링 (Over-Engineering):** FSD나 Redux와 같은 고도화된 아키텍처와 상태 관리 도구를 소규모 프로젝트나 경험이 적은 팀에 도입하면, 학습 곡선이 크게 상승하고 불필요한 보일러플레이트 코드가 양산되어 오히려 개발 속도를 늦출 수 있습니다 [40-43].
+*   **메모이제이션의 오용에 따른 성능 저하:** `React.memo`나 `useMemo`를 무분별하게 사용하면, 이전 props 및 상태를 비교하는 과정에서 발생하는 연산 비용이 렌더링 비용 자체를 초과하여 오히려 애플리케이션의 성능을 악화시킬 수 있습니다 [44, 45].
+*   **React Compiler의 가시성 저하 및 호환성 제약:** 자동화된 최적화 도구인 React Compiler는 블랙박스처럼 작동하므로 성능 병목 발생 시 디버깅이 더 까다로워집니다 [46]. 또한 매 렌더링 시 의도적으로 불안정한 참조를 반환하는 서드파티 라이브러리(예: React Router, TanStack Query 일부 훅)와는 최적화 호환이 깨질 수 있으며, React 규칙을 지키지 않은 레거시 코드베이스에서는 적용이 어렵습니다 [47, 48].
+*   **Context API의 리렌더링 폭풍 (Re-render Storm):** Context API를 빈번하게 변하는 데이터 관리에 사용하면, 데이터 중 일부분만 변경되더라도 해당 컨텍스트를 구독하는 모든 하위 컴포넌트가 불필요하게 리렌더링되는 치명적인 성능 병목 현상을 유발합니다 [49, 50].
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+
+#### [아키텍처 및 폴더 구조 (Architecture & Structure)]
+- [[Feature-Sliced Design (FSD)]]
+  - 연결 이유: 확장 가능한 리액트 앱을 구축하기 위한 핵심 도메인 주도 아키텍처 방법론입니다.
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 기능, 위젯, 엔티티를 분리하고 단방향 의존성 규칙을 강제하여 결
\ No newline at end of file
diff --git a/10_Wiki/Development/React Codebase Refactoring.md b/10_Wiki/Development/React Codebase Refactoring.md
new file mode 100644
index 00000000..53140358
--- /dev/null
+++ b/10_Wiki/Development/React Codebase Refactoring.md	
@@ -0,0 +1,64 @@
+# [[React Codebase Refactoring]]
+
+## 📌 Brief Summary
+React 코드베이스 리팩토링은 기존 앱의 외부 동작을 변경하지 않으면서 유지보수성, 성능, 가독성을 향상시키기 위해 코드를 재설계하고 정리하는 과정입니다. 대규모 React 앱에서 자주 발생하는 논리 결합, 불필요한 재렌더링, 전역 상태의 남용 등의 아키텍처 문제를 해결하는 데 중점을 둡니다. 성공적인 리팩토링을 위해서는 단위 테스트로 안전망을 확보한 후, 컴포넌트 책임 분리, TypeScript 도입, 상태 관리 도구의 현대화를 점진적으로 수행하는 것이 권장됩니다 [1-3].
+
+## 📖 Core Content
+*   **테스트 주도 접근 (Test-Driven Approach):** 리팩토링 도중 기존 기능이 손상되는 것을 방지하기 위해 가장 먼저 단위 테스트(Unit Test)나 UI 테스트 스위트를 작성해야 합니다. 이를 통해 코드의 기존 동작을 보장하며 안전하게 수정할 수 있습니다 [2, 4, 5].
+*   **점진적 마이그레이션 (Incremental Migration):** 전체 코드를 한 번에 재작성(Rewrite)하는 것은 위험도가 높으므로, 점진적인 접근이 필요합니다. 예를 들어 Context API에서 Zustand로 상태 관리를 변경할 때, 하나의 스토어나 기능 단위로 단계별 마이그레이션을 진행해야 비즈니스 개발의 중단 없이 아키텍처를 현대화할 수 있습니다 [1].
+*   **구조 및 컴포넌트 책임 분리 (Separation of Concerns):** 300줄 이상의 방대한 컴포넌트는 단일 책임 원칙(SRP)에 따라 더 작고 초점이 맞춰진 컴포넌트로 분리해야 합니다 [6, 7]. 데이터 페칭이나 폼 처리와 같은 비즈니스 로직은 커스텀 훅(Custom Hooks)으로 추출하여 UI 컴포넌트와 완전히 분리하는 것이 좋습니다 [8, 9].
+*   **상태 관리의 현대화:** 과거의 거대한 단일 전역 상태를 역할에 맞게 분리해야 합니다. API에서 가져오는 '서버 상태'는 TanStack Query(React Query)와 같은 데이터 페칭 라이브러리에 위임하고, '클라이언트 상태'는 Zustand와 같은 가벼운 라이브러리나 지역 상태(Local State)를 활용하여 관리하도록 개선해야 합니다 [10-12].
+*   **도구 및 컨벤션의 적용:** JavaScript 기반 코드는 TypeScript로 마이그레이션하여 타입 안정성을 확보하는 것이 좋습니다 [3, 11]. 또한, ESLint와 같은 도구를 도입해 코드 포맷팅과 아키텍처 규칙(예: 모듈 간 의존성 규칙)을 자동으로 강제해야 하며, 인라인 스타일이나 여러 방식이 혼재된 CSS를 한 가지 방식(예: CSS Modules, Tailwind 등)으로 통일해야 합니다 [13-15].
+*   **과거의 패턴 제거:** 클래스형 컴포넌트가 있다면 함수형 컴포넌트와 훅(Hooks)으로 교체해야 합니다 [11]. 최신 React(예: React 19)나 React Compiler를 사용하는 환경이라면 불필요한 `useEffect`, `useMemo`, `useCallback` 등을 제거하여 코드를 더욱 간결하게 만들 수 있습니다 [11, 16, 17].
+
+## ⚖️ Trade-offs & Caveats
+*   **추상화의 함정과 오버엔지니어링 (KISS vs DRY):** DRY(Don't Repeat Yourself) 원칙을 따르기 위해 성급하게 공통 로직을 추상화하면, 코드가 원래의 반복된 코드보다 더 복잡해지고 이해하기 어려워지는 부작용이 발생할 수 있습니다. 전문가들은 패턴이 3번 이상 반복될 때까지 기다렸다가 추상화(Custom Hook 등)를 진행할 것을 권장합니다 [18].
+*   **TypeScript 채택의 인지적 부하:** 리팩토링 시 TypeScript를 도입하는 것은 장기적 안정성을 보장하지만, 경험이 부족한 개발팀에게는 새로운 복잡성 레이어로 작용하여 초기에 생산성을 늦출 수 있습니다. 따라서 강제 도입보다는 개별 파일부터 점진적으로 전환하는 것이 추천됩니다 [3].
+*   **아키텍처 도입 비용:** Feature-Sliced Design(FSD)과 같이 엄격한 계층 구조를 강제하는 아키텍처로 폴더 구조를 리팩토링하는 것은 큰 학습 곡선과 설정 비용을 수반합니다. 팀 전체의 이해도가 없으면 오히려 시스템이 엉망이 되거나 소규모 프로젝트에서는 과도한 설계(Overkill)가 될 수 있습니다 [19-21].
+*   **완전 재작성(Rewrite)의 위험성:** 프로젝트가 매우 작다면 아예 처음부터 새로 작성하는 것이 빠를 수도 있으나 [4], 일반적인 환경에서는 기존 기능을 그대로 유지하면서 코드를 개선해야 하므로 전면 재작성보다는 안전성을 담보한 점진적 리팩토링이 필수적입니다 [1].
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+
+#### [관계 유형 A (아키텍처/기반 기술)]
+- [[Feature-Sliced Design]]
+  - 연결 이유: 리팩토링 과정에서 기술 단위(Component, Hooks 등)로 흩어진 기존 폴더 구조를 기능(Feature) 중심으로 모듈화하고 재편할 때 기준이 되는 현대적인 프론트엔드 아키텍처론입니다 [22, 23].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 확장성을 위한 단방향 의존성 규칙과 도메인 중심의 코드 캡슐화 설계 방법.
+- [[SOLID Principles]]
+  - 연결 이유: 거대한 React 컴포넌트를 작게 분리하고 인터페이스를 구성할 때, 단일 책임 원칙(SRP)과 같은 클린 코드의 기반 지침을 제공합니다 [6, 24].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 리액트 컴포넌트의 책임을 올바르게 분리하고 유지보수하기 쉬운 추상화를 설계하는 기준.
+
+#### [관계 유형 B (구현/활용 도구)]
+- [[TanStack Query]]
+  - 연결 이유: 기존의 비효율적인 Context API나 거대한 Redux 스토어를 리팩토링할 때, 서버 상태(캐싱, 동기화 등)를 깔끔하게 분리해 주는 핵심 도구입니다 [10, 11].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 서버 데이터 페칭 로직의 분리와 컴포넌트 내 복잡한 상태 관리 감소 방법.
+- [[Zustand]]
+  - 연결 이유: 불필요한 재렌더링을 유발하는 기존의 Context API 기반 상태 관리를 리팩토링할 때 주로 도입되는 경량 클라이언트 상태 관리 라이브러리입니다 [1, 25].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 상태 선택자(Selector)를 통한 렌더링 최적화 구조 및 보일러플레이트 없는 상태 관리 로직 작성법.
+- [[Unit Testing]]
+  - 연결 이유: 리팩토링 시 코드를 변경하더라도 기존의 비즈니스 로직이 파괴되지 않음을 보장하기 위해 리팩토링 작업에 선행되어야 하는 기술입니다 [2, 5].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 기존 코드를 검증 가능한 형태로 쪼개고 안전성을 확보하는 실질적인 엔지니어링 절차.
+
+### Deeper Research Questions
+- 레거시 React 앱에서 Context API를 Zustand로 점진적으로 마이그레이션할 때(Incremental Migration), 상태 충돌을 방지하기 위한 가장 안전한 전략은 무엇인가?
+- 대규모 리팩토링 진행 시, Feature-Sliced Design(FSD) 아키텍처를 도입할 때 기존 컴포넌트 간의 결합(Cross-cutting concerns)을 어떻게 계층적으로 분리할 수 있는가?
+- React Compiler 환경이 도입되었을 때, 리팩토링 시 기존 코드에 남용된 `useMemo`와 `useCallback`을 제거하는 것이 런타임 성능 및 코드 가독성에 어떤 구체적인 이점을 주는가?
+- 비즈니스 로직이 혼재된 거대한 폼(Form) 컴포넌트를 리팩토링할 때 단일 책임 원칙(SRP)과 YAGNI 원칙 간의 균형을 맞추는 기준은 무엇인가?
+- 대규모 TypeScript 마이그레이션을 진행할 때 개발 생산성 저하를 방지하면서 점진적 타입 정의를 적용하는 모범 사례는 무엇인가?
+
+### Practical Application Contexts
+- **Implementation:** 비대해진 React 컴포넌트에서 API 호출과 상태 관리 로직을 분리하여 Custom Hook으로 작성하고, ESLint를 도입하여 코드 컨벤션과 아키텍처 규칙 위반을 린트(Lint) 단계에서 차단합니다.
+- **System Design:** 프로젝트의 파일 디렉토리 구조를 단순한 기능별(File-type based) 분류에서 Feature-Sliced Design과 같은 도메인/비즈니스 중심의 계층형 구조로 재설계합니다.
+- **Operation / Maintenance:** 서비스를 중단하지 않기 위해 한 번에 모든 시스템을 바꾸지 않고, 하나의 스토어나 특정 기능 모듈 단위로 리팩토링을 수행하는 점진적 접근법을 운영합니다.
+- **Learning Path:** React 기초 습득 ➔ Clean Code 및 SOLID 원칙 이해 ➔ 상태 관리의 세분화(서버 데이터 vs UI 상태) ➔ 단위 테스트 작성 ➔ 점진적 리팩토링 적용 순으로 엔지니어링 역량을 확장합니다.
+- **My Project Relevance:** 현재 유지보수하고 있는 복잡한 레거시 React 프로젝트의 성능 및 유지보수성 저하 원인을 분석하고, 컴포넌트 분리와 상태 관리 라이브러리(Zustand, React Query) 교체 작업을 체계적으로 기획할 때 직접 적용할 수 있습니다.
+
+### Adjacent Topics
+- [[Web Performance Optimization]]
+  - 확장 방향: 리팩토링의 궁극적 결과물 중 하나인 초기 로딩 속도 향상, 렌더링 최적화, 그리고 불필요한 번들 사이즈를 줄이는 코드 스플리팅(Code Splitting) 기법 등으로 개념을 확장하여 학습할 수 있습니다.
+- [[Git Workflow & CI/CD]]
+  - 확장 방향: 대규모 리팩토링 시 발생할 수 있는 브랜치 충돌 방지와 코드 리뷰 자동화, 그리고 Pull Request 과정에서 Visual Regression Testing을 연동하는 등 협업 전략으로 확장할 수 있습니다.
+
+---
+*Last updated: 2026-04-30*
\ No newline at end of file
diff --git a/10_Wiki/Development/React DevTools Profiler.md b/10_Wiki/Development/React DevTools Profiler.md
new file mode 100644
index 00000000..0ed6a720
--- /dev/null
+++ b/10_Wiki/Development/React DevTools Profiler.md	
@@ -0,0 +1,52 @@
+# [[React DevTools Profiler]]
+
+## 📌 Brief Summary
+React DevTools Profiler는 React 애플리케이션의 렌더링 성능을 측정하고 최적화 대상을 식별하기 위해 React DevTools에 내장된 프로파일링 및 디버깅 도구이다 [1]. 이 도구는 어떤 컴포넌트가 언제, 얼마나 오래 렌더링되었는지, 그리고 어떤 요인(props, state 변경 등)이 렌더링을 유발했는지 파악하는 데 사용된다 [1, 2]. 주로 로컬 개발 환경에서 성능 병목 현상을 식별하고 불필요한 리렌더링을 찾아내는 데 핵심적으로 활용된다 [3].
+
+## 📖 Core Content
+* **렌더링 추적 및 시각화**: Profiler는 특정 props나 상태(state) 변경 등 컴포넌트의 렌더링이 발생한 정확한 원인을 추적할 수 있게 해준다 [1, 2]. 플레임그래프(Flamegraph)와 순위 뷰(Ranked views)를 제공하여 성능 병목 지점을 시각적으로 쉽게 식별할 수 있도록 돕는다 [2].
+* **최적화 필요성 검증 (측정 기반 최적화)**: `React.memo`와 같은 메모이제이션 기술을 적용하기 전에, 컴포넌트의 리렌더링 비용이 최적화 오버헤드를 감수할 만큼 큰지 측정하는 데 사용된다 [4]. 또한, 메모이제이션된 컴포넌트 내의 prop 변경을 추적하여 자식 컴포넌트가 불필요하게 리렌더링되는지 파악할 수 있다 [5]. "측정하지 않았다면 최적화하지 말라"는 원칙에 따라, 프로파일링은 성능 핫스팟에만 집중하도록 돕는다 [2, 6].
+* **React Compiler 시각화**: React Compiler가 적용된 환경에서는 Profiler 탭에서 자동 최적화된 컴포넌트에 `Memo ✨` 배지가 표시된다 [7, 8]. 입력값이 변경되지 않아 리렌더링을 건너뛴 자식 컴포넌트는 회색으로 표시되며, 마우스를 올리면 자동 메모이제이션 및 리렌더링 생략 여부를 확인하는 툴팁이 나타난다 [8].
+* **블랙박스 환경에서의 디버깅 필수성**: React Compiler 도입 시 기존의 명시적인 `React.memo`, `useMemo`, `useCallback` 호출이 코드에서 사라져 렌더링 제어가 블랙박스처럼 작동하게 된다 [9]. 따라서 예상치 못한 리렌더링 문제가 발생했을 때, 이를 코드 상에서 확인하는 대신 Profiler를 통해 직접 조사해야 하므로 그 중요성이 더욱 커진다 [9].
+
+## ⚖️ Trade-offs & Caveats
+* **해석상의 주의점 (`Memo ✨` 배지의 함정)**: Profiler 탭에서 확인할 수 있는 `Memo ✨` 배지는 다소 오해를 불러일으킬 수 있다 [10]. 이 배지는 React Compiler가 해당 컴포넌트를 처리(Compile)했음을 나타낼 뿐, 최적화가 완벽하게 성공했음을 의미하지는 않는다 [10]. 컴포넌트에 배지가 표시되어 있더라도, 인라인 객체나 함수와 같은 불안정한 참조를 가진 props가 전달된다면 컴파일러가 리렌더링을 막지 못해 여전히 매번 렌더링이 발생할 수 있다 [10].
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+
+#### [관계 유형 A: 아키텍처/기반 기술]
+- [[React Compiler]]
+  - 연결 이유: React Compiler가 빌드 타임에 주입한 자동 메모이제이션 로직의 성공 여부와 렌더링 스킵 결과를 Profiler를 통해 시각적으로 확인할 수 있다 [7-9].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 명시적인 메모이제이션 코드 없이도 렌더링 성능이 최적화되는 원리와, 블랙박스화된 렌더링 메커니즘을 디버깅하는 방법 [9, 11].
+
+#### [관계 유형 B: 구현/활용 도구]
+- [[React.memo]]
+  - 연결 이유: Profiler를 통해 특정 컴포넌트의 렌더링 빈도와 비용을 측정한 뒤, 그 결과에 따라 `React.memo` 적용이 성능 향상에 실질적인 도움이 될지 판단할 수 있다 [4].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 얕은 비교(Shallow comparison)의 원리와 프로파일링 데이터에 기반한 전략적 메모이제이션 방법 [4, 12, 13].
+- [[useCallback & useMemo]]
+  - 연결 이유: Profiler에서 자식 컴포넌트가 참조(Reference) 변경 때문에 계속 리렌더링되는 것을 발견했다면, 이 훅들을 사용하여 참조 안정성(Reference stability)을 확보할 수 있다 [5, 14].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 함수나 객체의 참조 동일성이 컴포넌트 렌더링 트리에 미치는 직접적인 영향 [14].
+
+### Deeper Research Questions
+- React DevTools Profiler의 플레임그래프(Flamegraph)와 순위 뷰(Ranked view)를 어떻게 분석해야 성능 병목 현상을 가장 빠르고 정확하게 찾아낼 수 있는가?
+- 명시적인 메모이제이션 훅이 제거되는 React Compiler 환경에서, Profiler를 통한 성능 디버깅 워크플로우는 기존과 구체적으로 어떻게 달라지는가?
+- Profiler를 통해 식별된 불필요한 렌더링 문제를 해결할 때, 어떤 상황에서 구조 재설계(예: Context API 대신 Zustand 도입)가 단순한 메모이제이션 적용보다 더 나은 선택이 되는가?
+- 로컬 환경의 Profiler에서 관찰되는 렌더링 시간과 프로덕션 환경의 실제 사용자 체감 성능(Core Web Vitals의 INP 등) 간의 차이를 어떻게 보정하여 분석할 수 있는가?
+
+### Practical Application Contexts
+- **Implementation:** 렌더링 최적화 코드를 무작정 추가하기 전에, Profiler를 실행하여 실제 렌더링 빈도와 실행 시간을 측정함으로써 렌더링이 무거운(expensive) 컴포넌트를 정확히 식별한다 [4, 6].
+- **System Design:** Context API의 값이 변경될 때 얼마나 많은 자식 컴포넌트가 불필요하게 렌더링되는지 확인하고, 글로벌 상태 관리 라이브러리(Zustand 등) 도입이나 상태 도메인 분리의 기술적 타당성을 검증한다 [15-18].
+- **Operation / Maintenance:** 레거시 코드베이스를 유지보수하거나 새로운 기능을 릴리스한 직후, 플레임그래프를 정기적으로 리뷰하여 의도치 않은 성능 회귀(Regression)를 식별하고 관리한다 [19].
+- **Learning Path:** React 입문자나 팀원들이 Props, State, Context가 변경될 때 컴포넌트가 어떻게 반응하고 재렌더링되는지를 시각적으로 보여줌으로써 렌더링 모델을 깊게 이해시킨다 [1, 20].
+- **My Project Relevance:** 화면 내 대용량 리스트나 복잡한 필터를 조작할 때 발생하는 지연 현상(Jank)의 원인이 렌더링 시간 자체인지, 아니면 불필요한 연쇄 리렌더링 때문인지 진단하고 해결책을 마련한다 [21, 22].
+
+### Adjacent Topics
+- [[why-did-you-render]]
+  - 확장 방향: Profiler와 결합하여 사용할 수 있는 라이브러리로, 실제 데이터 변경이 없음에도 불구하고 컴포넌트가 리렌더링된 '정확한 이유'를 콘솔에 경고 형태로 남겨주어 디버깅을 더욱 쉽게 만들어주는 도구에 대해 조사한다 [3, 23].
+- [[Chrome DevTools Performance Tab]]
+  - 확장 방향: Profiler가 알려주는 React 내부의 렌더링 속도 이외에, 프레임 드롭이나 메인 스레드를 막는 무거운 자바스크립트 실행, 레이아웃 이동 등 브라우저 레벨의 전체적인 성능 분석으로 시야를 확장한다 [3, 23].
+
+---
+*Last updated: 2026-04-30*
\ No newline at end of file
diff --git a/10_Wiki/Development/React Frontend Architecture.md b/10_Wiki/Development/React Frontend Architecture.md
new file mode 100644
index 00000000..76200a99
--- /dev/null
+++ b/10_Wiki/Development/React Frontend Architecture.md	
@@ -0,0 +1,64 @@
+# [[React Frontend Architecture]]
+
+## 📌 Brief Summary
+React 프론트엔드 아키텍처는 확장 가능하고 유지보수하기 쉬운 애플리케이션을 구축하기 위한 구조적 뼈대이자 조직화 방법론이다 [1, 2]. 기존의 기술적 파일 단위 분리에서 벗어나, 비즈니스 도메인과 기능(Feature-Based)을 중심으로 코드를 구성하여 결합도를 낮추고 응집도를 높이는 것을 목표로 한다 [3-5]. 이를 통해 무분별한 비즈니스 로직의 UI 누수를 막고 명확한 상태 소유권을 확립하며, 팀과 코드베이스가 성장함에 따라 시스템이 예측 가능하게 확장할 수 있도록 돕는다 [6-8].
+
+## 📖 Core Content
+
+*   **폴더 구조와 모듈화의 진화**: 과거에는 컴포넌트, 훅, 스타일 등을 파일 유형별로 그룹화했으나, 프로젝트가 커질수록 논리적 기능이 파편화되어 탐색과 확장이 어려웠다 [4, 9]. 2025년 기준 프론트엔드 업계 표준은 비즈니스 기능을 중심으로 코드를 묶는 '기능 기반(Feature-Based)' 구조로 전환되었다 [5, 10]. 특정 기능과 관련된 컴포넌트, 훅, API 로직 등을 단일 디렉토리에 캡슐화함으로써 모듈의 독립성과 확장성을 크게 향상시킨다 [11, 12].
+*   **기능 분할 설계 (Feature-Sliced Design, FSD)**: FSD는 도메인 주도 설계(DDD)와 모듈형 아키텍처를 결합한 프론트엔드 전용 방법론이다 [3, 13]. 애플리케이션을 `app`, `pages`, `widgets`, `features`, `entities`, `shared`의 계층(Layer)으로 나누고, 상위 계층은 하위 계층에만 의존할 수 있다는 엄격한 '단방향 의존성' 규칙을 강제한다 [11, 14, 15]. 각 슬라이스는 `index.ts` 형태의 'Public API'를 통해서만 외부에 기능과 컴포넌트를 노출하여 내부 구현을 안전하게 캡슐화한다 [16-18].
+*   **상태 관리 아키텍처의 세분화**: 단일 모놀리식 스토어(예: 대규모 Redux)에 의존하던 방식에서 벗어나, 데이터의 성격에 따라 최적의 도구를 선택하도록 상태 관리가 파편화되었다 [19, 20]. 서버에서 가져오는 데이터인 '서버 상태'는 TanStack Query(React Query)를 이용해 캐싱 및 네트워크 로직을 격리하고, 테마나 설정 등 정적인 '전역 상태'는 Context API로, 장바구니나 실시간 데이터처럼 빈번하게 변하는 상태는 Zustand나 Jotai 등 선택적 렌더링을 지원하는 도구로 관리한다 [20-24].
+*   **소프트웨어 공학 원칙의 적용 (SOLID & Clean Code)**: React의 함수형 컴포넌트 개발에도 단일 책임 원칙(SRP)을 적용하여, 컴포넌트가 커지면 상태 관리, 데이터 페칭, 렌더링 등 각기 다른 책임을 가진 작은 컴포넌트로 분리해야 한다 [25, 26]. 중복을 피하는 DRY 원칙을 통해 공통 로직을 커스텀 훅으로 추출하면서도, 코드를 단순하게 유지하는 KISS 원칙과 미래를 위한 과도한 최적화를 피하는 YAGNI 원칙 간의 균형을 맞추는 것이 핵심이다 [27, 28].
+*   **명명 규칙과 거버넌스 도구**: 폴더와 파일 시스템은 OS 환경에 따른 오류를 방지하기 위해 `kebab-case`를, React 컴포넌트는 `PascalCase`를, 변수와 함수는 `camelCase`를 사용하는 것이 보편적인 컨벤션이다 [29-33]. 이러한 규칙과 아키텍처 의존성 경계는 ESLint나 Prettier, Husky와 같은 도구를 활용해 빌드 타임 및 커밋 단계에서 자동으로 강제(Linting)된다 [30, 34].
+
+## ⚖️ Trade-offs & Caveats
+
+*   **FSD 및 기능 기반 모듈화의 복잡성 오버헤드**: Feature-Sliced Design은 구조적 안정성을 제공하지만 "무엇이 하나의 기능(Feature)인가?"를 정의하는 경계를 설정하기 매우 까다롭다는 근본적 어려움이 있다 [35]. 인증(Auth)과 같은 교차 관심사(Cross-cutting concern)는 여러 기능에 걸쳐 있어 적절한 계층을 찾기 모호하며 [35, 36], 엄격한 분할 규칙을 소규모 프로젝트에 도입하면 오히려 불필요한 폴더 구조와 오버엔지니어링으로 인한 개발 속도 저하를 초래할 수 있다 [12, 37]. 또한, 규칙을 제대로 숙지하지 않으면 모든 코드를 'Shared' 계층에 쏟아부어 최악의 파급 효과를 낳는 스파게티 코드가 될 위험이 존재한다 [38, 39].
+*   **추상화(DRY)와 단순함(KISS)의 상충**: DRY 원칙에 집착하여 코드 중복을 무조건 피하려고 하면, 수많은 예외 처리와 분기를 포함하는 거대하고 복잡한 커스텀 훅이나 컴포넌트가 탄생하게 된다 [27]. 이러한 과도한 추상화는 단순한 코드 반복보다 가독성과 유지보수성을 떨어뜨려 KISS 원칙을 위반하는 반대 급부를 낳으므로, 명확한 패턴이 3번 이상 반복될 때까지는 추상화를 미루는 것이 권장된다 [27, 40, 41].
+*   **상태 관리 도구 선택에 따른 부작용**: React 내장 Context API는 외부 의존성 없이 상태를 주입할 수 있지만, 상태값의 일부만 변경되어도 해당 컨텍스트를 구독하는 모든 하위 컴포넌트가 강제로 리렌더링된다는 치명적인 성능 제약이 있다 [42, 43]. 반대로 Redux는 명확한 구조와 강력한 디버깅 툴을 제공하지만, 보일러플레이트 코드의 폭발적 증가를 동반하여 소규모 팀이나 간단한 애플리케이션에서는 과도한 기술 부채로 작용할 수 있다 [44, 45].
+*   **성능 최적화 기법의 숨은 비용**: `React.memo`, `useMemo`, `useCallback`은 불필요한 리렌더링을 막아주지만 그 자체가 공짜는 아니다 [46]. 이전 Props나 의존성 배열을 메모리에 저장하고 변경 여부를 얕은 비교(Shallow compare)하는 연산 비용이 추가된다 [46]. 만약 렌더링 비용이 매우 싼 컴포넌트에 사용하거나 불안정한 참조값(인라인 함수, 객체)을 지속적으로 전달하여 리렌더링 차단에 실패한다면, 최적화 코드 자체가 오히려 애플리케이션을 더 느리게 만드는 부작용이 발생한다 [46, 47].
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+
+#### [아키텍처 및 디자인 패턴]
+- [[Feature-Sliced Design]]
+  - 연결 이유: 현대 React 애플리케이션의 모듈화 및 계층화를 위해 고안된 가장 대표적이고 구체적인 프론트엔드 아키텍처 방법론이기 때문 [3, 13].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 도메인 기반 분할, 단방향 의존성 규칙 적용 방법, 그리고 Public API를 통한 컴포넌트의 캡슐화 원리 [14, 16, 17].
+- [[SOLID Principles]]
+  - 연결 이유: 확장 가능한 프론트엔드 구조를 짜기 위해 클래스 기반 OOP를 넘어 React의 함수형 컴포넌트에도 적용해야 하는 근본적인 소프트웨어 설계 원칙이기 때문 [17, 48].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 단일 책임 원칙(SRP)을 이용한 비대해진 컴포넌트의 리팩토링 방식 및 개방-폐쇄 원칙(OCP)을 활용한 UI 컴포넌트 합성(Composition) 전략 [25, 49].
+
+#### [상태 관리 및 최적화 전략]
+- [[State Management]]
+  - 연결 이유: 아키텍처 내에서 데이터(서버 데이터, 로컬 상태, 전역 UI 상태)의 성격에 따라 책임과 저장소를 어떻게 나눌지 결정하는 핵심 분야이기 때문 [20, 50].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: Context API의 렌더링 한계를 돌파하기 위한 Zustand/Jotai의 Selector 패턴 작동 원리 및 TanStack Query를 활용한 서버 상태 격리 기법 [21, 43, 51].
+- [[Performance Optimization]]
+  - 연결 이유: 대규모 아키텍처가 실제로 사용자 브라우저에서 효율적으로 동작하기 위해 필수적으로 수반되어야 하는 성능 지표(Web Vitals) 관리 방법이기 때문 [52, 53].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 지연 로딩(Lazy Loading) 및 코드 스플리팅을 통한 초기 번들 사이즈 최적화, 그리고 동시성 렌더링(Concurrent Rendering) 훅의 활용법 [54-56].
+
+### Deeper Research Questions
+- Feature-Sliced Design(FSD)에서 인증(Auth)이나 분석(Analytics) 같은 도메인 간의 교차 관심사(Cross-cutting concerns)가 발생할 때, 결합도를 높이지 않고 주입/공유하는 가장 이상적인 방법은 무엇인가?
+- React Compiler가 프로젝트에 성공적으로 도입되어 수동 메모이제이션 로직(`useMemo`, `useCallback`)이 대거 삭제될 때, 프론트엔드 폴더 구조와 코드 응집도에 어떤 형태의 구조적 변화가 일어날 수 있는가?
+- 서버 상태(Server State) 관리 라이브러리와 클라이언트 글로벌 상태(Client State) 도구를 완벽히 분리한 아키텍처에서, 두 상태가 불가피하게 동기화되거나 상호작용해야 하는 엣지 케이스를 깨끗하게 처리하는 패턴은 무엇인가?
+- 대규모 엔터프라이즈 환경에서 Micro-Frontends 아키텍처와 Feature-Sliced Design은 어떻게 호환되며, 각 독립 서비스 간의 중복 코드(Shared 레이어) 문제를 어떻게 통제할 수 있는가?
+- 복잡도 높은 순수 함수형 React 컴포넌트에 의존성 역전 원칙(DIP)을 적용할 때, 컨텍스트(Context API)나 프롭 드릴링(Prop Drilling)을 피하면서 활용할 수 있는 현대적인 제어 역전(IoC) 구현 패턴은 무엇이 있는가?
+
+### Practical Application Contexts
+
+- **Implementation:** 기술적 파일 유형(컴포넌트, 훅) 중심의 디렉토리 구조에서 벗어나, `src/features/` 내에 특정 비즈니스 로직(예: 장바구니, 유저 프로필)에 연관된 UI, API 통신, 로컬 훅을 캡슐화하여 구현한다 [5, 11, 57]. 
+- **System Design:** 모놀리식 글로벌 스토어 설계 지양. API 캐싱 및 서버 데이터는 TanStack Query를 사용해 비즈니스 로직 경계로 분리하고, 다크 모드 같은 앱 설정은 Context API로, 실시간 UI 상태 변경은 Zustand 등으로 쪼개어 시스템 데이터 흐름을 최적화한다 [20, 21, 24].
+- **Operation / Maintenance:** 런타임 크래시에 대비하기 위해 Error Boundary 컴포넌트를 앱의 최상단뿐 아니라 불안정한 서드파티 위젯이나 개별 라우트 단위에 감싸, 특정 모듈의 에러가 앱 전체의 "화이트 스크린" 장애로 번지는 것을 차단한다 [58-60].
+- **Learning Path:** React 기초 문법 및 렌더링 원리 파악 -> 컴포넌트 재사용과 SRP 원칙(SOLID) 학습 -> 기능 기반 폴더 구조 및 FSD 적용 방식 이해 -> 번들 최적화 및 렌더링 리팩토링 스킬 향상의 흐름으로 역량을 발전시킨다 [6, 17, 25].
+- **My Project Relevance:** 기존 코드베이스의 `components/` 폴더에 수십 개의 컴포넌트가 방치되어 있거나, `useCallback` 등이 과도하게 사용된 경우, 이를 비즈니스 도메인 단위의 폴더로 재배치하고 프로파일러(Profiler)를 통해 실제 병목 지점을 측정한 뒤 최적화를 진행하는 아키텍처 리팩토링에 직결된다 [12, 61, 62].
+
+### Adjacent Topics
+
+- [[Micro-Frontends]]
+  - 확장 방향: 단일 React SPA 아키텍처의 한계를 넘어, 독립적으로 배포 및 관리 가능한 여러 프론트엔드 팀과 서비스를 하나로 조율하는 엔터프라이즈급 인프라 확장 관점으로 연결 [3, 63].
+- [[Observability and Monitoring]]
+  - 확장 방향: 설계한 아키텍처가 실제 프로덕션 환경에서 어떻게 동작하고 어디서 병목을 일으키는지 측정하기 위한 구조적 로깅, 성능 프로파일링(Web Vitals), 그리고 Sentry를 활용한 세션 모니터링 기법으로 확장 [64-66].
+
+--- 
+*Last updated: 2026-04-30*
\ No newline at end of file
diff --git a/10_Wiki/Development/React Scalability.md b/10_Wiki/Development/React Scalability.md
new file mode 100644
index 00000000..6bd3e18d
--- /dev/null
+++ b/10_Wiki/Development/React Scalability.md	
@@ -0,0 +1,67 @@
+# [[React Scalability]]
+
+## 📌 Brief Summary
+React Scalability(React 확장성)는 기능, 팀 규모, 비즈니스 로직의 복잡성이 증가함에 따라 애플리케이션의 성능, 유지보수성, 예측 가능한 성장을 유지하는 능력을 의미합니다. 단순히 컴포넌트를 렌더링하는 것을 넘어, 결합도를 낮추고 응집도를 높이는 아키텍처 설계, 상태 관리의 최적화, 그리고 코드 스플리팅과 렌더링 성능 최적화를 포괄합니다. 확장 가능한 React 시스템은 명확한 폴더 구조(예: Feature-Sliced Design)와 엄격한 관심사 분리를 통해 코드베이스가 자체적인 무게로 인해 붕괴되는 것을 방지합니다. [1-4]
+
+## 📖 Core Content
+- **아키텍처 및 폴더 구조의 진화:** React는 기본적으로 아키텍처를 강제하지 않기 때문에, 프로젝트가 커지면 비즈니스 로직이 UI에 스며들고 의존성이 엉키는 아키텍처 붕괴가 발생하기 쉽습니다 [2]. 과거의 파일 유형별 폴더 구조(components, hooks, styles 등)는 규모가 커질수록 유지보수를 어렵게 만듭니다 [5, 6]. 확장 가능한 애플리케이션을 위해서는 도메인/기능 중심으로 코드를 구성하는 Feature-Based 구조 또는 **Feature-Sliced Design(FSD)**과 같은 방법론이 필수적입니다. FSD는 앱을 layers(app, pages, widgets, features, entities, shared)로 나누고 단방향 의존성 규칙과 퍼블릭 API 캡슐화를 강제하여 모듈의 독립성을 보장합니다 [7-11].
+- **클린 코드와 소프트웨어 엔지니어링 원칙:** 대규모 React 시스템에서는 SOLID, DRY, KISS, YAGNI와 같은 원칙이 적용되어야 합니다. 단일 책임 원칙(SRP)에 따라 거대한 컴포넌트는 작고 집중된 컴포넌트로 분리되어야 하며 [12], DRY 원칙을 통해 공통 로직은 커스텀 훅으로 추출하여 재사용성을 높여야 합니다 [13]. 더불어 파일 및 컴포넌트 명명 규칙(예: 파일은 kebab-case, 컴포넌트는 PascalCase)을 일관되게 유지하고 ESLint를 통해 아키텍처 경계를 강제하는 것이 대규모 팀 협업에 필수적입니다 [14, 15].
+- **규모에 따른 상태 관리 전략:** 애플리케이션이 커지면 단일 전역 상태만으로는 부족하며 상태의 역할에 따라 도구가 분리됩니다 [16]. React의 Context API는 값이 변경될 때마다 하위 컴포넌트 전체를 리렌더링시키므로 업데이트가 잦은 상태 관리에는 적합하지 않습니다 [17, 18]. 중간 규모의 앱에서는 Selector 패턴을 통해 불필요한 리렌더링을 막는 Zustand가 유용하며 [19-21], 500개 이상의 컴포넌트가 있는 대규모 앱이나 비동기 작업이 복잡한 경우 일관된 패턴과 강력한 디버깅을 제공하는 Redux가 산업 표준으로 작용합니다 [22, 23]. 서버 상태 관리는 TanStack Query(React Query) 등으로 클라이언트 상태와 분리하여 처리합니다 [20, 24].
+- **성능 엔지니어링 (Performance Optimization):** 확장 가능한 앱은 런타임 성능과 로딩 속도 최적화가 필수적입니다. `React.lazy`와 동적 임포트(Dynamic Imports)를 활용한 라우트 및 컴포넌트 레벨의 코드 스플리팅은 초기 번들 크기를 획기적으로 줄여줍니다 [25-27]. 또한 Vite의 `manualChunks`를 이용해 자주 변경되지 않는 Vendor 라이브러리를 분리하여 캐싱 효율을 높여야 합니다 [28-30]. 런타임 시에는 대규모 리스트를 위한 Virtualization(가상화) 처리, 안정적인 참조 유지를 위한 `useCallback`과 `useMemo` 사용, 그리고 React 18의 동시성 기능(`useTransition`, `useDeferredValue`)을 활용해 메인 스레드의 응답성을 유지합니다 [31-34].
+
+## ⚖️ Trade-offs & Caveats
+- **아키텍처의 오버헤드:** Feature-Sliced Design이나 도메인 기반 구조를 도입하면 컴포넌트가 '기능'인지 '위젯'인지 구분하기 위한 의미론적 논의가 필요해지는 등 초기 학습 곡선과 오버헤드가 발생합니다 [35, 36]. 소규모 프로젝트에서는 이러한 구조가 오히려 과도한 복잡성(Overkill)을 초래할 수 있습니다 [37].
+- **메모이제이션의 비용:** `React.memo`, `useMemo`, `useCallback`을 남용하면 오히려 성능이 저하될 수 있습니다. React가 이전 props를 저장하고 비교하는 작업에 오버헤드가 발생하며, 컴포넌트 렌더링 비용이 매우 작은 경우 이 비교 작업이 렌더링 자체보다 더 많은 비용을 소모할 수 있습니다 [38, 39]. 
+- **상태 관리 도구의 유연성 vs 보일러플레이트:** Zustand의 극단적인 유연성은 규율 없이 사용될 경우 팀원마다 서로 다른 비동기 처리 패턴을 작성하게 만드는 등 혼란을 야기할 수 있습니다 [19, 40]. 반면 Redux는 초기에 작성해야 하는 보일러플레이트가 매우 많아 개발 속도를 늦추지만, 대규모 팀에서는 오히려 이 구조가 버그를 방지하는 기능으로 작용합니다 [22, 41].
+- **React Compiler와 서드파티 라이브러리 호환성:** React Compiler를 도입하면 수동 메모이제이션의 필요성을 크게 줄일 수 있지만, `useMutation`이나 `useLocation`처럼 렌더링 시마다 의도적으로 새로운 객체를 반환하는 서드파티 라이브러리 훅과 함께 사용할 경우 캐싱 체인이 끊어지고 리렌더링이 발생하는 한계가 있습니다 [42, 43].
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+
+#### [아키텍처/기반 기술]
+- [[Feature-Sliced Design]]
+  - 연결 이유: React의 한계인 구체적인 아키텍처 부재를 해결하기 위해 설계된 대규모 프론트엔드 방법론입니다.
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 레이어(Layer) 간의 단방향 의존성 원칙과 Public API를 활용한 모듈의 캡슐화 및 결합도 최소화 방법.
+- [[SOLID Principles]]
+  - 연결 이유: 확장 가능하고 유지보수가 쉬운 React 코드를 작성하기 위한 핵심 소프트웨어 엔지니어링 원칙입니다.
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 거대한 컴포넌트를 단일 책임 원칙(SRP)에 따라 작은 기능으로 분리하고, 커스텀 훅을 활용하여 로직을 재사용하는 구조적 사고.
+
+#### [구현/활용 도구]
+- [[State Management Libraries (Redux, Zustand, Context API)]]
+  - 연결 이유: 애플리케이션의 크기와 상태 업데이트 빈도에 따라 적절한 도구를 선택하는 것은 확장성에 지대한 영향을 미칩니다.
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 불필요한 리렌더링 방지를 위한 Selector 패턴의 동작 원리와, 대규모 프로젝트에서 강제되는 상태 관리 아키텍처의 중요성.
+- [[Code Splitting & Lazy Loading]]
+  - 연결 이유: 코드가 비대해짐에 따라 발생하는 성능 저하(번들 크기 증가)를 해결하기 위한 핵심 런타임 최적화 기법입니다.
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: `React.lazy`와 Vite의 `manualChunks`를 이용한 번들 크기 축소 및 브라우저 캐싱 전략.
+- [[React Error Boundaries]]
+  - 연결 이유: 대규모 앱에서 하나의 결함 있는 컴포넌트로 인해 전체 애플리케이션이 붕괴되는 것을 막아주는 안전 장치입니다.
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 런타임 렌더링 에러를 격리(Isolate)하고 폴백(Fallback) UI를 제공하여 시스템 복원력을 높이는 방법.
+
+### Deeper Research Questions
+
+- 대규모 팀 환경에서 Feature-Sliced Design을 적용할 때, 'Shared' 레이어가 비대해지고 기능 간 교차 관심사(Cross-cutting concerns)가 얽히는 문제를 어떻게 관리해야 하는가?
+- React Context API에서 발생하는 리렌더링 폭포(Re-render storm) 문제를 해결하기 위해 Zustand의 Selector 패턴은 내부적으로 구독(Subscription) 모델을 어떻게 다르게 처리하는가?
+- React Compiler의 자동 메모이제이션 기능이 도입됨에 따라 기존 레거시 코드베이스의 기술 부채(예: Rules of React 위반 사항)는 컴파일 최적화 과정에서 어떠한 부작용을 일으킬 수 있는가?
+- Vite의 `manualChunks`를 사용하여 거대한 번들을 분리할 때, 벤더 라이브러리(React core, UI Kits 등)의 특성에 따른 최적의 청크 분할 및 브라우저 캐싱 전략은 무엇인가?
+- 대규모 리스트 데이터를 렌더링할 때 가상화(Virtualization)를 적용하지 않으면 브라우저 메모리 할당(Detached DOM nodes 등) 측면에서 어떤 치명적인 문제가 발생하는가?
+
+### Practical Application Contexts
+
+- **Implementation:** 프로젝트 초기 설정 시 기술 파일 단위(components, hooks) 구조를 피하고, 도메인/기능 중심의 폴더 구조를 설계합니다. 파일명은 운영체제 간 충돌 방지를 위해 kebab-case로, 컴포넌트는 PascalCase로 일관되게 명명합니다.
+- **System Design:** 전역 상태(Zustand/Redux), 서버 상태(TanStack Query), 로컬 상태(useState)의 책임을 명확히 분리합니다. 잦은 업데이트가 발생하는 상태는 컴포넌트 트리의 최상단 Context에 두는 것을 피합니다.
+- **Operation / Maintenance:** Sentry나 LogRocket과 같은 프론트엔드 모니터링 도구와 React Error Boundaries를 결합하여, 프로덕션 환경에서 발생하는 컴포넌트 렌더링 에러를 캡처하고 앱의 크래시를 방지합니다.
+- **Learning Path:** 단순한 React 문법 학습을 넘어, 상태 관리 도구별 렌더링 최적화 차이를 분석하고 Chrome DevTools 프로파일러를 사용하여 렌더링 병목을 확인하는 습관을 길러 아키텍트 수준으로 성장합니다.
+- **My Project Relevance:** 현재 유지보수 중인 React 애플리케이션에서 무거운 서드파티 라이브러리로 인해 메인 번들 크기가 비대해진 상황이라면, `React.lazy` 기반의 라우트 레벨 스플리팅과 Vite `manualChunks` 적용을 검토할 수 있습니다.
+
+### Adjacent Topics
+
+- [[Server Components (Next.js)]]
+  - 확장 방향: 클라이언트 측으로 전송되는 JavaScript 번들 자체를 제거하여 하이드레이션(Hydration) 오버헤드를 줄이고 확장성과 성능을 동시에 잡는 최신 렌더링 패러다임.
+- [[Memory Leak Detection in JavaScript]]
+  - 확장 방향: 확장 가능한 애플리케이션에서 장시간 사용 시 성능을 저하시키는 Detached DOM Nodes나 이벤트 리스너 누수 등을 Chrome DevTools Heap Snapshot을 통해 디버깅하는 방법.
+- [[Git Branching Workflows for Small & Large Teams]]
+  - 확장 방향: 규모가 확장되는 프론트엔드 팀이 충돌 없이 코드를 통합하기 위해 사용하는 GitHub Flow, Trunk-Based Development 및 PR(Pull Request) 리뷰 에티켓.
+
+---
+*Last updated: 2026-04-30*
\ No newline at end of file
diff --git a/10_Wiki/Development/React.lazy().md b/10_Wiki/Development/React.lazy().md
new file mode 100644
index 00000000..afb49c8c
--- /dev/null
+++ b/10_Wiki/Development/React.lazy().md
@@ -0,0 +1,65 @@
+# [[React.lazy()]]
+
+## 📌 Brief Summary
+`React.lazy()`는 리액트(React)에서 컴포넌트를 필요한 시점에 동적으로 불러올 수 있게 해주는 내장 함수입니다 [1]. 이 기능을 동적 임포트(Dynamic Imports)와 결합하면 거대한 자바스크립트 번들을 더 작은 청크(Chunk)로 나눌 수 있습니다 [2, 3]. 결과적으로 사용자가 앱에 처음 접근할 때 다운로드해야 하는 초기 자바스크립트 페이로드 크기를 대폭 줄여 앱의 초기 로드 속도와 전반적인 성능을 크게 향상시킵니다 [2-4].
+
+## 📖 Core Content
+*   **코드 스플리팅(Code Splitting)과 번들 사이즈 감소:**
+    초기 로드 시 모든 코드를 한 번에 불러오면 번들 크기가 비대해져 성능 저하가 발생합니다 [5]. `React.lazy()`를 사용하면 거대한 애플리케이션 코드를 잘게 쪼개어, 특정 라우트나 컴포넌트가 렌더링될 때만 해당 코드를 네트워크를 통해 다운로드하도록 구성할 수 있습니다 [1, 6, 7].
+*   **Suspense와의 결합:**
+    `React.lazy()`로 불러오는 컴포넌트는 반드시 `<Suspense>` 컴포넌트로 감싸주어야 합니다 [1, 3]. `<Suspense>`는 모듈이 로드되는 동안 사용자에게 보여줄 대체 UI(예: 로딩 스피너)를 `fallback` 속성을 통해 정의하여 사용자 경험을 매끄럽게 만듭니다 [1, 3, 8].
+*   **적용 대상(Use Cases):**
+    *   **라우트 기반 컴포넌트(Route-based components):** 사용자가 특정 페이지로 이동할 때만 해당 페이지 코드를 로드합니다 [8, 9].
+    *   **사용 빈도가 낮은 뷰:** 관리자 화면이나 설정 패널처럼 드물게 사용되는 화면에 적용합니다 [9].
+    *   **무거운 UI 블록 및 서드파티 통합 기능:** 차트, 지도, 리치 텍스트 에디터, 비디오 플레이어 등 용량이 큰 위젯을 렌더링할 때 유용합니다 [3, 9, 10].
+*   **빌드 도구와의 자동 통합:**
+    Vite나 Webpack과 같은 최신 번들러는 `React.lazy(() => import('./Component'))` 문법을 자동으로 인식하여 해당 컴포넌트를 별도의 파일(청크)로 분리해 컴파일합니다 [2, 3, 8].
+
+## ⚖️ Trade-offs & Caveats
+*   **어보브 더 폴드(Above-the-fold) 요소 적용 금지:** 사용자가 페이지에 진입하자마자 즉시 보아야 하는 필수적인 컴포넌트나 빠르게 렌더링되어야 하는 요소에 `React.lazy()`를 적용하면 안 됩니다 [9]. 이를 지연 로딩할 경우 불필요한 네트워크 지연이 발생하여 오히려 체감 성능과 사용자 경험이 하락합니다 [9].
+*   **레이아웃 시프트 및 사용자 경험 저하:** 비동기 로딩 중 `<Suspense>`의 `fallback`이 화면에 나타나면서, 로딩이 끝난 후 본래 컴포넌트로 전환될 때 레이아웃이 밀리거나 깜빡거리는 현상이 발생할 수 있습니다 [1, 11].
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+
+#### [아키텍처/기반 기술]
+- [[Code Splitting]]
+  - 연결 이유: `React.lazy()`의 존재 목적이자 근본적인 성능 최적화 기법입니다 [6].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 초기 렌더링 시 불필요한 자바스크립트 번들 크기를 줄여 로딩 성능을 최적화하는 애플리케이션 구조 원리.
+- [[Dynamic Imports]]
+  - 연결 이유: `React.lazy()` 함수 내부에서 비동기적으로 모듈을 로드하기 위해 사용하는 표준 자바스크립트 문법(`import()`)입니다 [2, 3, 8].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 브라우저가 특정 코드가 실행되어야 할 시점에 네트워크 요청을 생성하여 모듈을 가져오는 메커니즘.
+
+#### [구현/활용 도구]
+- [[Suspense]]
+  - 연결 이유: `React.lazy()`로 분리된 코드가 백그라운드에서 다운로드되는 동안 앱이 멈추지 않도록 로딩 UI를 처리하기 위해 필수적으로 결합되는 리액트 기능입니다 [1, 3].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 비동기 렌더링 흐름에서 로딩 상태(Loading State)를 컴포넌트 트리 상단에서 선언적으로 처리하는 방법.
+- [[Vite/Rollup]]
+  - 연결 이유: 소스 코드에 작성된 `React.lazy()` 구문을 분석하여 빌드 타임에 물리적으로 개별 자바스크립트 파일(청크)로 분할해 내는 도구들입니다 [2, 8].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 모듈 번들러가 코드 스플리팅을 인식하고 프로덕션 환경의 정적 에셋으로 변환하여 캐싱 효율을 높이는 과정.
+
+### Deeper Research Questions
+- `React.lazy()`를 활용한 클라이언트 사이드 코드 스플리팅과 서버 사이드에서 이루어지는 [[React Server Components]]의 성능 최적화 방식은 어떻게 다르며 서로 어떻게 보완될 수 있는가?
+- `<Suspense>`로 감싸진 지연 로딩 컴포넌트가 로드될 때 발생하는 Cumulative Layout Shift (CLS)를 최소화하기 위한 구체적인 UI 패턴과 전략은 무엇인가?
+- 모바일 환경 등 네트워크 속도가 느린 곳에서 `React.lazy()`로 분리된 청크를 불러올 때, 에러가 발생한 경우(예: 배포 후 이전 해시 청크 삭제됨) 이를 Error Boundary로 어떻게 우아하게 복구할 수 있는가?
+- 사용자가 컴포넌트를 요청하기 전(예: 링크에 마우스를 올리는 시점)에 `React.lazy()`로 분리된 청크를 미리 가져오는 프리패치(Prefetching/Preloading) 전략은 어떻게 구현하는가?
+- Vite의 `manualChunks` 설정과 `React.lazy()`를 동시에 활용하여, 핵심 벤더 라이브러리 캐싱과 페이지별 지연 로딩을 결합하는 최적의 빌드 전략은 무엇인가?
+
+### Practical Application Contexts
+- **Implementation:** React 코드 상단에 모듈을 정적 임포트하는 대신, `const LazyComponent = React.lazy(() => import('./LazyComponent'))`로 선언하고, 렌더 트리에 사용할 때 `<Suspense fallback={<Spinner/>}> <LazyComponent/> </Suspense>` 형태로 감싸 구현합니다 [1, 3].
+- **System Design:** 애플리케이션의 라우팅 레이어 설계 시, 모든 라우트를 초기 번들에 묶지 않고 각 페이지 또는 무거운 차트/에디터와 같은 독립적 도메인을 분리하는 기준으로 설계 기준을 수립합니다 [8, 9].
+- **Operation / Maintenance:** `rollup-plugin-visualizer`나 Webpack Bundle Analyzer 등의 도구를 이용해 빌드 후 500KB가 넘어가는 큰 청크(Large chunks)가 있는지 모니터링하고, 발견 시 `React.lazy()`를 사용해 지연 로딩 가능한 부분으로 잘라냅니다 [7, 12, 13].
+- **Learning Path:** React 컴포넌트 생명주기와 렌더링에 대한 이해 → 번들 크기가 성능에 미치는 영향 파악 → `React.lazy`와 `Suspense`를 통한 클라이언트 로딩 최적화 → 더 나아가 서버 사이드 렌더링(SSR) 및 서버 컴포넌트로 확장하는 경로로 학습을 진행합니다.
+- **My Project Relevance:** 현재 유지보수 중인 프로젝트에 모달, 어드민 설정 패널 등 즉시 보이지 않는 컴포넌트들이 메인 번들에 포함되어 있다면, 이를 `React.lazy()`로 리팩토링하여 Time To Interactive (TTI) 지표를 당장 개선하는 데 적용할 수 있습니다.
+
+### Adjacent Topics
+- [[Core Web Vitals]]
+  - 확장 방향: `React.lazy()`를 적용했을 때 First Contentful Paint (FCP)와 Interaction to Next Paint (INP) 같은 구글의 웹 성능 지표가 어떻게 개선되는지 확인하는 방향으로 연구 확장 [1, 5].
+- [[manualChunks]]
+  - 확장 방향: `React.lazy()`에 의한 스플리팅 외에, React 코어나 서드파티 라이브러리들(vendor)을 별도 분리해 브라우저 캐싱을 고도화하는 빌드 도구 수준의 수동 제어 기법 파악 [8, 14].
+- [[React Server Components (RSC)]]
+  - 확장 방향: 자바스크립트를 클라이언트로 아예 보내지 않고 서버에서 렌더링하여 성능을 극대화하는 최신 Next.js 패러다임과 클라이언트 단의 `React.lazy`를 비교 [9, 15].
+
+---
+*Last updated: 2026-04-30*
\ No newline at end of file
diff --git a/10_Wiki/Development/Real User Monitoring (RUM).md b/10_Wiki/Development/Real User Monitoring (RUM).md
new file mode 100644
index 00000000..fafa3074
--- /dev/null
+++ b/10_Wiki/Development/Real User Monitoring (RUM).md	
@@ -0,0 +1,62 @@
+# [[Real User Monitoring (RUM)]]
+
+## 📌 Brief 시 Summary
+Real User Monitoring (RUM)은 다양한 기기와 네트워크 조건에서 사용자가 경험하는 실제 성능과 상호작용을 추적하는 모니터링 방식입니다 [1]. 합성 테스트(Synthetic testing)가 놓칠 수 있는 실제 성능 문제를 파악하는 데 필수적이며 [1], 프론트엔드의 사용자 액션과 백엔드의 인프라 트레이스를 연결하여 전체 시스템에 대한 가시성을 제공합니다 [2].
+
+## 📖 Core Content
+*   **실제 사용자 경험 추적:** RUM은 개발 환경이나 인위적인 합성 테스트 환경에서는 포착하기 어려운 다양한 기기, 브라우저 환경 및 네트워크 조건에서의 실제 사용자 경험 데이터를 수집합니다 [1]. 이를 통해 특정 기기나 브라우저에서만 발생하는 오류를 효과적으로 식별할 수 있습니다 [3].
+*   **엔드투엔드(End-to-End) 트레이싱:** Datadog RUM 등의 도구를 사용하면 프론트엔드와 백엔드 간의 모니터링 격차를 줄일 수 있습니다. 프론트엔드에서 발생한 에러를 클릭하면, 백엔드 서비스, 데이터베이스 및 서드파티 API에 이르는 전체 요청 과정을 분산 트레이싱(Distributed tracing)을 통해 추적할 수 있어 복잡한 시스템의 디버깅을 돕습니다 [2].
+*   **통합 관측성(Unified Observability):** 최신 모니터링 플랫폼에서 RUM은 프론트엔드의 오류 로그뿐만 아니라 인프라 모니터링, 백엔드 APM(Application Performance Monitoring) 등과 한곳에서 결합되어 활용됩니다 [4].
+*   **비용 및 라이선스 모델:** 1,000명의 유저를 대상으로 할 때 기본적인 RUM 기능은 월 $15~$30 수준으로 시작할 수 있으나, 데이터 수집량에 따라 비용이 청구되는 사용량 기반 가격 정책을 따릅니다 [5].
+
+## ⚖️ Trade-offs & Caveats
+*   **데이터 규모에 따른 과도한 비용 청구:** RUM 플랫폼(예: Datadog)은 데이터 수집(Ingest)과 검색을 위한 인덱싱(Index)을 분리하여 요금을 부과하는 '이중 요금제'를 채택하는 경우가 많습니다. 트래픽이 높은 서비스에서는 비용이 기하급수적으로 증가할 수 있으며, 이로 인해 비용 절감을 위해 로그의 20%만 인덱싱하게 되면 장애 발생 시 80%의 주요 디버깅 데이터를 검색할 수 없는 상황에 놓일 수 있습니다 [5, 6].
+*   **프라이버시 및 보안 문제:** 세션 리플레이(Session replay) 등 사용자의 모든 행동을 기록하는 RUM 도구는 민감한 개인정보를 수집할 위험이 있습니다. 엄격해지는 개인정보 보호 규제를 준수하기 위해 민감 데이터를 자동 마스킹하도록 설정하는 데 많은 시간이 소요될 수 있습니다 [7-9].
+*   **초기 로드 성능 저하 (성능 오버헤드):** 프론트엔드에 삽입되는 RUM 추적 스크립트는 번들 크기를 증가시킵니다. 일부 도구의 경우 로드 시간을 최대 120ms까지 지연시킬 수 있으므로, 1초가 중요한 이커머스 등의 사이트에서는 경량화된 옵션을 신중히 선택해야 합니다 [10].
+*   **도입 및 학습 곡선:** 풀스택 관측 플랫폼과 결합된 RUM 도구는 단순 프론트엔드 로깅만 필요한 작은 팀에게는 지나친 오버엔지니어링(Overkill)이 될 수 있으며, 전체 플랫폼을 이해하는 데 가파른 학습 곡선이 요구됩니다 [6, 11].
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+
+#### [관계 유형 A (아키텍처/기반 기술)]
+- [[Synthetic Testing]]
+  - 연결 이유: RUM과 대비되는 모니터링 개념으로, 가상 환경에서 애플리케이션의 성능을 시뮬레이션하여 측정합니다 [1].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 시뮬레이션 데이터와 실제 사용자 경험(RUM) 데이터가 어떻게 상호보완적으로 작용하여 성능 병목 현상을 찾아내는지 이해할 수 있습니다.
+- [[Distributed Tracing]]
+  - 연결 이유: RUM 도구가 프론트엔드의 사용자 동작을 백엔드의 서비스 요청과 연관 짓기 위해 사용하는 핵심 메커니즘입니다 [2, 4, 12].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 마이크로서비스 아키텍처 환경에서 클라이언트 에러의 근본 원인을 백엔드 데이터베이스나 외부 API까지 어떻게 추적하는지 원리를 파악할 수 있습니다.
+- [[Core Web Vitals]]
+  - 연결 이유: RUM을 통해 주로 측정하고 최적화하려는 대상인 실제 사용자 중심의 로딩 속도, 상호작용, 시각적 안정성 지표입니다 [13, 14].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: RUM 데이터가 웹 성능 최적화의 기준(LCP, FID, CLS, INP)과 어떻게 매핑되어 사용자 경험(UX)을 수치화하는지 이해할 수 있습니다.
+
+#### [관계 유형 B (구현/활용 도구)]
+- [[Datadog RUM]]
+  - 연결 이유: 소스에서 엔드투엔드 프론트엔드-백엔드 모니터링을 연결해 주는 대표적인 RUM 플랫폼으로 소개되었습니다 [2].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 대규모 분산 시스템에서 RUM을 활용하는 구체적인 사례와, 인덱싱 비용 최적화(Trade-off) 전략의 중요성을 학습할 수 있습니다.
+- [[Session Replay]]
+  - 연결 이유: 사용자의 상태 변경, 콘솔 로그, 네트워크 요청 등을 마치 화면 녹화처럼 재현하는 RUM의 고급 디버깅 기능입니다 [7, 12, 15].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 스택 트레이스만으로 찾기 힘든 복잡한 사용자 상호작용 오류의 디버깅 방법론과 이에 따른 프라이버시 설정의 중요성을 알 수 있습니다.
+
+### Deeper Research Questions
+- 가상 환경의 성능을 시뮬레이션하는 합성 테스트(Synthetic Testing)와 비교할 때, RUM만이 독점적으로 식별할 수 있는 실제 기기/네트워크 기반의 성능 이슈 패턴은 무엇인가?
+- Datadog과 같은 RUM 솔루션을 활용할 때, 대규모 트래픽 하에서 가시성 손실 없이 데이터 수집(Ingest)과 인덱싱(Indexing) 비용의 트레이드오프를 극복할 수 있는 로그 필터링 전략은 무엇인가?
+- RUM 에이전트의 삽입이 자바스크립트 번들 크기 및 초기 페이지 로드 속도(최대 120ms 추가)에 미치는 성능 오버헤드를 최소화하는 아키텍처 설계 방법은 무엇인가?
+- 글로벌 프라이버시 규제를 준수하면서 Session Replay를 포함한 RUM 데이터를 수집하기 위해, 민감한 DOM 요소나 사용자 입력을 어떻게 효과적으로 마스킹(Masking)할 수 있는가?
+- 프론트엔드 React 컴포넌트에서 발생한 에러를 RUM 데이터와 결합하고, 백엔드의 OpenTelemetry 분산 트레이스와 연결(Trace ID 공유 등)하여 전체 마이크로서비스 흐름에서 근본 원인을 파악하는 구체적인 파이프라인 구축 방법은 무엇인가?
+
+### Practical Application Contexts
+- **Implementation:** React 애플리케이션의 엔트리 포인트에 Datadog이나 Sentry와 같은 RUM 모니터링 SDK를 통합하고, Core Web Vitals 및 세션별 성능 지표를 자동으로 수집하도록 초기화합니다.
+- **System Design:** 사용자의 브라우저에서 발생한 프론트엔드 로그와 API 요청 헤더에 트레이스 ID를 삽입하여, 백엔드 로깅 시스템과 매칭시키는 '엔드투엔드(End-to-End) 모니터링 아키텍처'를 설계합니다.
+- **Operation / Maintenance:** 월별 모니터링 비용(특히 데이터 인덱싱 비용)을 모니터링하여 불필요한 이벤트는 샘플링하고, 데이터 마스킹 규칙을 지속적으로 관리해 GDPR 등의 개인정보 보호 정책을 위반하지 않도록 유지보수합니다.
+- **Learning Path:** 먼저 React의 기본 에러 처리(Error Boundaries)와 브라우저 DevTools를 사용한 메모리 누수 측정을 익힌 후, 프로덕션 환경의 실시간 사용자 데이터를 수집하는 RUM과 백엔드 분산 트레이싱을 학습하여 풀스택 관측성(Observability) 역량을 기릅니다.
+- **My Project Relevance:** 현재 진행 중인 프론트엔드 프로젝트에서 사용자 이탈률이 높은 특정 화면의 병목 지점을 찾기 위해, RUM을 적용하여 실제 모바일 기기와 3G/LTE 환경에서의 INP(Interaction to Next Paint)와 렌더링 지연을 측정 및 개선할 때 활용합니다.
+
+### Adjacent Topics
+- [[OpenTelemetry]]
+  - 확장 방향: 특정 벤더에 종속되지 않고(No vendor lock-in) 오픈 스탠다드 프로토콜을 이용해 RUM, 메트릭, 로그 데이터를 수집하고 백엔드와 연결하는 아키텍처로 지식을 확장할 수 있습니다 [16, 17].
+- [[Error Boundaries]]
+  - 확장 방향: React 애플리케이션 내에서 UI 렌더링 중 발생하는 런타임 에러를 캡처하여 전체 앱의 크래시를 방지하는 개념으로, 여기서 포착된 에러를 RUM 시스템에 보고하는 방식으로 연계할 수 있습니다 [18-20].
+
+---
+*Last updated: 2026-04-30*
\ No newline at end of file
diff --git a/10_Wiki/Development/Redux.md b/10_Wiki/Development/Redux.md
new file mode 100644
index 00000000..332910b5
--- /dev/null
+++ b/10_Wiki/Development/Redux.md
@@ -0,0 +1,53 @@
+# [[Redux]]
+
+## 📌 Brief Summary
+Redux는 예측 가능한 상태 컨테이너로, 불변성을 유지하는 업데이트, 액션 디스패치(action dispatch), 그리고 리듀서(reducer)를 통해 전역 상태를 관리하는 산업 표준 라이브러리이다 [1]. 주로 복잡한 파생 및 계산된 상태가 존재하거나 500개 이상의 컴포넌트를 다루는 대규모 애플리케이션에서 일관된 개발 패턴을 강제하기 위해 채택된다 [2]. RTK Query와 Redux DevTools 같은 성숙한 생태계를 통해 비동기 상태 관리의 복잡성을 줄이고 강력한 디버깅 기능을 제공한다 [2-4].
+
+## 📖 Core 대Content
+*   **상태 관리 아키텍처와 구조화**: Redux는 불변성을 기반으로 상태를 관리하며, 액션과 리듀서 패턴을 통해 애플리케이션의 복잡한 상태 로직을 제어한다 [1]. 모던 프론트엔드 폴더 구조에서 Redux 슬라이스(Redux slices)와 글로벌 상태 관련 로직은 전담 디렉토리인 `store/`에 배치된다 [5-7]. 10명 이상의 개발자가 협업하는 조직이나 이커머스, 금융 시스템과 같이 미션 크리티컬한 데이터 무결성이 중요한 프로젝트에서 코드 작성의 일관성을 강제하는 뼈대 역할을 한다 [2].
+*   **성능 최적화 및 상태 구독**: 내장된 React Context API는 상태의 일부만 변경되어도 해당 컨텍스트를 구독하는 모든 컴포넌트에 무차별적인 리렌더링을 유발하는 반면, Redux는 구독 로직과 렌더링을 명확히 분리한다 [3, 8-10]. 선택자(Selector)를 사용해 필요한 파생 상태만 컴포넌트에 공급하여 성능과 최적화를 보장한다 [3].
+*   **비동기 데이터 관리 (RTK Query 도입)**: 과거 Redux는 비동기 처리에 막대한 양의 보일러플레이트 코드(Thunk, Saga 등)가 필요했으나, 현재는 RTK Query를 통해 문제를 해결한다 [2, 4]. RTK Query는 데이터 캐싱, 중복 요청 제거, 자동 데이터 재요청 기능 등을 기본으로 제공하여 비동기 작업 코드를 획기적으로 줄여준다 [4]. 
+*   **디버깅과 추적성**: Redux의 가장 큰 차별점은 브라우저의 Redux DevTools를 활용한 '시간 여행 디버깅(Time-Travel Debugging)'이다 [2, 3]. 상태 변화 이력을 과거로 돌려보거나 액션을 재현할 수 있어, 심야에 발생하는 복잡한 운영 환경의 비동기 버그도 몇 분 내에 시각적으로 파악하게 해준다 [3, 11, 12].
+*   **한계점 및 주의사항**: Redux는 도입 시 막대한 보일러플레이트, 정규화된 상태 관리의 난해함, 미들웨어 순서 오류, 그리고 깨지기 쉬운 선택자 메모이제이션 등의 한계를 가진다 [13]. 또한 모든 상태를 하나의 큰 리듀서에 몰아넣는 "God Reducer" 구조나 팀 단위의 액션 결합(Action Coupling)은 대표적인 안티 패턴으로 지적된다 [13, 14]. 최신 트렌드에서는 이와 같은 단일(monolithic) 스토어 구조의 복잡성을 피하기 위해 클라이언트 상태와 서버 상태를 분리하는 등 보다 파편화된 방식으로 진화하고 있다 [15].
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+- [[Context API]]
+  - 연결 이유: Redux와 자주 비교되는 React의 내장 상태 공유 기능으로, 소규모 애플리케이션의 테마나 언어 설정 등을 관리하기 적합하지만, 상태 변경 시 발생하는 대규모 리렌더링 폭풍(Re-render Storm)을 유발하여 대규모 앱에서 Redux가 필요한 당위성을 제공한다 [8, 9, 16].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 상태 구독 아키텍처의 차이가 React 컴포넌트의 리렌더링 성능에 미치는 치명적인 영향성 [8, 10].
+
+- [[Zustand]]
+  - 연결 이유: Redux의 무거운 보일러플레이트와 Context API의 성능 문제 사이에서 적절한 타협점을 제공하는 경량 상태 관리 라이브러리이다 [17-19]. 
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 상태 관리 라이브러리의 과도한 유연성(Zustand)이 팀 단위 협업에서 어떻게 비동기 패턴의 파편화와 혼란을 야기할 수 있는지, 대조적으로 Redux의 엄격한 구조가 갖는 방어적 이점 [1, 11, 18, 20].
+
+- [[RTK Query]]
+  - 연결 이유: Redux Toolkit(RTK) 생태계에 포함된 데이터 패칭 및 캐싱 도구이다 [4].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: Redux가 어떻게 단순한 클라이언트 상태 관리를 넘어 서버 API 응답(캐싱, 무효화, 재요청)이라는 현대적인 요구사항을 보일러플레이트 없이 소화하는지 파악 [4, 21].
+
+- [[Time-Travel Debugging]]
+  - 연결 이유: Redux DevTools가 제공하는 고유의 강력한 기능으로, 언제 어떤 액션이 디스패치되어 상태가 어떻게 변경되었는지 기록하고 되감는 기술이다 [2, 3].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 5년 이상 지속되는 엔터프라이즈 애플리케이션에서 아키텍처의 디버깅 역량이 개발자의 생산성 및 장애 대응에 미치는 영향 [11, 12].
+
+### Deeper Research Questions
+- Redux의 상태 구독 및 선택자(selector) 패턴은 내부적으로 Context API와 어떻게 다르게 설계되어 부분 상태 변경 시 불필요한 리렌더링을 차단하는가?
+- RTK Query를 통한 Redux 비동기 상태 관리는 Zustand 환경에서 사용자가 직접 구현하는 비동기 캐싱 패턴과 비교해 어떠한 아키텍처적 안정성을 담보하는가?
+- "God Reducer" 안티 패턴이 대규모 React 코드베이스 내비게이션 및 성능 최적화에 미치는 치명적인 부작용은 무엇인가?
+- 프론트엔드 상태 관리가 과거의 거대한 단일 스토어 방식에서 '서버 상태'와 '클라이언트 로컬 상태'로 파편화(Fragmentation)되는 최신 트렌드 속에서, Redux의 적정 사용 범위는 어떻게 재조정되었는가?
+- 10명 이상의 시니어 및 주니어 개발자가 혼재된 팀에서 Redux의 보일러플레이트는 개발 속도를 저하시키는 부채인가, 아니면 버그를 사전에 방지하는 구조적 방어막인가?
+
+### Practical Application Contexts
+- **Implementation:** React 프로젝트의 `store/` 또는 `features/` 디렉토리에 도메인별 Redux slice를 배치하여 전역 상태 및 비동기 데이터를 선언하고 액션과 병합하여 관리한다 [5-7].
+- **System Design:** 장기 유지보수가 요구되는 대규모 엔터프라이즈 시스템(이커머스 결제 등 데이터 흐름이 중요한 500개 컴포넌트 이상의 앱)에서 파생 상태 처리와 팀 개발 패턴 강제화 목적으로 채택한다 [2, 12, 13, 22].
+- **Operation / Maintenance:** 프로덕션 환경이나 디버깅 시 Redux DevTools를 연동하여 특정 UI 버그나 비동기 데이터 꼬임 현상을 시각적인 액션 히스토리를 통해 단시간에 해결한다 [11, 12].
+- **Learning Path:** 프론트엔드 교육 시, Context API의 근본 원리와 한계를 먼저 학습하고, Zustand의 생산성을 경험한 뒤, 엔터프라이즈 표준이자 가장 복잡도가 높은 Redux의 패턴과 구조적 이점을 최종적으로 학습하는 단계적 접근이 요구된다 [23].
+- **My Project Relevance:** 글로벌 상태가 다수의 컴포넌트에 복잡하게 얽혀 있거나, 팀원 간 동일한 비동기/상태 관리 구조를 강제하여 파편화를 막아야 하는 애플리케이션을 구축할 때 핵심적인 기술 스택으로 검토될 수 있다 [1, 12].
+
+### Adjacent Topics
+- [[Server State Management (TanStack Query 등)]]
+  - 확장 방향: 클라이언트 전역 상태와 구별되는 "서버 데이터(API 캐싱, 동기화, 로딩/에러 사이클)"만을 전문적으로 처리하는 모던 라이브러리와 Redux의 역할 비교 및 연동 방안 탐색 [24, 25].
+- [[React Rendering Optimization]]
+  - 확장 방향: 상태 관리 라이브러리의 선택과 별개로, React 컴포넌트 생명주기 및 메모이제이션(`useMemo`, `useCallback`, `React.memo`)이 애플리케이션 퍼포먼스에 미치는 원리와 프로파일링 방법 탐색 [26-28].
+
+---
+*Last updated: 2026-04-30*
\ No newline at end of file
diff --git a/10_Wiki/Development/Rollup.md b/10_Wiki/Development/Rollup.md
new file mode 100644
index 00000000..5a38f732
--- /dev/null
+++ b/10_Wiki/Development/Rollup.md
@@ -0,0 +1,57 @@
+# [[Rollup]]
+
+## 📌 Brief Summary
+Rollup은 2025년 기준 최신 프론트엔드 빌드 도구인 Vite의 프로덕션 빌드를 백그라운드에서 담당하는 모듈 번들러입니다 [1]. 개발 단계에서는 네이티브 ES 모듈(ESM)을 사용하는 Vite가 실제 배포 시점에는 Rollup으로 전환하여 애플리케이션 코드를 병합하고 최적화합니다 [1, 2]. 자동 코드 분할(Code Splitting)과 사용하지 않는 코드를 제거하는 트리 쉐이킹(Tree-shaking) 기능을 통해 매우 최적화된 최종 에셋을 생성하는 것이 핵심 역할입니다 [1].
+
+## 📖 Core 대Content
+*   **Vite와의 하이브리드 아키텍처:** Vite는 로컬 개발 시에는 번들링 없이 네이티브 ESM으로 코드를 제공하여 극도로 빠른 시작과 HMR(Hot Module Replacement)을 지원하지만, 프로덕션 배포 시에는 Rollup을 사용하여 최적화된 번들(Bundled build)을 생성하는 하이브리드 방식을 취합니다 [1].
+*   **번들 최적화 및 트리 쉐이킹 (Tree-shaking):** Rollup은 프로덕션 빌드 시 애플리케이션 내에서 사용되지 않는 코드를 자동으로 제거(Tree-shaking)하고 효율적으로 코드를 분할하여 최적화된 에셋을 제공합니다 [1]. 
+*   **청크 수동 제어 (`manualChunks`):** 기본 설정 상태에서 Rollup은 애플리케이션 코드와 `node_modules`의 모든 종속성을 단일 파일(`index.js`)로 묶어 거대한 번들을 생성할 수 있습니다 [3]. 이를 해결하기 위해 대규모 프로젝트에서는 Rollup 옵션 중 `manualChunks`를 세밀하게 설정하여, 자주 변경되지 않는 무거운 벤더 라이브러리(React 코어, Recharts, Lodash, 아이콘 등)를 별도의 청크 파일로 분리하는 것이 권장됩니다 [4-6]. 
+*   **캐시 효율성 개선:** `manualChunks`를 통해 벤더 라이브러리를 분리하면, 해당 라이브러리는 자주 변경되지 않기 때문에 여러 번 배포하더라도 브라우저가 이를 캐시하여 재사용할 수 있으므로 초기 로드 성능이 크게 향상됩니다 [5-7].
+
+## ⚖️ Trade-offs & Caveats
+*   **초기 설정 부족 시 대용량 번들 발생:** 기본 설정으로 둘 경우 애플리케이션의 모든 종속성이 하나의 파일에 Eager Import 되어 결합될 수 있습니다 [3]. 이는 미니파이(Minification) 후에도 500kB를 초과하는 대규모 청크(Large Chunks)를 생성하여, 다운로드 시간을 지연시키고 저사양 기기에서 파싱 및 컴파일에 무리를 줄 수 있습니다 [3, 8, 9].
+*   **캐시 무효화(Cache Invalidation) 문제:** 단일 거대 번들로 빌드할 경우 애플리케이션의 작은 코드 하나만 수정하더라도 전체 번들이 새로 해시(Hash)되어 사용자는 모든 JavaScript 파일을 다시 다운로드해야 하는 비효율성이 발생합니다 [9]. 이를 방지하려면 `manualChunks` 설정과 `React.lazy`를 결합한 라우트 기반 코드 분할 등 추가적인 최적화 작업이 강제됩니다 [3, 6].
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+
+#### [아키텍처/기반 기술]
+- [[Vite]]
+  - 연결 이유: Rollup은 Vite의 아키텍처 내에서 프로덕션 배포 시 최적화된 빌드를 수행하는 내부 엔진으로 작동합니다 [1].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 개발 모드(ESM)와 배포 모드(Rollup)를 다르게 가져가는 Vite의 하이브리드 번들링 아키텍처 전략을 이해할 수 있습니다 [1, 2].
+- [[Tree-shaking]]
+  - 연결 이유: Rollup이 배포용 코드를 최적화할 때 사용하지 않는 코드를 덜어내는 핵심 메커니즘입니다 [1].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: ES 모듈 기반 라이브러리 사용이 왜 최종 번들 사이즈 최적화에 필수적인지 파악할 수 있습니다 [10].
+
+#### [구현/활용 도구]
+- [[manualChunks]]
+  - 연결 이유: Rollup을 사용하여 거대한 메인 번들을 세분화된 벤더 청크(Vendor chunk)로 쪼갤 때 사용되는 핵심 설정입니다 [4-6].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 브라우저 캐싱을 극대화하기 위해 코드를 성격(변경 빈도)에 따라 분리하는 최적화 전략을 배울 수 있습니다 [6, 7].
+- [[Code Splitting]]
+  - 연결 이유: Rollup의 기능과 React의 지연 로딩(`React.lazy`)을 결합하여 구현되는 성능 최적화 기법입니다 [3, 11].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 초기 페이로드(Payload)를 줄이고 Core Web Vitals를 개선하는 런타임 최적화 방법을 학습할 수 있습니다 [9, 12].
+
+### Deeper Research Questions
+- Vite는 왜 개발 환경에서는 Rollup을 사용하지 않고 네이티브 ESM을 사용하며, 프로덕션 빌드에서만 Rollup을 도입하는 아키텍처를 선택했는가?
+- Rollup의 Tree-shaking 메커니즘은 빌드 시 어떤 방식으로 데드 코드(Dead code)를 식별하고 최종 번들에서 제외하는가?
+- `manualChunks`를 사용하여 벤더(Vendor) 파일을 분할할 때 발생하는 모듈 간 중복 포함 문제를 방지하는 설정 방법은 무엇인가?
+- Rollup이 생성한 번들 크기를 시각적으로 분석하기 위해 `rollup-plugin-visualizer`가 제공하는 데이터는 실제 성능 개선에 어떻게 활용되는가?
+- Rollup의 빌드 최적화가 FCP, LCP, INP 등 Core Web Vitals 지표 향상에 미치는 구체적인 인과관계는 무엇인가?
+
+### Practical Application Contexts
+- **Implementation:** `vite.config.js` 내부에 `build.rollupOptions.output.manualChunks`를 구성하여 `react`, `react-dom` 등의 라이브러리를 별도의 파일로 강제 분리합니다 [4, 6].
+- **System Design:** 프론트엔드 프로덕션 시스템 설계 시, 자주 변하지 않는 서드파티 라이브러리와 비즈니스 로직을 분리하여 CDN 캐시 히트율을 높이도록 설계합니다 [5, 6].
+- **Operation / Maintenance:** CI/CD 파이프라인에서 "500 kB 이상의 청크" 경고가 발생할 경우, `rollup-plugin-visualizer`를 통해 번들 상태를 점검하고 분할 설정을 업데이트합니다 [8, 13, 14].
+- **Learning Path:** React 최적화 학습 시, 단순히 `React.lazy()`만 배우는 것을 넘어 번들러(Rollup) 레벨에서의 코드 청킹(Chunking) 원리를 함께 학습합니다 [3, 6].
+- **My Project Relevance:** Vite 기반 React 애플리케이션을 Vercel이나 AWS 서버에 배포하기 전에 빌드 속도 및 초기 다운로드 속도를 개선하기 위한 필수 점검 단계로 활용합니다 [2, 11].
+
+### Adjacent Topics
+- [[ES Modules (ESM)]]
+  - 확장 방향: Rollup의 프로덕션 빌드 이전, Vite가 개발 환경에서 코드 변경 사항을 즉각적으로 브라우저에 반영하는 원리 파악 [1, 15].
+- [[Core Web Vitals]]
+  - 확장 방향: Rollup의 번들 분할 및 경량화 작업이 LCP(Largest Contentful Paint)나 INP(Interaction to Next Paint)와 같은 브라우저 성능 측정 지표를 어떻게 개선하는지 조사 [9, 14].
+
+---
+*Last updated: 2026-04-30*
\ No newline at end of file
diff --git a/10_Wiki/Development/Scalable Frontend Systems.md b/10_Wiki/Development/Scalable Frontend Systems.md
new file mode 100644
index 00000000..57f7da94
--- /dev/null
+++ b/10_Wiki/Development/Scalable Frontend Systems.md	
@@ -0,0 +1,65 @@
+# [[Scalable Frontend Systems]]
+
+## 📌 Brief Summary
+대규모 프론트엔드 시스템(Scalable Frontend Systems)은 높은 유지보수성, 고성능, 확장성을 보장하기 위해 기존의 단순한 스크립트 실행을 넘어 정교하게 분산된 소프트웨어 아키텍처를 도입한 시스템입니다 [1]. 기능별 또는 도메인 중심의 모듈형 폴더 구조를 사용하며, SOLID와 같은 클린 코드 원칙을 준수하고 애플리케이션 상태와 서버 상태를 분리하여 관리합니다 [2-4]. 더불어 자동화된 빌드 최적화, 예측 가능한 렌더링 최적화, 정교한 에러 처리 및 협업 워크플로우를 결합하여 애플리케이션이 안정적으로 성장할 수 있도록 지원합니다 [1, 5].
+
+## 📖 Core Content
+
+*   **아키텍처 패러다임과 폴더 구조:** 확장성을 달성하기 위해서는 파일을 파일의 유형(components, hooks 등)별로 모아두는 구조에서 기능(Feature)이나 도메인 중심으로 구조를 개편해야 합니다 [2, 6]. 특히 Feature-Sliced Design (FSD)은 코드 계층을 Scope와 책임에 따라 분할(shared, entities, features, widgets, pages, app)하고, 하위 계층이 상위 계층을 참조하지 못하게 하는 단방향 의존성과 캡슐화된 Public API 규칙을 강제하여 결합도(Coupling)를 극적으로 낮춥니다 [7-10].
+*   **소프트웨어 엔지니어링 원칙 적용:** 확장 가능한 React 시스템은 컴포넌트가 하나의 역할만 하도록 분리하는 단일 책임 원칙(SRP)을 비롯하여 개방/폐쇄 원칙(OCP), DRY, KISS, YAGNI 등의 SOLID 및 클린 코드 원칙을 적용합니다 [3, 11]. 이로 인해 코드의 예측 가능성이 향상되고 불필요한 조기 최적화나 복잡성이 제거됩니다 [12].
+*   **상태 관리의 파편화 (State Management):** 하나의 거대한 Redux 스토어에 의존하기보다, 데이터의 성격에 맞는 도구를 선택하는 방식으로 진화했습니다 [13]. 불필요한 전역 렌더링을 방지하기 위해 Context API 대신 선택자(Selector) 패턴을 지원하는 Zustand 등을 전역 상태 관리에 사용하며, API에서 가져오는 서버 상태는 캐싱과 동기화를 위해 TanStack Query(React Query)로 분리합니다 [4, 14].
+*   **성능 엔지니어링 및 렌더링 최적화:** 초기의 거대한 JavaScript 번들 사이즈를 줄이기 위해 `React.lazy`와 Suspense를 활용한 라우트 및 컴포넌트 수준의 코드 스플리팅(Code Splitting)이 필수적입니다 [15-17]. 성능 병목을 일으키는 무의미한 리렌더링을 피하기 위해 `React.memo`, `useCallback`, `useMemo`를 적재적소에 사용하거나, React Compiler와 같은 빌드 타임 도구를 도입해 메모이제이션을 자동화합니다 [18-21]. 데이터가 방대한 목록의 경우 가상화(Virtualization/Windowing)를 도입하여 DOM 부하를 줄입니다 [22].
+*   **복원력(Resilience)과 모니터링:** 전체 애플리케이션의 렌더링 크래시를 방지하기 위해 불안정한 UI 영역(써드파티 위젯 등)을 Error Boundary로 감싸서 격리합니다 [23, 24]. 브라우저 메모리 탭의 Heap Snapshot을 통해 메모리 누수를 디버깅하고, 배포 이후에는 Sentry, LogRocket, Datadog과 같은 클라우드 관측(Observability) 도구를 사용해 프로덕션 환경의 사용자 에러 및 세션을 실시간 모니터링합니다 [25-27].
+*   **팀 협업 및 거버넌스 규칙:** 윈도우/리눅스 환경 차이로 인한 CI 빌드 에러를 막기 위해 파일명에 kebab-case를 강제하거나(컴포넌트 이름은 PascalCase 적용), ESLint 및 Git Hooks를 통해 아키텍처 규칙 및 코드 포맷을 자동 검증합니다 [28-30]. Git-flow, GitHub Flow 등 소규모/대규모 팀 규모에 맞는 명확한 브랜치 전략과 티켓 ID 기반 추적 관리를 함께 사용합니다 [31, 32].
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+
+- [[Feature-Sliced Design (FSD)]]
+  - 연결 이유: 확장 가능한 프론트엔드 아키텍처에서 빈번하게 발생하는 '비즈니스 로직 얽힘' 문제를 해결하기 위해 도입된 핵심적인 컴포넌트/디렉토리 분할 방법론입니다 [33, 34].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 단방향 의존성 흐름, 계층별(Layered) 분할, 캡슐화를 통한 Public API 인터페이스 설계 원리 [7, 9].
+
+- [[State Management Fragmentation (상태 관리 파편화)]]
+  - 연결 이유: 대규모 애플리케이션에서 단일 스토어나 Context API만으로는 리렌더링 성능 최적화가 불가능해짐에 따라, 전역 상태(Zustand), 서버 상태(React Query), 로컬 상태로 역할을 분리하여 관리하는 트렌드입니다 [4, 13, 35].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 불필요한 렌더링 방지 원리(Zustand의 선택자 패턴)와 서버/클라이언트 데이터 간의 캐싱 및 동기화 전략 [4, 14].
+
+- [[React Compiler]]
+  - 연결 이유: 개발자가 수동으로 수행하던 `useMemo`, `useCallback`, `React.memo` 등의 메모이제이션을 빌드 타임에 자동으로 처리해 주어, 깔끔한 코드를 유지하면서 성능 확장을 가능케 하는 최신 도구입니다 [19, 36].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: React의 렌더링 최적화 한계 및 Rules of React 준수 중요성, 써드파티 라이브러리와의 호환성 문제 [37, 38].
+
+- [[Error Boundaries]]
+  - 연결 이유: 시스템의 크기가 커질 때 단일 컴포넌트의 오류가 전체 앱의 '화이트 스크린' 크래시로 이어지지 않게 UI의 일부분만 대체(Fallback)하여 시스템 복원력(Resilience)을 보장하는 장치입니다 [23, 24, 39].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 클래스형 컴포넌트 생명주기를 활용한 런타임 에러 포착 원리 및 대규모 UI 보호 전략 [40, 41].
+
+- [[Code Splitting & Lazy Loading (코드 분할과 지연 로딩)]]
+  - 연결 이유: 프론트엔드 코드가 비대해지면서 초기 로딩 속도(TTI, LCP)를 최적화하기 위해 필수적으로 요구되는 기술로, Vite나 React.lazy를 통해 필요한 시점에만 모듈을 다운로드하게 합니다 [15, 17, 42].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 모듈 번들러의 청크(Chunk) 분리 원리 및 브라우저 성능 최적화(Core Web Vitals)와 번들 사이즈의 상관관계 [43, 44].
+
+### Deeper Research Questions
+
+- Feature-Sliced Design (FSD) 아키텍처를 도입할 때, 여러 기능(Feature)이 공유해야 하는 교차 관심사(Cross-cutting concerns)나 하위 기능 결합 문제를 어떻게 계층 분리와 캡슐화를 훼손하지 않고 해결할 수 있는가? [45, 46]
+- React Context API가 야기하는 불필요한 렌더 트리 리렌더링 문제를 Zustand나 Redux 같은 상태 관리 라이브러리의 선택자(Selector) 패턴 및 외부 스토어 구독 방식과 비교했을 때, 성능과 확장성 측면에서 구체적인 차이는 무엇인가? [14, 35, 47]
+- Vite 빌드 환경에서 번들 크기 경고("Large Chunks")를 해결하기 위해 `manualChunks`와 `React.lazy`를 결합하여 코드 스플리팅을 구현할 때, 초기 렌더링 성능 개선과 브라우저 캐싱 효율은 각각 어떻게 작용하는가? [42, 48, 49]
+- Next.js의 React Server Components (RSC)를 채택함으로써 서버에서 미리 렌더링하고 클라이언트 측 JavaScript 페이로드를 줄이는 접근법이, 거대한 프론트엔드 앱의 확장성에 어떤 아키텍처적 패러다임 전환을 가져오는가? [50, 51]
+- React Compiler의 자동 메모이제이션 로직이 서드파티 훅(예: 불안정한 참조를 반환하는 훅)과 레거시 코드베이스의 기술 부채 환경에서 어떤 최적화 실패를 발생시키며, 이를 방지하기 위한 리팩토링 전략은 무엇인가? [38, 52]
+
+### Practical Application Contexts
+
+- **Implementation:** 거대한 React 프로젝트를 리팩토링할 때 파일을 파일 속성 단위가 아닌 FSD와 같은 기능(Feature) 및 도메인 구조로 마이그레이션합니다. 상태가 자주 변경되는 기능에는 Zustand 스토어를 적용하고, 서버 API 요청에는 TanStack Query를 도입하여 로컬 상태와 서버 상태를 완벽히 분리 구현합니다 [2, 10, 53].
+- **System Design:** 컴포넌트 간의 순환 참조나 강한 결합(Coupling)을 막기 위해 캡슐화된 `index.ts` 형태의 Public API 설계 패턴을 적용합니다. 렌더링 부하를 막기 위해 데이터 리스트에는 가상화(Virtualization) 설계를 도입합니다 [11, 22].
+- **Operation / Maintenance:** 프로덕션 배포 후 어플리케이션 크래시를 방지하기 위해 Error Boundary를 위젯 및 중요 UI 섹션마다 감싸며, LogRocket 또는 Sentry를 도입해 에러 추적 및 메모리 릭(Memory Leaks) 상황을 실시간으로 디버깅하고 유지보수합니다 [23, 26, 27].
+- **Learning Path:** 소규모 장난감 프로젝트로 React의 기초를 다진 후, Context API의 한계를 파악하고 Zustand 등 상태 관리를 배웁니다. 이후 단위 테스트 작성, Typescript 전환, 그리고 클린 코드 원칙(SOLID, DRY) 기반의 아키텍처링(Feature-Sliced Design) 최적화로 나아가는 단계적 학습을 거칩니다 [54-57].
+- **My Project Relevance:** 소스에 관련 정보가 부족합니다.
+
+### Adjacent Topics
+
+- [[Frontend Cloud Logging Tools (프론트엔드 클라우드 로깅 도구)]]
+  - 확장 방향: 확장 가능한 시스템이 프로덕션 단계에 들어갔을 때, Sentry나 Datadog, SigNoz 같은 모니터링 툴을 활용해 사용자 세션과 에러 로그를 연동하여 가시성(Observability)을 확보하는 방향으로 확장할 수 있습니다 [58-60].
+- [[Storybook Visual Regression Testing (Storybook 시각적 회귀 테스트)]]
+  - 확장 방향: 대규모 팀에서 UI 컴포넌트를 변경할 때, 기존 화면(baseline)의 레이아웃이나 픽셀이 의도치 않게 깨지는 것을 방지하기 위한 자동화된 시각적 회귀 검증(Happo, Chromatic) 및 CI 파이프라인 연동 방향으로 확장할 수 있습니다 [61-63].
+- [[Git Branching Strategies & Workflows (Git 브랜치 전략 및 워크플로우)]]
+  - 확장 방향: 어플리케이션 확장뿐만 아니라 참여하는 개발자 수가 많아질 때, Trunk-based 개발이나 GitHub Flow 등을 도입하여 충돌을 줄이고 티켓 기반 추적성을 확보하는 형상관리 방향으로 확장할 수 있습니다 [31, 64].
+
+---
+*Last updated: 2026-04-30*
\ No newline at end of file
diff --git a/10_Wiki/Development/Storybook.md b/10_Wiki/Development/Storybook.md
new file mode 100644
index 00000000..6d872c98
--- /dev/null
+++ b/10_Wiki/Development/Storybook.md
@@ -0,0 +1,66 @@
+# [[Storybook]]
+
+## 📌 Brief 주Summary
+Storybook은 프론트엔드 개발 시 UI 컴포넌트를 주 애플리케이션과 격리하여 개발하고 문서화할 수 있도록 돕는 도구입니다 [1-3]. 특히 개발된 컴포넌트의 다양한 상태(스토리)를 기반으로 자동화된 시각적 회귀 테스트(Visual Regression Testing) 및 상호작용 테스트(Interaction Testing)를 수행하여 의도치 않은 UI 변경이나 접근성 위반을 방지합니다 [4-6]. Pull Request 과정에 결합되어 안전한 UI 업데이트와 리뷰를 지원하는 필수적인 플랫폼으로 활용됩니다 [1, 7].
+
+## 📖 Core Content
+* **컴포넌트의 격리된 개발 및 문서화**
+  Storybook은 개발자가 메인 애플리케이션의 복잡한 비즈니스 로직이나 컨텍스트에서 벗어나 UI 컴포넌트를 독립적으로 구축할 수 있게 해줍니다 [1]. 이는 모노레포(Monorepo) 환경이나 기능 기반 아키텍처(Feature-Sliced Design 등)에서 각 기능을 독립적으로 개발하고 테스트할 때 매우 유용합니다 [3]. 이미 컴포넌트를 문서화하고 개발하는 용도로 Storybook을 사용 중이라면, 이를 기반으로 시각적 회귀 테스트를 도입하는 것이 가장 빠른 UI 검증 방법입니다 [2].
+
+* **시각적 회귀 테스트 (Visual Regression Testing)**
+  Storybook의 핵심 기능 중 하나는 각 스토리의 스냅샷을 캡처하고 이를 이전에 승인된 '베이스라인(Baseline)'과 비교하여 시각적 변경 사항을 감지하는 것입니다 [8]. 전통적인 스냅샷 테스트가 HTML 마크업 블롭을 비교하여 시각적 변화가 없음에도 오탐(false positive)을 발생시키는 것과 달리, Storybook의 시각적 테스트는 사용자가 실제로 경험하는 '렌더링된 픽셀'을 직접 비교하므로 훨씬 더 풍부하고 유지보수하기 쉽습니다 [9].
+
+* **상호작용 및 접근성 테스트 (Interaction & Accessibility Tests)**
+  Storybook은 컴포넌트의 외형뿐만 아니라 동작(Behavior)까지 검증할 수 있습니다. 상호작용 테스트를 통해 로딩, 에러, 호버, 메뉴 열림 등 다양한 UI 상태를 시뮬레이션할 수 있으며 [5], 이러한 상태 변화에 맞춰 스크린샷을 찍음으로써 행동 테스트와 시각적 검증을 동일한 워크플로우 내에서 처리할 수 있습니다 [5, 6]. 부가적으로 추가적인 테스트 코드 작성 없이도 접근성 회귀 테스트를 함께 수행할 수 있습니다 [4, 10].
+
+* **CI/CD 및 도구 통합 (CI/CD Integrations)**
+  Storybook은 Chromatic이나 Happo 같은 클라우드 서비스 도구들과 원활하게 통합됩니다 [1, 4, 8]. 이러한 도구를 CI 파이프라인에 연동하면, PR(Pull Request)이 생성될 때마다 Chrome, Firefox, Safari 등 다양한 실제 브라우저와 여러 뷰포트 크기에서 자동으로 스크린샷이 캡처되고 베이스라인과 비교됩니다 [1, 4, 11]. 이를 통해 리뷰어는 각 상태를 수동으로 확인할 필요 없이 변경된 부분(Diff)에만 집중하여 변경 사항을 승인(Accept)하거나 수정할 수 있습니다 [2, 12, 13].
+
+## ⚖️ Trade-offs & Caveats
+* **테스트의 불안정성(Flakiness) 및 노이즈 문제:** 시각적 테스트는 애니메이션, 비동기 자산(Asset), 폰트 로딩 등으로 인해 깨지기 쉽거나 불안정해질 수 있습니다 [10, 11]. 또한 이미지 압축 노이즈나 안티앨리어싱(anti-aliasing)과 같은 미세한 차이로 인해 실패할 수도 있습니다 [10, 14]. 이를 완화하기 위해 Happo 등은 애니메이션을 자동으로 무효화하고 비동기 자산을 대기하며, 시각적 변경에 대한 색상 허용 오차(color-delta tolerance)를 설정해야 하는 제약과 설정 오버헤드가 따릅니다 [11, 14].
+* **추가적인 리뷰 병목 및 CI 설정 오버헤드:** 시각적 테스트가 유효하려면 변경된 스크린샷이 의도된 것인지(새로운 베이스라인으로 수락) 아니면 버그인지 판단하는 팀원의 수동 리뷰 과정이 반드시 수반되어야 합니다 [12, 13]. 또한 CI/CD에서 원활하게 동작하도록 프로젝트 토큰 등 인증 환경 변수를 구성하고 파이프라인을 설정하는 초기 작업이 요구됩니다 [7].
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+
+#### [테스트 및 검증 기법 (Testing Methods)]
+- [[Visual Regression Testing]]
+  - 연결 이유: Storybook이 컴포넌트의 변경 사항을 픽셀 단위로 확인하기 위해 사용하는 핵심 테스트 방법론입니다 [4, 8].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: HTML 마크업을 비교하는 Snapshot Test의 한계점과 오탐(False Positive)의 원리, 그리고 픽셀 렌더링 기반 비교의 장점을 명확히 이해할 수 있습니다 [9].
+
+- [[Interaction Testing]]
+  - 연결 이유: 컴포넌트의 단순한 렌더링뿐만 아니라 유저의 행동(이벤트, 상태 등)을 시뮬레이션하여 다양한 UI 상태(로딩, 호버 등)를 검증하는 Storybook의 기능입니다 [5, 6].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 상태 전이에 따라 동적으로 변하는 UI를 어떻게 시각적 테스트와 결합하여 검증할 수 있는지 원리를 파악할 수 있습니다 [5].
+
+#### [통합 및 자동화 도구 (Integration Tools)]
+- [[Chromatic]]
+  - 연결 이유: Storybook 유지보수 팀이 만든 공식 클라우드 서비스로, 크로스 브라우저 시각적 테스트와 CI 통합을 네이티브로 지원합니다 [8, 15].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 클라우드 환경에서 베이스라인(Baseline) 이미지가 어떻게 저장, 비교, 동기화되는지 CI/CD 파이프라인 통합 과정을 이해할 수 있습니다 [7, 13].
+
+- [[Happo]]
+  - 연결 이유: Storybook과 통합되어 다중 브라우저 스크린샷 테스트 및 접근성 회귀 테스트를 병렬로 수행하는 시각적 테스트 도구입니다 [4].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: Flakiness 방지를 위해 애니메이션을 정지하거나 색상 오차 범위(color-delta tolerance)를 설정하여 시각적 노이즈를 줄이는 구체적 최적화 기법을 알 수 있습니다 [11, 14].
+
+### Deeper Research Questions
+- Storybook의 Visual Test와 전통적인 HTML Snapshot Test를 비교했을 때, 실제 대규모 프로젝트에서 발생하는 유지보수 오버헤드와 오탐(false positive) 비율의 차이는 어떠한가?
+- 애니메이션, 비동기 폰트 로딩 등으로 인해 발생하는 Visual Test의 Flakiness를 완전히 제어하기 위해 Chromatic이나 Happo는 어떤 렌더링 파이프라인 제어 기술을 사용하는가?
+- Storybook의 Interaction Test로 복잡한 사용자 여정(User Journey)을 시뮬레이션할 때, 상태별 스크린샷 캡처가 CI 빌드 시간에 미치는 영향과 이를 병렬화하여 최적화하는 전략은 무엇인가?
+- 모노레포(Monorepo) 환경이나 Feature-Sliced Design 아키텍처에서 수백 개의 기능 모듈이 각각 분리된 Storybook을 가질 때, 이를 통합적으로 빌드하고 시각적 회귀를 모니터링하는 베스트 프랙티스는 무엇인가?
+- Storybook을 사용한 시각적 접근성 테스트(Accessibility regression testing)가 실제 DOM 기반의 접근성 감사 도구(aXe 등)와 비교하여 갖는 한계점과 보완점은 무엇인가?
+
+### Practical Application Contexts
+- **Implementation:** React 등 UI 프레임워크 기반 프로젝트에서 복잡한 컴포넌트를 앱의 비즈니스 로직과 분리하여 `Button`, `Modal` 등의 요소를 독립적으로 렌더링하고, 호버 및 에러 상태의 Story를 작성합니다.
+- **System Design:** Feature-Sliced Design처럼 도메인과 피처가 뚜렷하게 나뉜 아키텍처를 도입할 때, 각 피처 폴더별로 Storybook 환경을 세팅하여 격리된 개발 및 테스트 구조를 설계합니다.
+- **Operation / Maintenance:** CI/CD 워크플로우에 Chromatic 또는 Happo를 연동하여, 팀원이 PR을 올릴 때마다 자동으로 시각적 변경 사항(Visual Diff)이 캡처되고 이를 리뷰어가 직접 확인 후 병합(Merge)하는 운영 프로세스를 구축합니다.
+- **Learning Path:** 기본 UI 컴포넌트 격리 개발 -> Story 작성을 통한 문서화 -> Interaction Test 작성 -> 자동화된 Visual Regression Test 구축으로 이어지는 프론트엔드 품질 보증 학습 경로에 사용됩니다.
+- **My Project Relevance:** 현재 유지보수 중인 애플리케이션의 리팩토링이나 새로운 디자인 시스템(UI 라이브러리) 구축 작업 시, 실수로 발생하는 CSS/레이아웃 깨짐을 사전에 방지하기 위한 안전장치로 도입할 수 있습니다.
+
+### Adjacent Topics
+- [[Pull Request Workflow]]
+  - 확장 방향: Storybook 시각적 테스트의 결과를 GitHub, GitLab 등의 리뷰 프로세스와 결합하여, 버그 없는 UI 코드를 배포하기 위한 협업 및 검증 파이프라인 구축 전략으로 확장합니다.
+- [[Feature-Sliced Design]]
+  - 확장 방향: 프론트엔드 코드를 기능(Feature) 단위로 분리할 때, Storybook을 이용해 각 기능의 UI 컴포넌트들을 메인 앱에 의존하지 않고 독립적으로 작동하게 만드는 설계 원칙으로 확장합니다.
+
+---
+*Last updated: 2026-04-30*
\ No newline at end of file
diff --git a/10_Wiki/Development/Visual Regression Testing.md b/10_Wiki/Development/Visual Regression Testing.md
new file mode 100644
index 00000000..7711b648
--- /dev/null
+++ b/10_Wiki/Development/Visual Regression Testing.md	
@@ -0,0 +1,57 @@
+# [[Visual Regression Testing]]
+
+## 📌 Brief Summary
+시각적 회귀 테스트(Visual Regression Testing)는 스토리북(Storybook) 등의 도구로 렌더링된 컴포넌트의 픽셀 단위 스크린샷을 캡처하여 이전에 알려진 "정상(baseline)" 상태의 스크린샷과 자동으로 비교하는 테스트 방식이다 [1, 2]. 이를 통해 개발자는 풀 리퀘스트(PR) 과정에서 의도치 않은 UI 레이아웃, 색상, 타이포그래피 등의 시각적 변경이나 결함을 찾아낼 수 있다 [3-5]. HTML 마크업만 비교하는 기존의 스냅샷 테스트와 달리, 실제 사용자가 경험하는 화면 픽셀을 직접 검증하므로 추가적인 테스트 코드 작성이나 유지보수 부담을 줄이면서도 오탐(false positive)을 최소화할 수 있는 것이 특징이다 [1, 2].
+
+## 📖 Core Content
+*   **작동 원리 및 프로세스:** 시각적 회귀 테스트는 코드가 변경되었을 때 모든 스토리(story)를 실제 브라우저(Chrome, Firefox, Safari 등) 환경에서 렌더링하고, 해당 화면을 캡처하여 기존의 기준선(baseline)과 비교한다 [4, 6]. 만약 레이아웃이나 색상 등에 의도치 않은 변화가 감지되면 해당 차이점을 강조하여 PR에서 수동 검토를 거치게 함으로써 시각적 결함이 프로덕션으로 배포되는 것을 차단한다 [3, 6, 7]. 변경 사항이 의도된 것이라면 개발자가 새로운 기준선으로 승인(accept)하여 로컬 및 CI 환경에 동기화할 수 있다 [7, 8].
+*   **스냅샷 테스트(Snapshot Testing)와의 차이점:** 기존 스냅샷 테스트는 렌더링된 HTML 마크업 블록을 비교하기 때문에, 코드가 변경되었으나 사용자에게 보이는 실제 시각적 변경이 없는 경우에도 테스트가 실패하는 오탐(false positive)이 발생하기 쉽다 [2]. 반면 시각적 회귀 테스트는 렌더링된 픽셀 자체를 비교하므로 사용자가 실제로 경험하는 UI의 모양, 간격, 반응형 동작 등을 훨씬 더 정확하고 풍부하게 검증할 수 있다 [2, 5].
+*   **인터랙션(Interaction) 기반 상태 검증:** 컴포넌트의 로딩, 에러, 호버(hover), 메뉴 열림 등의 다양한 UI 상태를 검증하기 위해 스토리북의 인터랙션 테스트와 시각적 회귀 테스트를 결합할 수 있다 [9]. 인터랙션 테스트를 통해 컴포넌트를 특정 상태로 만든 후 스크린샷을 찍음으로써 동적인 행동에 대한 시각적 결함 유무까지 하나의 워크플로우 안에서 파악할 수 있다 [9, 10].
+*   **CI 파이프라인 자동화:** 이 테스트는 GitHub Actions, GitLab Pipelines 등 CI 환경과 원활하게 통합되어 풀 리퀘스트(PR)마다 자동으로 실행된다 [11, 12]. 테스트가 완료되면 PR에 UI 변경 사항에 대한 알림(badge)을 제공하여, 리뷰어가 모든 상태를 일일이 확인하는 대신 변경된 부분(diffs)에만 집중해서 리뷰할 수 있도록 돕는다 [6, 12].
+
+## ⚖️ Trade-offs & Caveats
+*   **미세한 픽셀 차이로 인한 노이즈(Flakiness):** 브라우저의 이미지 압축 노이즈나 안티앨리어싱(anti-aliasing) 처리 등 아주 미세한 픽셀 차이 때문에 실제로는 결함이 아님에도 불구하고 시각적 변경으로 감지되는 테스트 불안정성(Flake)이 발생할 수 있다 [11, 13]. 이를 방지하기 위해 시각적 테스트 도구에서는 색상 차이 허용치(color-delta tolerance) 임계값을 설정하여 해당 범주 아래의 차이는 노이즈로 무시하는 최적화 작업이 요구된다 [10, 13].
+*   **비동기 요소 및 애니메이션 제어의 필요성:** 컴포넌트에 포함된 애니메이션이나 비동기 에셋, 폰트 등이 완전히 렌더링되기 전에 스크린샷이 캡처되면 매번 다른 결과가 나와 일관된 테스트가 불가능해진다 [10, 11]. 따라서 시각적 회귀 테스트 도구(Happo 등)는 캡처 전 애니메이션을 자동으로 음소거(silence) 처리하거나 비동기 요소의 로딩을 강제로 기다려야 하는 기술적 제약과 추가 설정이 필요하다 [10, 11].
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+
+#### [테스트 및 검증 기술]
+- [[Snapshot Testing]]
+  - 연결 이유: 시각적 회귀 테스트와 대조되는 테스트 방식으로, 픽셀이 아닌 렌더링된 HTML 마크업 코드 덩어리를 비교한다 [2].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: HTML 구조 비교 방식이 왜 빈번하게 오탐(False Positive)을 발생시키는지, 그리고 픽셀 기반 비교가 유지보수에 왜 더 유리한지 명확하게 이해할 수 있다 [2].
+- [[Interaction Testing]]
+  - 연결 이유: 사용자의 상호작용이나 이벤트를 시뮬레이션하여 컴포넌트의 특정 UI 상태를 유도하는 테스트 방식이다 [5, 10].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 정적 UI 화면뿐만 아니라 로딩, 에러, 클릭 시 드롭다운 오픈 등 동적으로 변화하는 UI 상태를 시각적 회귀 테스트가 어떻게 캡처하고 검증하는지 파악할 수 있다 [9, 10].
+
+#### [구현 및 활용 도구]
+- [[Storybook]]
+  - 연결 이유: UI 컴포넌트를 애플리케이션의 복잡한 로직과 분리하여 격리된 환경에서 시각적으로 개발하고 문서화할 수 있게 해주는 도구이다 [3, 6].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 시각적 회귀 테스트가 전체 페이지 단위가 아닌 개별 컴포넌트의 상태(Story) 단위로 렌더링되고 기준선과 비교되는 아키텍처적 기반을 이해할 수 있다 [1].
+- [[Chromatic]] / [[Happo]]
+  - 연결 이유: Storybook과 연결되어 실제 브라우저 기반의 스크린샷 캡처, 베이스라인 픽셀 비교, CI/CD 연동 등을 수행하는 시각적 회귀 테스트 클라우드 서비스(도구)이다 [1, 3, 4].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 자동화된 시각적 회귀 테스트가 브라우저 간의 렌더링 차이를 어떻게 병렬로 처리하고 풀 리퀘스트(PR) 프로세스와 어떻게 상호작용하는지 확인할 수 있다 [4, 12].
+
+### Deeper Research Questions
+- Snapshot Testing에서 Visual Regression Testing으로 마이그레이션할 때, 대규모 컴포넌트 라이브러리 환경에서 초기 기준선(baseline) 구축 및 스토리지 유지보수 비용은 어떻게 최적화할 수 있는가?
+- Chromatic이나 Happo와 같은 도구가 크로스 브라우저(Chrome, Safari, Firefox 등)에서 동일한 컴포넌트를 렌더링할 때 발생하는 OS/브라우저 엔진별 미세한 렌더링 차이를 어떻게 처리하고 보정하는가?
+- 시각적 회귀 테스트 파이프라인을 CI/CD에 통합했을 때 빌드 시간 지연을 방지하기 위한 병렬 처리(Parallelization) 및 최적화 전략은 무엇인가?
+- 애니메이션 및 비동기 데이터를 많이 사용하는 복잡한 인터랙티브 컴포넌트에서 테스트의 불안정성(Flakiness)을 코드 레벨에서 근본적으로 제거하려면 컴포넌트를 어떻게 설계해야 하는가?
+- Visual Regression Testing과 Accessibility Regression Testing을 하나의 워크플로우로 결합했을 때, 접근성 위반 사항이 구체적으로 어떤 시각적 지표와 함께 리포트되며 PR 리뷰 프로세스는 어떻게 효율화되는가?
+
+### Practical Application Contexts
+- **Implementation:** Storybook으로 UI 컴포넌트를 개발한 후, Chromatic이나 Happo 등의 애드온을 설치하여 코드 변경 시마다 각 컴포넌트의 상태별 스크린샷을 자동으로 캡처하고 기준선과 비교하도록 설정한다 [4, 14].
+- **System Design:** 프론트엔드 아키텍처 설계 시, 비즈니스 로직과 UI를 철저히 분리하여 컴포넌트를 구축하고, 시각적 검증 시스템을 도입하여 대규모 팀이 동시에 개발하더라도 일관된 디자인 시스템이 훼손되지 않도록 방어 체계를 마련한다 [3, 4].
+- **Operation / Maintenance:** CI 파이프라인(GitHub Actions 등)에 시각적 테스트를 필수 단계로 추가하여, 변경된 디자인 코드가 PR에 올라올 때마다 의도치 않은 레이아웃 깨짐 현상을 자동으로 감지하고 리뷰어에게 시각적 Diff를 제공하여 운영 유지보수 부담을 줄인다 [3, 6, 12].
+- **Learning Path:** React 컴포넌트 기반 UI 작성 → Storybook을 활용한 컴포넌트 문서화 및 CDD(Component-Driven Development) → 인터랙션(Interaction) 테스트 작성 → 시각적 회귀 테스트 자동화 순으로 프론트엔드 품질 검증 파이프라인을 학습한다 [9, 15].
+- **My Project Relevance:** 프론트엔드 레거시 코드를 리팩토링하거나 수백 개의 화면에서 공유되는 코어 UI 라이브러리 버전을 업그레이드할 때, 다른 팀의 컴포넌트에서 발생하는 의도치 않은 파급 효과(Side Effect) 및 시각적 깨짐을 안전하게 감지하고 확신을 갖고 배포하는 데 핵심적인 역할을 한다 [3, 16].
+
+### Adjacent Topics
+- [[Accessibility Regression Testing]]
+  - 확장 방향: 시각적 테스트 워크플로우와 결합하여, 새로운 테스트 코드를 별도로 작성할 필요 없이 스크린샷 실행 단계에서 UI의 접근성 위반(명도 대비 부족, 키보드 포커스 누락 등)까지 동시에 자동 검증하는 영역으로 확장할 수 있다 [9, 10].
+- [[Continuous Integration (CI) Pipelines]]
+  - 확장 방향: GitHub Actions, CircleCI 등의 CI 도구에서 시각적 테스트 인프라가 어떻게 연동되며, 코드가 병합되기 전에 PR의 상태 체크(Status Check)를 필수로 제어하는 자동화 파이프라인 및 DevOps 프로세스로 학습을 넓힐 수 있다 [12].
+
+---
+*Last updated: 2026-04-30*
\ No newline at end of file
diff --git a/10_Wiki/Development/Vite + React 성능 최적화.md b/10_Wiki/Development/Vite + React 성능 최적화.md
new file mode 100644
index 00000000..5fbe3306
--- /dev/null
+++ b/10_Wiki/Development/Vite + React 성능 최적화.md	
@@ -0,0 +1,75 @@
+# [[Vite + React 성능 최적화]]
+
+## 📌 Brief Summary
+Vite와 React 환경에서 애플리케이션의 성능을 최적화하는 것은 초기 로딩 속도를 높이고 런타임 성능을 향상시켜 전반적인 사용자 경험을 개선하는 과정입니다. 개발 환경에서는 기본 ES 모듈(ESM)을, 운영 환경에서는 Rollup을 통한 번들링을 활용하는 Vite의 구조적 이점을 극대화하는 것이 핵심입니다. 주요 최적화 기법으로는 빠른 컴파일을 위한 SWC 도입, 동적 임포트를 통한 코드 분할, `manualChunks`를 활용한 무거운 벤더 라이브러리 분리, 그리고 번들 시각화 도구를 통한 불필요한 의존성 제거 등이 포함됩니다.
+
+## 📖 Core Content
+*   **Vite의 아키텍처 이해 및 SWC 활용**
+    개발 중에는 모든 코드를 미리 번들링하지 않고 브라우저에 네이티브 ES 모듈(ESM)로 직접 제공하여 매우 빠른 서버 시작과 HMR(Hot Module Replacement)을 달성합니다 [1, 2]. 컴파일 속도를 극대화하기 위해 기존의 Babel 대신 Rust 기반 컴파일러인 SWC(`@vitejs/plugin-react-swc`)를 채택하면, 커스텀 Babel 플러그인이 필요 없는 대규모 React 프로젝트에서 빌드 및 새로고침 시간을 획기적으로 줄일 수 있습니다 [3-5].
+*   **코드 분할(Code Splitting) 및 지연 로딩(Lazy Loading)**
+    초기 로드 속도를 높이고 LCP(Largest Contentful Paint)와 같은 웹 지표를 향상시키기 위해 무거운 번들을 여러 청크로 분할해야 합니다 [6, 7]. `React.lazy()`와 `<Suspense>`를 사용한 동적 임포트로 라우트 레벨이나 차트 등 큰 위젯을 사용자가 접근할 때만 로드하도록 설정하면 메인 번들의 크기를 대폭 줄일 수 있습니다 [6, 8-13].
+*   **`manualChunks`를 활용한 벤더 라이브러리 분할**
+    프로덕션 빌드 시 500kB 이상의 거대한 청크 경고를 해결하기 위해 `vite.config.js`의 Rollup 옵션에서 `manualChunks`를 설정합니다 [12, 14-17]. React 코어나 Lodash, 차트, 아이콘 등 잦은 변경이 없는 외부 라이브러리들을 별도의 파일로 분리하면, 브라우저가 변경되지 않은 코드를 장기간 캐싱(Long-term caching)할 수 있어 재방문 및 배포 시 로딩 효율이 향상됩니다 [12, 15, 18, 19].
+*   **의존성 사전 번들링(`optimizeDeps`)과 트리 쉐이킹**
+    대규모 앱이나 비정상적인 의존성 로딩으로 인한 성능 저하를 방지하기 위해 `optimizeDeps`를 명시적으로 제어할 수 있습니다 [5, 6]. 또한 불필요한 코드 로드를 막기 위해 `lodash` 대신 `lodash-es`처럼 트리 쉐이킹(Tree-shaking)이 지원되는 최신 ES 모듈 기반 라이브러리를 우선적으로 사용해야 합니다 [20].
+*   **번들 시각화 및 모니터링**
+    `rollup-plugin-visualizer` 플러그인을 연동하여 빌드 시 거대한 번들의 구성 요소를 시각적인 트리맵 형태로 분석합니다 [6, 13, 21]. 이를 통해 번들 내 차지하는 비중이 불필요하게 큰 코드를 찾아내어 제거하거나 지연 로딩으로 분리할 기회를 신속하게 파악할 수 있습니다 [13, 20, 22].
+
+## ⚖️ Trade-offs & Caveats
+*   **과도한 플러그인 사용:** Vite를 구성할 때 너무 많은 플러그인을 남용하면 개발 서버의 성능이 현저히 느려질 수 있으므로, 반드시 필요한 플러그인 위주로 가볍게 유지해야 합니다 [20].
+*   **캐싱 무효화 주의:** 모듈 로딩 성능을 위해 Vite는 브라우저 캐싱에 크게 의존하므로, 개발 시 브라우저 개발자 도구에서 캐시를 무효화(Disable cache)하면 성능이 급격하게 저하될 수 있습니다 [20].
+*   **지연 로딩의 과용 및 잘못된 배치:** 모든 컴포넌트에 지연 로딩을 남발하거나, 스크롤 없이 바로 보여야 하는 핵심(Above-the-fold) 요소나 즉시 렌더링해야 하는 UI까지 지연 로딩을 적용하면 초기 화면 표시가 지연되어 오히려 사용자 경험을 망칠 수 있습니다 [23, 24].
+*   **메모이제이션(`React.memo`, `useMemo` 등) 오버헤드:** 불필요한 리렌더링을 막기 위한 도구지만, 비교 연산과 이전 상태를 캐싱하는 메모리 비용이 발생합니다 [25]. 렌더링이 아주 빠르고 단순한 컴포넌트나, 전달되는 props가 빈번히 변경되는 경우(예: 인라인 객체, 함수 전달)에 사용하면 렌더링 자체보다 상태 비교 비용이 더 커져 성능이 오히려 악화될 수 있습니다 [25-28].
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+
+#### [관계 유형 A (아키텍처/기반 기술)]
+- [[네이티브 ES 모듈(ESM)]]
+  - 연결 이유: Vite가 개발 환경에서 코드 모듈을 서빙하는 방식의 핵심 기반 원리입니다.
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 번들러가 전체 앱을 매번 빌드하지 않고 변경된 모듈만 요청/로드함으로써 프로젝트 크기에 상관없이 빠른 HMR과 응답성을 유지하는 메커니즘을 파악할 수 있습니다 [1, 29, 30].
+
+- [[Rollup]]
+  - 연결 이유: Vite 환경에서 프로덕션 배포 시 코드를 하나로 모으고 최적화하는 데 사용되는 번들러입니다.
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: Vite의 설정 파일(`vite.config.js`)에서 `manualChunks` 등 Rollup 전용 빌드 옵션을 통해 어떻게 효율적인 정적 애셋(Asset)을 생성하고, 코드 분할과 트리 쉐이킹을 수행하는지 이해할 수 있습니다 [14, 18, 31, 32].
+
+#### [관계 유형 B (구현/활용 도구)]
+- [[SWC 컴파일러]]
+  - 연결 이유: Vite의 기본 구성을 확장해 속도를 향상시키기 위한 강력한 도구입니다.
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 과거 Babel이 처리하던 JSX/TypeScript 변환 작업을 Rust 기반의 빠른 도구(`@vitejs/plugin-react-swc`)로 교체하여 대형 React 애플리케이션의 재빌드 시간을 즉각적으로 단축시키는 방식을 파악할 수 있습니다 [1, 3, 5].
+
+- [[React.lazy & Suspense]]
+  - 연결 이유: React 내부에서 동적 임포트를 통한 컴포넌트 레벨 지연 로딩을 구현하기 위한 API입니다.
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 라우트나 무거운 모듈을 분리하고, 번들이 로드되는 동안 `<Suspense>`를 통해 폴백(Fallback) UI를 처리함으로써 초기 자바스크립트 페이로드 용량을 대폭 줄이는 실무 기법을 배울 수 있습니다 [6, 9, 11, 12, 33].
+
+- [[rollup-plugin-visualizer]]
+  - 연결 이유: 최적화 작업 전후로 번들 크기를 시각화하고 문제를 진단하는 필수 분석 플러그인입니다.
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 큰 청크가 왜 발생하는지, 어떤 외부 라이브러리(벤더)가 의도치 않게 용량을 과도하게 점유하는지 분석하여 `manualChunks`나 코드 교체를 결단하는 측정/디버깅 기반을 확립할 수 있습니다 [6, 13, 21].
+
+### Deeper Research Questions
+
+- 대규모 외부 패키지를 사용할 때 Vite의 `optimizeDeps`를 세밀하게 튜닝하려면 어떠한 기준과 설정 방식을 적용해야 하는가?
+- SWC 플러그인을 도입할 때 기존에 사용 중인 특정 커스텀 Babel 플러그인을 온전히 대체하거나 병행해서 사용해야 하는 경우의 한계 및 해결책은 무엇인가?
+- Rollup의 `manualChunks`로 무거운 라이브러리를 분리할 때, 브라우저가 병렬로 다운로드할 수 있는 한계점과 장기 캐싱(Long-term caching)의 이점을 고려한 최적의 분할 단위(Chunk size)는 어느 정도인가?
+- `React.lazy`와 `<Suspense>`를 라우트 레벨이 아닌 세부 컴포넌트 레벨(예: 무거운 모달 창이나 차트)에 광범위하게 적용할 때, 불필요한 로딩 상태 남발을 막고 자연스러운 사용자 경험을 유지하는 방법은 무엇인가?
+- 번들 시각화를 통해 발견된, 트리 쉐이킹이 전혀 적용되지 않는 레거시 라이브러리 의존성을 제거하거나 모던 라이브러리로 마이그레이션할 때 따라야 할 리팩토링 전략은 무엇인가?
+
+### Practical Application Contexts
+
+- **Implementation:** `vite.config.ts` 파일에서 SWC 플러그인 설정 및 `rollupOptions` 내 `manualChunks`를 직접 작성하여 React 런타임, 상태 관리 도구, 차트 라이브러리 등을 각각의 청크로 추출하도록 코드를 구현합니다.
+- **System Design:** 초기 아키텍처 수립 시, 라우트 별로 지연 로딩될 기능과 앱 구동 시 즉시 필요한 코어 레이어를 엄격하게 분리하여 코드 스플리팅을 전제로 한 컴포넌트 계층 트리를 설계합니다.
+- **Operation / Maintenance:** CI/CD 파이프라인에 `rollup-plugin-visualizer`의 결과를 리포트로 남기도록 구성하여, 팀원이 새로운 패키지를 추가할 때 메인 번들 크기가 비정상적으로 커지지 않는지 지속적으로 감시하고 유지보수합니다.
+- **Learning Path:** 우선 React의 렌더링 원리 및 프로파일러 사용법을 학습한 후, 빌드 툴(Vite/Rollup)의 번들링 메커니즘을 이해하고, 이후 지연 로딩 기법 및 번들 최적화 플러그인 실습으로 이어지는 로드맵을 구성합니다.
+- **My Project Relevance:** 거대한 자바스크립트 파일 전송으로 인해 렌더링이 지연되는 프로젝트나, 빌드 후 "500kB 초과" 경고가 뜨는 프론트엔드 환경에서 즉각적인 파일 분할과 캐싱 전략을 적용하여 페이지 로드 성능(FCP, LCP)을 가시적으로 개선할 수 있습니다.
+
+### Adjacent Topics
+
+- [[Core Web Vitals]]
+  - 확장 방향: Vite와 React 최적화를 통해 얻어낸 메인 번들 크기 감소 및 렌더링 속도 향상이 실제 사용자 체감 성능 지표(LCP, FID/INP 등)에 어떤 수치적 개선으로 나타나는지를 구체적으로 연구합니다 [11, 34, 35].
+
+- [[Concurrent Rendering (동시성 렌더링)]]
+  - 확장 방향: 로딩과 번들링 최적화뿐만 아니라, `useTransition` 및 `useDeferredValue` 훅을 이용하여 복잡한 데이터 변화 시에도 사용자 입력 등의 UI 반응성을 유지하는 런타임 차원의 성능 향상 전략으로 지식을 확장합니다 [36-38].
+
+---
+*Last updated: 2026-04-30*
\ No newline at end of file
diff --git a/10_Wiki/Development/Vite Build System.md b/10_Wiki/Development/Vite Build System.md
new file mode 100644
index 00000000..9ee03e7c
--- /dev/null
+++ b/10_Wiki/Development/Vite Build System.md	
@@ -0,0 +1,52 @@
+# [[Vite Build System]]
+
+## 📌 Brief Summary
+Vite는 현대 프론트엔드 애플리케이션(특히 React) 개발을 위한 새로운 산업 표준 빌드 도구로, 거의 즉각적인 서버 시작과 초고속 HMR(Hot Module Replacement)을 제공합니다 [1, 2]. 기존 번들러와 달리 개발 환경에서는 브라우저에 네이티브 ES 모듈 형태로 코드를 제공하고, 프로덕션 환경에서는 Rollup을 사용하여 고도로 최적화된 번들을 생성하는 하이브리드 아키텍처를 사용합니다 [3, 4]. 또한 SWC나 esbuild와 같은 Rust 기반 컴파일러를 활용하여 대규모 프로젝트에서도 빠르고 원활한 개발자 경험을 보장합니다 [3, 5, 6].
+
+## 📖 Core Content
+*   **하이브리드 아키텍처 (개발 및 프로덕션)**: Vite는 개발 시 모든 코드를 사전에 번들링하는 대신, 코드를 네이티브 ES 모듈(ESM) 형태로 브라우저에 직접 제공합니다 [2, 3]. 이 방식은 필요할 때 필요한 파일만 로드하므로 프로젝트 규모가 커져도 서버 시작 및 갱신 속도가 매우 빠릅니다 [3, 7]. 반면, 프로덕션 배포 시에는 내부적으로 Rollup을 사용하여 자동 코드 스플리팅, 미사용 코드 제거(Tree-shaking), 자산 최적화 등을 수행하여 성능이 뛰어난 번들을 생성합니다 [4, 8].
+*   **초고속 컴파일러 및 플러그인 활용**: Vite는 컴파일 속도를 높이기 위해 Rust 기반의 컴파일러인 SWC 또는 esbuild를 사용합니다 [3]. 기존 Babel 대신 `@vitejs/plugin-react-swc`를 사용하면 JSX 및 TypeScript 컴파일 속도가 비약적으로 향상되어 재빌드 시간이 단축됩니다 [5, 6, 9]. 이외에도 `vite-plugin-svgr`(SVG 컴포넌트화), `vite-plugin-pwa`와 같은 유연한 플러그인 생태계를 지원합니다 [10].
+*   **고급 구성 (vite.config.js)**: Vite는 `vite.config.js`를 통해 복잡한 프로젝트 설정을 제어할 수 있습니다. 예를 들어 경로 별칭(Path Aliases)을 설정하여 임포트를 깔끔하게 관리하거나, `VITE_` 접두사가 붙은 환경 변수만을 안전하게 노출하며, 개발 중 CORS 문제를 피하기 위한 내장 프록시 서버 설정을 지원합니다 [5, 9, 11].
+*   **성능 튜닝 및 대용량 청크(Chunk) 관리**: 대규모 앱에서는 무거운 벤더 라이브러리로 인해 메인 번들이 과도하게 커지는 문제("chunks are larger than 500 kB")가 발생할 수 있습니다 [12-14]. 이를 해결하기 위해 `manualChunks`를 사용하여 React, 차트 라이브러리 등 자주 변경되지 않는 벤더 코드를 별도의 파일로 분리해 브라우저 캐싱을 극대화합니다 [8, 11, 14-16]. 이와 함께 `React.lazy`와 `<Suspense>`를 이용한 라우트 레벨의 동적 임포트(코드 스플리팅)를 적용하고, `rollup-plugin-visualizer`로 번들 크기를 시각적으로 분석하여 불필요한 코드를 제거하는 것이 모범 사례입니다 [16-19].
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+- [[Native ES Modules (ESM)]]
+  - 연결 이유: Vite가 개발 환경에서 파일 전체를 사전 번들링하지 않고, 필요할 때 브라우저에 코드를 제공하는 핵심 메커니즘이기 때문입니다 [3, 7].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: Vite가 기존 도구(Webpack 등)에 비해 어떻게 초기 구동 속도와 HMR 응답성을 극적으로 단축할 수 있는지 그 원리를 파악할 수 있습니다 [2, 3].
+
+- [[Rollup]]
+  - 연결 이유: Vite가 프로덕션용 빌드를 생성할 때 내부적으로 채택하고 있는 번들러 도구이기 때문입니다 [4].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 프로덕션 환경에서 청크가 어떻게 나뉘며(`manualChunks`), 코드 스플리팅과 트리 쉐이킹을 통해 최적화된 정적 자산이 만들어지는 과정을 이해할 수 있습니다 [4, 8, 11].
+
+- [[SWC (Speedy Web Compiler)]]
+  - 연결 이유: Vite 환경에서 기존의 Babel을 대체하여 JSX와 TypeScript를 실시간에 가깝게 변환하는 Rust 기반 컴파일러 기술이기 때문입니다 [3, 5, 6].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 대규모 React 애플리케이션 개발 시 컴파일 속도와 핫 리로드 속도를 향상하는 기술적 배경을 깊이 이해할 수 있습니다 [3, 6].
+
+- [[Code Splitting & manualChunks]]
+  - 연결 이유: 대용량 메인 번들 문제를 해결하고, 초기 페이지 로드 속도를 높이기 위한 Vite 성능 최적화의 핵심 기법이기 때문입니다 [12, 14].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 동적 임포트와 결합하여 벤더 라이브러리(안정적인 코드)를 별도 파일로 캐싱하고 기능 단위로 청크를 나누는 전략을 학습할 수 있습니다 [8, 16].
+
+### Deeper Research Questions
+- 개발 환경의 네이티브 ESM 처리 방식과 프로덕션 환경의 Rollup 번들링 간의 아키텍처 차이가 런타임 동작이나 모듈 해석(Module Resolution)에 어떤 차이와 잠재적 버그를 유발할 수 있는가?
+- Vite의 `optimizeDeps`를 통한 사전 번들링(Pre-bundling) 프로세스는 거대한 외부 의존성 패키지를 로드할 때 브라우저의 네트워크 병목을 어떻게 해결하는가?
+- 대규모 React 앱을 마이그레이션 할 때 커스텀 Babel 플러그인을 사용 중인 환경에서 SWC 컴파일러(`@vitejs/plugin-react-swc`)로 전환할 때 발생하는 호환성 한계와 대안은 무엇인가?
+- `manualChunks`를 활용해 벤더 라이브러리를 세밀하게 분할할 때, 생성된 해시(hash) 파일명 기반의 장기 캐싱(Long-term Caching) 메커니즘은 브라우저에서 구체적으로 어떻게 최적화되는가?
+- `rollup-plugin-visualizer`를 통한 번들 시각화 이후, 의도치 않게 메인 청크에 포함된 과도한 트랜지티브 의존성(Transitive Dependencies)을 효과적으로 분리하는 구체적인 코드 레벨 패턴은 무엇인가?
+
+### Practical Application Contexts
+- **Implementation:** `vite.config.js`를 구성하여 `@vitejs/plugin-react-swc`를 도입하고, 상대 경로를 피하기 위한 경로 별칭(Path Aliases) 설정, `VITE_` 접두사를 이용한 안전한 환경 변수 바인딩, CORS를 우회하기 위한 프록시(Proxy) 설정을 적용합니다 [5, 9, 11].
+- **System Design:** 대규모 프론트엔드 시스템 설계 시, 무거운 초기 번들 크기 이슈를 방지하기 위해 Webpack 대신 Vite를 도입하고 개발(네이티브 ESM)과 프로덕션(Rollup 최적화)의 하이브리드 빌드 파이프라인을 구축합니다 [2-4, 8].
+- **Operation / Maintenance:** `rollup-plugin-visualizer`를 빌드 프로세스에 연동해 정기적으로 번들 크기를 모니터링하고, `manualChunks`를 유지보수하여 React 코어 같은 벤더 패키지의 브라우저 캐싱 이점을 유지합니다 [16-19].
+- **Learning Path:** 우선 Vite의 공식 스캐폴드 툴로 React 앱을 생성하여 기존 CRA(Create React App) 구조와의 차이를 체험한 후, 동적 임포트(`React.lazy`)와 `optimizeDeps` 등의 고급 설정 및 플러그인 확장을 점진적으로 학습합니다 [6, 7, 10, 16, 20].
+- **My Project Relevance:** 소스에 관련 정보가 부족합니다. (개인의 현재 진행 중인 특정 프로젝트에 대한 정보가 소스 텍스트에 포함되어 있지 않습니다.)
+
+### Adjacent Topics
+- [[React Server Components (RSC) & Next.js App Router]]
+  - 확장 방향: Vite를 이용한 빌드 툴 체인 최적화(CSR/SPA 성능 최적화)를 넘어, 클라이언트 측 자바스크립트 번들 자체를 전송하지 않고 서버에서 미리 렌더링하는 아키텍처 수준의 성능 최적화 패러다임으로 이해를 넓힙니다 [21-23].
+- [[Performance Metrics (Core Web Vitals)]]
+  - 확장 방향: Vite의 청크 최적화와 레이지 로딩 기법이 실제 사용자 체감 성능 지표인 FCP(First Contentful Paint), LCP(Largest Contentful Paint), INP(Interaction to Next Paint)에 어떤 직접적인 영향을 미치는지 연결하여 학습합니다 [13, 24, 25].
+
+---
+*Last updated: 2026-04-30*
\ No newline at end of file
diff --git a/10_Wiki/Development/Vite Build Tool.md b/10_Wiki/Development/Vite Build Tool.md
new file mode 100644
index 00000000..de593fe3
--- /dev/null
+++ b/10_Wiki/Development/Vite Build Tool.md	
@@ -0,0 +1,72 @@
+# [[Vite Build Tool]]
+
+## 📌 Brief 임무
+Vite는 현대 프론트엔드 애플리케이션(주로 React)을 위한 표준 빌드 도구로, 기존 Webpack 및 Create React App(CRA)을 대체하며 빠르게 자리 잡았습니다 [1, 2]. 이 도구는 개발 환경에서는 브라우저의 네이티브 ES 모듈(ESM)을 활용해 즉각적인 서버 시작과 초고속 HMR(Hot Module Replacement)을 제공합니다 [2-4]. 프로덕션 배포 시에는 내부적으로 Rollup을 사용하여 코드 스플리팅과 트리 쉐이킹이 적용된 고도로 최적화된 번들을 생성하는 하이브리드 아키텍처를 특징으로 합니다 [5, 6].
+
+## 📖 Core Content
+* **하이브리드 아키텍처 (Hybrid Architecture)**
+  * **개발 환경:** 코드를 사전에 전체 번들링하지 않고 브라우저에 네이티브 ES 모듈(ESM)로 직접 제공합니다. 필요한 파일만 로드되므로 프로젝트 크기가 커져도 개발 서버가 즉각적으로 반응합니다 [2-4].
+  * **프로덕션 환경:** 배포 시에는 Rollup을 사용하여 애플리케이션을 번들링하며, 자동 코드 스플리팅 및 사용하지 않는 코드를 제거하는 트리 쉐이킹(Tree-shaking)을 통해 최적화된 정적 에셋을 제공합니다 [5, 6].
+* **초고속 컴파일 및 사전 번들링 (Fast Compilation & Pre-bundling)**
+  * Vite는 esbuild나 최신 Rust 기반 트랜스포머인 SWC(Speedy Web Compiler)를 활용하여 JSX 및 TypeScript 파일을 사실상 즉시 컴파일합니다 [4, 7]. 기존 Babel을 SWC로 대체하면 핫 모듈 리로드 시간이 크게 단축됩니다 [8].
+  * 개발 중 새로고침 속도를 최적화하기 위해 종속성을 사전 번들링(Pre-bundling, `optimizeDeps`)합니다 [8].
+* **설정 및 플러그인 생태계 (Configuration & Plugins)**
+  * `vite.config.js`를 통해 경로 별칭(Path Aliases), CORS 문제를 방지하는 개발 서버 프록시, `VITE_` 접두사가 붙은 환경 변수 등을 유연하게 설정할 수 있습니다 [7, 9, 10].
+  * SVG를 React 컴포넌트로 가져오기 위한 `vite-plugin-svgr`, 오프라인 PWA 지원을 위한 `vite-plugin-pwa`, 번들 크기를 시각적으로 분석하는 `rollup-plugin-visualizer` 등 강력한 플러그인 생태계를 지원합니다 [11-13].
+* **번들 사이즈 최적화 (Bundle Optimization)**
+  * 기본적으로 Vite는 앱 코드와 모든 종속성(node_modules)을 하나의 `index.js`에 담아 빌드합니다. 이를 방지하기 위해 `vite.config.ts`의 Rollup 옵션에서 `manualChunks`를 설정하여 React 코어 라이브러리 등 무거운 벤더를 분리하고 브라우저 캐싱 효율을 높입니다 [6, 14, 15].
+  * `React.lazy()`와 `<Suspense>`를 결합한 라우트 레벨 동적 임포트를 통해 초기 메인 번들 크기를 극적으로 줄일 수 있습니다 [11, 14, 15].
+
+## ⚖️ Trade-offs & Caveats
+* **대형 청크 경고 및 초기 번들 비대화 (Large Chunks Warning):** Vite는 기본적으로 모든 종속성을 단일 파일로 빌드하기 때문에, 수동으로 코드 스플리팅을 하지 않으면 프로덕션 빌드 시 "500kB 초과" 경고가 발생할 수 있습니다. 이는 다운로드 시간을 지연시키고 낮은 성능의 모바일 기기에서 파싱 및 컴파일에 무리를 주어 FCP, LCP, INP와 같은 Core Web Vitals 지표를 악화시킬 수 있습니다 [14, 16, 17].
+* **개발자 도구 캐싱 의존성:** Vite는 모듈 로딩 성능을 위해 브라우저의 캐싱에 크게 의존합니다. 따라서 개발 중 브라우저 개발자 도구에서 "캐시 사용 안 함(Disable cache)"을 설정하면 개발 서버가 느려지는 부작용이 발생할 수 있습니다 [18].
+* **플러그인 남용으로 인한 성능 저하:** 과도한 플러그인 사용은 개발 서버의 속도를 저하시킬 수 있으므로, 구성을 최소화하고 필요한 플러그인만 유지해야 합니다 [18].
+* **사전 번들링 관리 필요성:** 규모가 크거나 특이한 외부 종속성의 경우, `optimizeDeps` 설정을 수동으로 제어하지 않으면 개발 환경에서 사전 번들링으로 인한 속도 저하가 발생할 수 있습니다 [8, 11].
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+
+#### [아키텍처/기반 기술]
+- [[Native ES Modules (ESM)]]
+  - 연결 이유: Vite가 개발 단계에서 빠른 구동 속도를 달성하기 위해 활용하는 브라우저의 기본 모듈 시스템입니다 [2, 4].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 과거 도구(Webpack)의 무거운 사전 번들링 방식과 대비되는 Vite의 '요청 시 제공(On-demand serving)' 메커니즘의 원리.
+
+- [[Rollup]]
+  - 연결 이유: Vite의 프로덕션 빌드를 담당하는 내부 번들러입니다 [5, 6].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 배포 환경에서 어떻게 `manualChunks`를 활용하여 번들을 분할하고, 트리 쉐이킹을 통해 최적화된 결과물을 도출하는지 그 과정 [10, 16].
+
+- [[SWC]]
+  - 연결 이유: 기존의 Babel을 대체하여 JSX와 TypeScript 컴파일을 엄청나게 빠른 속도로 처리하는 Rust 기반 트랜스포머입니다 [4, 7, 8].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: Vite 환경에서 React 애플리케이션의 핫 리로드와 빌드 퍼포먼스를 한 차원 끌어올리는 컴파일러의 역할.
+
+#### [최적화 기법]
+- [[Code Splitting & manualChunks]]
+  - 연결 이유: 500kB 이상의 거대한 메인 번들 경고 문제를 해결하기 위해 Vite/Rollup 환경에서 벤더 코드와 앱 코드를 나누는 핵심 기법입니다 [6, 14, 15].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 브라우저 병렬 다운로드와 효율적인 캐시 무효화 전략, 초기 페이로드 최소화 방법 [17, 19].
+
+### Deeper Research Questions
+
+- Vite의 네이티브 ESM 기반 개발 환경과 Rollup 기반 프로덕션 환경 사이의 차이로 인해, 런타임 또는 빌드 타임에 발생할 수 있는 호환성 문제나 예외 케이스는 무엇인가?
+- 대규모 애플리케이션에서 `optimizeDeps`를 통한 사전 번들링 메커니즘 최적화를 위해 구체적으로 어떤 기준을 가지고 종속성을 분리/포함해야 하는가?
+- `@vitejs/plugin-react-swc` 사용 시, 기존 Babel 생태계의 커스텀 플러그인들을 어떻게 이관하거나 대체해야 하는가?
+- `manualChunks`를 세밀하게 설정할 때 벤더 라이브러리의 중복 포함을 막고 가장 이상적인 청크 크기를 유지하는 전략은 무엇인가?
+- Vite 환경에서 라우트 레벨 지연 로딩(`React.lazy`) 적용 시 발생하는 워터폴(Waterfall) 네트워크 요청 문제를 방지하기 위해 `preload` 또는 `prefetch` 힌트를 어떻게 결합할 수 있는가?
+
+### Practical Application Contexts
+
+- **Implementation:** `npm create vite@latest`를 사용해 불필요한 설정 없는 가벼운 초기 구조를 생성하고, `vite.config.js`에 `@vitejs/plugin-react-swc`와 같은 플러그인, 경로 별칭(`@/components` 등), 백엔드 API 연동을 위한 proxy 설정을 구현합니다 [3, 7, 9, 10].
+- **System Design:** 프론트엔드 시스템 설계 시 개발 환경(빠른 피드백 루프 보장)과 배포 환경(고도의 압축 및 병렬 로드를 위한 모듈화 보장)에 다른 전략을 취하는 Vite의 하이브리드 철학을 아키텍처에 반영합니다 [5].
+- **Operation / Maintenance:** CI/CD 파이프라인이나 로컬 빌드 후 `rollup-plugin-visualizer` 플러그인을 활용하여 어떤 패키지가 메인 번들 용량을 차지하는지 시각적 트리맵으로 정기 점검하고 최적화합니다 [11, 13, 18].
+- **Learning Path:** 모듈 번들러의 발전 과정(Webpack -> ES Modules 네이티브 도입 -> Vite)을 학습한 후, 빌드 도구 차원의 최적화(`manualChunks`)와 React 프레임워크 차원의 최적화(`React.lazy`)가 결합되었을 때의 시너지를 이해하는 방향으로 학습을 진행합니다 [2, 6, 15].
+- **My Project Relevance:** Vite 빌드 시 "Some chunks are larger than 500 kB" 경고가 발생했을 때 당황하지 않고, 자주 변경되지 않는 벤더 코드(React 코어, 차트 라이브러리 등)를 분리하고 라우터 레벨에서 지연 로딩을 도입하여 다운로드 속도 및 FCP, LCP를 개선하는 데 직접적으로 적용합니다 [14-16].
+
+### Adjacent Topics
+
+- [[Webpack]]
+  - 확장 방향: Vite가 등장하기 전 업계 표준이었으나 시작 전 전체 번들링 과정으로 인해 무거운 구조를 가진 Webpack의 한계와 Vite와의 아키텍처 비교 [1, 2].
+- [[Core Web Vitals]]
+  - 확장 방향: Vite의 청크 분할 및 지연 로딩 기법이 실제 사용자 경험 지표인 FCP(First Contentful Paint), LCP(Largest Contentful Paint), INP(Interaction to Next Paint)에 어떻게 직결되는지 탐구 [17, 20].
+
+---
+*Last updated: 2026-04-30*
\ No newline at end of file
diff --git a/10_Wiki/Development/대규모 프론트엔드 애플리케이션.md b/10_Wiki/Development/대규모 프론트엔드 애플리케이션.md
new file mode 100644
index 00000000..b3e02b9e
--- /dev/null
+++ b/10_Wiki/Development/대규모 프론트엔드 애플리케이션.md	
@@ -0,0 +1,64 @@
+# [[대규모 프론트엔드 애플리케이션]]
+
+## 📌 Brief Summary
+대규모 프론트엔드 애플리케이션은 단순한 스크립트 실행을 넘어 확장성, 유지보수성, 고성능을 요구하는 고도로 정교한 분산 소프트웨어 시스템입니다. 비즈니스 로직과 UI의 분리, 명확한 상태 소유권, 엄격한 폴더 구조(Feature-Sliced Design 등)를 통해 아키텍처의 붕괴를 방지합니다. 또한, 코드 스플리팅, 자동 메모이제이션, 세분화된 상태 관리 도구를 활용하여 최적의 렌더링 성능과 사용자 경험을 유지하는 것이 핵심입니다.
+
+## 📖 Core Content
+
+*   **아키텍처 및 폴더 구조 (Architecture & Folder Structure)**
+    *   과거의 파일 타입 기반(MVC 등) 폴더 구조는 규모가 커질수록 로직이 파편화되는 한계가 있습니다. 대규모 앱에서는 비즈니스 기능별로 코드를 구성하는 **기능 기반(Feature-based)** 또는 **FSD(Feature-Sliced Design)** 아키텍처가 표준으로 자리 잡았습니다 [1-13].
+    *   FSD는 앱을 공유(shared), 엔티티(entities), 기능(features), 위젯(widgets), 페이지(pages), 앱(app) 등의 계층으로 나누고, **단방향 의존성 규칙**(하위 계층만 참조 가능)과 **Public API 규칙**(index.ts를 통한 캡슐화)을 강제하여 결합도를 낮춥니다 [6, 9, 10, 14, 15].
+*   **상태 관리의 파편화 (Fragmentation of Global State)**
+    *   거대한 단일 스토어(Monolithic Redux) 대신, 데이터 유형에 따라 최적의 도구를 선택합니다. 로컬 상태는 `useState`, 전역 애플리케이션 상태는 `Zustand`나 `Jotai`, 서버(API) 상태는 `TanStack Query`를 사용하여 캐싱 및 동기화를 처리합니다 [16-24].
+    *   특히 Context API는 값이 변할 때마다 모든 구독 컴포넌트를 리렌더링하는 '브로드캐스트' 방식이므로 정적 데이터(테마 등)에 적합하며, 자주 변경되는 동적 상태는 선택자(Selector) 패턴으로 불필요한 리렌더링을 방지하는 Zustand 등이 유리합니다 [16, 17, 25-28].
+*   **성능 최적화 (Performance Optimization)**
+    *   **빌드/런타임 최적화:** Vite와 Rollup을 활용하여 자주 변경되지 않는 벤더 라이브러리(React 등)를 `manualChunks`로 분리하여 캐시 효율을 높이고, `React.lazy`와 `Suspense`를 통해 라우트 또는 컴포넌트 단위의 코드 스플리팅을 구현합니다 [29-37].
+    *   **렌더링 성능:** React 19/2025 생태계에서는 수동 메모이제이션(React.memo, useMemo)의 한계를 극복하기 위해 **React Compiler**를 도입하여 빌드 타임에 자동으로 렌더링 최적화를 수행합니다. 대량의 리스트 데이터는 가상화(Virtualization) 기술을 통해 DOM 비대화를 막습니다 [30-32, 38-44].
+*   **복원력 및 디버깅 (Resilience & Debugging)**
+    *   런타임 에러로 인한 '백지 화면(White screen of death)'을 방지하기 위해 **에러 바운더리(Error Boundaries)**를 대시보드나 서드파티 위젯 등 불안정한 UI 섹션에 전략적으로 배치하여 Fallback UI를 제공합니다 [45-53].
+    *   메모리 누수(Detached DOM nodes 등)는 성능 저하의 주원인이므로 Chrome DevTools의 Heap Snapshot 및 Allocation Timeline을 통해 추적하며, 프로덕션 환경에서는 Sentry, LogRocket, Datadog 등의 가시성(Observability) 도구로 모니터링합니다 [54-63].
+*   **클린 코드 및 거버넌스 (Clean Code & Governance)**
+    *   React의 함수형 컴포넌트에도 SOLID 원칙(단일 책임 원칙, 개방-폐쇄 원칙 등), DRY, KISS, YAGNI 원칙이 적용됩니다. 컴포넌트는 단일 책임을 가져야 하며 과도한 추상화는 지양해야 합니다 [64-69].
+    *   운영체제 간 호환성 및 빌드 오류 방지를 위해 파일 및 폴더명은 `kebab-case`, 컴포넌트는 `PascalCase` 사용을 표준화하며, ESLint, Prettier, Husky를 통해 CI/CD 파이프라인에서 아키텍처 경계와 코드 품질을 자동 강제합니다 [70-73].
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+- [[Feature-Sliced Design (FSD)]]
+  - 연결 이유: 대규모 프론트엔드 프로젝트의 폴더 구조와 모듈 의존성을 통제하는 핵심 아키텍처 방법론입니다.
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 비즈니스 도메인과 UI를 어떻게 계층적으로 분리하고, 순환 참조 및 강한 결합을 어떻게 방지할 수 있는지 이해할 수 있습니다.
+- [[상태 관리 (State Management)]]
+  - 연결 이유: 대규모 앱에서는 전역 상태, 서버 상태, 로컬 상태를 명확히 분리해야 확장 및 성능 유지가 가능합니다.
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: Context API의 성능적 한계(리렌더링 폭풍)와 Zustand의 Selector 패턴, TanStack Query를 통한 서버 상태 캐싱 원리를 이해할 수 있습니다.
+- [[성능 최적화 (Performance Optimization)]]
+  - 연결 이유: 대규모 코드베이스는 필연적으로 번들 크기 증가와 렌더링 병목을 초래하므로 이를 제어하는 기술이 필수적입니다.
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: React Compiler의 자동화된 메모이제이션 원리, Vite의 manualChunks를 통한 번들 분할, React.lazy 기반의 코드 스플리팅 적용 방식을 파악할 수 있습니다.
+- [[에러 바운더리 (Error Boundaries)]]
+  - 연결 이유: 컴포넌트 하나의 오류가 전체 앱의 크래시로 이어지지 않게 막아주는 대규모 시스템의 필수 안전망입니다.
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 컴포넌트 트리 내에서 에러를 격리하는 원리와 런타임 에러를 우아하게 처리(Graceful degradation)하는 방법을 배울 수 있습니다.
+- [[메모리 누수 (Memory Leaks)]]
+  - 연결 이유: 앱 사용 시간이 길어질수록 성능을 심각하게 저하시키는 숨은 원인입니다.
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 클로저(Closure)나 Detached DOM에 의해 가비지 컬렉터가 메모리를 회수하지 못하는 구조적 원인과 DevTools를 활용한 디버깅 기법을 이해할 수 있습니다.
+
+### Deeper Research Questions
+- FSD(Feature-Sliced Design) 도입 시 '인증(Auth)'이나 '라우팅'과 같은 Cross-cutting concern(공통 관심사)은 계층(Layer) 구조의 어느 부분에 배치하고 어떻게 관리하는 것이 가장 적합한가?
+- React Compiler가 자동 메모이제이션을 수행할 때, 서드파티 라이브러리(예: 불안정한 객체 참조를 반환하는 커스텀 훅)와의 호환성 충돌 문제를 해결하기 위한 구체적 방안은 무엇인가?
+- 대규모 리스트 데이터를 렌더링할 때 Virtualization(윈도윙) 기술이 DOM 노드 증가를 막는 원리는 무엇이며, 이 과정에서 `key` 프롭(prop)이 성능에 미치는 정확한 영향은 무엇인가?
+- 프로덕션 환경의 프론트엔드 모니터링(Sentry, Datadog 등)이 제공하는 세션 리플레이(Session Replay) 기능이 개발자의 디버깅에 어떻게 기여하며, 이때 발생할 수 있는 민감 데이터 유출 및 번들 사이즈 증가라는 트레이드오프는 어떻게 극복하는가?
+- Zustand, Jotai와 같은 최신 상태 관리 라이브러리가 기존의 Redux나 Context API와 비교하여 동적/실시간 렌더링 최적화(예: 리렌더링 스킵)를 내부적으로 어떻게 구현하고 있는가?
+
+### Practical Application Contexts
+- **Implementation:** 파일과 폴더 네이밍 규칙(파일: kebab-case, 컴포넌트: PascalCase)을 통일하고, 300줄이 넘어가는 컴포넌트는 단일 책임 원칙(SRP)에 따라 더 작은 훅(Hook)과 서브 컴포넌트로 리팩토링합니다.
+- **System Design:** 프로젝트 설계 시 폴더 구조를 기술 스택(components, hooks) 기반이 아닌 비즈니스 도메인(features/auth, features/dashboard 등) 기반으로 구성하여 각 모듈의 캡슐화를 보장합니다.
+- **Operation / Maintenance:** 개별 서드파티 위젯이나 불안정한 UI 파트에 Error Boundary를 씌워 메인 서비스의 동작을 보장하며, Memory Profiler를 사용해 Detached DOM node 등 메모리 누수 요인을 정기적으로 감사(Audit)합니다.
+- **Learning Path:** 리액트 핵심 원리(렌더링 트리거 이해) → 폴더 구조/아키텍처(FSD) 설계 → 상태 관리 도구 비교 및 도입 → 웹 성능 지표(Core Web Vitals) 및 번들러(Vite) 최적화 도구 체득의 순서로 학습을 고도화합니다.
+- **My Project Relevance:** 팀 단위의 협업 시 ESLint, Prettier, Husky를 도입해 아키텍처 규칙(다른 Feature에 직접 접근 금지 등)을 자동 강제하고, 코드 리뷰 시 일관된 아키텍처 원칙을 기준으로 삼을 수 있습니다.
+
+### Adjacent Topics
+- [[마이크로 프론트엔드 (Micro-Frontends)]]
+  - 확장 방향: 단일 저장소(Monorepo) 및 모듈화의 한계를 넘어, 초대형 엔터프라이즈 환경에서 여러 팀이 프론트엔드를 독립적으로 배포하고 운영하기 위한 런타임 통합 아키텍처로 지식을 확장합니다.
+- [[시각적 회귀 테스트 (Visual Regression Testing)]]
+  - 확장 방향: Storybook을 활용한 컴포넌트 고립 개발을 넘어서, Happo, Chromatic 등의 도구를 통해 코드 변경이 UI나 접근성(Accessibility)에 의도치 않은 파괴적 영향을 미쳤는지 자동 검증하는 QA 고도화 영역으로 확장합니다.
+
+---
+*Last updated: 2026-04-30*
\ No newline at end of file
diff --git a/10_Wiki/Development/비동기 데이터 관리.md b/10_Wiki/Development/비동기 데이터 관리.md
new file mode 100644
index 00000000..a26dcf51
--- /dev/null
+++ b/10_Wiki/Development/비동기 데이터 관리.md	
@@ -0,0 +1,63 @@
+# [[비동기 데이터 관리]]
+
+## 📌 Brief Summary
+비동기 데이터 관리(서버 상태 관리)는 API에서 가져온 데이터를 클라이언트 측 애플리케이션 상태와 명확히 분리하여 처리하는 것을 의미합니다 [1]. 이는 네트워크 요청에 따른 데이터 캐싱, 동기화, 로딩 및 에러 사이클 관리를 포함하며, 현대 프론트엔드 시스템 아키텍처의 핵심 요소입니다 [1, 2]. 대규모 앱에서는 RTK Query나 TanStack Query(React Query)와 같은 특화된 도구를 사용하여 비동기 보일러플레이트를 줄이고 효율적인 캐시 관리를 수행합니다 [1, 3, 4].
+
+## 📖 Core Content
+
+*   **서버 상태와 클라이언트 상태의 분리:** 
+    최근 프론트엔드 아키텍처에서 가장 중요한 변화 중 하나는 "서버 상태(Server State)"를 "애플리케이션 상태"와 분리하는 것입니다. API에서 가져오는 데이터는 클라이언트 데이터와 근본적으로 다르며, 캐싱, 동기화, 로딩 및 에러 처리가 반드시 필요합니다 [1]. Zustand와 같이 유연한 상태 관리 라이브러리로 비동기(Async) 작업을 직접 다루게 되면, 팀원마다 콜백, 프로미스, 미들웨어 등 서로 다른 패턴을 사용하여 일관성이 떨어지고 유지보수가 어려워지는 한계가 발생할 수 있습니다 [3, 5].
+
+*   **비동기 데이터 관리 최적화 도구:** 
+    이러한 문제를 해결하기 위해 TanStack Query(React Query)와 RTK Query 같은 라이브러리가 사실상의 표준으로 자리 잡았습니다 [1]. 
+    *   **TanStack Query:** 강력한 캐싱 레이어를 제공하여 불필요한 네트워크 중복 요청을 줄이고 데이터의 최신 상태를 유지합니다. 무한 스크롤(infinite scrolling)이나 낙관적 업데이트(optimistic updates)와 같은 복잡한 비동기 기능을 단순하게 구현할 수 있습니다 [2].
+    *   **RTK Query:** Redux 생태계에서 비동기 작업이 많은 앱을 위해 캐싱, 중복 제거, 자동 데이터 재요청(refetching), 캐시 무효화 기능을 기본으로 제공하여 비동기 보일러플레이트 코드를 사실상 제거합니다 [3, 4].
+
+*   **구조적 분리와 아키텍처:**
+    API 계층은 일반적으로 독립적인 경계로 구성되며, 요청 선언부와 커스텀 훅(Custom Hooks)은 특정 기능(feature) 폴더 내에 함께 배치(colocate)됩니다. 이를 통해 네트워크 관련 비동기 로직을 UI 컴포넌트와 완벽히 디커플링(decoupling)하여 유지보수성을 향상시킵니다 [2].
+
+*   **성능 최적화 및 안정성:**
+    *   **디바운싱과 쓰로틀링:** 사용자 입력(예: 검색)에 의해 트리거되는 값비싼 비동기 API 호출은 디바운싱(debouncing)이나 쓰로틀링(throttling)을 통해 횟수를 제한해야 합니다. 이는 과도한 API 호출을 방지하여 클라이언트 성능을 향상시키고 서버 부하를 줄여줍니다 [6, 7].
+    *   **메모리 누수 방지:** 이벤트 리스너나 구독(subscriptions) 등 정리가 필요한 비동기 사이드 이펙트의 경우, 컴포넌트가 언마운트될 때 리소스를 해제하지 않으면 메모리 누수(memory leaks)가 발생할 수 있습니다. 이를 막기 위해 반드시 `useEffect`에서 클린업(cleanup) 함수를 반환해야 합니다 [8, 9].
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+- [[TanStack Query 및 RTK Query]]
+  - 연결 이유: 서버 상태(API 데이터) 관리에 있어 캐싱, 중복 요청 제거, 자동 재요청 등을 처리하기 위한 현대적인 필수 표준 도구로 소스에서 강조되고 있기 때문입니다 [1, 2, 4].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 비동기 데이터 관리에서 발생하는 보일러플레이트 감소 원리와 데이터 동기화 메커니즘.
+
+- [[서버 상태 (Server State)]]
+  - 연결 이유: API로부터 패치(fetch)되는 데이터는 클라이언트 상태와 성격이 완전히 달라 별도의 관리가 필요하다는 비동기 관리의 핵심 전제이기 때문입니다 [1].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 캐싱 로딩, 에러 사이클, 서버 데이터 최신화 기법.
+
+- [[디바운싱(Debouncing) 및 쓰로틀링(Throttling)]]
+  - 연결 이유: 잦은 사용자 이벤트로 인해 발생하는 무분별한 비동기 API 호출을 제어하여 성능을 최적화하는 구체적인 전략이기 때문입니다 [6, 7].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 프론트엔드에서의 네트워크 최적화 및 런타임 병목 현상 방지.
+
+- [[클린업 (Cleanup) 함수와 메모리 누수]]
+  - 연결 이유: 비동기 작업 완료 전 컴포넌트가 언마운트되었을 때 발생할 수 있는 자원 낭비와 메모리 누수를 막는 필수 규칙이기 때문입니다 [8, 9].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: React 생명주기(Lifecycle)와 결합된 안전한 비동기 처리 방법.
+
+### Deeper Research Questions
+- Zustand와 같은 가벼운 전역 상태 관리 라이브러리로 대규모 비동기 처리를 구현할 때 발생하는 아키텍처적 한계와 파편화 문제는 구체적으로 어떻게 나타나는가? [3, 5]
+- RTK Query가 제공하는 캐시 무효화(cache invalidation) 및 자동 데이터 재요청 기능의 내부 작동 방식은 무엇인가? [4]
+- TanStack Query를 활용하여 무한 스크롤 및 낙관적 업데이트를 구현할 때, 캐시 레이어는 어떻게 무결성을 보장하는가? [2]
+- Feature-Sliced Design 같은 모듈화된 폴더 구조에서 API 선언과 비동기 커스텀 훅은 어떤 방식으로 캡슐화되고 호출되는가? [2]
+- `useEffect` 내의 비동기 호출 시 메모리 누수를 잡기 위한 DevTools Heap Snapshot 분석 방법은 어떻게 적용되는가? [9]
+
+### Practical Application Contexts
+- **Implementation:** UI 컴포넌트 내부에서 비동기 로직을 직접 구현하지 않고, API 요청을 처리하는 네트워크 로직을 커스텀 훅으로 추출하여 `features/` 폴더 하위에 격리하여 구현합니다 [2, 10]. 또한 `useEffect`를 통한 구독 시 클린업 함수를 반드시 적용합니다 [8].
+- **System Design:** 프로젝트 설계 시 클라이언트 전역 상태(예: UI 테마, 언어)와 서버에서 불러오는 비동기 상태(예: 사용자 데이터, 알림)를 완전히 분리하여 각기 다른 도구(Zustand + TanStack Query)를 사용하도록 설계합니다 [1, 11].
+- **Operation / Maintenance:** Redux DevTools와 같은 도구를 활용하여 비동기 액션이 언제 호출되었고 서버 데이터가 어떻게 업데이트되었는지 타임트래블 디버깅(Time-travel debugging)을 진행하여 문제를 신속히 파악합니다 [12, 13].
+- **Learning Path:** 컴포넌트 단위의 `useState`/`useEffect`를 통한 데이터 패칭의 한계 학습 → 디바운싱/메모리 누수 방지 원리 이해 → 서버 상태와 클라이언트 상태의 차이 인지 → TanStack Query/RTK Query를 통한 전문적인 비동기 상태 관리 마스터로 이어집니다 [1, 3, 7, 8].
+- **My Project Relevance:** 실시간 알림, 방대한 데이터의 무한 스크롤, 사용자 검색 시의 자동완성(디바운스 적용) 기능 등 복잡한 API 기반 기능이 있는 프로젝트의 성능 및 아키텍처 개선에 직접 적용됩니다 [2, 6, 7].
+
+### Adjacent Topics
+- [[상태 관리 아키텍처 (State Management Architecture)]]
+  - 확장 방향: 비동기 데이터 관리(서버 상태)와 로컬 상태, 전역 애플리케이션 상태가 애플리케이션 내에서 어떻게 상호작용하고 조화롭게 구성되는지 확장해서 알아봅니다 [1, 14].
+- [[성능 프로파일링 및 렌더링 최적화 (Performance Profiling & Rendering Optimization)]]
+  - 확장 방향: 잘못된 비동기 데이터 처리가 어떻게 불필요한 리렌더링 폭풍(re-render storm)이나 병목을 일으키는지 파악하고, React Profiler를 통해 이를 어떻게 탐지하는지 알아봅니다 [15-17].
+
+---
+*Last updated: 2026-04-30*
\ No newline at end of file
diff --git a/10_Wiki/Development/프론트엔드 애플리케이션 렌더링 병목 개선.md b/10_Wiki/Development/프론트엔드 애플리케이션 렌더링 병목 개선.md
new file mode 100644
index 00000000..600727cc
--- /dev/null
+++ b/10_Wiki/Development/프론트엔드 애플리케이션 렌더링 병목 개선.md	
@@ -0,0 +1,70 @@
+# [[프론트엔드 애플리케이션 렌더링 병목 개선]]
+
+## 📌 Brief Summary
+프론트엔드 애플리케이션 렌더링 병목은 불필요하거나 과도한 컴포넌트 리렌더링으로 인해 UI 반응성이 떨어지고 상호작용 속도가 지연되는 현상을 의미합니다 [1, 2]. 이를 개선하기 위해서는 렌더링 트리거(상태, Props, Context 등)를 식별하고 메모이제이션, 리스트 가상화, 상태 분리, 동시성 렌더링(Concurrent Rendering) 기능 등을 활용해야 합니다 [3, 4]. 지속적인 프로파일링을 통해 렌더링 비용이 높은 부분을 측정하고 전략적으로 최적화를 적용하는 것이 핵심입니다 [5, 6].
+
+## 📖 Core Content
+* **렌더링 발생 원인 파악 및 프로파일링**
+  React 컴포넌트는 상태(State), Props, Context의 값이 변경되거나 부모 컴포넌트가 렌더링될 때 리렌더링됩니다 [4]. 이러한 불필요한 렌더링은 애플리케이션 트리가 깊을 경우 스크립팅 시간을 30~60% 증가시켜 성능을 저하시킬 수 있습니다 [2]. 따라서 React DevTools Profiler나 `why-did-you-render` 같은 도구를 사용해 렌더링 빈도와 비용을 측정한 뒤 최적화를 진행해야 합니다 [5, 7, 8].
+* **메모이제이션(Memoization)과 참조 안정성**
+  `React.memo()`, `useCallback`, `useMemo`를 적절히 활용하면 변경되지 않은 컴포넌트의 리렌더링을 막을 수 있습니다 [9, 10]. 단, JSX 내부에 익명 함수나 인라인 객체를 직접 정의하여 Props로 넘기면 얕은 비교(Shallow comparison) 특성상 매 렌더링마다 새로운 참조가 생성되어 메모이제이션이 무력화되므로 참조를 안정화해야 합니다 [10-12]. 
+* **React Compiler를 통한 자동화**
+  2025년 기준 React Compiler는 빌드 타임에 컴포넌트를 정적으로 분석하여 JSX 요소 단위까지 세밀하게 자동 메모이제이션을 적용합니다 [13, 14]. 이를 통해 수동 메모이제이션의 번거로움을 줄이고 렌더링 오버헤드를 방지할 수 있습니다 [15].
+* **Context API 최적화와 글로벌 상태 분리**
+  Context API는 값이 변할 때 해당 컨텍스트를 구독하는 모든 컴포넌트를 렌더링하는 "브로드캐스트 시스템"으로 작동하여 큰 병목을 유발합니다 [16, 17]. 이를 방지하기 위해 컨텍스트를 작은 도메인 단위로 쪼개거나, Zustand 등 특정 상태 슬라이스(Slice)만 선택적으로 구독(Selector)할 수 있는 가벼운 상태 관리 라이브러리를 사용하여 리렌더링을 제어해야 합니다 [16, 18-20].
+* **동시성 기능(Concurrent Features)의 활용**
+  `useTransition`을 사용해 중요하지 않은 업데이트를 지연시킴으로써 타이핑과 같은 즉각적인 상호작용이 차단되지 않게 하고, `useDeferredValue`로 무거운 파생 데이터의 렌더링을 미루어 UI의 반응성을 부드럽게 개선할 수 있습니다 [21-23].
+* **대규모 데이터 가상화(Virtualization) 및 리스트 최적화**
+  50~100개 이상의 항목이 있는 긴 목록은 다수의 DOM 노드 렌더링을 유발하여 병목을 만듭니다 [24, 25]. `react-window` 등의 라이브러리를 활용해 뷰포트에 보이는 항목만 렌더링하는 윈도윙(Windowing) 기법을 적용하고, 안정적이고 고유한 `key`를 부여하여 불필요한 DOM 재생성을 막아야 합니다 [25-27].
+
+## ⚖️ Trade-offs & Caveats
+* **메모이제이션 오버헤드:** `React.memo()`, `useCallback`, `useMemo`는 남용될 경우 성능을 오히려 악화시킬 수 있습니다 [28, 29]. 이전 Props와 새 Props를 비교하고 메모리를 할당하는 과정에 오버헤드가 발생하기 때문에, 렌더링 비용이 저렴한 컴포넌트에서는 렌더링 자체보다 비교 연산의 비용이 더 클 수 있습니다 [29].
+* **React Compiler의 제약 사항:** React Compiler는 자동 최적화를 제공하지만, 'Rules of React'를 엄격히 준수해야 정상 작동합니다 [30, 31]. 또한 매 렌더링마다 새로운 참조를 반환하는 일부 서드파티 라이브러리 훅(예: TanStack Query의 `useMutation` 등)과 함께 사용하면 메모이제이션 체인이 끊어지는 호환성 문제가 발생할 수 있습니다 [32, 33].
+* **Context API vs 외부 라이브러리 도입:** Context API는 서드파티 라이브러리 추가 없이 테마, 다국어 등 정적 데이터 관리에 용이하지만 [34], 잦은 상태 변경에는 성능 취약점이 있습니다 [35]. 그러나 이를 해결하기 위해 외부 상태 라이브러리(Zustand 등)를 무조건 도입하면 추가적인 번들 용량 증가 및 팀의 학습 곡선이 수반된다는 반대 급부가 있습니다 [36, 37].
+* **익명 함수 제거에 따른 코드 복잡도 증가:** 불필요한 리렌더링을 막고자 모든 인라인 함수를 외부로 빼거나 `useCallback`으로 감싸면 코드가 길어지고 가독성이 떨어질 수 있습니다 [38]. 컴포넌트가 작고 성능 영향이 없는 경우에는 익명 함수 사용이 실용적일 수 있습니다 [38].
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+
+#### [아키텍처/기반 기술]
+- [[Context API]]
+  - 연결 이유: 컴포넌트 트리 깊은 곳까지 상태를 전달할 수 있으나 구독 중인 모든 컴포넌트를 리렌더링시키는 특성상 렌더링 병목의 주요 원인이 됩니다 [17].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 브로드캐스트 기반 상태 관리의 한계와 리렌더링 발생 범위를 이해할 수 있습니다.
+- [[Concurrent Rendering]]
+  - 연결 이유: 렌더링 작업의 우선순위를 부여하고 중단/재개할 수 있는 기술로, `useTransition` 등을 통해 무거운 렌더링이 메인 스레드를 막는 병목 현상을 방지합니다 [21].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 반응성 지표(INP 등)를 개선하기 위한 렌더링 스케줄링 메커니즘을 이해할 수 있습니다.
+- [[React Compiler]]
+  - 연결 이유: 수동 메모이제이션의 한계를 극복하고 빌드 타임에 자동으로 JSX 요소 단위의 메모이제이션을 적용하여 렌더링 최적화를 달성합니다 [13, 14].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 최신 React의 렌더링 최적화가 런타임 제어에서 컴파일러 기반 정적 분석으로 넘어가는 기술적 진화를 이해할 수 있습니다.
+
+#### [구현/활용 도구]
+- [[Zustand]]
+  - 연결 이유: 셀렉터(Selector) 기능을 활용해 컴포넌트가 자신이 필요한 상태 조각(Slice)이 변경될 때만 리렌더링되도록 보장하여 병목을 줄이는 상태 관리 도구입니다 [18].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 전역 상태의 파편화 관리와 불필요한 리렌더링을 차단하는 구독 최적화 패턴을 학습할 수 있습니다.
+- [[List Virtualization (Windowing)]]
+  - 연결 이유: 대규모 리스트에서 사용자의 화면 뷰포트에 존재하는 DOM 노드만 제한적으로 렌더링하여 DOM 트리 비대화를 막습니다 [25, 26].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 다수의 데이터를 렌더링할 때 발생하는 메모리 및 레이아웃 페인팅 병목을 제어하는 원리를 이해할 수 있습니다.
+
+### Deeper Research Questions
+- React Compiler는 빌드 타임에 명시적인 의존성 배열 없이 어떻게 내부 JSX 노드별 캐싱 및 메모이제이션 단위를 결정하는가?
+- Context API의 브로드캐스트 리렌더링 문제를 해결하는 `use-context-selector`의 원리는 무엇이며, Zustand의 구독 최적화 방식과 구조적으로 어떻게 다른가?
+- `useTransition`과 `useDeferredValue`를 결합하여 사용할 때, 브라우저의 페인트 주기(Paint Cycle) 관점에서 컴포넌트 렌더링은 어떻게 스케줄링 및 지연되는가?
+- 대형 데이터를 처리할 때 List Virtualization과 함께 사용하는 스크롤 이벤트 디바운싱(Debouncing) 혹은 쓰로틀링(Throttling) 최적화의 기술적 한계점은 무엇인가?
+- 상태 관리 아키텍처 관점에서, Feature-Sliced Design(FSD)과 같이 횡단 관심사를 분리하는 폴더 및 구조적 설계가 애플리케이션의 리렌더링 범위를 제한하는 데 어떻게 기여하는가?
+
+### Practical Application Contexts
+- **Implementation:** Props로 전달하는 함수나 객체는 익명 생성(인라인)을 지양하고 `useCallback`이나 외부 선언으로 분리하여 참조 무결성을 유지합니다. 수백 개 이상의 항목을 렌더링할 경우 `react-window`와 같은 가상화 라이브러리를 의무적으로 도입합니다.
+- **System Design:** 빈번히 업데이트되는 상태(예: 알림 개수, 장바구니)는 Context API 대신 Zustand 등의 선택적 구독이 가능한 스토어에 배치하고, 정적 데이터(테마 등)는 Context를 활용하여 렌더링 전파 범위를 시스템 레벨에서 격리합니다.
+- **Operation / Maintenance:** `why-did-you-render` 패키지와 React DevTools의 Profiler 패널을 이용해 개발 과정에서 불필요하게 반복 렌더링되는 컴포넌트를 찾아내고, 프로덕션 환경에서는 Core Web Vitals(INP, FCP 등)를 추적하여 상호작용 지연이 있는지 모니터링합니다.
+- **Learning Path:** React의 렌더링 조건(State, Props, Parent) 이해 -> 수동 메모이제이션 도구 숙달 -> Context API의 성능 한계 체감 및 Zustand 활용 -> Concurrent Features 적용 -> React Compiler를 이용한 자동화 흐름으로 렌더링 최적화 지식을 확장합니다.
+- **My Project Relevance:** 현재 유지 보수하거나 신규 구축하는 React 웹 앱에서 스크롤 끊김이나 클릭 시 반응 지연이 발생할 때, 해당 개념을 기반으로 병목이 되는 컴포넌트의 렌더링 횟수를 측정하고 적절한 최적화 도구를 즉각 적용할 수 있습니다.
+
+### Adjacent Topics
+- [[Server Components (Next.js)]]
+  - 확장 방향: 브라우저에서의 렌더링 부하를 줄이기 위해 클라이언트 자바스크립트 번들을 최소화하고 서버에서 정적 UI를 렌더링하여 넘겨주는 아키텍처적 최적화에 대해 심도 있게 조사할 수 있습니다 [39-41].
+- [[JavaScript Memory Leaks]]
+  - 확장 방향: 과도한 렌더링 외에도 클로저나 분리된 DOM 노드에 의해 자바스크립트 메모리가 해제되지 않고 누적되어 성능 저하를 일으키는 메모리 누수 식별 및 해결 방법으로 이해를 확장합니다 [42-44].
+
+---
+*Last updated: 2026-04-30*
\ No newline at end of file
diff --git a/10_Wiki/Management/Agile Environments.md b/10_Wiki/Management/Agile Environments.md
new file mode 100644
index 00000000..dbf3a829
--- /dev/null
+++ b/10_Wiki/Management/Agile Environments.md	
@@ -0,0 +1,47 @@
+# [[Agile Environments]]
+
+## 📌 Brief Summary
+Agile Environments(애자일 환경)는 요구사항이 지속적으로 변화하는 프로젝트나 스타트업 환경을 의미합니다 [1]. 이러한 환경에서는 미래에 필요할지도 모르는 복잡한 기능을 미리 개발하기보다는 오직 현재의 요구사항에 집중하는 것이 핵심입니다 [2]. 따라서 각 기능을 독립적으로 생성하고 구현할 수 있는 유연하고 모듈화된 접근 방식이 매우 적합합니다 [3].
+
+## 📖 Core 소스에 관련 정보가 부족합니다.Content
+애자일 환경(Agile Environments)과 관련하여 제공된 소스에서 다루고 있는 구체적인 설명은 다음과 같습니다. 
+
+* **YAGNI 원칙의 중요성**: 애자일 환경에서는 "You Aren't Gonna Need It (YAGNI)" 원칙이 특히 필수적으로 작용합니다 [2]. 변화하는 요구사항을 가진 스타트업이나 애자일 프로젝트에서는, 미래의 사용 사례를 대비하여 복잡한 기능을 미리 구축하는 것을 피해야 합니다 [1, 2]. 개발팀은 오직 현재의 요구사항에만 집중함으로써 나중에 유지보수해야 할 복잡성과 사용되지 않는 코드(dead code)의 양을 최소화할 수 있습니다 [2].
+* **기능 기반 구조(Feature-Based Structure)의 적합성**: 프론트엔드 아키텍처 측면에서 기능 기반 폴더 구조는 애자일 개발 방법론과 매우 잘 맞습니다 [3]. 이 구조에서는 각각의 기능(feature)이 독립적으로 분리되어 생성 및 구현될 수 있기 때문에, 애자일 환경에서 요구하는 유연성과 병렬적인 개발을 효과적으로 지원합니다 [3].
+* *참고: 주어진 소스에는 개발 원칙(YAGNI) 및 폴더 구조(Feature-Based)와 애자일의 연관성만 언급되어 있으며, 스크럼이나 스프린트 등 애자일 환경 자체의 전반적인 프로세스나 이론에 대해서는 소스에 관련 정보가 부족합니다.*
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+- [[YAGNI]]
+  - 연결 이유: 애자일 환경에서 미래의 불확실한 기능을 미리 만들지 않고 현재의 요구사항에 집중하도록 이끄는 가장 핵심적인 개발 원칙입니다 [1, 2].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 애자일 환경에서 불필요한 코드(Dead Code)의 생성을 방지하고 유지보수 비용을 최소화하는 구체적인 판단 기준을 이해할 수 있습니다 [2].
+- [[Feature-Based Structure]]
+  - 연결 이유: 애자일 방법론과 가장 잘 어울리는 아키텍처 패턴으로, 코드 베이스를 기능 단위로 분리하여 독립적인 개발을 가능하게 합니다 [3].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 애자일 팀이 요구사항 변경에 맞춰 여러 기능을 독립적으로 확장하고 개발할 때 파일과 폴더를 어떻게 구성해야 하는지 이해할 수 있습니다 [3].
+- [[Startup Projects]]
+  - 연결 이유: 애자일 환경과 마찬가지로 요구사항이 지속적으로 변화하는 특성을 공유하며, YAGNI 원칙이 강하게 적용되는 대표적인 비즈니스 환경입니다 [1].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 애자일 원칙이 실무에서 어떠한 형태의 프로젝트 규모나 상황(빠른 변화와 유연성 요구)에서 주로 채택되는지 파악할 수 있습니다 [1].
+
+### Deeper Research Questions
+- 애자일 환경에서 YAGNI 원칙을 엄격하게 적용하여 당장의 기능만 개발할 때, 향후 시스템이 확장되면서 발생할 수 있는 기술 부채(Technical Debt)는 어떻게 관리해야 하는가?
+- 요구사항이 끊임없이 변화하는 애자일 프로젝트에서 Feature-Based Structure가 기존의 파일 유형 기반 구조(File-Type Based Structure)보다 팀 협업 및 유지보수에 유리한 구체적 이유는 무엇인가?
+- 스타트업 프로젝트의 초기 단계에서 애자일 원칙(YAGNI, KISS 등)을 적용할 때와, 엔터프라이즈 환경으로 확장(Scaling)될 때 아키텍처 원칙(SOLID 등)의 적용 비중은 어떻게 변화해야 하는가?
+- 기능(Feature)을 독립적으로 분리하여 개발하는 애자일 환경에서, 여러 기능 간에 공유되는 교차 의존성(Cross-cutting concerns)은 구조적으로 어떻게 해결해야 하는가?
+- 애자일 환경의 '현재 요구사항에 대한 집중'과 '장기적인 소프트웨어 아키텍처의 견고함' 사이의 균형을 맞추기 위한 개발 거버넌스는 어떻게 구축해야 하는가?
+
+### Practical Application Contexts
+- **Implementation:** 주어진 스토리나 태스크의 요구사항을 충족하는 데 필요한 최소한의 코드만 우선적으로 구현합니다 (오버엔지니어링 금지) [2].
+- **System Design:** 프로젝트 폴더와 모듈을 기능(Feature)을 중심으로 설계하여, 요구사항이 변경되더라도 다른 기능에 미치는 영향을 최소화하고 독립적인 배포 및 테스트가 가능하게 합니다 [3].
+- **Operation / Maintenance:** 언젠가 쓰일 것이라 예상하고 작성한 불필요한 코드를 배제함으로써, 운영 단계에서 팀이 관리하고 파악해야 할 레거시 코드의 복잡성을 대폭 낮춥니다 [2].
+- **Learning Path:** 애자일 환경에 합류하기 위해 YAGNI 원칙의 적용법과 Feature-Sliced Design과 같은 최신 기능 단위의 모듈형 아키텍처 패턴을 학습합니다 [2, 3].
+- **My Project Relevance:** 잦은 기획 변경이 예상되는 초기 단계의 스타트업 프로젝트나 애자일 조직을 세팅할 때, 초기 개발 속도를 높이면서도 변경에 유연하게 대응하기 위한 가이드라인으로 직결됩니다 [1, 3].
+
+### Adjacent Topics
+- [[SOLID Principles]]
+  - 확장 방향: 애자일 환경에서 당장의 기능을 단순하게 개발(YAGNI)하면서도, 장기적으로 애플리케이션의 규모가 커졌을 때 코드를 어떻게 유지보수 가능하게 설계할지 객체 지향적/구조적 관점에서 이해를 확장할 수 있습니다 [1, 4].
+- [[Clean Code]]
+  - 확장 방향: 빠른 변화와 반복 개발(Iteration)이 일어나는 애자일 환경 속에서, 여러 명의 개발자가 코드를 쉽게 읽고 협업할 수 있도록 하는 기본적인 코드 품질 유지 기법으로 확장이 가능합니다 [4, 5].
+
+---
+*Last updated: 2026-04-30*
\ No newline at end of file
diff --git a/10_Wiki/Management/Branching Strategies.md b/10_Wiki/Management/Branching Strategies.md
new file mode 100644
index 00000000..0c39642f
--- /dev/null
+++ b/10_Wiki/Management/Branching Strategies.md	
@@ -0,0 +1,71 @@
+# [[Branching Strategies]]
+
+## 📌 Brief 소Summary
+Branching Strategies(브랜칭 전략)는 소프트웨어 개발 과정에서 코드 변경 사항을 관리하고 팀원 간의 협업을 조율하기 위해 버전 관리 시스템(Git 등)에서 브랜치를 생성, 병합, 유지보수하는 규칙과 워크플로우를 의미합니다. 팀의 규모와 프로젝트 요구사항에 따라 Git Flow, GitHub Flow, Trunk-Based Development, Feature Branch Workflow 등 다양한 전략이 사용됩니다. 명확한 브랜칭 전략의 도입은 메인 코드베이스의 안정성을 보장하고 병합 충돌을 방지하며 코드 리뷰와 추적성을 강화하는 핵심 역할을 합니다 [1-3].
+
+## 📖 Core Content
+*   **주요 브랜칭 전략 유형**
+    *   **Feature Branch Workflow (기능 브랜치 워크플로우):** 2~5명 규모의 소규모 팀에 가장 초보자 친화적이고 충돌이 적은 워크플로우입니다 [4]. `main` 브랜치는 항상 안정적이고 배포 가능한 상태를 유지하며, 새로운 기능이나 버그 수정 시 `main`에서 파생된 짧은 수명의 브랜치를 생성합니다 [5]. 개발 완료 후 Pull Request(PR)를 열고 최소 1명 이상의 동료 리뷰와 테스트를 거친 후 Squash Merge 방식으로 병합합니다 [6, 7].
+    *   **Trunk-Based Development (트렁크 기반 개발):** 강력한 CI(지속적 통합) 환경을 갖춘 숙련된 팀에 적합한 가벼운 방식입니다 [8, 9]. 수명이 매우 짧은 기능 브랜치를 사용하거나 메인 브랜치에 작은 변경 사항을 자주 커밋합니다. 오버헤드가 최소화되고 피드백이 빠르며 대규모 병합 충돌을 피할 수 있습니다 [8, 10].
+    *   **Git Flow:** 정기적인 릴리스 일정을 가진 대규모 프로젝트에 유용합니다 [9]. 하지만 기능 브랜치 외에도 `develop`, `release` 등 관리해야 할 브랜치가 많아 소규모 팀에게는 무겁고 과도한 복잡성을 유발할 수 있습니다 [9, 11, 12].
+    *   **GitHub Flow:** `main` 브랜치로 기능 브랜치를 직접 병합하는 단순화된 구조로, Git Flow보다 빠르고 지속적인 배포 환경에 적합합니다 [11, 13].
+
+*   **모든 전략에 적용되는 모범 사례 (Best Practices)**
+    *   **티켓 ID 및 명명 규칙 사용:** 브랜치 이름과 커밋 메시지에 요구사항 추적을 위한 티켓 ID(예: `feature/PROJ-123-user-auth`)를 포함해야 합니다 [14, 15]. 브랜치 이름은 케밥 케이스(kebab-case)를 사용하고 짧고 명확하게 작성합니다 [16, 17].
+    *   **원자적 커밋 (Atomic Commits):** 하나의 커밋에는 하나의 논리적 변경 사항만 포함하여 코드 리뷰와 히스토리 추적을 단순화합니다 [7, 18].
+    *   **Conventional Commits 규칙:** 커밋 메시지는 `feat:`, `fix:`, `chore:` 등의 표준화된 접두사를 사용하여 변경의 목적을 명확히 합니다 [19-21].
+    *   **PR 및 병합 규칙:** 코드를 절대 `main`에 직접 푸시해서는 안 되며, 반드시 PR을 통한 리뷰를 거쳐야 합니다 [6, 22]. 병합 후에는 사용이 끝난 브랜치를 즉시 삭제하여 저장소를 정리합니다 [6, 23].
+
+*   **전략 간 마이그레이션 방법**
+    *   프로젝트가 변화함에 따라 전략도 진화할 수 있습니다. 예를 들어 통합 속도를 높이려면 Feature Branch에서 Trunk-Based(기능 플래그 사용 및 수명 단축)로 전환하고, 더 많은 체계가 필요하다면 GitHub Flow에서 Git Flow(`develop` 브랜치 및 릴리스 브랜치 추가)로 마이그레이션할 수 있습니다 [11, 12].
+
+## ⚖️ Trade-offs & Caveats
+*   **구조적 오버헤드 vs. 안정성:** Git Flow는 구조가 명확하고 정기적인 릴리스에 강점이 있지만, 브랜치의 수가 많아 유지보수 비용(오버헤드)이 높습니다 [9]. 반면 Feature Branch나 Trunk-Based 방식은 프로세스가 가벼운 대신 메인 브랜치의 보호(`main` 브랜치 직접 푸시 금지, 엄격한 코드 리뷰 등) 규칙이 강제되지 않으면 코드가 쉽게 깨질 위험이 있습니다 [6, 22].
+*   **기능 브랜치의 수명(Long-lived branches) 문제:** 기능 브랜치나 GitHub Flow를 사용할 때, 브랜치의 수명이 몇 주 이상 길어지면 다른 작업자와의 코드 분기가 심해져 거대한 병합 충돌(Merge conflicts)이 발생할 수 있습니다 [17]. 따라서 매일 `main`의 최신 변경 사항을 Pull 하거나 Rebase하여 충돌을 예방해야 합니다 [7].
+*   **Trunk-Based 개발의 의존성:** 빠른 병합을 지향하는 Trunk-Based Development는 지속적이고 자동화된 테스트 환경(CI)과 미완성 기능을 프로덕션에서 숨기기 위한 기능 플래그(Feature Flags) 구현 등 기술적 뒷받침이 필수적입니다 [9, 11].
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+
+#### [관계 유형 A: 아키텍처/기반 방법론]
+- [[Feature Branch Workflow]]
+  - 연결 이유: 소규모 3~5인 개발 팀에 가장 추천되는 단순하고 직관적인 브랜칭 전략의 기반 개념입니다.
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 메인 브랜치를 오염시키지 않고 새로운 기능을 격리된 환경에서 개발하고 병합하는 방법론을 이해할 수 있습니다.
+- [[Trunk-Based Development]]
+  - 연결 이유: 무거운 워크플로우를 탈피하여 브랜치 생명주기를 극한으로 줄이고 빠른 통합을 중시하는 최신 트렌드 모델입니다.
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: CI/CD 환경에서의 잦은 소규모 배포 방식과 충돌 최소화 전략을 학습할 수 있습니다.
+- [[Git Flow]]
+  - 연결 이유: 브랜칭 전략의 고전적이고 체계적인 형태로서, 대형 프로젝트의 정기적 버저닝 관리를 위해 설계되었습니다.
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: `develop`, `release`, `hotfix` 등 개발 파이프라인에 따른 브랜치의 역할 분리 기법을 이해할 수 있습니다.
+
+#### [관계 유형 B: 구현/활용 도구 및 규칙]
+- [[Pull Request & Code Review]]
+  - 연결 이유: 브랜칭 전략이 안전하게 동작하기 위해 모든 병합 전에 필수적으로 거쳐야 하는 품질 검증 관문입니다.
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 팀원 간의 비동기적 피드백 수렴, 시각적 검증, 그리고 CI 통과를 전제로 한 안전한 병합 과정을 배울 수 있습니다.
+- [[Conventional Commits]]
+  - 연결 이유: 브랜치 병합 내역을 추적하고 가독성을 높이기 위해 전 세계적으로 통용되는 커밋 메시지 작성 표준입니다.
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: `feat(scope): message` 와 같은 형식의 구문을 통해 코드 히스토리 파악 및 문서 자동화를 어떻게 이룰 수 있는지 이해할 수 있습니다.
+
+### Deeper Research Questions
+- Trunk-Based Development를 성공적으로 적용하기 위해 필수적인 자동화 테스트 환경(CI)과 기능 플래그(Feature flags)의 구현 전략은 무엇인가?
+- 소규모 팀이 단일 `main` 브랜치 전략을 사용할 때, 예기치 않은 버그가 배포되는 것을 막기 위한 GitHub 저장소의 브랜치 보호 규칙(Branch Protection Rules) 최적화 방법은 무엇인가?
+- 장기 체류 브랜치(Long-lived branch)에서 발생하는 거대한 병합 충돌을 피하기 위해 `main` 브랜치의 최신 내용을 가져올 때 `merge`와 `rebase` 중 어떤 방식이 이력 관리에 더 효과적인가?
+- 원자적 커밋(Atomic Commits)을 강제하는 정책이 Pull Request 리뷰 시간과 버그 추적성에 어떠한 정량적/정성적 영향을 미치는가?
+- Git Flow 방식에서 GitHub Flow 방식으로 팀의 워크플로우를 마이그레이션할 때 예상되는 혼란 요소와 이를 해결하기 위한 CI/CD 파이프라인의 재구성 방법은 무엇인가?
+
+### Practical Application Contexts
+- **Implementation:** 새로운 기능 개발을 시작할 때, 최신 `main` 브랜치에서 `feature/티켓ID-간단한-설명` 이름으로 브랜치를 파생하고, 원자적 단위로 작은 커밋을 자주 기록합니다.
+- **System Design:** 프론트엔드 모듈 아키텍처 설계 시, 독립적인 피처(Feature) 폴더별로 브랜치를 나누어 개발함으로써 특정 코드 영역 밖으로 병합 충돌의 폭발 반경(Blast radius)이 퍼지지 않도록 합니다.
+- **Operation / Maintenance:** 브랜치가 `main`으로 병합되는 즉시 GitHub Action 등 CI 서버에서 자동으로 린트(ESLint), 테스트(Jest), 포맷팅을 수행하도록 방어막을 구축하여 메인 브랜치의 배포 가능한 상태를 영구적으로 유지합니다.
+- **Learning Path:** Git의 기초 명령어를 습득한 후, 소규모 팀 단위의 Feature Branch Workflow를 실습하고, 이후 CI/CD 도구를 연동한 Trunk-Based 환경으로 발전하는 순서로 학습합니다.
+- **My Project Relevance:** 3~5인 규모의 프로젝트에서 무거운 Git Flow의 도입을 지양하고, '단기 기능 브랜치 → PR 및 1인 이상 피어 리뷰 승인 → Squash Merge 및 브랜치 즉시 삭제'라는 단순화된 룰을 적용하여 개발 속도와 코드 품질을 동시에 챙깁니다.
+
+### Adjacent Topics
+- [[Continuous Integration / Continuous Deployment (CI/CD)]]
+  - 확장 방향: 브랜칭 전략에 의해 트리거(Trigger)되어 실행되는 빌드, 테스트, 배포 파이프라인의 자동화 프로세스를 깊이 알아봅니다.
+- [[Feature-Sliced Design (FSD)]]
+  - 확장 방향: 도메인과 기능 단위로 코드를 분리하는 프론트엔드 아키텍처 방법론으로, 브랜치를 기능별로 나눌 때 충돌을 물리적으로 최소화하는 코드 구조 설계법을 탐구합니다.
+
+---
+*Last updated: 2026-04-30*
\ No newline at end of file
diff --git a/10_Wiki/Management/Code Review.md b/10_Wiki/Management/Code Review.md
new file mode 100644
index 00000000..5436d57b
--- /dev/null
+++ b/10_Wiki/Management/Code Review.md	
@@ -0,0 +1,56 @@
+# [[Code Review]]
+
+## 📌 Brief Summary
+코드 리뷰(Code Review)는 개발자가 작성한 코드를 메인 브랜치에 병합하기 전에 팀원(동료)이 검토하여 승인하는 품질 관리 및 협업 프로세스입니다 [1, 2]. 주로 Pull Request(PR) 단계를 통해 이루어지며, 단독으로 잘못된 코드가 병합되는 것을 방지하고 팀 내 빠른 피드백 루프를 형성합니다 [1]. 최근 프론트엔드 환경에서는 단순한 코드 검토를 넘어 Storybook과 같은 도구를 CI 파이프라인과 결합한 '시각적 리뷰(Visual Review)'로 확장되어 의도치 않은 UI 변경을 방지하는 역할도 수행합니다 [3].
+
+## 📖 Core 소스에 기반한 Core Content
+- **동료 검토(Peer Review)의 역할 및 이점**: 개발자는 기능 브랜치(feature branch)에서 작업을 마친 후 병합을 위한 Pull Request(PR)를 생성하며, 이때 최소 1명 이상의 팀원에게 검토와 승인을 받아야 합니다 [1, 4]. 리뷰어는 변경된 코드에 대해 코멘트를 남기며, 작성자가 이를 수정하고 재푸시(push)하여 최종 승인을 받으면 병합이 이루어집니다 [5]. 이는 단일 개발자의 실수로 인한 잘못된 병합을 막고, 팀원 간의 건전한 리뷰 습관과 협업을 촉진합니다 [1, 6].
+- **효율적인 PR 에티켓**: 원활한 코드 리뷰를 위해서는 PR을 작게 유지하고 단일 작업(Single task)에 집중하는 것이 모범 사례입니다 [2]. 리뷰어가 한 번에 2,000줄 이상의 방대한 코드를 검사하도록 요구해서는 안 되며, PR 규모가 작을수록 더 빠르고 철저하게 검토될 수 있습니다 [2, 7].
+- **시각적 리뷰(Visual Review)의 도입**: 프론트엔드 개발의 PR 프로세스에서는 코드의 논리 검토뿐만 아니라 시각적 회귀(Visual Regression) 검토가 필수가 되었습니다 [3]. 개발자는 Storybook을 활용해 컴포넌트를 분리하여 구축하고, Chromatic이나 Happo 등의 도구를 CI 파이프라인에 통합합니다 [3, 8]. 
+- **자동화된 시각적 회귀 감지**: PR이 열리면 이 도구들이 여러 브라우저 및 뷰포트 환경에서 자동으로 모든 UI 상태의 스크린샷을 캡처하고 이전 기준선(baseline)과 비교합니다 [9, 10]. 레이아웃이나 색상 등에 의도치 않은 변경 사항이 발견되면 PR에 해당 사항이 수동 검토 대상으로 표시(flagged)되어 버그가 프로덕션 환경으로 배포되는 것을 차단합니다 [3]. 더불어, 시각적 검토 도구는 시각적 변경 사항과 함께 새로운 접근성 위반(accessibility violations)까지 포착할 수 있습니다 [9, 11].
+
+## ⚖️ Trade-offs & Caveats
+- **리뷰 병목 현상 및 복잡도 증가**: 한 번에 수천 줄에 달하는 큰 규모의 코드(PR)를 리뷰하도록 요청할 경우, 리뷰어가 코드를 철저히 감사(audit)하기 어려워 리뷰 속도와 품질이 모두 저하되는 문제가 발생합니다 [2]. 이를 피하기 위해서는 PR을 매우 작게 나누어 지속적으로 리뷰해야 하므로, 개발자는 작업 단위를 세밀하게 쪼개야 하는 추가적인 노력이 필요합니다 [2, 7].
+- **시각적 테스트의 불안정성(Flake) 이슈**: 시각적 리뷰를 위해 스크린샷 기반 테스트를 도입할 때, 컴포넌트의 기능적 변경이 없더라도 압축 노이즈, 안티앨리어싱, 비동기 에셋(폰트 등), 애니메이션 등으로 인해 미세한 픽셀 차이가 발생하여 오류로 처리되는 거짓 양성(False positive) 문제가 생길 수 있습니다 [8, 12]. 이를 해결하기 위해 색상 오차 허용 범위(color-delta tolerance)를 설정하거나 애니메이션을 음소거하는 등의 추가적인 구성(Configuration)과 관리가 요구됩니다 [8, 12, 13].
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+
+#### [협업 및 형상 관리 워크플로우]
+- [[Pull Request (PR)]]
+  - 연결 이유: 코드 리뷰가 실질적으로 요청되고, 검토 피드백이 오가는 핵심 플랫폼이자 단위입니다 [1, 2].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 브랜치 병합 전 품질 관리 게이트로서의 기능과 짧고 명확한 작업 단위 분할의 중요성을 파악할 수 있습니다.
+
+- [[Feature Branch Workflow]]
+  - 연결 이유: 코드 리뷰 시스템을 쉽게 도입하기 위한 가장 기본적이고 충돌이 적은 브랜치 전략입니다 [14, 15].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 메인 브랜치를 항상 안정적으로 유지하면서, 각각의 태스크를 독립된 브랜치에서 작업하고 리뷰를 통해 검증하는 전체 흐름을 이해할 수 있습니다.
+
+#### [자동화 및 품질 검증 도구]
+- [[Visual Regression Testing]]
+  - 연결 이유: 프론트엔드 코드 리뷰 시 육안으로 확인하기 힘든 의도치 않은 레이아웃/색상 변경을 자동화 도구가 시각적으로 찾아내어 리뷰어에게 제시합니다 [3, 9].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: Chromatic이나 Happo를 CI 파이프라인과 결합하여 PR 리뷰의 정확도를 높이고 안정적인 UI를 배포하는 프로세스를 배울 수 있습니다.
+
+### Deeper Research Questions
+
+- PR의 크기를 작게 유지하고 단일 작업(Single task)에 집중하도록 논리적으로 작업을 분할하는 가장 효과적인 방법론과 기준은 무엇인가?
+- 대규모 팀에서 쏟아지는 수많은 PR과 코드 리뷰 요청을 병목 현상 없이 효율적으로 처리하고 배포 속도를 유지하기 위한 전략은 무엇인가?
+- 시각적 회귀 테스트(Visual Regression Testing) 시 발생하는 미세한 렌더링 차이(Flake)를 방지하고 신뢰할 수 있는 기준선(Baseline)을 유지하기 위한 구체적인 구성 최적화 방법은 무엇인가?
+- 코드 리뷰 시 시각적 회귀(Visual changes) 감지뿐만 아니라, 접근성 테스트(Accessibility tests)를 함께 자동화했을 때 얻게 되는 이점과 이를 처리하는 내부 동작 원리는 무엇인가?
+- 기능 분기(Feature branch)의 수명이 길어졌을 때 발생하는 리뷰 및 병합 충돌 문제를 해결하고, 지속적으로 짧은 주기의 리뷰를 유도하는 문화는 어떻게 정착시킬 수 있는가?
+
+### Practical Application Contexts
+
+- **Implementation:** 코드를 커밋하고 PR을 생성할 때, 리뷰어가 쉽게 코드를 파악할 수 있도록 200줄 미만의 작은 단위로 변경 사항을 쪼개어 올리고 무엇이 왜 변경되었는지 명확히 명시해야 합니다 [2, 7].
+- **System Design:** 프론트엔드 설계 시 Storybook을 활용하여 모든 UI 컴포넌트의 다양한 상태(loading, error 등)를 캡슐화해 두면, 코드 리뷰 시에 이 상태들을 자동으로 스크린샷으로 찍어 검증할 수 있는 기반 시스템이 만들어집니다 [16].
+- **Operation / Maintenance:** CI/CD 파이프라인 단계에 Chromatic이나 Happo 같은 도구를 연동시켜, 팀원이 PR을 생성할 때마다 시각적 변동 사항(diff)이나 접근성 위반 내역이 PR 체크 리스트에 배지로 자동 보고되도록 운영 환경을 구축합니다 [17].
+- **Learning Path:** Git의 기초적인 브랜치 사용법을 배운 후, 팀 협업의 핵심인 PR 생성 및 리뷰 요청 과정(GitHub Flow 등)을 익히고, 나아가 시각적 테스팅 도구가 PR에 어떻게 피드백을 주는지를 실습해보는 흐름으로 학습할 수 있습니다 [8, 18].
+- **My Project Relevance:** 소규모 3인 팀 프로젝트를 진행할 때 복잡한 Git-Flow 대신 기능 브랜치 워크플로우를 채택하고, 코드 병합 시 반드시 1명 이상의 피어 리뷰(Peer review)를 받도록 규칙을 정해 버그 없는 안정적 메인 브랜치를 유지할 수 있습니다 [1, 14].
+
+### Adjacent Topics
+
+- [[Continuous Integration (CI)]]
+  - 확장 방향: PR이 올라왔을 때 코드 리뷰를 돕기 위해 사전에 테스트 통과 여부, 빌드 성공 여부 등을 자동으로 검사해주는 자동화 파이프라인의 구축에 대해 학습할 수 있습니다 [7, 19].
+
+---
+*Last updated: 2026-04-30*
\ No newline at end of file
diff --git a/10_Wiki/Management/Git Workflow.md b/10_Wiki/Management/Git Workflow.md
new file mode 100644
index 00000000..5dc64fac
--- /dev/null
+++ b/10_Wiki/Management/Git Workflow.md	
@@ -0,0 +1,75 @@
+# [[Git Workflow]]
+
+## 📌 Brief Summary
+Git Workflow(깃 워크플로우)는 팀 환경에서 코드 변경 사항을 관리하고 협업하기 위한 체계적이고 구조화된 접근 방식입니다 [1, 2]. 이는 기능 브랜치(Feature-branch), 트렁크 기반(Trunk-based), Git Flow 등 다양한 전략을 포괄하며, 충돌을 방지하고 `main` 브랜치의 배포 가능 상태를 보장하는 것을 목표로 합니다 [2-4]. 일관된 브랜치 명명 규칙, 커밋 메시지 규약, 풀 리퀘스트(PR)와 리뷰 절차를 도입함으로써 잠재적인 혼돈을 예측 가능한 릴리스 흐름으로 전환할 수 있습니다 [1, 5, 6].
+
+## 📖 Core Content
+*   **주요 브랜칭 전략 (Main Branching Strategies):**
+    *   **Feature-Branch Workflow (기능 브랜치 워크플로우):** 주 브랜치(`main`)를 항상 안정적이고 배포 가능한 상태로 유지하며, 새로운 작업이나 버그 수정마다 짧은 수명의 기능 브랜치(예: `feature/login`)를 생성하여 작업합니다 [3, 4, 7]. 소규모 팀에 매우 적합하며, 오버헤드 없이 코드를 안전하게 통합할 수 있습니다 [4, 8].
+    *   **Trunk-Based Development (트렁크 기반 개발):** 강력한 CI(지속적 통합) 환경을 갖춘 경험 많은 팀에 적합한 방식으로, 아주 짧은 수명의 브랜치를 사용해 자주 `main`에 코드를 병합하여 통합 속도를 높입니다 [8, 9].
+    *   **Git Flow:** `develop` 및 `release` 등 다수의 브랜치를 운영하며 스케줄된 릴리스를 관리하는 대규모 프로젝트에 적합하지만, 소규모 팀에게는 너무 복잡하고 무거울 수 있습니다 [8, 10].
+    *   **GitHub Flow:** 기능을 기능 브랜치에서 작업한 뒤 풀 리퀘스트를 통해 리뷰받고 병합하여, `main`에서 바로 배포하는 방식입니다 [11, 12].
+
+*   **명명 규칙 및 추적성 (Naming Conventions & Traceability):**
+    *   **브랜치 이름:** 브랜치 목적을 명확히 하기 위해 `feature/`, `bugfix/`와 같은 접두사를 사용하며, 티켓 ID를 함께 포함(예: `feature/PROJ-123-user-auth`)하여 이슈 트래커와의 추적성을 확보해야 합니다 [13-15]. 
+    *   **커밋 메시지:** `type(scope): description` 형태를 따르는 "Conventional Commits" 규약을 사용하는 것이 좋습니다 [6, 16]. 예를 들어 새로운 기능은 `feat:`, 버그 수정은 `fix:`, 문서 수정은 `docs:` 등으로 시작하여 변경의 의도를 명확히 합니다 [6, 16].
+
+*   **풀 리퀘스트와 병합 (Pull Requests & Merging):**
+    *   `main` 브랜치에 직접 푸시(Push)하는 것을 금지하고, 반드시 풀 리퀘스트(PR)를 생성하여 최소 1명 이상의 동료에게 코드 리뷰를 받아야 합니다 [13, 17].
+    *   코드 리뷰 속도와 품질을 위해 PR은 작고 논리적인 단일 변경 사항(Atomic Commits) 단위로 유지해야 합니다 [16, 18].
+    *   병합 시에는 스쿼시 병합(Squash merge)을 사용하여 커밋 히스토리를 깔끔하게 유지하고, 병합이 완료된 기능 브랜치는 자동으로 삭제하여 리포지토리를 정리합니다 [17-19].
+
+## ⚖️ Trade-offs & Caveats
+*   **구조의 복잡성 vs. 팀의 규모:** Git Flow는 대규모의 복잡한 릴리스 계획을 안전하게 관리할 수 있지만, 프로세스 오버헤드가 크고 병합 지연을 초래합니다 [8, 20]. 반면, Feature-Branch 워크플로우나 Trunk-Based 방식은 소규모 팀이 빠르고 가볍게 움직일 수 있도록 돕지만, 규모가 커지거나 엄격한 릴리스 버전 관리가 필요한 경우 한계에 부딪힐 수 있어 워크플로우를 진화(Migration)시켜야 합니다 [8, 10].
+*   **기능 브랜치의 수명과 충돌:** 기능 브랜치 방식의 가장 큰 부작용은 브랜치의 수명이 길어질 경우 메인 브랜치와의 차이가 커져 심각한 병합 충돌(Merge Conflict)이 발생한다는 점입니다 [20, 21]. 이를 피하기 위해 개발자는 자주 `main` 브랜치를 풀(Pull) 받거나 리베이스(Rebase)하여 최신 상태를 동기화하는 부가적인 작업을 수행해야 합니다 [19, 20].
+*   **완전한 추적성의 대가:** 모든 브랜치와 커밋에 티켓 ID 부여를 강제하면 버그 추적이나 리뷰에 있어 컨텍스트 확보에는 탁월하나 [5, 22], 아주 단순하고 사소한 코드 수정 작업에도 반드시 티켓을 생성하고 절차를 밟아야 하는 속도 저하의 단점이 발생합니다 [23].
+*   **Trunk-Based 전환의 전제 조건:** Trunk-Based Development로 전환하여 빠른 통합의 이점을 얻고자 한다면, 코드의 불안정성을 감추기 위한 기능 토글(Feature flags) 기법과 병합 전 결함을 잡아낼 강력한 테스트 자동화(CI)가 필수적으로 요구된다는 제약 사항이 있습니다 [12].
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+
+#### [관계 유형 A (아키텍처/기반 기술)]
+- `[[Trunk-Based Development]]`
+  - 연결 이유: Git Workflow를 구성하는 핵심 전략 중 하나로, 빠른 통합을 목적으로 하는 방법론입니다 [2].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 짧은 수명의 브랜치, 빈번한 병합, 기능 플래그(Feature Flags) 활용이 프로젝트 배포 속도에 어떻게 기여하는지 이해할 수 있습니다 [9, 12].
+
+- `[[Git Flow]]`
+  - 연결 이유: 구조가 복잡한 대규모 프로젝트의 릴리스를 관리하기 위해 만들어진 전통적 브랜칭 모델입니다 [2, 10].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: `develop`, `release`, `hotfix` 등 다중 브랜치 전략이 왜 오버헤드를 유발하면서도 엔터프라이즈 환경에서 사용되는지 파악할 수 있습니다 [8, 10].
+
+#### [관계 유형 B (구현/활용 도구)]
+- `[[Conventional Commits]]`
+  - 연결 이유: 팀의 일관된 코드베이스 히스토리 관리를 위해 Git 커밋 메시지 작성에 적용되는 업계 표준 규칙입니다 [6, 16].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: `feat:`, `fix:`, `chore:`와 같은 접두사가 리뷰어의 코드 이해도를 어떻게 높이고 자동화된 릴리스에 기여하는지 배울 수 있습니다 [6, 16].
+
+- `[[Pull Requests (PR)]]`
+  - 연결 이유: 브랜치의 코드를 `main`으로 병합하기 전, 협업 팀원들이 코드를 검토하는 핵심 관문입니다 [13, 16].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 브랜치 보호 설정, 동료 리뷰 요구(1 review required), 지속적 통합(CI) 체크가 시스템 안정성 유지에 어떻게 필수적으로 작용하는지 이해할 수 있습니다 [16, 17].
+
+- `[[Ticket IDs (Traceability)]]`
+  - 연결 이유: 코드의 변경 사항이 어떤 비즈니스 요구사항(예: Jira 티켓)에 의해 발생했는지를 연결하는 도구적 장치입니다 [5, 22].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: `PROJ-123` 형태의 티켓 번호를 브랜치와 커밋에 삽입함으로써 리뷰어에게 맥락을 제공하고, 문서화 및 작업 추적(Traceability)을 어떻게 달성하는지 알 수 있습니다 [5, 22].
+
+### Deeper Research Questions
+- 소규모 팀이 성장하여 복잡성이 증가할 때, Feature Branch Workflow에서 Git Flow로 안전하게 마이그레이션하려면 어떤 절차와 팀 내 교육이 필요한가?
+- Trunk-Based Development를 효과적으로 도입하기 위해 CI/CD(지속적 통합/배포) 파이프라인에서 반드시 구성해야 하는 자동화 테스트 조건은 무엇인가?
+- Conventional Commits 시스템과 연동하여 자동 릴리스 노트를 작성하고 시맨틱 버저닝(Semantic Versioning)을 구현하는 기술적 원리는 어떻게 작동하는가?
+- 다수의 작업자가 겹치는 영역을 수정할 때 발생하는 Merge Conflict를 예방하기 위해, 'Atomic Commits'와 '자주 병합하기' 원칙은 실무에서 어떻게 구체적으로 적용되어야 하는가?
+- 코드 리뷰의 병목 현상을 방지하기 위해 PR의 규모를 작게(예: 200줄 이하) 유지하면서도 논리적인 기능 단위를 훼손하지 않는 코드 분할 기법은 무엇인가?
+
+### Practical Application Contexts
+- **Implementation:** 새로운 작업을 시작할 때 무조건 `git checkout -b feature/티켓ID-작업명`으로 독립적인 브랜치를 파고, 완료 후 `feat:` 등의 규칙을 따른 커밋 메시지를 작성한 뒤 `main` 브랜치에 PR을 생성합니다 [6, 7, 13, 22].
+- **System Design:** GitHub와 같은 호스팅 플랫폼에서 `main` 브랜치 보호(Branch Protection) 옵션을 활성화하여 직접 푸시를 막고, CI 빌드 통과와 최소 1인의 승인이 있어야 병합되도록 시스템을 설계합니다 [17].
+- **Operation / Maintenance:** 브랜치가 병합될 때마다 스쿼시 병합(Squash and merge)을 강제하여 커밋 히스토리를 단일 항목으로 압축하고, 병합 후 남은 브랜치를 자동 삭제(Auto-delete) 설정하여 저장소를 깔끔하게 운영합니다 [17-19].
+- **Learning Path:** Git에 입문하는 소규모 프로젝트의 경우, 복잡한 `develop` 브랜치 없이 `main` 브랜치 하나와 기능 브랜치들로만 구성된 가벼운 워크플로우(Feature-Branch Workflow)를 먼저 학습하고 체화하는 것이 권장됩니다 [4, 8].
+- **My Project Relevance:** 현재 진행하는 3인 규모의 프로젝트 등에서는 Git Flow의 무거운 절차를 피하고, 항상 배포 가능한 안정적인 `main` 브랜치를 기준으로 짧은 기능 브랜치를 생성하여 빠른 리뷰와 피드백을 주고받는 방식을 즉각 도입할 수 있습니다 [4, 8].
+
+### Adjacent Topics
+- `[[CI/CD (Continuous Integration/Continuous Deployment)]]`
+  - 확장 방향: PR을 생성하거나 병합할 때 코드를 자동으로 테스트하고 빌드, 배포하는 인프라 파이프라인 구성 방법론으로 확장하여 조사.
+- `[[Semantic Versioning (SemVer)]]`
+  - 확장 방향: Git 태그(Tag)와 Conventional Commits를 활용하여 소프트웨어의 버전을 체계적이고 일관성 있게 부여하는 방법으로 확장.
+
+---
+*Last updated: 2026-04-30*
\ No newline at end of file
diff --git a/10_Wiki/Management/GitHub Flow.md b/10_Wiki/Management/GitHub Flow.md
new file mode 100644
index 00000000..2214b4bc
--- /dev/null
+++ b/10_Wiki/Management/GitHub Flow.md	
@@ -0,0 +1,64 @@
+# [[GitHub Flow]]
+
+## 📌 Brief Summary
+GitHub Flow는 복잡한 Git Flow의 대안으로 사용되는 가볍고 단순한 브랜치 기반 워크플로우입니다 [1, 2]. 이 방식은 항상 배포 가능한 상태(deployable)를 유지하는 `main` 브랜치를 중심으로 작동하며, 개발자는 새로운 작업을 위해 짧은 주기의 기능 브랜치(feature branch)를 생성합니다 [3-5]. 변경된 코드는 동료의 코드 리뷰와 CI/CD 테스트를 모두 통과한 후 오직 Pull Request(PR)를 통해서만 `main`에 병합됩니다 [1, 6].
+
+## 📖 Core Content
+* **안정적인 `main` 브랜치 유지**
+  GitHub Flow의 핵심은 `main` (또는 `master`) 브랜치가 항상 안정적이고 언제든 배포 가능한 상태여야 한다는 점입니다 [3-5]. 개발자는 어떠한 경우에도 `main` 브랜치에 직접 커밋(direct commit)해서는 안 됩니다 [1, 6, 7].
+* **기능 브랜치(Feature Branch) 기반 작업**
+  모든 새로운 기능 개발, 버그 수정, 문서 작업 등은 `main`에서 파생된 짧은 수명(short-lived)의 전용 브랜치에서 수행되어야 합니다 [3-5]. 브랜치 이름은 `feature/user-auth` 또는 `bugfix/login-error`와 같이 설명적이어야 하며, 가능하면 티켓 ID(예: `PROJ-123`)를 포함하여 추적성을 높이는 것이 좋습니다 [8, 9].
+* **Pull Request (PR) 및 코드 리뷰**
+  작업이 완료되면 `main` 브랜치로 병합하기 위해 PR을 생성합니다 [6, 10]. 병합 전에는 반드시 최소 1명 이상의 팀원에게 코드 리뷰(Peer Review)를 받아야 하며, CI/CD 환경에서의 자동화 테스트를 통과해야 합니다 [1, 6, 8]. 이는 혼자서 잘못된 코드를 병합하는 것을 방지하는 안전장치입니다 [8].
+* **병합 규칙과 정리**
+  커밋 히스토리를 깔끔하게 유지하기 위해 PR을 병합할 때는 'Squash Merge' 방식을 주로 사용합니다 [6, 7, 11]. 성공적으로 병합된 이후에는 불필요한 브랜치가 쌓이지 않도록 기능 브랜치를 즉시 삭제(auto-delete)합니다 [6, 8, 11].
+* **워크플로우 마이그레이션 (Migration)**
+  팀이 기존의 복잡한 Git Flow에서 GitHub Flow로 전환하여 통합 속도를 높이고 단순화하려면, 릴리스 브랜치(release branch) 생성을 중단하고, `develop` 브랜치를 `main`으로 통합한 뒤, `main` 브랜치에서 직접 배포하도록 CI/CD 파이프라인을 업데이트해야 합니다 [2]. 반대로 프로젝트의 구조가 더 복잡해지면 `develop` 브랜치 등을 추가해 Git Flow로 되돌아갈 수도 있습니다 [12].
+
+## ⚖️ Trade-offs & Caveats
+* **병합 코드의 즉각적인 리스크**: `main` 브랜치가 유일한 배포 기준점이 되므로, 리뷰나 테스트가 누락되어 버그가 포함된 코드가 병합될 경우 프로덕션(운영) 환경에 치명적인 영향을 미칠 수 있습니다 [13, 14]. 따라서 강력한 CI/CD 자동화 환경과 Branch Protection Rule(보호 규칙)이 필수적으로 뒷받침되어야 합니다 [1, 6].
+* **브랜치 수명 관리의 어려움**: 기능 브랜치가 너무 오래 유지(Long-lived)되면 `main` 브랜치와의 차이가 벌어져 심각한 병합 충돌(Merge Conflict)이 발생합니다 [13, 15]. 이를 방지하기 위해 개발자는 매일 작업 전 `main` 브랜치의 최신 상태를 당겨오고(pull/rebase) 변경 사항을 작게 유지하는 규율을 엄격히 지켜야 합니다 [11, 13].
+* **대규모/정기 릴리스 프로젝트에서의 한계**: 정해진 일정에 따라 버전을 묶어서 배포해야 하거나, 유지보수해야 할 과거 릴리스 버전이 여러 개인 대규모 프로젝트의 경우, 릴리스 브랜치가 없는 GitHub Flow는 구조적 한계를 가집니다. 이 경우에는 무겁더라도 Git Flow가 더 적합할 수 있습니다 [12, 16].
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+
+#### [관계 유형 A: 아키텍처/기반 기술 (개발 워크플로우)]
+- [[Git Flow]]
+  - 연결 이유: GitHub Flow와 자주 비교되는 분기 전략으로, 프로젝트의 복잡성에 따라 두 전략 사이를 마이그레이션하는 경우가 많습니다 [2, 12].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: `develop`, `release`, `hotfix` 브랜치를 사용하는 Git Flow를 이해함으로써, 상대적으로 GitHub Flow가 생략한 구조적 복잡성과 그에 따른 속도/단순성의 이점을 명확히 비교할 수 있습니다.
+- [[Trunk-Based Development]]
+  - 연결 이유: 소규모 팀에서 빠르고 충돌 없는 병합을 위해 도입할 수 있는 또 다른 경량 워크플로우입니다 [3, 16].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 극단적으로 짧은 생명주기의 브랜치를 사용하거나 메인에 빈번히 직접 병합하는 철학을 통해 CI(지속적 통합)의 본질을 더 깊게 이해할 수 있습니다.
+
+#### [관계 유형 B: 구현/활용 도구]
+- [[Pull Request]]
+  - 연결 이유: GitHub Flow에서 코드 병합을 수행하고 팀원 간의 협업 및 리뷰를 진행하는 가장 핵심적인 메커니즘입니다 [8, 10].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 코드 품질 통제, 피어 리뷰(Peer Review)의 역할 및 CI/CD 훅(Hook)이 작동하는 방식을 구체적으로 이해할 수 있습니다.
+- [[CI/CD]]
+  - 연결 이유: `main` 브랜치를 항상 배포 가능한 상태로 유지하기 위해 배후에서 코드를 검증하는 필수 자동화 파이프라인입니다 [1, 6].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 왜 수동 병합이 위험한지, PR 리뷰가 끝난 코드가 어떻게 안전하게 프로덕션 레벨까지 배포되는지의 전 과정을 파악할 수 있습니다.
+
+### Deeper Research Questions
+- Git Flow 기반 프로젝트에서 GitHub Flow로 마이그레이션할 때, 기존의 버전 관리 체계 및 배포 자동화 파이프라인을 어떻게 재설계해야 하는가?
+- GitHub Flow 환경에서 기능이 미완성된 상태로 `main`에 병합되어야 할 때, Feature Flag(기능 토글)를 어떻게 효과적으로 활용할 수 있는가?
+- 팀 규모가 3~5인에서 20인 이상으로 급격히 성장할 때, GitHub Flow의 한계점은 구체적으로 어떻게 나타나며 어떤 시점에 워크플로우를 전환해야 하는가?
+- 커밋 히스토리를 정리하기 위해 권장되는 Squash Merge 방식이 장기적인 버그 추적성(Traceability) 관점에서는 어떤 단점을 가질 수 있는가?
+- Branch Protection을 통해 '최소 1인의 리뷰'와 'CI 통과'를 강제할 때, 코드 리뷰 병목 현상을 해결하기 위한 프로세스적 최적화 방법은 무엇인가?
+
+### Practical Application Contexts
+- **Implementation:** 개발자는 JIRA 등에서 할당받은 티켓 ID를 기반으로 `feature/PROJ-123-login` 형식의 브랜치를 따고, 한 가지 논리적 변경사항만 담은 Atomic Commit을 수행한 뒤 PR을 생성합니다.
+- **System Design:** GitHub/GitLab 등의 레포지토리 설정에서 `main` 브랜치에 대해 직접 푸시(Direct Push)를 차단하고, Status Check(테스트 통과) 및 지정된 리뷰어의 Approve를 강제하는 보호 규칙(Branch Protection)을 설계합니다.
+- **Operation / Maintenance:** CI/CD 파이프라인이 `main` 브랜치의 변경을 감지하면 자동으로 프로덕션에 배포되도록 구성하고, 저장소의 깔끔한 관리를 위해 병합된 브랜치는 시스템에서 자동 삭제되도록 설정합니다.
+- **Learning Path:** Git 브랜치 기초 명령어 숙지 -> 1기능 1브랜치 원칙 실습 -> PR 작성 및 동료 리뷰 경험 -> 자동화된 CI/CD와의 연동 이해의 순서로 협업 능력을 성장시킬 수 있습니다.
+- **My Project Relevance:** 3~5명의 소규모 팀에서 충돌을 최소화하면서도 빠른 피드백과 릴리스가 필요한 현재 프로젝트 상황에, 불필요한 절차를 없애고 안정성을 보장하는 가장 이상적인 협업 모델로 적용할 수 있습니다.
+
+### Adjacent Topics
+- [[Conventional Commits]]
+  - 확장 방향: 커밋 메시지를 `feat:`, `fix:`, `chore:` 등의 규격으로 통일함으로써, PR 내용의 가독성을 높이고 향후 릴리스 노트를 자동화하는 방향으로 지식을 확장할 수 있습니다.
+- [[Issue Tracking System]]
+  - 확장 방향: 코드 구현(GitHub)과 요구사항 정의(JIRA, Linear 등)를 연결하여 프로젝트 관리 수준을 높이고 변경 사항의 비즈니스 맥락(Traceability)을 추적하는 방법론으로 확장됩니다.
+
+---
+*Last updated: 2026-04-30*
\ No newline at end of file
diff --git a/10_Wiki/Management/Team Collaboration.md b/10_Wiki/Management/Team Collaboration.md
new file mode 100644
index 00000000..cd5d477d
--- /dev/null
+++ b/10_Wiki/Management/Team Collaboration.md	
@@ -0,0 +1,70 @@
+# [[Team Collaboration]]
+
+## 📌 Brief Summary
+프론트엔드 개발에서 'Team Collaboration(팀 협업)'이란 다수의 개발자가 동일한 코드베이스에서 효율적으로 함께 작업할 수 있도록 지원하는 실천 방식, 아키텍처, 그리고 워크플로우를 의미한다 [1, 2]. 이는 일관된 폴더 구조, 명명 규칙, 상태 관리 패턴 및 Git 브랜칭 전략을 확립하여 개발자 간의 충돌과 소통 비용을 최소화하는 것을 목표로 한다 [2-4]. 성공적인 협업은 린팅이나 포매팅과 같은 자동화된 도구를 통한 엄격한 코드 거버넌스와 명확한 코드 리뷰 문화를 바탕으로 애플리케이션과 팀이 확장될 때 안정성을 유지하도록 돕는다 [5-7].
+
+## 📖 Core Content
+* **Git 워크플로우 및 브랜칭 전략:** 
+  소규모 팀에서는 오버헤드가 적으면서도 충돌을 방지하는 '기능 브랜치(Feature-branch) 워크플로우'나 '트렁크 기반(Trunk-based) 개발'이 주로 권장된다 [8-10]. 모든 작업은 `main` 브랜치에 직접 커밋하지 않고 짧은 수명의 기능 브랜치에서 진행되며, Pull Request(PR)와 최소 1명 이상의 동료 리뷰(Peer review) 및 테스트 통과 후 병합되어야 한다 [7, 11, 12]. 또한, 브랜치명과 커밋 메시지에 티켓 ID(예: `PROJ-123`)를 포함하면 요구사항과 코드 변경 이력 간의 추적성(Traceability)을 확보할 수 있다 [13, 14].
+* **아키텍처 및 폴더 구조의 표준화:** 
+  표준화된 폴더 구조(예: 기능 기반 구조 또는 Feature-Sliced Design)는 파일의 위치를 예측 가능하게 하여 팀 협업을 크게 향상시킨다 [2]. 구조가 잘 잡혀 있으면 개발자들이 파일을 찾는 시간을 줄이고, 팀원 간 불필요한 소통을 줄일 수 있으며, 신규 개발자의 온보딩이 빨라진다 [2, 15]. 또한 각 기능이 독립된 폴더로 격리되어 있어 서로의 코드를 간섭할 확률이 낮아진다 [16].
+* **명명 규칙(Naming Conventions) 및 자동화된 거버넌스:** 
+  컴포넌트 이름은 파스칼 케이스(PascalCase), 파일 및 폴더 이름은 케밥 케이스(kebab-case)를 사용하는 등 일관된 명명 규칙은 OS 환경 간의 빌드 오류를 방지하고 코드 가독성을 높인다 [17-19]. 더 나아가 수동 검사에 의존하기보다 ESLint, Prettier, Husky를 활용해 커밋 이전에 린팅, 포매팅 및 타입 검사를 자동으로 강제하는 것이 고품질 코드 협업의 기반이다 [6, 20, 21].
+* **상태 관리 도구와 팀 규모의 상관관계:** 
+  팀의 규모가 클수록(10명 이상) 구조를 강제하는 도구가 협업에 유리하다 [5]. Zustand와 같은 도구는 유연하고 빠르지만, 규율이 부족하면 개발자마다 비동기 작업을 다르게 처리하여 코드베이스에 혼란(integration chaos)을 초래할 수 있다 [22, 23]. 반면 Redux는 보일러플레이트가 많지만, 팀 전원이 동일한 방식으로 코드를 작성하게 만드는 '단일 진실 공급원'과 구조를 제공하여 대규모 협업에서 버그를 줄인다 [5, 24, 25].
+
+## ⚖️ Trade-offs & Caveats
+* **유연성 vs. 구조적 강제성 (상태 관리):** Zustand 같이 가벼운 상태 관리 라이브러리는 보일러플레이트가 적어 빠른 기능 개발(스타트업 등)에 적합하지만, 유연성이 너무 커서 팀이 커질 경우 파편화된 패턴을 낳을 수 있다 [22, 23, 26, 27]. 반면 Redux는 일관성을 강제하여 디버깅과 협업을 편하게 해주지만, 초기 설정과 구조화에 드는 시간이 소규모 팀에게는 과도한 오버헤드로 작용할 수 있다 [5, 24, 28].
+* **브랜칭 워크플로우의 무게감:** Git Flow는 예정된 릴리스를 관리하는 거대 프로젝트에는 유용하지만, 소규모 팀에게는 브랜치 관리 비용이 너무 커서 개발 속도를 늦출 수 있다 [8, 29]. 가벼운 Feature-branch 워크플로우나 Trunk-based 개발이 대안이지만, 이는 개발자들이 브랜치를 짧게 유지하고 빈번히 병합(Merge)하는 규율을 스스로 지켜야만 성공할 수 있다 [30, 31].
+* **초기 학습 곡선과 오버헤드:** Feature-Sliced Design(FSD) 같은 엄격한 아키텍처는 코드의 모듈화와 독립적 작업(병렬 작업)을 가능하게 하지만, 초기 도입 시 팀원 전체가 해당 방법론(Layer, Slice 등의 개념)을 이해하고 동의해야 하는 학습 비용이 발생한다 [32, 33]. 규칙에 대한 지식 공유와 문서화가 동반되지 않으면, 개발자들이 임의로 하위 폴더나 `/shared` 등에 코드를 쏟아부어 오히려 아키텍처가 망가지는 결과를 낳을 수 있다 [33].
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+
+#### [관계 유형 A (협업/코드 관리 프로세스)]
+- [[Git Branching Strategies]]
+  - 연결 이유: 다수의 개발자가 동시에 코드를 작성할 때 충돌을 방지하고 통합 과정을 관리하기 위한 핵심 규약이기 때문이다 [3, 34].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: Pull Request, 코드 리뷰, 브랜치 명명 규칙, Trunk-based 워크플로우 등 실제 팀 운영 방식 [7, 35].
+- [[Commit Message Conventions]]
+  - 연결 이유: 변경 사항의 의도와 작업 내역(버그 픽스, 기능 추가 등)을 다른 팀원들에게 명확히 전달하는 소통의 도구이기 때문이다 [36].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 티켓 ID 통합, `feat:`, `fix:`와 같은 접두사를 통한 변경 이력의 자동화 및 스캐닝 [14, 36, 37].
+
+#### [관계 유형 B (아키텍처 및 거버넌스 도구)]
+- [[Feature-Sliced Design]]
+  - 연결 이유: 코드를 기술적 계층이 아닌 비즈니스 기능(Feature) 중심으로 분리하여, 여러 팀이 서로 간섭 없이 독립적으로 작업할 수 있는 환경을 제공한다 [16, 38].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 도메인 주도 설계의 프론트엔드 적용, 명시적 퍼블릭 API를 통한 모듈 캡슐화와 결합도 낮추기 [38-40].
+- [[Automated Governance]]
+  - 연결 이유: 사람의 수동 확인에 의존하지 않고 ESLint, Prettier, Husky 등으로 코드 컨벤션과 아키텍처 룰(의존성 방향 등)을 시스템적으로 강제한다 [6, 20].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: CI/CD 파이프라인에서의 코드 품질 보증 및 팀원 간의 스타일 분쟁 방지 [20].
+- [[Redux vs Zustand in Teams]]
+  - 연결 이유: 팀의 규모(소규모 vs 엔터프라이즈)에 따라 상태 관리 도구의 선택이 협업의 일관성에 결정적인 영향을 미치기 때문이다 [5, 24, 27].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 개발자의 자율성 부여와 일관성 강제(Boilerplate) 사이의 아키텍처적 트레이드오프 [22, 41].
+
+### Deeper Research Questions
+
+- 소규모 팀(2~5인)에서 대규모 팀(10인 이상)으로 확장할 때 Git 워크플로우와 브랜칭 전략은 어떻게 진화해야 하는가?
+- Feature-Sliced Design(FSD)을 프로젝트에 도입할 때, 팀원들이 공통 모듈을 `/shared` 폴더에 무분별하게 추가하는 것을 방지할 수 있는 구체적인 거버넌스 전략은 무엇인가?
+- ESLint와 Husky를 활용한 자동화 거버넌스 설정 시, 개발 속도를 늦추지 않으면서 모듈 간 잘못된 의존성(상위 레이어 참조 등)을 원천 차단하는 최적의 규칙 구성은 무엇인가?
+- 상태 관리 라이브러리(Redux vs Zustand)의 선택이 팀원 간의 비동기 로직 및 데이터 패칭(Fetching) 패턴의 파편화에 미치는 실제 영향은 무엇인가?
+- Pull Request 기반의 협업 환경에서, 시각적 회귀 테스트 도구(예: Storybook, Chromatic)가 코드 리뷰의 병목 현상을 어떻게 해소할 수 있는가?
+
+### Practical Application Contexts
+
+- **Implementation:** 코드를 커밋하고 PR을 생성할 때, 반드시 정해진 Conventional Commits 규칙을 따르고 JIRA 등의 이슈 티켓 번호를 브랜치와 커밋에 기입하여 추적성을 보장한다 [14, 37].
+- **System Design:** 프로젝트 폴더 구조 설계 시 기술적 파일 타입(컴포넌트, 훅 등)의 나열이 아닌, 인증, 대시보드 등 기능(Feature) 도메인 단위로 격리시켜 각 기능별로 전담 개발자가 병렬로 작업할 수 있도록 한다 [2, 42, 43].
+- **Operation / Maintenance:** CI/CD 파이프라인과 Git Hooks(Husky)를 세팅하여, 누군가 컨벤션을 어긴 코드를 푸시하려고 할 때 사전에 린터와 포매터가 작동해 잘못된 코드가 원격 브랜치에 올라가는 것을 차단한다 [20].
+- **Learning Path:** 신규 입사자나 팀원이 배정되었을 때, `README`에 명시된 팀의 브랜칭 전략 규칙과 폴더 디렉토리 설계 의도를 먼저 학습하게 하여 프로젝트 온보딩 시간을 단축한다 [2, 44].
+- **My Project Relevance:** 다수의 프론트엔드 개발자가 함께 참여하는 리액트 프로젝트에서, 코드 충돌과 기술 부채를 방지하고 일관된 제품 품질을 유지하기 위해 필수적으로 수립해야 하는 협업 그라운드 룰(Ground Rules)이다.
+
+### Adjacent Topics
+
+- [[Code Review Practices]]
+  - 확장 방향: 작은 단위의 Pull Request 유지, 시각적 리뷰 도구의 도입, 효율적인 동료 피드백 제공 등 코드 리뷰 자체의 품질과 속도를 높이는 방법론 [37, 45].
+- [[CI/CD Pipelines]]
+  - 확장 방향: 팀원의 코드가 `main`에 병합되기 전, 자동으로 테스트와 린팅을 수행하고 배포까지 이어지는 인프라 및 데브옵스 환경 [7].
+- [[Visual Regression Testing]]
+  - 확장 방향: Storybook 및 Chromatic을 활용해 UI 변경 사항을 리뷰어가 시각적으로 직접 확인하고, 예기치 않은 레이아웃 깨짐을 방지하는 협업 기술 [45, 46].
+
+---
+*Last updated: 2026-04-30*
\ No newline at end of file
diff --git a/10_Wiki/Management/Version Control.md b/10_Wiki/Management/Version Control.md
new file mode 100644
index 00000000..2da5260d
--- /dev/null
+++ b/10_Wiki/Management/Version Control.md	
@@ -0,0 +1,69 @@
+# [[Version Control]]
+
+## 📌 Brief Summary
+버전 관리(Version Control)는 소규모부터 대규모 팀에 이르기까지 코드의 변경 사항을 추적하고, 병합 충돌을 방지하며 안정적인 배포를 가능하게 하는 필수적인 협업 도구 및 거버넌스 프로세스입니다 [1, 2]. 개발팀은 프로젝트 규모와 팀의 숙련도에 따라 Feature-Branch 워크플로우, Trunk-based 개발, Git Flow 등 다양한 브랜칭 전략을 선택하여 사용합니다 [3, 4]. 효과적인 버전 관리는 브랜치와 커밋에 티켓 ID 연동, 의미 있는 커밋 메시지 작성, 작고 빈번한 커밋, 그리고 엄격한 풀 리퀘스트(PR) 리뷰 등의 모범 사례를 준수하여 코드베이스의 품질과 추적성을 유지하는 것을 목표로 합니다 [2, 5].
+
+## 📖 Core Content
+* **주요 브랜칭 전략 (Branching Strategies)**
+  * **Feature-Branch Workflow**: 2~5인 규모의 소규모 팀에게 가장 권장되는 단순하고 충돌이 적은 방식입니다 [6]. `main` 브랜치는 항상 안정적이고 배포 가능한 상태를 유지하며, 각 기능이나 버그 수정은 `main`에서 분기된 짧은 수명의 개별 브랜치에서 진행됩니다 [6, 7].
+  * **Trunk-Based Development**: 짧은 기능 브랜치를 활용하여 메인 브랜치(Trunk)에 코드를 빠르고 빈번하게 병합하는 전략으로, 강력한 CI/CD 환경과 경험이 많은 팀에게 적합합니다 [8, 9].
+  * **Git Flow & GitHub Flow**: Git Flow는 별도의 릴리스 브랜치 등을 두어 스케줄에 따른 대규모 프로젝트를 관리하기 좋지만, 작은 팀에게는 절차가 무겁습니다 [9]. 반면 GitHub Flow는 더 단순하며 빠른 통합을 지향합니다 [10].
+
+* **명명 규칙 및 추적성 (Naming Conventions & Traceability)**
+  * **브랜치 명명 (Branch Naming)**: 브랜치 이름에는 작업의 유형과 티켓 ID, 짧은 설명을 포함하는 것(예: `feature/PROJ-123-user-auth`)이 권장되며, 일관성 있게 소문자와 하이픈을 사용해야 합니다 [11, 12].
+  * **커밋 메시지 (Commit Messages)**: 'Conventional Commits' 사양을 따라 `feat:`, `fix:`, `docs:`, `refactor:`, `chore:` 등의 접두사를 사용하여 변경 목적을 명확히 해야 합니다 [5, 13]. 커밋은 논리적인 단일 변경 사항만을 포함하는 '원자적 커밋(Atomic Commits)' 형태여야 합니다 [14].
+
+* **병합 및 리뷰 프로세스 (Merging and Code Review)**
+  * **Pull Request (PR)**: 코드를 `main`에 병합하기 전 반드시 PR을 열어 최소 1명 이상의 동료 리뷰를 거치고 CI 테스트를 통과해야 합니다 [15, 16]. 리뷰가 쉽게 진행되도록 PR은 작게 유지해야 합니다 [13].
+  * **충돌 예방 및 정리**: 병합 충돌을 피하기 위해 `main` 브랜치의 최신 변경 사항을 자주 가져와 동기화(pull/rebase)해야 하며, 병합할 때는 'Squash & Merge'를 사용하여 커밋 히스토리를 깔끔하게 유지하고 병합 후에는 사용한 브랜치를 자동 삭제하는 것이 좋습니다 [15, 17, 18].
+
+## ⚖️ Trade-offs & Caveats
+* **오버헤드 vs. 제어력**: Git Flow와 같이 구조화되고 무거운 프로세스는 대규모 애플리케이션의 릴리스 일정을 관리하기 좋지만, 소규모 팀에게는 프로세스 오버헤드가 너무 커서 개발 속도를 저하시킬 수 있습니다 [9, 19]. 반대로 너무 단순한 전략은 엄격한 제어가 필요한 대형 프로젝트에서 문제를 일으킬 수 있으므로 팀 규모와 요구사항에 맞춘 전략 선택이 필요합니다 [20].
+* **Trunk-Based 개발의 제약사항**: 병합 충돌을 최소화하고 빠른 피드백을 제공하지만, 개발팀의 높은 숙련도와 강력한 CI 검증 파이프라인이 전제되어야 합니다 [9]. 또한, 미완성된 기능이 병합될 위험이 있으므로 기능 플래그(Feature flags)를 추가로 도입해야 하는 제약이 발생합니다 [19].
+* **장기 브랜치(Long-lived Branches)의 반대급부**: 기능 개발을 위해 브랜치를 너무 오래 유지하면 병합 시점에 엄청난 코드 충돌(merge conflicts)을 처리해야 하는 위험이 있습니다 [12, 21]. 따라서 충돌을 방지하기 위해서는 작업자가 매일 `main` 브랜치와 동기화하는 지속적인 유지보수 노력을 기울여야 합니다 [18].
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+
+#### [워크플로우 및 방법론 (Workflow Strategies)]
+- [[Feature Branch Workflow]]
+  - 연결 이유: 버그 수정이나 새 기능 개발 시 `main`과 분리된 독립적이고 짧은 수명의 브랜치를 사용하는 전략이기 때문입니다. [6, 7]
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 어떻게 `main` 브랜치의 안정성을 훼손하지 않으면서도 다수의 개발자가 코드를 작성하고 충돌을 방지할 수 있는지 이해할 수 있습니다.
+- [[Trunk-Based Development]]
+  - 연결 이유: 모든 개발자가 빈번하게 짧은 주기로 메인 브랜치(Trunk)에 코드를 병합하는 방법론이기 때문입니다. [8, 9]
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 지속적 통합(CI)을 어떻게 보장하며, 장기 브랜치로 인해 발생하는 문제를 어떻게 회피하는지 파악할 수 있습니다.
+- [[Git Flow]]
+  - 연결 이유: 릴리스용 브랜치와 개발용 브랜치를 명확히 나누어 복잡한 프로젝트 릴리스를 관리하는 아키텍처이기 때문입니다. [9, 19]
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 팀의 규모와 배포 스케줄에 따라 워크플로우에 어떤 구조적 레이어를 추가해야 하는지 이해할 수 있습니다.
+
+#### [협업 및 품질 관리 (Quality Assurance & Collaboration)]
+- [[Pull Request (PR)]]
+  - 연결 이유: 코드를 주 브랜치에 병합하기 전, 변경 사항을 동료에게 검토받는 핵심 품질 통제 절차이기 때문입니다. [13, 16]
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 코드 리뷰와 CI 테스트 자동화가 어떻게 실제 코드 품질을 유지하고 팀 내 지식 공유를 돕는지 이해할 수 있습니다.
+- [[Conventional Commits]]
+  - 연결 이유: `feat:`, `fix:`와 같이 표준화된 접두사를 사용하여 커밋 메시지의 의도를 명확하게 만드는 구문 규칙이기 때문입니다. [5, 13]
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 커밋 히스토리를 통한 변경 사항 추적성 확보와 릴리스 노트 자동화에 어떻게 기여하는지 이해할 수 있습니다.
+
+### Deeper Research Questions
+- 소규모 팀(2~5명)이 성장하여 10명 이상의 대규모 조직이 될 때, Feature-Branch 워크플로우에서 Git Flow 등 더 복잡한 전략으로 마이그레이션하는 구체적이고 안전한 방법은 무엇인가? [9, 20]
+- Trunk-based 개발 환경에서 불완전한 코드를 배포하지 않기 위해 사용하는 기능 플래그(Feature Flags)는 버전 관리 및 브랜칭 전략의 복잡성에 어떤 영향을 미치는가? [19]
+- Pull Request 완료 시 'Squash & Merge' 방식과 'Merge Commit' 방식 간의 커밋 히스토리 가독성 및 롤백 용이성 차이는 어떻게 나타나는가? [15, 17, 18]
+- 브랜치 이름과 커밋 메시지에 티켓 ID를 의무적으로 포함하는 거버넌스는, 실제 이슈 트래킹 도구(예: JIRA) 및 CI/CD 파이프라인과 결합 시 어떤 자동화 혜택을 제공하는가? [2, 10]
+- 장기 기능 브랜치(Long-lived feature branches)로 인해 발생하는 거대한 병합 충돌을 피하기 위해 팀은 일일 작업에서 어떤 동기화 패턴을 습관화해야 하는가? [18, 21]
+
+### Practical Application Contexts
+- **Implementation:** 브랜치 생성 시 `feature/PROJ-123-user-auth`처럼 티켓 ID를 포함하는 명명 규칙을 적용하고, `feat: add login form` 등의 Conventional Commits 형식을 사용하여 구현 이력을 체계적으로 관리합니다 [10, 11].
+- **System Design:** 코드를 하나의 논리적 단위로 분리하는 원자적 커밋(Atomic Commits) 규칙을 도입하고, CI/CD 체크가 통과되고 1인 이상이 승인해야만 `main`에 병합 가능하도록 브랜치 보호(Branch Protection) 시스템을 설계합니다 [14, 15].
+- **Operation / Maintenance:** `main` 브랜치는 항상 안정적이고 배포 가능한(deployable) 상태를 유지하도록 운영하며, 병합 완료 후 사용이 끝난 기능 브랜치를 자동 삭제 설정하여 저장소를 깔끔하게 유지합니다 [7, 15, 18].
+- **Learning Path:** 처음에는 복잡한 룰 없이 단순한 Feature-Branch 워크플로우와 명확한 네이밍 규칙을 익히고, 숙련도가 높아지면 자동화된 CI 환경 하의 Trunk-Based 개발 또는 복잡한 버전 관리를 위한 Git Flow로 학습을 확장합니다 [9, 19, 20].
+- **My Project Relevance:** 프론트엔드/React 개발 프로젝트 등의 팀 단위 협업 시, 불필요한 절차 없이 코드 충돌을 최소화하고 추적 가능한 변경 내역을 보장하는 협업 기준을 마련하는 데 즉각적으로 활용할 수 있습니다 [1, 22].
+
+### Adjacent Topics
+- [[Continuous Integration / Continuous Deployment (CI/CD)]]
+  - 확장 방향: PR 단계에서 자동화된 테스트 및 린팅을 실행하고, 메인 브랜치 병합 시 배포를 자동화하여 버전 관리 도구와 어떻게 시너지를 내는지 조사. [1, 19]
+- [[Issue Tracking Systems]]
+  - 확장 방향: JIRA나 GitHub Issues 등의 도구가 Git의 티켓 ID 거버넌스와 결합되어 요구사항부터 코드 변경까지 어떻게 완벽한 추적성(Traceability)을 보장하는지 조사. [2, 23]
+
+---
+*Last updated: 2026-04-30*
\ No newline at end of file
diff --git a/10_Wiki/Technical_Reports/system_analysis_and_improvement_plan.md b/10_Wiki/Technical_Reports/system_analysis_and_improvement_plan.md
new file mode 100644
index 00000000..cf92d5ac
--- /dev/null
+++ b/10_Wiki/Technical_Reports/system_analysis_and_improvement_plan.md
@@ -0,0 +1,27 @@
+# ConnectAI 기술 부채 및 아키텍처 개선 계획 (Python Core)
+
+## 📌 핵심 진단 요약
+현재 ConnectAI의 Python 기반 추론 엔진은 알고리즘 비효율성($O(N^2)$), 동기식 I/O 블로킹, 강한 결합도(Tight Coupling)로 인해 성능 확장이 제한된 상태임. 이를 프로덕션 수준으로 끌어올리기 위한 단계별 최적화가 필요함.
+
+## 🛠️ 최적화 전략 (Phase 2: Core Optimization)
+
+### 1. 알고리즘 효율화 (Performance P1)
+- **현상**: `InferenceEngine.py`의 `feature_match_brute_force` 함수가 중첩 루프로 인해 $O(N^2)$ 복잡도 가짐.
+- **해결**: **KD-Tree** 또는 행렬 분해 기법을 도입하여 $O(N \log N)$으로 최적화. 추론 지연 시간 5~10배 단축 목표.
+
+### 2. 비동기 I/O 전환 (Throughput P1)
+- **현상**: `DataLoader.py`의 `load_dataset_sync` 함수가 동기식으로 동작하여 I/O 대기 시 CPU 유휴 발생.
+- **해결**: `asyncio` 기반 비동기 I/O 또는 스레드 풀 기반 병렬 처리를 도입하여 처리량(Throughput) 개선.
+
+### 3. 모듈 디커플링 (Maintainability P2)
+- **현상**: `PreprocessingModule`과 `CoreModel` 간의 직접 의존성으로 인한 강한 결합.
+- **해결**: **관찰자 패턴(Observer Pattern)** 도입. `DataReadyEvent` 발행-구독 모델을 통해 모듈 간 독립성 및 테스트 용이성 확보.
+
+## 🚀 구현 가이드라인
+- **Step 1**: 알고리즘 최적화 (KD-Tree 구현 및 검증)
+- **Step 2**: 비동기 I/O 전환 (async/await 래핑 및 이벤트 루프 통합)
+- **Step 3**: 아키텍처 디커플링 (이벤트 시스템 구축 및 DIP 실현)
+
+---
+*분석 일자: 2026-04-30*
+*우선순위: Step 1 (ROI 최상) > Step 2 > Step 3*
diff --git a/10_Wiki/Topics_Art/Visual Regression Testing.md b/10_Wiki/Topics_Art/Visual Regression Testing.md
new file mode 100644
index 00000000..7711b648
--- /dev/null
+++ b/10_Wiki/Topics_Art/Visual Regression Testing.md	
@@ -0,0 +1,57 @@
+# [[Visual Regression Testing]]
+
+## 📌 Brief Summary
+시각적 회귀 테스트(Visual Regression Testing)는 스토리북(Storybook) 등의 도구로 렌더링된 컴포넌트의 픽셀 단위 스크린샷을 캡처하여 이전에 알려진 "정상(baseline)" 상태의 스크린샷과 자동으로 비교하는 테스트 방식이다 [1, 2]. 이를 통해 개발자는 풀 리퀘스트(PR) 과정에서 의도치 않은 UI 레이아웃, 색상, 타이포그래피 등의 시각적 변경이나 결함을 찾아낼 수 있다 [3-5]. HTML 마크업만 비교하는 기존의 스냅샷 테스트와 달리, 실제 사용자가 경험하는 화면 픽셀을 직접 검증하므로 추가적인 테스트 코드 작성이나 유지보수 부담을 줄이면서도 오탐(false positive)을 최소화할 수 있는 것이 특징이다 [1, 2].
+
+## 📖 Core Content
+*   **작동 원리 및 프로세스:** 시각적 회귀 테스트는 코드가 변경되었을 때 모든 스토리(story)를 실제 브라우저(Chrome, Firefox, Safari 등) 환경에서 렌더링하고, 해당 화면을 캡처하여 기존의 기준선(baseline)과 비교한다 [4, 6]. 만약 레이아웃이나 색상 등에 의도치 않은 변화가 감지되면 해당 차이점을 강조하여 PR에서 수동 검토를 거치게 함으로써 시각적 결함이 프로덕션으로 배포되는 것을 차단한다 [3, 6, 7]. 변경 사항이 의도된 것이라면 개발자가 새로운 기준선으로 승인(accept)하여 로컬 및 CI 환경에 동기화할 수 있다 [7, 8].
+*   **스냅샷 테스트(Snapshot Testing)와의 차이점:** 기존 스냅샷 테스트는 렌더링된 HTML 마크업 블록을 비교하기 때문에, 코드가 변경되었으나 사용자에게 보이는 실제 시각적 변경이 없는 경우에도 테스트가 실패하는 오탐(false positive)이 발생하기 쉽다 [2]. 반면 시각적 회귀 테스트는 렌더링된 픽셀 자체를 비교하므로 사용자가 실제로 경험하는 UI의 모양, 간격, 반응형 동작 등을 훨씬 더 정확하고 풍부하게 검증할 수 있다 [2, 5].
+*   **인터랙션(Interaction) 기반 상태 검증:** 컴포넌트의 로딩, 에러, 호버(hover), 메뉴 열림 등의 다양한 UI 상태를 검증하기 위해 스토리북의 인터랙션 테스트와 시각적 회귀 테스트를 결합할 수 있다 [9]. 인터랙션 테스트를 통해 컴포넌트를 특정 상태로 만든 후 스크린샷을 찍음으로써 동적인 행동에 대한 시각적 결함 유무까지 하나의 워크플로우 안에서 파악할 수 있다 [9, 10].
+*   **CI 파이프라인 자동화:** 이 테스트는 GitHub Actions, GitLab Pipelines 등 CI 환경과 원활하게 통합되어 풀 리퀘스트(PR)마다 자동으로 실행된다 [11, 12]. 테스트가 완료되면 PR에 UI 변경 사항에 대한 알림(badge)을 제공하여, 리뷰어가 모든 상태를 일일이 확인하는 대신 변경된 부분(diffs)에만 집중해서 리뷰할 수 있도록 돕는다 [6, 12].
+
+## ⚖️ Trade-offs & Caveats
+*   **미세한 픽셀 차이로 인한 노이즈(Flakiness):** 브라우저의 이미지 압축 노이즈나 안티앨리어싱(anti-aliasing) 처리 등 아주 미세한 픽셀 차이 때문에 실제로는 결함이 아님에도 불구하고 시각적 변경으로 감지되는 테스트 불안정성(Flake)이 발생할 수 있다 [11, 13]. 이를 방지하기 위해 시각적 테스트 도구에서는 색상 차이 허용치(color-delta tolerance) 임계값을 설정하여 해당 범주 아래의 차이는 노이즈로 무시하는 최적화 작업이 요구된다 [10, 13].
+*   **비동기 요소 및 애니메이션 제어의 필요성:** 컴포넌트에 포함된 애니메이션이나 비동기 에셋, 폰트 등이 완전히 렌더링되기 전에 스크린샷이 캡처되면 매번 다른 결과가 나와 일관된 테스트가 불가능해진다 [10, 11]. 따라서 시각적 회귀 테스트 도구(Happo 등)는 캡처 전 애니메이션을 자동으로 음소거(silence) 처리하거나 비동기 요소의 로딩을 강제로 기다려야 하는 기술적 제약과 추가 설정이 필요하다 [10, 11].
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+
+#### [테스트 및 검증 기술]
+- [[Snapshot Testing]]
+  - 연결 이유: 시각적 회귀 테스트와 대조되는 테스트 방식으로, 픽셀이 아닌 렌더링된 HTML 마크업 코드 덩어리를 비교한다 [2].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: HTML 구조 비교 방식이 왜 빈번하게 오탐(False Positive)을 발생시키는지, 그리고 픽셀 기반 비교가 유지보수에 왜 더 유리한지 명확하게 이해할 수 있다 [2].
+- [[Interaction Testing]]
+  - 연결 이유: 사용자의 상호작용이나 이벤트를 시뮬레이션하여 컴포넌트의 특정 UI 상태를 유도하는 테스트 방식이다 [5, 10].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 정적 UI 화면뿐만 아니라 로딩, 에러, 클릭 시 드롭다운 오픈 등 동적으로 변화하는 UI 상태를 시각적 회귀 테스트가 어떻게 캡처하고 검증하는지 파악할 수 있다 [9, 10].
+
+#### [구현 및 활용 도구]
+- [[Storybook]]
+  - 연결 이유: UI 컴포넌트를 애플리케이션의 복잡한 로직과 분리하여 격리된 환경에서 시각적으로 개발하고 문서화할 수 있게 해주는 도구이다 [3, 6].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 시각적 회귀 테스트가 전체 페이지 단위가 아닌 개별 컴포넌트의 상태(Story) 단위로 렌더링되고 기준선과 비교되는 아키텍처적 기반을 이해할 수 있다 [1].
+- [[Chromatic]] / [[Happo]]
+  - 연결 이유: Storybook과 연결되어 실제 브라우저 기반의 스크린샷 캡처, 베이스라인 픽셀 비교, CI/CD 연동 등을 수행하는 시각적 회귀 테스트 클라우드 서비스(도구)이다 [1, 3, 4].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 자동화된 시각적 회귀 테스트가 브라우저 간의 렌더링 차이를 어떻게 병렬로 처리하고 풀 리퀘스트(PR) 프로세스와 어떻게 상호작용하는지 확인할 수 있다 [4, 12].
+
+### Deeper Research Questions
+- Snapshot Testing에서 Visual Regression Testing으로 마이그레이션할 때, 대규모 컴포넌트 라이브러리 환경에서 초기 기준선(baseline) 구축 및 스토리지 유지보수 비용은 어떻게 최적화할 수 있는가?
+- Chromatic이나 Happo와 같은 도구가 크로스 브라우저(Chrome, Safari, Firefox 등)에서 동일한 컴포넌트를 렌더링할 때 발생하는 OS/브라우저 엔진별 미세한 렌더링 차이를 어떻게 처리하고 보정하는가?
+- 시각적 회귀 테스트 파이프라인을 CI/CD에 통합했을 때 빌드 시간 지연을 방지하기 위한 병렬 처리(Parallelization) 및 최적화 전략은 무엇인가?
+- 애니메이션 및 비동기 데이터를 많이 사용하는 복잡한 인터랙티브 컴포넌트에서 테스트의 불안정성(Flakiness)을 코드 레벨에서 근본적으로 제거하려면 컴포넌트를 어떻게 설계해야 하는가?
+- Visual Regression Testing과 Accessibility Regression Testing을 하나의 워크플로우로 결합했을 때, 접근성 위반 사항이 구체적으로 어떤 시각적 지표와 함께 리포트되며 PR 리뷰 프로세스는 어떻게 효율화되는가?
+
+### Practical Application Contexts
+- **Implementation:** Storybook으로 UI 컴포넌트를 개발한 후, Chromatic이나 Happo 등의 애드온을 설치하여 코드 변경 시마다 각 컴포넌트의 상태별 스크린샷을 자동으로 캡처하고 기준선과 비교하도록 설정한다 [4, 14].
+- **System Design:** 프론트엔드 아키텍처 설계 시, 비즈니스 로직과 UI를 철저히 분리하여 컴포넌트를 구축하고, 시각적 검증 시스템을 도입하여 대규모 팀이 동시에 개발하더라도 일관된 디자인 시스템이 훼손되지 않도록 방어 체계를 마련한다 [3, 4].
+- **Operation / Maintenance:** CI 파이프라인(GitHub Actions 등)에 시각적 테스트를 필수 단계로 추가하여, 변경된 디자인 코드가 PR에 올라올 때마다 의도치 않은 레이아웃 깨짐 현상을 자동으로 감지하고 리뷰어에게 시각적 Diff를 제공하여 운영 유지보수 부담을 줄인다 [3, 6, 12].
+- **Learning Path:** React 컴포넌트 기반 UI 작성 → Storybook을 활용한 컴포넌트 문서화 및 CDD(Component-Driven Development) → 인터랙션(Interaction) 테스트 작성 → 시각적 회귀 테스트 자동화 순으로 프론트엔드 품질 검증 파이프라인을 학습한다 [9, 15].
+- **My Project Relevance:** 프론트엔드 레거시 코드를 리팩토링하거나 수백 개의 화면에서 공유되는 코어 UI 라이브러리 버전을 업그레이드할 때, 다른 팀의 컴포넌트에서 발생하는 의도치 않은 파급 효과(Side Effect) 및 시각적 깨짐을 안전하게 감지하고 확신을 갖고 배포하는 데 핵심적인 역할을 한다 [3, 16].
+
+### Adjacent Topics
+- [[Accessibility Regression Testing]]
+  - 확장 방향: 시각적 테스트 워크플로우와 결합하여, 새로운 테스트 코드를 별도로 작성할 필요 없이 스크린샷 실행 단계에서 UI의 접근성 위반(명도 대비 부족, 키보드 포커스 누락 등)까지 동시에 자동 검증하는 영역으로 확장할 수 있다 [9, 10].
+- [[Continuous Integration (CI) Pipelines]]
+  - 확장 방향: GitHub Actions, CircleCI 등의 CI 도구에서 시각적 테스트 인프라가 어떻게 연동되며, 코드가 병합되기 전에 PR의 상태 체크(Status Check)를 필수로 제어하는 자동화 파이프라인 및 DevOps 프로세스로 학습을 넓힐 수 있다 [12].
+
+---
+*Last updated: 2026-04-30*
\ No newline at end of file
diff --git a/10_Wiki/Topics_Biz/Agile Environments.md b/10_Wiki/Topics_Biz/Agile Environments.md
new file mode 100644
index 00000000..dbf3a829
--- /dev/null
+++ b/10_Wiki/Topics_Biz/Agile Environments.md	
@@ -0,0 +1,47 @@
+# [[Agile Environments]]
+
+## 📌 Brief Summary
+Agile Environments(애자일 환경)는 요구사항이 지속적으로 변화하는 프로젝트나 스타트업 환경을 의미합니다 [1]. 이러한 환경에서는 미래에 필요할지도 모르는 복잡한 기능을 미리 개발하기보다는 오직 현재의 요구사항에 집중하는 것이 핵심입니다 [2]. 따라서 각 기능을 독립적으로 생성하고 구현할 수 있는 유연하고 모듈화된 접근 방식이 매우 적합합니다 [3].
+
+## 📖 Core 소스에 관련 정보가 부족합니다.Content
+애자일 환경(Agile Environments)과 관련하여 제공된 소스에서 다루고 있는 구체적인 설명은 다음과 같습니다. 
+
+* **YAGNI 원칙의 중요성**: 애자일 환경에서는 "You Aren't Gonna Need It (YAGNI)" 원칙이 특히 필수적으로 작용합니다 [2]. 변화하는 요구사항을 가진 스타트업이나 애자일 프로젝트에서는, 미래의 사용 사례를 대비하여 복잡한 기능을 미리 구축하는 것을 피해야 합니다 [1, 2]. 개발팀은 오직 현재의 요구사항에만 집중함으로써 나중에 유지보수해야 할 복잡성과 사용되지 않는 코드(dead code)의 양을 최소화할 수 있습니다 [2].
+* **기능 기반 구조(Feature-Based Structure)의 적합성**: 프론트엔드 아키텍처 측면에서 기능 기반 폴더 구조는 애자일 개발 방법론과 매우 잘 맞습니다 [3]. 이 구조에서는 각각의 기능(feature)이 독립적으로 분리되어 생성 및 구현될 수 있기 때문에, 애자일 환경에서 요구하는 유연성과 병렬적인 개발을 효과적으로 지원합니다 [3].
+* *참고: 주어진 소스에는 개발 원칙(YAGNI) 및 폴더 구조(Feature-Based)와 애자일의 연관성만 언급되어 있으며, 스크럼이나 스프린트 등 애자일 환경 자체의 전반적인 프로세스나 이론에 대해서는 소스에 관련 정보가 부족합니다.*
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+- [[YAGNI]]
+  - 연결 이유: 애자일 환경에서 미래의 불확실한 기능을 미리 만들지 않고 현재의 요구사항에 집중하도록 이끄는 가장 핵심적인 개발 원칙입니다 [1, 2].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 애자일 환경에서 불필요한 코드(Dead Code)의 생성을 방지하고 유지보수 비용을 최소화하는 구체적인 판단 기준을 이해할 수 있습니다 [2].
+- [[Feature-Based Structure]]
+  - 연결 이유: 애자일 방법론과 가장 잘 어울리는 아키텍처 패턴으로, 코드 베이스를 기능 단위로 분리하여 독립적인 개발을 가능하게 합니다 [3].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 애자일 팀이 요구사항 변경에 맞춰 여러 기능을 독립적으로 확장하고 개발할 때 파일과 폴더를 어떻게 구성해야 하는지 이해할 수 있습니다 [3].
+- [[Startup Projects]]
+  - 연결 이유: 애자일 환경과 마찬가지로 요구사항이 지속적으로 변화하는 특성을 공유하며, YAGNI 원칙이 강하게 적용되는 대표적인 비즈니스 환경입니다 [1].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 애자일 원칙이 실무에서 어떠한 형태의 프로젝트 규모나 상황(빠른 변화와 유연성 요구)에서 주로 채택되는지 파악할 수 있습니다 [1].
+
+### Deeper Research Questions
+- 애자일 환경에서 YAGNI 원칙을 엄격하게 적용하여 당장의 기능만 개발할 때, 향후 시스템이 확장되면서 발생할 수 있는 기술 부채(Technical Debt)는 어떻게 관리해야 하는가?
+- 요구사항이 끊임없이 변화하는 애자일 프로젝트에서 Feature-Based Structure가 기존의 파일 유형 기반 구조(File-Type Based Structure)보다 팀 협업 및 유지보수에 유리한 구체적 이유는 무엇인가?
+- 스타트업 프로젝트의 초기 단계에서 애자일 원칙(YAGNI, KISS 등)을 적용할 때와, 엔터프라이즈 환경으로 확장(Scaling)될 때 아키텍처 원칙(SOLID 등)의 적용 비중은 어떻게 변화해야 하는가?
+- 기능(Feature)을 독립적으로 분리하여 개발하는 애자일 환경에서, 여러 기능 간에 공유되는 교차 의존성(Cross-cutting concerns)은 구조적으로 어떻게 해결해야 하는가?
+- 애자일 환경의 '현재 요구사항에 대한 집중'과 '장기적인 소프트웨어 아키텍처의 견고함' 사이의 균형을 맞추기 위한 개발 거버넌스는 어떻게 구축해야 하는가?
+
+### Practical Application Contexts
+- **Implementation:** 주어진 스토리나 태스크의 요구사항을 충족하는 데 필요한 최소한의 코드만 우선적으로 구현합니다 (오버엔지니어링 금지) [2].
+- **System Design:** 프로젝트 폴더와 모듈을 기능(Feature)을 중심으로 설계하여, 요구사항이 변경되더라도 다른 기능에 미치는 영향을 최소화하고 독립적인 배포 및 테스트가 가능하게 합니다 [3].
+- **Operation / Maintenance:** 언젠가 쓰일 것이라 예상하고 작성한 불필요한 코드를 배제함으로써, 운영 단계에서 팀이 관리하고 파악해야 할 레거시 코드의 복잡성을 대폭 낮춥니다 [2].
+- **Learning Path:** 애자일 환경에 합류하기 위해 YAGNI 원칙의 적용법과 Feature-Sliced Design과 같은 최신 기능 단위의 모듈형 아키텍처 패턴을 학습합니다 [2, 3].
+- **My Project Relevance:** 잦은 기획 변경이 예상되는 초기 단계의 스타트업 프로젝트나 애자일 조직을 세팅할 때, 초기 개발 속도를 높이면서도 변경에 유연하게 대응하기 위한 가이드라인으로 직결됩니다 [1, 3].
+
+### Adjacent Topics
+- [[SOLID Principles]]
+  - 확장 방향: 애자일 환경에서 당장의 기능을 단순하게 개발(YAGNI)하면서도, 장기적으로 애플리케이션의 규모가 커졌을 때 코드를 어떻게 유지보수 가능하게 설계할지 객체 지향적/구조적 관점에서 이해를 확장할 수 있습니다 [1, 4].
+- [[Clean Code]]
+  - 확장 방향: 빠른 변화와 반복 개발(Iteration)이 일어나는 애자일 환경 속에서, 여러 명의 개발자가 코드를 쉽게 읽고 협업할 수 있도록 하는 기본적인 코드 품질 유지 기법으로 확장이 가능합니다 [4, 5].
+
+---
+*Last updated: 2026-04-30*
\ No newline at end of file
diff --git a/10_Wiki/Topics_Biz/Branching Strategies.md b/10_Wiki/Topics_Biz/Branching Strategies.md
new file mode 100644
index 00000000..0c39642f
--- /dev/null
+++ b/10_Wiki/Topics_Biz/Branching Strategies.md	
@@ -0,0 +1,71 @@
+# [[Branching Strategies]]
+
+## 📌 Brief 소Summary
+Branching Strategies(브랜칭 전략)는 소프트웨어 개발 과정에서 코드 변경 사항을 관리하고 팀원 간의 협업을 조율하기 위해 버전 관리 시스템(Git 등)에서 브랜치를 생성, 병합, 유지보수하는 규칙과 워크플로우를 의미합니다. 팀의 규모와 프로젝트 요구사항에 따라 Git Flow, GitHub Flow, Trunk-Based Development, Feature Branch Workflow 등 다양한 전략이 사용됩니다. 명확한 브랜칭 전략의 도입은 메인 코드베이스의 안정성을 보장하고 병합 충돌을 방지하며 코드 리뷰와 추적성을 강화하는 핵심 역할을 합니다 [1-3].
+
+## 📖 Core Content
+*   **주요 브랜칭 전략 유형**
+    *   **Feature Branch Workflow (기능 브랜치 워크플로우):** 2~5명 규모의 소규모 팀에 가장 초보자 친화적이고 충돌이 적은 워크플로우입니다 [4]. `main` 브랜치는 항상 안정적이고 배포 가능한 상태를 유지하며, 새로운 기능이나 버그 수정 시 `main`에서 파생된 짧은 수명의 브랜치를 생성합니다 [5]. 개발 완료 후 Pull Request(PR)를 열고 최소 1명 이상의 동료 리뷰와 테스트를 거친 후 Squash Merge 방식으로 병합합니다 [6, 7].
+    *   **Trunk-Based Development (트렁크 기반 개발):** 강력한 CI(지속적 통합) 환경을 갖춘 숙련된 팀에 적합한 가벼운 방식입니다 [8, 9]. 수명이 매우 짧은 기능 브랜치를 사용하거나 메인 브랜치에 작은 변경 사항을 자주 커밋합니다. 오버헤드가 최소화되고 피드백이 빠르며 대규모 병합 충돌을 피할 수 있습니다 [8, 10].
+    *   **Git Flow:** 정기적인 릴리스 일정을 가진 대규모 프로젝트에 유용합니다 [9]. 하지만 기능 브랜치 외에도 `develop`, `release` 등 관리해야 할 브랜치가 많아 소규모 팀에게는 무겁고 과도한 복잡성을 유발할 수 있습니다 [9, 11, 12].
+    *   **GitHub Flow:** `main` 브랜치로 기능 브랜치를 직접 병합하는 단순화된 구조로, Git Flow보다 빠르고 지속적인 배포 환경에 적합합니다 [11, 13].
+
+*   **모든 전략에 적용되는 모범 사례 (Best Practices)**
+    *   **티켓 ID 및 명명 규칙 사용:** 브랜치 이름과 커밋 메시지에 요구사항 추적을 위한 티켓 ID(예: `feature/PROJ-123-user-auth`)를 포함해야 합니다 [14, 15]. 브랜치 이름은 케밥 케이스(kebab-case)를 사용하고 짧고 명확하게 작성합니다 [16, 17].
+    *   **원자적 커밋 (Atomic Commits):** 하나의 커밋에는 하나의 논리적 변경 사항만 포함하여 코드 리뷰와 히스토리 추적을 단순화합니다 [7, 18].
+    *   **Conventional Commits 규칙:** 커밋 메시지는 `feat:`, `fix:`, `chore:` 등의 표준화된 접두사를 사용하여 변경의 목적을 명확히 합니다 [19-21].
+    *   **PR 및 병합 규칙:** 코드를 절대 `main`에 직접 푸시해서는 안 되며, 반드시 PR을 통한 리뷰를 거쳐야 합니다 [6, 22]. 병합 후에는 사용이 끝난 브랜치를 즉시 삭제하여 저장소를 정리합니다 [6, 23].
+
+*   **전략 간 마이그레이션 방법**
+    *   프로젝트가 변화함에 따라 전략도 진화할 수 있습니다. 예를 들어 통합 속도를 높이려면 Feature Branch에서 Trunk-Based(기능 플래그 사용 및 수명 단축)로 전환하고, 더 많은 체계가 필요하다면 GitHub Flow에서 Git Flow(`develop` 브랜치 및 릴리스 브랜치 추가)로 마이그레이션할 수 있습니다 [11, 12].
+
+## ⚖️ Trade-offs & Caveats
+*   **구조적 오버헤드 vs. 안정성:** Git Flow는 구조가 명확하고 정기적인 릴리스에 강점이 있지만, 브랜치의 수가 많아 유지보수 비용(오버헤드)이 높습니다 [9]. 반면 Feature Branch나 Trunk-Based 방식은 프로세스가 가벼운 대신 메인 브랜치의 보호(`main` 브랜치 직접 푸시 금지, 엄격한 코드 리뷰 등) 규칙이 강제되지 않으면 코드가 쉽게 깨질 위험이 있습니다 [6, 22].
+*   **기능 브랜치의 수명(Long-lived branches) 문제:** 기능 브랜치나 GitHub Flow를 사용할 때, 브랜치의 수명이 몇 주 이상 길어지면 다른 작업자와의 코드 분기가 심해져 거대한 병합 충돌(Merge conflicts)이 발생할 수 있습니다 [17]. 따라서 매일 `main`의 최신 변경 사항을 Pull 하거나 Rebase하여 충돌을 예방해야 합니다 [7].
+*   **Trunk-Based 개발의 의존성:** 빠른 병합을 지향하는 Trunk-Based Development는 지속적이고 자동화된 테스트 환경(CI)과 미완성 기능을 프로덕션에서 숨기기 위한 기능 플래그(Feature Flags) 구현 등 기술적 뒷받침이 필수적입니다 [9, 11].
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+
+#### [관계 유형 A: 아키텍처/기반 방법론]
+- [[Feature Branch Workflow]]
+  - 연결 이유: 소규모 3~5인 개발 팀에 가장 추천되는 단순하고 직관적인 브랜칭 전략의 기반 개념입니다.
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 메인 브랜치를 오염시키지 않고 새로운 기능을 격리된 환경에서 개발하고 병합하는 방법론을 이해할 수 있습니다.
+- [[Trunk-Based Development]]
+  - 연결 이유: 무거운 워크플로우를 탈피하여 브랜치 생명주기를 극한으로 줄이고 빠른 통합을 중시하는 최신 트렌드 모델입니다.
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: CI/CD 환경에서의 잦은 소규모 배포 방식과 충돌 최소화 전략을 학습할 수 있습니다.
+- [[Git Flow]]
+  - 연결 이유: 브랜칭 전략의 고전적이고 체계적인 형태로서, 대형 프로젝트의 정기적 버저닝 관리를 위해 설계되었습니다.
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: `develop`, `release`, `hotfix` 등 개발 파이프라인에 따른 브랜치의 역할 분리 기법을 이해할 수 있습니다.
+
+#### [관계 유형 B: 구현/활용 도구 및 규칙]
+- [[Pull Request & Code Review]]
+  - 연결 이유: 브랜칭 전략이 안전하게 동작하기 위해 모든 병합 전에 필수적으로 거쳐야 하는 품질 검증 관문입니다.
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 팀원 간의 비동기적 피드백 수렴, 시각적 검증, 그리고 CI 통과를 전제로 한 안전한 병합 과정을 배울 수 있습니다.
+- [[Conventional Commits]]
+  - 연결 이유: 브랜치 병합 내역을 추적하고 가독성을 높이기 위해 전 세계적으로 통용되는 커밋 메시지 작성 표준입니다.
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: `feat(scope): message` 와 같은 형식의 구문을 통해 코드 히스토리 파악 및 문서 자동화를 어떻게 이룰 수 있는지 이해할 수 있습니다.
+
+### Deeper Research Questions
+- Trunk-Based Development를 성공적으로 적용하기 위해 필수적인 자동화 테스트 환경(CI)과 기능 플래그(Feature flags)의 구현 전략은 무엇인가?
+- 소규모 팀이 단일 `main` 브랜치 전략을 사용할 때, 예기치 않은 버그가 배포되는 것을 막기 위한 GitHub 저장소의 브랜치 보호 규칙(Branch Protection Rules) 최적화 방법은 무엇인가?
+- 장기 체류 브랜치(Long-lived branch)에서 발생하는 거대한 병합 충돌을 피하기 위해 `main` 브랜치의 최신 내용을 가져올 때 `merge`와 `rebase` 중 어떤 방식이 이력 관리에 더 효과적인가?
+- 원자적 커밋(Atomic Commits)을 강제하는 정책이 Pull Request 리뷰 시간과 버그 추적성에 어떠한 정량적/정성적 영향을 미치는가?
+- Git Flow 방식에서 GitHub Flow 방식으로 팀의 워크플로우를 마이그레이션할 때 예상되는 혼란 요소와 이를 해결하기 위한 CI/CD 파이프라인의 재구성 방법은 무엇인가?
+
+### Practical Application Contexts
+- **Implementation:** 새로운 기능 개발을 시작할 때, 최신 `main` 브랜치에서 `feature/티켓ID-간단한-설명` 이름으로 브랜치를 파생하고, 원자적 단위로 작은 커밋을 자주 기록합니다.
+- **System Design:** 프론트엔드 모듈 아키텍처 설계 시, 독립적인 피처(Feature) 폴더별로 브랜치를 나누어 개발함으로써 특정 코드 영역 밖으로 병합 충돌의 폭발 반경(Blast radius)이 퍼지지 않도록 합니다.
+- **Operation / Maintenance:** 브랜치가 `main`으로 병합되는 즉시 GitHub Action 등 CI 서버에서 자동으로 린트(ESLint), 테스트(Jest), 포맷팅을 수행하도록 방어막을 구축하여 메인 브랜치의 배포 가능한 상태를 영구적으로 유지합니다.
+- **Learning Path:** Git의 기초 명령어를 습득한 후, 소규모 팀 단위의 Feature Branch Workflow를 실습하고, 이후 CI/CD 도구를 연동한 Trunk-Based 환경으로 발전하는 순서로 학습합니다.
+- **My Project Relevance:** 3~5인 규모의 프로젝트에서 무거운 Git Flow의 도입을 지양하고, '단기 기능 브랜치 → PR 및 1인 이상 피어 리뷰 승인 → Squash Merge 및 브랜치 즉시 삭제'라는 단순화된 룰을 적용하여 개발 속도와 코드 품질을 동시에 챙깁니다.
+
+### Adjacent Topics
+- [[Continuous Integration / Continuous Deployment (CI/CD)]]
+  - 확장 방향: 브랜칭 전략에 의해 트리거(Trigger)되어 실행되는 빌드, 테스트, 배포 파이프라인의 자동화 프로세스를 깊이 알아봅니다.
+- [[Feature-Sliced Design (FSD)]]
+  - 확장 방향: 도메인과 기능 단위로 코드를 분리하는 프론트엔드 아키텍처 방법론으로, 브랜치를 기능별로 나눌 때 충돌을 물리적으로 최소화하는 코드 구조 설계법을 탐구합니다.
+
+---
+*Last updated: 2026-04-30*
\ No newline at end of file
diff --git a/10_Wiki/Topics_Biz/Code Review.md b/10_Wiki/Topics_Biz/Code Review.md
new file mode 100644
index 00000000..5436d57b
--- /dev/null
+++ b/10_Wiki/Topics_Biz/Code Review.md	
@@ -0,0 +1,56 @@
+# [[Code Review]]
+
+## 📌 Brief Summary
+코드 리뷰(Code Review)는 개발자가 작성한 코드를 메인 브랜치에 병합하기 전에 팀원(동료)이 검토하여 승인하는 품질 관리 및 협업 프로세스입니다 [1, 2]. 주로 Pull Request(PR) 단계를 통해 이루어지며, 단독으로 잘못된 코드가 병합되는 것을 방지하고 팀 내 빠른 피드백 루프를 형성합니다 [1]. 최근 프론트엔드 환경에서는 단순한 코드 검토를 넘어 Storybook과 같은 도구를 CI 파이프라인과 결합한 '시각적 리뷰(Visual Review)'로 확장되어 의도치 않은 UI 변경을 방지하는 역할도 수행합니다 [3].
+
+## 📖 Core 소스에 기반한 Core Content
+- **동료 검토(Peer Review)의 역할 및 이점**: 개발자는 기능 브랜치(feature branch)에서 작업을 마친 후 병합을 위한 Pull Request(PR)를 생성하며, 이때 최소 1명 이상의 팀원에게 검토와 승인을 받아야 합니다 [1, 4]. 리뷰어는 변경된 코드에 대해 코멘트를 남기며, 작성자가 이를 수정하고 재푸시(push)하여 최종 승인을 받으면 병합이 이루어집니다 [5]. 이는 단일 개발자의 실수로 인한 잘못된 병합을 막고, 팀원 간의 건전한 리뷰 습관과 협업을 촉진합니다 [1, 6].
+- **효율적인 PR 에티켓**: 원활한 코드 리뷰를 위해서는 PR을 작게 유지하고 단일 작업(Single task)에 집중하는 것이 모범 사례입니다 [2]. 리뷰어가 한 번에 2,000줄 이상의 방대한 코드를 검사하도록 요구해서는 안 되며, PR 규모가 작을수록 더 빠르고 철저하게 검토될 수 있습니다 [2, 7].
+- **시각적 리뷰(Visual Review)의 도입**: 프론트엔드 개발의 PR 프로세스에서는 코드의 논리 검토뿐만 아니라 시각적 회귀(Visual Regression) 검토가 필수가 되었습니다 [3]. 개발자는 Storybook을 활용해 컴포넌트를 분리하여 구축하고, Chromatic이나 Happo 등의 도구를 CI 파이프라인에 통합합니다 [3, 8]. 
+- **자동화된 시각적 회귀 감지**: PR이 열리면 이 도구들이 여러 브라우저 및 뷰포트 환경에서 자동으로 모든 UI 상태의 스크린샷을 캡처하고 이전 기준선(baseline)과 비교합니다 [9, 10]. 레이아웃이나 색상 등에 의도치 않은 변경 사항이 발견되면 PR에 해당 사항이 수동 검토 대상으로 표시(flagged)되어 버그가 프로덕션 환경으로 배포되는 것을 차단합니다 [3]. 더불어, 시각적 검토 도구는 시각적 변경 사항과 함께 새로운 접근성 위반(accessibility violations)까지 포착할 수 있습니다 [9, 11].
+
+## ⚖️ Trade-offs & Caveats
+- **리뷰 병목 현상 및 복잡도 증가**: 한 번에 수천 줄에 달하는 큰 규모의 코드(PR)를 리뷰하도록 요청할 경우, 리뷰어가 코드를 철저히 감사(audit)하기 어려워 리뷰 속도와 품질이 모두 저하되는 문제가 발생합니다 [2]. 이를 피하기 위해서는 PR을 매우 작게 나누어 지속적으로 리뷰해야 하므로, 개발자는 작업 단위를 세밀하게 쪼개야 하는 추가적인 노력이 필요합니다 [2, 7].
+- **시각적 테스트의 불안정성(Flake) 이슈**: 시각적 리뷰를 위해 스크린샷 기반 테스트를 도입할 때, 컴포넌트의 기능적 변경이 없더라도 압축 노이즈, 안티앨리어싱, 비동기 에셋(폰트 등), 애니메이션 등으로 인해 미세한 픽셀 차이가 발생하여 오류로 처리되는 거짓 양성(False positive) 문제가 생길 수 있습니다 [8, 12]. 이를 해결하기 위해 색상 오차 허용 범위(color-delta tolerance)를 설정하거나 애니메이션을 음소거하는 등의 추가적인 구성(Configuration)과 관리가 요구됩니다 [8, 12, 13].
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+
+#### [협업 및 형상 관리 워크플로우]
+- [[Pull Request (PR)]]
+  - 연결 이유: 코드 리뷰가 실질적으로 요청되고, 검토 피드백이 오가는 핵심 플랫폼이자 단위입니다 [1, 2].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 브랜치 병합 전 품질 관리 게이트로서의 기능과 짧고 명확한 작업 단위 분할의 중요성을 파악할 수 있습니다.
+
+- [[Feature Branch Workflow]]
+  - 연결 이유: 코드 리뷰 시스템을 쉽게 도입하기 위한 가장 기본적이고 충돌이 적은 브랜치 전략입니다 [14, 15].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 메인 브랜치를 항상 안정적으로 유지하면서, 각각의 태스크를 독립된 브랜치에서 작업하고 리뷰를 통해 검증하는 전체 흐름을 이해할 수 있습니다.
+
+#### [자동화 및 품질 검증 도구]
+- [[Visual Regression Testing]]
+  - 연결 이유: 프론트엔드 코드 리뷰 시 육안으로 확인하기 힘든 의도치 않은 레이아웃/색상 변경을 자동화 도구가 시각적으로 찾아내어 리뷰어에게 제시합니다 [3, 9].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: Chromatic이나 Happo를 CI 파이프라인과 결합하여 PR 리뷰의 정확도를 높이고 안정적인 UI를 배포하는 프로세스를 배울 수 있습니다.
+
+### Deeper Research Questions
+
+- PR의 크기를 작게 유지하고 단일 작업(Single task)에 집중하도록 논리적으로 작업을 분할하는 가장 효과적인 방법론과 기준은 무엇인가?
+- 대규모 팀에서 쏟아지는 수많은 PR과 코드 리뷰 요청을 병목 현상 없이 효율적으로 처리하고 배포 속도를 유지하기 위한 전략은 무엇인가?
+- 시각적 회귀 테스트(Visual Regression Testing) 시 발생하는 미세한 렌더링 차이(Flake)를 방지하고 신뢰할 수 있는 기준선(Baseline)을 유지하기 위한 구체적인 구성 최적화 방법은 무엇인가?
+- 코드 리뷰 시 시각적 회귀(Visual changes) 감지뿐만 아니라, 접근성 테스트(Accessibility tests)를 함께 자동화했을 때 얻게 되는 이점과 이를 처리하는 내부 동작 원리는 무엇인가?
+- 기능 분기(Feature branch)의 수명이 길어졌을 때 발생하는 리뷰 및 병합 충돌 문제를 해결하고, 지속적으로 짧은 주기의 리뷰를 유도하는 문화는 어떻게 정착시킬 수 있는가?
+
+### Practical Application Contexts
+
+- **Implementation:** 코드를 커밋하고 PR을 생성할 때, 리뷰어가 쉽게 코드를 파악할 수 있도록 200줄 미만의 작은 단위로 변경 사항을 쪼개어 올리고 무엇이 왜 변경되었는지 명확히 명시해야 합니다 [2, 7].
+- **System Design:** 프론트엔드 설계 시 Storybook을 활용하여 모든 UI 컴포넌트의 다양한 상태(loading, error 등)를 캡슐화해 두면, 코드 리뷰 시에 이 상태들을 자동으로 스크린샷으로 찍어 검증할 수 있는 기반 시스템이 만들어집니다 [16].
+- **Operation / Maintenance:** CI/CD 파이프라인 단계에 Chromatic이나 Happo 같은 도구를 연동시켜, 팀원이 PR을 생성할 때마다 시각적 변동 사항(diff)이나 접근성 위반 내역이 PR 체크 리스트에 배지로 자동 보고되도록 운영 환경을 구축합니다 [17].
+- **Learning Path:** Git의 기초적인 브랜치 사용법을 배운 후, 팀 협업의 핵심인 PR 생성 및 리뷰 요청 과정(GitHub Flow 등)을 익히고, 나아가 시각적 테스팅 도구가 PR에 어떻게 피드백을 주는지를 실습해보는 흐름으로 학습할 수 있습니다 [8, 18].
+- **My Project Relevance:** 소규모 3인 팀 프로젝트를 진행할 때 복잡한 Git-Flow 대신 기능 브랜치 워크플로우를 채택하고, 코드 병합 시 반드시 1명 이상의 피어 리뷰(Peer review)를 받도록 규칙을 정해 버그 없는 안정적 메인 브랜치를 유지할 수 있습니다 [1, 14].
+
+### Adjacent Topics
+
+- [[Continuous Integration (CI)]]
+  - 확장 방향: PR이 올라왔을 때 코드 리뷰를 돕기 위해 사전에 테스트 통과 여부, 빌드 성공 여부 등을 자동으로 검사해주는 자동화 파이프라인의 구축에 대해 학습할 수 있습니다 [7, 19].
+
+---
+*Last updated: 2026-04-30*
\ No newline at end of file
diff --git a/10_Wiki/Topics_Biz/Git Workflow.md b/10_Wiki/Topics_Biz/Git Workflow.md
new file mode 100644
index 00000000..5dc64fac
--- /dev/null
+++ b/10_Wiki/Topics_Biz/Git Workflow.md	
@@ -0,0 +1,75 @@
+# [[Git Workflow]]
+
+## 📌 Brief Summary
+Git Workflow(깃 워크플로우)는 팀 환경에서 코드 변경 사항을 관리하고 협업하기 위한 체계적이고 구조화된 접근 방식입니다 [1, 2]. 이는 기능 브랜치(Feature-branch), 트렁크 기반(Trunk-based), Git Flow 등 다양한 전략을 포괄하며, 충돌을 방지하고 `main` 브랜치의 배포 가능 상태를 보장하는 것을 목표로 합니다 [2-4]. 일관된 브랜치 명명 규칙, 커밋 메시지 규약, 풀 리퀘스트(PR)와 리뷰 절차를 도입함으로써 잠재적인 혼돈을 예측 가능한 릴리스 흐름으로 전환할 수 있습니다 [1, 5, 6].
+
+## 📖 Core Content
+*   **주요 브랜칭 전략 (Main Branching Strategies):**
+    *   **Feature-Branch Workflow (기능 브랜치 워크플로우):** 주 브랜치(`main`)를 항상 안정적이고 배포 가능한 상태로 유지하며, 새로운 작업이나 버그 수정마다 짧은 수명의 기능 브랜치(예: `feature/login`)를 생성하여 작업합니다 [3, 4, 7]. 소규모 팀에 매우 적합하며, 오버헤드 없이 코드를 안전하게 통합할 수 있습니다 [4, 8].
+    *   **Trunk-Based Development (트렁크 기반 개발):** 강력한 CI(지속적 통합) 환경을 갖춘 경험 많은 팀에 적합한 방식으로, 아주 짧은 수명의 브랜치를 사용해 자주 `main`에 코드를 병합하여 통합 속도를 높입니다 [8, 9].
+    *   **Git Flow:** `develop` 및 `release` 등 다수의 브랜치를 운영하며 스케줄된 릴리스를 관리하는 대규모 프로젝트에 적합하지만, 소규모 팀에게는 너무 복잡하고 무거울 수 있습니다 [8, 10].
+    *   **GitHub Flow:** 기능을 기능 브랜치에서 작업한 뒤 풀 리퀘스트를 통해 리뷰받고 병합하여, `main`에서 바로 배포하는 방식입니다 [11, 12].
+
+*   **명명 규칙 및 추적성 (Naming Conventions & Traceability):**
+    *   **브랜치 이름:** 브랜치 목적을 명확히 하기 위해 `feature/`, `bugfix/`와 같은 접두사를 사용하며, 티켓 ID를 함께 포함(예: `feature/PROJ-123-user-auth`)하여 이슈 트래커와의 추적성을 확보해야 합니다 [13-15]. 
+    *   **커밋 메시지:** `type(scope): description` 형태를 따르는 "Conventional Commits" 규약을 사용하는 것이 좋습니다 [6, 16]. 예를 들어 새로운 기능은 `feat:`, 버그 수정은 `fix:`, 문서 수정은 `docs:` 등으로 시작하여 변경의 의도를 명확히 합니다 [6, 16].
+
+*   **풀 리퀘스트와 병합 (Pull Requests & Merging):**
+    *   `main` 브랜치에 직접 푸시(Push)하는 것을 금지하고, 반드시 풀 리퀘스트(PR)를 생성하여 최소 1명 이상의 동료에게 코드 리뷰를 받아야 합니다 [13, 17].
+    *   코드 리뷰 속도와 품질을 위해 PR은 작고 논리적인 단일 변경 사항(Atomic Commits) 단위로 유지해야 합니다 [16, 18].
+    *   병합 시에는 스쿼시 병합(Squash merge)을 사용하여 커밋 히스토리를 깔끔하게 유지하고, 병합이 완료된 기능 브랜치는 자동으로 삭제하여 리포지토리를 정리합니다 [17-19].
+
+## ⚖️ Trade-offs & Caveats
+*   **구조의 복잡성 vs. 팀의 규모:** Git Flow는 대규모의 복잡한 릴리스 계획을 안전하게 관리할 수 있지만, 프로세스 오버헤드가 크고 병합 지연을 초래합니다 [8, 20]. 반면, Feature-Branch 워크플로우나 Trunk-Based 방식은 소규모 팀이 빠르고 가볍게 움직일 수 있도록 돕지만, 규모가 커지거나 엄격한 릴리스 버전 관리가 필요한 경우 한계에 부딪힐 수 있어 워크플로우를 진화(Migration)시켜야 합니다 [8, 10].
+*   **기능 브랜치의 수명과 충돌:** 기능 브랜치 방식의 가장 큰 부작용은 브랜치의 수명이 길어질 경우 메인 브랜치와의 차이가 커져 심각한 병합 충돌(Merge Conflict)이 발생한다는 점입니다 [20, 21]. 이를 피하기 위해 개발자는 자주 `main` 브랜치를 풀(Pull) 받거나 리베이스(Rebase)하여 최신 상태를 동기화하는 부가적인 작업을 수행해야 합니다 [19, 20].
+*   **완전한 추적성의 대가:** 모든 브랜치와 커밋에 티켓 ID 부여를 강제하면 버그 추적이나 리뷰에 있어 컨텍스트 확보에는 탁월하나 [5, 22], 아주 단순하고 사소한 코드 수정 작업에도 반드시 티켓을 생성하고 절차를 밟아야 하는 속도 저하의 단점이 발생합니다 [23].
+*   **Trunk-Based 전환의 전제 조건:** Trunk-Based Development로 전환하여 빠른 통합의 이점을 얻고자 한다면, 코드의 불안정성을 감추기 위한 기능 토글(Feature flags) 기법과 병합 전 결함을 잡아낼 강력한 테스트 자동화(CI)가 필수적으로 요구된다는 제약 사항이 있습니다 [12].
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+
+#### [관계 유형 A (아키텍처/기반 기술)]
+- `[[Trunk-Based Development]]`
+  - 연결 이유: Git Workflow를 구성하는 핵심 전략 중 하나로, 빠른 통합을 목적으로 하는 방법론입니다 [2].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 짧은 수명의 브랜치, 빈번한 병합, 기능 플래그(Feature Flags) 활용이 프로젝트 배포 속도에 어떻게 기여하는지 이해할 수 있습니다 [9, 12].
+
+- `[[Git Flow]]`
+  - 연결 이유: 구조가 복잡한 대규모 프로젝트의 릴리스를 관리하기 위해 만들어진 전통적 브랜칭 모델입니다 [2, 10].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: `develop`, `release`, `hotfix` 등 다중 브랜치 전략이 왜 오버헤드를 유발하면서도 엔터프라이즈 환경에서 사용되는지 파악할 수 있습니다 [8, 10].
+
+#### [관계 유형 B (구현/활용 도구)]
+- `[[Conventional Commits]]`
+  - 연결 이유: 팀의 일관된 코드베이스 히스토리 관리를 위해 Git 커밋 메시지 작성에 적용되는 업계 표준 규칙입니다 [6, 16].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: `feat:`, `fix:`, `chore:`와 같은 접두사가 리뷰어의 코드 이해도를 어떻게 높이고 자동화된 릴리스에 기여하는지 배울 수 있습니다 [6, 16].
+
+- `[[Pull Requests (PR)]]`
+  - 연결 이유: 브랜치의 코드를 `main`으로 병합하기 전, 협업 팀원들이 코드를 검토하는 핵심 관문입니다 [13, 16].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 브랜치 보호 설정, 동료 리뷰 요구(1 review required), 지속적 통합(CI) 체크가 시스템 안정성 유지에 어떻게 필수적으로 작용하는지 이해할 수 있습니다 [16, 17].
+
+- `[[Ticket IDs (Traceability)]]`
+  - 연결 이유: 코드의 변경 사항이 어떤 비즈니스 요구사항(예: Jira 티켓)에 의해 발생했는지를 연결하는 도구적 장치입니다 [5, 22].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: `PROJ-123` 형태의 티켓 번호를 브랜치와 커밋에 삽입함으로써 리뷰어에게 맥락을 제공하고, 문서화 및 작업 추적(Traceability)을 어떻게 달성하는지 알 수 있습니다 [5, 22].
+
+### Deeper Research Questions
+- 소규모 팀이 성장하여 복잡성이 증가할 때, Feature Branch Workflow에서 Git Flow로 안전하게 마이그레이션하려면 어떤 절차와 팀 내 교육이 필요한가?
+- Trunk-Based Development를 효과적으로 도입하기 위해 CI/CD(지속적 통합/배포) 파이프라인에서 반드시 구성해야 하는 자동화 테스트 조건은 무엇인가?
+- Conventional Commits 시스템과 연동하여 자동 릴리스 노트를 작성하고 시맨틱 버저닝(Semantic Versioning)을 구현하는 기술적 원리는 어떻게 작동하는가?
+- 다수의 작업자가 겹치는 영역을 수정할 때 발생하는 Merge Conflict를 예방하기 위해, 'Atomic Commits'와 '자주 병합하기' 원칙은 실무에서 어떻게 구체적으로 적용되어야 하는가?
+- 코드 리뷰의 병목 현상을 방지하기 위해 PR의 규모를 작게(예: 200줄 이하) 유지하면서도 논리적인 기능 단위를 훼손하지 않는 코드 분할 기법은 무엇인가?
+
+### Practical Application Contexts
+- **Implementation:** 새로운 작업을 시작할 때 무조건 `git checkout -b feature/티켓ID-작업명`으로 독립적인 브랜치를 파고, 완료 후 `feat:` 등의 규칙을 따른 커밋 메시지를 작성한 뒤 `main` 브랜치에 PR을 생성합니다 [6, 7, 13, 22].
+- **System Design:** GitHub와 같은 호스팅 플랫폼에서 `main` 브랜치 보호(Branch Protection) 옵션을 활성화하여 직접 푸시를 막고, CI 빌드 통과와 최소 1인의 승인이 있어야 병합되도록 시스템을 설계합니다 [17].
+- **Operation / Maintenance:** 브랜치가 병합될 때마다 스쿼시 병합(Squash and merge)을 강제하여 커밋 히스토리를 단일 항목으로 압축하고, 병합 후 남은 브랜치를 자동 삭제(Auto-delete) 설정하여 저장소를 깔끔하게 운영합니다 [17-19].
+- **Learning Path:** Git에 입문하는 소규모 프로젝트의 경우, 복잡한 `develop` 브랜치 없이 `main` 브랜치 하나와 기능 브랜치들로만 구성된 가벼운 워크플로우(Feature-Branch Workflow)를 먼저 학습하고 체화하는 것이 권장됩니다 [4, 8].
+- **My Project Relevance:** 현재 진행하는 3인 규모의 프로젝트 등에서는 Git Flow의 무거운 절차를 피하고, 항상 배포 가능한 안정적인 `main` 브랜치를 기준으로 짧은 기능 브랜치를 생성하여 빠른 리뷰와 피드백을 주고받는 방식을 즉각 도입할 수 있습니다 [4, 8].
+
+### Adjacent Topics
+- `[[CI/CD (Continuous Integration/Continuous Deployment)]]`
+  - 확장 방향: PR을 생성하거나 병합할 때 코드를 자동으로 테스트하고 빌드, 배포하는 인프라 파이프라인 구성 방법론으로 확장하여 조사.
+- `[[Semantic Versioning (SemVer)]]`
+  - 확장 방향: Git 태그(Tag)와 Conventional Commits를 활용하여 소프트웨어의 버전을 체계적이고 일관성 있게 부여하는 방법으로 확장.
+
+---
+*Last updated: 2026-04-30*
\ No newline at end of file
diff --git a/10_Wiki/Topics_Biz/GitHub Flow.md b/10_Wiki/Topics_Biz/GitHub Flow.md
new file mode 100644
index 00000000..2214b4bc
--- /dev/null
+++ b/10_Wiki/Topics_Biz/GitHub Flow.md	
@@ -0,0 +1,64 @@
+# [[GitHub Flow]]
+
+## 📌 Brief Summary
+GitHub Flow는 복잡한 Git Flow의 대안으로 사용되는 가볍고 단순한 브랜치 기반 워크플로우입니다 [1, 2]. 이 방식은 항상 배포 가능한 상태(deployable)를 유지하는 `main` 브랜치를 중심으로 작동하며, 개발자는 새로운 작업을 위해 짧은 주기의 기능 브랜치(feature branch)를 생성합니다 [3-5]. 변경된 코드는 동료의 코드 리뷰와 CI/CD 테스트를 모두 통과한 후 오직 Pull Request(PR)를 통해서만 `main`에 병합됩니다 [1, 6].
+
+## 📖 Core Content
+* **안정적인 `main` 브랜치 유지**
+  GitHub Flow의 핵심은 `main` (또는 `master`) 브랜치가 항상 안정적이고 언제든 배포 가능한 상태여야 한다는 점입니다 [3-5]. 개발자는 어떠한 경우에도 `main` 브랜치에 직접 커밋(direct commit)해서는 안 됩니다 [1, 6, 7].
+* **기능 브랜치(Feature Branch) 기반 작업**
+  모든 새로운 기능 개발, 버그 수정, 문서 작업 등은 `main`에서 파생된 짧은 수명(short-lived)의 전용 브랜치에서 수행되어야 합니다 [3-5]. 브랜치 이름은 `feature/user-auth` 또는 `bugfix/login-error`와 같이 설명적이어야 하며, 가능하면 티켓 ID(예: `PROJ-123`)를 포함하여 추적성을 높이는 것이 좋습니다 [8, 9].
+* **Pull Request (PR) 및 코드 리뷰**
+  작업이 완료되면 `main` 브랜치로 병합하기 위해 PR을 생성합니다 [6, 10]. 병합 전에는 반드시 최소 1명 이상의 팀원에게 코드 리뷰(Peer Review)를 받아야 하며, CI/CD 환경에서의 자동화 테스트를 통과해야 합니다 [1, 6, 8]. 이는 혼자서 잘못된 코드를 병합하는 것을 방지하는 안전장치입니다 [8].
+* **병합 규칙과 정리**
+  커밋 히스토리를 깔끔하게 유지하기 위해 PR을 병합할 때는 'Squash Merge' 방식을 주로 사용합니다 [6, 7, 11]. 성공적으로 병합된 이후에는 불필요한 브랜치가 쌓이지 않도록 기능 브랜치를 즉시 삭제(auto-delete)합니다 [6, 8, 11].
+* **워크플로우 마이그레이션 (Migration)**
+  팀이 기존의 복잡한 Git Flow에서 GitHub Flow로 전환하여 통합 속도를 높이고 단순화하려면, 릴리스 브랜치(release branch) 생성을 중단하고, `develop` 브랜치를 `main`으로 통합한 뒤, `main` 브랜치에서 직접 배포하도록 CI/CD 파이프라인을 업데이트해야 합니다 [2]. 반대로 프로젝트의 구조가 더 복잡해지면 `develop` 브랜치 등을 추가해 Git Flow로 되돌아갈 수도 있습니다 [12].
+
+## ⚖️ Trade-offs & Caveats
+* **병합 코드의 즉각적인 리스크**: `main` 브랜치가 유일한 배포 기준점이 되므로, 리뷰나 테스트가 누락되어 버그가 포함된 코드가 병합될 경우 프로덕션(운영) 환경에 치명적인 영향을 미칠 수 있습니다 [13, 14]. 따라서 강력한 CI/CD 자동화 환경과 Branch Protection Rule(보호 규칙)이 필수적으로 뒷받침되어야 합니다 [1, 6].
+* **브랜치 수명 관리의 어려움**: 기능 브랜치가 너무 오래 유지(Long-lived)되면 `main` 브랜치와의 차이가 벌어져 심각한 병합 충돌(Merge Conflict)이 발생합니다 [13, 15]. 이를 방지하기 위해 개발자는 매일 작업 전 `main` 브랜치의 최신 상태를 당겨오고(pull/rebase) 변경 사항을 작게 유지하는 규율을 엄격히 지켜야 합니다 [11, 13].
+* **대규모/정기 릴리스 프로젝트에서의 한계**: 정해진 일정에 따라 버전을 묶어서 배포해야 하거나, 유지보수해야 할 과거 릴리스 버전이 여러 개인 대규모 프로젝트의 경우, 릴리스 브랜치가 없는 GitHub Flow는 구조적 한계를 가집니다. 이 경우에는 무겁더라도 Git Flow가 더 적합할 수 있습니다 [12, 16].
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+
+#### [관계 유형 A: 아키텍처/기반 기술 (개발 워크플로우)]
+- [[Git Flow]]
+  - 연결 이유: GitHub Flow와 자주 비교되는 분기 전략으로, 프로젝트의 복잡성에 따라 두 전략 사이를 마이그레이션하는 경우가 많습니다 [2, 12].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: `develop`, `release`, `hotfix` 브랜치를 사용하는 Git Flow를 이해함으로써, 상대적으로 GitHub Flow가 생략한 구조적 복잡성과 그에 따른 속도/단순성의 이점을 명확히 비교할 수 있습니다.
+- [[Trunk-Based Development]]
+  - 연결 이유: 소규모 팀에서 빠르고 충돌 없는 병합을 위해 도입할 수 있는 또 다른 경량 워크플로우입니다 [3, 16].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 극단적으로 짧은 생명주기의 브랜치를 사용하거나 메인에 빈번히 직접 병합하는 철학을 통해 CI(지속적 통합)의 본질을 더 깊게 이해할 수 있습니다.
+
+#### [관계 유형 B: 구현/활용 도구]
+- [[Pull Request]]
+  - 연결 이유: GitHub Flow에서 코드 병합을 수행하고 팀원 간의 협업 및 리뷰를 진행하는 가장 핵심적인 메커니즘입니다 [8, 10].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 코드 품질 통제, 피어 리뷰(Peer Review)의 역할 및 CI/CD 훅(Hook)이 작동하는 방식을 구체적으로 이해할 수 있습니다.
+- [[CI/CD]]
+  - 연결 이유: `main` 브랜치를 항상 배포 가능한 상태로 유지하기 위해 배후에서 코드를 검증하는 필수 자동화 파이프라인입니다 [1, 6].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 왜 수동 병합이 위험한지, PR 리뷰가 끝난 코드가 어떻게 안전하게 프로덕션 레벨까지 배포되는지의 전 과정을 파악할 수 있습니다.
+
+### Deeper Research Questions
+- Git Flow 기반 프로젝트에서 GitHub Flow로 마이그레이션할 때, 기존의 버전 관리 체계 및 배포 자동화 파이프라인을 어떻게 재설계해야 하는가?
+- GitHub Flow 환경에서 기능이 미완성된 상태로 `main`에 병합되어야 할 때, Feature Flag(기능 토글)를 어떻게 효과적으로 활용할 수 있는가?
+- 팀 규모가 3~5인에서 20인 이상으로 급격히 성장할 때, GitHub Flow의 한계점은 구체적으로 어떻게 나타나며 어떤 시점에 워크플로우를 전환해야 하는가?
+- 커밋 히스토리를 정리하기 위해 권장되는 Squash Merge 방식이 장기적인 버그 추적성(Traceability) 관점에서는 어떤 단점을 가질 수 있는가?
+- Branch Protection을 통해 '최소 1인의 리뷰'와 'CI 통과'를 강제할 때, 코드 리뷰 병목 현상을 해결하기 위한 프로세스적 최적화 방법은 무엇인가?
+
+### Practical Application Contexts
+- **Implementation:** 개발자는 JIRA 등에서 할당받은 티켓 ID를 기반으로 `feature/PROJ-123-login` 형식의 브랜치를 따고, 한 가지 논리적 변경사항만 담은 Atomic Commit을 수행한 뒤 PR을 생성합니다.
+- **System Design:** GitHub/GitLab 등의 레포지토리 설정에서 `main` 브랜치에 대해 직접 푸시(Direct Push)를 차단하고, Status Check(테스트 통과) 및 지정된 리뷰어의 Approve를 강제하는 보호 규칙(Branch Protection)을 설계합니다.
+- **Operation / Maintenance:** CI/CD 파이프라인이 `main` 브랜치의 변경을 감지하면 자동으로 프로덕션에 배포되도록 구성하고, 저장소의 깔끔한 관리를 위해 병합된 브랜치는 시스템에서 자동 삭제되도록 설정합니다.
+- **Learning Path:** Git 브랜치 기초 명령어 숙지 -> 1기능 1브랜치 원칙 실습 -> PR 작성 및 동료 리뷰 경험 -> 자동화된 CI/CD와의 연동 이해의 순서로 협업 능력을 성장시킬 수 있습니다.
+- **My Project Relevance:** 3~5명의 소규모 팀에서 충돌을 최소화하면서도 빠른 피드백과 릴리스가 필요한 현재 프로젝트 상황에, 불필요한 절차를 없애고 안정성을 보장하는 가장 이상적인 협업 모델로 적용할 수 있습니다.
+
+### Adjacent Topics
+- [[Conventional Commits]]
+  - 확장 방향: 커밋 메시지를 `feat:`, `fix:`, `chore:` 등의 규격으로 통일함으로써, PR 내용의 가독성을 높이고 향후 릴리스 노트를 자동화하는 방향으로 지식을 확장할 수 있습니다.
+- [[Issue Tracking System]]
+  - 확장 방향: 코드 구현(GitHub)과 요구사항 정의(JIRA, Linear 등)를 연결하여 프로젝트 관리 수준을 높이고 변경 사항의 비즈니스 맥락(Traceability)을 추적하는 방법론으로 확장됩니다.
+
+---
+*Last updated: 2026-04-30*
\ No newline at end of file
diff --git a/10_Wiki/Topics_Biz/Team Collaboration.md b/10_Wiki/Topics_Biz/Team Collaboration.md
new file mode 100644
index 00000000..cd5d477d
--- /dev/null
+++ b/10_Wiki/Topics_Biz/Team Collaboration.md	
@@ -0,0 +1,70 @@
+# [[Team Collaboration]]
+
+## 📌 Brief Summary
+프론트엔드 개발에서 'Team Collaboration(팀 협업)'이란 다수의 개발자가 동일한 코드베이스에서 효율적으로 함께 작업할 수 있도록 지원하는 실천 방식, 아키텍처, 그리고 워크플로우를 의미한다 [1, 2]. 이는 일관된 폴더 구조, 명명 규칙, 상태 관리 패턴 및 Git 브랜칭 전략을 확립하여 개발자 간의 충돌과 소통 비용을 최소화하는 것을 목표로 한다 [2-4]. 성공적인 협업은 린팅이나 포매팅과 같은 자동화된 도구를 통한 엄격한 코드 거버넌스와 명확한 코드 리뷰 문화를 바탕으로 애플리케이션과 팀이 확장될 때 안정성을 유지하도록 돕는다 [5-7].
+
+## 📖 Core Content
+* **Git 워크플로우 및 브랜칭 전략:** 
+  소규모 팀에서는 오버헤드가 적으면서도 충돌을 방지하는 '기능 브랜치(Feature-branch) 워크플로우'나 '트렁크 기반(Trunk-based) 개발'이 주로 권장된다 [8-10]. 모든 작업은 `main` 브랜치에 직접 커밋하지 않고 짧은 수명의 기능 브랜치에서 진행되며, Pull Request(PR)와 최소 1명 이상의 동료 리뷰(Peer review) 및 테스트 통과 후 병합되어야 한다 [7, 11, 12]. 또한, 브랜치명과 커밋 메시지에 티켓 ID(예: `PROJ-123`)를 포함하면 요구사항과 코드 변경 이력 간의 추적성(Traceability)을 확보할 수 있다 [13, 14].
+* **아키텍처 및 폴더 구조의 표준화:** 
+  표준화된 폴더 구조(예: 기능 기반 구조 또는 Feature-Sliced Design)는 파일의 위치를 예측 가능하게 하여 팀 협업을 크게 향상시킨다 [2]. 구조가 잘 잡혀 있으면 개발자들이 파일을 찾는 시간을 줄이고, 팀원 간 불필요한 소통을 줄일 수 있으며, 신규 개발자의 온보딩이 빨라진다 [2, 15]. 또한 각 기능이 독립된 폴더로 격리되어 있어 서로의 코드를 간섭할 확률이 낮아진다 [16].
+* **명명 규칙(Naming Conventions) 및 자동화된 거버넌스:** 
+  컴포넌트 이름은 파스칼 케이스(PascalCase), 파일 및 폴더 이름은 케밥 케이스(kebab-case)를 사용하는 등 일관된 명명 규칙은 OS 환경 간의 빌드 오류를 방지하고 코드 가독성을 높인다 [17-19]. 더 나아가 수동 검사에 의존하기보다 ESLint, Prettier, Husky를 활용해 커밋 이전에 린팅, 포매팅 및 타입 검사를 자동으로 강제하는 것이 고품질 코드 협업의 기반이다 [6, 20, 21].
+* **상태 관리 도구와 팀 규모의 상관관계:** 
+  팀의 규모가 클수록(10명 이상) 구조를 강제하는 도구가 협업에 유리하다 [5]. Zustand와 같은 도구는 유연하고 빠르지만, 규율이 부족하면 개발자마다 비동기 작업을 다르게 처리하여 코드베이스에 혼란(integration chaos)을 초래할 수 있다 [22, 23]. 반면 Redux는 보일러플레이트가 많지만, 팀 전원이 동일한 방식으로 코드를 작성하게 만드는 '단일 진실 공급원'과 구조를 제공하여 대규모 협업에서 버그를 줄인다 [5, 24, 25].
+
+## ⚖️ Trade-offs & Caveats
+* **유연성 vs. 구조적 강제성 (상태 관리):** Zustand 같이 가벼운 상태 관리 라이브러리는 보일러플레이트가 적어 빠른 기능 개발(스타트업 등)에 적합하지만, 유연성이 너무 커서 팀이 커질 경우 파편화된 패턴을 낳을 수 있다 [22, 23, 26, 27]. 반면 Redux는 일관성을 강제하여 디버깅과 협업을 편하게 해주지만, 초기 설정과 구조화에 드는 시간이 소규모 팀에게는 과도한 오버헤드로 작용할 수 있다 [5, 24, 28].
+* **브랜칭 워크플로우의 무게감:** Git Flow는 예정된 릴리스를 관리하는 거대 프로젝트에는 유용하지만, 소규모 팀에게는 브랜치 관리 비용이 너무 커서 개발 속도를 늦출 수 있다 [8, 29]. 가벼운 Feature-branch 워크플로우나 Trunk-based 개발이 대안이지만, 이는 개발자들이 브랜치를 짧게 유지하고 빈번히 병합(Merge)하는 규율을 스스로 지켜야만 성공할 수 있다 [30, 31].
+* **초기 학습 곡선과 오버헤드:** Feature-Sliced Design(FSD) 같은 엄격한 아키텍처는 코드의 모듈화와 독립적 작업(병렬 작업)을 가능하게 하지만, 초기 도입 시 팀원 전체가 해당 방법론(Layer, Slice 등의 개념)을 이해하고 동의해야 하는 학습 비용이 발생한다 [32, 33]. 규칙에 대한 지식 공유와 문서화가 동반되지 않으면, 개발자들이 임의로 하위 폴더나 `/shared` 등에 코드를 쏟아부어 오히려 아키텍처가 망가지는 결과를 낳을 수 있다 [33].
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+
+#### [관계 유형 A (협업/코드 관리 프로세스)]
+- [[Git Branching Strategies]]
+  - 연결 이유: 다수의 개발자가 동시에 코드를 작성할 때 충돌을 방지하고 통합 과정을 관리하기 위한 핵심 규약이기 때문이다 [3, 34].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: Pull Request, 코드 리뷰, 브랜치 명명 규칙, Trunk-based 워크플로우 등 실제 팀 운영 방식 [7, 35].
+- [[Commit Message Conventions]]
+  - 연결 이유: 변경 사항의 의도와 작업 내역(버그 픽스, 기능 추가 등)을 다른 팀원들에게 명확히 전달하는 소통의 도구이기 때문이다 [36].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 티켓 ID 통합, `feat:`, `fix:`와 같은 접두사를 통한 변경 이력의 자동화 및 스캐닝 [14, 36, 37].
+
+#### [관계 유형 B (아키텍처 및 거버넌스 도구)]
+- [[Feature-Sliced Design]]
+  - 연결 이유: 코드를 기술적 계층이 아닌 비즈니스 기능(Feature) 중심으로 분리하여, 여러 팀이 서로 간섭 없이 독립적으로 작업할 수 있는 환경을 제공한다 [16, 38].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 도메인 주도 설계의 프론트엔드 적용, 명시적 퍼블릭 API를 통한 모듈 캡슐화와 결합도 낮추기 [38-40].
+- [[Automated Governance]]
+  - 연결 이유: 사람의 수동 확인에 의존하지 않고 ESLint, Prettier, Husky 등으로 코드 컨벤션과 아키텍처 룰(의존성 방향 등)을 시스템적으로 강제한다 [6, 20].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: CI/CD 파이프라인에서의 코드 품질 보증 및 팀원 간의 스타일 분쟁 방지 [20].
+- [[Redux vs Zustand in Teams]]
+  - 연결 이유: 팀의 규모(소규모 vs 엔터프라이즈)에 따라 상태 관리 도구의 선택이 협업의 일관성에 결정적인 영향을 미치기 때문이다 [5, 24, 27].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 개발자의 자율성 부여와 일관성 강제(Boilerplate) 사이의 아키텍처적 트레이드오프 [22, 41].
+
+### Deeper Research Questions
+
+- 소규모 팀(2~5인)에서 대규모 팀(10인 이상)으로 확장할 때 Git 워크플로우와 브랜칭 전략은 어떻게 진화해야 하는가?
+- Feature-Sliced Design(FSD)을 프로젝트에 도입할 때, 팀원들이 공통 모듈을 `/shared` 폴더에 무분별하게 추가하는 것을 방지할 수 있는 구체적인 거버넌스 전략은 무엇인가?
+- ESLint와 Husky를 활용한 자동화 거버넌스 설정 시, 개발 속도를 늦추지 않으면서 모듈 간 잘못된 의존성(상위 레이어 참조 등)을 원천 차단하는 최적의 규칙 구성은 무엇인가?
+- 상태 관리 라이브러리(Redux vs Zustand)의 선택이 팀원 간의 비동기 로직 및 데이터 패칭(Fetching) 패턴의 파편화에 미치는 실제 영향은 무엇인가?
+- Pull Request 기반의 협업 환경에서, 시각적 회귀 테스트 도구(예: Storybook, Chromatic)가 코드 리뷰의 병목 현상을 어떻게 해소할 수 있는가?
+
+### Practical Application Contexts
+
+- **Implementation:** 코드를 커밋하고 PR을 생성할 때, 반드시 정해진 Conventional Commits 규칙을 따르고 JIRA 등의 이슈 티켓 번호를 브랜치와 커밋에 기입하여 추적성을 보장한다 [14, 37].
+- **System Design:** 프로젝트 폴더 구조 설계 시 기술적 파일 타입(컴포넌트, 훅 등)의 나열이 아닌, 인증, 대시보드 등 기능(Feature) 도메인 단위로 격리시켜 각 기능별로 전담 개발자가 병렬로 작업할 수 있도록 한다 [2, 42, 43].
+- **Operation / Maintenance:** CI/CD 파이프라인과 Git Hooks(Husky)를 세팅하여, 누군가 컨벤션을 어긴 코드를 푸시하려고 할 때 사전에 린터와 포매터가 작동해 잘못된 코드가 원격 브랜치에 올라가는 것을 차단한다 [20].
+- **Learning Path:** 신규 입사자나 팀원이 배정되었을 때, `README`에 명시된 팀의 브랜칭 전략 규칙과 폴더 디렉토리 설계 의도를 먼저 학습하게 하여 프로젝트 온보딩 시간을 단축한다 [2, 44].
+- **My Project Relevance:** 다수의 프론트엔드 개발자가 함께 참여하는 리액트 프로젝트에서, 코드 충돌과 기술 부채를 방지하고 일관된 제품 품질을 유지하기 위해 필수적으로 수립해야 하는 협업 그라운드 룰(Ground Rules)이다.
+
+### Adjacent Topics
+
+- [[Code Review Practices]]
+  - 확장 방향: 작은 단위의 Pull Request 유지, 시각적 리뷰 도구의 도입, 효율적인 동료 피드백 제공 등 코드 리뷰 자체의 품질과 속도를 높이는 방법론 [37, 45].
+- [[CI/CD Pipelines]]
+  - 확장 방향: 팀원의 코드가 `main`에 병합되기 전, 자동으로 테스트와 린팅을 수행하고 배포까지 이어지는 인프라 및 데브옵스 환경 [7].
+- [[Visual Regression Testing]]
+  - 확장 방향: Storybook 및 Chromatic을 활용해 UI 변경 사항을 리뷰어가 시각적으로 직접 확인하고, 예기치 않은 레이아웃 깨짐을 방지하는 협업 기술 [45, 46].
+
+---
+*Last updated: 2026-04-30*
\ No newline at end of file
diff --git a/10_Wiki/Topics_Biz/Version Control.md b/10_Wiki/Topics_Biz/Version Control.md
new file mode 100644
index 00000000..2da5260d
--- /dev/null
+++ b/10_Wiki/Topics_Biz/Version Control.md	
@@ -0,0 +1,69 @@
+# [[Version Control]]
+
+## 📌 Brief Summary
+버전 관리(Version Control)는 소규모부터 대규모 팀에 이르기까지 코드의 변경 사항을 추적하고, 병합 충돌을 방지하며 안정적인 배포를 가능하게 하는 필수적인 협업 도구 및 거버넌스 프로세스입니다 [1, 2]. 개발팀은 프로젝트 규모와 팀의 숙련도에 따라 Feature-Branch 워크플로우, Trunk-based 개발, Git Flow 등 다양한 브랜칭 전략을 선택하여 사용합니다 [3, 4]. 효과적인 버전 관리는 브랜치와 커밋에 티켓 ID 연동, 의미 있는 커밋 메시지 작성, 작고 빈번한 커밋, 그리고 엄격한 풀 리퀘스트(PR) 리뷰 등의 모범 사례를 준수하여 코드베이스의 품질과 추적성을 유지하는 것을 목표로 합니다 [2, 5].
+
+## 📖 Core Content
+* **주요 브랜칭 전략 (Branching Strategies)**
+  * **Feature-Branch Workflow**: 2~5인 규모의 소규모 팀에게 가장 권장되는 단순하고 충돌이 적은 방식입니다 [6]. `main` 브랜치는 항상 안정적이고 배포 가능한 상태를 유지하며, 각 기능이나 버그 수정은 `main`에서 분기된 짧은 수명의 개별 브랜치에서 진행됩니다 [6, 7].
+  * **Trunk-Based Development**: 짧은 기능 브랜치를 활용하여 메인 브랜치(Trunk)에 코드를 빠르고 빈번하게 병합하는 전략으로, 강력한 CI/CD 환경과 경험이 많은 팀에게 적합합니다 [8, 9].
+  * **Git Flow & GitHub Flow**: Git Flow는 별도의 릴리스 브랜치 등을 두어 스케줄에 따른 대규모 프로젝트를 관리하기 좋지만, 작은 팀에게는 절차가 무겁습니다 [9]. 반면 GitHub Flow는 더 단순하며 빠른 통합을 지향합니다 [10].
+
+* **명명 규칙 및 추적성 (Naming Conventions & Traceability)**
+  * **브랜치 명명 (Branch Naming)**: 브랜치 이름에는 작업의 유형과 티켓 ID, 짧은 설명을 포함하는 것(예: `feature/PROJ-123-user-auth`)이 권장되며, 일관성 있게 소문자와 하이픈을 사용해야 합니다 [11, 12].
+  * **커밋 메시지 (Commit Messages)**: 'Conventional Commits' 사양을 따라 `feat:`, `fix:`, `docs:`, `refactor:`, `chore:` 등의 접두사를 사용하여 변경 목적을 명확히 해야 합니다 [5, 13]. 커밋은 논리적인 단일 변경 사항만을 포함하는 '원자적 커밋(Atomic Commits)' 형태여야 합니다 [14].
+
+* **병합 및 리뷰 프로세스 (Merging and Code Review)**
+  * **Pull Request (PR)**: 코드를 `main`에 병합하기 전 반드시 PR을 열어 최소 1명 이상의 동료 리뷰를 거치고 CI 테스트를 통과해야 합니다 [15, 16]. 리뷰가 쉽게 진행되도록 PR은 작게 유지해야 합니다 [13].
+  * **충돌 예방 및 정리**: 병합 충돌을 피하기 위해 `main` 브랜치의 최신 변경 사항을 자주 가져와 동기화(pull/rebase)해야 하며, 병합할 때는 'Squash & Merge'를 사용하여 커밋 히스토리를 깔끔하게 유지하고 병합 후에는 사용한 브랜치를 자동 삭제하는 것이 좋습니다 [15, 17, 18].
+
+## ⚖️ Trade-offs & Caveats
+* **오버헤드 vs. 제어력**: Git Flow와 같이 구조화되고 무거운 프로세스는 대규모 애플리케이션의 릴리스 일정을 관리하기 좋지만, 소규모 팀에게는 프로세스 오버헤드가 너무 커서 개발 속도를 저하시킬 수 있습니다 [9, 19]. 반대로 너무 단순한 전략은 엄격한 제어가 필요한 대형 프로젝트에서 문제를 일으킬 수 있으므로 팀 규모와 요구사항에 맞춘 전략 선택이 필요합니다 [20].
+* **Trunk-Based 개발의 제약사항**: 병합 충돌을 최소화하고 빠른 피드백을 제공하지만, 개발팀의 높은 숙련도와 강력한 CI 검증 파이프라인이 전제되어야 합니다 [9]. 또한, 미완성된 기능이 병합될 위험이 있으므로 기능 플래그(Feature flags)를 추가로 도입해야 하는 제약이 발생합니다 [19].
+* **장기 브랜치(Long-lived Branches)의 반대급부**: 기능 개발을 위해 브랜치를 너무 오래 유지하면 병합 시점에 엄청난 코드 충돌(merge conflicts)을 처리해야 하는 위험이 있습니다 [12, 21]. 따라서 충돌을 방지하기 위해서는 작업자가 매일 `main` 브랜치와 동기화하는 지속적인 유지보수 노력을 기울여야 합니다 [18].
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+
+#### [워크플로우 및 방법론 (Workflow Strategies)]
+- [[Feature Branch Workflow]]
+  - 연결 이유: 버그 수정이나 새 기능 개발 시 `main`과 분리된 독립적이고 짧은 수명의 브랜치를 사용하는 전략이기 때문입니다. [6, 7]
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 어떻게 `main` 브랜치의 안정성을 훼손하지 않으면서도 다수의 개발자가 코드를 작성하고 충돌을 방지할 수 있는지 이해할 수 있습니다.
+- [[Trunk-Based Development]]
+  - 연결 이유: 모든 개발자가 빈번하게 짧은 주기로 메인 브랜치(Trunk)에 코드를 병합하는 방법론이기 때문입니다. [8, 9]
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 지속적 통합(CI)을 어떻게 보장하며, 장기 브랜치로 인해 발생하는 문제를 어떻게 회피하는지 파악할 수 있습니다.
+- [[Git Flow]]
+  - 연결 이유: 릴리스용 브랜치와 개발용 브랜치를 명확히 나누어 복잡한 프로젝트 릴리스를 관리하는 아키텍처이기 때문입니다. [9, 19]
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 팀의 규모와 배포 스케줄에 따라 워크플로우에 어떤 구조적 레이어를 추가해야 하는지 이해할 수 있습니다.
+
+#### [협업 및 품질 관리 (Quality Assurance & Collaboration)]
+- [[Pull Request (PR)]]
+  - 연결 이유: 코드를 주 브랜치에 병합하기 전, 변경 사항을 동료에게 검토받는 핵심 품질 통제 절차이기 때문입니다. [13, 16]
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 코드 리뷰와 CI 테스트 자동화가 어떻게 실제 코드 품질을 유지하고 팀 내 지식 공유를 돕는지 이해할 수 있습니다.
+- [[Conventional Commits]]
+  - 연결 이유: `feat:`, `fix:`와 같이 표준화된 접두사를 사용하여 커밋 메시지의 의도를 명확하게 만드는 구문 규칙이기 때문입니다. [5, 13]
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 커밋 히스토리를 통한 변경 사항 추적성 확보와 릴리스 노트 자동화에 어떻게 기여하는지 이해할 수 있습니다.
+
+### Deeper Research Questions
+- 소규모 팀(2~5명)이 성장하여 10명 이상의 대규모 조직이 될 때, Feature-Branch 워크플로우에서 Git Flow 등 더 복잡한 전략으로 마이그레이션하는 구체적이고 안전한 방법은 무엇인가? [9, 20]
+- Trunk-based 개발 환경에서 불완전한 코드를 배포하지 않기 위해 사용하는 기능 플래그(Feature Flags)는 버전 관리 및 브랜칭 전략의 복잡성에 어떤 영향을 미치는가? [19]
+- Pull Request 완료 시 'Squash & Merge' 방식과 'Merge Commit' 방식 간의 커밋 히스토리 가독성 및 롤백 용이성 차이는 어떻게 나타나는가? [15, 17, 18]
+- 브랜치 이름과 커밋 메시지에 티켓 ID를 의무적으로 포함하는 거버넌스는, 실제 이슈 트래킹 도구(예: JIRA) 및 CI/CD 파이프라인과 결합 시 어떤 자동화 혜택을 제공하는가? [2, 10]
+- 장기 기능 브랜치(Long-lived feature branches)로 인해 발생하는 거대한 병합 충돌을 피하기 위해 팀은 일일 작업에서 어떤 동기화 패턴을 습관화해야 하는가? [18, 21]
+
+### Practical Application Contexts
+- **Implementation:** 브랜치 생성 시 `feature/PROJ-123-user-auth`처럼 티켓 ID를 포함하는 명명 규칙을 적용하고, `feat: add login form` 등의 Conventional Commits 형식을 사용하여 구현 이력을 체계적으로 관리합니다 [10, 11].
+- **System Design:** 코드를 하나의 논리적 단위로 분리하는 원자적 커밋(Atomic Commits) 규칙을 도입하고, CI/CD 체크가 통과되고 1인 이상이 승인해야만 `main`에 병합 가능하도록 브랜치 보호(Branch Protection) 시스템을 설계합니다 [14, 15].
+- **Operation / Maintenance:** `main` 브랜치는 항상 안정적이고 배포 가능한(deployable) 상태를 유지하도록 운영하며, 병합 완료 후 사용이 끝난 기능 브랜치를 자동 삭제 설정하여 저장소를 깔끔하게 유지합니다 [7, 15, 18].
+- **Learning Path:** 처음에는 복잡한 룰 없이 단순한 Feature-Branch 워크플로우와 명확한 네이밍 규칙을 익히고, 숙련도가 높아지면 자동화된 CI 환경 하의 Trunk-Based 개발 또는 복잡한 버전 관리를 위한 Git Flow로 학습을 확장합니다 [9, 19, 20].
+- **My Project Relevance:** 프론트엔드/React 개발 프로젝트 등의 팀 단위 협업 시, 불필요한 절차 없이 코드 충돌을 최소화하고 추적 가능한 변경 내역을 보장하는 협업 기준을 마련하는 데 즉각적으로 활용할 수 있습니다 [1, 22].
+
+### Adjacent Topics
+- [[Continuous Integration / Continuous Deployment (CI/CD)]]
+  - 확장 방향: PR 단계에서 자동화된 테스트 및 린팅을 실행하고, 메인 브랜치 병합 시 배포를 자동화하여 버전 관리 도구와 어떻게 시너지를 내는지 조사. [1, 19]
+- [[Issue Tracking Systems]]
+  - 확장 방향: JIRA나 GitHub Issues 등의 도구가 Git의 티켓 ID 거버넌스와 결합되어 요구사항부터 코드 변경까지 어떻게 완벽한 추적성(Traceability)을 보장하는지 조사. [2, 23]
+
+---
+*Last updated: 2026-04-30*
\ No newline at end of file
diff --git a/10_Wiki/Topics_Biz/system_analysis_and_improvement_plan.md b/10_Wiki/Topics_Biz/system_analysis_and_improvement_plan.md
new file mode 100644
index 00000000..cf92d5ac
--- /dev/null
+++ b/10_Wiki/Topics_Biz/system_analysis_and_improvement_plan.md
@@ -0,0 +1,27 @@
+# ConnectAI 기술 부채 및 아키텍처 개선 계획 (Python Core)
+
+## 📌 핵심 진단 요약
+현재 ConnectAI의 Python 기반 추론 엔진은 알고리즘 비효율성($O(N^2)$), 동기식 I/O 블로킹, 강한 결합도(Tight Coupling)로 인해 성능 확장이 제한된 상태임. 이를 프로덕션 수준으로 끌어올리기 위한 단계별 최적화가 필요함.
+
+## 🛠️ 최적화 전략 (Phase 2: Core Optimization)
+
+### 1. 알고리즘 효율화 (Performance P1)
+- **현상**: `InferenceEngine.py`의 `feature_match_brute_force` 함수가 중첩 루프로 인해 $O(N^2)$ 복잡도 가짐.
+- **해결**: **KD-Tree** 또는 행렬 분해 기법을 도입하여 $O(N \log N)$으로 최적화. 추론 지연 시간 5~10배 단축 목표.
+
+### 2. 비동기 I/O 전환 (Throughput P1)
+- **현상**: `DataLoader.py`의 `load_dataset_sync` 함수가 동기식으로 동작하여 I/O 대기 시 CPU 유휴 발생.
+- **해결**: `asyncio` 기반 비동기 I/O 또는 스레드 풀 기반 병렬 처리를 도입하여 처리량(Throughput) 개선.
+
+### 3. 모듈 디커플링 (Maintainability P2)
+- **현상**: `PreprocessingModule`과 `CoreModel` 간의 직접 의존성으로 인한 강한 결합.
+- **해결**: **관찰자 패턴(Observer Pattern)** 도입. `DataReadyEvent` 발행-구독 모델을 통해 모듈 간 독립성 및 테스트 용이성 확보.
+
+## 🚀 구현 가이드라인
+- **Step 1**: 알고리즘 최적화 (KD-Tree 구현 및 검증)
+- **Step 2**: 비동기 I/O 전환 (async/await 래핑 및 이벤트 루프 통합)
+- **Step 3**: 아키텍처 디커플링 (이벤트 시스템 구축 및 DIP 실현)
+
+---
+*분석 일자: 2026-04-30*
+*우선순위: Step 1 (ROI 최상) > Step 2 > Step 3*
diff --git a/10_Wiki/Topics_Blog/Code Splitting.md b/10_Wiki/Topics_Blog/Code Splitting.md
new file mode 100644
index 00000000..96aa31b1
--- /dev/null
+++ b/10_Wiki/Topics_Blog/Code Splitting.md	
@@ -0,0 +1,58 @@
+# [[Code Splitting]]
+
+## 📌 Brief Summary
+큰 자바스크립트 번들을 더 작은 청크(chunk) 단위로 나누어 사용자가 필요로 할 때(on demand) 로드하는 프로세스입니다 [1, 2]. 모든 애플리케이션 코드를 초기에 한 번에 다운로드하는 대신, 필요한 파일만 먼저 불러오게 하여 초기 번들 크기를 극적으로 줄일 수 있습니다 [2, 3]. 결과적으로 초기 페이지 로드 속도를 향상시키고, 애플리케이션의 체감 성능을 개선하는 핵심적인 프론트엔드 최적화 기법입니다 [1, 4].
+
+## 📖 Core Content
+* **라우트 기반 분할 (Route-level Code Splitting):** 가장 일반적이고 효과적인 접근 방식입니다. 사용자가 특정 라우트로 이동할 때만 해당 페이지의 코드를 다운로드하도록 하여 초기 로딩 시 불필요한 코드 다운로드를 방지합니다 [1, 2, 5].
+* **컴포넌트 수준 지연 로딩 (Component-level Lazy Loading):** 차트, 지도, 리치 텍스트 에디터처럼 크고 무거운 컴포넌트나 드물게 사용되는 모달, 설정 패널 등을 렌더링이 필요한 시점에만 로드하도록 분리합니다 [6, 7]. React에서는 `React.lazy()`와 동적 임포트(dynamic imports), 그리고 `<Suspense>`를 활용해 이를 쉽게 구현할 수 있습니다 [4, 6, 8].
+* **벤더 라이브러리 분할 (Vendor Splitting):** Vite(내부적으로 Rollup 사용) 등의 번들러를 사용할 때 `manualChunks` 옵션을 통해 React 코어 라이브러리나 차트 등 무거운 벤더 코드를 별도의 파일로 분할합니다 [5, 9, 10]. 벤더 라이브러리는 자주 변경되지 않기 때문에 브라우저 캐싱 효율을 극대화할 수 있습니다 [5, 11].
+* **번들러의 자동화 지원:** 최신 번들러(Webpack, Vite)는 코드 내에 작성된 동적 임포트(`import()`)를 감지하면 자동으로 해당 코드를 별도의 청크로 분리합니다 [4, 6].
+
+## ⚖️ Trade-offs & Caveats
+* **필수 컴포넌트에 대한 오남용 금지:** 페이지에 즉시 필요한 스크롤 없이 볼 수 있는(above-the-fold) 핵심 컴포넌트나, 렌더링 속도가 빨라야 하는 요소에는 지연 로딩과 코드 분할을 피해야 합니다 [7]. 오히려 첫 화면을 그리는 시간을 지연시킬 수 있습니다.
+* **사용자 경험 저하 방지 (Fallback UI 필요):** 코드를 동적으로 불러오는 동안 네트워크 지연이 발생할 수 있습니다. 따라서 `<Suspense>`를 사용해 모듈이 로드되는 동안 스피너나 스켈레톤과 같은 Fallback UI를 제공해야 합니다 [5, 8]. 
+* **네트워크 요청 증가의 위험:** 너무 잘게 코드를 분할하면 오히려 수많은 네트워크 요청이 발생해 오버헤드가 발생할 수 있습니다. 따라서 번들 크기를 시각적으로 분석할 수 있는 `rollup-plugin-visualizer` 등의 도구를 사용해 500kB 이상의 큰 청크를 타겟으로 식별하고 적절하게 분할해야 합니다 [12, 13].
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+
+#### [아키텍처/기반 기술]
+- [[Lazy Loading]]
+  - 연결 이유: 코드 분할이 번들을 쪼개는 행위라면, 지연 로딩(Lazy Loading)은 그 쪼개진 코드를 필요 시점에 로드하는 기술적 방법론입니다 [2, 3].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 분할된 코드가 언제 브라우저로 전송되고 애플리케이션에 병합되는지 이해할 수 있습니다 [8].
+- [[Core Web Vitals]]
+  - 연결 이유: 코드 분할을 적용하는 주된 성능적 목적은 초기 자바스크립트 실행을 최소화하여 LCP(Largest Contentful Paint)와 INP(Interaction to Next Paint) 같은 핵심 웹 지표를 향상시키는 데 있습니다 [1, 8, 14].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 최적화 결과가 실제 사용자의 체감 성능 및 페이지 측정 지표에 어떻게 긍정적 영향을 주는지 평가할 수 있습니다 [15].
+
+#### [구현/활용 도구]
+- [[React.lazy() and Suspense]]
+  - 연결 이유: React 애플리케이션에서 컴포넌트 레벨 및 라우트 레벨의 동적 코드 분할을 구현하기 위해 사용하는 공식 API입니다 [6, 8].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 동적 임포트 처리 과정에서의 비동기 UI 렌더링 흐름과 예외(지연) 처리 방식을 배울 수 있습니다 [5].
+- [[Vite (Rollup)]]
+  - 연결 이유: 개발 및 프로덕션 환경에서 자바스크립트 애플리케이션을 번들링하고 실제 물리적인 청크 파일들로 분리해 내는 도구입니다 [9, 11].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 번들러의 `manualChunks` 설정을 통해 어떻게 벤더 라이브러리와 애플리케이션 코드를 효율적으로 나누어 브라우저 캐싱을 활용할 수 있는지 이해할 수 있습니다 [5].
+
+### Deeper Research Questions
+- 라우트 기반 분할과 컴포넌트 기반 분할을 어느 정도 비율로 적용해야 초기 렌더링 성능과 이후 탐색 시의 네트워크 지연 간의 균형을 이룰 수 있는가?
+- Vite나 Webpack 환경에서 `manualChunks`를 설정할 때, 브라우저의 HTTP/2 및 HTTP/3 다중화(multiplexing) 환경을 고려한 가장 이상적인 청크 개수와 크기는 무엇인가?
+- 동적 청크(chunk)를 로드하는 도중 사용자의 네트워크 연결이 끊기거나 에러가 발생할 경우, React Error Boundaries와 결합하여 어떻게 안정적인 Fallback 경험을 설계할 것인가?
+- 코드 분할로 인해 컴포넌트가 지연 로드될 때, 해당 컴포넌트가 의존하는 상태(Context, Zustand 등)는 로드 시점에 어떻게 동기화되는가?
+- Above-the-fold UI에 잘못 지연 로딩을 적용했을 때 LCP 점수에 미치는 악영향을 확인하려면 브라우저 개발자 도구의 성능(Performance) 패널에서 어떤 지표를 중점적으로 모니터링해야 하는가?
+
+### Practical Application Contexts
+- **Implementation:** React 코드에서 `import { Chart } from 'chart.js'`와 같은 정적 임포트를 제거하고, `const HeavyComponent = React.lazy(() => import('./HeavyComponent'))`로 감싸서 특정 버튼이 눌리거나 라우트가 전환될 때 렌더링되게 구현합니다 [4, 6, 8].
+- **System Design:** 아키텍처 설계 시, 모든 코드가 포함된 하나의 `index.js` 모놀리스 번들 대신, Vite의 `vite.config.ts`에서 `manualChunks` 설정을 통해 React 코어 및 무거운 서드파티 라이브러리를 별개의 캐싱 가능한 청크로 분리하도록 설계합니다 [5, 10].
+- **Operation / Maintenance:** CI/CD 파이프라인이나 로컬 빌드 과정에 `rollup-plugin-visualizer` 등의 번들 분석 도구를 연결하여 시각적 트리맵을 확인하고, 500kB를 초과하는 거대 청크가 발견되면 추가적인 분할 대상을 식별하여 최적화합니다 [4, 12, 13].
+- **Learning Path:** 우선 React의 번들링 개념을 이해한 후, 동적 임포트 구문 활용 -> `React.lazy()` 및 `<Suspense>` 적용 -> 라우터에 코드 분할 결합 -> 번들 분석기 및 Core Web Vitals 측정을 통한 효과 검증 순서로 지식을 확장합니다 [6, 8].
+- **My Project Relevance:** 프로젝트 규모가 커짐에 따라 메인 자바스크립트 번들이 수 메가바이트 단위로 무거워져 모바일 기기 등에서 로딩 속도 저하 현상이 보일 경우, 즉각적으로 라우트 기반 코드 분할과 차트/에디터 등 무거운 UI의 지연 로딩을 도입하여 LCP 문제를 해결할 수 있습니다 [3, 14, 16].
+
+### Adjacent Topics
+- [[Tree Shaking]]
+  - 확장 방향: 코드 분할이 필요한 코드를 '쪼개어' 가져오는 방식이라면, 트리 쉐이킹은 사용되지 않는 죽은 코드(Dead Code) 자체를 번들에서 '제거'하여 초기 번들 크기를 줄이는 상호 보완적인 최적화 기법입니다 [17, 18].
+- [[Server Components (Next.js)]]
+  - 확장 방향: 클라이언트 사이드의 코드 분할에서 더 나아가, 아예 정적인 UI 렌더링을 서버에서 처리하여 클라이언트로 보내는 자바스크립트 번들의 양 자체를 획기적으로 줄이거나 제거하는 최신 아키텍처 접근법입니다 [19-21].
+
+---
+*Last updated: 2026-04-30*
\ No newline at end of file
diff --git a/10_Wiki/Topics_Blog/Concurrent Features.md b/10_Wiki/Topics_Blog/Concurrent Features.md
new file mode 100644
index 00000000..2c5c54ed
--- /dev/null
+++ b/10_Wiki/Topics_Blog/Concurrent Features.md	
@@ -0,0 +1,56 @@
+# [[Concurrent Features]]
+
+## 📌 Brief Summary
+Concurrent Features는 React 18부터 도입된 기능으로, 렌더링 작업을 일시 중지(pause), 중단(interrupt), 재개(resume)할 수 있게 해주는 기능입니다 [1]. 이를 통해 중요한 사용자 상호작용(클릭, 타이핑 등)의 우선순위를 높이고, 상대적으로 느린 업데이트(대용량 필터링 등)를 지연시킬 수 있습니다 [1]. 결과적으로 앱의 실제 연산 속도 자체를 마법처럼 빠르게 만드는 것은 아니지만, 인지되는 속도(perceived speed)를 최적화하여 사용자 인터페이스를 반응성 있게 유지합니다 [2].
+
+## 📖 Core Content
+*   **동시성 렌더링(Concurrent Rendering)의 원리:** 최신 버전의 React에서 기본적으로 동작하는 방식으로, 렌더링 작업의 우선순위를 지정하여 중요도가 높은 상호작용이 렌더링에 의해 차단(block)되지 않고 즉시 반응하도록 돕습니다 [1].
+*   **`useTransition`을 통한 우선순위 제어:** 특정 상태 업데이트를 '긴급하지 않은(non-urgent)' 것으로 표시하여 지연시키는 훅(Hook)입니다 [3]. 실시간 검색 결과나 대용량 데이터 필터링 시, 사용자의 타이핑 같은 입력은 즉각적으로 반응하게 하면서 무거운 렌더링 처리는 뒤로 미룰 수 있습니다 [3]. 또한 `isPending` 상태를 활용해 입력 즉각성을 막지 않고 로딩 스피너나 스켈레톤 UI를 표시할 수도 있습니다 [3].
+*   **`useDeferredValue`를 통한 값 참조 지연:** `useTransition`이 업데이트를 언제 발생시킬지를 관리한다면, `useDeferredValue`는 무거운 값을 언제 '읽을지'를 제어합니다 [4]. 입력과 같은 UI 변경은 즉시 반영하면서, 파생되는 무거운 로직 적용은 살짝 지연시켜 실시간 폼(form) 등에서 발생하는 끊김 현상(jank)을 줄여줍니다 [4].
+*   **프레임워크 지원 환경:** 2025년 기준 Next.js(App Router), Remix, Vite + React 18+ 환경 등 대부분의 풀스택 및 번들러 프레임워크에서 기본적으로 동시성 렌더링 기능이 통합되어 지원됩니다 [2].
+
+## ⚖️ Trade-offs & Caveats
+*   **성능 향상의 본질적 한계:** 이 기능들은 앱의 실제 연산 속도를 물리적으로 높여주는 것이 아니라 "인지되는 속도(perceived speed)"를 우선시하는 기능입니다 [2]. 백그라운드 작업이 계속 진행되는 동안 UI의 반응성을 유지할 뿐, 실행해야 할 연산량 자체가 줄어드는 것은 아닙니다 [2].
+*   **선별적 사용 요구:** 모든 컴포넌트에 전역적으로 사용해서는 안 되며, 주로 '상호작용이 많은 뷰(interactive views)'에 선별적으로 적용해야 합니다 [4]. 
+*   **호환성 문제:** 렌더링을 차단하는(render-blocking) 구식 패턴(가드가 없는 클래스 컴포넌트 등)이나 오래된 상태 관리 라이브러리와 섞어서 사용하면 정상적으로 동작하지 않거나 성능 문제를 야기할 수 있습니다 [4].
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+
+#### [관계 유형 A: 아키텍처/기반 기술]
+- [[useTransition]]
+  - 연결 이유: 상태 업데이트를 긴급하지 않은 것으로 표시하여 지연시킬 수 있는 Concurrent Feature의 핵심 요소입니다 [3].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: React가 렌더링 우선순위를 조정하여 사용자 입력 반응성을 잃지 않게 유지하는 구체적인 메커니즘.
+
+- [[useDeferredValue]]
+  - 연결 이유: 비용이 큰 파생 데이터의 렌더링 반영 시점을 지연시켜 UI 끊김을 막는 또 다른 주요 요소입니다 [4].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 상태의 업데이트 시점이 아닌, 계산된 값을 읽어 들이는 시점을 분리하는 최적화 전략.
+
+#### [관계 유형 B: 구현/활용 도구]
+- [[Suspense]]
+  - 연결 이유: Concurrent Feature(특히 `useTransition`)와 결합하여 무거운 렌더링이나 데이터가 로드되는 동안 Fallback UI를 유연하게 표시하는 데 사용됩니다 [4].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 비동기 로딩 상태에서 사용자 경험(UX)을 부드럽게 설계하는 선언적 UI 패턴.
+
+### Deeper Research Questions
+- Concurrent Rendering이 동작할 때 브라우저의 메인 스레드는 내부적으로 어떻게 작업을 일시 중지하고 재개(pause, interrupt, resume)하는가?
+- `useTransition`과 `useDeferredValue`는 구체적으로 어떤 상황에서 각각 선택적으로 사용되어야 하며, 두 가지를 함께 사용할 때 발생하는 제약 사항은 없는가?
+- 구식 상태 관리 라이브러리(outdated state libraries)가 Concurrent Features와 섞였을 때 충돌이 발생하는 기술적 원리는 무엇인가?
+- 인지되는 속도(perceived speed)를 개선하기 위해 Concurrent 기능을 과도하게 사용했을 때 발생하는 메모리나 스케줄링 오버헤드는 어느 정도인가?
+- Next.js나 Remix 같은 최신 프레임워크는 내부적으로 Concurrent Features를 어떻게 활용하여 스트리밍(streaming) 업데이트와 같은 성능 향상을 이끌어내는가?
+
+### Practical Application Contexts
+- **Implementation:** 실시간 검색창, 타입어헤드(Typeahead) 입력기, 복잡한 데이터 그리드 필터링 등 사용자 입력이 발생할 때마다 무거운 UI를 다시 그려야 하는 곳에 구현하여 입력이 버벅이지 않도록 만듭니다 [3, 4].
+- **System Design:** 사용자의 즉각적인 피드백이 필요한 뷰와, 백그라운드에서 지연 렌더링되어도 무방한 컴포넌트를 분리하여 시스템 구조 및 우선순위를 기획합니다 [4].
+- **Operation / Maintenance:** 애플리케이션 프로파일링 중 입력 지연(Input Lag)이 빈번하게 보고되는 부분을 찾아내고, 해당 부분에 렌더링 차단 패턴이 없는지 점검하여 Concurrent 기능을 점진적으로 도입합니다 [4, 5].
+- **Learning Path:** 단순한 React Hook(`useState`, `useEffect`)의 렌더링 과정을 이해한 후, 메모이제이션 최적화(`React.memo`, `useCallback`)를 배우고, 최종적으로 렌더링의 우선순위를 제어하는 고급 최적화 과정으로 Concurrent 기능을 학습합니다.
+- **My Project Relevance:** 검색 필터가 많은 대시보드나 실시간 데이터 시각화 차트를 구축할 때 UI 스레드가 멈추는 것을 방지하여 사용자 경험을 크게 개선하는 데 직접적으로 적용될 수 있습니다.
+
+### Adjacent Topics
+- [[Server Components]]
+  - 확장 방향: 클라이언트에서 렌더링을 지연시키거나 최적화하는 것을 넘어, 무거운 렌더링 작업 자체를 서버로 완전히 옮겨 클라이언트의 자바스크립트 번들 크기와 실행 부담을 근본적으로 줄이는 방법론 탐구 [6, 7].
+- [[Code Splitting & Lazy Loading]]
+  - 확장 방향: 화면의 렌더링 과정을 매끄럽게 하는 것을 넘어, 초기 애플리케이션 로딩 시 네트워크를 통해 다운로드하는 코드의 양 자체를 분할하여 초기 응답성(Time to Interactive)을 향상시키는 전략 탐구 [8, 9].
+
+---
+*Last updated: 2026-04-30*
\ No newline at end of file
diff --git a/10_Wiki/Topics_Blog/Concurrent Rendering in React 18+.md b/10_Wiki/Topics_Blog/Concurrent Rendering in React 18+.md
new file mode 100644
index 00000000..b20eeb11
--- /dev/null
+++ b/10_Wiki/Topics_Blog/Concurrent Rendering in React 18+.md	
@@ -0,0 +1,62 @@
+# [[Concurrent Rendering in React 18+]]
+
+## 📌 Brief Summary
+React 18+의 동시성 렌더링(Concurrent Rendering)은 React가 렌더링 작업을 일시 중지, 중단 및 재개할 수 있도록 하는 강력한 기능입니다 [1]. 이를 통해 개발자는 업데이트 발생 시기와 방식을 세밀하게 제어할 수 있으며, 사용자의 상호작용성을 저하시키지 않으면서도 화면이 멈추지 않는 더 부드럽고 반응성 높은 애플리케이션을 구축할 수 있습니다 [1, 2].
+
+## 📖 Core Content
+
+**동시성 렌더링의 개념과 이점**
+*   React 18부터 도입된 동시성 기능은 렌더링 작업의 우선순위를 동적으로 지정할 수 있게 해줍니다. 렌더링 작업을 차단하지 않고, 느린 데이터 필터링 업데이트 등을 지연시키는 동시에 클릭이나 타이핑과 같은 중요한 사용자 상호작용에 즉각적으로 반응하도록 렌더링을 일시 중지하거나 재개할 수 있습니다 [1]. 이는 최신 React 버전의 기본 동작으로 내장되어 있습니다 [1].
+
+**주요 동시성 훅(Hooks)**
+*   **`useTransition`:** 특정 상태 업데이트를 '긴급하지 않은(non-urgent)' 것으로 표시하여 지연시킬 수 있는 훅입니다 [3]. 실시간 검색 결과 표시, 대규모 데이터 세트 필터링, 복잡한 차트 및 테이블 렌더링과 같은 무거운 작업이 사용자의 즉각적인 상호작용을 차단하지 못하게 합니다 [3]. 제공되는 `isPending` 상태를 활용하여 메인 스레드를 차단하지 않고 로딩 스피너나 스켈레톤 UI를 표시할 수 있습니다 [3].
+*   **`useDeferredValue`:** `useTransition`이 업데이트를 트리거하는 시점을 제어한다면, `useDeferredValue`는 비용이 많이 드는 값을 *읽고 적용하는 시점*을 지연시킵니다 [4]. 검색창의 입력 값 등 UI 변경 사항은 즉시 반영하면서, 파생되는 무거운 계산 로직은 약간 지연시켜 실시간 폼이나 인터페이스에서의 화면 끊김(Jank) 현상을 줄여줍니다 [4].
+
+**사용 모범 사례 및 프레임워크 지원**
+*   동시성 기능은 앱의 모든 곳이 아닌 '상호작용이 집중된 뷰'에 전략적으로 사용해야 합니다 [4]. 데이터가 로드되는 동안 대체 UI를 자연스럽게 보여주기 위해 `Suspense`와 결합하는 것이 권장됩니다 [4]. 
+*   주의할 점은 구식 상태 관리 라이브러리나 렌더링을 차단하는 패턴(예: 가드 로직이 없는 오래된 클래스 컴포넌트)과 혼용해서는 안 된다는 것입니다 [4]. 
+*   이러한 기능들은 연산 속도 자체를 물리적으로 높이는 것이 아니라, 백그라운드에서 작업이 계속되는 동안 UI가 반응하도록 유지함으로써 '체감 속도(perceived speed)'를 우선시하는 도구입니다 [4].
+*   2025년 기준 Next.js(App Router), Remix, Vite + React 18 등 대부분의 최신 풀스택 프레임워크는 기본적으로 이 동시성 렌더링을 완전히 통합하여 지원하고 있습니다 [5].
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+
+- [[useTransition]]
+  - 연결 이유: 동시성 렌더링 환경에서 특정 상태 업데이트를 '긴급하지 않은 작업'으로 명시적으로 분류하기 위해 사용되는 핵심 훅입니다 [3].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 상태 업데이트의 우선순위를 낮추어 사용자 입력에 대한 메인 스레드 차단을 방지하는 구체적인 제어 방법.
+
+- [[useDeferredValue]]
+  - 연결 이유: 연산 비용이 높은 값의 화면 적용 시점을 늦추어 UI의 즉각적인 체감 반응성을 향상시키는 동시성 기능이기 때문입니다 [4].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 사용자 입력(타이핑 등)의 즉각적인 반영과 무거운 파생 데이터 렌더링 간의 처리 시점을 분리하는 메커니즘.
+
+- [[Suspense]]
+  - 연결 이유: 동시성 훅(`useTransition` 등)과 결합하여 비동기 처리나 지연된 렌더링이 완료되기 전까지 자연스러운 대체 UI(Fallback UI)를 표시하는 역할을 합니다 [4].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 비동기 데이터 로딩 과정에서 동시성 렌더링을 활용한 부드러운 사용자 경험(UX) 설계 방식.
+
+### Deeper Research Questions
+
+- React의 동시성 렌더링 엔진은 내부적으로 긴급 업데이트와 지연 업데이트의 우선순위를 어떤 스케줄링 알고리즘으로 관리하는가?
+- `useTransition`과 `useDeferredValue`를 복잡한 단일 컴포넌트 내에서 함께 사용할 때 발생할 수 있는 렌더링 엣지 케이스나 성능적 트레이드오프는 무엇인가?
+- 구식 상태 관리 라이브러리(Context API를 잘못 사용하는 경우 등)가 React 18의 동시성 렌더링 패턴을 방해할 때 발생하는 정확한 기술적 원리(예: Tearing 현상)는 무엇인가?
+- 동시성 렌더링의 도입이 브라우저의 INP(Interaction to Next Paint)와 TBT(Total Blocking Time) 지표 최적화에 수학적으로 어떤 연관성을 가지는가?
+- 동시성 렌더링으로 인해 렌더링 트리가 중단(Interrupt)되고 폐기된 후 다시 시작될 때, 불필요한 메모리 누수를 방지하기 위한 React의 내부 최적화 메커니즘은 무엇인가?
+
+### Practical Application Contexts
+
+- **Implementation:** 라이브 검색 결과창, 대규모 데이터 세트 필터링 기능 구현 시 `useTransition`과 `useDeferredValue`를 적극 활용하여 입력 중 발생하는 화면 멈춤(Jank) 방지 [3, 4].
+- **System Design:** 아키텍처 설계 시 기본적으로 동시성 렌더링이 활성화된 Next.js App Router나 Remix와 같은 최신 React 프레임워크를 도입하여 반응성 이점을 극대화 [5].
+- **Operation / Maintenance:** 기존 레거시 코드베이스에서 렌더링을 차단하는 요소(오래된 클래스 컴포넌트 등)를 리팩토링하고, 동시성 기능이 충돌 없이 작동할 수 있도록 유지보수 환경 개선 [4].
+- **Learning Path:** 전통적인 '동기적 렌더링(Synchronous Rendering)' 모델이 가진 한계를 벗어나, 작업 단위의 일시 중지와 재개가 가능한 렌더링 패러다임으로 개발자의 사고 방식을 전환.
+- **My Project Relevance:** 현재 진행 중인 서비스 내 무거운 대시보드 화면이나 복잡한 검색 인터페이스에서 사용자가 직접 체감하는 '인식 속도(Perceived Speed)'를 최적화하는 아키텍처 개선 지표로 활용 [3, 4].
+
+### Adjacent Topics
+
+- [[React Server Components]]
+  - 확장 방향: 동시성 렌더링과 함께 Next.js App Router 환경의 핵심 성능 최적화 축을 이루며, 클라이언트 측 자바스크립트 번들을 획기적으로 줄여주는 서버 컴포넌트의 렌더링 원리 탐구 [5, 6].
+
+- [[Core Web Vitals (INP/TBT)]]
+  - 확장 방향: 동시성 렌더링 기능 적용이 웹의 핵심 반응성 지표인 INP 및 TBT를 어떻게 개선하는지 실제 성능 측정 툴(Chrome DevTools, Lighthouse) 데이터와 연계하여 조사 [7-9].
+
+---
+*Last updated: 2026-04-30*
\ No newline at end of file
diff --git a/10_Wiki/Topics_Blog/Context API.md b/10_Wiki/Topics_Blog/Context API.md
new file mode 100644
index 00000000..b0dfba57
--- /dev/null
+++ b/10_Wiki/Topics_Blog/Context API.md	
@@ -0,0 +1,46 @@
+# [[Context API]]
+
+## 📌 Brief Summary
+Context API는 React에 내장된 상태 공유 솔루션으로, 컴포넌트 트리의 모든 레벨을 통해 명시적으로 props를 전달하지 않고도 데이터를 전송할 수 있게 해주는 기능입니다 [1, 2]. 이는 독립적인 상태 관리 도구라기보다는 데이터를 전달하는 브로드캐스트 전송 메커니즘에 가깝습니다 [3, 4]. 주로 테마, 다국어 설정 등 변경이 거의 없는 정적인 데이터를 전역적으로 공유할 때 적합하게 사용됩니다 [5, 6].
+
+## 📖 Core Content
+* **작동 방식 및 구조:** Context API는 `React.createContext()`를 호출하여 생성되며, 상태 값을 제공하는 `Provider`와 데이터를 읽는 `Consumer`(실무에서는 주로 `useContext` 훅)로 구성됩니다 [4]. Provider는 값을 브로드캐스트하고, 트리의 어느 깊이에 있든 `useContext`를 호출하여 해당 값을 읽을 수 있습니다 [4]. 단, 상태 자체를 관리하려면 `useState`나 `useReducer`와 같은 훅과 반드시 함께 사용해야 합니다 [4, 7].
+* **성능적 한계와 리렌더링 폭포:** Context의 가장 큰 단점은 성능 관리입니다 [8]. Context로 전달되는 값 중 일부만 변경되더라도, 해당 Context를 구독하는 **모든 컴포넌트가 리렌더링**됩니다 [8, 9]. React는 특정 데이터 부분만 사용하는 컴포넌트를 구별해 내지 못하므로, 상태 변경이 잦은 대규모 애플리케이션에서는 전체 대시보드가 수 초간 멈추는 등 심각한 성능 병목을 초래할 수 있습니다 [1, 10].
+* **구조적 최적화 전략:** 이러한 리렌더링 문제를 피하기 위해 애플리케이션의 모든 상태를 하나의 'Global Context'에 담는 안티 패턴을 피해야 합니다 [11, 12]. 대신 `ThemeContext`, `NotificationContext`처럼 상태를 여러 개의 작은 도메인별 Context로 분리하고, 커스텀 훅과 Selector 패턴을 활용해 필요한 값만 스코프를 좁혀 사용하는 것이 권장됩니다 [12, 13].
+* **사용의 적합성:** 테마(라이트/다크 모드), 언어 환경 설정, 기능 플래그 등 **변경 빈도가 매우 낮고 정적인 데이터**를 공유하거나 외부 종속성을 추가하고 싶지 않은 작은 프로젝트 및 라이브러리 개발에 완벽한 선택입니다 [5, 6, 14]. 반면, 실시간 데이터, 자주 업데이트되는 장바구니, 복잡한 비동기 작업이 필요한 경우에는 Context를 피하고 Zustand나 Redux를 사용하는 것이 좋습니다 [15-18].
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+- [[Prop Drilling]]
+  - 연결 이유: 부모 컴포넌트에서 깊게 중첩된 자식 컴포넌트로 데이터를 전달하기 위해 불필요한 중간 컴포넌트들을 거쳐야 하는 패턴입니다 [2]. 
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: Context API가 탄생하게 된 근본적인 배경과, 데이터를 어떻게 트리 아래로 "건너뛰어" 전달하는지 그 목적을 이해할 수 있습니다 [2, 19].
+- [[useContext]]
+  - 연결 이유: Context API의 Provider가 제공하는 브로드캐스트 값을 읽기 위해 개별 컴포넌트 내부에서 호출하는 React의 내장 훅입니다 [4].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 구독(Subscription)이 발생하는 정확한 지점과, 값이 변경될 때 어떤 컴포넌트에서 리렌더링이 트리거되는지 렌더링 동작 원리를 파악할 수 있습니다 [8].
+- [[Zustand]]
+  - 연결 이유: Context API의 리렌더링 한계와 보일러플레이트를 극복하기 위해 자주 비교되고 채택되는 경량 상태 관리 라이브러리입니다 [20, 21].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: Zustand의 'Selector 패턴'이 어떻게 특정 상태 슬라이스만 구독하게 하여 Context API의 "전체 리렌더링" 문제를 해결하는지 성능 최적화의 차이를 비교할 수 있습니다 [8, 10].
+
+### Deeper Research Questions
+- Context API와 외부 상태 관리 라이브러리(Zustand, Redux)를 동일한 애플리케이션 내에서 효율적으로 혼용(Hybrid)하기 위해, 정적 상태와 동적 상태를 분리하는 최적의 아키텍처 설계 기준은 무엇인가?
+- Context API의 "브로드캐스트" 특성으로 인한 불필요한 리렌더링을 방지하기 위해 도메인별로 Context를 쪼갤 때, 코드의 유지보수성을 잃지 않으면서도 성능을 잡을 수 있는 적절한 분리 입도(Granularity)는 어느 정도인가?
+- `use-context-selector`와 같은 외부 라이브러리를 사용하여 Context API의 리렌더링 문제를 우회하는 방식은, 처음부터 Zustand나 Redux를 도입하는 것과 비교하여 도입 비용 및 장기적 확장성 측면에서 어떤 장단점을 가지는가?
+- 의존성 주입(Dependency Injection)의 목적으로 Context API를 사용할 때, 테스트 환경(Jest 등)이나 Storybook에서 Provider 모킹(Mocking)을 설계할 때 발생할 수 있는 취약점과 해결책은 무엇인가?
+- 대규모 애플리케이션에서 무분별한 `useEffect`와 Context API가 결합되었을 때 발생하는 '리렌더링 폭풍(Re-render storm)'을 React DevTools Profiler로 진단하고 리팩토링하는 구체적인 과정은 어떻게 되는가?
+
+### Practical Application Contexts
+- **Implementation:** React 프로젝트에서 `React.createContext()`로 테마나 로케일 정보를 정의하고, 최상위 레이어(`app/` 또는 최상위 컴포넌트)를 `Provider`로 감싼 뒤, 내부 컴포넌트에서 `useContext`를 통해 해당 설정값을 불러와 UI에 즉각적으로 적용합니다 [4, 22, 23].
+- **System Design:** 아키텍처 설계 시 상태의 '변경 빈도'에 따라 저장소를 이원화합니다. 다크모드, 로그인 여부 같은 정적인 설정은 Context API에 배치하고, 장바구니나 실시간 알림처럼 수시로 변하는 데이터는 Zustand나 Redux 같은 외부 스토어에 배치하여 불필요한 렌더링 전파를 방지합니다 [24].
+- **Operation / Maintenance:** 성능 프로파일링 시 사용자 인터랙션 이후 대시보드가 일시적으로 멈추는 현상이 발견되면, React DevTools의 Profiler를 이용해 원인을 분석합니다. 원인이 단일 Context 업데이트에 의한 수백 개 컴포넌트의 리렌더링으로 확인될 경우, Context를 잘게 쪼개거나 다른 상태 관리 도구로 마이그레이션하는 유지보수 결정을 내립니다 [1, 25].
+- **Learning Path:** React 상태 관리를 처음 배우는 단계에서, 컴포넌트 간 Props 전달의 피로도를 줄이는 첫 번째 도구로 학습됩니다. 이후 실제 복잡한 앱을 만들며 한계를 경험하고, Redux의 보일러플레이트 구조나 Zustand의 독립된 스토어 개념을 자연스럽게 받아들이게 하는 핵심 학습 경로입니다 [14, 26, 27].
+- **My Project Relevance:** 기존 코드베이스에 'Global Context' 안티 패턴(모든 상태를 한 곳에 몰아넣은 형태)이 존재하지 않는지 점검하고 [11], 렌더링 병목이 있는 경우 `useMemo`, `useCallback`과 함께 Context를 책임별로 분할하는 리팩토링 목표와 직접적으로 연관됩니다 [1, 12].
+
+### Adjacent Topics
+- [[React.memo]]
+  - 확장 방향: Context API에 의해 발생하는 불필요한 하위 컴포넌트 렌더링을 방지하기 위한 얕은 비교(Shallow Compare) 최적화 도구로, 렌더링 성능 최적화(Performance Optimization) 기법 전반으로의 이해를 확장합니다 [28, 29].
+- [[Concurrent Rendering]]
+  - 확장 방향: React 18의 동시성 렌더링 기능(`useTransition`, `useDeferredValue`)을 통해 무거운 컴포넌트 렌더링을 어떻게 지연시키고 애플리케이션의 반응성을 개선할 수 있는지 상태 업데이트 흐름으로 탐구를 확장합니다 [6, 30].
+
+---
+*Last updated: 2026-04-30*
\ No newline at end of file
diff --git a/10_Wiki/Topics_Blog/Debugging Frontend Applications.md b/10_Wiki/Topics_Blog/Debugging Frontend Applications.md
new file mode 100644
index 00000000..51a64a0b
--- /dev/null
+++ b/10_Wiki/Topics_Blog/Debugging Frontend Applications.md	
@@ -0,0 +1,74 @@
+# [[Debugging Frontend Applications]]
+
+## 📌 Brief Summary
+프론트엔드 디버깅은 웹 애플리케이션에서 발생하는 자바스크립트 런타임 에러, 메모리 누수, 그리고 불필요한 리렌더링과 같은 성능 저하 요인을 식별하고 해결하는 과정입니다 [1-3]. Chrome DevTools와 같은 브라우저 내장 도구부터 React DevTools, 그리고 Sentry나 LogRocket과 같은 프로덕션 클라우드 로깅 도구를 활용하여 문제의 근본 원인을 추적합니다 [4-7]. 효과적인 디버깅 전략과 에러 핸들링 아키텍처는 애플리케이션의 안정성을 보장하고 사용자 경험을 최적화하는 데 필수적입니다 [8-10].
+
+## 📖 Core Content
+
+*   **메모리 누수(Memory Leaks) 탐지 및 해결:** 
+    *   메모리 누수는 할당된 메모리가 더 이상 필요하지 않음에도 해제되지 않을 때 발생하며, 앱 속도 저하와 브라우저 탭 충돌을 유발합니다 [2, 11]. 
+    *   Chrome DevTools의 Task Manager를 통해 실시간 JavaScript 메모리 사용량을 확인하고, Performance 탭의 기록을 통해 시간 경과에 따른 메모리 증가 패턴을 시각화할 수 있습니다 [12, 13].
+    *   Memory 패널의 **Heap Snapshots**을 사용하여 스냅샷 간의 차이(Delta)를 비교함으로써, DOM에서 제거되었으나 자바스크립트 참조가 남아있는 'Detached DOM nodes'를 식별할 수 있습니다 [14-17]. 또한, **Allocation Timeline**을 통해 새로운 메모리가 언제 할당되는지 추적하여 누수 후보를 찾아냅니다 [18, 19].
+*   **React 컴포넌트 및 성능 디버깅:**
+    *   **리렌더링 원인 추적:** React DevTools의 Profiler를 사용해 어떤 컴포넌트가 언제, 왜 렌더링되었는지 파악할 수 있으며, 개발 전용 라이브러리인 `why-did-you-render`를 통해 실제 props나 상태 변경 없이 발생하는 불필요한 리렌더링을 콘솔 경고로 확인할 수 있습니다 [7, 20].
+    *   **React Error Boundaries:** React 애플리케이션에서는 Error Boundary라는 클래스 컴포넌트를 활용하여 하위 컴포넌트 트리의 렌더링, 생명주기 메서드, 생성자에서 발생하는 에러를 포착합니다 [1]. 이는 UI를 위한 `try-catch` 블록 역할을 하며, 앱 전체가 충돌하는 대신 Fallback UI를 표시하여 앱의 나머지 부분을 상호작용 가능한 상태로 유지합니다 [1, 8, 10].
+*   **상태 관리 도구와 디버깅 편의성:**
+    *   상태 관리 도구의 선택은 디버깅 경험에 큰 영향을 미칩니다. Context API는 상태 변경 기록 추적이나 시간 여행(Time-travel) 디버깅이 불가능하여 버그 원인을 파악하기 어렵습니다 [21]. 반면, Redux는 Redux DevTools를 통해 어떤 액션이 언제 디스패치되었는지 확인하고, 상태 이력을 검사 및 재생(Replay)할 수 있어 복잡한 비동기 에러를 신속하게 디버깅할 수 있습니다 [21, 22].
+*   **프로덕션 환경 모니터링 및 로깅:**
+    *   배포된 프로덕션 앱에서는 Sentry, LogRocket, Datadog RUM 등의 클라우드 로깅 툴을 통해 사용자가 경험하는 에러를 모니터링합니다 [23-25].
+    *   Sentry는 지능형 에러 그룹화(Error grouping)와 에러 발생 전의 콘솔 로그, 네트워크 요청 등을 보여주는 빵부스러기(Breadcrumb) 트레일을 제공합니다 [4, 25]. LogRocket은 사용자의 전체 화면을 녹화하듯 DOM 및 Redux/Vuex 상태 변화까지 캡처하는 세션 리플레이(Session replay) 기능으로 상세한 디버깅 컨텍스트를 제공합니다 [5]. Datadog RUM은 프론트엔드 에러를 백엔드 분산 트레이싱(Distributed tracing)과 상관관계 지어(Correlation) 복잡한 시스템의 에러를 파악하게 해줍니다 [24].
+
+## ⚖️ Trade-offs & Caveats
+
+*   **클라우드 로깅 도구의 성능 및 비용 문제:** 모니터링 도구들은 렌더링 성능 및 번들 크기에 직접적인 영향을 미칩니다. 일부 도구 구현 시 최대 120ms의 추가 로드 시간이 발생할 수 있습니다 [26]. 또한, Datadog과 같은 툴은 로그 수집(Ingest)과 검색을 위한 인덱싱(Index)에 대해 이중 과금 구조를 가지고 있어 규모가 커질수록 비용이 매우 가파르게 증가하는 단점이 있습니다 [27, 28].
+*   **세션 리플레이와 개인정보 침해 (Privacy Concerns):** LogRocket처럼 '모든 것을 캡처'하는 세션 리플레이 방식은 기본적으로 강력한 디버깅 정보를 제공하지만, 민감한 사용자 데이터까지 녹화될 수 있는 심각한 개인정보 침해 우려가 동반됩니다. 따라서 별도의 마스킹 및 설정 작업이 강제됩니다 [5, 29, 30].
+*   **Error Boundaries의 한계:** 선언적인 UI 에러 처리에 강력하지만, 이벤트 핸들러 내부의 에러, `setTimeout` 같은 비동기 코드, 서버 사이드 렌더링(SSR), 그리고 Error Boundary 자체에서 발생한 에러는 포착하지 못합니다. 이러한 부분은 전통적인 자바스크립트의 `try/catch` 블록으로 디버깅 및 예외 처리를 해야 하는 제약이 있습니다 [31, 32].
+*   **React Compiler 도입에 따른 디버깅 난이도 증가:** 코드를 자동으로 최적화해주는 React Compiler는 내부 로직이 블랙박스(Black box) 형태로 동작합니다. 개발자는 최적화된 부분과 그 이유에 대한 가시성을 잃게 되며, 예기치 않은 리렌더링 발생 시 코드상의 `React.memo`나 `useCallback` 호출을 확인하는 대신 React DevTools Profiler에 전적으로 의존해 조사해야 하므로 디버깅 난이도가 상승합니다 [33].
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+
+#### [관계 유형 A (브라우저 및 성능 분석 기반 도구)]
+- [[Chrome DevTools]]
+  - 연결 이유: 자바스크립트 힙 메모리와 DOM의 상태를 프로파일링하여 메모리 누수를 진단하는 가장 근본적인 프론트엔드 디버깅 도구이기 때문입니다 [6, 34].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 브라우저의 가비지 컬렉션(GC) 동작 원리, 분리된 DOM 노드(Detached DOM nodes)와 클로저(Closure)가 메모리를 점유하여 성능을 저하시키는 원리를 시각적으로 이해할 수 있습니다 [2, 14, 17, 35].
+
+#### [관계 유형 B (React 컴포넌트 및 에러 핸들링 도구)]
+- [[React Error Boundaries]]
+  - 연결 이유: 렌더링 및 생명주기 도중 발생하는 컴포넌트 런타임 에러를 디버깅/핸들링하여 "하얀 화면(White screen of death)"을 막아주는 React만의 고유한 방어적 디버깅 패턴입니다 [1, 36].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 선언적(Declarative) UI 트리의 에러 전파 방식과, 명령형(Imperative) 이벤트 핸들러에서 `try-catch`를 사용해야 하는 아키텍처적 차이를 명확히 구분할 수 있습니다 [32].
+- [[React DevTools Profiler]]
+  - 연결 이유: 어떤 컴포넌트가 언제, 왜 리렌더링되었는지를 측정(Profiling)하여 렌더링 병목 현상을 디버깅하는 필수 도구입니다 [7, 37].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: React의 렌더링 라이프사이클, 불필요한 상태 및 props 변경 추적, 그리고 React Compiler 도입 전후의 렌더링 패스(Render pass) 차이를 검증하는 방법을 배울 수 있습니다 [7, 38].
+
+#### [관계 유형 C (프로덕션 환경 관측성 도구)]
+- [[Session Replay & Distributed Tracing]]
+  - 연결 이유: 로컬에서 재현이 불가능한 프로덕션 에러를 추적하기 위해 사용자의 브라우저 상호작용(Sentry, LogRocket)과 백엔드 데이터 흐름(Datadog)을 연결하여 디버깅 단서를 찾는 핵심 개념입니다 [5, 24, 39].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 풀스택 환경에서의 엔드투엔드(End-to-End) 성능 모니터링 한계와 프론트엔드 에러가 백엔드 서비스에 미치는 연관 관계를 깊게 이해할 수 있습니다 [24, 25].
+
+### Deeper Research Questions
+
+- Chrome DevTools의 Heap Snapshot 분석에서 'Shallow size'와 'Retained size'의 차이는 프론트엔드 메모리 관리 측면에서 어떻게 해석되며, 디버깅 시 어떤 기준표가 되는가? [40]
+- React Error Boundary가 이벤트 핸들러나 비동기 코드의 에러를 잡지 못하는 아키텍처적 이유는 무엇이며, 이를 보완하여 전체 애플리케이션의 에러를 효과적으로 캡처하기 위한 최적의 로깅 패턴은 무엇인가? [31, 32]
+- Sentry, LogRocket, Datadog RUM 등 클라우드 기반 로깅 도구가 프론트엔드 번들 크기 증가 및 초기 렌더링 성능 지연(최대 120ms 추가 로드)에 미치는 영향을 최소화하기 위한 설정 및 로드 전략은 무엇인가? [26, 41]
+- Redux DevTools의 시간 여행(Time-travel) 디버깅 원리는 무엇이며, 왜 Context API나 Zustand보다 복잡한 비동기 상태의 버그를 더 빠르고 정확하게 찾아낼 수 있는가? [21, 22]
+- React Compiler 도입 이후 자동화된 메모이제이션 과정에서 발생하는 렌더링 이슈(예: Library Compatibility 문제로 인한 참조 변경)를 디버깅하기 위해 React Profiler를 어떻게 활용해야 하는가? [33, 42, 43]
+
+### Practical Application Contexts
+
+- **Implementation:** 개발자는 `why-did-you-render` 라이브러리를 프로젝트에 연동해, 로컬 개발 시 불필요한 컴포넌트 렌더링 원인을 콘솔 경고를 통해 즉각적으로 파악하고 코드를 수정할 수 있습니다 [20, 44].
+- **System Design:** 프론트엔드 시스템 설계 시 대시보드, 차트, 복잡한 폼 등 장애 발생 확률이 높은 UI 컴포넌트 각각에 독립적인 `Error Boundary`를 배치해 하나의 위젯 결함이 전체 앱의 마비를 가져오지 않도록 설계합니다 [8, 45, 46].
+- **Operation / Maintenance:** 프로덕션 단계에서는 Sentry나 LogRocket과 같은 관측성(Observability) 툴을 통합하여, 오류 로그 발생 시 사용자가 클릭한 이벤트와 화면의 상태(Session Replay)를 실시간으로 확인하고 빠르게 이슈를 대응(Hotfix)합니다 [5, 25, 47].
+- **Learning Path:** 주니어 프론트엔드 개발자가 메모리 누수를 학습할 때, Chrome DevTools의 Memory 탭을 사용해 스냅샷을 찍고 DOM 노드가 자바스크립트 변수에 의해 참조되어 가비지 컬렉션되지 않는 상황(Detached Elements)을 실습합니다 [14, 15, 17].
+- **My Project Relevance:** React 프로젝트에서 전역 상태를 설계할 때, 단순 설정(Theme 등)은 디버깅이 단순한 Context API로, 변경이 잦고 상태 추적이 중요한 요소는 DevTools를 지원하는 Redux나 Zustand를 도입하여 디버깅 용이성을 확보합니다 [22, 48, 49].
+
+### Adjacent Topics
+
+- [[State Management Architecture]]
+  - 확장 방향: 상태 관리 라이브러리(Redux, Zustand, Context API 등)의 아키텍처적 선택이 상태 변화 추적성과 DevTools 디버깅 퀄리티에 어떤 영향을 미치는지 분석 [21, 22, 49].
+- [[Frontend Performance Optimization]]
+  - 확장 방향: 디버깅을 통해 발견한 메모리 누수와 불필요한 컴포넌트 렌더링(Re-renders) 문제를 실질적인 성능 최적화 기법(가상화, 코드 스플리팅)으로 해결하여 Core Web Vitals를 개선하는 방향 [20, 50].
+
+---
+*Last updated: 2026-04-30*
\ No newline at end of file
diff --git a/10_Wiki/Topics_Blog/Large-scale Application Refactoring.md b/10_Wiki/Topics_Blog/Large-scale Application Refactoring.md
new file mode 100644
index 00000000..57dc756e
--- /dev/null
+++ b/10_Wiki/Topics_Blog/Large-scale Application Refactoring.md	
@@ -0,0 +1,66 @@
+# [[Large-scale Application Refactoring]]
+
+## 📌 Brief Summary
+대규모 애플리케이션 리팩토링은 코드의 동작 방식을 보존하면서 내부 구조를 개선하여 오래된 코드베이스의 유지보수성과 확장성을 회복하는 과정이다 [1]. 이는 단순히 코드를 '수정'하는 것이 아니라, 복잡한 비즈니스 로직을 분리하고 구조적 결합도를 낮추는 것을 목표로 한다 [2]. 성공적인 리팩토링을 위해서는 점진적인 접근 방식, 엄격한 아키텍처 적용, 그리고 코드 변경을 뒷받침할 수 있는 테스트 구축이 필수적이다 [1, 3].
+
+## 📖 Core Content
+
+*   **점진적 마이그레이션 전략 (Incremental Migration):** 대규모 애플리케이션을 한 번에 전면 재작성(Rewrite)하는 것은 리스크가 매우 크기 때문에, "재작성이 아닌 리팩토링" 전략이 권장된다 [1]. 예를 들어 상태 관리 도구를 Context API에서 Zustand로 마이그레이션할 때, 알림과 같은 단순한 유틸리티 스토어부터 시작해 결제 흐름과 같은 복잡한 도메인으로 한 번에 하나의 스토어씩 점진적으로 이동해야 한다 [1].
+*   **기능 및 도메인 기반 구조로의 개편:** 레거시 앱에서 흔히 쓰이는 파일 타입 기반 구조(components, hooks 등을 따로 모으는 방식)는 앱이 커질수록 탐색과 유지보수를 어렵게 만든다 [4, 5]. 따라서 비즈니스 기능별로 코드를 모으는 기능 기반 구조나, 단방향 의존성을 강제하는 엄격한 계층 모델인 Feature-Sliced Design(FSD)으로 폴더 구조를 재편하는 것이 핵심적인 리팩토링 목표가 된다 [6-8].
+*   **커스텀 훅을 통한 로직 캡슐화:** 현대 React 리팩토링의 기본 단위는 커스텀 훅이다 [9]. 복잡한 데이터 페칭이나 폼 핸들링 로직을 거대한 UI 컴포넌트에서 추출하여 `useFetch`, `useForm` 등의 훅으로 분리하면, UI와 비즈니스 로직이 격리되어 더 빠르고 독립적인 유닛 테스트가 가능해진다 [9, 10].
+*   **테스트를 통한 안전망 확보:** 코드를 본격적으로 수정하기 전에 테스트(Unit Test, UI Test 등)를 작성하는 것이 최우선 방어선이다 [3, 11, 12]. 기존 기능이 깨지지 않았는지 검증할 뿐만 아니라, 테스트 코드를 작성하는 과정 자체가 개발자가 기존 애플리케이션의 비즈니스 로직과 흐름을 깊이 이해하도록 강제하는 학습 도구가 된다 [13, 14].
+*   **레거시 안티패턴 및 스택 제거:** 효율적인 구조를 위해 불필요하게 렌더링을 유발하는 다수의 `useEffect`를 제거하고, 클라이언트와 서버 상태를 분리하기 위해 TanStack Query와 같은 도구를 도입해야 한다 [15]. 또한, 가능할 경우 클래스 기반 컴포넌트를 함수형 컴포넌트와 훅으로 변환하고, 일관성 없는 CSS 적용 방식을 하나로 통일하는 작업도 수반된다 [15, 16].
+
+## ⚖️ Trade-offs & Caveats
+*   **DRY와 KISS 원칙의 충돌:** 중복을 제거하려는 DRY(Don't Repeat Yourself) 원칙을 과도하게 적용할 경우, 추상화가 지나치게 복잡해져 코드를 단순하게 유지해야 하는 KISS(Keep It Simple, Stupid) 원칙을 위반하게 된다 [17]. 따라서 특정 패턴이 세 번 반복될 때까지 기다렸다가 추상화를 진행하는 것이 조기 최적화로 인한 부작용을 막는 방법이다 [17].
+*   **재작성(Rewrite) vs 리팩토링(Refactoring)의 기로:** 리팩토링 대상인 앱의 규모가 비교적 작다면 처음부터 새로 앱을 구축하는 것이 오히려 효율적일 수 있다 [11]. 그러나 대형 앱의 경우 전체 재작성은 위험이 커서 점진적 마이그레이션을 해야 하는데, 이 경우 전환 기간 동안 두 가지 다른 기술이나 아키텍처 패턴이 공존해야 하는 과도기적 기술 부채를 감당해야 한다 [1].
+*   **컴파일러 자동화 도입의 장벽:** React Compiler와 같이 성능 최적화(메모이제이션)를 자동화해 주는 도구를 도입하면 수동 최적화 코드를 지워 코드를 간결하게 만들 수 있다 [18]. 하지만 기술 부채가 많은 레거시 코드베이스의 경우, 기존 코드가 'React의 규칙(Rules of React)'을 광범위하게 위반하고 있다면 컴파일러가 제대로 작동하지 않으므로, 도입 전 대대적인 사전 리팩토링이 선행되어야 하는 제약이 따른다 [19].
+*   **공유(Shared) 모듈의 비대화:** 기능 기반 아키텍처(예: FSD)로 분리할 때, 공통으로 쓰이는 코드를 무분별하게 'Shared' 계층에 넣으면 해당 계층이 복잡한 스파게티 코드가 되고 변경 시 영향 범위(Blast Radius)가 기하급수적으로 커지는 위험이 있다 [20, 21]. 
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+
+#### [아키텍처 및 기반 원칙]
+- [[Feature-Sliced Design]]
+  - 연결 이유: 대규모 코드베이스의 스파게티화를 해결하고, 도메인/기능 중심의 단방향 의존성 규칙을 부여하여 확장 가능한 구조를 만드는 리팩토링의 궁극적 목표 모델이기 때문이다 [7, 22].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 기능(Feature)과 계층(Layer)을 어떻게 나누고 캡슐화하여 서로 간의 의존성 결합을 끊어내는지에 대한 실무적 아키텍처 구조 [6, 23].
+
+- [[SOLID Principles]]
+  - 연결 이유: 단일 책임 원칙(SRP) 등을 통해 거대한 컴포넌트가 가지는 여러 책임을 분리하고, 함수나 컴포넌트를 테스트 가능하게 잘게 쪼개는 리팩토링의 핵심 이론적 배경이기 때문이다 [24, 25].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 기능적 컴포넌트 내에서 인터페이스(Props)를 어떻게 분리하고, 확장에 열려있으면서 수정에는 닫힌 코드 작성을 구현하는 방법 [25, 26].
+
+#### [구현 및 활용 도구]
+- [[Unit Testing]]
+  - 연결 이유: 레거시 코드 구조를 변경할 때 기능이 망가지지 않았음을 보장하는 첫 번째 단계이자 가장 중요한 안전망 역할을 수행하기 때문이다 [3, 12].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 코드를 어떻게 더 작고 논리적인 블록 단위로 나누어(Triangulation) 의존성 없이 독립적으로 검증할 수 있는지에 대한 방법론 [9, 12].
+
+- [[Custom Hooks]]
+  - 연결 이유: 리액트 컴포넌트 내부에 복잡하게 얽힌 상태와 사이드 이펙트 로직을 외부로 추출하는 리팩토링의 주된 단위이자 도구이기 때문이다 [9].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: UI 렌더링 책임과 비즈니스 데이터 처리 책임을 어떻게 물리적으로 격리하여 코드 재사용성을 높일 수 있는지의 원리 [9, 10].
+
+### Deeper Research Questions
+
+- 리팩토링 과정에서 Feature-Sliced Design(FSD) 아키텍처를 도입할 때, 여러 기능(Feature)에서 동시에 요구되는 교차 관심사(Cross-cutting concerns) 로직은 어떤 방식으로 분리하여 관리해야 하는가?
+- 테스트 코드가 전무한 거대한 레거시 React 앱을 리팩토링할 때, 어떤 부분(예: 공통 유틸, UI 컴포넌트, 전역 상태 등)부터 우선순위를 두고 테스트 커버리지를 확보해야 하는가?
+- 대규모 애플리케이션의 Context API 기반 전역 상태를 Zustand 등 현대적 상태 관리 도구로 점진적으로 마이그레이션할 때 발생하는 상태 동기화 문제는 어떻게 해결할 수 있는가?
+- 기존의 수동 메모이제이션(`useMemo`, `useCallback`) 코드가 많은 레거시 앱에 React Compiler를 도입하기 위해 코드 내의 'Rules of React' 위반 사항을 추적하고 검증하는 효과적인 자동화 프로세스는 무엇인가?
+- 클래스형 컴포넌트를 함수형 컴포넌트와 커스텀 훅 구조로 리팩토링할 때 발생할 수 있는 메모리 누수(Memory Leaks) 패턴을 감지하고 방지하는 디버깅 전략론은 무엇인가?
+
+### Practical Application Contexts
+
+- **Implementation:** 거대한 폼 처리나 API 페칭 로직이 뷰와 결합하여 300줄이 넘어가는 기존 컴포넌트를, 단일 책임 원칙(SRP)에 따라 순수 뷰 컴포넌트와 비즈니스 로직을 담은 커스텀 훅으로 추출하여 다시 연결한다 [9, 25].
+- **System Design:** 폴더 구조를 `components/`, `hooks/` 같은 파일 유형 구분이 아닌, 비즈니스 도메인(예: 인증, 결제)을 중심으로 모은 기능 기반 혹은 FSD 기반 폴더 계층 구조로 전면 재설계한다 [8, 27].
+- **Operation / Maintenance:** ESLint와 Husky 등의 도구를 파이프라인에 구축하여 리팩토링된 코드가 상위 계층을 잘못 참조하는 역의존성(Reverse dependency)을 발생시키거나 코드 컨벤션이 어긋나지 않도록 엄격히 통제한다 [28].
+- **Learning Path:** 리팩토링해야 할 코드를 파악하기 전, 먼저 작은 빈 프로젝트나 '토이 앱'을 만들어 리팩토링에 도입할 새로운 기술(React의 최신 기능 등)의 기초를 실습하여 개념을 확립한다 [29].
+- **My Project Relevance:** 다른 개발자들이 작성한 레거시 코드를 인계받아 논문 프로젝트용으로 리팩토링해야 하는 경우, 먼저 기존 로직을 파악하기 위한 유닛 테스트를 작성한 후, 무분별하게 혼용된 CSS 스타일 정책을 하나로 통일시키고 불필요한 전역 상태를 지역 상태로 전환하는 실무 프로세스를 진행한다 [14, 16, 30, 31].
+
+### Adjacent Topics
+
+- [[Web Performance Optimization]]
+  - 확장 방향: 리팩토링 작업과 병행하여 번들 사이즈 감소(코드 스플리팅), 리렌더링 최적화, 불필요한 렌더 블로킹 제거 등을 통해 애플리케이션의 런타임 및 로딩 속도를 향상하는 전략적 기법을 탐구한다.
+- [[State Management Fragmentation]]
+  - 확장 방향: 레거시 앱의 거대한 단일 전역 상태를 분석하여 로컬 컴포넌트 상태, 전역 UI 상태, 서버 캐시 상태, URL 상태 등으로 파편화 및 전문화하여 각각에 맞는 도구(Zustand, React Query 등)로 이관하는 설계 방법론을 조사한다.
+
+---
+*Last updated: 2026-04-30*
\ No newline at end of file
diff --git a/10_Wiki/Topics_Blog/Lazy Loading.md b/10_Wiki/Topics_Blog/Lazy Loading.md
new file mode 100644
index 00000000..8756a85b
--- /dev/null
+++ b/10_Wiki/Topics_Blog/Lazy Loading.md	
@@ -0,0 +1,63 @@
+# [[Lazy Loading]]
+
+## 📌 Brief Summary
+Lazy Loading은 리소스나 코드 청크를 애플리케이션 초기 구동 시 한 번에 로드하지 않고, 사용자가 실제로 필요로 하는 시점에 비동기적으로 불러오는 성능 최적화 기법입니다 [1, 2]. 프론트엔드 환경에서는 초기 JavaScript 번들 크기를 최대 20~70%까지 줄여 초기 페이지 로드 시간을 획기적으로 향상시킵니다 [3]. 주로 경로(Route) 기반 컴포넌트, 무거운 UI 위젯(차트 등), 뷰포트 하단의 이미지 등에 적용되어 앱의 전반적인 반응성과 Core Web Vitals 지표를 개선합니다 [4, 5].
+
+## 📖 Core Content
+*   **JavaScript 코드 스플리팅과 동적 임포트(Dynamic Imports)**: Lazy Loading은 대규모 애플리케이션을 온디맨드(on-demand)로 로드할 수 있는 더 작은 청크(chunk)로 분할하는 코드 스플리팅(Code Splitting) 기법의 핵심입니다 [2]. 동적 임포트를 통해 Vite나 Webpack 같은 빌드 툴이 렌더링에 당장 필요하지 않은 코드를 메인 번들에서 분리하여 독립적인 파일로 만듭니다 [1, 6, 7].
+*   **React 환경에서의 구현 (`React.lazy` 및 `Suspense`)**: React 애플리케이션에서는 `React.lazy()` 함수를 통해 컴포넌트의 지연 로딩을 활성화합니다 [8]. 모듈이 네트워크를 통해 다운로드되는 동안 화면이 멈추거나 비어 보이지 않도록, `<Suspense>`를 감싸서 로딩 스피너와 같은 대체 UI(Fallback UI)를 렌더링합니다 [7, 8]. 
+*   **라우트 레벨 및 컴포넌트 레벨 지연 로딩**: 가장 일반적인 방식은 라우트 레벨에서 적용하는 것으로, 사용자가 특정 페이지로 네비게이션할 때만 해당 페이지의 JavaScript 청크가 다운로드되도록 합니다 [2, 7]. 컴포넌트 단위로는 서드파티 통합 기능(비디오 플레이어, PDF 뷰어 등)이나 차트, 리치 텍스트 에디터 같이 무거운 UI 블록에 적용하여 메인 번들을 최소화합니다 [5, 6].
+*   **이미지(Media) 최적화**: JavaScript 코드뿐 아니라 미디어 리소스에도 Lazy Loading이 널리 쓰입니다 [4]. HTML `<img>` 태그에 네이티브 속성인 `loading="lazy"`를 추가하면, 스크롤을 통해 사용자의 뷰포트에 도달하기 전까지 이미지를 다운로드하지 않으므로 초기 페이지 로딩의 오버헤드를 줄입니다 [4].
+
+## ⚖️ Trade-offs & Caveats
+*   **초기 뷰포트(Above-the-fold) 콘텐츠 적용 금지**: 지연 로딩은 스크롤 없이 처음 화면에 바로 보여야 하는 핵심 콘텐츠(Above-the-fold)나 즉시 상호작용해야 하는 렌더링이 빠른 요소에는 절대 적용해서는 안 됩니다 [5]. 이를 적용할 경우 초기 페인트 시간이 느려지고 사용자 경험이 심각하게 저하됩니다 [5, 9].
+*   **사용자 인터랙션 시 일시적 지연 발생**: 지연 로딩된 기능이나 페이지에 사용자가 처음 접근할 때, 브라우저는 필요한 스크립트 청크를 그제야 네트워크로 요청합니다 [7, 8, 10]. 이로 인해 약간의 대기 시간이 발생할 수 있으므로 `<Suspense>`를 통한 폴백 상태를 세심하게 디자인해야 합니다 [8, 11].
+*   **과도한 파편화(Over-fragmentation) 주의**: 크기가 작고 가벼운 기능까지 모두 지연 로딩으로 분리할 경우, 오히려 브라우저의 네트워크 요청 횟수가 급증하고 관리해야 할 로딩 상태(`Suspense`)가 많아져 성능 및 개발 효율을 떨어뜨릴 수 있습니다 [5, 12].
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+
+#### [아키텍처/기반 기술]
+- [[Code Splitting]]
+  - 연결 이유: Lazy Loading이 가능하도록 애플리케이션의 단일 JavaScript 번들을 여러 개의 작은 청크 단위로 나누는 근본적인 기반 기술이기 때문입니다 [2, 13].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 모던 프론트엔드 환경에서 빌드 툴(Vite, Webpack)이 런타임 최적화를 위해 코드를 어떻게 분할하고 관리하는지 이해할 수 있습니다 [6, 7].
+
+- [[Dynamic Imports]]
+  - 연결 이유: 자바스크립트 모듈을 파일의 최상단에서 정적으로 불러오지 않고, 실행 중에 비동기적으로 불러오기 위해 `import()` 문법을 사용하는 방식입니다 [1, 7].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 라우트 전환이나 특정 이벤트 발생 시점에 필요한 코드만 네트워크로 호출하는 런타임 메커니즘을 파악할 수 있습니다 [7].
+
+#### [구현/활용 도구]
+- [[React Suspense]]
+  - 연결 이유: `React.lazy()`를 이용해 지연 로딩을 수행할 때, 청크가 로드되기 전까지 렌더링을 일시 중지하고 Fallback UI를 화면에 그려주는 핵심 컴포넌트입니다 [7, 8].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 비동기 UI 로딩 시 사용자 경험(UX)을 부드럽게 유지하기 위한 렌더링 제어 및 로딩 상태 설계 패턴을 배울 수 있습니다 [8, 11].
+
+- [[Vite manualChunks]]
+  - 연결 이유: Vite를 통해 빌드할 때, 변경이 잦지 않은 무거운 벤더 라이브러리(React 코어 등)를 Lazy Loading의 청크 분할 전략과 결합해 별도 파일로 독립시키는 환경 설정입니다 [7, 14].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 브라우저 캐싱 전략을 극대화하고, 초기 번들 용량 경고("Large Chunks") 문제를 해결하는 구체적인 번들러 최적화 방법을 학습할 수 있습니다 [7, 15].
+
+### Deeper Research Questions
+
+- React 18의 동시성 렌더링(Concurrent Rendering) 기능인 `useTransition` 등은 지연 로딩 시 발생하는 UI 멈춤 현상을 어떻게 보완할 수 있는가? [16, 17]
+- 사용자 경험 저하를 막기 위해 지연 로딩되는 컴포넌트를 사용자가 클릭하기 직전에 미리 가져오는 Prefetching 전략은 어떻게 구현하는가? [18, 19]
+- Next.js의 클라이언트 컴포넌트 지연 로딩과 서버 컴포넌트(RSC) 아키텍처는 초기 번들 최적화 측면에서 어떤 차이점과 시너지를 가지는가? [5, 20, 21]
+- 무거운 UI 블록을 지연 로딩할 때, `rollup-plugin-visualizer`와 같은 번들 분석 도구를 통해 지연 로딩 대상을 어떻게 효과적으로 식별하고 우선순위를 정할 수 있는가? [10, 12]
+- 네이티브 브라우저 기능인 `loading="lazy"` 속성과 JavaScript 기반의 Intersection Observer API를 활용한 미디어 지연 로딩의 성능 최적화 한계점과 Trade-off는 무엇인가? [4]
+
+### Practical Application Contexts
+
+- **Implementation:** React 코드 상단의 무거운 외부 컴포넌트(예: 에디터, 차트 등) import 문을 지우고, `const Dashboard = React.lazy(() => import('./Dashboard'));`와 같이 변경한 후 렌더링 영역을 `<Suspense fallback={<Spinner/>}>`로 감쌉니다 [1, 6-8].
+- **System Design:** 프론트엔드 라우팅 및 아키텍처 설계 시부터, 필수 초기 진입 화면(Above-the-fold)은 즉시 로드하고, 관리자 패널이나 잘 쓰이지 않는 라우트는 분리하여 Code Splitting되도록 시스템의 번들링 전략을 구상합니다 [5, 12, 14].
+- **Operation / Maintenance:** 운영 중인 서비스가 무거워지거나 Vite 빌드 시 "500 kB 초과 청크" 경고가 뜰 경우, 번들 분석 도구를 사용해 메인 번들에서 분리 가능한 무거운 벤더나 특정 라우트를 식별해 점진적으로 Lazy Loading을 적용합니다 [10, 12, 15].
+- **Learning Path:** React 기초 렌더링 사이클 학습 ➔ JavaScript 모듈 및 번들러 구조 이해 ➔ `React.lazy`와 `Suspense`를 통한 라우트 스플리팅 적용 ➔ Chrome 성능 탭과 Web Vitals로 실제 로드 속도 측정 및 검증 [13, 22, 23].
+- **My Project Relevance:** 웹 애플리케이션의 규모가 커짐에 따라 필연적으로 증가하는 JavaScript 페이로드 문제를 해결하고, FCP(First Contentful Paint)와 TTI(Time to Interactive) 등 핵심 성능 지표를 방어하기 위한 필수적인 렌더링 최적화 전략입니다 [3, 8].
+
+### Adjacent Topics
+
+- [[Core Web Vitals]]
+  - 확장 방향: 지연 로딩이 검색 엔진 최적화(SEO) 및 사용자 경험 지표인 FCP, LCP(Largest Contentful Paint), INP(Interaction to Next Paint) 수치를 실제로 얼마나 개선하는지 측정 및 분석하는 관점으로 확장할 수 있습니다 [3, 23, 24].
+- [[Server Components (RSC)]]
+  - 확장 방향: 클라이언트 사이드의 자바스크립트 크기를 줄이기 위한 또 다른 현대적 패러다임으로, 클라이언트에서 실행될 코드를 아예 서버에서 렌더링하고 HTML로만 보내는 방식과 Lazy Loading과의 역할을 비교/대조합니다 [20, 21].
+
+---
+*Last updated: 2026-04-30*
\ No newline at end of file
diff --git a/10_Wiki/Topics_Blog/Next.js App Router.md b/10_Wiki/Topics_Blog/Next.js App Router.md
new file mode 100644
index 00000000..43ddac1f
--- /dev/null
+++ b/10_Wiki/Topics_Blog/Next.js App Router.md	
@@ -0,0 +1,54 @@
+# [[Next.js App Router]]
+
+## 📌 Brief Summary
+Next.js App Router는 Next.js(버전 13 이후)에서 도입된 최신 라우팅 및 아키텍처 시스템으로, React Server Components(RSC)를 기본적으로 지원하여 클라이언트 측 자바스크립트 전송량을 줄이고 초기 로딩 속도를 향상시킵니다 [1, 2]. 이 시스템은 `app` 디렉토리를 기반으로 동작하며, `page.js`, `layout.js`와 같은 특수 파일들을 통해 직관적이고 구조화된 라우팅을 제공합니다 [3, 4].
+
+## 📖 Core Content
+
+*   **특수 파일을 활용한 구조적 라우팅**: Next.js App Router는 라우트 구성 및 관리를 위해 특수 파일 명명 규칙을 사용합니다. 라우트는 `page.js`로, 공유 레이아웃은 `layout.js`로, 사용자 정의 에러는 `error.js`로, 로딩 상태는 `loading.js`로 정의하여 애플리케이션의 동작을 제어합니다 [3].
+*   **동적 라우트 및 라우트 그룹**: 동적인 경로 처리를 위해 `[param]`을 사용하고, 포괄적(catch-all) 라우트 처리를 위해 `[...param]`을 지원합니다 [3]. 또한 URL 구조에 영향을 주지 않고 논리적으로 라우트를 그룹화할 수 있도록 괄호를 사용하는 라우트 그룹(예: `(folderName)`) 기능을 제공하여, 기능별 또는 팀별로 코드를 깔끔하게 조직할 수 있습니다 [5].
+*   **React Server Components (RSC) 통합**: App Router는 서버 컴포넌트를 기반으로 동작합니다. 이를 통해 정적이거나 데이터 주도적인(read-only) UI는 클라이언트 측 자바스크립트 없이 서버에서만 렌더링할 수 있어 자바스크립트 번들 크기와 Hydration 소요 시간을 극대화하여 줄여줍니다 [2, 6, 7].
+*   **클라이언트와 서버의 역할 분리**: 서버 컴포넌트에서는 상태(state), `useEffect`, 클라이언트 전용 라이브러리를 사용할 수 없습니다 [8]. 따라서 상호작용이 즉각적으로 필요한 UI(모달, 입력창 등)에만 파일 상단에 `use client` 지시어를 선언하여 클라이언트 컴포넌트로 만들고, 나머지는 서버 컴포넌트로 분리하는 아키텍처 패턴이 필수적입니다 [7, 9].
+*   **동시성 렌더링(Concurrent Rendering) 완벽 지원**: App Router는 React 18의 동시성 기능과 완벽하게 통합되어 있습니다. `useTransition` 및 서버 컴포넌트와 함께 사용하여 사용자 인터페이스의 응답성을 떨어뜨리지 않고 백그라운드 작업을 효과적으로 처리할 수 있습니다 [10].
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+
+- [[React Server Components]]
+  - 연결 이유: Next.js App Router 아키텍처의 핵심 기반으로, 번들 크기를 줄이고 데이터 페칭 성능을 향상시키는 역할을 합니다 [1, 2].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 클라이언트 측 렌더링 코드와 서버 측 렌더링 코드 간의 명확한 경계 구분 및 Hydration 최소화 전략 [6, 7, 9].
+
+- [[Route Groups]]
+  - 연결 이유: App Router 내에서 URL 경로를 변경하지 않고도 폴더 구조를 논리적으로 조직할 수 있게 해주는 핵심 폴더 라우팅 패턴입니다 [5, 11].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 복잡한 애플리케이션에서 별도의 레이아웃을 가진 섹션(예: 마케팅 페이지와 상점 페이지)을 충돌 없이 독립적으로 분리하는 방법 [5, 11].
+
+- [[Concurrent Rendering]]
+  - 연결 이유: Next.js App Router가 기본적으로 완벽하게 지원하는 React의 렌더링 메커니즘으로, 렌더링 작업을 일시 중지, 중단 및 재개할 수 있게 해줍니다 [10, 12].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: `useTransition` 및 `useDeferredValue` 훅을 통해 무거운 렌더링 시에도 사용자 입력 반응성(UX)을 높게 유지하는 원리 [13, 14].
+
+### Deeper Research Questions
+
+- 여러 개의 루트 레이아웃을 가진 Route Groups 환경에서 최상위 `layout.js`가 없을 때, 다른 루트 레이아웃 간의 네비게이션 시 발생하는 전체 페이지 로드(full page load)의 내부 메커니즘은 무엇인가? [11]
+- App Router에서 `[param]` 형태의 동적 라우트와 Route Group 간의 경로 중복(예: `(marketing)/about/page.tsx`와 `(shop)/about/page.tsx`) 충돌 시, Next.js의 라우트 해석 우선순위는 어떻게 결정되는가? [11]
+- 기존 Pages Router 방식과 비교하여 App Router의 React Server Components는 데이터 페칭 시 어떻게 'Double Fetching' 문제를 해결하고 성능을 최적화하는가? [7, 8]
+- 클라이언트 컴포넌트(`use client`)와 서버 컴포넌트가 혼합된 형태의 트리에서, 서버 컴포넌트가 클라이언트 컴포넌트를 `children`으로 전달하거나 임포트할 때 적용되는 직렬화 규칙 및 한계점은 무엇인가? [6, 7, 9]
+- 특수 라우팅 파일 중 `error.js`가 React Error Boundary로서 동작할 때 서버 컴포넌트 오류와 클라이언트 컴포넌트 오류를 각각 처리하는 흐름은 어떻게 구분되는가? [3]
+
+### Practical Application Contexts
+
+- **Implementation:** 라우트를 구현할 때는 `kebab-case` 명명 규칙을 적용한 폴더(예: `auth-provider.tsx`)를 생성하여 라우팅하고, 대시보드처럼 정적인 레이아웃은 서버 컴포넌트로 두면서 `AddToCartButton` 같이 상호작용이 필요한 위젯만 `use client` 컴포넌트로 임포트하여 구현합니다 [4, 7, 15].
+- **System Design:** 애플리케이션 코드를 조직할 때, 기능별(Feature-Based) 폴더 구조를 사용하여 컴포넌트, 페이지, 유틸리티를 한 기능 폴더(예: `features/auth/`)에 모으고, 이를 다시 `Route Groups`를 통해 모듈화된 아키텍처로 설계합니다 [5, 16, 17].
+- **Operation / Maintenance:** 초기 자바스크립트 번들 용량이 커져 INP(Interaction to Next Paint)와 TTI(Time to Interactive) 등 코어 웹 바이탈 수치가 저하될 때, 어떤 컴포넌트가 불필요하게 클라이언트 사이드로 로드되었는지 파악하여 서버 컴포넌트로 마이그레이션 하는 유지보수를 진행합니다 [6, 18].
+- **Learning Path:** 우선 React의 렌더링 모델 트리거 요인과 상태 변화 원리를 숙지하고 [19], 이후 React 18의 동시성 훅(`useTransition`) 동작을 실습한 뒤 [12, 13], Next.js App Router의 Server Components를 통한 서버/클라이언트 경계 개념을 배우는 순서로 접근해야 합니다 [2, 7].
+- **My Project Relevance:** 소스에 관련 정보가 부족합니다.
+
+### Adjacent Topics
+
+- [[Code Splitting & Lazy Loading]]
+  - 확장 방향: App Router의 Server Components뿐만 아니라, `React.lazy`와 `Suspense`를 결합하여 라우트 및 무거운 컴포넌트(차트, 에디터 등)를 필요한 순간에만 로드하도록 최적화하는 기법으로의 이해 확장 [20, 21].
+- [[React Context API Optimization]]
+  - 확장 방향: App Router 환경 하의 클라이언트 컴포넌트 내에서 불가피하게 전역 상태를 쓸 때, Context의 광범위한 리렌더링 이슈를 회피하기 위해 컨텍스트를 분리하거나 Zustand, Jotai 등의 외부 라이브러리를 도입하는 방향으로 학습 확장 [22-24].
+
+---
+*Last updated: 2026-04-30*
\ No newline at end of file
diff --git a/10_Wiki/Topics_Blog/Prop Drilling.md b/10_Wiki/Topics_Blog/Prop Drilling.md
new file mode 100644
index 00000000..aea73383
--- /dev/null
+++ b/10_Wiki/Topics_Blog/Prop Drilling.md	
@@ -0,0 +1,56 @@
+# [[Prop Drilling]]
+
+## 📌 Brief Summary
+Prop Drilling은 실제로 해당 데이터가 필요하지 않은 여러 중간 컴포넌트들을 거쳐 계층적으로 데이터를 전달하는 안티 패턴을 의미합니다 [1]. 주로 깊게 중첩된 하위 컴포넌트에 상태나 데이터를 전달해야 할 때 발생합니다 [1]. React 생태계에서는 이 문제를 해결하기 위해 내장된 Context API나 외부 상태 관리 라이브러리를 활용합니다 [1, 2].
+
+## 📖 Core Content
+*   **작동 방식 및 원인:** Prop Drilling은 데이터를 부모 컴포넌트에서 깊이 중첩된 자식 컴포넌트로 전달하기 위해, 중간에 위치한 모든 컴포넌트의 props를 통해 데이터를 통과시키는 방식입니다 [1].
+*   **구조적 문제점:** 이 패턴은 중간 컴포넌트들이 자신에게 필요 없는 데이터를 단지 전달(transport)하기 위한 목적으로 취급하게 만들며, 이는 코드의 복잡성을 높이고 유지보수를 어렵게 만듭니다 [1].
+*   **React의 내장 해결책:** React는 이러한 현상을 해결하기 위해 'Context API'를 도입했습니다. 이를 통해 컴포넌트 트리의 모든 레벨을 거치지 않고도 전역 관심사(global concerns) 데이터를 직접적으로 하위 컴포넌트와 공유할 수 있습니다 [1, 3, 4].
+*   **파생 상태 처리의 한계:** Redux나 Zustand가 파생 상태를 위한 선택자(derived selectors)를 지원하는 것과 달리, Context는 파생 상태를 관리할 때 여전히 Prop Drilling 방식에 의존하게 되거나 불필요한 리렌더링을 피하기 어려운 기능적 한계가 있습니다 [5].
+
+## ⚖️ Trade-offs & Caveats
+Prop Drilling을 피하기 위해 가장 먼저 고려되는 Context API는 빈번하게 변경되는 상태를 다룰 때 심각한 성능 제약(Trade-off)을 동반합니다 [6, 7]. Context 값의 일부만 변경되어도 해당 Context를 구독하는 모든 컴포넌트가 불필요하게 전체 리렌더링(re-render)을 수행하게 됩니다 [6, 8]. 
+
+따라서 장바구니나 실시간 데이터 등 빈번하게 변경되는 상태에 대해 Prop Drilling을 피하겠다고 무작정 Context API를 사용하면 애플리케이션의 성능 저하(Re-render storm)를 초래할 수 있습니다 [9, 10]. 이러한 경우에는 선택자(Selector) 기능을 통해 필요한 상태 변경 시에만 리렌더링을 발생시키는 Zustand나 Redux를 사용하는 것이 최적화 측면에서 필수적인 반대 급부의 해결책이 됩니다 [7, 11].
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+
+#### [기반 기술/해결책]
+- [[Context API]]
+  - 연결 이유: Prop Drilling 문제를 해결하기 위해 React에서 자체적으로 도입한 내장 데이터 전달 메커니즘이기 때문입니다 [1].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: props를 일일이 넘기지 않고 컴포넌트 트리에 데이터를 브로드캐스트하는 원리와 그에 따른 리렌더링 한계를 이해할 수 있습니다 [6, 12].
+
+#### [상태 관리 도구/대안]
+- [[Zustand]]
+  - 연결 이유: Prop Drilling의 대안인 Context API가 갖는 리렌더링 성능 문제를 극복할 수 있는 경량 상태 관리 라이브러리이기 때문입니다 [2, 7].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 선택자(Selector) 패턴을 활용해 필요한 상태의 변경에만 컴포넌트를 리렌더링하도록 스마트하게 구독(subscribe)하는 구조를 이해할 수 있습니다 [7, 13].
+- [[Redux]]
+  - 연결 이유: 대규모 애플리케이션에서 Prop Drilling을 방지하고 상태를 일관성 있게 관리하기 위한 산업 표준 상태 컨테이너 도구이기 때문입니다 [5, 14].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 파생 선택자(derived selectors)가 존재함으로써 Prop Drilling 없이 복잡한 상태와 비동기 로직을 어떻게 효율적으로 다루는지 파악할 수 있습니다 [5, 15].
+
+### Deeper Research Questions
+
+- Prop Drilling을 피하기 위해 Context API를 사용할 때 발생하는 불필요한 리렌더링(re-renders) 문제는 어떤 방식으로 최적화할 수 있는가? [6, 8]
+- Redux와 Zustand가 제공하는 '선택자(Selector)' 기능은 Prop Drilling 방식과 비교하여 파생 상태(derived state)를 처리할 때 어떠한 아키텍처적 이점을 제공하는가? [5, 7]
+- Context API가 아닌 Zustand나 Redux 같은 전문적인 상태 관리 도구를 도입하여 Prop Drilling을 해결해야 하는 애플리케이션의 복잡도 및 컴포넌트 렌더링 빈도의 정확한 기준점은 무엇인가? [10, 11]
+- Prop Drilling을 단순히 회피하기 위해 모든 상태를 전역 컨텍스트(Global Context for Everything)에 넣는 안티 패턴은 시스템 아키텍처에 어떤 부작용을 일으키는가? [16, 17]
+- 전역 상태가 아닌 지역 컴포넌트 트리 내에서 발생하는 Prop Drilling을 해결하기 위해, 컴포넌트 합성(Component Composition)이나 클린 코드 원칙을 적용하는 방법은 무엇인가? [18, 19]
+
+### Practical Application Contexts
+
+- **Implementation:** 깊게 중첩된 하위 컴포넌트에 데이터를 전달할 때, 중간 컴포넌트들이 불필요한 props를 거치지 않도록 `React.createContext()`를 활용해 데이터 제공자(Provider)와 소비자(Consumer)를 분리하여 구현합니다 [1, 12].
+- **System Design:** 테마나 언어 설정과 같은 정적인 전역 관심사(global concerns)에 대한 Prop Drilling을 방지하기 위해서는 Context API를 설계에 반영하지만, 상태 변경이 잦은 영역은 Zustand나 Redux 기반의 스마트 알림 시스템(smart notification system) 구조로 설계하여 관심사와 성능을 모두 챙깁니다 [4, 13, 20].
+- **Operation / Maintenance:** 성능 모니터링 툴(예: React DevTools Profiler)을 통해 Prop Drilling을 우회하고자 도입한 Context가 리렌더링 폭풍(re-render storm)을 일으키는지 추적하고, 병목 발생 시 Selector를 지원하는 상태 관리 도구로 점진적 마이그레이션(Incremental Migration)을 수행합니다 [8, 9, 21].
+- **Learning Path:** React 입문 시 데이터 흐름의 기본인 Prop Drilling의 불편함을 먼저 경험하고, 이를 해결하는 Context API를 학습한 후, 최종적으로 대규모 앱을 위한 Zustand나 Redux로 발전해 나가는 형태의 학습 경로를 밟는 것이 권장됩니다 [22].
+- **My Project Relevance:** 소스에 관련 정보가 부족합니다.
+
+### Adjacent Topics
+
+- [[Re-renders]]
+  - 확장 방향: Prop Drilling을 피하기 위한 수단(Context API)이 초래하는 부작용인 불필요한 렌더링을 방지하기 위한 메모이제이션(`React.memo`, `useMemo`, `useCallback`) 등 React 런타임 성능 최적화 기법으로의 이해 확장이 필요합니다 [3, 6, 23].
+
+---
+*Last updated: 2026-04-30*
\ No newline at end of file
diff --git a/10_Wiki/Topics_Blog/Re-renders Optimization.md b/10_Wiki/Topics_Blog/Re-renders Optimization.md
new file mode 100644
index 00000000..be2c3213
--- /dev/null
+++ b/10_Wiki/Topics_Blog/Re-renders Optimization.md	
@@ -0,0 +1,54 @@
+# [[Re-renders Optimization]]
+
+## 📌 Brief Summary
+Re-renders Optimization은 React 애플리케이션에서 불필요한 컴포넌트 업데이트를 최소화하여 성능, 반응성 및 사용자 경험을 향상시키는 과정입니다 [1, 2]. 주로 상태(state), 속성(props), 컨텍스트(context)의 변경으로 인해 발생하는 과도한 렌더링을 타겟으로 합니다 [3]. 이를 위해 수동 메모이제이션, 상태 관리 최적화, 가상화 기법, 그리고 React Compiler와 같은 최신 자동화 도구를 활용하여 병목 현상을 방지합니다 [4-6].
+
+## 📖 Core Content
+*   **리렌더링의 원인과 성능적 영향:**
+    React 컴포넌트는 내부 상태(state) 변경, 속성(props) 변경, 구독 중인 컨텍스트(context) 값 변경, 혹은 부모 컴포넌트가 리렌더링될 때 업데이트됩니다 [3]. 불필요한 리렌더링이 누적되면 UI 반응성 저하, 메모리 사용량 증가, 상호작용성(TTI) 지연 등을 초래하며, 깊은 컴포넌트 트리에서는 스크립팅 시간을 30~60%까지 증가시킬 수 있습니다 [2].
+*   **수동 메모이제이션 (Manual Memoization):**
+    `React.memo()`를 사용하면 props가 변경되지 않은 경우 이전 렌더링 결과를 재사용하여 렌더링 횟수를 30~50%가량 줄일 수 있습니다 [7, 8]. 이와 함께 `useCallback`과 `useMemo` 훅을 사용하여 객체나 함수의 참조 동등성(Reference Equality)을 유지해야 자식 컴포넌트의 불필요한 렌더링을 막을 수 있습니다 [9, 10]. 단, 무분별한 사용은 비교 연산의 오버헤드를 발생시키므로 프로파일링을 통해 확인된 병목 구간에만 적용해야 합니다 [11, 12].
+*   **컨텍스트 최적화 (Context Optimization):**
+    React의 기본 Context API는 값의 일부만 변경되어도 해당 컨텍스트를 구독하는 모든 컴포넌트를 리렌더링합니다 [13, 14]. 이를 해결하기 위해 컨텍스트를 작은 도메인 단위로 쪼개거나 [15], 선택자(Selector)를 통해 상태의 특정 조각이 변경될 때만 리렌더링을 트리거하는 Zustand, Jotai 등의 외부 상태 관리 라이브러리를 사용하는 것이 권장됩니다 [16-18].
+*   **React Compiler의 도입:**
+    빌드 타임 최적화 도구인 React Compiler는 수동 메모이제이션(`useMemo`, `useCallback`, `React.memo`) 코드를 작성하지 않아도 컴파일 단계에서 자동으로 캐싱 로직을 삽입합니다 [4, 19]. 컴포넌트 전체가 아닌 개별 JSX 요소 단위로 세분화하여 메모이제이션을 수행함으로써, 코드의 가독성을 높이고 불필요한 렌더링을 원천적으로 차단합니다 [19, 20].
+*   **렌더링 패턴 및 동시성 최적화:**
+    수백 개 이상의 항목을 렌더링하는 대규모 리스트에서는 고유하고 안정적인 `key` 속성을 부여하고, 화면에 보이는 항목만 렌더링하는 가상화(Windowing) 라이브러리(예: `react-window`)를 적용하여 DOM 오버헤드를 줄여야 합니다 [6, 21]. 또한 JSX 내부에 익명 함수를 직접 작성하면 매 렌더링마다 새로운 참조가 생성되므로 지양해야 합니다 [22, 23]. 부가적으로 `useTransition` 및 `useDeferredValue`와 같은 동시성 기능을 활용해 무거운 업데이트를 지연시키고 사용자 입력에 대한 UI 반응성을 우선순위에 둘 수 있습니다 [24, 25].
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+- [[React Compiler]]
+  - 연결 이유: 개발자가 수동으로 리렌더링을 최적화하던 기존 방식을 대체하여, 빌드 타임에 자동으로 메모이제이션을 적용하는 2025년 기준 핵심 기술이기 때문입니다 [4].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 컴포넌트 전체가 아닌 개별 JSX 요소와 연산이 어떻게 독립적으로 캐싱되는지의 원리와 서드파티 라이브러리 호환성 한계 [19, 26].
+
+- [[State Management (Zustand vs Context)]]
+  - 연결 이유: 불필요한 전체 리렌더링을 유발하는 Context API의 구조적 한계를 Zustand의 선택자(Selector) 패턴이 어떻게 극복하여 렌더링을 최적화하는지 설명하기 때문입니다 [13, 17].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 자주 변경되는 전역 상태 관리에서 React 렌더링 사이클 외부의 스토어가 어떻게 컴포넌트 렌더링을 정밀하게 제어하는지 [17, 27].
+
+- [[Memoization (useMemo, useCallback)]]
+  - 연결 이유: React의 얕은 비교(Shallow comparison) 특성을 극복하고 참조 동등성을 유지하여 `React.memo`와 결합한 리렌더링 최적화의 기반이 되기 때문입니다 [10].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 무분별한 메모이제이션이 오히려 렌더링 비용보다 큰 성능 오버헤드를 유발하는 이유와 올바른 적용 조건 [11, 12].
+
+### Deeper Research Questions
+- React Compiler가 적용된 환경에서 기존 `React.memo`, `useMemo`, `useCallback`으로 작성된 수동 메모이제이션 코드는 어떤 방식으로 리팩토링되거나 공존해야 하는가?
+- Context API를 다수의 작은 도메인으로 분할하는 아키텍처와 Zustand를 도입하여 선택자를 사용하는 아키텍처 간의 렌더링 성능 및 유지보수성 트레이드오프는 무엇인가?
+- 대규모 리스트에서 안정적인 `key` 속성 부여와 가상화(Windowing) 기법을 함께 적용할 때, DOM 노드 관리와 메모리 가비지 컬렉션 측면에서 내부적으로 어떤 최적화가 발생하는가?
+- JSX 내 익명 함수 사용이 유발하는 참조 변경(Reference change) 문제를 `useCallback` 외에 컴포넌트 외부 선언 방식 등으로 해결할 때 발생하는 상태 접근성 제약은 어떻게 극복할 수 있는가?
+- `useTransition`과 `useDeferredValue`를 활용한 동시성 렌더링(Concurrent rendering)이 리렌더링을 차단하지 않고 지연시킬 때, 무거운 연산이 메인 스레드를 점유하는 한계는 어떻게 보완할 수 있는가?
+
+### Practical Application Contexts
+- **Implementation:** 무거운 컴포넌트나 자식에게 전달되는 함수/객체 prop에 대해 `React.memo()`, `useCallback`, `useMemo`를 선택적으로 적용하여 리렌더링을 방지합니다 [7, 10]. 대규모 리스트 구현 시 `react-window`를 사용합니다 [6].
+- **System Design:** 애플리케이션의 전역 상태를 설계할 때, 테마나 다국어처럼 변경이 적은 정적 데이터는 Context API를, 알림이나 장바구니처럼 빈번하게 변경되는 동적 데이터는 부분 구독(Selector)을 지원하는 외부 상태 라이브러리(Zustand 등)로 설계하여 렌더링 범위를 제한합니다 [18, 28, 29].
+- **Operation / Maintenance:** React DevTools Profiler, `why-did-you-render` 라이브러리, Chrome DevTools Performance Tab을 활용하여 프로덕션 배포 전 및 운영 중에 불필요한 리렌더링과 그 원인을 지속적으로 측정하고 개선합니다 [30-32].
+- **Learning Path:** React의 기본 렌더링 동작 원리(상태, props, 참조 동등성)를 먼저 학습하고 수동 메모이제이션의 비용을 이해한 뒤, 동시성 기능(Concurrent Features)과 React Compiler를 통한 자동화 최적화 패러다임으로 지식을 확장합니다 [5].
+- **My Project Relevance:** 현재 유지보수하거나 새로 구축하는 React 프로젝트에서 성능 저하를 겪고 있다면, 익명 함수 인라인 작성 패턴을 수정하고, 불필요한 거대 Context를 분리하며, 식별 가능한 병목 지점에 프로파일링 기반의 메모이제이션을 적용해 즉각적인 성능 개선을 이룰 수 있습니다 [5, 15, 22].
+
+### Adjacent Topics
+- [[Core Web Vitals (INP, FCP, TTI)]]
+  - 확장 방향: 프론트엔드 코드의 리렌더링 최적화가 실제 사용자의 체감 성능을 측정하는 지표(특히 Interaction to Next Paint)에 브라우저 레벨에서 어떤 영향을 미치는지 확장하여 조사합니다 [2, 33].
+- [[Code Splitting & Lazy Loading]]
+  - 확장 방향: 컴포넌트 업데이트 시점(리렌더링)의 최적화뿐만 아니라, 컴포넌트 최초 로드 시점의 번들 크기를 줄여 초기 렌더링 성능을 극대화하는 `React.lazy`와 동적 임포트 기법을 함께 학습합니다 [34].
+
+---
+*Last updated: 2026-04-30*
\ No newline at end of file
diff --git a/10_Wiki/Topics_Blog/React 18 Concurrent Features.md b/10_Wiki/Topics_Blog/React 18 Concurrent Features.md
new file mode 100644
index 00000000..a5c653e9
--- /dev/null
+++ b/10_Wiki/Topics_Blog/React 18 Concurrent Features.md	
@@ -0,0 +1,50 @@
+# [[React 18 Concurrent Features]]
+
+## 📌 Brief Summary
+React 18 Concurrent Features(동시성 기능)는 업데이트가 발생하는 시점과 방식을 제어하여 응답성을 희생하지 않으면서도 더 매끄러운 앱을 구축할 수 있게 해주는 기능이다 [1]. 이 렌더링 모델은 React가 렌더링 작업을 일시 중지(pause), 중단(interrupt), 재개(resume)할 수 있도록 허용하여 중요도에 따른 업데이트 우선순위 지정을 가능하게 한다 [2]. 대표적인 훅(Hook)인 `useTransition`과 `useDeferredValue`를 통해 느린 렌더링이 중요한 사용자 상호작용을 차단하지 못하게 방지할 수 있다 [3, 4].
+
+## 📖 Core Content
+*   **동시성 렌더링의 원리와 장점**
+    동시성 렌더링은 무거운 필터 업데이트와 같은 작업은 지연시키면서, 클릭이나 타이핑 등 중요하고 즉각적인 상호작용을 우선적으로 처리할 수 있게 한다 [2]. 최신 버전의 React에서는 개발자가 수동으로 활성화할 필요 없이 기본 동작으로 내장되어 작동한다 [2]. 이 기능은 앱을 실제로 더 빠르게 만든다기보다는, 백그라운드 작업이 진행되는 동안 UI의 응답성을 유지하여 사용자가 느끼는 체감 속도(perceived speed)를 우선시한다 [4].
+*   **`useTransition` (UX 응답성 우선순위 지정)**
+    이 훅은 특정 업데이트를 '비긴급(non-urgent)'으로 표시하는 역할을 한다 [3]. 예를 들어 라이브 검색 결과나 대규모 데이터를 필터링할 때, 렌더링 처리가 느려지더라도 사용자의 타이핑이나 클릭 같은 중요한 상호작용이 차단되지 않는다 [3]. 처리 대기 중인 상태(`isPending`)를 활용하여 렌더링을 차단하지 않고 로딩 스피너나 스켈레톤 상태를 표시할 수 있다 [3].
+*   **`useDeferredValue` (파생 데이터 처리 지연)**
+    `useTransition`이 업데이트가 트리거되는 시점을 제어한다면, `useDeferredValue`는 무거운 값을 '읽는(read)' 시점을 제어한다 [4]. 사용자의 타이핑과 같은 UI 변경은 즉각적으로 반영하되, 파생된 무거운 연산이나 필터링 로직은 약간 지연시켜 적용해야 할 때 이상적인 방법이다 [4]. 주로 검색 상자, Typeahead 입력기, 실시간 폼 등에서 끊김 현상(jank)을 줄이는 데 사용된다 [4].
+*   **모범 사례 및 프레임워크 생태계 지원**
+    동시성 기능은 앱의 모든 곳이 아닌 '인터랙티브 뷰'에 한정하여 사용해야 한다 [4]. 데이터가 로드되는 동안 대체 UI를 표시하기 위해 `Suspense`와 결합하는 것이 권장되며, 구형 상태 관리 라이브러리나 렌더링을 차단하는 안티 패턴과 함께 사용하는 것은 피해야 한다 [4]. 2025년 기준 Next.js(App Router), Remix, Vite 기반 환경 등 대다수의 풀스택 프레임워크가 동시성 렌더링을 기본적으로 연동하고 지원한다 [5].
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+- [[useTransition]]
+  - 연결 이유: React 18 동시성 기능의 핵심 훅으로, 비긴급 업데이트를 지연시키는 구체적인 구현체이다 [3].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 라이브 검색이나 필터링 시 렌더링 병목 현상을 방지하고, 어떻게 비긴급 작업과 긴급 상호작용(타이핑 등)을 분리하는지 이해할 수 있다 [3].
+- [[useDeferredValue]]
+  - 연결 이유: 값의 읽기를 지연시켜 UI 업데이트와 연산 부하를 분리하는 동시성 기능의 또 다른 핵심 훅이다 [4].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 즉각적인 UI 반영이 필요한 부분과 지연시켜도 무방한 무거운 계산(derived data)을 어떻게 나누어 처리하는지 알 수 있다 [4].
+- [[Suspense]]
+  - 연결 이유: 동시성 훅(`useTransition` 등)과 결합하여 백그라운드 렌더링이 진행되거나 데이터가 로드될 때 스켈레톤(fallback UI)을 보여줄 수 있도록 설계된 기능이다 [4].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 지연 중인 렌더링 상태에서 사용자의 경험(UX)을 어떻게 부드럽게 이어갈 수 있는지 이해할 수 있다 [4].
+
+### Deeper Research Questions
+- `useTransition`과 `useDeferredValue`를 사용할 때 React 내부적으로 메인 스레드의 유휴 시간(idle time)을 어떻게 판단하여 작업을 중단 및 재개하는가?
+- 구형 상태 관리 라이브러리나 클래스 기반 컴포넌트를 동시성 기능과 혼용했을 때 구체적으로 어떤 렌더링 차단 충돌이나 예외가 발생하는가?
+- 동시성 렌더링을 적용했을 때 Interaction to Next Paint (INP)나 Total Blocking Time (TBT)과 같은 Core Web Vitals 지표가 수치상으로 어떻게 변화하는가?
+- Next.js의 App Router와 결합된 동시성 렌더링에서, 서버 컴포넌트(Server Components)와 클라이언트 컴포넌트 간의 렌더링 우선순위는 어떻게 관리되는가?
+- `isPending` 속성을 활용해 대체 UI(스켈레톤, 스피너)를 구현할 때 시각적 깜빡임을 최소화하기 위한 이상적인 지연 시간 설계 패턴은 무엇인가?
+
+### Practical Application Contexts
+- **Implementation:** 라이브 검색 결과 렌더링이나 수천 개의 항목이 있는 데이터 목록을 필터링할 때 `useTransition`을 도입하여 입력창의 입력이 지연되지 않도록 구현한다 [3].
+- **System Design:** 검색 상자, Typeahead 입력기, 또는 실시간 폼을 설계할 때 즉각적인 입력 렌더링과 연산이 무거운 데이터 렌더링 간의 영향을 차단하기 위해 `useDeferredValue` 아키텍처를 도입한다 [4].
+- **Operation / Maintenance:** Chrome DevTools의 Performance 탭과 Web Vitals 지표를 통해 긴 작업(Long tasks)이 동시성 렌더링 덕분에 성공적으로 쪼개져 메인 스레드 차단을 줄였는지 지속적으로 모니터링한다 [6, 7].
+- **Learning Path:** React의 기본 렌더링 모델(props 및 state 변경에 따른 리렌더링 트리거)을 명확히 이해한 다음, 동시성 기능을 통해 이러한 렌더링 사이클이 어떻게 일시 중지되고 재개될 수 있는지 학습을 확장한다 [2, 8].
+- **My Project Relevance:** 현재 진행 중인 프로젝트에서 데이터가 많은 차트나 테이블 필터링 시 UI가 끊기는(Jank) 현상이 있다면, 이 동시성 기능 훅을 도입하여 즉각적인 클릭/입력 응답성을 확보할 수 있다 [3, 4].
+
+### Adjacent Topics
+- [[React Performance Optimization]]
+  - 확장 방향: 동시성 렌더링 외에도 불필요한 리렌더링 자체를 막는 `React.memo`, `useCallback`, `useMemo` 활용법과 같은 다양한 React 성능 최적화 기법 전반으로 지식을 확장할 수 있다 [9-11].
+- [[Server Components]]
+  - 확장 방향: Next.js에서 동시성 기능과 함께 성능 향상의 양대 축을 이루는 기능으로, 클라이언트 측 JavaScript를 전송하지 않고 서버에서 렌더링을 완료하여 번들 크기를 줄이는 전략을 학습할 수 있다 [12, 13].
+
+---
+*Last updated: 2026-04-30*
\ No newline at end of file
diff --git a/10_Wiki/Topics_Blog/React Codebase Refactoring.md b/10_Wiki/Topics_Blog/React Codebase Refactoring.md
new file mode 100644
index 00000000..53140358
--- /dev/null
+++ b/10_Wiki/Topics_Blog/React Codebase Refactoring.md	
@@ -0,0 +1,64 @@
+# [[React Codebase Refactoring]]
+
+## 📌 Brief Summary
+React 코드베이스 리팩토링은 기존 앱의 외부 동작을 변경하지 않으면서 유지보수성, 성능, 가독성을 향상시키기 위해 코드를 재설계하고 정리하는 과정입니다. 대규모 React 앱에서 자주 발생하는 논리 결합, 불필요한 재렌더링, 전역 상태의 남용 등의 아키텍처 문제를 해결하는 데 중점을 둡니다. 성공적인 리팩토링을 위해서는 단위 테스트로 안전망을 확보한 후, 컴포넌트 책임 분리, TypeScript 도입, 상태 관리 도구의 현대화를 점진적으로 수행하는 것이 권장됩니다 [1-3].
+
+## 📖 Core Content
+*   **테스트 주도 접근 (Test-Driven Approach):** 리팩토링 도중 기존 기능이 손상되는 것을 방지하기 위해 가장 먼저 단위 테스트(Unit Test)나 UI 테스트 스위트를 작성해야 합니다. 이를 통해 코드의 기존 동작을 보장하며 안전하게 수정할 수 있습니다 [2, 4, 5].
+*   **점진적 마이그레이션 (Incremental Migration):** 전체 코드를 한 번에 재작성(Rewrite)하는 것은 위험도가 높으므로, 점진적인 접근이 필요합니다. 예를 들어 Context API에서 Zustand로 상태 관리를 변경할 때, 하나의 스토어나 기능 단위로 단계별 마이그레이션을 진행해야 비즈니스 개발의 중단 없이 아키텍처를 현대화할 수 있습니다 [1].
+*   **구조 및 컴포넌트 책임 분리 (Separation of Concerns):** 300줄 이상의 방대한 컴포넌트는 단일 책임 원칙(SRP)에 따라 더 작고 초점이 맞춰진 컴포넌트로 분리해야 합니다 [6, 7]. 데이터 페칭이나 폼 처리와 같은 비즈니스 로직은 커스텀 훅(Custom Hooks)으로 추출하여 UI 컴포넌트와 완전히 분리하는 것이 좋습니다 [8, 9].
+*   **상태 관리의 현대화:** 과거의 거대한 단일 전역 상태를 역할에 맞게 분리해야 합니다. API에서 가져오는 '서버 상태'는 TanStack Query(React Query)와 같은 데이터 페칭 라이브러리에 위임하고, '클라이언트 상태'는 Zustand와 같은 가벼운 라이브러리나 지역 상태(Local State)를 활용하여 관리하도록 개선해야 합니다 [10-12].
+*   **도구 및 컨벤션의 적용:** JavaScript 기반 코드는 TypeScript로 마이그레이션하여 타입 안정성을 확보하는 것이 좋습니다 [3, 11]. 또한, ESLint와 같은 도구를 도입해 코드 포맷팅과 아키텍처 규칙(예: 모듈 간 의존성 규칙)을 자동으로 강제해야 하며, 인라인 스타일이나 여러 방식이 혼재된 CSS를 한 가지 방식(예: CSS Modules, Tailwind 등)으로 통일해야 합니다 [13-15].
+*   **과거의 패턴 제거:** 클래스형 컴포넌트가 있다면 함수형 컴포넌트와 훅(Hooks)으로 교체해야 합니다 [11]. 최신 React(예: React 19)나 React Compiler를 사용하는 환경이라면 불필요한 `useEffect`, `useMemo`, `useCallback` 등을 제거하여 코드를 더욱 간결하게 만들 수 있습니다 [11, 16, 17].
+
+## ⚖️ Trade-offs & Caveats
+*   **추상화의 함정과 오버엔지니어링 (KISS vs DRY):** DRY(Don't Repeat Yourself) 원칙을 따르기 위해 성급하게 공통 로직을 추상화하면, 코드가 원래의 반복된 코드보다 더 복잡해지고 이해하기 어려워지는 부작용이 발생할 수 있습니다. 전문가들은 패턴이 3번 이상 반복될 때까지 기다렸다가 추상화(Custom Hook 등)를 진행할 것을 권장합니다 [18].
+*   **TypeScript 채택의 인지적 부하:** 리팩토링 시 TypeScript를 도입하는 것은 장기적 안정성을 보장하지만, 경험이 부족한 개발팀에게는 새로운 복잡성 레이어로 작용하여 초기에 생산성을 늦출 수 있습니다. 따라서 강제 도입보다는 개별 파일부터 점진적으로 전환하는 것이 추천됩니다 [3].
+*   **아키텍처 도입 비용:** Feature-Sliced Design(FSD)과 같이 엄격한 계층 구조를 강제하는 아키텍처로 폴더 구조를 리팩토링하는 것은 큰 학습 곡선과 설정 비용을 수반합니다. 팀 전체의 이해도가 없으면 오히려 시스템이 엉망이 되거나 소규모 프로젝트에서는 과도한 설계(Overkill)가 될 수 있습니다 [19-21].
+*   **완전 재작성(Rewrite)의 위험성:** 프로젝트가 매우 작다면 아예 처음부터 새로 작성하는 것이 빠를 수도 있으나 [4], 일반적인 환경에서는 기존 기능을 그대로 유지하면서 코드를 개선해야 하므로 전면 재작성보다는 안전성을 담보한 점진적 리팩토링이 필수적입니다 [1].
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+
+#### [관계 유형 A (아키텍처/기반 기술)]
+- [[Feature-Sliced Design]]
+  - 연결 이유: 리팩토링 과정에서 기술 단위(Component, Hooks 등)로 흩어진 기존 폴더 구조를 기능(Feature) 중심으로 모듈화하고 재편할 때 기준이 되는 현대적인 프론트엔드 아키텍처론입니다 [22, 23].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 확장성을 위한 단방향 의존성 규칙과 도메인 중심의 코드 캡슐화 설계 방법.
+- [[SOLID Principles]]
+  - 연결 이유: 거대한 React 컴포넌트를 작게 분리하고 인터페이스를 구성할 때, 단일 책임 원칙(SRP)과 같은 클린 코드의 기반 지침을 제공합니다 [6, 24].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 리액트 컴포넌트의 책임을 올바르게 분리하고 유지보수하기 쉬운 추상화를 설계하는 기준.
+
+#### [관계 유형 B (구현/활용 도구)]
+- [[TanStack Query]]
+  - 연결 이유: 기존의 비효율적인 Context API나 거대한 Redux 스토어를 리팩토링할 때, 서버 상태(캐싱, 동기화 등)를 깔끔하게 분리해 주는 핵심 도구입니다 [10, 11].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 서버 데이터 페칭 로직의 분리와 컴포넌트 내 복잡한 상태 관리 감소 방법.
+- [[Zustand]]
+  - 연결 이유: 불필요한 재렌더링을 유발하는 기존의 Context API 기반 상태 관리를 리팩토링할 때 주로 도입되는 경량 클라이언트 상태 관리 라이브러리입니다 [1, 25].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 상태 선택자(Selector)를 통한 렌더링 최적화 구조 및 보일러플레이트 없는 상태 관리 로직 작성법.
+- [[Unit Testing]]
+  - 연결 이유: 리팩토링 시 코드를 변경하더라도 기존의 비즈니스 로직이 파괴되지 않음을 보장하기 위해 리팩토링 작업에 선행되어야 하는 기술입니다 [2, 5].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 기존 코드를 검증 가능한 형태로 쪼개고 안전성을 확보하는 실질적인 엔지니어링 절차.
+
+### Deeper Research Questions
+- 레거시 React 앱에서 Context API를 Zustand로 점진적으로 마이그레이션할 때(Incremental Migration), 상태 충돌을 방지하기 위한 가장 안전한 전략은 무엇인가?
+- 대규모 리팩토링 진행 시, Feature-Sliced Design(FSD) 아키텍처를 도입할 때 기존 컴포넌트 간의 결합(Cross-cutting concerns)을 어떻게 계층적으로 분리할 수 있는가?
+- React Compiler 환경이 도입되었을 때, 리팩토링 시 기존 코드에 남용된 `useMemo`와 `useCallback`을 제거하는 것이 런타임 성능 및 코드 가독성에 어떤 구체적인 이점을 주는가?
+- 비즈니스 로직이 혼재된 거대한 폼(Form) 컴포넌트를 리팩토링할 때 단일 책임 원칙(SRP)과 YAGNI 원칙 간의 균형을 맞추는 기준은 무엇인가?
+- 대규모 TypeScript 마이그레이션을 진행할 때 개발 생산성 저하를 방지하면서 점진적 타입 정의를 적용하는 모범 사례는 무엇인가?
+
+### Practical Application Contexts
+- **Implementation:** 비대해진 React 컴포넌트에서 API 호출과 상태 관리 로직을 분리하여 Custom Hook으로 작성하고, ESLint를 도입하여 코드 컨벤션과 아키텍처 규칙 위반을 린트(Lint) 단계에서 차단합니다.
+- **System Design:** 프로젝트의 파일 디렉토리 구조를 단순한 기능별(File-type based) 분류에서 Feature-Sliced Design과 같은 도메인/비즈니스 중심의 계층형 구조로 재설계합니다.
+- **Operation / Maintenance:** 서비스를 중단하지 않기 위해 한 번에 모든 시스템을 바꾸지 않고, 하나의 스토어나 특정 기능 모듈 단위로 리팩토링을 수행하는 점진적 접근법을 운영합니다.
+- **Learning Path:** React 기초 습득 ➔ Clean Code 및 SOLID 원칙 이해 ➔ 상태 관리의 세분화(서버 데이터 vs UI 상태) ➔ 단위 테스트 작성 ➔ 점진적 리팩토링 적용 순으로 엔지니어링 역량을 확장합니다.
+- **My Project Relevance:** 현재 유지보수하고 있는 복잡한 레거시 React 프로젝트의 성능 및 유지보수성 저하 원인을 분석하고, 컴포넌트 분리와 상태 관리 라이브러리(Zustand, React Query) 교체 작업을 체계적으로 기획할 때 직접 적용할 수 있습니다.
+
+### Adjacent Topics
+- [[Web Performance Optimization]]
+  - 확장 방향: 리팩토링의 궁극적 결과물 중 하나인 초기 로딩 속도 향상, 렌더링 최적화, 그리고 불필요한 번들 사이즈를 줄이는 코드 스플리팅(Code Splitting) 기법 등으로 개념을 확장하여 학습할 수 있습니다.
+- [[Git Workflow & CI/CD]]
+  - 확장 방향: 대규모 리팩토링 시 발생할 수 있는 브랜치 충돌 방지와 코드 리뷰 자동화, 그리고 Pull Request 과정에서 Visual Regression Testing을 연동하는 등 협업 전략으로 확장할 수 있습니다.
+
+---
+*Last updated: 2026-04-30*
\ No newline at end of file
diff --git a/10_Wiki/Topics_Blog/React DevTools Profiler.md b/10_Wiki/Topics_Blog/React DevTools Profiler.md
new file mode 100644
index 00000000..0ed6a720
--- /dev/null
+++ b/10_Wiki/Topics_Blog/React DevTools Profiler.md	
@@ -0,0 +1,52 @@
+# [[React DevTools Profiler]]
+
+## 📌 Brief Summary
+React DevTools Profiler는 React 애플리케이션의 렌더링 성능을 측정하고 최적화 대상을 식별하기 위해 React DevTools에 내장된 프로파일링 및 디버깅 도구이다 [1]. 이 도구는 어떤 컴포넌트가 언제, 얼마나 오래 렌더링되었는지, 그리고 어떤 요인(props, state 변경 등)이 렌더링을 유발했는지 파악하는 데 사용된다 [1, 2]. 주로 로컬 개발 환경에서 성능 병목 현상을 식별하고 불필요한 리렌더링을 찾아내는 데 핵심적으로 활용된다 [3].
+
+## 📖 Core Content
+* **렌더링 추적 및 시각화**: Profiler는 특정 props나 상태(state) 변경 등 컴포넌트의 렌더링이 발생한 정확한 원인을 추적할 수 있게 해준다 [1, 2]. 플레임그래프(Flamegraph)와 순위 뷰(Ranked views)를 제공하여 성능 병목 지점을 시각적으로 쉽게 식별할 수 있도록 돕는다 [2].
+* **최적화 필요성 검증 (측정 기반 최적화)**: `React.memo`와 같은 메모이제이션 기술을 적용하기 전에, 컴포넌트의 리렌더링 비용이 최적화 오버헤드를 감수할 만큼 큰지 측정하는 데 사용된다 [4]. 또한, 메모이제이션된 컴포넌트 내의 prop 변경을 추적하여 자식 컴포넌트가 불필요하게 리렌더링되는지 파악할 수 있다 [5]. "측정하지 않았다면 최적화하지 말라"는 원칙에 따라, 프로파일링은 성능 핫스팟에만 집중하도록 돕는다 [2, 6].
+* **React Compiler 시각화**: React Compiler가 적용된 환경에서는 Profiler 탭에서 자동 최적화된 컴포넌트에 `Memo ✨` 배지가 표시된다 [7, 8]. 입력값이 변경되지 않아 리렌더링을 건너뛴 자식 컴포넌트는 회색으로 표시되며, 마우스를 올리면 자동 메모이제이션 및 리렌더링 생략 여부를 확인하는 툴팁이 나타난다 [8].
+* **블랙박스 환경에서의 디버깅 필수성**: React Compiler 도입 시 기존의 명시적인 `React.memo`, `useMemo`, `useCallback` 호출이 코드에서 사라져 렌더링 제어가 블랙박스처럼 작동하게 된다 [9]. 따라서 예상치 못한 리렌더링 문제가 발생했을 때, 이를 코드 상에서 확인하는 대신 Profiler를 통해 직접 조사해야 하므로 그 중요성이 더욱 커진다 [9].
+
+## ⚖️ Trade-offs & Caveats
+* **해석상의 주의점 (`Memo ✨` 배지의 함정)**: Profiler 탭에서 확인할 수 있는 `Memo ✨` 배지는 다소 오해를 불러일으킬 수 있다 [10]. 이 배지는 React Compiler가 해당 컴포넌트를 처리(Compile)했음을 나타낼 뿐, 최적화가 완벽하게 성공했음을 의미하지는 않는다 [10]. 컴포넌트에 배지가 표시되어 있더라도, 인라인 객체나 함수와 같은 불안정한 참조를 가진 props가 전달된다면 컴파일러가 리렌더링을 막지 못해 여전히 매번 렌더링이 발생할 수 있다 [10].
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+
+#### [관계 유형 A: 아키텍처/기반 기술]
+- [[React Compiler]]
+  - 연결 이유: React Compiler가 빌드 타임에 주입한 자동 메모이제이션 로직의 성공 여부와 렌더링 스킵 결과를 Profiler를 통해 시각적으로 확인할 수 있다 [7-9].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 명시적인 메모이제이션 코드 없이도 렌더링 성능이 최적화되는 원리와, 블랙박스화된 렌더링 메커니즘을 디버깅하는 방법 [9, 11].
+
+#### [관계 유형 B: 구현/활용 도구]
+- [[React.memo]]
+  - 연결 이유: Profiler를 통해 특정 컴포넌트의 렌더링 빈도와 비용을 측정한 뒤, 그 결과에 따라 `React.memo` 적용이 성능 향상에 실질적인 도움이 될지 판단할 수 있다 [4].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 얕은 비교(Shallow comparison)의 원리와 프로파일링 데이터에 기반한 전략적 메모이제이션 방법 [4, 12, 13].
+- [[useCallback & useMemo]]
+  - 연결 이유: Profiler에서 자식 컴포넌트가 참조(Reference) 변경 때문에 계속 리렌더링되는 것을 발견했다면, 이 훅들을 사용하여 참조 안정성(Reference stability)을 확보할 수 있다 [5, 14].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 함수나 객체의 참조 동일성이 컴포넌트 렌더링 트리에 미치는 직접적인 영향 [14].
+
+### Deeper Research Questions
+- React DevTools Profiler의 플레임그래프(Flamegraph)와 순위 뷰(Ranked view)를 어떻게 분석해야 성능 병목 현상을 가장 빠르고 정확하게 찾아낼 수 있는가?
+- 명시적인 메모이제이션 훅이 제거되는 React Compiler 환경에서, Profiler를 통한 성능 디버깅 워크플로우는 기존과 구체적으로 어떻게 달라지는가?
+- Profiler를 통해 식별된 불필요한 렌더링 문제를 해결할 때, 어떤 상황에서 구조 재설계(예: Context API 대신 Zustand 도입)가 단순한 메모이제이션 적용보다 더 나은 선택이 되는가?
+- 로컬 환경의 Profiler에서 관찰되는 렌더링 시간과 프로덕션 환경의 실제 사용자 체감 성능(Core Web Vitals의 INP 등) 간의 차이를 어떻게 보정하여 분석할 수 있는가?
+
+### Practical Application Contexts
+- **Implementation:** 렌더링 최적화 코드를 무작정 추가하기 전에, Profiler를 실행하여 실제 렌더링 빈도와 실행 시간을 측정함으로써 렌더링이 무거운(expensive) 컴포넌트를 정확히 식별한다 [4, 6].
+- **System Design:** Context API의 값이 변경될 때 얼마나 많은 자식 컴포넌트가 불필요하게 렌더링되는지 확인하고, 글로벌 상태 관리 라이브러리(Zustand 등) 도입이나 상태 도메인 분리의 기술적 타당성을 검증한다 [15-18].
+- **Operation / Maintenance:** 레거시 코드베이스를 유지보수하거나 새로운 기능을 릴리스한 직후, 플레임그래프를 정기적으로 리뷰하여 의도치 않은 성능 회귀(Regression)를 식별하고 관리한다 [19].
+- **Learning Path:** React 입문자나 팀원들이 Props, State, Context가 변경될 때 컴포넌트가 어떻게 반응하고 재렌더링되는지를 시각적으로 보여줌으로써 렌더링 모델을 깊게 이해시킨다 [1, 20].
+- **My Project Relevance:** 화면 내 대용량 리스트나 복잡한 필터를 조작할 때 발생하는 지연 현상(Jank)의 원인이 렌더링 시간 자체인지, 아니면 불필요한 연쇄 리렌더링 때문인지 진단하고 해결책을 마련한다 [21, 22].
+
+### Adjacent Topics
+- [[why-did-you-render]]
+  - 확장 방향: Profiler와 결합하여 사용할 수 있는 라이브러리로, 실제 데이터 변경이 없음에도 불구하고 컴포넌트가 리렌더링된 '정확한 이유'를 콘솔에 경고 형태로 남겨주어 디버깅을 더욱 쉽게 만들어주는 도구에 대해 조사한다 [3, 23].
+- [[Chrome DevTools Performance Tab]]
+  - 확장 방향: Profiler가 알려주는 React 내부의 렌더링 속도 이외에, 프레임 드롭이나 메인 스레드를 막는 무거운 자바스크립트 실행, 레이아웃 이동 등 브라우저 레벨의 전체적인 성능 분석으로 시야를 확장한다 [3, 23].
+
+---
+*Last updated: 2026-04-30*
\ No newline at end of file
diff --git a/10_Wiki/Topics_Blog/React.lazy().md b/10_Wiki/Topics_Blog/React.lazy().md
new file mode 100644
index 00000000..afb49c8c
--- /dev/null
+++ b/10_Wiki/Topics_Blog/React.lazy().md
@@ -0,0 +1,65 @@
+# [[React.lazy()]]
+
+## 📌 Brief Summary
+`React.lazy()`는 리액트(React)에서 컴포넌트를 필요한 시점에 동적으로 불러올 수 있게 해주는 내장 함수입니다 [1]. 이 기능을 동적 임포트(Dynamic Imports)와 결합하면 거대한 자바스크립트 번들을 더 작은 청크(Chunk)로 나눌 수 있습니다 [2, 3]. 결과적으로 사용자가 앱에 처음 접근할 때 다운로드해야 하는 초기 자바스크립트 페이로드 크기를 대폭 줄여 앱의 초기 로드 속도와 전반적인 성능을 크게 향상시킵니다 [2-4].
+
+## 📖 Core Content
+*   **코드 스플리팅(Code Splitting)과 번들 사이즈 감소:**
+    초기 로드 시 모든 코드를 한 번에 불러오면 번들 크기가 비대해져 성능 저하가 발생합니다 [5]. `React.lazy()`를 사용하면 거대한 애플리케이션 코드를 잘게 쪼개어, 특정 라우트나 컴포넌트가 렌더링될 때만 해당 코드를 네트워크를 통해 다운로드하도록 구성할 수 있습니다 [1, 6, 7].
+*   **Suspense와의 결합:**
+    `React.lazy()`로 불러오는 컴포넌트는 반드시 `<Suspense>` 컴포넌트로 감싸주어야 합니다 [1, 3]. `<Suspense>`는 모듈이 로드되는 동안 사용자에게 보여줄 대체 UI(예: 로딩 스피너)를 `fallback` 속성을 통해 정의하여 사용자 경험을 매끄럽게 만듭니다 [1, 3, 8].
+*   **적용 대상(Use Cases):**
+    *   **라우트 기반 컴포넌트(Route-based components):** 사용자가 특정 페이지로 이동할 때만 해당 페이지 코드를 로드합니다 [8, 9].
+    *   **사용 빈도가 낮은 뷰:** 관리자 화면이나 설정 패널처럼 드물게 사용되는 화면에 적용합니다 [9].
+    *   **무거운 UI 블록 및 서드파티 통합 기능:** 차트, 지도, 리치 텍스트 에디터, 비디오 플레이어 등 용량이 큰 위젯을 렌더링할 때 유용합니다 [3, 9, 10].
+*   **빌드 도구와의 자동 통합:**
+    Vite나 Webpack과 같은 최신 번들러는 `React.lazy(() => import('./Component'))` 문법을 자동으로 인식하여 해당 컴포넌트를 별도의 파일(청크)로 분리해 컴파일합니다 [2, 3, 8].
+
+## ⚖️ Trade-offs & Caveats
+*   **어보브 더 폴드(Above-the-fold) 요소 적용 금지:** 사용자가 페이지에 진입하자마자 즉시 보아야 하는 필수적인 컴포넌트나 빠르게 렌더링되어야 하는 요소에 `React.lazy()`를 적용하면 안 됩니다 [9]. 이를 지연 로딩할 경우 불필요한 네트워크 지연이 발생하여 오히려 체감 성능과 사용자 경험이 하락합니다 [9].
+*   **레이아웃 시프트 및 사용자 경험 저하:** 비동기 로딩 중 `<Suspense>`의 `fallback`이 화면에 나타나면서, 로딩이 끝난 후 본래 컴포넌트로 전환될 때 레이아웃이 밀리거나 깜빡거리는 현상이 발생할 수 있습니다 [1, 11].
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+
+#### [아키텍처/기반 기술]
+- [[Code Splitting]]
+  - 연결 이유: `React.lazy()`의 존재 목적이자 근본적인 성능 최적화 기법입니다 [6].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 초기 렌더링 시 불필요한 자바스크립트 번들 크기를 줄여 로딩 성능을 최적화하는 애플리케이션 구조 원리.
+- [[Dynamic Imports]]
+  - 연결 이유: `React.lazy()` 함수 내부에서 비동기적으로 모듈을 로드하기 위해 사용하는 표준 자바스크립트 문법(`import()`)입니다 [2, 3, 8].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 브라우저가 특정 코드가 실행되어야 할 시점에 네트워크 요청을 생성하여 모듈을 가져오는 메커니즘.
+
+#### [구현/활용 도구]
+- [[Suspense]]
+  - 연결 이유: `React.lazy()`로 분리된 코드가 백그라운드에서 다운로드되는 동안 앱이 멈추지 않도록 로딩 UI를 처리하기 위해 필수적으로 결합되는 리액트 기능입니다 [1, 3].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 비동기 렌더링 흐름에서 로딩 상태(Loading State)를 컴포넌트 트리 상단에서 선언적으로 처리하는 방법.
+- [[Vite/Rollup]]
+  - 연결 이유: 소스 코드에 작성된 `React.lazy()` 구문을 분석하여 빌드 타임에 물리적으로 개별 자바스크립트 파일(청크)로 분할해 내는 도구들입니다 [2, 8].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 모듈 번들러가 코드 스플리팅을 인식하고 프로덕션 환경의 정적 에셋으로 변환하여 캐싱 효율을 높이는 과정.
+
+### Deeper Research Questions
+- `React.lazy()`를 활용한 클라이언트 사이드 코드 스플리팅과 서버 사이드에서 이루어지는 [[React Server Components]]의 성능 최적화 방식은 어떻게 다르며 서로 어떻게 보완될 수 있는가?
+- `<Suspense>`로 감싸진 지연 로딩 컴포넌트가 로드될 때 발생하는 Cumulative Layout Shift (CLS)를 최소화하기 위한 구체적인 UI 패턴과 전략은 무엇인가?
+- 모바일 환경 등 네트워크 속도가 느린 곳에서 `React.lazy()`로 분리된 청크를 불러올 때, 에러가 발생한 경우(예: 배포 후 이전 해시 청크 삭제됨) 이를 Error Boundary로 어떻게 우아하게 복구할 수 있는가?
+- 사용자가 컴포넌트를 요청하기 전(예: 링크에 마우스를 올리는 시점)에 `React.lazy()`로 분리된 청크를 미리 가져오는 프리패치(Prefetching/Preloading) 전략은 어떻게 구현하는가?
+- Vite의 `manualChunks` 설정과 `React.lazy()`를 동시에 활용하여, 핵심 벤더 라이브러리 캐싱과 페이지별 지연 로딩을 결합하는 최적의 빌드 전략은 무엇인가?
+
+### Practical Application Contexts
+- **Implementation:** React 코드 상단에 모듈을 정적 임포트하는 대신, `const LazyComponent = React.lazy(() => import('./LazyComponent'))`로 선언하고, 렌더 트리에 사용할 때 `<Suspense fallback={<Spinner/>}> <LazyComponent/> </Suspense>` 형태로 감싸 구현합니다 [1, 3].
+- **System Design:** 애플리케이션의 라우팅 레이어 설계 시, 모든 라우트를 초기 번들에 묶지 않고 각 페이지 또는 무거운 차트/에디터와 같은 독립적 도메인을 분리하는 기준으로 설계 기준을 수립합니다 [8, 9].
+- **Operation / Maintenance:** `rollup-plugin-visualizer`나 Webpack Bundle Analyzer 등의 도구를 이용해 빌드 후 500KB가 넘어가는 큰 청크(Large chunks)가 있는지 모니터링하고, 발견 시 `React.lazy()`를 사용해 지연 로딩 가능한 부분으로 잘라냅니다 [7, 12, 13].
+- **Learning Path:** React 컴포넌트 생명주기와 렌더링에 대한 이해 → 번들 크기가 성능에 미치는 영향 파악 → `React.lazy`와 `Suspense`를 통한 클라이언트 로딩 최적화 → 더 나아가 서버 사이드 렌더링(SSR) 및 서버 컴포넌트로 확장하는 경로로 학습을 진행합니다.
+- **My Project Relevance:** 현재 유지보수 중인 프로젝트에 모달, 어드민 설정 패널 등 즉시 보이지 않는 컴포넌트들이 메인 번들에 포함되어 있다면, 이를 `React.lazy()`로 리팩토링하여 Time To Interactive (TTI) 지표를 당장 개선하는 데 적용할 수 있습니다.
+
+### Adjacent Topics
+- [[Core Web Vitals]]
+  - 확장 방향: `React.lazy()`를 적용했을 때 First Contentful Paint (FCP)와 Interaction to Next Paint (INP) 같은 구글의 웹 성능 지표가 어떻게 개선되는지 확인하는 방향으로 연구 확장 [1, 5].
+- [[manualChunks]]
+  - 확장 방향: `React.lazy()`에 의한 스플리팅 외에, React 코어나 서드파티 라이브러리들(vendor)을 별도 분리해 브라우저 캐싱을 고도화하는 빌드 도구 수준의 수동 제어 기법 파악 [8, 14].
+- [[React Server Components (RSC)]]
+  - 확장 방향: 자바스크립트를 클라이언트로 아예 보내지 않고 서버에서 렌더링하여 성능을 극대화하는 최신 Next.js 패러다임과 클라이언트 단의 `React.lazy`를 비교 [9, 15].
+
+---
+*Last updated: 2026-04-30*
\ No newline at end of file
diff --git a/10_Wiki/Topics_Blog/Real User Monitoring (RUM).md b/10_Wiki/Topics_Blog/Real User Monitoring (RUM).md
new file mode 100644
index 00000000..fafa3074
--- /dev/null
+++ b/10_Wiki/Topics_Blog/Real User Monitoring (RUM).md	
@@ -0,0 +1,62 @@
+# [[Real User Monitoring (RUM)]]
+
+## 📌 Brief 시 Summary
+Real User Monitoring (RUM)은 다양한 기기와 네트워크 조건에서 사용자가 경험하는 실제 성능과 상호작용을 추적하는 모니터링 방식입니다 [1]. 합성 테스트(Synthetic testing)가 놓칠 수 있는 실제 성능 문제를 파악하는 데 필수적이며 [1], 프론트엔드의 사용자 액션과 백엔드의 인프라 트레이스를 연결하여 전체 시스템에 대한 가시성을 제공합니다 [2].
+
+## 📖 Core Content
+*   **실제 사용자 경험 추적:** RUM은 개발 환경이나 인위적인 합성 테스트 환경에서는 포착하기 어려운 다양한 기기, 브라우저 환경 및 네트워크 조건에서의 실제 사용자 경험 데이터를 수집합니다 [1]. 이를 통해 특정 기기나 브라우저에서만 발생하는 오류를 효과적으로 식별할 수 있습니다 [3].
+*   **엔드투엔드(End-to-End) 트레이싱:** Datadog RUM 등의 도구를 사용하면 프론트엔드와 백엔드 간의 모니터링 격차를 줄일 수 있습니다. 프론트엔드에서 발생한 에러를 클릭하면, 백엔드 서비스, 데이터베이스 및 서드파티 API에 이르는 전체 요청 과정을 분산 트레이싱(Distributed tracing)을 통해 추적할 수 있어 복잡한 시스템의 디버깅을 돕습니다 [2].
+*   **통합 관측성(Unified Observability):** 최신 모니터링 플랫폼에서 RUM은 프론트엔드의 오류 로그뿐만 아니라 인프라 모니터링, 백엔드 APM(Application Performance Monitoring) 등과 한곳에서 결합되어 활용됩니다 [4].
+*   **비용 및 라이선스 모델:** 1,000명의 유저를 대상으로 할 때 기본적인 RUM 기능은 월 $15~$30 수준으로 시작할 수 있으나, 데이터 수집량에 따라 비용이 청구되는 사용량 기반 가격 정책을 따릅니다 [5].
+
+## ⚖️ Trade-offs & Caveats
+*   **데이터 규모에 따른 과도한 비용 청구:** RUM 플랫폼(예: Datadog)은 데이터 수집(Ingest)과 검색을 위한 인덱싱(Index)을 분리하여 요금을 부과하는 '이중 요금제'를 채택하는 경우가 많습니다. 트래픽이 높은 서비스에서는 비용이 기하급수적으로 증가할 수 있으며, 이로 인해 비용 절감을 위해 로그의 20%만 인덱싱하게 되면 장애 발생 시 80%의 주요 디버깅 데이터를 검색할 수 없는 상황에 놓일 수 있습니다 [5, 6].
+*   **프라이버시 및 보안 문제:** 세션 리플레이(Session replay) 등 사용자의 모든 행동을 기록하는 RUM 도구는 민감한 개인정보를 수집할 위험이 있습니다. 엄격해지는 개인정보 보호 규제를 준수하기 위해 민감 데이터를 자동 마스킹하도록 설정하는 데 많은 시간이 소요될 수 있습니다 [7-9].
+*   **초기 로드 성능 저하 (성능 오버헤드):** 프론트엔드에 삽입되는 RUM 추적 스크립트는 번들 크기를 증가시킵니다. 일부 도구의 경우 로드 시간을 최대 120ms까지 지연시킬 수 있으므로, 1초가 중요한 이커머스 등의 사이트에서는 경량화된 옵션을 신중히 선택해야 합니다 [10].
+*   **도입 및 학습 곡선:** 풀스택 관측 플랫폼과 결합된 RUM 도구는 단순 프론트엔드 로깅만 필요한 작은 팀에게는 지나친 오버엔지니어링(Overkill)이 될 수 있으며, 전체 플랫폼을 이해하는 데 가파른 학습 곡선이 요구됩니다 [6, 11].
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+
+#### [관계 유형 A (아키텍처/기반 기술)]
+- [[Synthetic Testing]]
+  - 연결 이유: RUM과 대비되는 모니터링 개념으로, 가상 환경에서 애플리케이션의 성능을 시뮬레이션하여 측정합니다 [1].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 시뮬레이션 데이터와 실제 사용자 경험(RUM) 데이터가 어떻게 상호보완적으로 작용하여 성능 병목 현상을 찾아내는지 이해할 수 있습니다.
+- [[Distributed Tracing]]
+  - 연결 이유: RUM 도구가 프론트엔드의 사용자 동작을 백엔드의 서비스 요청과 연관 짓기 위해 사용하는 핵심 메커니즘입니다 [2, 4, 12].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 마이크로서비스 아키텍처 환경에서 클라이언트 에러의 근본 원인을 백엔드 데이터베이스나 외부 API까지 어떻게 추적하는지 원리를 파악할 수 있습니다.
+- [[Core Web Vitals]]
+  - 연결 이유: RUM을 통해 주로 측정하고 최적화하려는 대상인 실제 사용자 중심의 로딩 속도, 상호작용, 시각적 안정성 지표입니다 [13, 14].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: RUM 데이터가 웹 성능 최적화의 기준(LCP, FID, CLS, INP)과 어떻게 매핑되어 사용자 경험(UX)을 수치화하는지 이해할 수 있습니다.
+
+#### [관계 유형 B (구현/활용 도구)]
+- [[Datadog RUM]]
+  - 연결 이유: 소스에서 엔드투엔드 프론트엔드-백엔드 모니터링을 연결해 주는 대표적인 RUM 플랫폼으로 소개되었습니다 [2].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 대규모 분산 시스템에서 RUM을 활용하는 구체적인 사례와, 인덱싱 비용 최적화(Trade-off) 전략의 중요성을 학습할 수 있습니다.
+- [[Session Replay]]
+  - 연결 이유: 사용자의 상태 변경, 콘솔 로그, 네트워크 요청 등을 마치 화면 녹화처럼 재현하는 RUM의 고급 디버깅 기능입니다 [7, 12, 15].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 스택 트레이스만으로 찾기 힘든 복잡한 사용자 상호작용 오류의 디버깅 방법론과 이에 따른 프라이버시 설정의 중요성을 알 수 있습니다.
+
+### Deeper Research Questions
+- 가상 환경의 성능을 시뮬레이션하는 합성 테스트(Synthetic Testing)와 비교할 때, RUM만이 독점적으로 식별할 수 있는 실제 기기/네트워크 기반의 성능 이슈 패턴은 무엇인가?
+- Datadog과 같은 RUM 솔루션을 활용할 때, 대규모 트래픽 하에서 가시성 손실 없이 데이터 수집(Ingest)과 인덱싱(Indexing) 비용의 트레이드오프를 극복할 수 있는 로그 필터링 전략은 무엇인가?
+- RUM 에이전트의 삽입이 자바스크립트 번들 크기 및 초기 페이지 로드 속도(최대 120ms 추가)에 미치는 성능 오버헤드를 최소화하는 아키텍처 설계 방법은 무엇인가?
+- 글로벌 프라이버시 규제를 준수하면서 Session Replay를 포함한 RUM 데이터를 수집하기 위해, 민감한 DOM 요소나 사용자 입력을 어떻게 효과적으로 마스킹(Masking)할 수 있는가?
+- 프론트엔드 React 컴포넌트에서 발생한 에러를 RUM 데이터와 결합하고, 백엔드의 OpenTelemetry 분산 트레이스와 연결(Trace ID 공유 등)하여 전체 마이크로서비스 흐름에서 근본 원인을 파악하는 구체적인 파이프라인 구축 방법은 무엇인가?
+
+### Practical Application Contexts
+- **Implementation:** React 애플리케이션의 엔트리 포인트에 Datadog이나 Sentry와 같은 RUM 모니터링 SDK를 통합하고, Core Web Vitals 및 세션별 성능 지표를 자동으로 수집하도록 초기화합니다.
+- **System Design:** 사용자의 브라우저에서 발생한 프론트엔드 로그와 API 요청 헤더에 트레이스 ID를 삽입하여, 백엔드 로깅 시스템과 매칭시키는 '엔드투엔드(End-to-End) 모니터링 아키텍처'를 설계합니다.
+- **Operation / Maintenance:** 월별 모니터링 비용(특히 데이터 인덱싱 비용)을 모니터링하여 불필요한 이벤트는 샘플링하고, 데이터 마스킹 규칙을 지속적으로 관리해 GDPR 등의 개인정보 보호 정책을 위반하지 않도록 유지보수합니다.
+- **Learning Path:** 먼저 React의 기본 에러 처리(Error Boundaries)와 브라우저 DevTools를 사용한 메모리 누수 측정을 익힌 후, 프로덕션 환경의 실시간 사용자 데이터를 수집하는 RUM과 백엔드 분산 트레이싱을 학습하여 풀스택 관측성(Observability) 역량을 기릅니다.
+- **My Project Relevance:** 현재 진행 중인 프론트엔드 프로젝트에서 사용자 이탈률이 높은 특정 화면의 병목 지점을 찾기 위해, RUM을 적용하여 실제 모바일 기기와 3G/LTE 환경에서의 INP(Interaction to Next Paint)와 렌더링 지연을 측정 및 개선할 때 활용합니다.
+
+### Adjacent Topics
+- [[OpenTelemetry]]
+  - 확장 방향: 특정 벤더에 종속되지 않고(No vendor lock-in) 오픈 스탠다드 프로토콜을 이용해 RUM, 메트릭, 로그 데이터를 수집하고 백엔드와 연결하는 아키텍처로 지식을 확장할 수 있습니다 [16, 17].
+- [[Error Boundaries]]
+  - 확장 방향: React 애플리케이션 내에서 UI 렌더링 중 발생하는 런타임 에러를 캡처하여 전체 앱의 크래시를 방지하는 개념으로, 여기서 포착된 에러를 RUM 시스템에 보고하는 방식으로 연계할 수 있습니다 [18-20].
+
+---
+*Last updated: 2026-04-30*
\ No newline at end of file
diff --git a/10_Wiki/Topics_Blog/Redux.md b/10_Wiki/Topics_Blog/Redux.md
new file mode 100644
index 00000000..332910b5
--- /dev/null
+++ b/10_Wiki/Topics_Blog/Redux.md
@@ -0,0 +1,53 @@
+# [[Redux]]
+
+## 📌 Brief Summary
+Redux는 예측 가능한 상태 컨테이너로, 불변성을 유지하는 업데이트, 액션 디스패치(action dispatch), 그리고 리듀서(reducer)를 통해 전역 상태를 관리하는 산업 표준 라이브러리이다 [1]. 주로 복잡한 파생 및 계산된 상태가 존재하거나 500개 이상의 컴포넌트를 다루는 대규모 애플리케이션에서 일관된 개발 패턴을 강제하기 위해 채택된다 [2]. RTK Query와 Redux DevTools 같은 성숙한 생태계를 통해 비동기 상태 관리의 복잡성을 줄이고 강력한 디버깅 기능을 제공한다 [2-4].
+
+## 📖 Core 대Content
+*   **상태 관리 아키텍처와 구조화**: Redux는 불변성을 기반으로 상태를 관리하며, 액션과 리듀서 패턴을 통해 애플리케이션의 복잡한 상태 로직을 제어한다 [1]. 모던 프론트엔드 폴더 구조에서 Redux 슬라이스(Redux slices)와 글로벌 상태 관련 로직은 전담 디렉토리인 `store/`에 배치된다 [5-7]. 10명 이상의 개발자가 협업하는 조직이나 이커머스, 금융 시스템과 같이 미션 크리티컬한 데이터 무결성이 중요한 프로젝트에서 코드 작성의 일관성을 강제하는 뼈대 역할을 한다 [2].
+*   **성능 최적화 및 상태 구독**: 내장된 React Context API는 상태의 일부만 변경되어도 해당 컨텍스트를 구독하는 모든 컴포넌트에 무차별적인 리렌더링을 유발하는 반면, Redux는 구독 로직과 렌더링을 명확히 분리한다 [3, 8-10]. 선택자(Selector)를 사용해 필요한 파생 상태만 컴포넌트에 공급하여 성능과 최적화를 보장한다 [3].
+*   **비동기 데이터 관리 (RTK Query 도입)**: 과거 Redux는 비동기 처리에 막대한 양의 보일러플레이트 코드(Thunk, Saga 등)가 필요했으나, 현재는 RTK Query를 통해 문제를 해결한다 [2, 4]. RTK Query는 데이터 캐싱, 중복 요청 제거, 자동 데이터 재요청 기능 등을 기본으로 제공하여 비동기 작업 코드를 획기적으로 줄여준다 [4]. 
+*   **디버깅과 추적성**: Redux의 가장 큰 차별점은 브라우저의 Redux DevTools를 활용한 '시간 여행 디버깅(Time-Travel Debugging)'이다 [2, 3]. 상태 변화 이력을 과거로 돌려보거나 액션을 재현할 수 있어, 심야에 발생하는 복잡한 운영 환경의 비동기 버그도 몇 분 내에 시각적으로 파악하게 해준다 [3, 11, 12].
+*   **한계점 및 주의사항**: Redux는 도입 시 막대한 보일러플레이트, 정규화된 상태 관리의 난해함, 미들웨어 순서 오류, 그리고 깨지기 쉬운 선택자 메모이제이션 등의 한계를 가진다 [13]. 또한 모든 상태를 하나의 큰 리듀서에 몰아넣는 "God Reducer" 구조나 팀 단위의 액션 결합(Action Coupling)은 대표적인 안티 패턴으로 지적된다 [13, 14]. 최신 트렌드에서는 이와 같은 단일(monolithic) 스토어 구조의 복잡성을 피하기 위해 클라이언트 상태와 서버 상태를 분리하는 등 보다 파편화된 방식으로 진화하고 있다 [15].
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+- [[Context API]]
+  - 연결 이유: Redux와 자주 비교되는 React의 내장 상태 공유 기능으로, 소규모 애플리케이션의 테마나 언어 설정 등을 관리하기 적합하지만, 상태 변경 시 발생하는 대규모 리렌더링 폭풍(Re-render Storm)을 유발하여 대규모 앱에서 Redux가 필요한 당위성을 제공한다 [8, 9, 16].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 상태 구독 아키텍처의 차이가 React 컴포넌트의 리렌더링 성능에 미치는 치명적인 영향성 [8, 10].
+
+- [[Zustand]]
+  - 연결 이유: Redux의 무거운 보일러플레이트와 Context API의 성능 문제 사이에서 적절한 타협점을 제공하는 경량 상태 관리 라이브러리이다 [17-19]. 
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 상태 관리 라이브러리의 과도한 유연성(Zustand)이 팀 단위 협업에서 어떻게 비동기 패턴의 파편화와 혼란을 야기할 수 있는지, 대조적으로 Redux의 엄격한 구조가 갖는 방어적 이점 [1, 11, 18, 20].
+
+- [[RTK Query]]
+  - 연결 이유: Redux Toolkit(RTK) 생태계에 포함된 데이터 패칭 및 캐싱 도구이다 [4].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: Redux가 어떻게 단순한 클라이언트 상태 관리를 넘어 서버 API 응답(캐싱, 무효화, 재요청)이라는 현대적인 요구사항을 보일러플레이트 없이 소화하는지 파악 [4, 21].
+
+- [[Time-Travel Debugging]]
+  - 연결 이유: Redux DevTools가 제공하는 고유의 강력한 기능으로, 언제 어떤 액션이 디스패치되어 상태가 어떻게 변경되었는지 기록하고 되감는 기술이다 [2, 3].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 5년 이상 지속되는 엔터프라이즈 애플리케이션에서 아키텍처의 디버깅 역량이 개발자의 생산성 및 장애 대응에 미치는 영향 [11, 12].
+
+### Deeper Research Questions
+- Redux의 상태 구독 및 선택자(selector) 패턴은 내부적으로 Context API와 어떻게 다르게 설계되어 부분 상태 변경 시 불필요한 리렌더링을 차단하는가?
+- RTK Query를 통한 Redux 비동기 상태 관리는 Zustand 환경에서 사용자가 직접 구현하는 비동기 캐싱 패턴과 비교해 어떠한 아키텍처적 안정성을 담보하는가?
+- "God Reducer" 안티 패턴이 대규모 React 코드베이스 내비게이션 및 성능 최적화에 미치는 치명적인 부작용은 무엇인가?
+- 프론트엔드 상태 관리가 과거의 거대한 단일 스토어 방식에서 '서버 상태'와 '클라이언트 로컬 상태'로 파편화(Fragmentation)되는 최신 트렌드 속에서, Redux의 적정 사용 범위는 어떻게 재조정되었는가?
+- 10명 이상의 시니어 및 주니어 개발자가 혼재된 팀에서 Redux의 보일러플레이트는 개발 속도를 저하시키는 부채인가, 아니면 버그를 사전에 방지하는 구조적 방어막인가?
+
+### Practical Application Contexts
+- **Implementation:** React 프로젝트의 `store/` 또는 `features/` 디렉토리에 도메인별 Redux slice를 배치하여 전역 상태 및 비동기 데이터를 선언하고 액션과 병합하여 관리한다 [5-7].
+- **System Design:** 장기 유지보수가 요구되는 대규모 엔터프라이즈 시스템(이커머스 결제 등 데이터 흐름이 중요한 500개 컴포넌트 이상의 앱)에서 파생 상태 처리와 팀 개발 패턴 강제화 목적으로 채택한다 [2, 12, 13, 22].
+- **Operation / Maintenance:** 프로덕션 환경이나 디버깅 시 Redux DevTools를 연동하여 특정 UI 버그나 비동기 데이터 꼬임 현상을 시각적인 액션 히스토리를 통해 단시간에 해결한다 [11, 12].
+- **Learning Path:** 프론트엔드 교육 시, Context API의 근본 원리와 한계를 먼저 학습하고, Zustand의 생산성을 경험한 뒤, 엔터프라이즈 표준이자 가장 복잡도가 높은 Redux의 패턴과 구조적 이점을 최종적으로 학습하는 단계적 접근이 요구된다 [23].
+- **My Project Relevance:** 글로벌 상태가 다수의 컴포넌트에 복잡하게 얽혀 있거나, 팀원 간 동일한 비동기/상태 관리 구조를 강제하여 파편화를 막아야 하는 애플리케이션을 구축할 때 핵심적인 기술 스택으로 검토될 수 있다 [1, 12].
+
+### Adjacent Topics
+- [[Server State Management (TanStack Query 등)]]
+  - 확장 방향: 클라이언트 전역 상태와 구별되는 "서버 데이터(API 캐싱, 동기화, 로딩/에러 사이클)"만을 전문적으로 처리하는 모던 라이브러리와 Redux의 역할 비교 및 연동 방안 탐색 [24, 25].
+- [[React Rendering Optimization]]
+  - 확장 방향: 상태 관리 라이브러리의 선택과 별개로, React 컴포넌트 생명주기 및 메모이제이션(`useMemo`, `useCallback`, `React.memo`)이 애플리케이션 퍼포먼스에 미치는 원리와 프로파일링 방법 탐색 [26-28].
+
+---
+*Last updated: 2026-04-30*
\ No newline at end of file
diff --git a/10_Wiki/Topics_Blog/Rollup.md b/10_Wiki/Topics_Blog/Rollup.md
new file mode 100644
index 00000000..5a38f732
--- /dev/null
+++ b/10_Wiki/Topics_Blog/Rollup.md
@@ -0,0 +1,57 @@
+# [[Rollup]]
+
+## 📌 Brief Summary
+Rollup은 2025년 기준 최신 프론트엔드 빌드 도구인 Vite의 프로덕션 빌드를 백그라운드에서 담당하는 모듈 번들러입니다 [1]. 개발 단계에서는 네이티브 ES 모듈(ESM)을 사용하는 Vite가 실제 배포 시점에는 Rollup으로 전환하여 애플리케이션 코드를 병합하고 최적화합니다 [1, 2]. 자동 코드 분할(Code Splitting)과 사용하지 않는 코드를 제거하는 트리 쉐이킹(Tree-shaking) 기능을 통해 매우 최적화된 최종 에셋을 생성하는 것이 핵심 역할입니다 [1].
+
+## 📖 Core 대Content
+*   **Vite와의 하이브리드 아키텍처:** Vite는 로컬 개발 시에는 번들링 없이 네이티브 ESM으로 코드를 제공하여 극도로 빠른 시작과 HMR(Hot Module Replacement)을 지원하지만, 프로덕션 배포 시에는 Rollup을 사용하여 최적화된 번들(Bundled build)을 생성하는 하이브리드 방식을 취합니다 [1].
+*   **번들 최적화 및 트리 쉐이킹 (Tree-shaking):** Rollup은 프로덕션 빌드 시 애플리케이션 내에서 사용되지 않는 코드를 자동으로 제거(Tree-shaking)하고 효율적으로 코드를 분할하여 최적화된 에셋을 제공합니다 [1]. 
+*   **청크 수동 제어 (`manualChunks`):** 기본 설정 상태에서 Rollup은 애플리케이션 코드와 `node_modules`의 모든 종속성을 단일 파일(`index.js`)로 묶어 거대한 번들을 생성할 수 있습니다 [3]. 이를 해결하기 위해 대규모 프로젝트에서는 Rollup 옵션 중 `manualChunks`를 세밀하게 설정하여, 자주 변경되지 않는 무거운 벤더 라이브러리(React 코어, Recharts, Lodash, 아이콘 등)를 별도의 청크 파일로 분리하는 것이 권장됩니다 [4-6]. 
+*   **캐시 효율성 개선:** `manualChunks`를 통해 벤더 라이브러리를 분리하면, 해당 라이브러리는 자주 변경되지 않기 때문에 여러 번 배포하더라도 브라우저가 이를 캐시하여 재사용할 수 있으므로 초기 로드 성능이 크게 향상됩니다 [5-7].
+
+## ⚖️ Trade-offs & Caveats
+*   **초기 설정 부족 시 대용량 번들 발생:** 기본 설정으로 둘 경우 애플리케이션의 모든 종속성이 하나의 파일에 Eager Import 되어 결합될 수 있습니다 [3]. 이는 미니파이(Minification) 후에도 500kB를 초과하는 대규모 청크(Large Chunks)를 생성하여, 다운로드 시간을 지연시키고 저사양 기기에서 파싱 및 컴파일에 무리를 줄 수 있습니다 [3, 8, 9].
+*   **캐시 무효화(Cache Invalidation) 문제:** 단일 거대 번들로 빌드할 경우 애플리케이션의 작은 코드 하나만 수정하더라도 전체 번들이 새로 해시(Hash)되어 사용자는 모든 JavaScript 파일을 다시 다운로드해야 하는 비효율성이 발생합니다 [9]. 이를 방지하려면 `manualChunks` 설정과 `React.lazy`를 결합한 라우트 기반 코드 분할 등 추가적인 최적화 작업이 강제됩니다 [3, 6].
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+
+#### [아키텍처/기반 기술]
+- [[Vite]]
+  - 연결 이유: Rollup은 Vite의 아키텍처 내에서 프로덕션 배포 시 최적화된 빌드를 수행하는 내부 엔진으로 작동합니다 [1].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 개발 모드(ESM)와 배포 모드(Rollup)를 다르게 가져가는 Vite의 하이브리드 번들링 아키텍처 전략을 이해할 수 있습니다 [1, 2].
+- [[Tree-shaking]]
+  - 연결 이유: Rollup이 배포용 코드를 최적화할 때 사용하지 않는 코드를 덜어내는 핵심 메커니즘입니다 [1].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: ES 모듈 기반 라이브러리 사용이 왜 최종 번들 사이즈 최적화에 필수적인지 파악할 수 있습니다 [10].
+
+#### [구현/활용 도구]
+- [[manualChunks]]
+  - 연결 이유: Rollup을 사용하여 거대한 메인 번들을 세분화된 벤더 청크(Vendor chunk)로 쪼갤 때 사용되는 핵심 설정입니다 [4-6].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 브라우저 캐싱을 극대화하기 위해 코드를 성격(변경 빈도)에 따라 분리하는 최적화 전략을 배울 수 있습니다 [6, 7].
+- [[Code Splitting]]
+  - 연결 이유: Rollup의 기능과 React의 지연 로딩(`React.lazy`)을 결합하여 구현되는 성능 최적화 기법입니다 [3, 11].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 초기 페이로드(Payload)를 줄이고 Core Web Vitals를 개선하는 런타임 최적화 방법을 학습할 수 있습니다 [9, 12].
+
+### Deeper Research Questions
+- Vite는 왜 개발 환경에서는 Rollup을 사용하지 않고 네이티브 ESM을 사용하며, 프로덕션 빌드에서만 Rollup을 도입하는 아키텍처를 선택했는가?
+- Rollup의 Tree-shaking 메커니즘은 빌드 시 어떤 방식으로 데드 코드(Dead code)를 식별하고 최종 번들에서 제외하는가?
+- `manualChunks`를 사용하여 벤더(Vendor) 파일을 분할할 때 발생하는 모듈 간 중복 포함 문제를 방지하는 설정 방법은 무엇인가?
+- Rollup이 생성한 번들 크기를 시각적으로 분석하기 위해 `rollup-plugin-visualizer`가 제공하는 데이터는 실제 성능 개선에 어떻게 활용되는가?
+- Rollup의 빌드 최적화가 FCP, LCP, INP 등 Core Web Vitals 지표 향상에 미치는 구체적인 인과관계는 무엇인가?
+
+### Practical Application Contexts
+- **Implementation:** `vite.config.js` 내부에 `build.rollupOptions.output.manualChunks`를 구성하여 `react`, `react-dom` 등의 라이브러리를 별도의 파일로 강제 분리합니다 [4, 6].
+- **System Design:** 프론트엔드 프로덕션 시스템 설계 시, 자주 변하지 않는 서드파티 라이브러리와 비즈니스 로직을 분리하여 CDN 캐시 히트율을 높이도록 설계합니다 [5, 6].
+- **Operation / Maintenance:** CI/CD 파이프라인에서 "500 kB 이상의 청크" 경고가 발생할 경우, `rollup-plugin-visualizer`를 통해 번들 상태를 점검하고 분할 설정을 업데이트합니다 [8, 13, 14].
+- **Learning Path:** React 최적화 학습 시, 단순히 `React.lazy()`만 배우는 것을 넘어 번들러(Rollup) 레벨에서의 코드 청킹(Chunking) 원리를 함께 학습합니다 [3, 6].
+- **My Project Relevance:** Vite 기반 React 애플리케이션을 Vercel이나 AWS 서버에 배포하기 전에 빌드 속도 및 초기 다운로드 속도를 개선하기 위한 필수 점검 단계로 활용합니다 [2, 11].
+
+### Adjacent Topics
+- [[ES Modules (ESM)]]
+  - 확장 방향: Rollup의 프로덕션 빌드 이전, Vite가 개발 환경에서 코드 변경 사항을 즉각적으로 브라우저에 반영하는 원리 파악 [1, 15].
+- [[Core Web Vitals]]
+  - 확장 방향: Rollup의 번들 분할 및 경량화 작업이 LCP(Largest Contentful Paint)나 INP(Interaction to Next Paint)와 같은 브라우저 성능 측정 지표를 어떻게 개선하는지 조사 [9, 14].
+
+---
+*Last updated: 2026-04-30*
\ No newline at end of file
diff --git a/10_Wiki/Topics_Blog/Vite + React 성능 최적화.md b/10_Wiki/Topics_Blog/Vite + React 성능 최적화.md
new file mode 100644
index 00000000..5fbe3306
--- /dev/null
+++ b/10_Wiki/Topics_Blog/Vite + React 성능 최적화.md	
@@ -0,0 +1,75 @@
+# [[Vite + React 성능 최적화]]
+
+## 📌 Brief Summary
+Vite와 React 환경에서 애플리케이션의 성능을 최적화하는 것은 초기 로딩 속도를 높이고 런타임 성능을 향상시켜 전반적인 사용자 경험을 개선하는 과정입니다. 개발 환경에서는 기본 ES 모듈(ESM)을, 운영 환경에서는 Rollup을 통한 번들링을 활용하는 Vite의 구조적 이점을 극대화하는 것이 핵심입니다. 주요 최적화 기법으로는 빠른 컴파일을 위한 SWC 도입, 동적 임포트를 통한 코드 분할, `manualChunks`를 활용한 무거운 벤더 라이브러리 분리, 그리고 번들 시각화 도구를 통한 불필요한 의존성 제거 등이 포함됩니다.
+
+## 📖 Core Content
+*   **Vite의 아키텍처 이해 및 SWC 활용**
+    개발 중에는 모든 코드를 미리 번들링하지 않고 브라우저에 네이티브 ES 모듈(ESM)로 직접 제공하여 매우 빠른 서버 시작과 HMR(Hot Module Replacement)을 달성합니다 [1, 2]. 컴파일 속도를 극대화하기 위해 기존의 Babel 대신 Rust 기반 컴파일러인 SWC(`@vitejs/plugin-react-swc`)를 채택하면, 커스텀 Babel 플러그인이 필요 없는 대규모 React 프로젝트에서 빌드 및 새로고침 시간을 획기적으로 줄일 수 있습니다 [3-5].
+*   **코드 분할(Code Splitting) 및 지연 로딩(Lazy Loading)**
+    초기 로드 속도를 높이고 LCP(Largest Contentful Paint)와 같은 웹 지표를 향상시키기 위해 무거운 번들을 여러 청크로 분할해야 합니다 [6, 7]. `React.lazy()`와 `<Suspense>`를 사용한 동적 임포트로 라우트 레벨이나 차트 등 큰 위젯을 사용자가 접근할 때만 로드하도록 설정하면 메인 번들의 크기를 대폭 줄일 수 있습니다 [6, 8-13].
+*   **`manualChunks`를 활용한 벤더 라이브러리 분할**
+    프로덕션 빌드 시 500kB 이상의 거대한 청크 경고를 해결하기 위해 `vite.config.js`의 Rollup 옵션에서 `manualChunks`를 설정합니다 [12, 14-17]. React 코어나 Lodash, 차트, 아이콘 등 잦은 변경이 없는 외부 라이브러리들을 별도의 파일로 분리하면, 브라우저가 변경되지 않은 코드를 장기간 캐싱(Long-term caching)할 수 있어 재방문 및 배포 시 로딩 효율이 향상됩니다 [12, 15, 18, 19].
+*   **의존성 사전 번들링(`optimizeDeps`)과 트리 쉐이킹**
+    대규모 앱이나 비정상적인 의존성 로딩으로 인한 성능 저하를 방지하기 위해 `optimizeDeps`를 명시적으로 제어할 수 있습니다 [5, 6]. 또한 불필요한 코드 로드를 막기 위해 `lodash` 대신 `lodash-es`처럼 트리 쉐이킹(Tree-shaking)이 지원되는 최신 ES 모듈 기반 라이브러리를 우선적으로 사용해야 합니다 [20].
+*   **번들 시각화 및 모니터링**
+    `rollup-plugin-visualizer` 플러그인을 연동하여 빌드 시 거대한 번들의 구성 요소를 시각적인 트리맵 형태로 분석합니다 [6, 13, 21]. 이를 통해 번들 내 차지하는 비중이 불필요하게 큰 코드를 찾아내어 제거하거나 지연 로딩으로 분리할 기회를 신속하게 파악할 수 있습니다 [13, 20, 22].
+
+## ⚖️ Trade-offs & Caveats
+*   **과도한 플러그인 사용:** Vite를 구성할 때 너무 많은 플러그인을 남용하면 개발 서버의 성능이 현저히 느려질 수 있으므로, 반드시 필요한 플러그인 위주로 가볍게 유지해야 합니다 [20].
+*   **캐싱 무효화 주의:** 모듈 로딩 성능을 위해 Vite는 브라우저 캐싱에 크게 의존하므로, 개발 시 브라우저 개발자 도구에서 캐시를 무효화(Disable cache)하면 성능이 급격하게 저하될 수 있습니다 [20].
+*   **지연 로딩의 과용 및 잘못된 배치:** 모든 컴포넌트에 지연 로딩을 남발하거나, 스크롤 없이 바로 보여야 하는 핵심(Above-the-fold) 요소나 즉시 렌더링해야 하는 UI까지 지연 로딩을 적용하면 초기 화면 표시가 지연되어 오히려 사용자 경험을 망칠 수 있습니다 [23, 24].
+*   **메모이제이션(`React.memo`, `useMemo` 등) 오버헤드:** 불필요한 리렌더링을 막기 위한 도구지만, 비교 연산과 이전 상태를 캐싱하는 메모리 비용이 발생합니다 [25]. 렌더링이 아주 빠르고 단순한 컴포넌트나, 전달되는 props가 빈번히 변경되는 경우(예: 인라인 객체, 함수 전달)에 사용하면 렌더링 자체보다 상태 비교 비용이 더 커져 성능이 오히려 악화될 수 있습니다 [25-28].
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+
+#### [관계 유형 A (아키텍처/기반 기술)]
+- [[네이티브 ES 모듈(ESM)]]
+  - 연결 이유: Vite가 개발 환경에서 코드 모듈을 서빙하는 방식의 핵심 기반 원리입니다.
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 번들러가 전체 앱을 매번 빌드하지 않고 변경된 모듈만 요청/로드함으로써 프로젝트 크기에 상관없이 빠른 HMR과 응답성을 유지하는 메커니즘을 파악할 수 있습니다 [1, 29, 30].
+
+- [[Rollup]]
+  - 연결 이유: Vite 환경에서 프로덕션 배포 시 코드를 하나로 모으고 최적화하는 데 사용되는 번들러입니다.
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: Vite의 설정 파일(`vite.config.js`)에서 `manualChunks` 등 Rollup 전용 빌드 옵션을 통해 어떻게 효율적인 정적 애셋(Asset)을 생성하고, 코드 분할과 트리 쉐이킹을 수행하는지 이해할 수 있습니다 [14, 18, 31, 32].
+
+#### [관계 유형 B (구현/활용 도구)]
+- [[SWC 컴파일러]]
+  - 연결 이유: Vite의 기본 구성을 확장해 속도를 향상시키기 위한 강력한 도구입니다.
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 과거 Babel이 처리하던 JSX/TypeScript 변환 작업을 Rust 기반의 빠른 도구(`@vitejs/plugin-react-swc`)로 교체하여 대형 React 애플리케이션의 재빌드 시간을 즉각적으로 단축시키는 방식을 파악할 수 있습니다 [1, 3, 5].
+
+- [[React.lazy & Suspense]]
+  - 연결 이유: React 내부에서 동적 임포트를 통한 컴포넌트 레벨 지연 로딩을 구현하기 위한 API입니다.
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 라우트나 무거운 모듈을 분리하고, 번들이 로드되는 동안 `<Suspense>`를 통해 폴백(Fallback) UI를 처리함으로써 초기 자바스크립트 페이로드 용량을 대폭 줄이는 실무 기법을 배울 수 있습니다 [6, 9, 11, 12, 33].
+
+- [[rollup-plugin-visualizer]]
+  - 연결 이유: 최적화 작업 전후로 번들 크기를 시각화하고 문제를 진단하는 필수 분석 플러그인입니다.
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 큰 청크가 왜 발생하는지, 어떤 외부 라이브러리(벤더)가 의도치 않게 용량을 과도하게 점유하는지 분석하여 `manualChunks`나 코드 교체를 결단하는 측정/디버깅 기반을 확립할 수 있습니다 [6, 13, 21].
+
+### Deeper Research Questions
+
+- 대규모 외부 패키지를 사용할 때 Vite의 `optimizeDeps`를 세밀하게 튜닝하려면 어떠한 기준과 설정 방식을 적용해야 하는가?
+- SWC 플러그인을 도입할 때 기존에 사용 중인 특정 커스텀 Babel 플러그인을 온전히 대체하거나 병행해서 사용해야 하는 경우의 한계 및 해결책은 무엇인가?
+- Rollup의 `manualChunks`로 무거운 라이브러리를 분리할 때, 브라우저가 병렬로 다운로드할 수 있는 한계점과 장기 캐싱(Long-term caching)의 이점을 고려한 최적의 분할 단위(Chunk size)는 어느 정도인가?
+- `React.lazy`와 `<Suspense>`를 라우트 레벨이 아닌 세부 컴포넌트 레벨(예: 무거운 모달 창이나 차트)에 광범위하게 적용할 때, 불필요한 로딩 상태 남발을 막고 자연스러운 사용자 경험을 유지하는 방법은 무엇인가?
+- 번들 시각화를 통해 발견된, 트리 쉐이킹이 전혀 적용되지 않는 레거시 라이브러리 의존성을 제거하거나 모던 라이브러리로 마이그레이션할 때 따라야 할 리팩토링 전략은 무엇인가?
+
+### Practical Application Contexts
+
+- **Implementation:** `vite.config.ts` 파일에서 SWC 플러그인 설정 및 `rollupOptions` 내 `manualChunks`를 직접 작성하여 React 런타임, 상태 관리 도구, 차트 라이브러리 등을 각각의 청크로 추출하도록 코드를 구현합니다.
+- **System Design:** 초기 아키텍처 수립 시, 라우트 별로 지연 로딩될 기능과 앱 구동 시 즉시 필요한 코어 레이어를 엄격하게 분리하여 코드 스플리팅을 전제로 한 컴포넌트 계층 트리를 설계합니다.
+- **Operation / Maintenance:** CI/CD 파이프라인에 `rollup-plugin-visualizer`의 결과를 리포트로 남기도록 구성하여, 팀원이 새로운 패키지를 추가할 때 메인 번들 크기가 비정상적으로 커지지 않는지 지속적으로 감시하고 유지보수합니다.
+- **Learning Path:** 우선 React의 렌더링 원리 및 프로파일러 사용법을 학습한 후, 빌드 툴(Vite/Rollup)의 번들링 메커니즘을 이해하고, 이후 지연 로딩 기법 및 번들 최적화 플러그인 실습으로 이어지는 로드맵을 구성합니다.
+- **My Project Relevance:** 거대한 자바스크립트 파일 전송으로 인해 렌더링이 지연되는 프로젝트나, 빌드 후 "500kB 초과" 경고가 뜨는 프론트엔드 환경에서 즉각적인 파일 분할과 캐싱 전략을 적용하여 페이지 로드 성능(FCP, LCP)을 가시적으로 개선할 수 있습니다.
+
+### Adjacent Topics
+
+- [[Core Web Vitals]]
+  - 확장 방향: Vite와 React 최적화를 통해 얻어낸 메인 번들 크기 감소 및 렌더링 속도 향상이 실제 사용자 체감 성능 지표(LCP, FID/INP 등)에 어떤 수치적 개선으로 나타나는지를 구체적으로 연구합니다 [11, 34, 35].
+
+- [[Concurrent Rendering (동시성 렌더링)]]
+  - 확장 방향: 로딩과 번들링 최적화뿐만 아니라, `useTransition` 및 `useDeferredValue` 훅을 이용하여 복잡한 데이터 변화 시에도 사용자 입력 등의 UI 반응성을 유지하는 런타임 차원의 성능 향상 전략으로 지식을 확장합니다 [36-38].
+
+---
+*Last updated: 2026-04-30*
\ No newline at end of file
diff --git a/10_Wiki/Topics_Blog/Vite Build System.md b/10_Wiki/Topics_Blog/Vite Build System.md
new file mode 100644
index 00000000..9ee03e7c
--- /dev/null
+++ b/10_Wiki/Topics_Blog/Vite Build System.md	
@@ -0,0 +1,52 @@
+# [[Vite Build System]]
+
+## 📌 Brief Summary
+Vite는 현대 프론트엔드 애플리케이션(특히 React) 개발을 위한 새로운 산업 표준 빌드 도구로, 거의 즉각적인 서버 시작과 초고속 HMR(Hot Module Replacement)을 제공합니다 [1, 2]. 기존 번들러와 달리 개발 환경에서는 브라우저에 네이티브 ES 모듈 형태로 코드를 제공하고, 프로덕션 환경에서는 Rollup을 사용하여 고도로 최적화된 번들을 생성하는 하이브리드 아키텍처를 사용합니다 [3, 4]. 또한 SWC나 esbuild와 같은 Rust 기반 컴파일러를 활용하여 대규모 프로젝트에서도 빠르고 원활한 개발자 경험을 보장합니다 [3, 5, 6].
+
+## 📖 Core Content
+*   **하이브리드 아키텍처 (개발 및 프로덕션)**: Vite는 개발 시 모든 코드를 사전에 번들링하는 대신, 코드를 네이티브 ES 모듈(ESM) 형태로 브라우저에 직접 제공합니다 [2, 3]. 이 방식은 필요할 때 필요한 파일만 로드하므로 프로젝트 규모가 커져도 서버 시작 및 갱신 속도가 매우 빠릅니다 [3, 7]. 반면, 프로덕션 배포 시에는 내부적으로 Rollup을 사용하여 자동 코드 스플리팅, 미사용 코드 제거(Tree-shaking), 자산 최적화 등을 수행하여 성능이 뛰어난 번들을 생성합니다 [4, 8].
+*   **초고속 컴파일러 및 플러그인 활용**: Vite는 컴파일 속도를 높이기 위해 Rust 기반의 컴파일러인 SWC 또는 esbuild를 사용합니다 [3]. 기존 Babel 대신 `@vitejs/plugin-react-swc`를 사용하면 JSX 및 TypeScript 컴파일 속도가 비약적으로 향상되어 재빌드 시간이 단축됩니다 [5, 6, 9]. 이외에도 `vite-plugin-svgr`(SVG 컴포넌트화), `vite-plugin-pwa`와 같은 유연한 플러그인 생태계를 지원합니다 [10].
+*   **고급 구성 (vite.config.js)**: Vite는 `vite.config.js`를 통해 복잡한 프로젝트 설정을 제어할 수 있습니다. 예를 들어 경로 별칭(Path Aliases)을 설정하여 임포트를 깔끔하게 관리하거나, `VITE_` 접두사가 붙은 환경 변수만을 안전하게 노출하며, 개발 중 CORS 문제를 피하기 위한 내장 프록시 서버 설정을 지원합니다 [5, 9, 11].
+*   **성능 튜닝 및 대용량 청크(Chunk) 관리**: 대규모 앱에서는 무거운 벤더 라이브러리로 인해 메인 번들이 과도하게 커지는 문제("chunks are larger than 500 kB")가 발생할 수 있습니다 [12-14]. 이를 해결하기 위해 `manualChunks`를 사용하여 React, 차트 라이브러리 등 자주 변경되지 않는 벤더 코드를 별도의 파일로 분리해 브라우저 캐싱을 극대화합니다 [8, 11, 14-16]. 이와 함께 `React.lazy`와 `<Suspense>`를 이용한 라우트 레벨의 동적 임포트(코드 스플리팅)를 적용하고, `rollup-plugin-visualizer`로 번들 크기를 시각적으로 분석하여 불필요한 코드를 제거하는 것이 모범 사례입니다 [16-19].
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+- [[Native ES Modules (ESM)]]
+  - 연결 이유: Vite가 개발 환경에서 파일 전체를 사전 번들링하지 않고, 필요할 때 브라우저에 코드를 제공하는 핵심 메커니즘이기 때문입니다 [3, 7].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: Vite가 기존 도구(Webpack 등)에 비해 어떻게 초기 구동 속도와 HMR 응답성을 극적으로 단축할 수 있는지 그 원리를 파악할 수 있습니다 [2, 3].
+
+- [[Rollup]]
+  - 연결 이유: Vite가 프로덕션용 빌드를 생성할 때 내부적으로 채택하고 있는 번들러 도구이기 때문입니다 [4].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 프로덕션 환경에서 청크가 어떻게 나뉘며(`manualChunks`), 코드 스플리팅과 트리 쉐이킹을 통해 최적화된 정적 자산이 만들어지는 과정을 이해할 수 있습니다 [4, 8, 11].
+
+- [[SWC (Speedy Web Compiler)]]
+  - 연결 이유: Vite 환경에서 기존의 Babel을 대체하여 JSX와 TypeScript를 실시간에 가깝게 변환하는 Rust 기반 컴파일러 기술이기 때문입니다 [3, 5, 6].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 대규모 React 애플리케이션 개발 시 컴파일 속도와 핫 리로드 속도를 향상하는 기술적 배경을 깊이 이해할 수 있습니다 [3, 6].
+
+- [[Code Splitting & manualChunks]]
+  - 연결 이유: 대용량 메인 번들 문제를 해결하고, 초기 페이지 로드 속도를 높이기 위한 Vite 성능 최적화의 핵심 기법이기 때문입니다 [12, 14].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 동적 임포트와 결합하여 벤더 라이브러리(안정적인 코드)를 별도 파일로 캐싱하고 기능 단위로 청크를 나누는 전략을 학습할 수 있습니다 [8, 16].
+
+### Deeper Research Questions
+- 개발 환경의 네이티브 ESM 처리 방식과 프로덕션 환경의 Rollup 번들링 간의 아키텍처 차이가 런타임 동작이나 모듈 해석(Module Resolution)에 어떤 차이와 잠재적 버그를 유발할 수 있는가?
+- Vite의 `optimizeDeps`를 통한 사전 번들링(Pre-bundling) 프로세스는 거대한 외부 의존성 패키지를 로드할 때 브라우저의 네트워크 병목을 어떻게 해결하는가?
+- 대규모 React 앱을 마이그레이션 할 때 커스텀 Babel 플러그인을 사용 중인 환경에서 SWC 컴파일러(`@vitejs/plugin-react-swc`)로 전환할 때 발생하는 호환성 한계와 대안은 무엇인가?
+- `manualChunks`를 활용해 벤더 라이브러리를 세밀하게 분할할 때, 생성된 해시(hash) 파일명 기반의 장기 캐싱(Long-term Caching) 메커니즘은 브라우저에서 구체적으로 어떻게 최적화되는가?
+- `rollup-plugin-visualizer`를 통한 번들 시각화 이후, 의도치 않게 메인 청크에 포함된 과도한 트랜지티브 의존성(Transitive Dependencies)을 효과적으로 분리하는 구체적인 코드 레벨 패턴은 무엇인가?
+
+### Practical Application Contexts
+- **Implementation:** `vite.config.js`를 구성하여 `@vitejs/plugin-react-swc`를 도입하고, 상대 경로를 피하기 위한 경로 별칭(Path Aliases) 설정, `VITE_` 접두사를 이용한 안전한 환경 변수 바인딩, CORS를 우회하기 위한 프록시(Proxy) 설정을 적용합니다 [5, 9, 11].
+- **System Design:** 대규모 프론트엔드 시스템 설계 시, 무거운 초기 번들 크기 이슈를 방지하기 위해 Webpack 대신 Vite를 도입하고 개발(네이티브 ESM)과 프로덕션(Rollup 최적화)의 하이브리드 빌드 파이프라인을 구축합니다 [2-4, 8].
+- **Operation / Maintenance:** `rollup-plugin-visualizer`를 빌드 프로세스에 연동해 정기적으로 번들 크기를 모니터링하고, `manualChunks`를 유지보수하여 React 코어 같은 벤더 패키지의 브라우저 캐싱 이점을 유지합니다 [16-19].
+- **Learning Path:** 우선 Vite의 공식 스캐폴드 툴로 React 앱을 생성하여 기존 CRA(Create React App) 구조와의 차이를 체험한 후, 동적 임포트(`React.lazy`)와 `optimizeDeps` 등의 고급 설정 및 플러그인 확장을 점진적으로 학습합니다 [6, 7, 10, 16, 20].
+- **My Project Relevance:** 소스에 관련 정보가 부족합니다. (개인의 현재 진행 중인 특정 프로젝트에 대한 정보가 소스 텍스트에 포함되어 있지 않습니다.)
+
+### Adjacent Topics
+- [[React Server Components (RSC) & Next.js App Router]]
+  - 확장 방향: Vite를 이용한 빌드 툴 체인 최적화(CSR/SPA 성능 최적화)를 넘어, 클라이언트 측 자바스크립트 번들 자체를 전송하지 않고 서버에서 미리 렌더링하는 아키텍처 수준의 성능 최적화 패러다임으로 이해를 넓힙니다 [21-23].
+- [[Performance Metrics (Core Web Vitals)]]
+  - 확장 방향: Vite의 청크 최적화와 레이지 로딩 기법이 실제 사용자 체감 성능 지표인 FCP(First Contentful Paint), LCP(Largest Contentful Paint), INP(Interaction to Next Paint)에 어떤 직접적인 영향을 미치는지 연결하여 학습합니다 [13, 24, 25].
+
+---
+*Last updated: 2026-04-30*
\ No newline at end of file
diff --git a/10_Wiki/Topics_Blog/Vite Build Tool.md b/10_Wiki/Topics_Blog/Vite Build Tool.md
new file mode 100644
index 00000000..de593fe3
--- /dev/null
+++ b/10_Wiki/Topics_Blog/Vite Build Tool.md	
@@ -0,0 +1,72 @@
+# [[Vite Build Tool]]
+
+## 📌 Brief 임무
+Vite는 현대 프론트엔드 애플리케이션(주로 React)을 위한 표준 빌드 도구로, 기존 Webpack 및 Create React App(CRA)을 대체하며 빠르게 자리 잡았습니다 [1, 2]. 이 도구는 개발 환경에서는 브라우저의 네이티브 ES 모듈(ESM)을 활용해 즉각적인 서버 시작과 초고속 HMR(Hot Module Replacement)을 제공합니다 [2-4]. 프로덕션 배포 시에는 내부적으로 Rollup을 사용하여 코드 스플리팅과 트리 쉐이킹이 적용된 고도로 최적화된 번들을 생성하는 하이브리드 아키텍처를 특징으로 합니다 [5, 6].
+
+## 📖 Core Content
+* **하이브리드 아키텍처 (Hybrid Architecture)**
+  * **개발 환경:** 코드를 사전에 전체 번들링하지 않고 브라우저에 네이티브 ES 모듈(ESM)로 직접 제공합니다. 필요한 파일만 로드되므로 프로젝트 크기가 커져도 개발 서버가 즉각적으로 반응합니다 [2-4].
+  * **프로덕션 환경:** 배포 시에는 Rollup을 사용하여 애플리케이션을 번들링하며, 자동 코드 스플리팅 및 사용하지 않는 코드를 제거하는 트리 쉐이킹(Tree-shaking)을 통해 최적화된 정적 에셋을 제공합니다 [5, 6].
+* **초고속 컴파일 및 사전 번들링 (Fast Compilation & Pre-bundling)**
+  * Vite는 esbuild나 최신 Rust 기반 트랜스포머인 SWC(Speedy Web Compiler)를 활용하여 JSX 및 TypeScript 파일을 사실상 즉시 컴파일합니다 [4, 7]. 기존 Babel을 SWC로 대체하면 핫 모듈 리로드 시간이 크게 단축됩니다 [8].
+  * 개발 중 새로고침 속도를 최적화하기 위해 종속성을 사전 번들링(Pre-bundling, `optimizeDeps`)합니다 [8].
+* **설정 및 플러그인 생태계 (Configuration & Plugins)**
+  * `vite.config.js`를 통해 경로 별칭(Path Aliases), CORS 문제를 방지하는 개발 서버 프록시, `VITE_` 접두사가 붙은 환경 변수 등을 유연하게 설정할 수 있습니다 [7, 9, 10].
+  * SVG를 React 컴포넌트로 가져오기 위한 `vite-plugin-svgr`, 오프라인 PWA 지원을 위한 `vite-plugin-pwa`, 번들 크기를 시각적으로 분석하는 `rollup-plugin-visualizer` 등 강력한 플러그인 생태계를 지원합니다 [11-13].
+* **번들 사이즈 최적화 (Bundle Optimization)**
+  * 기본적으로 Vite는 앱 코드와 모든 종속성(node_modules)을 하나의 `index.js`에 담아 빌드합니다. 이를 방지하기 위해 `vite.config.ts`의 Rollup 옵션에서 `manualChunks`를 설정하여 React 코어 라이브러리 등 무거운 벤더를 분리하고 브라우저 캐싱 효율을 높입니다 [6, 14, 15].
+  * `React.lazy()`와 `<Suspense>`를 결합한 라우트 레벨 동적 임포트를 통해 초기 메인 번들 크기를 극적으로 줄일 수 있습니다 [11, 14, 15].
+
+## ⚖️ Trade-offs & Caveats
+* **대형 청크 경고 및 초기 번들 비대화 (Large Chunks Warning):** Vite는 기본적으로 모든 종속성을 단일 파일로 빌드하기 때문에, 수동으로 코드 스플리팅을 하지 않으면 프로덕션 빌드 시 "500kB 초과" 경고가 발생할 수 있습니다. 이는 다운로드 시간을 지연시키고 낮은 성능의 모바일 기기에서 파싱 및 컴파일에 무리를 주어 FCP, LCP, INP와 같은 Core Web Vitals 지표를 악화시킬 수 있습니다 [14, 16, 17].
+* **개발자 도구 캐싱 의존성:** Vite는 모듈 로딩 성능을 위해 브라우저의 캐싱에 크게 의존합니다. 따라서 개발 중 브라우저 개발자 도구에서 "캐시 사용 안 함(Disable cache)"을 설정하면 개발 서버가 느려지는 부작용이 발생할 수 있습니다 [18].
+* **플러그인 남용으로 인한 성능 저하:** 과도한 플러그인 사용은 개발 서버의 속도를 저하시킬 수 있으므로, 구성을 최소화하고 필요한 플러그인만 유지해야 합니다 [18].
+* **사전 번들링 관리 필요성:** 규모가 크거나 특이한 외부 종속성의 경우, `optimizeDeps` 설정을 수동으로 제어하지 않으면 개발 환경에서 사전 번들링으로 인한 속도 저하가 발생할 수 있습니다 [8, 11].
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+
+#### [아키텍처/기반 기술]
+- [[Native ES Modules (ESM)]]
+  - 연결 이유: Vite가 개발 단계에서 빠른 구동 속도를 달성하기 위해 활용하는 브라우저의 기본 모듈 시스템입니다 [2, 4].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 과거 도구(Webpack)의 무거운 사전 번들링 방식과 대비되는 Vite의 '요청 시 제공(On-demand serving)' 메커니즘의 원리.
+
+- [[Rollup]]
+  - 연결 이유: Vite의 프로덕션 빌드를 담당하는 내부 번들러입니다 [5, 6].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 배포 환경에서 어떻게 `manualChunks`를 활용하여 번들을 분할하고, 트리 쉐이킹을 통해 최적화된 결과물을 도출하는지 그 과정 [10, 16].
+
+- [[SWC]]
+  - 연결 이유: 기존의 Babel을 대체하여 JSX와 TypeScript 컴파일을 엄청나게 빠른 속도로 처리하는 Rust 기반 트랜스포머입니다 [4, 7, 8].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: Vite 환경에서 React 애플리케이션의 핫 리로드와 빌드 퍼포먼스를 한 차원 끌어올리는 컴파일러의 역할.
+
+#### [최적화 기법]
+- [[Code Splitting & manualChunks]]
+  - 연결 이유: 500kB 이상의 거대한 메인 번들 경고 문제를 해결하기 위해 Vite/Rollup 환경에서 벤더 코드와 앱 코드를 나누는 핵심 기법입니다 [6, 14, 15].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 브라우저 병렬 다운로드와 효율적인 캐시 무효화 전략, 초기 페이로드 최소화 방법 [17, 19].
+
+### Deeper Research Questions
+
+- Vite의 네이티브 ESM 기반 개발 환경과 Rollup 기반 프로덕션 환경 사이의 차이로 인해, 런타임 또는 빌드 타임에 발생할 수 있는 호환성 문제나 예외 케이스는 무엇인가?
+- 대규모 애플리케이션에서 `optimizeDeps`를 통한 사전 번들링 메커니즘 최적화를 위해 구체적으로 어떤 기준을 가지고 종속성을 분리/포함해야 하는가?
+- `@vitejs/plugin-react-swc` 사용 시, 기존 Babel 생태계의 커스텀 플러그인들을 어떻게 이관하거나 대체해야 하는가?
+- `manualChunks`를 세밀하게 설정할 때 벤더 라이브러리의 중복 포함을 막고 가장 이상적인 청크 크기를 유지하는 전략은 무엇인가?
+- Vite 환경에서 라우트 레벨 지연 로딩(`React.lazy`) 적용 시 발생하는 워터폴(Waterfall) 네트워크 요청 문제를 방지하기 위해 `preload` 또는 `prefetch` 힌트를 어떻게 결합할 수 있는가?
+
+### Practical Application Contexts
+
+- **Implementation:** `npm create vite@latest`를 사용해 불필요한 설정 없는 가벼운 초기 구조를 생성하고, `vite.config.js`에 `@vitejs/plugin-react-swc`와 같은 플러그인, 경로 별칭(`@/components` 등), 백엔드 API 연동을 위한 proxy 설정을 구현합니다 [3, 7, 9, 10].
+- **System Design:** 프론트엔드 시스템 설계 시 개발 환경(빠른 피드백 루프 보장)과 배포 환경(고도의 압축 및 병렬 로드를 위한 모듈화 보장)에 다른 전략을 취하는 Vite의 하이브리드 철학을 아키텍처에 반영합니다 [5].
+- **Operation / Maintenance:** CI/CD 파이프라인이나 로컬 빌드 후 `rollup-plugin-visualizer` 플러그인을 활용하여 어떤 패키지가 메인 번들 용량을 차지하는지 시각적 트리맵으로 정기 점검하고 최적화합니다 [11, 13, 18].
+- **Learning Path:** 모듈 번들러의 발전 과정(Webpack -> ES Modules 네이티브 도입 -> Vite)을 학습한 후, 빌드 도구 차원의 최적화(`manualChunks`)와 React 프레임워크 차원의 최적화(`React.lazy`)가 결합되었을 때의 시너지를 이해하는 방향으로 학습을 진행합니다 [2, 6, 15].
+- **My Project Relevance:** Vite 빌드 시 "Some chunks are larger than 500 kB" 경고가 발생했을 때 당황하지 않고, 자주 변경되지 않는 벤더 코드(React 코어, 차트 라이브러리 등)를 분리하고 라우터 레벨에서 지연 로딩을 도입하여 다운로드 속도 및 FCP, LCP를 개선하는 데 직접적으로 적용합니다 [14-16].
+
+### Adjacent Topics
+
+- [[Webpack]]
+  - 확장 방향: Vite가 등장하기 전 업계 표준이었으나 시작 전 전체 번들링 과정으로 인해 무거운 구조를 가진 Webpack의 한계와 Vite와의 아키텍처 비교 [1, 2].
+- [[Core Web Vitals]]
+  - 확장 방향: Vite의 청크 분할 및 지연 로딩 기법이 실제 사용자 경험 지표인 FCP(First Contentful Paint), LCP(Largest Contentful Paint), INP(Interaction to Next Paint)에 어떻게 직결되는지 탐구 [17, 20].
+
+---
+*Last updated: 2026-04-30*
\ No newline at end of file
diff --git a/10_Wiki/Topics_Blog/비동기 데이터 관리.md b/10_Wiki/Topics_Blog/비동기 데이터 관리.md
new file mode 100644
index 00000000..a26dcf51
--- /dev/null
+++ b/10_Wiki/Topics_Blog/비동기 데이터 관리.md	
@@ -0,0 +1,63 @@
+# [[비동기 데이터 관리]]
+
+## 📌 Brief Summary
+비동기 데이터 관리(서버 상태 관리)는 API에서 가져온 데이터를 클라이언트 측 애플리케이션 상태와 명확히 분리하여 처리하는 것을 의미합니다 [1]. 이는 네트워크 요청에 따른 데이터 캐싱, 동기화, 로딩 및 에러 사이클 관리를 포함하며, 현대 프론트엔드 시스템 아키텍처의 핵심 요소입니다 [1, 2]. 대규모 앱에서는 RTK Query나 TanStack Query(React Query)와 같은 특화된 도구를 사용하여 비동기 보일러플레이트를 줄이고 효율적인 캐시 관리를 수행합니다 [1, 3, 4].
+
+## 📖 Core Content
+
+*   **서버 상태와 클라이언트 상태의 분리:** 
+    최근 프론트엔드 아키텍처에서 가장 중요한 변화 중 하나는 "서버 상태(Server State)"를 "애플리케이션 상태"와 분리하는 것입니다. API에서 가져오는 데이터는 클라이언트 데이터와 근본적으로 다르며, 캐싱, 동기화, 로딩 및 에러 처리가 반드시 필요합니다 [1]. Zustand와 같이 유연한 상태 관리 라이브러리로 비동기(Async) 작업을 직접 다루게 되면, 팀원마다 콜백, 프로미스, 미들웨어 등 서로 다른 패턴을 사용하여 일관성이 떨어지고 유지보수가 어려워지는 한계가 발생할 수 있습니다 [3, 5].
+
+*   **비동기 데이터 관리 최적화 도구:** 
+    이러한 문제를 해결하기 위해 TanStack Query(React Query)와 RTK Query 같은 라이브러리가 사실상의 표준으로 자리 잡았습니다 [1]. 
+    *   **TanStack Query:** 강력한 캐싱 레이어를 제공하여 불필요한 네트워크 중복 요청을 줄이고 데이터의 최신 상태를 유지합니다. 무한 스크롤(infinite scrolling)이나 낙관적 업데이트(optimistic updates)와 같은 복잡한 비동기 기능을 단순하게 구현할 수 있습니다 [2].
+    *   **RTK Query:** Redux 생태계에서 비동기 작업이 많은 앱을 위해 캐싱, 중복 제거, 자동 데이터 재요청(refetching), 캐시 무효화 기능을 기본으로 제공하여 비동기 보일러플레이트 코드를 사실상 제거합니다 [3, 4].
+
+*   **구조적 분리와 아키텍처:**
+    API 계층은 일반적으로 독립적인 경계로 구성되며, 요청 선언부와 커스텀 훅(Custom Hooks)은 특정 기능(feature) 폴더 내에 함께 배치(colocate)됩니다. 이를 통해 네트워크 관련 비동기 로직을 UI 컴포넌트와 완벽히 디커플링(decoupling)하여 유지보수성을 향상시킵니다 [2].
+
+*   **성능 최적화 및 안정성:**
+    *   **디바운싱과 쓰로틀링:** 사용자 입력(예: 검색)에 의해 트리거되는 값비싼 비동기 API 호출은 디바운싱(debouncing)이나 쓰로틀링(throttling)을 통해 횟수를 제한해야 합니다. 이는 과도한 API 호출을 방지하여 클라이언트 성능을 향상시키고 서버 부하를 줄여줍니다 [6, 7].
+    *   **메모리 누수 방지:** 이벤트 리스너나 구독(subscriptions) 등 정리가 필요한 비동기 사이드 이펙트의 경우, 컴포넌트가 언마운트될 때 리소스를 해제하지 않으면 메모리 누수(memory leaks)가 발생할 수 있습니다. 이를 막기 위해 반드시 `useEffect`에서 클린업(cleanup) 함수를 반환해야 합니다 [8, 9].
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+- [[TanStack Query 및 RTK Query]]
+  - 연결 이유: 서버 상태(API 데이터) 관리에 있어 캐싱, 중복 요청 제거, 자동 재요청 등을 처리하기 위한 현대적인 필수 표준 도구로 소스에서 강조되고 있기 때문입니다 [1, 2, 4].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 비동기 데이터 관리에서 발생하는 보일러플레이트 감소 원리와 데이터 동기화 메커니즘.
+
+- [[서버 상태 (Server State)]]
+  - 연결 이유: API로부터 패치(fetch)되는 데이터는 클라이언트 상태와 성격이 완전히 달라 별도의 관리가 필요하다는 비동기 관리의 핵심 전제이기 때문입니다 [1].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 캐싱 로딩, 에러 사이클, 서버 데이터 최신화 기법.
+
+- [[디바운싱(Debouncing) 및 쓰로틀링(Throttling)]]
+  - 연결 이유: 잦은 사용자 이벤트로 인해 발생하는 무분별한 비동기 API 호출을 제어하여 성능을 최적화하는 구체적인 전략이기 때문입니다 [6, 7].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 프론트엔드에서의 네트워크 최적화 및 런타임 병목 현상 방지.
+
+- [[클린업 (Cleanup) 함수와 메모리 누수]]
+  - 연결 이유: 비동기 작업 완료 전 컴포넌트가 언마운트되었을 때 발생할 수 있는 자원 낭비와 메모리 누수를 막는 필수 규칙이기 때문입니다 [8, 9].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: React 생명주기(Lifecycle)와 결합된 안전한 비동기 처리 방법.
+
+### Deeper Research Questions
+- Zustand와 같은 가벼운 전역 상태 관리 라이브러리로 대규모 비동기 처리를 구현할 때 발생하는 아키텍처적 한계와 파편화 문제는 구체적으로 어떻게 나타나는가? [3, 5]
+- RTK Query가 제공하는 캐시 무효화(cache invalidation) 및 자동 데이터 재요청 기능의 내부 작동 방식은 무엇인가? [4]
+- TanStack Query를 활용하여 무한 스크롤 및 낙관적 업데이트를 구현할 때, 캐시 레이어는 어떻게 무결성을 보장하는가? [2]
+- Feature-Sliced Design 같은 모듈화된 폴더 구조에서 API 선언과 비동기 커스텀 훅은 어떤 방식으로 캡슐화되고 호출되는가? [2]
+- `useEffect` 내의 비동기 호출 시 메모리 누수를 잡기 위한 DevTools Heap Snapshot 분석 방법은 어떻게 적용되는가? [9]
+
+### Practical Application Contexts
+- **Implementation:** UI 컴포넌트 내부에서 비동기 로직을 직접 구현하지 않고, API 요청을 처리하는 네트워크 로직을 커스텀 훅으로 추출하여 `features/` 폴더 하위에 격리하여 구현합니다 [2, 10]. 또한 `useEffect`를 통한 구독 시 클린업 함수를 반드시 적용합니다 [8].
+- **System Design:** 프로젝트 설계 시 클라이언트 전역 상태(예: UI 테마, 언어)와 서버에서 불러오는 비동기 상태(예: 사용자 데이터, 알림)를 완전히 분리하여 각기 다른 도구(Zustand + TanStack Query)를 사용하도록 설계합니다 [1, 11].
+- **Operation / Maintenance:** Redux DevTools와 같은 도구를 활용하여 비동기 액션이 언제 호출되었고 서버 데이터가 어떻게 업데이트되었는지 타임트래블 디버깅(Time-travel debugging)을 진행하여 문제를 신속히 파악합니다 [12, 13].
+- **Learning Path:** 컴포넌트 단위의 `useState`/`useEffect`를 통한 데이터 패칭의 한계 학습 → 디바운싱/메모리 누수 방지 원리 이해 → 서버 상태와 클라이언트 상태의 차이 인지 → TanStack Query/RTK Query를 통한 전문적인 비동기 상태 관리 마스터로 이어집니다 [1, 3, 7, 8].
+- **My Project Relevance:** 실시간 알림, 방대한 데이터의 무한 스크롤, 사용자 검색 시의 자동완성(디바운스 적용) 기능 등 복잡한 API 기반 기능이 있는 프로젝트의 성능 및 아키텍처 개선에 직접 적용됩니다 [2, 6, 7].
+
+### Adjacent Topics
+- [[상태 관리 아키텍처 (State Management Architecture)]]
+  - 확장 방향: 비동기 데이터 관리(서버 상태)와 로컬 상태, 전역 애플리케이션 상태가 애플리케이션 내에서 어떻게 상호작용하고 조화롭게 구성되는지 확장해서 알아봅니다 [1, 14].
+- [[성능 프로파일링 및 렌더링 최적화 (Performance Profiling & Rendering Optimization)]]
+  - 확장 방향: 잘못된 비동기 데이터 처리가 어떻게 불필요한 리렌더링 폭풍(re-render storm)이나 병목을 일으키는지 파악하고, React Profiler를 통해 이를 어떻게 탐지하는지 알아봅니다 [15-17].
+
+---
+*Last updated: 2026-04-30*
\ No newline at end of file
diff --git a/10_Wiki/Topics_GD/Engineering Scalable Frontend Systems.md b/10_Wiki/Topics_GD/Engineering Scalable Frontend Systems.md
new file mode 100644
index 00000000..387ef5fb
--- /dev/null
+++ b/10_Wiki/Topics_GD/Engineering Scalable Frontend Systems.md	
@@ -0,0 +1,84 @@
+# [[Engineering Scalable Frontend Systems]]
+
+## 📌 Brief Summary
+확장 가능한 프론트엔드 시스템(Engineering Scalable Frontend Systems)은 단순한 스크립트 실행을 넘어 유지보수성, 고성능, 견고성을 갖춘 분산 소프트웨어 아키텍처를 구축하는 것을 의미합니다 [1]. 이는 기술적 파일 기반 폴더 구조에서 기능 중심(Feature-Based) 및 도메인 기반 설계로의 전환을 요구하며, 엄격한 코드 컨벤션과 거버넌스를 동반합니다 [2, 3]. 또한 프론트엔드 개발에 SOLID와 같은 소프트웨어 공학 원칙을 결합하고, 서버/클라이언트 상태의 분리, 그리고 빌드 타임 및 런타임 성능 최적화를 통해 예측 가능한 성장을 가능하게 합니다 [1, 4, 5].
+
+## 📖 Core Content
+
+*   **아키텍처 및 폴더 구조의 진화**
+    기존의 컴포넌트, 훅, 스타일 등을 파일 타입별로 모아두는 구조는 앱이 커질수록 인지 부하를 높이고 확장을 어렵게 만듭니다 [2, 6]. 2025년의 프론트엔드 시스템은 비즈니스 도메인과 기능(Feature)을 중심으로 코드를 응집시키는 구조를 표준으로 삼고 있습니다 [3, 7]. 특히 **Feature-Sliced Design (FSD)** 같은 아키텍처는 코드를 횡단 관심사별 레이어(shared, entities, features, widgets, pages, app)로 나누고, 상위 계층에서 하위 계층으로만 접근할 수 있는 엄격한 단방향 의존성 규칙을 강제합니다 [8-10]. 각 슬라이스는 `index.ts`를 통해 퍼블릭 API(Public API)만 외부에 노출하여 내부 구현을 캡슐화합니다 [4, 11, 12].
+*   **소프트웨어 공학 원칙의 적용 (SOLID & Clean Code)**
+    프론트엔드 코드의 유지보수성을 위해 SOLID, DRY, KISS, YAGNI 원칙이 적용됩니다 [4, 13].
+    *   단일 책임 원칙(SRP)에 따라 너무 많은 작업을 수행하는 대형 컴포넌트(예: 300줄 이상)는 데이터 패칭, 상태 관리, UI 렌더링 등의 책임에 맞게 더 작고 독립적인 단위로 분리되어야 합니다 [14].
+    *   개방-폐쇄 원칙(OCP)은 기존 컴포넌트 소스를 수정하지 않고 `children` prop이나 Render Props 패턴을 이용한 컴포넌트 합성(Composition)으로 기능을 확장하는 방식으로 구현됩니다 [15, 16].
+    *   중복을 줄이는 DRY 원칙은 공통 로직을 커스텀 훅으로 분리하는 것을 권장하지만, 지나친 추상화는 코드 파악을 어렵게 하므로 단순성을 유지하는 KISS 원칙과 균형을 이루어야 합니다 [17].
+*   **상태 관리 패러다임의 세분화**
+    거대한 단일 상태 저장소(예: 과거의 Redux)에 의존하기보다는 데이터의 성격에 따라 최적의 도구를 선택하여 상태를 파편화 및 전문화합니다 [5].
+    *   **전역 애플리케이션 상태:** Context API는 값이 변경될 때마다 하위 컴포넌트 전체를 리렌더링하는 한계가 있으므로 [18, 19], 상태 변경이 잦고 규모가 큰 앱에서는 부분 구독(Selector)을 지원하여 렌더링 성능을 최적화하는 **Zustand**나 **Jotai**가 선호됩니다 [5, 20, 21].
+    *   **서버 상태 (API Layer):** API에서 가져온 데이터는 캐싱, 동기화, 로딩/에러 사이클 관리가 필요하므로, 클라이언트 상태와 명확히 분리하여 **TanStack Query (React Query)** 등의 라이브러리로 관리합니다 [18, 22].
+*   **성능 엔지니어링 및 빌드 최적화**
+    초기 로딩 시간과 Core Web Vitals 최적화를 위해 다양한 기법이 적용됩니다 [23, 24].
+    *   **빌드/컴파일 타임:** Vite와 같은 도구를 사용하여 개발 환경에서는 네이티브 ES 모듈을 제공하고, 프로덕션에서는 Rollup의 `manualChunks`를 활용해 용량이 큰 벤더 라이브러리(React, Recharts 등)를 분할 캐싱하여 캐시 효율을 높입니다 [23, 25-27]. 또한 **React Compiler**의 도입으로 컴파일러가 자동으로 코드의 리렌더링 방지(메모이제이션)를 처리하여 수동 최적화(`useMemo`, `useCallback`)의 오류를 줄여줍니다 [25, 28, 29].
+    *   **런타임 최적화:** 동적 임포트를 이용한 라우트 및 컴포넌트 레벨의 코드 스플리팅(Code Splitting & Lazy Loading), 그리고 수천 개의 리스트 아이템 렌더링 시 DOM 비대를 막는 가상화(Virtualization) 기술이 필수적으로 요구됩니다 [30-32].
+*   **복원력(Resilience) 및 시스템 거버넌스**
+    견고한 시스템은 런타임 오류가 전체 앱의 크래시로 이어지는 것을 막습니다. UI의 불안정한 영역이나 서드파티 위젯은 **Error Boundaries**로 감싸 폴백 UI를 제공하여 안정성을 보장합니다 [33-35]. 또한, 메모리 누수 방지를 위한 DevTools 힙 스냅샷 디버깅과 Sentry, LogRocket 같은 클라우드 도구를 이용한 프로덕션 에러 모니터링이 활용됩니다 [36-38]. 협업 차원에서는 일관된 네이밍 규칙(예: 파일명은 kebab-case, 컴포넌트는 PascalCase)과 ESLint, Prettier, Husky를 통한 자동화된 거버넌스, 그리고 Storybook을 활용한 시각적 회귀 테스트가 코드 품질을 보장합니다 [39-41].
+
+## ⚖️ Trade-offs & Caveats
+*   **Feature-Sliced Design (FSD)의 초기 도입 비용 및 복잡성:** FSD는 확장성과 모듈화에 뛰어나지만 러닝 커브가 높으며, 작은 규모의 프로젝트에서는 오버엔지니어링으로 느껴질 수 있습니다 [42, 43]. 또한 '인증(Auth)' 같은 횡단 관심사(Cross-cutting concerns)를 정확히 어떤 기능이나 슬라이스에 배치할지 경계를 설정하는 것이 어려워 팀 내 규칙 합의와 지속적인 문서화가 요구됩니다 [44, 45].
+*   **React Compiler 적용의 제약:** React Compiler가 자동 메모이제이션을 수행하여 성능을 높여주지만, 이는 블랙박스로 동작하기 때문에 예기치 않게 리렌더링이 발생했을 때 원인을 디버깅하기 더 어려워질 수 있습니다 [46]. 또한 매 렌더링마다 새로운 객체 참조를 반환하는 서드파티 라이브러리와 충돌할 수 있으며, 레거시 코드베이스의 경우 React의 불변성 및 부수 효과 규칙(Rules of React)을 엄격히 준수하도록 대대적인 리팩토링이 선행되어야 합니다 [28, 47, 48].
+*   **Context API vs. 외부 상태 관리 라이브러리의 트레이드오프:** Context API는 내장 기능이므로 의존성을 추가하지 않는 장점이 있지만, 변경이 잦은 상태에 사용할 경우 불필요한 하위 컴포넌트의 연쇄 리렌더링을 유발하는 치명적인 성능 병목을 발생시킵니다 [19, 20]. 반대로 Zustand나 TanStack Query를 도입하면 리렌더링 문제를 해결할 수 있으나, 시스템에 새로운 라이브러리 의존성과 학습 곡선이 추가됩니다 [21, 49].
+*   **DRY와 KISS 원칙의 상충:** 중복을 줄이기(DRY) 위해 공통 로직을 고차 컴포넌트(HOC)나 커스텀 훅으로 지나치게 추상화하면, 코드가 원래의 단순한 형태보다 이해하고 디버깅하기 훨씬 어려워져 결국 KISS 원칙을 위배하게 되는 부작용이 발생할 수 있습니다 [17].
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+
+#### [관계 유형 A: 아키텍처 및 시스템 구조 (Architecture & Structural Design)]
+*   `[[Feature-Sliced Design (FSD)]]`
+    *   연결 이유: 현대 프론트엔드의 모듈화 및 확장성을 해결하기 위해 널리 채택되는 아키텍처 방법론의 핵심이기 때문입니다 [9, 10].
+    *   이 개념을 통해 더 깊게 이해할 수 있는 부분: 비즈니스 도메인 기반의 코드 분할, 엄격한 단방향 의존성 규칙 적용 방법, 그리고 퍼블릭 API를 통한 모듈 캡슐화 원리 [4, 8, 50].
+*   `[[Error Boundaries]]`
+    *   연결 이유: 부분적인 UI 런타임 에러가 시스템 전체의 장애(White screen of death)로 확산되는 것을 방지하는 구조적 안전 장치이기 때문입니다 [33, 34].
+    *   이 개념을 통해 더 깊게 이해할 수 있는 부분: 렌더링 트리에서 컴포넌트 결함을 격리하는 원리와 시스템 복원력을 높이는 에러 처리 전략 [33, 35].
+
+#### [관계 유형 B: 상태 관리 패러다임 (State Management Paradigms)]
+*   `[[Zustand vs Context API]]`
+    *   연결 이유: 전역 상태 관리에서 성능과 확장성을 결정짓는 가장 빈번한 아키텍처 결정 지점이기 때문입니다 [5, 19].
+    *   이 개념을 통해 더 깊게 이해할 수 있는 부분: Context API의 브로드캐스트 렌더링 문제점과 이를 해결하기 위한 Zustand의 구독/선택자(Selector) 기반 렌더링 최적화 기법 [19, 20, 51].
+*   `[[TanStack Query (React Query)]]`
+    *   연결 이유: 클라이언트 상태와 서버 상태(Server State)를 구조적으로 분리하여 API 데이터 처리의 병목을 없애주기 때문입니다 [18, 22].
+    *   이 개념을 통해 더 깊게 이해할 수 있는 부분: 데이터 캐싱, 백그라운드 동기화 및 API 계층의 관심사 분리(Separation of Concerns) [18, 22].
+
+#### [관계 유형 C: 성능 및 빌드 최적화 (Performance & Build Optimization)]
+*   `[[React Compiler]]`
+    *   연결 이유: 수동 메모이제이션의 복잡성을 줄이고 빌드 타임에 컴포넌트 렌더링 성능을 자동으로 최적화하는 최신 핵심 도구이기 때문입니다 [25, 28, 29].
+    *   이 개념을 통해 더 깊게 이해할 수 있는 부분: 선언적 UI 프레임워크에서의 빌드 타임 최적화 한계 및 React의 규칙(Rules of React)이 강제하는 불변성의 중요성 [52, 53].
+*   `[[Code Splitting & Lazy Loading]]`
+    *   연결 이유: 초기 로드(First Paint) 속도 향상과 JavaScript 번들 크기를 제어하는 확장 가능한 시스템의 필수 성능 전략이기 때문입니다 [30, 31, 54].
+    *   이 개념을 통해 더 깊게 이해할 수 있는 부분: Vite나 Webpack 같은 번들러 환경에서 동적 임포트를 통한 라우트 단위 분할 및 무거운 벤더 청크(`manualChunks`)의 캐싱 분리 전략 [26, 27, 31].
+
+### Deeper Research Questions
+
+*   거대한 모놀리식 구조 혹은 단일 파일 타입(components/, hooks/) 기반의 레거시 React 앱을 Feature-Sliced Design(FSD) 아키텍처로 점진적으로 리팩토링할 때 고려해야 할 최적의 마이그레이션 전략은 무엇인가?
+*   React Compiler가 도입되어 컴포넌트의 리렌더링을 자동으로 제어하게 된다면, 개발자는 더 이상 `useMemo`나 `useCallback`을 작성할 필요가 완전히 없어지는가? 혹은 여전히 수동 메모이제이션이 필수적인 엣지 케이스는 무엇인가?
+*   Zustand와 같은 클라이언트 상태 관리와 TanStack Query와 같은 서버 상태 관리 라이브러리를 동시 사용할 때, 두 상태 사이의 데이터 동기화와 의존성 주입은 어떻게 설계해야 응집도를 높일 수 있는가?
+*   프론트엔드 성능 최적화 중 메모리 누수(Memory Leak)를 예방하기 위해 Chrome DevTools 힙 스냅샷에서 식별되는 '분리된 DOM 노드(Detached DOM Nodes)'와 클로저(Closure) 잔류 문제를 프로덕션에서 어떻게 모니터링하고 방지할 수 있는가?
+*   Vite를 활용한 빌드 시 대규모 벤더 라이브러리로 인한 번들 사이즈 경고("Large Chunks")를 근본적으로 해결하기 위해 `manualChunks` 설정을 어떻게 분할해야 브라우저의 병렬 다운로드 및 캐싱 효율을 극대화할 수 있는가?
+
+### Practical Application Contexts
+
+*   **Implementation:** 신규 도메인 기능을 구현할 때 로직, UI, 커스텀 훅을 하나의 피처(Feature) 폴더에 응집시키고 다른 피처에서의 직접 임포트를 제한하여 철저히 캡슐화된 코드를 작성합니다 [3, 4]. 빈번히 발생하는 이벤트나 렌더링 로직 안에서는 인라인 익명 함수 사용을 지양하고 불필요한 재할당을 막습니다 [55, 56].
+*   **System Design:** 시스템 초기 아키텍처를 설계할 때 상태의 유형을 명확히 분류하여, 자주 바뀌지 않는 테마/설정은 Context API에, 상호작용이 잦은 장바구니/UI 상태는 Zustand에, 서버 데이터는 TanStack Query에 위임하는 다층적 상태 트리를 설계합니다 [5, 18, 57].
+*   **Operation / Maintenance:** 프로덕션 배포 후 Sentry, LogRocket, Datadog과 같은 가시성(Observability) 및 클라우드 로깅 도구를 연동해 사용자 세션을 리플레이하고 런타임 오류 및 메모리 누수 이슈를 사전에 탐지합니다 [36, 37].
+*   **Learning Path:** React 기초(useState, Props)와 컴포넌트 분리(SOLID, Clean Code) 개념을 숙지한 후, 점진적으로 Context API의 한계를 체험하고 Zustand로 마이그레이션하는 과정을 거치며 렌더링 최적화와 메모이제이션의 원리를 학습합니다 [4, 14, 58].
+*   **My Project Relevance:** 현재 유지보수 중인 거대한 React 프로젝트가 있다면, 컴포넌트 트리 상단에 무분별하게 배치된 Context Provider를 걷어내고 Zustand 기반의 부분 구독 패턴으로 리팩토링하거나 [21], Storybook 및 Chromatic을 CI 파이프라인에 도입하여 PR 단계에서 시각적 회귀 테스트(Visual Test)를 자동화하여 품질을 개선할 수 있습니다 [41, 59].
+
+### Adjacent Topics
+
+*   `[[Core Web Vitals]]`
+    *   확장 방향: LCP(Largest Contentful Paint), INP(Interaction to Next Paint), CLS(Cumulative Layout Shift) 등 구글이 정의한 사용자 경험 중심의 성능 측정 지표를 이해하고, 앞서 다룬 코드 스플리팅, 레이지 로딩, 렌더링 최적화 기법이 실제 사용자 체감 속도 향상에 어떻게 직결되는지 심층 분석하는 방향으로 연구할 수 있습니다 [23, 60, 61].
+*   `[[Git Branching Strategies & CI/CD Governance]]`
+    *   확장 방향: 복잡한 프론트엔드 시스템을 다수의 개발자가 협업하여 구축할 때 충돌을 최소화하고 릴리스 안정성을 높이기 위한 GitHub Flow, Trunk-Based Development 등의 브랜칭 전략과, ESLint/Prettier 자동화, Conventional Commits를 활용한 배포 파이프라인(CI/CD) 통제 방법을 확장해서 조사할 수 있습니다 [62-64].
+
+---
+*Last updated: 2026-04-30*
\ No newline at end of file
diff --git a/10_Wiki/Topics_GD/Folder Structure Best Practices.md b/10_Wiki/Topics_GD/Folder Structure Best Practices.md
new file mode 100644
index 00000000..c340d218
--- /dev/null
+++ b/10_Wiki/Topics_GD/Folder Structure Best Practices.md	
@@ -0,0 +1,69 @@
+# [[Folder Structure Best Practices]]
+
+## 📌 Brief Summary
+React 등 프론트엔드 프로젝트에서 코드의 유지보수성, 확장성, 그리고 협업 효율성을 높이기 위해 파일과 디렉터리를 체계적으로 구성하는 방법론입니다 [1]. 현대적인 애플리케이션에서는 과거의 파일 유형 기반(유형별 분류) 구조에서 벗어나, 기능(Feature)이나 도메인 중심으로 관련된 로직을 묶는 하이브리드 또는 기능 기반 방식이 모범 사례로 권장됩니다 [2, 3]. 이를 통해 UI, 비즈니스 로직, 상태 관리 등의 관심사를 명확히 분리하고 프로젝트가 커짐에 따라 발생하는 기술 부채를 최소화할 수 있습니다 [4].
+
+## 📖 Core 소스 Content
+
+*   **구조의 진화와 한계:** 
+    *   초기 소규모 프로젝트는 주로 모든 컴포넌트를 `components` 폴더에, 모든 훅을 `hooks` 폴더에 넣는 플랫(Flat) 구조나 파일 유형 기반 구조로 시작합니다 [5, 6].
+    *   하지만 앱의 규모가 커지면 단일 기능을 수정하기 위해 여러 폴더를 넘나들어야 하므로, 개발 속도가 느려지고 디버깅이 어려워지며 코드베이스가 복잡해지는 한계가 발생합니다 [3, 6, 7].
+*   **기능 기반(Feature-based) 및 하이브리드 구조:** 
+    *   2025년 기준 가장 권장되는 접근 방식은 파일 유형이 아닌 비즈니스 기능이나 모듈을 중심으로 폴더를 구성하는 것입니다 [2, 8, 9].
+    *   각 기능(Feature)은 캡슐화되어 다른 기능과 독립적으로 작동할 수 있으므로, 규모 확장 시 기존 코드에 영향을 주지 않고 새로운 기능을 매끄럽게 추가할 수 있습니다 [8, 10].
+*   **권장 디렉터리 구성 (src/ 하위):**
+    *   `assets/`: 이미지, 폰트 등 정적 미디어 리소스 보관 [11, 12].
+    *   `components/`: 여러 기능에서 공통으로 재사용되는 도메인에 구애받지 않는 UI 요소 (예: 버튼, 모달, 네비게이션 바 등) [2, 12, 13].
+    *   `features/` (또는 `modules/`): 인증(Auth), 대시보드(Dashboard) 등 도메인별 비즈니스 로직. 이 폴더 내부에는 해당 기능에만 쓰이는 컴포넌트, 훅, API 등을 캡슐화하여 보관합니다 [2, 9, 13].
+    *   `hooks/`: 폼 처리, 데이터 페칭 등 앱 전반에서 재사용 가능한 커스텀 훅 [9, 14].
+    *   `pages/` (또는 `routes/`): 라우팅에 매핑되는 페이지 레벨 컴포넌트 [15, 16].
+    *   `services/`: 서드파티 서비스 연동이나 API 요청 등 외부 통신 로직 [16, 17].
+    *   `store/` (또는 `context/`): Redux, Zustand, Context API를 활용하는 전역 상태 관리 로직 [14-16].
+    *   `utils/`: 날짜 포맷팅, 데이터 유효성 검사 등 상태를 가지지 않는 유틸리티 함수 [17, 18].
+    *   `styles/`: 글로벌 CSS, 테마(Theme) 등 전역 스타일링 파일 [18, 19].
+    *   `types/`: TypeScript 사용 시 전역으로 사용되는 타입 및 인터페이스 보관 [18].
+    *   `config/`: 환경 변수나 애플리케이션 전역 설정(API 기본 URL 등) 관리 [18, 20].
+*   **Feature-Sliced Design (FSD):** 
+    *   기능 기반 폴더 구조보다 더 엄격하게 의존성의 방향을 통제하는 프론트엔드 아키텍처 방법론입니다 [21].
+    *   `shared` -> `entities` -> `features` -> `widgets` -> `pages` -> `app` 이라는 고정된 다층 계층(Layer)을 가집니다 [22, 23].
+    *   상위 계층은 하위 계층의 코드를 가져올 수 있지만(Import), 하위 계층은 상위 계층을 참조할 수 없는 단방향 의존성 규칙을 통해 순환 의존성을 방지합니다 [22, 24].
+*   **Next.js 환경에서의 라우트 그룹 (Route Groups):**
+    *   Next.js 프로젝트에서는 괄호를 사용한 폴더명 `(folderName)` 방식을 통해, 실제 URL 경로에는 영향을 주지 않으면서도 관련 기능이나 논리에 따라 라우트를 깔끔하게 그룹화할 수 있습니다 [25-27].
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+- [[Feature-Sliced Design]]
+  - 연결 이유: 대규모 React 애플리케이션의 폴더 구조를 구축하기 위해 고안된 전문적인 프론트엔드 아키텍처 방법론이기 때문입니다 [21].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 폴더 간의 단방향 의존성 규칙과 각 폴더(Layer, Slice, Segment)가 담당해야 하는 역할의 엄격한 분리 방식 [22, 28].
+
+- [[Separation of Concerns]] (관심사의 분리)
+  - 연결 이유: 폴더 구조를 설계하는 근본적인 목적이 UI 렌더링, 전역 상태 관리, 데이터 통신(API) 등의 책임을 각기 다른 위치로 분리하는 데 있기 때문입니다 [4, 29].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: `services/`, `store/`, `components/` 등의 폴더를 분리하여 단일 책임 원칙(SRP)을 프론트엔드 아키텍처 전반에 적용하는 방법 [4, 30].
+
+- [[Naming Conventions]] (명명 규칙)
+  - 연결 이유: 일관된 폴더 및 파일 명명 규칙(예: 폴더명은 kebab-case, 컴포넌트는 PascalCase)은 폴더 구조 내에서 파일을 예측 가능하게 찾고 충돌을 방지하는 핵심 규칙이기 때문입니다 [31-33].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 다양한 운영체제와 CI/CD 파이프라인에서 빌드 에러를 방지하고 팀 내 코드 가독성을 유지하는 방법 [34, 35].
+
+### Deeper Research Questions
+- 기능 기반(Feature-based) 폴더 구조에서 각 기능이 상호작용해야 할 때 발생하는 교차 관심사(Cross-cutting concerns)나 공유 의존성을 어떻게 관리하고 해결할 수 있는가?
+- 레거시 파일 유형 기반(File-type based) React 프로젝트를 기능 기반 혹은 Feature-Sliced Design으로 점진적으로 마이그레이션하기 위한 가장 안전하고 효율적인 단계는 무엇인가?
+- Feature-Sliced Design의 단방향 의존성 원칙을 ESLint와 같은 정적 분석 도구로 자동 강제화(Governance)하는 방법은 무엇인가?
+- 폴더 구조를 모듈화할 때 발생하는 파일 중첩 문제와 이를 피하기 위한 적절한 인덱스(Barrel) 파일 사용 전략의 장단점은 무엇인가?
+- 상태 관리 라이브러리(Context API, Zustand, Redux 등)의 종류에 따라 권장되는 `store/` 폴더 내부의 구조는 어떻게 달라져야 하는가?
+
+### Practical Application Contexts
+- **Implementation:** React 컴포넌트를 생성할 때, 모든 요소를 `components/` 폴더에 넣지 않고 특정 도메인(예: 인증)에만 쓰이는 요소는 `features/auth/components/`로 격리하여 캡슐화를 실천합니다.
+- **System Design:** 프로젝트 초기 세팅 단계에서 비즈니스 도메인을 분석하여 어떤 코드가 전역(`shared/` 또는 `components/`)에 속하고 어떤 코드가 로컬(`features/`)에 속할지 기준을 마련합니다.
+- **Operation / Maintenance:** 기능에 버그가 발생했을 때, 해당 기능의 폴더(`features/feature-name/`)만 확인하면 UI, 상태, API 요청 로직이 모여 있어 디버깅 및 유지보수 속도가 크게 향상됩니다.
+- **Learning Path:** 처음에는 단순한 플랫 구조로 React를 학습한 후, 컴포넌트가 30개 이상으로 늘어나는 시점에 기능 기반 폴더 구조를 도입하여 아키텍처 설계 역량을 기를 수 있습니다.
+- **My Project Relevance:** 현재 진행 중이거나 리팩토링해야 할 React 코드베이스에서, 거대해진 `components/` 폴더를 도메인 단위의 `features/` 폴더로 나누고 재사용 불가 로직들을 분리하는 데 직접적으로 적용됩니다.
+
+### Adjacent Topics
+- [[State Management]]
+  - 확장 방향: 전역 상태(Global State)와 로컬 상태(Local State)를 어디에 보관해야 하는지, Zustand와 같은 도구가 `store/` 폴더의 구조를 어떻게 단순화하는지 확장하여 조사할 수 있습니다.
+- [[Code Splitting]] (코드 스플리팅)
+  - 확장 방향: 라우트 혹은 폴더(Feature) 단위로 코드 스플리팅과 지연 로딩(Lazy Loading)을 적용하여 초기 번들 크기를 줄이고 성능을 최적화하는 전략과 연결됩니다.
+
+---
+*Last updated: 2026-04-30*
\ No newline at end of file
diff --git a/10_Wiki/Topics_GD/Frontend Performance Debugging.md b/10_Wiki/Topics_GD/Frontend Performance Debugging.md
new file mode 100644
index 00000000..e8479bfa
--- /dev/null
+++ b/10_Wiki/Topics_GD/Frontend Performance Debugging.md	
@@ -0,0 +1,72 @@
+# [[Frontend Performance Debugging]]
+
+## 📌 Brief Summary
+프론트엔드 성능 디버깅(Frontend Performance Debugging)은 웹 애플리케이션의 메모리 누수, 불필요한 리렌더링, 잦은 가비지 컬렉션 등으로 인해 발생하는 성능 저하와 응답 지연을 식별하고 해결하는 과정입니다 [1-3]. 개발자는 브라우저의 내장 개발자 도구(Chrome DevTools)를 활용해 메모리 상태와 컴포넌트 렌더링 비용을 로컬에서 분석합니다 [4, 5]. 더 나아가 프로덕션 환경에서는 클라우드 기반 로깅 및 모니터링 도구를 사용하여 실제 사용자의 세션과 에러를 추적함으로써 복잡한 성능 병목의 근본 원인을 파악합니다 [6-8].
+
+## 📖 Core 소스 Content
+**메모리 문제 진단 (Memory Issues Diagnosis)**
+프론트엔드 성능 저하의 주요 원인 중 하나는 메모리 누수(Memory Leak)와 메모리 팽창(Memory Bloat)입니다. 자바스크립트에서는 사용이 끝난 메모리를 가비지 컬렉터가 회수하지만, DOM 노드가 문서에서 제거된 후에도 자바스크립트 참조가 남아있는 '분리된 DOM 노드(Detached DOM Nodes)', 누적된 이벤트 리스너, 클로저(Closure)에 의해 유지되는 참조 등이 메모리 누수를 유발합니다 [2, 9, 10]. Chrome DevTools의 Task Manager를 통해 실시간 DOM 노드와 JS 힙(Heap) 메모리 증가를 확인하고, Memory 패널의 Heap Snapshot을 비교하여 분리된 DOM 트리를 식별하며, Allocation Timeline을 사용해 언제 새로운 메모리가 할당되는지 추적할 수 있습니다 [4, 11, 12]. 빈번한 가비지 컬렉션은 스크립트 실행을 자주 일시 정지시켜 화면의 끊김(Jank)을 발생시킵니다 [1].
+
+**React 컴포넌트 렌더링 프로파일링 (React Rendering Profiling)**
+React 애플리케이션에서는 상태(State), 프로퍼티(Props), 컨텍스트(Context) 변경 또는 부모 컴포넌트의 렌더링에 의해 리렌더링이 트리거됩니다 [13]. 불필요한 리렌더링은 메인 스레드를 차단하고 상호작용 시간을 지연시킵니다 [3]. 이를 디버깅하기 위해 React DevTools Profiler를 사용하여 어떤 컴포넌트가 언제, 왜 렌더링되었는지, 얼마나 시간이 걸렸는지(Flamegraph 뷰 등)를 분석합니다 [5, 14]. 또한, 개발 환경 전용 라이브러리인 `why-did-you-render`를 활용하면 실제 상태나 prop 변경 없이 발생하는 리렌더링에 대한 콘솔 경고를 받을 수 있습니다 [15, 16].
+
+**프로덕션 관측성과 클라우드 로깅 (Production Observability and Logging)**
+로컬 환경을 넘어 실제 운영 환경의 성능을 디버깅하기 위해 Sentry, LogRocket, Datadog RUM, SigNoz와 같은 프론트엔드 클라우드 로깅 도구가 사용됩니다 [17, 18]. 이 도구들은 단순한 에러 로깅을 넘어 사용자가 에러나 성능 저하를 겪기 직전의 행동을 비디오처럼 다시 볼 수 있는 세션 리플레이(Session Replay), 프론트엔드 에러를 백엔드 트레이스와 연관 지어 분석하는 분산 트레이싱(Distributed Tracing), 그리고 실제 사용자의 Core Web Vitals(LCP, FID, INP 등) 모니터링 기능을 제공하여 맹점 없는 디버깅을 가능하게 합니다 [7, 8, 19-21].
+
+## ⚖️ Trade-offs & Caveats
+* **모니터링 도구의 성능 최적화 반대 급부:** LogRocket이나 Sentry 같은 강력한 로깅 및 성능 모니터링 도구들을 클라이언트 사이드에 탑재하면 자바스크립트 번들 사이즈가 커지고 성능에 영향을 미칩니다. 일부 도구는 최대 120ms의 추가 로드 시간을 발생시킬 수 있으므로 1초가 중요한 서비스에서는 가벼운 옵션을 선택해야 합니다 [22-24].
+* **세션 리플레이와 프라이버시 문제:** 모든 사용자 세션과 DOM/상태 변화를 기록하는 도구(예: LogRocket)의 기본 '모두 캡처' 방식은 민감한 개인정보를 노출할 위험이 있습니다. 이를 방지하기 위해 마스킹 설정을 수동으로 엄격히 구성해야 하는 관리 비용이 발생합니다 [19, 23, 25, 26].
+* **비용과 가시성의 타협 (Cost vs. Visibility):** Datadog과 같은 대규모 옵저버빌리티 플랫폼은 수집(Ingestion)과 색인(Indexing) 단계에서 이중 과금 모델을 사용하여 트래픽이 많은 경우 엄청난 비용이 발생합니다. 비용 절감을 위해 로그의 20%만 색인하게 되면, 실제 장애 발생 시 디버깅에 필요한 데이터의 80%가 검색되지 않는 트레이드오프가 발생합니다 [27-29].
+* **최적화 기법 자체의 오버헤드:** `React.memo()`, `useCallback`, `useMemo`와 같은 최적화 훅은 이전 참조값을 메모리에 저장하고 비교하는 오버헤드를 발생시킵니다. 렌더링 비용보다 비교 비용이 더 큰 가벼운 컴포넌트에 남용하면 오히려 성능을 저하시키는 원인이 됩니다 [30, 31].
+* **컴파일러 자동화로 인한 디버깅 난이도 상승:** React Compiler 같은 빌드 타임 자동 메모이제이션 도구를 사용하면 명시적인 훅 작성을 줄일 수 있지만, 컴파일러가 블랙박스로 작동하므로 예기치 않은 리렌더링이 발생할 경우 코드 상에서 원인을 찾기 어려워 React DevTools Profiler에 전적으로 의존해야 하는 단점이 있습니다 [32].
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+
+#### [관계 유형 A (로컬 디버깅 및 분석 도구)]
+- [[Chrome DevTools Memory Profiler]]
+  - 연결 이유: 자바스크립트 애플리케이션의 메모리 누수와 객체 보존 상태를 프로파일링하는 브라우저 내장 도구.
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: Heap Snapshots 비교, Allocation Timeline을 통한 메모리 할당 추적, Detached DOM tree 파악 기법 [9, 12, 33].
+- [[React DevTools Profiler]]
+  - 연결 이유: React 특유의 렌더링 사이클과 성능 병목을 시각화하는 핵심 도구.
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 컴포넌트 렌더링 소요 시간, 렌더링 발생 원인(Props/State 변경 여부 판별) [5, 14].
+
+#### [관계 유형 B (프로덕션 관측성 및 모니터링)]
+- [[Frontend Cloud Logging Tools]]
+  - 연결 이유: Sentry, LogRocket, Datadog RUM, SigNoz 등 배포 이후 발생하는 성능 저하와 버그를 추적하는 플랫폼.
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 프로덕션 레벨에서의 세션 리플레이, 자동 에러 그룹화, 엔드투엔드 분산 트레이싱, Core Web Vitals 추적 [7, 8, 20, 21, 34].
+
+#### [관계 유형 C (아키텍처 및 안티패턴)]
+- [[JavaScript Memory Leaks]]
+  - 연결 이유: 애플리케이션 성능을 점진적으로 파괴하는 현상으로 메모리 팽창, 가비지 컬렉션 등과 연관.
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 클로저 잔류 참조(Closure-Retained References), 해제되지 않은 이벤트 리스너의 동작 메커니즘 [2, 10, 35].
+- [[React Re-render Optimization]]
+  - 연결 이유: React의 렌더링 특성상 발생하는 메인 스레드 블로킹 문제를 해결하기 위한 코드 레벨 기법.
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 참조 안정성(Reference stability), 익명 함수의 부작용, `useMemo` 및 `useCallback`의 올바른 활용법 [36-38].
+
+### Deeper Research Questions
+
+- 프론트엔드 모니터링 시 수집하는 Sentry, LogRocket 등의 툴이 유발하는 성능 저하(번들 사이즈 및 실행 오버헤드)를 최소화하면서도 Core Web Vitals 등 유의미한 디버깅 데이터를 수집하는 최적의 설정 전략은 무엇인가?
+- JavaScript 환경의 Allocation Timeline 상에서 빈번하게 발생하는 가비지 컬렉션(GC) 스파이크와 실제 브라우저의 메인 스레드 멈춤 현상(Jank/INP 저하) 간의 상관관계를 어떻게 정량적으로 프로파일링할 수 있는가?
+- React Compiler가 자동화하는 영역과 서드파티 라이브러리(예: 항상 새로운 객체를 반환하는 `useLocation`, `useMutation`)로 인해 컴파일러가 최적화를 우회하는 경우, 이 충돌을 디버깅하고 해결하는 구체적인 패턴은 무엇인가?
+- Puppeteer 기반의 Automated Memory Testing을 CI/CD 파이프라인에 통합하여, Detached DOM node나 Event Listener 누적과 같은 메모리 누수를 프로덕션 배포 전에 차단하는 방법은 무엇인가?
+- Context API 사용 시 발생하는 광범위한 리렌더링 문제를 해결하기 위해 Zustand와 같은 외부 상태 관리 도구의 'Selector' 패턴을 사용할 때, 디버깅 과정에서 Redux DevTools 연동이 제공하는 구체적인 이점은 무엇인가?
+
+### Practical Application Contexts
+
+- **Implementation:** React 컴포넌트 마운트 해제 시 `useEffect` 클린업 함수를 작성하여 이벤트 리스너를 제거함으로써 메모리 누수를 방지하고, 로컬 개발 환경에서 `why-did-you-render` 라이브러리를 추가하여 불필요한 리렌더링을 콘솔 경고로 조기 감지한다 [15, 39].
+- **System Design:** 초기 프론트엔드 아키텍처 설계 단계부터 SigNoz(OpenTelemetry 기반)나 Sentry와 같은 로깅 도구 도입을 인프라 구성 요소로 결정하고, 사용자 정보 보호를 위해 세션 캡처 시 민감 데이터 마스킹 정책을 사전 설계한다 [21, 25, 26, 40].
+- **Operation / Maintenance:** 프로덕션 환경에서 시간이 지남에 따라 앱이 무거워지거나 느려진다는 사용자 제보가 들어올 경우, Chrome DevTools Memory 패널의 Heap Snapshot을 통해 분리된 DOM 노드가 점진적으로 누적되는지 검사하고 원인 코드를 수정한다 [1, 9, 41].
+- **Learning Path:** 우선 JavaScript 가비지 컬렉터의 동작 원리와 메모리 누수 패턴을 학습한 뒤, Chrome DevTools의 Task Manager와 Memory 패널 사용법을 익히고, 최종적으로 React Profiler와 프로덕션 로깅 도구 활용법으로 학습을 확장한다.
+- **My Project Relevance:** 현재 진행하는 React 기반 대시보드 프로젝트에서 테이블 데이터나 차트 업데이트 시 화면 멈춤이 발생할 경우, Chrome DevTools Performance 탭을 통해 스크립트 실행 시간을 확인하고 React Profiler를 붙여 불필요하게 리렌더링되는 자식 컴포넌트를 식별, `React.memo` 또는 식별자(Key)를 수정하는 최적화 작업에 직접 적용할 수 있다.
+
+### Adjacent Topics
+
+- [[Core Web Vitals]]
+  - 확장 방향: 프론트엔드 성능 최적화와 디버깅의 궁극적인 성과 지표이자 기준점이 되는 실제 사용자 체감 속도 지표(LCP, FID, INP, CLS 등) 심층 탐구 [8].
+- [[React Server Components (RSC)]]
+  - 확장 방향: Next.js 환경에서 클라이언트 측 자바스크립트 번들 사이즈 자체를 줄이고 상호작용 없는 UI를 서버에서 렌더링함으로써 근본적인 클라이언트 디버깅 요소 및 리렌더링 비용을 제거하는 아키텍처 [42, 43].
+
+---
+*Last updated: 2026-04-30*
\ No newline at end of file
diff --git a/10_Wiki/Topics_GD/React Application Scaling.md b/10_Wiki/Topics_GD/React Application Scaling.md
new file mode 100644
index 00000000..3baf9301
--- /dev/null
+++ b/10_Wiki/Topics_GD/React Application Scaling.md	
@@ -0,0 +1,29 @@
+# [[React Application Scaling]]
+
+## 📌 Brief Summary
+리액트 애플리케이션 스케일링(React Application Scaling)은 애플리케이션의 크기와 복잡성이 증가함에 따라 발생하는 아키텍처, 성능, 상태 관리, 그리고 협업 문제를 체계적으로 해결하는 과정입니다 [1-3]. 이는 단순히 렌더링 속도를 높이는 것을 넘어, 비즈니스 로직과 UI의 결합을 막고, 예측 가능한 폴더 구조를 도입하며, 불필요한 리렌더링과 번들 크기를 최적화하는 것을 포함합니다 [2-5]. 결과적으로 대규모 팀이 안정적이고 유지보수하기 쉬운 프론트엔드 시스템을 구축할 수 있도록 돕는 핵심 엔지니어링 패러다임입니다 [3, 6].
+
+## 📖 Core Content
+*   **구조적 아키텍처 및 폴더 구성 (Architectural Paradigms):**
+    초기 리액트 앱은 컴포넌트나 훅을 기술적 파일 타입(Type-Based)으로 분리하지만, 앱이 커지면 기능 기반(Feature-Based) 또는 도메인 주도 구조로 전환해야 확장성을 확보할 수 있습니다 [7, 8]. 특히 **FSD(Feature-Sliced Design)**는 애플리케이션을 `app`, `pages`, `widgets`, `features`, `entities`, `shared` 등의 계층화된 슬라이스로 나누고, 하위 계층만 참조하도록 하는 단방향 의존성을 강제하여 코드 결합도를 낮추고 리팩토링을 용이하게 합니다 [9-11].
+*   **상태 관리 아키텍처 (State Management Evolution):**
+    단일한 전역 상태 도구에서 벗어나 데이터 특성에 맞는 도구를 선택해야 합니다 [12]. 테마나 로케일처럼 정적이고 변경이 적은 데이터는 Context API가 적합합니다 [13]. 반면 빈번하게 변경되는 동적 상태는 선택자(Selector) 패턴을 통해 리렌더링을 방지하는 Zustand가 유리하며, 복잡한 비동기 로직과 대규모 팀 협업에는 구조를 강제하는 Redux가 권장됩니다 [14-17]. 서버 상태 처리는 TanStack Query와 같은 API 계층용 도구로 완전히 분리해야 합니다 [16, 18].
+*   **성능 및 번들링 최적화 (Performance & Bundling):**
+    리액트는 상태나 프롭스가 변경될 때마다 하위 트리를 리렌더링합니다 [19]. 이를 방지하기 위해 `React.memo`, `useCallback`, `useMemo`를 전략적으로 사용하여 참조 안정성(Reference Equality)을 유지해야 합니다 [20, 21]. 초기 로딩 속도 개선을 위해서는 `React.lazy`와 라우트 레벨의 코드 스플리팅을 적용하고, Vite의 `manualChunks`를 활용해 React 코어 등 무거운 벤더 라이브러리를 별도 파일로 분리하여 캐싱 효율을 높입니다 [22-25]. 최근에는 React Compiler를 도입해 빌드 타임에 자동 메모이제이션을 수행하는 기법도 활용됩니다 [26-29].
+*   **코드 품질 및 복원력 (Quality & Resilience):**
+    SOLID, DRY, KISS, YAGNI 원칙을 준수하여 컴포넌트를 단일 책임(SRP)을 갖도록 간결하게 유지합니다 [30-32]. 파일명은 운영체제 호환성을 위해 `kebab-case`를, 리액트 컴포넌트는 `PascalCase`를 사용하는 등 네이밍 컨벤션을 통일합니다 [33-36]. 또한 특정 컴포넌트의 렌더링 오류가 전체 앱을 다운시키는 것을 막기 위해 에러 바운더리(Error Boundaries)를 중요 UI 섹션마다 배치하여 Fallback UI를 제공하는 복원력 있는 설계가 필수적입니다 [37-39].
+
+## ⚖️ Trade-offs & Caveats
+*   **과도한 엔지니어링 (Over-Engineering):** FSD나 Redux와 같은 고도화된 아키텍처와 상태 관리 도구를 소규모 프로젝트나 경험이 적은 팀에 도입하면, 학습 곡선이 크게 상승하고 불필요한 보일러플레이트 코드가 양산되어 오히려 개발 속도를 늦출 수 있습니다 [40-43].
+*   **메모이제이션의 오용에 따른 성능 저하:** `React.memo`나 `useMemo`를 무분별하게 사용하면, 이전 props 및 상태를 비교하는 과정에서 발생하는 연산 비용이 렌더링 비용 자체를 초과하여 오히려 애플리케이션의 성능을 악화시킬 수 있습니다 [44, 45].
+*   **React Compiler의 가시성 저하 및 호환성 제약:** 자동화된 최적화 도구인 React Compiler는 블랙박스처럼 작동하므로 성능 병목 발생 시 디버깅이 더 까다로워집니다 [46]. 또한 매 렌더링 시 의도적으로 불안정한 참조를 반환하는 서드파티 라이브러리(예: React Router, TanStack Query 일부 훅)와는 최적화 호환이 깨질 수 있으며, React 규칙을 지키지 않은 레거시 코드베이스에서는 적용이 어렵습니다 [47, 48].
+*   **Context API의 리렌더링 폭풍 (Re-render Storm):** Context API를 빈번하게 변하는 데이터 관리에 사용하면, 데이터 중 일부분만 변경되더라도 해당 컨텍스트를 구독하는 모든 하위 컴포넌트가 불필요하게 리렌더링되는 치명적인 성능 병목 현상을 유발합니다 [49, 50].
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+
+#### [아키텍처 및 폴더 구조 (Architecture & Structure)]
+- [[Feature-Sliced Design (FSD)]]
+  - 연결 이유: 확장 가능한 리액트 앱을 구축하기 위한 핵심 도메인 주도 아키텍처 방법론입니다.
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 기능, 위젯, 엔티티를 분리하고 단방향 의존성 규칙을 강제하여 결
\ No newline at end of file
diff --git a/10_Wiki/Topics_GD/React Frontend Architecture.md b/10_Wiki/Topics_GD/React Frontend Architecture.md
new file mode 100644
index 00000000..76200a99
--- /dev/null
+++ b/10_Wiki/Topics_GD/React Frontend Architecture.md	
@@ -0,0 +1,64 @@
+# [[React Frontend Architecture]]
+
+## 📌 Brief Summary
+React 프론트엔드 아키텍처는 확장 가능하고 유지보수하기 쉬운 애플리케이션을 구축하기 위한 구조적 뼈대이자 조직화 방법론이다 [1, 2]. 기존의 기술적 파일 단위 분리에서 벗어나, 비즈니스 도메인과 기능(Feature-Based)을 중심으로 코드를 구성하여 결합도를 낮추고 응집도를 높이는 것을 목표로 한다 [3-5]. 이를 통해 무분별한 비즈니스 로직의 UI 누수를 막고 명확한 상태 소유권을 확립하며, 팀과 코드베이스가 성장함에 따라 시스템이 예측 가능하게 확장할 수 있도록 돕는다 [6-8].
+
+## 📖 Core Content
+
+*   **폴더 구조와 모듈화의 진화**: 과거에는 컴포넌트, 훅, 스타일 등을 파일 유형별로 그룹화했으나, 프로젝트가 커질수록 논리적 기능이 파편화되어 탐색과 확장이 어려웠다 [4, 9]. 2025년 기준 프론트엔드 업계 표준은 비즈니스 기능을 중심으로 코드를 묶는 '기능 기반(Feature-Based)' 구조로 전환되었다 [5, 10]. 특정 기능과 관련된 컴포넌트, 훅, API 로직 등을 단일 디렉토리에 캡슐화함으로써 모듈의 독립성과 확장성을 크게 향상시킨다 [11, 12].
+*   **기능 분할 설계 (Feature-Sliced Design, FSD)**: FSD는 도메인 주도 설계(DDD)와 모듈형 아키텍처를 결합한 프론트엔드 전용 방법론이다 [3, 13]. 애플리케이션을 `app`, `pages`, `widgets`, `features`, `entities`, `shared`의 계층(Layer)으로 나누고, 상위 계층은 하위 계층에만 의존할 수 있다는 엄격한 '단방향 의존성' 규칙을 강제한다 [11, 14, 15]. 각 슬라이스는 `index.ts` 형태의 'Public API'를 통해서만 외부에 기능과 컴포넌트를 노출하여 내부 구현을 안전하게 캡슐화한다 [16-18].
+*   **상태 관리 아키텍처의 세분화**: 단일 모놀리식 스토어(예: 대규모 Redux)에 의존하던 방식에서 벗어나, 데이터의 성격에 따라 최적의 도구를 선택하도록 상태 관리가 파편화되었다 [19, 20]. 서버에서 가져오는 데이터인 '서버 상태'는 TanStack Query(React Query)를 이용해 캐싱 및 네트워크 로직을 격리하고, 테마나 설정 등 정적인 '전역 상태'는 Context API로, 장바구니나 실시간 데이터처럼 빈번하게 변하는 상태는 Zustand나 Jotai 등 선택적 렌더링을 지원하는 도구로 관리한다 [20-24].
+*   **소프트웨어 공학 원칙의 적용 (SOLID & Clean Code)**: React의 함수형 컴포넌트 개발에도 단일 책임 원칙(SRP)을 적용하여, 컴포넌트가 커지면 상태 관리, 데이터 페칭, 렌더링 등 각기 다른 책임을 가진 작은 컴포넌트로 분리해야 한다 [25, 26]. 중복을 피하는 DRY 원칙을 통해 공통 로직을 커스텀 훅으로 추출하면서도, 코드를 단순하게 유지하는 KISS 원칙과 미래를 위한 과도한 최적화를 피하는 YAGNI 원칙 간의 균형을 맞추는 것이 핵심이다 [27, 28].
+*   **명명 규칙과 거버넌스 도구**: 폴더와 파일 시스템은 OS 환경에 따른 오류를 방지하기 위해 `kebab-case`를, React 컴포넌트는 `PascalCase`를, 변수와 함수는 `camelCase`를 사용하는 것이 보편적인 컨벤션이다 [29-33]. 이러한 규칙과 아키텍처 의존성 경계는 ESLint나 Prettier, Husky와 같은 도구를 활용해 빌드 타임 및 커밋 단계에서 자동으로 강제(Linting)된다 [30, 34].
+
+## ⚖️ Trade-offs & Caveats
+
+*   **FSD 및 기능 기반 모듈화의 복잡성 오버헤드**: Feature-Sliced Design은 구조적 안정성을 제공하지만 "무엇이 하나의 기능(Feature)인가?"를 정의하는 경계를 설정하기 매우 까다롭다는 근본적 어려움이 있다 [35]. 인증(Auth)과 같은 교차 관심사(Cross-cutting concern)는 여러 기능에 걸쳐 있어 적절한 계층을 찾기 모호하며 [35, 36], 엄격한 분할 규칙을 소규모 프로젝트에 도입하면 오히려 불필요한 폴더 구조와 오버엔지니어링으로 인한 개발 속도 저하를 초래할 수 있다 [12, 37]. 또한, 규칙을 제대로 숙지하지 않으면 모든 코드를 'Shared' 계층에 쏟아부어 최악의 파급 효과를 낳는 스파게티 코드가 될 위험이 존재한다 [38, 39].
+*   **추상화(DRY)와 단순함(KISS)의 상충**: DRY 원칙에 집착하여 코드 중복을 무조건 피하려고 하면, 수많은 예외 처리와 분기를 포함하는 거대하고 복잡한 커스텀 훅이나 컴포넌트가 탄생하게 된다 [27]. 이러한 과도한 추상화는 단순한 코드 반복보다 가독성과 유지보수성을 떨어뜨려 KISS 원칙을 위반하는 반대 급부를 낳으므로, 명확한 패턴이 3번 이상 반복될 때까지는 추상화를 미루는 것이 권장된다 [27, 40, 41].
+*   **상태 관리 도구 선택에 따른 부작용**: React 내장 Context API는 외부 의존성 없이 상태를 주입할 수 있지만, 상태값의 일부만 변경되어도 해당 컨텍스트를 구독하는 모든 하위 컴포넌트가 강제로 리렌더링된다는 치명적인 성능 제약이 있다 [42, 43]. 반대로 Redux는 명확한 구조와 강력한 디버깅 툴을 제공하지만, 보일러플레이트 코드의 폭발적 증가를 동반하여 소규모 팀이나 간단한 애플리케이션에서는 과도한 기술 부채로 작용할 수 있다 [44, 45].
+*   **성능 최적화 기법의 숨은 비용**: `React.memo`, `useMemo`, `useCallback`은 불필요한 리렌더링을 막아주지만 그 자체가 공짜는 아니다 [46]. 이전 Props나 의존성 배열을 메모리에 저장하고 변경 여부를 얕은 비교(Shallow compare)하는 연산 비용이 추가된다 [46]. 만약 렌더링 비용이 매우 싼 컴포넌트에 사용하거나 불안정한 참조값(인라인 함수, 객체)을 지속적으로 전달하여 리렌더링 차단에 실패한다면, 최적화 코드 자체가 오히려 애플리케이션을 더 느리게 만드는 부작용이 발생한다 [46, 47].
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+
+#### [아키텍처 및 디자인 패턴]
+- [[Feature-Sliced Design]]
+  - 연결 이유: 현대 React 애플리케이션의 모듈화 및 계층화를 위해 고안된 가장 대표적이고 구체적인 프론트엔드 아키텍처 방법론이기 때문 [3, 13].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 도메인 기반 분할, 단방향 의존성 규칙 적용 방법, 그리고 Public API를 통한 컴포넌트의 캡슐화 원리 [14, 16, 17].
+- [[SOLID Principles]]
+  - 연결 이유: 확장 가능한 프론트엔드 구조를 짜기 위해 클래스 기반 OOP를 넘어 React의 함수형 컴포넌트에도 적용해야 하는 근본적인 소프트웨어 설계 원칙이기 때문 [17, 48].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 단일 책임 원칙(SRP)을 이용한 비대해진 컴포넌트의 리팩토링 방식 및 개방-폐쇄 원칙(OCP)을 활용한 UI 컴포넌트 합성(Composition) 전략 [25, 49].
+
+#### [상태 관리 및 최적화 전략]
+- [[State Management]]
+  - 연결 이유: 아키텍처 내에서 데이터(서버 데이터, 로컬 상태, 전역 UI 상태)의 성격에 따라 책임과 저장소를 어떻게 나눌지 결정하는 핵심 분야이기 때문 [20, 50].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: Context API의 렌더링 한계를 돌파하기 위한 Zustand/Jotai의 Selector 패턴 작동 원리 및 TanStack Query를 활용한 서버 상태 격리 기법 [21, 43, 51].
+- [[Performance Optimization]]
+  - 연결 이유: 대규모 아키텍처가 실제로 사용자 브라우저에서 효율적으로 동작하기 위해 필수적으로 수반되어야 하는 성능 지표(Web Vitals) 관리 방법이기 때문 [52, 53].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 지연 로딩(Lazy Loading) 및 코드 스플리팅을 통한 초기 번들 사이즈 최적화, 그리고 동시성 렌더링(Concurrent Rendering) 훅의 활용법 [54-56].
+
+### Deeper Research Questions
+- Feature-Sliced Design(FSD)에서 인증(Auth)이나 분석(Analytics) 같은 도메인 간의 교차 관심사(Cross-cutting concerns)가 발생할 때, 결합도를 높이지 않고 주입/공유하는 가장 이상적인 방법은 무엇인가?
+- React Compiler가 프로젝트에 성공적으로 도입되어 수동 메모이제이션 로직(`useMemo`, `useCallback`)이 대거 삭제될 때, 프론트엔드 폴더 구조와 코드 응집도에 어떤 형태의 구조적 변화가 일어날 수 있는가?
+- 서버 상태(Server State) 관리 라이브러리와 클라이언트 글로벌 상태(Client State) 도구를 완벽히 분리한 아키텍처에서, 두 상태가 불가피하게 동기화되거나 상호작용해야 하는 엣지 케이스를 깨끗하게 처리하는 패턴은 무엇인가?
+- 대규모 엔터프라이즈 환경에서 Micro-Frontends 아키텍처와 Feature-Sliced Design은 어떻게 호환되며, 각 독립 서비스 간의 중복 코드(Shared 레이어) 문제를 어떻게 통제할 수 있는가?
+- 복잡도 높은 순수 함수형 React 컴포넌트에 의존성 역전 원칙(DIP)을 적용할 때, 컨텍스트(Context API)나 프롭 드릴링(Prop Drilling)을 피하면서 활용할 수 있는 현대적인 제어 역전(IoC) 구현 패턴은 무엇이 있는가?
+
+### Practical Application Contexts
+
+- **Implementation:** 기술적 파일 유형(컴포넌트, 훅) 중심의 디렉토리 구조에서 벗어나, `src/features/` 내에 특정 비즈니스 로직(예: 장바구니, 유저 프로필)에 연관된 UI, API 통신, 로컬 훅을 캡슐화하여 구현한다 [5, 11, 57]. 
+- **System Design:** 모놀리식 글로벌 스토어 설계 지양. API 캐싱 및 서버 데이터는 TanStack Query를 사용해 비즈니스 로직 경계로 분리하고, 다크 모드 같은 앱 설정은 Context API로, 실시간 UI 상태 변경은 Zustand 등으로 쪼개어 시스템 데이터 흐름을 최적화한다 [20, 21, 24].
+- **Operation / Maintenance:** 런타임 크래시에 대비하기 위해 Error Boundary 컴포넌트를 앱의 최상단뿐 아니라 불안정한 서드파티 위젯이나 개별 라우트 단위에 감싸, 특정 모듈의 에러가 앱 전체의 "화이트 스크린" 장애로 번지는 것을 차단한다 [58-60].
+- **Learning Path:** React 기초 문법 및 렌더링 원리 파악 -> 컴포넌트 재사용과 SRP 원칙(SOLID) 학습 -> 기능 기반 폴더 구조 및 FSD 적용 방식 이해 -> 번들 최적화 및 렌더링 리팩토링 스킬 향상의 흐름으로 역량을 발전시킨다 [6, 17, 25].
+- **My Project Relevance:** 기존 코드베이스의 `components/` 폴더에 수십 개의 컴포넌트가 방치되어 있거나, `useCallback` 등이 과도하게 사용된 경우, 이를 비즈니스 도메인 단위의 폴더로 재배치하고 프로파일러(Profiler)를 통해 실제 병목 지점을 측정한 뒤 최적화를 진행하는 아키텍처 리팩토링에 직결된다 [12, 61, 62].
+
+### Adjacent Topics
+
+- [[Micro-Frontends]]
+  - 확장 방향: 단일 React SPA 아키텍처의 한계를 넘어, 독립적으로 배포 및 관리 가능한 여러 프론트엔드 팀과 서비스를 하나로 조율하는 엔터프라이즈급 인프라 확장 관점으로 연결 [3, 63].
+- [[Observability and Monitoring]]
+  - 확장 방향: 설계한 아키텍처가 실제 프로덕션 환경에서 어떻게 동작하고 어디서 병목을 일으키는지 측정하기 위한 구조적 로깅, 성능 프로파일링(Web Vitals), 그리고 Sentry를 활용한 세션 모니터링 기법으로 확장 [64-66].
+
+--- 
+*Last updated: 2026-04-30*
\ No newline at end of file
diff --git a/10_Wiki/Topics_GD/React Scalability.md b/10_Wiki/Topics_GD/React Scalability.md
new file mode 100644
index 00000000..6bd3e18d
--- /dev/null
+++ b/10_Wiki/Topics_GD/React Scalability.md	
@@ -0,0 +1,67 @@
+# [[React Scalability]]
+
+## 📌 Brief Summary
+React Scalability(React 확장성)는 기능, 팀 규모, 비즈니스 로직의 복잡성이 증가함에 따라 애플리케이션의 성능, 유지보수성, 예측 가능한 성장을 유지하는 능력을 의미합니다. 단순히 컴포넌트를 렌더링하는 것을 넘어, 결합도를 낮추고 응집도를 높이는 아키텍처 설계, 상태 관리의 최적화, 그리고 코드 스플리팅과 렌더링 성능 최적화를 포괄합니다. 확장 가능한 React 시스템은 명확한 폴더 구조(예: Feature-Sliced Design)와 엄격한 관심사 분리를 통해 코드베이스가 자체적인 무게로 인해 붕괴되는 것을 방지합니다. [1-4]
+
+## 📖 Core Content
+- **아키텍처 및 폴더 구조의 진화:** React는 기본적으로 아키텍처를 강제하지 않기 때문에, 프로젝트가 커지면 비즈니스 로직이 UI에 스며들고 의존성이 엉키는 아키텍처 붕괴가 발생하기 쉽습니다 [2]. 과거의 파일 유형별 폴더 구조(components, hooks, styles 등)는 규모가 커질수록 유지보수를 어렵게 만듭니다 [5, 6]. 확장 가능한 애플리케이션을 위해서는 도메인/기능 중심으로 코드를 구성하는 Feature-Based 구조 또는 **Feature-Sliced Design(FSD)**과 같은 방법론이 필수적입니다. FSD는 앱을 layers(app, pages, widgets, features, entities, shared)로 나누고 단방향 의존성 규칙과 퍼블릭 API 캡슐화를 강제하여 모듈의 독립성을 보장합니다 [7-11].
+- **클린 코드와 소프트웨어 엔지니어링 원칙:** 대규모 React 시스템에서는 SOLID, DRY, KISS, YAGNI와 같은 원칙이 적용되어야 합니다. 단일 책임 원칙(SRP)에 따라 거대한 컴포넌트는 작고 집중된 컴포넌트로 분리되어야 하며 [12], DRY 원칙을 통해 공통 로직은 커스텀 훅으로 추출하여 재사용성을 높여야 합니다 [13]. 더불어 파일 및 컴포넌트 명명 규칙(예: 파일은 kebab-case, 컴포넌트는 PascalCase)을 일관되게 유지하고 ESLint를 통해 아키텍처 경계를 강제하는 것이 대규모 팀 협업에 필수적입니다 [14, 15].
+- **규모에 따른 상태 관리 전략:** 애플리케이션이 커지면 단일 전역 상태만으로는 부족하며 상태의 역할에 따라 도구가 분리됩니다 [16]. React의 Context API는 값이 변경될 때마다 하위 컴포넌트 전체를 리렌더링시키므로 업데이트가 잦은 상태 관리에는 적합하지 않습니다 [17, 18]. 중간 규모의 앱에서는 Selector 패턴을 통해 불필요한 리렌더링을 막는 Zustand가 유용하며 [19-21], 500개 이상의 컴포넌트가 있는 대규모 앱이나 비동기 작업이 복잡한 경우 일관된 패턴과 강력한 디버깅을 제공하는 Redux가 산업 표준으로 작용합니다 [22, 23]. 서버 상태 관리는 TanStack Query(React Query) 등으로 클라이언트 상태와 분리하여 처리합니다 [20, 24].
+- **성능 엔지니어링 (Performance Optimization):** 확장 가능한 앱은 런타임 성능과 로딩 속도 최적화가 필수적입니다. `React.lazy`와 동적 임포트(Dynamic Imports)를 활용한 라우트 및 컴포넌트 레벨의 코드 스플리팅은 초기 번들 크기를 획기적으로 줄여줍니다 [25-27]. 또한 Vite의 `manualChunks`를 이용해 자주 변경되지 않는 Vendor 라이브러리를 분리하여 캐싱 효율을 높여야 합니다 [28-30]. 런타임 시에는 대규모 리스트를 위한 Virtualization(가상화) 처리, 안정적인 참조 유지를 위한 `useCallback`과 `useMemo` 사용, 그리고 React 18의 동시성 기능(`useTransition`, `useDeferredValue`)을 활용해 메인 스레드의 응답성을 유지합니다 [31-34].
+
+## ⚖️ Trade-offs & Caveats
+- **아키텍처의 오버헤드:** Feature-Sliced Design이나 도메인 기반 구조를 도입하면 컴포넌트가 '기능'인지 '위젯'인지 구분하기 위한 의미론적 논의가 필요해지는 등 초기 학습 곡선과 오버헤드가 발생합니다 [35, 36]. 소규모 프로젝트에서는 이러한 구조가 오히려 과도한 복잡성(Overkill)을 초래할 수 있습니다 [37].
+- **메모이제이션의 비용:** `React.memo`, `useMemo`, `useCallback`을 남용하면 오히려 성능이 저하될 수 있습니다. React가 이전 props를 저장하고 비교하는 작업에 오버헤드가 발생하며, 컴포넌트 렌더링 비용이 매우 작은 경우 이 비교 작업이 렌더링 자체보다 더 많은 비용을 소모할 수 있습니다 [38, 39]. 
+- **상태 관리 도구의 유연성 vs 보일러플레이트:** Zustand의 극단적인 유연성은 규율 없이 사용될 경우 팀원마다 서로 다른 비동기 처리 패턴을 작성하게 만드는 등 혼란을 야기할 수 있습니다 [19, 40]. 반면 Redux는 초기에 작성해야 하는 보일러플레이트가 매우 많아 개발 속도를 늦추지만, 대규모 팀에서는 오히려 이 구조가 버그를 방지하는 기능으로 작용합니다 [22, 41].
+- **React Compiler와 서드파티 라이브러리 호환성:** React Compiler를 도입하면 수동 메모이제이션의 필요성을 크게 줄일 수 있지만, `useMutation`이나 `useLocation`처럼 렌더링 시마다 의도적으로 새로운 객체를 반환하는 서드파티 라이브러리 훅과 함께 사용할 경우 캐싱 체인이 끊어지고 리렌더링이 발생하는 한계가 있습니다 [42, 43].
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+
+#### [아키텍처/기반 기술]
+- [[Feature-Sliced Design]]
+  - 연결 이유: React의 한계인 구체적인 아키텍처 부재를 해결하기 위해 설계된 대규모 프론트엔드 방법론입니다.
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 레이어(Layer) 간의 단방향 의존성 원칙과 Public API를 활용한 모듈의 캡슐화 및 결합도 최소화 방법.
+- [[SOLID Principles]]
+  - 연결 이유: 확장 가능하고 유지보수가 쉬운 React 코드를 작성하기 위한 핵심 소프트웨어 엔지니어링 원칙입니다.
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 거대한 컴포넌트를 단일 책임 원칙(SRP)에 따라 작은 기능으로 분리하고, 커스텀 훅을 활용하여 로직을 재사용하는 구조적 사고.
+
+#### [구현/활용 도구]
+- [[State Management Libraries (Redux, Zustand, Context API)]]
+  - 연결 이유: 애플리케이션의 크기와 상태 업데이트 빈도에 따라 적절한 도구를 선택하는 것은 확장성에 지대한 영향을 미칩니다.
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 불필요한 리렌더링 방지를 위한 Selector 패턴의 동작 원리와, 대규모 프로젝트에서 강제되는 상태 관리 아키텍처의 중요성.
+- [[Code Splitting & Lazy Loading]]
+  - 연결 이유: 코드가 비대해짐에 따라 발생하는 성능 저하(번들 크기 증가)를 해결하기 위한 핵심 런타임 최적화 기법입니다.
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: `React.lazy`와 Vite의 `manualChunks`를 이용한 번들 크기 축소 및 브라우저 캐싱 전략.
+- [[React Error Boundaries]]
+  - 연결 이유: 대규모 앱에서 하나의 결함 있는 컴포넌트로 인해 전체 애플리케이션이 붕괴되는 것을 막아주는 안전 장치입니다.
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 런타임 렌더링 에러를 격리(Isolate)하고 폴백(Fallback) UI를 제공하여 시스템 복원력을 높이는 방법.
+
+### Deeper Research Questions
+
+- 대규모 팀 환경에서 Feature-Sliced Design을 적용할 때, 'Shared' 레이어가 비대해지고 기능 간 교차 관심사(Cross-cutting concerns)가 얽히는 문제를 어떻게 관리해야 하는가?
+- React Context API에서 발생하는 리렌더링 폭포(Re-render storm) 문제를 해결하기 위해 Zustand의 Selector 패턴은 내부적으로 구독(Subscription) 모델을 어떻게 다르게 처리하는가?
+- React Compiler의 자동 메모이제이션 기능이 도입됨에 따라 기존 레거시 코드베이스의 기술 부채(예: Rules of React 위반 사항)는 컴파일 최적화 과정에서 어떠한 부작용을 일으킬 수 있는가?
+- Vite의 `manualChunks`를 사용하여 거대한 번들을 분리할 때, 벤더 라이브러리(React core, UI Kits 등)의 특성에 따른 최적의 청크 분할 및 브라우저 캐싱 전략은 무엇인가?
+- 대규모 리스트 데이터를 렌더링할 때 가상화(Virtualization)를 적용하지 않으면 브라우저 메모리 할당(Detached DOM nodes 등) 측면에서 어떤 치명적인 문제가 발생하는가?
+
+### Practical Application Contexts
+
+- **Implementation:** 프로젝트 초기 설정 시 기술 파일 단위(components, hooks) 구조를 피하고, 도메인/기능 중심의 폴더 구조를 설계합니다. 파일명은 운영체제 간 충돌 방지를 위해 kebab-case로, 컴포넌트는 PascalCase로 일관되게 명명합니다.
+- **System Design:** 전역 상태(Zustand/Redux), 서버 상태(TanStack Query), 로컬 상태(useState)의 책임을 명확히 분리합니다. 잦은 업데이트가 발생하는 상태는 컴포넌트 트리의 최상단 Context에 두는 것을 피합니다.
+- **Operation / Maintenance:** Sentry나 LogRocket과 같은 프론트엔드 모니터링 도구와 React Error Boundaries를 결합하여, 프로덕션 환경에서 발생하는 컴포넌트 렌더링 에러를 캡처하고 앱의 크래시를 방지합니다.
+- **Learning Path:** 단순한 React 문법 학습을 넘어, 상태 관리 도구별 렌더링 최적화 차이를 분석하고 Chrome DevTools 프로파일러를 사용하여 렌더링 병목을 확인하는 습관을 길러 아키텍트 수준으로 성장합니다.
+- **My Project Relevance:** 현재 유지보수 중인 React 애플리케이션에서 무거운 서드파티 라이브러리로 인해 메인 번들 크기가 비대해진 상황이라면, `React.lazy` 기반의 라우트 레벨 스플리팅과 Vite `manualChunks` 적용을 검토할 수 있습니다.
+
+### Adjacent Topics
+
+- [[Server Components (Next.js)]]
+  - 확장 방향: 클라이언트 측으로 전송되는 JavaScript 번들 자체를 제거하여 하이드레이션(Hydration) 오버헤드를 줄이고 확장성과 성능을 동시에 잡는 최신 렌더링 패러다임.
+- [[Memory Leak Detection in JavaScript]]
+  - 확장 방향: 확장 가능한 애플리케이션에서 장시간 사용 시 성능을 저하시키는 Detached DOM Nodes나 이벤트 리스너 누수 등을 Chrome DevTools Heap Snapshot을 통해 디버깅하는 방법.
+- [[Git Branching Workflows for Small & Large Teams]]
+  - 확장 방향: 규모가 확장되는 프론트엔드 팀이 충돌 없이 코드를 통합하기 위해 사용하는 GitHub Flow, Trunk-Based Development 및 PR(Pull Request) 리뷰 에티켓.
+
+---
+*Last updated: 2026-04-30*
\ No newline at end of file
diff --git a/10_Wiki/Topics_GD/Scalable Frontend Systems.md b/10_Wiki/Topics_GD/Scalable Frontend Systems.md
new file mode 100644
index 00000000..57f7da94
--- /dev/null
+++ b/10_Wiki/Topics_GD/Scalable Frontend Systems.md	
@@ -0,0 +1,65 @@
+# [[Scalable Frontend Systems]]
+
+## 📌 Brief Summary
+대규모 프론트엔드 시스템(Scalable Frontend Systems)은 높은 유지보수성, 고성능, 확장성을 보장하기 위해 기존의 단순한 스크립트 실행을 넘어 정교하게 분산된 소프트웨어 아키텍처를 도입한 시스템입니다 [1]. 기능별 또는 도메인 중심의 모듈형 폴더 구조를 사용하며, SOLID와 같은 클린 코드 원칙을 준수하고 애플리케이션 상태와 서버 상태를 분리하여 관리합니다 [2-4]. 더불어 자동화된 빌드 최적화, 예측 가능한 렌더링 최적화, 정교한 에러 처리 및 협업 워크플로우를 결합하여 애플리케이션이 안정적으로 성장할 수 있도록 지원합니다 [1, 5].
+
+## 📖 Core Content
+
+*   **아키텍처 패러다임과 폴더 구조:** 확장성을 달성하기 위해서는 파일을 파일의 유형(components, hooks 등)별로 모아두는 구조에서 기능(Feature)이나 도메인 중심으로 구조를 개편해야 합니다 [2, 6]. 특히 Feature-Sliced Design (FSD)은 코드 계층을 Scope와 책임에 따라 분할(shared, entities, features, widgets, pages, app)하고, 하위 계층이 상위 계층을 참조하지 못하게 하는 단방향 의존성과 캡슐화된 Public API 규칙을 강제하여 결합도(Coupling)를 극적으로 낮춥니다 [7-10].
+*   **소프트웨어 엔지니어링 원칙 적용:** 확장 가능한 React 시스템은 컴포넌트가 하나의 역할만 하도록 분리하는 단일 책임 원칙(SRP)을 비롯하여 개방/폐쇄 원칙(OCP), DRY, KISS, YAGNI 등의 SOLID 및 클린 코드 원칙을 적용합니다 [3, 11]. 이로 인해 코드의 예측 가능성이 향상되고 불필요한 조기 최적화나 복잡성이 제거됩니다 [12].
+*   **상태 관리의 파편화 (State Management):** 하나의 거대한 Redux 스토어에 의존하기보다, 데이터의 성격에 맞는 도구를 선택하는 방식으로 진화했습니다 [13]. 불필요한 전역 렌더링을 방지하기 위해 Context API 대신 선택자(Selector) 패턴을 지원하는 Zustand 등을 전역 상태 관리에 사용하며, API에서 가져오는 서버 상태는 캐싱과 동기화를 위해 TanStack Query(React Query)로 분리합니다 [4, 14].
+*   **성능 엔지니어링 및 렌더링 최적화:** 초기의 거대한 JavaScript 번들 사이즈를 줄이기 위해 `React.lazy`와 Suspense를 활용한 라우트 및 컴포넌트 수준의 코드 스플리팅(Code Splitting)이 필수적입니다 [15-17]. 성능 병목을 일으키는 무의미한 리렌더링을 피하기 위해 `React.memo`, `useCallback`, `useMemo`를 적재적소에 사용하거나, React Compiler와 같은 빌드 타임 도구를 도입해 메모이제이션을 자동화합니다 [18-21]. 데이터가 방대한 목록의 경우 가상화(Virtualization/Windowing)를 도입하여 DOM 부하를 줄입니다 [22].
+*   **복원력(Resilience)과 모니터링:** 전체 애플리케이션의 렌더링 크래시를 방지하기 위해 불안정한 UI 영역(써드파티 위젯 등)을 Error Boundary로 감싸서 격리합니다 [23, 24]. 브라우저 메모리 탭의 Heap Snapshot을 통해 메모리 누수를 디버깅하고, 배포 이후에는 Sentry, LogRocket, Datadog과 같은 클라우드 관측(Observability) 도구를 사용해 프로덕션 환경의 사용자 에러 및 세션을 실시간 모니터링합니다 [25-27].
+*   **팀 협업 및 거버넌스 규칙:** 윈도우/리눅스 환경 차이로 인한 CI 빌드 에러를 막기 위해 파일명에 kebab-case를 강제하거나(컴포넌트 이름은 PascalCase 적용), ESLint 및 Git Hooks를 통해 아키텍처 규칙 및 코드 포맷을 자동 검증합니다 [28-30]. Git-flow, GitHub Flow 등 소규모/대규모 팀 규모에 맞는 명확한 브랜치 전략과 티켓 ID 기반 추적 관리를 함께 사용합니다 [31, 32].
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+
+- [[Feature-Sliced Design (FSD)]]
+  - 연결 이유: 확장 가능한 프론트엔드 아키텍처에서 빈번하게 발생하는 '비즈니스 로직 얽힘' 문제를 해결하기 위해 도입된 핵심적인 컴포넌트/디렉토리 분할 방법론입니다 [33, 34].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 단방향 의존성 흐름, 계층별(Layered) 분할, 캡슐화를 통한 Public API 인터페이스 설계 원리 [7, 9].
+
+- [[State Management Fragmentation (상태 관리 파편화)]]
+  - 연결 이유: 대규모 애플리케이션에서 단일 스토어나 Context API만으로는 리렌더링 성능 최적화가 불가능해짐에 따라, 전역 상태(Zustand), 서버 상태(React Query), 로컬 상태로 역할을 분리하여 관리하는 트렌드입니다 [4, 13, 35].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 불필요한 렌더링 방지 원리(Zustand의 선택자 패턴)와 서버/클라이언트 데이터 간의 캐싱 및 동기화 전략 [4, 14].
+
+- [[React Compiler]]
+  - 연결 이유: 개발자가 수동으로 수행하던 `useMemo`, `useCallback`, `React.memo` 등의 메모이제이션을 빌드 타임에 자동으로 처리해 주어, 깔끔한 코드를 유지하면서 성능 확장을 가능케 하는 최신 도구입니다 [19, 36].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: React의 렌더링 최적화 한계 및 Rules of React 준수 중요성, 써드파티 라이브러리와의 호환성 문제 [37, 38].
+
+- [[Error Boundaries]]
+  - 연결 이유: 시스템의 크기가 커질 때 단일 컴포넌트의 오류가 전체 앱의 '화이트 스크린' 크래시로 이어지지 않게 UI의 일부분만 대체(Fallback)하여 시스템 복원력(Resilience)을 보장하는 장치입니다 [23, 24, 39].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 클래스형 컴포넌트 생명주기를 활용한 런타임 에러 포착 원리 및 대규모 UI 보호 전략 [40, 41].
+
+- [[Code Splitting & Lazy Loading (코드 분할과 지연 로딩)]]
+  - 연결 이유: 프론트엔드 코드가 비대해지면서 초기 로딩 속도(TTI, LCP)를 최적화하기 위해 필수적으로 요구되는 기술로, Vite나 React.lazy를 통해 필요한 시점에만 모듈을 다운로드하게 합니다 [15, 17, 42].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 모듈 번들러의 청크(Chunk) 분리 원리 및 브라우저 성능 최적화(Core Web Vitals)와 번들 사이즈의 상관관계 [43, 44].
+
+### Deeper Research Questions
+
+- Feature-Sliced Design (FSD) 아키텍처를 도입할 때, 여러 기능(Feature)이 공유해야 하는 교차 관심사(Cross-cutting concerns)나 하위 기능 결합 문제를 어떻게 계층 분리와 캡슐화를 훼손하지 않고 해결할 수 있는가? [45, 46]
+- React Context API가 야기하는 불필요한 렌더 트리 리렌더링 문제를 Zustand나 Redux 같은 상태 관리 라이브러리의 선택자(Selector) 패턴 및 외부 스토어 구독 방식과 비교했을 때, 성능과 확장성 측면에서 구체적인 차이는 무엇인가? [14, 35, 47]
+- Vite 빌드 환경에서 번들 크기 경고("Large Chunks")를 해결하기 위해 `manualChunks`와 `React.lazy`를 결합하여 코드 스플리팅을 구현할 때, 초기 렌더링 성능 개선과 브라우저 캐싱 효율은 각각 어떻게 작용하는가? [42, 48, 49]
+- Next.js의 React Server Components (RSC)를 채택함으로써 서버에서 미리 렌더링하고 클라이언트 측 JavaScript 페이로드를 줄이는 접근법이, 거대한 프론트엔드 앱의 확장성에 어떤 아키텍처적 패러다임 전환을 가져오는가? [50, 51]
+- React Compiler의 자동 메모이제이션 로직이 서드파티 훅(예: 불안정한 참조를 반환하는 훅)과 레거시 코드베이스의 기술 부채 환경에서 어떤 최적화 실패를 발생시키며, 이를 방지하기 위한 리팩토링 전략은 무엇인가? [38, 52]
+
+### Practical Application Contexts
+
+- **Implementation:** 거대한 React 프로젝트를 리팩토링할 때 파일을 파일 속성 단위가 아닌 FSD와 같은 기능(Feature) 및 도메인 구조로 마이그레이션합니다. 상태가 자주 변경되는 기능에는 Zustand 스토어를 적용하고, 서버 API 요청에는 TanStack Query를 도입하여 로컬 상태와 서버 상태를 완벽히 분리 구현합니다 [2, 10, 53].
+- **System Design:** 컴포넌트 간의 순환 참조나 강한 결합(Coupling)을 막기 위해 캡슐화된 `index.ts` 형태의 Public API 설계 패턴을 적용합니다. 렌더링 부하를 막기 위해 데이터 리스트에는 가상화(Virtualization) 설계를 도입합니다 [11, 22].
+- **Operation / Maintenance:** 프로덕션 배포 후 어플리케이션 크래시를 방지하기 위해 Error Boundary를 위젯 및 중요 UI 섹션마다 감싸며, LogRocket 또는 Sentry를 도입해 에러 추적 및 메모리 릭(Memory Leaks) 상황을 실시간으로 디버깅하고 유지보수합니다 [23, 26, 27].
+- **Learning Path:** 소규모 장난감 프로젝트로 React의 기초를 다진 후, Context API의 한계를 파악하고 Zustand 등 상태 관리를 배웁니다. 이후 단위 테스트 작성, Typescript 전환, 그리고 클린 코드 원칙(SOLID, DRY) 기반의 아키텍처링(Feature-Sliced Design) 최적화로 나아가는 단계적 학습을 거칩니다 [54-57].
+- **My Project Relevance:** 소스에 관련 정보가 부족합니다.
+
+### Adjacent Topics
+
+- [[Frontend Cloud Logging Tools (프론트엔드 클라우드 로깅 도구)]]
+  - 확장 방향: 확장 가능한 시스템이 프로덕션 단계에 들어갔을 때, Sentry나 Datadog, SigNoz 같은 모니터링 툴을 활용해 사용자 세션과 에러 로그를 연동하여 가시성(Observability)을 확보하는 방향으로 확장할 수 있습니다 [58-60].
+- [[Storybook Visual Regression Testing (Storybook 시각적 회귀 테스트)]]
+  - 확장 방향: 대규모 팀에서 UI 컴포넌트를 변경할 때, 기존 화면(baseline)의 레이아웃이나 픽셀이 의도치 않게 깨지는 것을 방지하기 위한 자동화된 시각적 회귀 검증(Happo, Chromatic) 및 CI 파이프라인 연동 방향으로 확장할 수 있습니다 [61-63].
+- [[Git Branching Strategies & Workflows (Git 브랜치 전략 및 워크플로우)]]
+  - 확장 방향: 어플리케이션 확장뿐만 아니라 참여하는 개발자 수가 많아질 때, Trunk-based 개발이나 GitHub Flow 등을 도입하여 충돌을 줄이고 티켓 기반 추적성을 확보하는 형상관리 방향으로 확장할 수 있습니다 [31, 64].
+
+---
+*Last updated: 2026-04-30*
\ No newline at end of file
diff --git a/10_Wiki/Topics_GD/Storybook.md b/10_Wiki/Topics_GD/Storybook.md
new file mode 100644
index 00000000..6d872c98
--- /dev/null
+++ b/10_Wiki/Topics_GD/Storybook.md
@@ -0,0 +1,66 @@
+# [[Storybook]]
+
+## 📌 Brief 주Summary
+Storybook은 프론트엔드 개발 시 UI 컴포넌트를 주 애플리케이션과 격리하여 개발하고 문서화할 수 있도록 돕는 도구입니다 [1-3]. 특히 개발된 컴포넌트의 다양한 상태(스토리)를 기반으로 자동화된 시각적 회귀 테스트(Visual Regression Testing) 및 상호작용 테스트(Interaction Testing)를 수행하여 의도치 않은 UI 변경이나 접근성 위반을 방지합니다 [4-6]. Pull Request 과정에 결합되어 안전한 UI 업데이트와 리뷰를 지원하는 필수적인 플랫폼으로 활용됩니다 [1, 7].
+
+## 📖 Core Content
+* **컴포넌트의 격리된 개발 및 문서화**
+  Storybook은 개발자가 메인 애플리케이션의 복잡한 비즈니스 로직이나 컨텍스트에서 벗어나 UI 컴포넌트를 독립적으로 구축할 수 있게 해줍니다 [1]. 이는 모노레포(Monorepo) 환경이나 기능 기반 아키텍처(Feature-Sliced Design 등)에서 각 기능을 독립적으로 개발하고 테스트할 때 매우 유용합니다 [3]. 이미 컴포넌트를 문서화하고 개발하는 용도로 Storybook을 사용 중이라면, 이를 기반으로 시각적 회귀 테스트를 도입하는 것이 가장 빠른 UI 검증 방법입니다 [2].
+
+* **시각적 회귀 테스트 (Visual Regression Testing)**
+  Storybook의 핵심 기능 중 하나는 각 스토리의 스냅샷을 캡처하고 이를 이전에 승인된 '베이스라인(Baseline)'과 비교하여 시각적 변경 사항을 감지하는 것입니다 [8]. 전통적인 스냅샷 테스트가 HTML 마크업 블롭을 비교하여 시각적 변화가 없음에도 오탐(false positive)을 발생시키는 것과 달리, Storybook의 시각적 테스트는 사용자가 실제로 경험하는 '렌더링된 픽셀'을 직접 비교하므로 훨씬 더 풍부하고 유지보수하기 쉽습니다 [9].
+
+* **상호작용 및 접근성 테스트 (Interaction & Accessibility Tests)**
+  Storybook은 컴포넌트의 외형뿐만 아니라 동작(Behavior)까지 검증할 수 있습니다. 상호작용 테스트를 통해 로딩, 에러, 호버, 메뉴 열림 등 다양한 UI 상태를 시뮬레이션할 수 있으며 [5], 이러한 상태 변화에 맞춰 스크린샷을 찍음으로써 행동 테스트와 시각적 검증을 동일한 워크플로우 내에서 처리할 수 있습니다 [5, 6]. 부가적으로 추가적인 테스트 코드 작성 없이도 접근성 회귀 테스트를 함께 수행할 수 있습니다 [4, 10].
+
+* **CI/CD 및 도구 통합 (CI/CD Integrations)**
+  Storybook은 Chromatic이나 Happo 같은 클라우드 서비스 도구들과 원활하게 통합됩니다 [1, 4, 8]. 이러한 도구를 CI 파이프라인에 연동하면, PR(Pull Request)이 생성될 때마다 Chrome, Firefox, Safari 등 다양한 실제 브라우저와 여러 뷰포트 크기에서 자동으로 스크린샷이 캡처되고 베이스라인과 비교됩니다 [1, 4, 11]. 이를 통해 리뷰어는 각 상태를 수동으로 확인할 필요 없이 변경된 부분(Diff)에만 집중하여 변경 사항을 승인(Accept)하거나 수정할 수 있습니다 [2, 12, 13].
+
+## ⚖️ Trade-offs & Caveats
+* **테스트의 불안정성(Flakiness) 및 노이즈 문제:** 시각적 테스트는 애니메이션, 비동기 자산(Asset), 폰트 로딩 등으로 인해 깨지기 쉽거나 불안정해질 수 있습니다 [10, 11]. 또한 이미지 압축 노이즈나 안티앨리어싱(anti-aliasing)과 같은 미세한 차이로 인해 실패할 수도 있습니다 [10, 14]. 이를 완화하기 위해 Happo 등은 애니메이션을 자동으로 무효화하고 비동기 자산을 대기하며, 시각적 변경에 대한 색상 허용 오차(color-delta tolerance)를 설정해야 하는 제약과 설정 오버헤드가 따릅니다 [11, 14].
+* **추가적인 리뷰 병목 및 CI 설정 오버헤드:** 시각적 테스트가 유효하려면 변경된 스크린샷이 의도된 것인지(새로운 베이스라인으로 수락) 아니면 버그인지 판단하는 팀원의 수동 리뷰 과정이 반드시 수반되어야 합니다 [12, 13]. 또한 CI/CD에서 원활하게 동작하도록 프로젝트 토큰 등 인증 환경 변수를 구성하고 파이프라인을 설정하는 초기 작업이 요구됩니다 [7].
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+
+#### [테스트 및 검증 기법 (Testing Methods)]
+- [[Visual Regression Testing]]
+  - 연결 이유: Storybook이 컴포넌트의 변경 사항을 픽셀 단위로 확인하기 위해 사용하는 핵심 테스트 방법론입니다 [4, 8].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: HTML 마크업을 비교하는 Snapshot Test의 한계점과 오탐(False Positive)의 원리, 그리고 픽셀 렌더링 기반 비교의 장점을 명확히 이해할 수 있습니다 [9].
+
+- [[Interaction Testing]]
+  - 연결 이유: 컴포넌트의 단순한 렌더링뿐만 아니라 유저의 행동(이벤트, 상태 등)을 시뮬레이션하여 다양한 UI 상태(로딩, 호버 등)를 검증하는 Storybook의 기능입니다 [5, 6].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 상태 전이에 따라 동적으로 변하는 UI를 어떻게 시각적 테스트와 결합하여 검증할 수 있는지 원리를 파악할 수 있습니다 [5].
+
+#### [통합 및 자동화 도구 (Integration Tools)]
+- [[Chromatic]]
+  - 연결 이유: Storybook 유지보수 팀이 만든 공식 클라우드 서비스로, 크로스 브라우저 시각적 테스트와 CI 통합을 네이티브로 지원합니다 [8, 15].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 클라우드 환경에서 베이스라인(Baseline) 이미지가 어떻게 저장, 비교, 동기화되는지 CI/CD 파이프라인 통합 과정을 이해할 수 있습니다 [7, 13].
+
+- [[Happo]]
+  - 연결 이유: Storybook과 통합되어 다중 브라우저 스크린샷 테스트 및 접근성 회귀 테스트를 병렬로 수행하는 시각적 테스트 도구입니다 [4].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: Flakiness 방지를 위해 애니메이션을 정지하거나 색상 오차 범위(color-delta tolerance)를 설정하여 시각적 노이즈를 줄이는 구체적 최적화 기법을 알 수 있습니다 [11, 14].
+
+### Deeper Research Questions
+- Storybook의 Visual Test와 전통적인 HTML Snapshot Test를 비교했을 때, 실제 대규모 프로젝트에서 발생하는 유지보수 오버헤드와 오탐(false positive) 비율의 차이는 어떠한가?
+- 애니메이션, 비동기 폰트 로딩 등으로 인해 발생하는 Visual Test의 Flakiness를 완전히 제어하기 위해 Chromatic이나 Happo는 어떤 렌더링 파이프라인 제어 기술을 사용하는가?
+- Storybook의 Interaction Test로 복잡한 사용자 여정(User Journey)을 시뮬레이션할 때, 상태별 스크린샷 캡처가 CI 빌드 시간에 미치는 영향과 이를 병렬화하여 최적화하는 전략은 무엇인가?
+- 모노레포(Monorepo) 환경이나 Feature-Sliced Design 아키텍처에서 수백 개의 기능 모듈이 각각 분리된 Storybook을 가질 때, 이를 통합적으로 빌드하고 시각적 회귀를 모니터링하는 베스트 프랙티스는 무엇인가?
+- Storybook을 사용한 시각적 접근성 테스트(Accessibility regression testing)가 실제 DOM 기반의 접근성 감사 도구(aXe 등)와 비교하여 갖는 한계점과 보완점은 무엇인가?
+
+### Practical Application Contexts
+- **Implementation:** React 등 UI 프레임워크 기반 프로젝트에서 복잡한 컴포넌트를 앱의 비즈니스 로직과 분리하여 `Button`, `Modal` 등의 요소를 독립적으로 렌더링하고, 호버 및 에러 상태의 Story를 작성합니다.
+- **System Design:** Feature-Sliced Design처럼 도메인과 피처가 뚜렷하게 나뉜 아키텍처를 도입할 때, 각 피처 폴더별로 Storybook 환경을 세팅하여 격리된 개발 및 테스트 구조를 설계합니다.
+- **Operation / Maintenance:** CI/CD 워크플로우에 Chromatic 또는 Happo를 연동하여, 팀원이 PR을 올릴 때마다 자동으로 시각적 변경 사항(Visual Diff)이 캡처되고 이를 리뷰어가 직접 확인 후 병합(Merge)하는 운영 프로세스를 구축합니다.
+- **Learning Path:** 기본 UI 컴포넌트 격리 개발 -> Story 작성을 통한 문서화 -> Interaction Test 작성 -> 자동화된 Visual Regression Test 구축으로 이어지는 프론트엔드 품질 보증 학습 경로에 사용됩니다.
+- **My Project Relevance:** 현재 유지보수 중인 애플리케이션의 리팩토링이나 새로운 디자인 시스템(UI 라이브러리) 구축 작업 시, 실수로 발생하는 CSS/레이아웃 깨짐을 사전에 방지하기 위한 안전장치로 도입할 수 있습니다.
+
+### Adjacent Topics
+- [[Pull Request Workflow]]
+  - 확장 방향: Storybook 시각적 테스트의 결과를 GitHub, GitLab 등의 리뷰 프로세스와 결합하여, 버그 없는 UI 코드를 배포하기 위한 협업 및 검증 파이프라인 구축 전략으로 확장합니다.
+- [[Feature-Sliced Design]]
+  - 확장 방향: 프론트엔드 코드를 기능(Feature) 단위로 분리할 때, Storybook을 이용해 각 기능의 UI 컴포넌트들을 메인 앱에 의존하지 않고 독립적으로 작동하게 만드는 설계 원칙으로 확장합니다.
+
+---
+*Last updated: 2026-04-30*
\ No newline at end of file
diff --git a/10_Wiki/Topics_GD/대규모 프론트엔드 애플리케이션.md b/10_Wiki/Topics_GD/대규모 프론트엔드 애플리케이션.md
new file mode 100644
index 00000000..b3e02b9e
--- /dev/null
+++ b/10_Wiki/Topics_GD/대규모 프론트엔드 애플리케이션.md	
@@ -0,0 +1,64 @@
+# [[대규모 프론트엔드 애플리케이션]]
+
+## 📌 Brief Summary
+대규모 프론트엔드 애플리케이션은 단순한 스크립트 실행을 넘어 확장성, 유지보수성, 고성능을 요구하는 고도로 정교한 분산 소프트웨어 시스템입니다. 비즈니스 로직과 UI의 분리, 명확한 상태 소유권, 엄격한 폴더 구조(Feature-Sliced Design 등)를 통해 아키텍처의 붕괴를 방지합니다. 또한, 코드 스플리팅, 자동 메모이제이션, 세분화된 상태 관리 도구를 활용하여 최적의 렌더링 성능과 사용자 경험을 유지하는 것이 핵심입니다.
+
+## 📖 Core Content
+
+*   **아키텍처 및 폴더 구조 (Architecture & Folder Structure)**
+    *   과거의 파일 타입 기반(MVC 등) 폴더 구조는 규모가 커질수록 로직이 파편화되는 한계가 있습니다. 대규모 앱에서는 비즈니스 기능별로 코드를 구성하는 **기능 기반(Feature-based)** 또는 **FSD(Feature-Sliced Design)** 아키텍처가 표준으로 자리 잡았습니다 [1-13].
+    *   FSD는 앱을 공유(shared), 엔티티(entities), 기능(features), 위젯(widgets), 페이지(pages), 앱(app) 등의 계층으로 나누고, **단방향 의존성 규칙**(하위 계층만 참조 가능)과 **Public API 규칙**(index.ts를 통한 캡슐화)을 강제하여 결합도를 낮춥니다 [6, 9, 10, 14, 15].
+*   **상태 관리의 파편화 (Fragmentation of Global State)**
+    *   거대한 단일 스토어(Monolithic Redux) 대신, 데이터 유형에 따라 최적의 도구를 선택합니다. 로컬 상태는 `useState`, 전역 애플리케이션 상태는 `Zustand`나 `Jotai`, 서버(API) 상태는 `TanStack Query`를 사용하여 캐싱 및 동기화를 처리합니다 [16-24].
+    *   특히 Context API는 값이 변할 때마다 모든 구독 컴포넌트를 리렌더링하는 '브로드캐스트' 방식이므로 정적 데이터(테마 등)에 적합하며, 자주 변경되는 동적 상태는 선택자(Selector) 패턴으로 불필요한 리렌더링을 방지하는 Zustand 등이 유리합니다 [16, 17, 25-28].
+*   **성능 최적화 (Performance Optimization)**
+    *   **빌드/런타임 최적화:** Vite와 Rollup을 활용하여 자주 변경되지 않는 벤더 라이브러리(React 등)를 `manualChunks`로 분리하여 캐시 효율을 높이고, `React.lazy`와 `Suspense`를 통해 라우트 또는 컴포넌트 단위의 코드 스플리팅을 구현합니다 [29-37].
+    *   **렌더링 성능:** React 19/2025 생태계에서는 수동 메모이제이션(React.memo, useMemo)의 한계를 극복하기 위해 **React Compiler**를 도입하여 빌드 타임에 자동으로 렌더링 최적화를 수행합니다. 대량의 리스트 데이터는 가상화(Virtualization) 기술을 통해 DOM 비대화를 막습니다 [30-32, 38-44].
+*   **복원력 및 디버깅 (Resilience & Debugging)**
+    *   런타임 에러로 인한 '백지 화면(White screen of death)'을 방지하기 위해 **에러 바운더리(Error Boundaries)**를 대시보드나 서드파티 위젯 등 불안정한 UI 섹션에 전략적으로 배치하여 Fallback UI를 제공합니다 [45-53].
+    *   메모리 누수(Detached DOM nodes 등)는 성능 저하의 주원인이므로 Chrome DevTools의 Heap Snapshot 및 Allocation Timeline을 통해 추적하며, 프로덕션 환경에서는 Sentry, LogRocket, Datadog 등의 가시성(Observability) 도구로 모니터링합니다 [54-63].
+*   **클린 코드 및 거버넌스 (Clean Code & Governance)**
+    *   React의 함수형 컴포넌트에도 SOLID 원칙(단일 책임 원칙, 개방-폐쇄 원칙 등), DRY, KISS, YAGNI 원칙이 적용됩니다. 컴포넌트는 단일 책임을 가져야 하며 과도한 추상화는 지양해야 합니다 [64-69].
+    *   운영체제 간 호환성 및 빌드 오류 방지를 위해 파일 및 폴더명은 `kebab-case`, 컴포넌트는 `PascalCase` 사용을 표준화하며, ESLint, Prettier, Husky를 통해 CI/CD 파이프라인에서 아키텍처 경계와 코드 품질을 자동 강제합니다 [70-73].
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+- [[Feature-Sliced Design (FSD)]]
+  - 연결 이유: 대규모 프론트엔드 프로젝트의 폴더 구조와 모듈 의존성을 통제하는 핵심 아키텍처 방법론입니다.
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 비즈니스 도메인과 UI를 어떻게 계층적으로 분리하고, 순환 참조 및 강한 결합을 어떻게 방지할 수 있는지 이해할 수 있습니다.
+- [[상태 관리 (State Management)]]
+  - 연결 이유: 대규모 앱에서는 전역 상태, 서버 상태, 로컬 상태를 명확히 분리해야 확장 및 성능 유지가 가능합니다.
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: Context API의 성능적 한계(리렌더링 폭풍)와 Zustand의 Selector 패턴, TanStack Query를 통한 서버 상태 캐싱 원리를 이해할 수 있습니다.
+- [[성능 최적화 (Performance Optimization)]]
+  - 연결 이유: 대규모 코드베이스는 필연적으로 번들 크기 증가와 렌더링 병목을 초래하므로 이를 제어하는 기술이 필수적입니다.
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: React Compiler의 자동화된 메모이제이션 원리, Vite의 manualChunks를 통한 번들 분할, React.lazy 기반의 코드 스플리팅 적용 방식을 파악할 수 있습니다.
+- [[에러 바운더리 (Error Boundaries)]]
+  - 연결 이유: 컴포넌트 하나의 오류가 전체 앱의 크래시로 이어지지 않게 막아주는 대규모 시스템의 필수 안전망입니다.
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 컴포넌트 트리 내에서 에러를 격리하는 원리와 런타임 에러를 우아하게 처리(Graceful degradation)하는 방법을 배울 수 있습니다.
+- [[메모리 누수 (Memory Leaks)]]
+  - 연결 이유: 앱 사용 시간이 길어질수록 성능을 심각하게 저하시키는 숨은 원인입니다.
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 클로저(Closure)나 Detached DOM에 의해 가비지 컬렉터가 메모리를 회수하지 못하는 구조적 원인과 DevTools를 활용한 디버깅 기법을 이해할 수 있습니다.
+
+### Deeper Research Questions
+- FSD(Feature-Sliced Design) 도입 시 '인증(Auth)'이나 '라우팅'과 같은 Cross-cutting concern(공통 관심사)은 계층(Layer) 구조의 어느 부분에 배치하고 어떻게 관리하는 것이 가장 적합한가?
+- React Compiler가 자동 메모이제이션을 수행할 때, 서드파티 라이브러리(예: 불안정한 객체 참조를 반환하는 커스텀 훅)와의 호환성 충돌 문제를 해결하기 위한 구체적 방안은 무엇인가?
+- 대규모 리스트 데이터를 렌더링할 때 Virtualization(윈도윙) 기술이 DOM 노드 증가를 막는 원리는 무엇이며, 이 과정에서 `key` 프롭(prop)이 성능에 미치는 정확한 영향은 무엇인가?
+- 프로덕션 환경의 프론트엔드 모니터링(Sentry, Datadog 등)이 제공하는 세션 리플레이(Session Replay) 기능이 개발자의 디버깅에 어떻게 기여하며, 이때 발생할 수 있는 민감 데이터 유출 및 번들 사이즈 증가라는 트레이드오프는 어떻게 극복하는가?
+- Zustand, Jotai와 같은 최신 상태 관리 라이브러리가 기존의 Redux나 Context API와 비교하여 동적/실시간 렌더링 최적화(예: 리렌더링 스킵)를 내부적으로 어떻게 구현하고 있는가?
+
+### Practical Application Contexts
+- **Implementation:** 파일과 폴더 네이밍 규칙(파일: kebab-case, 컴포넌트: PascalCase)을 통일하고, 300줄이 넘어가는 컴포넌트는 단일 책임 원칙(SRP)에 따라 더 작은 훅(Hook)과 서브 컴포넌트로 리팩토링합니다.
+- **System Design:** 프로젝트 설계 시 폴더 구조를 기술 스택(components, hooks) 기반이 아닌 비즈니스 도메인(features/auth, features/dashboard 등) 기반으로 구성하여 각 모듈의 캡슐화를 보장합니다.
+- **Operation / Maintenance:** 개별 서드파티 위젯이나 불안정한 UI 파트에 Error Boundary를 씌워 메인 서비스의 동작을 보장하며, Memory Profiler를 사용해 Detached DOM node 등 메모리 누수 요인을 정기적으로 감사(Audit)합니다.
+- **Learning Path:** 리액트 핵심 원리(렌더링 트리거 이해) → 폴더 구조/아키텍처(FSD) 설계 → 상태 관리 도구 비교 및 도입 → 웹 성능 지표(Core Web Vitals) 및 번들러(Vite) 최적화 도구 체득의 순서로 학습을 고도화합니다.
+- **My Project Relevance:** 팀 단위의 협업 시 ESLint, Prettier, Husky를 도입해 아키텍처 규칙(다른 Feature에 직접 접근 금지 등)을 자동 강제하고, 코드 리뷰 시 일관된 아키텍처 원칙을 기준으로 삼을 수 있습니다.
+
+### Adjacent Topics
+- [[마이크로 프론트엔드 (Micro-Frontends)]]
+  - 확장 방향: 단일 저장소(Monorepo) 및 모듈화의 한계를 넘어, 초대형 엔터프라이즈 환경에서 여러 팀이 프론트엔드를 독립적으로 배포하고 운영하기 위한 런타임 통합 아키텍처로 지식을 확장합니다.
+- [[시각적 회귀 테스트 (Visual Regression Testing)]]
+  - 확장 방향: Storybook을 활용한 컴포넌트 고립 개발을 넘어서, Happo, Chromatic 등의 도구를 통해 코드 변경이 UI나 접근성(Accessibility)에 의도치 않은 파괴적 영향을 미쳤는지 자동 검증하는 QA 고도화 영역으로 확장합니다.
+
+---
+*Last updated: 2026-04-30*
\ No newline at end of file
diff --git a/10_Wiki/Topics_GD/프론트엔드 애플리케이션 렌더링 병목 개선.md b/10_Wiki/Topics_GD/프론트엔드 애플리케이션 렌더링 병목 개선.md
new file mode 100644
index 00000000..600727cc
--- /dev/null
+++ b/10_Wiki/Topics_GD/프론트엔드 애플리케이션 렌더링 병목 개선.md	
@@ -0,0 +1,70 @@
+# [[프론트엔드 애플리케이션 렌더링 병목 개선]]
+
+## 📌 Brief Summary
+프론트엔드 애플리케이션 렌더링 병목은 불필요하거나 과도한 컴포넌트 리렌더링으로 인해 UI 반응성이 떨어지고 상호작용 속도가 지연되는 현상을 의미합니다 [1, 2]. 이를 개선하기 위해서는 렌더링 트리거(상태, Props, Context 등)를 식별하고 메모이제이션, 리스트 가상화, 상태 분리, 동시성 렌더링(Concurrent Rendering) 기능 등을 활용해야 합니다 [3, 4]. 지속적인 프로파일링을 통해 렌더링 비용이 높은 부분을 측정하고 전략적으로 최적화를 적용하는 것이 핵심입니다 [5, 6].
+
+## 📖 Core Content
+* **렌더링 발생 원인 파악 및 프로파일링**
+  React 컴포넌트는 상태(State), Props, Context의 값이 변경되거나 부모 컴포넌트가 렌더링될 때 리렌더링됩니다 [4]. 이러한 불필요한 렌더링은 애플리케이션 트리가 깊을 경우 스크립팅 시간을 30~60% 증가시켜 성능을 저하시킬 수 있습니다 [2]. 따라서 React DevTools Profiler나 `why-did-you-render` 같은 도구를 사용해 렌더링 빈도와 비용을 측정한 뒤 최적화를 진행해야 합니다 [5, 7, 8].
+* **메모이제이션(Memoization)과 참조 안정성**
+  `React.memo()`, `useCallback`, `useMemo`를 적절히 활용하면 변경되지 않은 컴포넌트의 리렌더링을 막을 수 있습니다 [9, 10]. 단, JSX 내부에 익명 함수나 인라인 객체를 직접 정의하여 Props로 넘기면 얕은 비교(Shallow comparison) 특성상 매 렌더링마다 새로운 참조가 생성되어 메모이제이션이 무력화되므로 참조를 안정화해야 합니다 [10-12]. 
+* **React Compiler를 통한 자동화**
+  2025년 기준 React Compiler는 빌드 타임에 컴포넌트를 정적으로 분석하여 JSX 요소 단위까지 세밀하게 자동 메모이제이션을 적용합니다 [13, 14]. 이를 통해 수동 메모이제이션의 번거로움을 줄이고 렌더링 오버헤드를 방지할 수 있습니다 [15].
+* **Context API 최적화와 글로벌 상태 분리**
+  Context API는 값이 변할 때 해당 컨텍스트를 구독하는 모든 컴포넌트를 렌더링하는 "브로드캐스트 시스템"으로 작동하여 큰 병목을 유발합니다 [16, 17]. 이를 방지하기 위해 컨텍스트를 작은 도메인 단위로 쪼개거나, Zustand 등 특정 상태 슬라이스(Slice)만 선택적으로 구독(Selector)할 수 있는 가벼운 상태 관리 라이브러리를 사용하여 리렌더링을 제어해야 합니다 [16, 18-20].
+* **동시성 기능(Concurrent Features)의 활용**
+  `useTransition`을 사용해 중요하지 않은 업데이트를 지연시킴으로써 타이핑과 같은 즉각적인 상호작용이 차단되지 않게 하고, `useDeferredValue`로 무거운 파생 데이터의 렌더링을 미루어 UI의 반응성을 부드럽게 개선할 수 있습니다 [21-23].
+* **대규모 데이터 가상화(Virtualization) 및 리스트 최적화**
+  50~100개 이상의 항목이 있는 긴 목록은 다수의 DOM 노드 렌더링을 유발하여 병목을 만듭니다 [24, 25]. `react-window` 등의 라이브러리를 활용해 뷰포트에 보이는 항목만 렌더링하는 윈도윙(Windowing) 기법을 적용하고, 안정적이고 고유한 `key`를 부여하여 불필요한 DOM 재생성을 막아야 합니다 [25-27].
+
+## ⚖️ Trade-offs & Caveats
+* **메모이제이션 오버헤드:** `React.memo()`, `useCallback`, `useMemo`는 남용될 경우 성능을 오히려 악화시킬 수 있습니다 [28, 29]. 이전 Props와 새 Props를 비교하고 메모리를 할당하는 과정에 오버헤드가 발생하기 때문에, 렌더링 비용이 저렴한 컴포넌트에서는 렌더링 자체보다 비교 연산의 비용이 더 클 수 있습니다 [29].
+* **React Compiler의 제약 사항:** React Compiler는 자동 최적화를 제공하지만, 'Rules of React'를 엄격히 준수해야 정상 작동합니다 [30, 31]. 또한 매 렌더링마다 새로운 참조를 반환하는 일부 서드파티 라이브러리 훅(예: TanStack Query의 `useMutation` 등)과 함께 사용하면 메모이제이션 체인이 끊어지는 호환성 문제가 발생할 수 있습니다 [32, 33].
+* **Context API vs 외부 라이브러리 도입:** Context API는 서드파티 라이브러리 추가 없이 테마, 다국어 등 정적 데이터 관리에 용이하지만 [34], 잦은 상태 변경에는 성능 취약점이 있습니다 [35]. 그러나 이를 해결하기 위해 외부 상태 라이브러리(Zustand 등)를 무조건 도입하면 추가적인 번들 용량 증가 및 팀의 학습 곡선이 수반된다는 반대 급부가 있습니다 [36, 37].
+* **익명 함수 제거에 따른 코드 복잡도 증가:** 불필요한 리렌더링을 막고자 모든 인라인 함수를 외부로 빼거나 `useCallback`으로 감싸면 코드가 길어지고 가독성이 떨어질 수 있습니다 [38]. 컴포넌트가 작고 성능 영향이 없는 경우에는 익명 함수 사용이 실용적일 수 있습니다 [38].
+
+## 🔗 Knowledge Connections
+
+### Related Concepts
+
+#### [아키텍처/기반 기술]
+- [[Context API]]
+  - 연결 이유: 컴포넌트 트리 깊은 곳까지 상태를 전달할 수 있으나 구독 중인 모든 컴포넌트를 리렌더링시키는 특성상 렌더링 병목의 주요 원인이 됩니다 [17].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 브로드캐스트 기반 상태 관리의 한계와 리렌더링 발생 범위를 이해할 수 있습니다.
+- [[Concurrent Rendering]]
+  - 연결 이유: 렌더링 작업의 우선순위를 부여하고 중단/재개할 수 있는 기술로, `useTransition` 등을 통해 무거운 렌더링이 메인 스레드를 막는 병목 현상을 방지합니다 [21].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 반응성 지표(INP 등)를 개선하기 위한 렌더링 스케줄링 메커니즘을 이해할 수 있습니다.
+- [[React Compiler]]
+  - 연결 이유: 수동 메모이제이션의 한계를 극복하고 빌드 타임에 자동으로 JSX 요소 단위의 메모이제이션을 적용하여 렌더링 최적화를 달성합니다 [13, 14].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 최신 React의 렌더링 최적화가 런타임 제어에서 컴파일러 기반 정적 분석으로 넘어가는 기술적 진화를 이해할 수 있습니다.
+
+#### [구현/활용 도구]
+- [[Zustand]]
+  - 연결 이유: 셀렉터(Selector) 기능을 활용해 컴포넌트가 자신이 필요한 상태 조각(Slice)이 변경될 때만 리렌더링되도록 보장하여 병목을 줄이는 상태 관리 도구입니다 [18].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 전역 상태의 파편화 관리와 불필요한 리렌더링을 차단하는 구독 최적화 패턴을 학습할 수 있습니다.
+- [[List Virtualization (Windowing)]]
+  - 연결 이유: 대규모 리스트에서 사용자의 화면 뷰포트에 존재하는 DOM 노드만 제한적으로 렌더링하여 DOM 트리 비대화를 막습니다 [25, 26].
+  - 이 개념을 통해 더 깊게 이해할 수 있는 부분: 다수의 데이터를 렌더링할 때 발생하는 메모리 및 레이아웃 페인팅 병목을 제어하는 원리를 이해할 수 있습니다.
+
+### Deeper Research Questions
+- React Compiler는 빌드 타임에 명시적인 의존성 배열 없이 어떻게 내부 JSX 노드별 캐싱 및 메모이제이션 단위를 결정하는가?
+- Context API의 브로드캐스트 리렌더링 문제를 해결하는 `use-context-selector`의 원리는 무엇이며, Zustand의 구독 최적화 방식과 구조적으로 어떻게 다른가?
+- `useTransition`과 `useDeferredValue`를 결합하여 사용할 때, 브라우저의 페인트 주기(Paint Cycle) 관점에서 컴포넌트 렌더링은 어떻게 스케줄링 및 지연되는가?
+- 대형 데이터를 처리할 때 List Virtualization과 함께 사용하는 스크롤 이벤트 디바운싱(Debouncing) 혹은 쓰로틀링(Throttling) 최적화의 기술적 한계점은 무엇인가?
+- 상태 관리 아키텍처 관점에서, Feature-Sliced Design(FSD)과 같이 횡단 관심사를 분리하는 폴더 및 구조적 설계가 애플리케이션의 리렌더링 범위를 제한하는 데 어떻게 기여하는가?
+
+### Practical Application Contexts
+- **Implementation:** Props로 전달하는 함수나 객체는 익명 생성(인라인)을 지양하고 `useCallback`이나 외부 선언으로 분리하여 참조 무결성을 유지합니다. 수백 개 이상의 항목을 렌더링할 경우 `react-window`와 같은 가상화 라이브러리를 의무적으로 도입합니다.
+- **System Design:** 빈번히 업데이트되는 상태(예: 알림 개수, 장바구니)는 Context API 대신 Zustand 등의 선택적 구독이 가능한 스토어에 배치하고, 정적 데이터(테마 등)는 Context를 활용하여 렌더링 전파 범위를 시스템 레벨에서 격리합니다.
+- **Operation / Maintenance:** `why-did-you-render` 패키지와 React DevTools의 Profiler 패널을 이용해 개발 과정에서 불필요하게 반복 렌더링되는 컴포넌트를 찾아내고, 프로덕션 환경에서는 Core Web Vitals(INP, FCP 등)를 추적하여 상호작용 지연이 있는지 모니터링합니다.
+- **Learning Path:** React의 렌더링 조건(State, Props, Parent) 이해 -> 수동 메모이제이션 도구 숙달 -> Context API의 성능 한계 체감 및 Zustand 활용 -> Concurrent Features 적용 -> React Compiler를 이용한 자동화 흐름으로 렌더링 최적화 지식을 확장합니다.
+- **My Project Relevance:** 현재 유지 보수하거나 신규 구축하는 React 웹 앱에서 스크롤 끊김이나 클릭 시 반응 지연이 발생할 때, 해당 개념을 기반으로 병목이 되는 컴포넌트의 렌더링 횟수를 측정하고 적절한 최적화 도구를 즉각 적용할 수 있습니다.
+
+### Adjacent Topics
+- [[Server Components (Next.js)]]
+  - 확장 방향: 브라우저에서의 렌더링 부하를 줄이기 위해 클라이언트 자바스크립트 번들을 최소화하고 서버에서 정적 UI를 렌더링하여 넘겨주는 아키텍처적 최적화에 대해 심도 있게 조사할 수 있습니다 [39-41].
+- [[JavaScript Memory Leaks]]
+  - 확장 방향: 과도한 렌더링 외에도 클로저나 분리된 DOM 노드에 의해 자바스크립트 메모리가 해제되지 않고 누적되어 성능 저하를 일으키는 메모리 누수 식별 및 해결 방법으로 이해를 확장합니다 [42-44].
+
+---
+*Last updated: 2026-04-30*
\ No newline at end of file