기초부터 실전 Q&A까지 순서형 로드맵
토픽별로 탐색하고 최신 글을 바로 확인
Spring, Database, Kafka, DevOps 등으로 정리
백엔드 커리큘럼 심화: Graceful Degradation …
🚀 백엔드 커리큘럼
1단계: 백엔드 기초 다지기 (언어/알고리즘/CS)
언어, 자료구조/알고리즘, 운영체제·네트워크 기본을 다지는 모듈
2단계: 스프링 핵심 공략 (Core/Boot/JPA/테스트)
스프링 코어, 부트 자동설정, JPA, 테스트 전략을 집중적으로 다지는 모듈
3단계: 데이터베이스 & 데이터 시스템
인덱스/트랜잭션/락/캐시/메시징으로 데이터 시스템의 성능·정합성·확장성을 다지는 모듈
4단계: 분산 시스템 & 아키텍처 (Distributed Systems)
분산 트랜잭션, 일관성 모델, 샤딩, 이벤트 드리븐 아키텍처를 다루는 모듈
5단계: 시스템 안정성 & 회복탄력성 (Resilience)
장애 전파 차단, 트래픽 제어, 고가용성 설계를 다루는 모듈
6단계: 클라우드 네이티브 & DevOps
Docker, K8s, CI/CD, 모니터링, 트레이싱까지 운영 스택을 갖추는 모듈
7단계: 복습(Q&A)
학습하며 남긴 Q&A를 한 번에 모아 복습하는 단계
8단계: 보안 (Security Specialist)
기능 구현을 넘어, 안전한 서비스를 만들기 위한 필수 보안 지식과 공격 방어 기법을 다룹니다.
9단계: 컴퓨터 공학 심화 (Deep CS)
분산 시스템의 정합성 모델, DB 스토리지 엔진의 원리 등 시니어 레벨로 가기 위한 이론적 깊이를 다룹니다.
10단계: 현대적 백엔드 기술 (Modern Frontiers)
AI 시대의 백엔드(Vector Search), 차세대 웹 프로토콜(HTTP/3), 그리고 Serverless/MicroVM 등 최신 기술의 '내부 원리'를 다룹니다.
11단계: 아키텍처 마스터리 (Architecture Mastery)
대규모 분산 시스템에서 발생하는 데이터 정합성 문제와 무한 확장을 위한 샤딩, 그리고 복잡한 도메인을 다루는 DDD까지 아키텍트 레벨의 난제를 다룹니다.
보조 트랙: 백엔드 면접 실전 (Interview Readiness)
개념을 아는 것에서 끝나지 않고, 면접에서 짧고 정확하게 말하는 훈련 트랙
부록: 실습실 (Hands-on Labs)
이론으로 배운 내용을 가볍게 구현해보는 연습 문제 모음 (Optional)
🗺️ 학습 가이드
개발하면서 배우고 공부한 내용들을 주제별로 정리합니다. 백엔드 학습은 기초 → 스프링 → 데이터/설계 → 운영/모니터링 → 심화/시스템 설계 → 복습(Q&A) 모듈로 나누어 지속적으로 업데이트하며, 커리큘럼·주제 카드·최신 노트가 자동으로 정렬됩니다. 학습 순서는 타임라인 페이지에서 study_order 기준으로 확인할 수 있습니다.
- 학습 타임라인:
/learning/timeline/에서study_order순서대로 확인합니다. - 커리큘럼 카드: Backend Roadmap 토픽 글이 자동으로 순서대로 표시됩니다.
- 주제 카드: Spring/Database/Kafka/DevOps 등 토픽별 최신 글을 한 번에 확인합니다.
- 최근 학습 노트: 최신순 정렬, 더보기/토픽별 필터 지원.
학습 방법
- 개념 → 실험 → 기록: 읽고 끝내지 말고, 작은 코드/재현으로 확인한 뒤 내 말로 정리합니다.
- 선택 기준 만들기: “언제 A, 언제 B”를 한 줄이라도 남기면 실전에서 재사용됩니다.
- 복습(Q&A): 막힌 포인트를 질문/답 형태로 쌓아두면 다시 꺼내보기 쉬워집니다.
📂 학습 주제
AI Agent Operations
학습 노트 모음
Algorithm
학습 노트 모음
API
URL, Header, Query 기반 버전 관리와 Breaking Change 전략
API Design
학습 노트 모음
Architecture
학습 노트 모음
Backend
학습 노트 모음
Backend Architecture
학습 노트 모음
Backend Deep Dive
학습 노트 모음
Backend Integration
학습 노트 모음
Backend Operations
학습 노트 모음
Backend Reliability
학습 노트 모음
Backend Roadmap
학습 노트 모음
Build
학습 노트 모음
Caching
학습 노트 모음
Cloud
S3 개념, Presigned URL, 대용량 업로드, 비용 최적화
Code Quality
네이밍, 함수 설계, 주석, 리팩토링 원칙
CS
학습 노트 모음
Data Architecture
학습 노트 모음
Data Consistency
학습 노트 모음
Data Engineering
학습 노트 모음
Data Platform
학습 노트 모음
Database
학습 노트 모음
Database Internals
학습 노트 모음
Database Reliability
학습 노트 모음
Design Patterns
학습 노트 모음
DevOps
학습 노트 모음
Distributed
Kafka, RabbitMQ, Redis Pub/Sub 비교와 선택 기준
Distributed Coordination
학습 노트 모음
Distributed Systems
학습 노트 모음
Frontend
React 성능 최적화, Virtual DOM, memo, useCallback 관련 핵심 개념과 실전 예제 정리
Git
학습 노트 모음
Java
학습 노트 모음
JPA
Lazy/Eager 로딩, Batch Size, QueryDSL, Hibernate 통계
JVM
학습 노트 모음
Kafka
학습 노트 모음
Messaging
학습 노트 모음
Modern Tech
학습 노트 모음
Network
학습 노트 모음
Networking
학습 노트 모음
Observability
학습 노트 모음
OOP
학습 노트 모음
Ops
학습 노트 모음
OS
학습 노트 모음
Performance
학습 노트 모음
Practical Project
학습 노트 모음
Q&A
학습 노트 모음
React
React 라이브러리 학습 노트
Reactive
Reactive Programming, Publisher/Subscriber, Backpressure 관련 핵심 개념과 실전 예제 정리
Redis
학습 노트 모음
Resilience
학습 노트 모음
Security
학습 노트 모음
Spring
ApplicationEvent, @EventListener, 비동기 이벤트, 트랜잭션 바인딩
Spring Data JPA
학습 노트 모음
System Design
학습 노트 모음
Testing
테스트 피라미드, Mock vs Stub, 통합 테스트 격리 전략
Testing Strategy
학습 노트 모음
● 최근 학습 노트
백엔드 커리큘럼 심화: Graceful Degradation 플레이북 (Fallback·Read Only·Brownout)
장애를 0으로 만들 수 없다면 서비스가 어떤 순서로 덜 망가질지 먼저 설계해야 합니다. fallback, read only, brownout, load shedding …
백엔드 커리큘럼 심화: eBPF 기반 프로덕션 디버깅 플레이북 (CPU·락·네트워크 병목을 커널 레벨에서 추적하기)
APM과 로그만으로 원인이 안 잡히는 CPU 스파이크, 락 경합, 네트워크 지연을 eBPF로 어떻게 좁혀 가야 하는지 실무 기준과 숫자 중심으로 정리합니다.
백엔드 커리큘럼 심화: Service Discovery와 Health-Aware Routing 실무 설계
인스턴스가 자주 바뀌는 환경에서 DNS, registry, client-side/server-side discovery, active/passive health check …
백엔드 커리큘럼 심화: Execution Receipt 운영 플레이북 (Approval·Lease·Evidence·Replay Guard)
에이전트가 외부 전송, 파일 수정, 운영 액션을 수행할 때 execution receipt를 어떤 순서로 설계하고 어떤 숫자로 운영해야 하는지 실무 플레이북 형태로 정리합니다.
백엔드 커리큘럼 심화: Hot Partition과 Partition Key Skew 실무 플레이북
샤딩은 했는데 특정 키와 특정 테넌트만 계속 뜨거워지는 상황에서, skew를 어떻게 탐지하고 어떤 기준으로 salting, resharding, 캐시, 비동기화를 선택할지 실무 숫 …
백엔드 커리큘럼 심화: Hedged Requests와 Request Racing 실무 플레이북
평균 응답시간이 아니라 p95, p99 지연을 깎아야 하는 구간에서 hedged request를 언제 쓰고 언제 피해야 하는지, 비용과 성공 조건을 숫자로 정리합니다.
백엔드 커리큘럼 심화: Snapshot Isolation, Serializable, Write Skew 실무 판단 플레이북
트랜잭션 격리 수준을 이론으로만 외우지 않고, write skew가 실제로 언제 터지는지, Snapshot Isolation과 Serializable을 어떤 기준으로 고를지 운영 …
백엔드 커리큘럼 심화: Advisory Lock 실무 플레이북, DB 락으로 어디까지 해결하고 언제 다른 조율 방식으로 넘어갈까
중복 실행 방지, 단일 작업자 선출, 배치 겹침 차단 같은 문제를 Advisory Lock으로 해결할 때의 설계 기준과 한계를 숫자 중심으로 정리합니다.
백엔드 커리큘럼 심화: Webhook Delivery Reliability 플레이북 (Signature·Retry·Idempotency·DLQ)
외부 시스템으로 webhook를 보내는 백엔드에서 중복 전송, 유실, 서명 검증 실패, 재시도 폭주를 줄이기 위한 실무 기준을 숫자와 우선순위 중심으로 정리합니다.
백엔드 커리큘럼 심화: Materialized View + Incremental Refresh 운영 플레이북
리드 모델과 집계성 조회를 안정적으로 운영하기 위해 Materialized View를 증분 새로고침 중심으로 설계하는 기준을 정리합니다.
백엔드 커리큘럼 심화: 데이터 레지던시(주권) 요구를 만족하는 리전 분리 아키텍처 플레이북
국가·산업별 데이터 주권 요구를 만족하면서도 제품 속도와 운영 복잡도를 통제하기 위한 리전 분리 아키텍처 설계 기준을 실무 관점으로 정리합니다.
백엔드 커리큘럼 심화: Queue Visibility Timeout·Ack/Nack·DLQ 재처리 설계 플레이북
메시지 큐 기반 비동기 처리에서 중복 실행, 유실, 무한 재시도를 줄이기 위해 Visibility Timeout, Ack/Nack, DLQ를 숫자 기준으로 설계하는 실무 플레이북입 …
백엔드 커리큘럼 심화: 분산 스케줄러 Singleton 실행 보장 플레이북 (Lease·Fencing·Idempotency)
멀티 인스턴스 환경에서 배치/크론 작업이 중복 실행되는 사고를 줄이기 위해 Lease·Fencing·Idempotency를 함께 설계하는 실무 기준을 숫자와 우선순위 중심으로 정리 …
백엔드 커리큘럼 심화: HTTP 캐싱·ETag·재검증(Revalidation) 운영 플레이북
캐시 적중률 숫자만 보는 단계를 넘어, Cache-Control/ETag/재검증 정책을 서비스 위험도와 데이터 신선도 기준으로 설계하는 실무 플레이북입니다.
백엔드 커리큘럼 심화: DB 장애조치(Failover) 운영 플레이북 — RTO/RPO, Fencing, Connection Draining
DB 장애조치를 사람이 감으로 처리하지 않도록, 트리거 조건·우선순위·롤백 기준을 숫자로 정의하는 실무형 플레이북입니다.
백엔드 커리큘럼 심화: 종단간 Deadline Budget과 Cancellation Propagation 운영 플레이북
클라이언트가 이미 포기한 요청을 백엔드가 계속 처리하는 낭비를 줄이기 위해, 홉별 deadline 배분과 취소 전파를 숫자 기준으로 설계하는 방법을 정리합니다.
백엔드 커리큘럼 심화: 워터마크와 지연 도착 이벤트를 전제로 한 스트림 처리 운영 플레이북
실시간 집계가 배치 결과와 다르게 나오는 문제를 줄이기 위해, 워터마크·허용 지연·재처리 규칙을 숫자 기준으로 설계하는 방법을 정리합니다.
백엔드 커리큘럼 심화: Clock Skew를 전제로 시간 의미론을 설계하는 실무 플레이북
분산 시스템에서 시계 오차를 예외가 아니라 기본 조건으로 보고, 시간 기반 로직을 안전하게 설계·운영하는 기준을 정리합니다.
백엔드 커리큘럼 심화: DB 메이저 버전 무중단 업그레이드 플레이북(호환성·회귀·롤백 기준)
DB 메이저 버전 업그레이드를 단순 점검이 아니라 운영 가능한 전환 절차로 다룹니다. 호환성 확인, 쿼리 플랜 회귀 감지, 트래픽 승격/롤백 기준까지 숫자 중심으로 정리합니다.
백엔드 커리큘럼 심화: Bounded Staleness와 Read-Your-Writes 보장 설계 플레이북
읽기 복제 구조에서 사용자 체감 일관성을 지키기 위해 Bounded Staleness, Read-Your-Writes, 라우팅 정책을 숫자 기준으로 설계하는 실무 플레이북입니다.
백엔드 커리큘럼 심화: 캐시 일관성 설계(Write-Through/Invalidate/CDC)로 stale read 사고 줄이기
캐시 적중률보다 더 어려운 캐시 일관성 문제를 실무 기준으로 정리합니다. stale read 허용 범위, 무효화 지연 임계치, 재처리 규칙까지 숫자로 설명합니다.
백엔드 커리큘럼 심화: Query Plan Regression Guardrail 실무 플레이북
배포 후 갑자기 느려지는 SQL 실행계획 회귀를 예방하고, 30분 내 완화할 수 있도록 Plan Baseline·통계 관리·카나리 검증·런북 기준을 실무 숫자로 정리합니다.
백엔드 커리큘럼 심화: Cell-Based Architecture로 Blast Radius를 통제하는 실무 플레이북
단일 대형 플랫폼을 작은 셀(cell) 단위로 나눠 장애 전파를 줄이고 복구 속도를 높이기 위한 설계·운영 기준을 숫자 기반으로 정리합니다.
백엔드 커리큘럼 심화: 멀티테넌트 공정성 스케줄링(WFQ/DRR)으로 노이즈 네이버를 제어하는 방법
멀티테넌트 환경에서 특정 고객 트래픽이 전체 서비스를 흔들지 않도록, WFQ/DRR 기반 공정성 제어와 운영 임계치를 실무 관점으로 정리합니다.
백엔드 커리큘럼 심화: Priority Load Shedding과 Bulkhead로 혼잡 상황을 통제하는 법
트래픽 급증 시 모든 요청을 동일하게 처리하려는 접근을 버리고, 우선순위 기반 차단과 격리(Bulkhead)로 시스템 붕괴를 막는 실무 기준을 정리합니다.
백엔드 커리큘럼 심화: 멀티테넌트 격리 전략 플레이북
공유 스키마부터 전용 클러스터까지 멀티테넌트 격리 모델의 선택 기준과 마이그레이션 순서를 실무 숫자 기준으로 정리합니다.
백엔드 커리큘럼 심화: Tail Latency 엔지니어링 플레이북
평균이 아닌 P95/P99를 기준으로 시스템을 설계하고 운영하기 위해, 타임아웃 버짓 분배부터 큐 규율·헤지드 요청·관측 지표까지 실무 기준으로 정리합니다.
백엔드 커리큘럼 심화: Connection Storm·Thundering Herd를 막는 용량 보호 플레이북
트래픽 급증·재시작·장애 복구 시 발생하는 Connection Storm과 Thundering Herd를 예방하고 완화하는 실무 설계 기준을 정리합니다.
백엔드 커리큘럼 심화: 이벤트 스키마 레지스트리와 호환성 운영 플레이북
이벤트 스키마 변경으로 장애를 만들지 않기 위해, 호환성 모드 선택부터 배포 순서·검증 기준·운영 지표까지 실무형으로 정리합니다.
백엔드 커리큘럼 심화: 샤딩 키 설계와 리샤딩 운영 플레이북
샤딩 키를 어떻게 고르고, 언제 리샤딩을 결정하며, 운영 중단 없이 이전하는지 실무 기준으로 정리합니다.
백엔드 커리큘럼 심화: Reconciliation 파이프라인으로 금액·포인트 데이터 불일치 줄이기
주문·결제·포인트 시스템에서 발생하는 데이터 불일치를 탐지하고 복구하는 Reconciliation 아키텍처를 실무 기준으로 정리합니다.
백엔드 커리큘럼 심화: Usage Metering·Quota·청구 정합성을 한 번에 설계하는 방법
사용량 계량, 실시간 쿼터 차단, 월말 청구 정산을 분리·연결해서 운영하는 실무 아키텍처와 의사결정 기준을 정리합니다.
워크플로 오케스트레이션 실전: Temporal로 장기 실행 트랜잭션 운영하기
결제·배송·정산처럼 길고 복잡한 비즈니스 플로우를 Temporal로 안정적으로 운영하는 기준을 실무 관점에서 정리합니다.
백엔드 커리큘럼 심화: 데이터 보존·삭제 아키텍처 (Soft Delete, Archive, Purge)
백엔드 서비스에서 데이터 보존 기간, 논리 삭제, 물리 삭제, 아카이브를 어떻게 분리 설계해야 운영 안정성과 규제 대응을 동시에 잡을 수 있는지 실무 기준으로 정리합니다.
DB 락 경합 실전 플레이북: 대기열을 줄이고 쓰기 성능을 지키는 기준
DB 락 경합을 측정하고 완화하는 실무 기준: 대기 시간, 충돌 패턴, 트랜잭션 설계, 운영 체크리스트
멀티리전 Active-Active 백엔드 설계: 지연·가용성·정합성의 현실적인 균형
멀티리전 Active-Active를 도입할 때 팀이 실제로 부딪히는 정합성, 라우팅, 장애복구 이슈를 수치 기준과 함께 정리합니다.
백엔드 용량 계획 심화: 리틀의 법칙, 포화지점, 운영 임계치로 계산하는 서버 증설 타이밍
리틀의 법칙과 동시성 한계를 기반으로 백엔드 포화지점을 계산하고, 증설·최적화·부하차단의 의사결정 기준을 수치로 정리합니다.
배치 파이프라인 실전 설계: 멱등성·재처리·운영 지표로 완성하는 안정적인 데이터 처리
배치 파이프라인에서 자주 깨지는 지점(중복 처리, 부분 실패, 재처리)을 멱등 키·체크포인트·운영 지표로 다루는 실무 의사결정 기준
인가 모델 실전 설계: RBAC·ABAC·ReBAC와 정책 엔진 운영 기준
백엔드 인가를 RBAC/ABAC/ReBAC 관점에서 비교하고, 정책 엔진 도입 기준·성능 예산·운영 체크리스트까지 실무 의사결정 중심으로 정리합니다.
백엔드 요청 병합(Request Coalescing) 실전: Singleflight로 캐시 스탬피드 줄이기
동일 키 동시 요청이 몰릴 때 요청 병합으로 DB 부하와 P95 지연을 줄이는 설계/운영 기준을 정리합니다.
Consumer-Driven Contract Testing: 통합 테스트 병목을 줄이는 API 계약 검증 전략
마이크로서비스 환경에서 느리고 깨지기 쉬운 통합 테스트를 줄이기 위해 Consumer-Driven Contract Testing을 설계·운영하는 실무 기준
트랜잭션 아웃박스 + CDC: 이중 쓰기 없이 이벤트 일관성 확보하기
주문/결제 같은 핵심 도메인에서 이중 쓰기 문제를 피하기 위한 트랜잭션 아웃박스 + CDC 패턴의 실무 설계 기준
운영 중 스키마 변경 실전: Online DDL + Expand/Contract 패턴
서비스를 멈추지 않고 DB 스키마를 변경할 때 필요한 실무 기준, 트레이드오프, 흔한 실수와 점검 루틴을 정리합니다.
PostgreSQL Autovacuum 튜닝: 느려진 쿼리와 Bloat를 동시에 잡는 법
PostgreSQL에서 autovacuum이 밀릴 때 생기는 실무 장애 패턴, 튜닝 기준, 트레이드오프와 체크리스트를 정리합니다.
Timeout/Retry/Backoff 설계: 장애 전파를 막는 3종 세트
타임아웃/재시도/백오프를 잘못 설정했을 때 발생하는 장애 전파를 막는 실무 기준과 Spring 예제
Spring Security OAuth2 + JWT 실전 구현
Authorization Code 흐름과 JWT 발급/검증을 Spring Security 구성으로 연결하고, 실무에서 흔한 함정까지 정리
SLO/SLI/Error Budget: 운영 의사결정을 숫자로 만드는 법
서비스의 안정성을 감(感)으로 판단하지 않도록, SLO/SLI/Error Budget을 설정하고 운영에 적용하는 실무 가이드
Redis Cache Stampede 방지 실전: 락, 조기만료, 이중 캐시
TTL 만료 폭발을 막는 락/조기만료/이중 캐시 전략과 Spring Boot 통합, 모니터링, 실전 트러블슈팅까지
JVM GC 내부 구조: TLAB, 카드 테이블, 배리어까지
객체 할당 경로(TLAB)와 Remembered Set, Card Table, Write/Read Barrier까지 GC 내부 흐름을 구조적으로 이해
DB 복제 & 읽기/쓰기 분리: Replication, Lag, Failover 실전
복제 구조의 원리(Primary/Replica), 복제 지연(Lag) 대응, 읽기/쓰기 분리 라우팅과 장애 전환 기준
마이크로서비스 패턴: 분해, 통신, 데이터 관리
모놀리식에서 MSA로 전환할 때 알아야 할 분해 전략, 서비스 간 통신, 데이터 일관성 패턴
OSI 7계층과 TCP/IP 이해
백엔드 개발자가 알아야 할 실무 관점의 네트워크 계층 구조 (L4 vs L7 로드밸런서 차이점 포함)
OAuth 2.0 & 소셜 로그인: Google/Kakao 로그인 직접 구현하기
OAuth 2.0 승인 코드 방식(Authorization Code Grant)의 흐름과 Spring Security OAuth2 Client 설정법
JWT vs Session: 토큰 기반 인증의 허와 실
세션과 토큰(JWT)의 장단점 비교, Access/Refresh Token 전략, 그리고 보안 취약점(XSS, CSRF) 방어
Java 기초: Primitive, Wrapper, String Constant Pool
원시 타입과 래퍼 클래스의 메모리 차이, 오토박싱의 함정, 그리고 String Pool의 동작 원리까지
IntelliJ IDEA 필수 단축키 및 디버깅 활용
개발 생산성을 2배로 올려주는 IntelliJ 단축키와 디버깅 기능 정복하기
HTTP Essentials: 요청/응답 구조와 메서드, 상태 코드
HTTP 메시지 구조부터 GET/POST 차이, 2xx~5xx 상태 코드의 정확한 의미까지, 백엔드 개발자의 필수 상식
Docker Compose & Network: 컨테이너끼리 대화하는 법
여러 컨테이너를 관리하는 Docker Compose의 원리와 Docker Network(Bridge, Host, Overlay) 모드 완전 정복
DNS와 웹의 동작 원리: 주소창에 google.com을 쳤을 때
주소창 입력부터 렌더링까지 전체 흐름과 DNS 구조(Recursor, Root, TLD, Authoritative) 완벽 정리
CI/CD with GitHub Actions: 배포 자동화의 시작
GitHub Actions의 Workflow 구조부터 Matrix 전략, 보안 하드닝, Docker 빌드, 배포 파이프라인, 비용 최적화까지 — 운영 수준의 CI/CD 설계
AWS 배포 실전: EC2와 RDS로 나만의 서버 띄우기
VPC 설계부터 EC2·RDS 구성, IaC(Terraform), CI/CD 자동 배포, 보안 하드닝, 모니터링까지 — 프로덕션 수준 AWS 배포 완전 가이드
피처 플래그: 안전한 기능 릴리스
피처 플래그로 안전한 기능 릴리스와 A/B 테스트를 구현하는 운영 전략
페이지네이션과 정렬: 대용량 데이터 처리
Offset vs Cursor 페이지네이션 비교, 대용량 데이터 정렬과 Spring Data 적용
테스트 전략: 단위 테스트부터 E2E까지
단위/통합/E2E 테스트의 역할 구분과 효과적인 테스트 피라미드 전략
클린 코드: 읽기 좋은 코드 작성법
네이밍, 함수 설계, 주석 원칙, 리팩토링 기법 등 읽기 좋은 코드의 핵심 원칙
육각형 아키텍처 (Hexagonal): 도메인을 프레임워크로부터 격리하라
스프링조차도 도메인 로직에 침범하지 못하게 하라. Ports & Adapters 패턴의 구현.
오브젝트 스토리지: S3와 파일 관리
AWS S3 기반 오브젝트 스토리지 구조, Presigned URL, 멀티파트 업로드 실무
예외 처리 패턴: 비즈니스 예외 설계
비즈니스 예외와 시스템 예외를 구분하고 일관된 에러 응답을 설계하는 패턴
실전 프로젝트 1: URL Shortener (단축 URL 서비스)
시스템 설계 인터뷰의 단골 문제, URL 단축 서비스를 직접 설계하고 구현하며 인덱스와 캐시를 이해합니다.
시스템 설계 답변 프레임 Q&A (가정 분리 → 측정 → 대응 우선순위)
시스템 설계 면접 답변 프레임워크: 가정 분리, 측정, 대응 우선순위 Q&A
스토리지 엔진 내부: B-Tree vs LSM-Tree
DB 성능의 핵심인 스토리지 엔진. MySQL의 B-Tree와 Cassandra/RocksDB의 LSM-Tree 구조를 비교하고 장단점을 파헤칩니다.
설정 관리: 외부 설정과 시크릿 관리
Spring Cloud Config, Vault 등을 활용한 외부 설정과 시크릿 관리 전략
분산 트랜잭션: 2PC에서 SAGA까지
마이크로서비스 환경에서 데이터 정합성을 어떻게 보장할까요? 강한 일관성(2PC)의 한계와 결과적 일관성(SAGA) 패턴의 구현 방법을 다룹니다.
백엔드 면접 답변 프레임 Q&A (1분 구조)
백엔드 면접 1분 답변 구조, 트레이드오프 정리 프레임워크 Q&A
멱등성: 안전한 재시도를 위한 API 설계
멱등키 설계, 재시도 안전한 API 구현, 분산 환경에서의 중복 방지 전략
메시지 큐 비교: Kafka vs RabbitMQ vs Redis
Kafka, RabbitMQ, Redis Streams의 아키텍처 차이와 선택 기준
마이크로서비스 패턴: 분산 시스템의 설계 원칙
마이크로서비스 아키텍처의 핵심 설계 패턴과 실무 적용 기준 정리
데이터 정합성 모델: Strong부터 Eventual까지
분산 시스템에서 '최신 데이터'를 본다는 것의 의미와 비용. Linearizability, Sequential, Eventual Consistency의 차이를 명확히 구분합니다.
데이터 샤딩과 Consistent Hashing
DB 데이터를 여러 서버에 나누는 샤딩 전략과, 서버 증설 시 데이터 이동을 최소화하는 Consistent Hashing 알고리즘 설명.
구조화 로깅: 검색 가능한 로그 설계
JSON 기반 구조화 로깅 설계, MDC 활용, ELK/Loki에서 검색 가능한 로그 전략
WebSocket과 실시간 통신
WebSocket 프로토콜 동작 원리, STOMP 기반 실시간 통신과 Spring 적용
WebFlux vs MVC 면접 Q&A (선택 기준/운영 포인트)
WebFlux와 Spring MVC 선택 기준, 운영 포인트 면접 Q&A
Vector DB 내부: HNSW 인덱스와 RAG 백엔드
AI 서비스의 필수 인프라인 Vector Search. ANN 알고리즘(HNSW, IVF, PQ) 원리, 파라미터 튜닝, RAG 파이프라인 설계, 그리고 운영 체크리스트까지.
TLS Handshake 1.3: HTTPS는 어떻게 연결될까?
HTTPS 연결이 성립되는 과정을 Wireshark 패킷 관점에서 봅니다. TLS 1.2와 1.3의 차이, Cipher Suite 선택, 인증서 체인 검증, 0-RTT의 위험, 그 …
Thread Pool 튜닝: 적정 스레드 수 찾기
ThreadPoolExecutor 파라미터 튜닝, 적정 스레드 수 공식, 모니터링 전략
TCP 성능 최적화: 혼잡 제어부터 TCP Fast Open까지
TCP 3-way Handshake의 비용, Sliding Window의 원리, 그리고 최신 TCP 성능 튜닝 기법.
Spring WebFlux와 Reactive Programming: 비동기의 미학
MVC의 한계를 넘어서는 Event-Loop 기반 아키텍처와 Backpressure 메커니즘.
Spring Validation: 입력 검증 완벽 가이드
Bean Validation과 커스텀 검증 로직으로 입력 검증을 구현하는 완벽 가이드
Spring Security 아키텍처와 필터 체인 동작 원리
DelegatingFilterProxy부터 SecurityFilterChain까지, 스프링 시큐리티의 내부 동작을 해부한다.
Spring Events: 느슨한 결합의 이벤트 기반 아키텍처
ApplicationEvent와 @EventListener로 구현하는 이벤트 기반 아키텍처
Serverless 내부: Cold Start와 Firecracker MicroVM
서버리스는 정말 서버가 없을까? AWS Lambda가 수천 개의 함수를 격리하는 기술인 Firecracker와, 1초의 지연(Cold Start) …
OpenTelemetry: 통합 관측 표준
OpenTelemetry의 Trace/Metric/Log 통합 관측 표준과 Spring Boot 적용 가이드
OAuth 2.0와 OIDC: 소셜 로그인 내부 동작 원리
Authorization Code Grant Flow부터 PKCE, BFF 패턴, 토큰 저장 전략, 멀티 프로바이더 설정까지 — 인증 프로세스의 모든 것.
Linux I/O 모델 심화: BIO, NIO부터 Epoll, Zero Copy까지
Blocking vs Non-blocking, Synchronous vs Asynchronous의 정확한 구분과 고성능 서버(Nginx, Node.js, Kafka)의 기반 기술 …
Kafka 전달 보장 면접 Q&A (At-most/At-least/Exactly-once)
Kafka At-most/At-least/Exactly-once 전달 보장과 중복 처리 면접 Q&A
JPA 성능 최적화: Fetch 전략과 배치 처리
JPA N+1 해결, Fetch 전략, 배치 처리 등 성능 최적화 실전 기법
JPA 성능 면접 Q&A (N+1, fetch join, OSIV)
JPA N+1 문제, fetch join, OSIV 등 성능 관련 면접 Q&A
Java 개발자를 위한 Kotlin: NPE 종말과 코루틴 혁명
Lombok 없이도 간결한 코드를 작성하고, 스레드 지옥에서 벗어나 코루틴의 세계로. Scope Functions, Sealed Class, Spring Boot 통합까지.
Java Concurrent Collections: 스레드 안전 컬렉션 완벽 가이드
ConcurrentHashMap 등 Java 동시성 컬렉션의 내부 구조와 사용 시나리오 가이드
HTTPS와 SSL/TLS Handshake: 암호화 통신의 정석
RSA와 AES의 조화, 그리고 TLS 1.3 핸드셰이크 과정을 시각적으로 이해한다.
HTTP/3 & QUIC: TCP를 버리고 UDP로 간 이유
웹의 속도를 제한하던 TCP의 구조적 한계(Head-of-Line Blocking)와 이를 UDP 기반의 QUIC으로 해결한 HTTP/3의 혁신을 다룹니다.
GraphQL 심화: 스키마 설계와 성능 최적화
GraphQL 스키마 설계, DataLoader로 N+1 해결, 성능 최적화와 보안 고려사항
Graceful Shutdown: 안전한 애플리케이션 종료
Spring Boot Graceful Shutdown 설정과 컨테이너 환경 종료 시나리오
DNS 내부: 주소창에 google.com을 치면?
재귀적 질의, 레코드 타입, 캐싱 전략, DNSSEC/DoH 보안, 컨테이너 DNS, GSLB, 실전 트러블슈팅까지 DNS 내부를 완전히 파헤칩니다.
DDD 전술적 설계: Entity, VO, 그리고 Aggregate
도메인 주도 설계의 핵심 빌딩 블록을 이해하고, 왜 불변 객체(VO)가 중요한지 파헤칩니다.
DDD 심화: Aggregate Root와 트랜잭션 경계
도메인 주도 설계(DDD)에서 가장 어려운 Aggregate 개념. 트랜잭션의 범위를 정의하고 데이터 무결성을 지키는 원칙을 다룹니다.
DB 병목 대응 순서 Q&A (측정 → 쿼리/인덱스 → 캐시 → 비동기화 → 스케일)
DB 병목 측정부터 쿼리/인덱스 최적화, 캐시, 비동기화, 스케일까지 대응 순서 Q&A
CQRS: 명령과 조회의 분리
CQRS 패턴의 개념, 읽기/쓰기 모델 분리, Event Sourcing과의 조합 가이드
CAP 이론과 PACELC: 분산 시스템 트레이드오프
CAP 이론과 PACELC 확장을 설계 의사결정 기준으로 이해하고, 주요 분산 시스템의 트레이드오프를 분류
API 버전 관리: 하위 호환성을 지키는 방법
URI/Header/Content Negotiation 방식의 API 버전 관리와 하위 호환성 전략
부록: 실습실 (Hands-on Labs)
이론으로 배운 내용을 가볍게 구현해보는 연습 문제 모음 (Optional)
보조 트랙: 백엔드 면접 실전 (Interview Readiness)
개념을 아는 것에서 끝나지 않고, 면접에서 짧고 정확하게 말하는 훈련 트랙
11단계: 아키텍처 마스터리 (Architecture Mastery)
대규모 분산 시스템에서 발생하는 데이터 정합성 문제와 무한 확장을 위한 샤딩, 그리고 복잡한 도메인을 다루는 DDD까지 아키텍트 레벨의 난제를 다룹니다.
10단계: 현대적 백엔드 기술 (Modern Frontiers)
AI 시대의 백엔드(Vector Search), 차세대 웹 프로토콜(HTTP/3), 그리고 Serverless/MicroVM 등 최신 기술의 '내부 원리'를 다룹니다.
9단계: 컴퓨터 공학 심화 (Deep CS)
분산 시스템의 정합성 모델, DB 스토리지 엔진의 원리 등 시니어 레벨로 가기 위한 이론적 깊이를 다룹니다.
8단계: 보안 (Security Specialist)
기능 구현을 넘어, 안전한 서비스를 만들기 위한 필수 보안 지식과 공격 방어 기법을 다룹니다.
트래픽 컷오버 & 데이터 마이그레이션 전략
점진적 트래픽 전환, 데이터 동기화, 롤백 전략을 설계하는 방법 — Spring Boot 코드, 비교 검증, 실행 런북 포함
타임존·국제화 처리 베스트 프랙티스
UTC 저장/표시 변환, Locale별 메시지/포맷, 스케줄·마감 처리 시 주의점
클라우드 비용 최적화 전략
FinOps 프레임워크, Compute/DB/Network/Storage 영역별 최적화, Kubernetes 비용 관리, Spot/RI 전략, …
클라우드 네트워크 기초: VPC/Subnet/보안그룹
VPC, 서브넷, 라우팅, 보안그룹/네트워크 ACL 개념과 설계 포인트
자료구조 복잡도 한눈에 보기
주요 자료구조의 삽입/삭제/탐색 시간복잡도와 사용 시 주의점 정리
인덱스 기본: B-Tree 구조와 쿼리 성능
인덱스가 왜 빨라지는지(B-Tree/선택도/커버링), 복합 인덱스 설계와 쿼리 튜닝의 기본 감각
웹 보안 기본: CORS/CSRF와 헤더 보안
SOP/CORS 동작 원리, CSRF 공격 시나리오와 4가지 방어 전략, 보안 헤더(HSTS/CSP/Permissions-Policy) 실전 적용 가이드
운영체제 기초: 프로세스·스레드·스케줄링
프로세스/스레드 차이, 컨텍스트 스위칭, 스케줄링 알고리즘, 동기화 기본
알람 전략: 에러율/레이턴시/자원지표 설계
알람 설계 원칙, PromQL 규칙, Alertmanager 라우팅, SLO 번레이트, Runbook 템플릿까지 실무 가이드
실행 모델 기초: 동기/비동기, 블로킹/논블로킹
동기/비동기 vs 블로킹/논블로킹을 명확히 구분하고, 스레드풀·이벤트 루프·MVC/WebFlux 선택 기준까지 연결
실시간 통신: WebSocket vs SSE vs Webhook
실시간/준실시간 요구에 따라 WebSocket, SSE, Webhook을 선택하는 기준과 설계 패턴 — Spring Boot 구현 코드, 스케일 아웃 전략, 운영 체크리스트 포함
시스템 설계: 파일 업로드와 서빙 (S3+CDN)
Presigned URL, 멀티파트 업로드, CDN 캐싱 전략으로 파일을 안전하게 업로드/서빙하는 방법
시스템 설계: 뉴스피드
Fan-out on write/read, 캐시/타임라인 테이블 설계, 지연/일관성 트레이드오프 정리
시스템 설계: URL Shortener
Key 생성, 충돌 방지, 캐시/DB 설계, 확장성·가용성 고려사항 정리
빌드 기본: Gradle/Maven 의존성과 멀티모듈 감각
의존성 해석/버전 충돌, 빌드·테스트 파이프라인, 멀티모듈 분리의 기준을 잡는 글
비밀 관리: Vault/Secrets Manager와 Spring 연동
애플리케이션 비밀을 분리·주입·회전하는 설계 — Vault/AWS SM 비교, Spring 연동 코드, 회전 자동화, 유출 대응, 운영 체크리스트까지
부하 테스트 전략과 성능 튜닝 체크리스트
부하 시나리오 설계, 목표 지표(SLI/SLO), 병목 파악과 튜닝 루틴
백엔드 학습 커리큘럼 한눈에 보기
모듈형 커리큘럼 구조, 학습 루틴, 자료 모음을 한 번에 정리한 학습 개요
백업·DR(Disaster Recovery) 전략
RPO/RTO 정의, 백업/복구, DR 리전 설계와 주기적 복구 테스트 가이드
배포 런북: 안전한 배포와 롤백
배포 전/중/후 판단 기준과 실전 명령어, K8s 매니페스트, ArgoCD Rollout, DB 마이그레이션 SQL까지 — 바로 복사해서 쓰는 런북
모듈 아키텍처: 패키지/레이어/멀티모듈 설계
Layered vs Modular, 패키지 의존성 최소화, 멀티모듈 분리 전략과 의존성 검증까지
모놀리스를 모듈러/서비스로 나누기
모놀리스 코드베이스를 단계적으로 모듈러/서비스로 분리하는 전략 — 판별 기준, 실무 코드, 데이터 분리, Strangler 구현, 운영 체크리스트까지
멀티테넌시 설계 전략
스키마/데이터베이스 분리, 테넌트 격리/보안, 마이그레이션·운영 고려사항과 실전 구현
리눅스/CLI 기본: 장애를 빠르게 좁히는 디버깅 루틴
프로세스/리소스/로그/네트워크를 ps/top/journalctl/ss/curl/dig로 확인하며 장애 범위를 좁히는 방법
로드밸런서/헬스체크: 고가용성의 심장
ALB/NLB 선택 기준, 헬스체크 실패 시 트래픽 흐름, 타임아웃/리트라이로 인한 장애 전파 차단
레거시 리팩터링 전략
대규모 레거시 개선을 위한 우선순위, 단계별 접근, 위험 관리
도메인 모델링: 엔티티, 값 객체, 애그리게이트
도메인 모델링 기본 개념과 애그리게이트 경계를 잡는 방법
네트워크 기초: TCP 핸드셰이크와 HTTP/2
TCP 3-way, 흐름/혼잡 제어, HTTP/2 멀티플렉싱·HPACK·헤더 압축 핵심
관측성 베이스라인: 로그·메트릭·트레이스
로그/메트릭/트레이스 3대 기둥과 Spring Boot 기반 기본 설정 가이드
WebFlux vs MVC 선택 가이드
Spring MVC와 WebFlux를 실행 모델·병목 유형·운영 난이도로 비교하고, 안전한 전환 전략과 실전 체크리스트를 정리합니다.
WebClient 회복탄력성: 타임아웃·재시도·백프레셔
WebClient로 외부 API 호출 시 타임아웃/재시도/서킷 브레이커/백프레셔 설정 가이드
TDD 입문: JUnit 5 + Mockito로 테스트 드라이빙
레드-그린-리팩터 사이클, 단위/슬라이스 테스트 작성과 Mock 활용 패턴
SQL 기본: 조인/집계/인덱스가 먹는 조건 감각
SQL 실행 순서와 조인/집계 성능 함정, 인덱스가 타는 조건을 감각으로 잡는 기본기
Spring 프로필과 설정 분리 전략
dev/stage/prod 설정 분리, @ConfigurationProperties, Secret 관리, Kubernetes 환경변수 주입, Vault 연동, …
Spring 통합 테스트와 Testcontainers
MySQL/Redis/Kafka를 Testcontainers로 올려 실제 환경과 유사한 통합 테스트를 구성하는 방법
Spring Validation과 공통 응답 규약
Bean Validation 적용, 공통 응답/에러 코드 규약, 필드 에러 처리 패턴 정리
Spring Transaction: @Transactional 동작 원리와 실전 함정
전파/격리/롤백 규칙과 프록시 동작, self-invocation/checked exception 같은 실무 함정을 한 번에 정리
Spring Security: 필터 체인의 미학
어렵게만 느껴지는 Security의 내부 작동 원리(DelegatingFilterProxy, FilterChain)와 커스텀 필터
Spring Security OAuth2 Authorization Code 흐름
Authorization Server 없이 외부 프로바이더(Google 등) 연동하는 OAuth2 로그인 흐름 정리
Spring Security + JWT 인증 흐름
JWT 기반 인증 필터, 토큰 발급/검증, Stateless 세션 구성을 코드로 정리
Spring MVC 요청 처리 흐름: Filter → DispatcherServlet → Interceptor → Controller
요청이 들어와서 응답이 나가기까지: Filter/DispatcherServlet/Interceptor/예외 처리 흐름과 디버깅 포인트
Spring Cache Abstraction 활용하기
@Cacheable/@CachePut/@CacheEvict 사용법과 Redis/Caffeine 연동 패턴
Spring Boot 자동 설정 해부
자동 설정 동작 원리, 조건부 빈 등록, 커스터마이징 포인트 정리
Spring Batch와 스케줄링 기초
대량 배치 처리와 스케줄링 설계, Spring Batch/Quartz/스케줄러 기본부터 운영 안정성까지
Spring AOP와 트랜잭션 내부 동작
프록시 기반 AOP, @Transactional 적용 시점, self-invocation 주의사항 정리
Spring AOP (Part 2: Proxy 동작 원리, 실무)
Spring AOP의 동작(프록시)과 포인트컷/어드바이스를 이해하고, self-invocation 같은 실전 함정을 피하는 방법
Spring AOP (Part 1: 개념과 기초)
Spring AOP의 동작(프록시)과 포인트컷/어드바이스를 이해하고, self-invocation 같은 실전 함정을 피하는 방법
REST API 에러 핸들링 모범 사례
표준 에러 응답 포맷, 글로벌 예외 처리, 검증 에러 응답 설계
Redis 캐싱: 패턴/무효화/운영 함정까지
Cache-Aside/Write-through/Write-behind 선택, 무효화/스탬피드/핫키 같은 실전 문제와 운영 지표까지 정리
Redis 캐시 패턴 모음
Cache-Aside, Write-Through, Write-Behind, 분산락 패턴을 코드 예시와 함께 정리
Redis Streams로 이벤트 스트림 처리하기
Redis Streams 기본 개념부터 Consumer Group/PEL, 멱등 처리와 재처리(복구)까지: 작은 이벤트 파이프라인 설계
Redis Streams 심화: Backlog 관리와 재처리 전략
Pending 리스트 관리, 장애 시 재처리, 대량 backlog를 제어하는 Streams 운영 패턴 — Spring Boot + Lettuce 실무 코드 포함
Rate Limiter: 트래픽 홍수에서 살아남기
DDoS 방어부터 유료 API 사용량 제한까지. Token Bucket 알고리즘과 Redis 분산 처리
QueryDSL 입문: 타입세이프 쿼리와 페이징
기본 문법, 동적 where, 페이징/정렬 패턴을 예제로 정리
Q&A 모음: 운영/보안 20제
CI/CD, 모니터링/알람, 네트워크, CORS/CSRF/OWASP 등 운영/보안 관련 20문항 Q&A
Q&A 모음: Java/Spring 핵심 50제
JVM/GC, 동시성, 스프링 빈/트랜잭션/보안 등 자주 묻는 50문항 Q&A
Q&A 모음: DB/캐시/메시징 30제
인덱스/격리/락, Redis 캐시/락, Kafka 파티션·정렬·리밸런스 등 30문항 Q&A
OWASP Top 10 대응 체크리스트
OWASP Top 10 주요 취약점을 백엔드 관점에서 점검하기 위한 체크리스트
Outbox/Saga 패턴으로 분산 트랜잭션 다루기
Outbox 패턴, Saga(Choreography/Orchestration)로 데이터 일관성을 유지하는 방법
MySQL 트랜잭션 격리 수준과 락
READ COMMITTED/REPEATABLE READ 차이, Gap/Next-Key Lock과 데드락 예방법
MySQL 인덱스 설계와 실행 계획 읽기
B-Tree/컴포지트 인덱스 설계, EXPLAIN으로 실행 계획을 해석하고 튜닝하는 방법
MySQL 성능 튜닝: 슬로우 쿼리와 커넥션 풀
슬로우 쿼리 로그, 커넥션 풀(HikariCP) 파라미터, 실행 계획 튜닝 포인트
Kubernetes 롤아웃 전략과 무중단 배포
RollingUpdate, Canary, Blue/Green 전략과 실습 체크리스트
Kafka 재시도/DLQ 설계
재시도 토픽, DLQ, 멱등 처리로 Kafka 소비 실패를 다루는 패턴
Kafka 멱등·정렬 처리 전략
멱등 프로듀서, 정렬 보장 패턴, Exactly-once 처리를 위한 설정과 설계
Kafka 기본: 토픽, 파티션, Consumer Group
Kafka 핵심 개념과 메시지 흐름, Ordering/스루풋 설계를 위한 기초
Kafka Consumer Lag 관리와 리밸런스 대응
Lag 모니터링, 리밸런스 원인, 처리량/중복/손실 사이 트레이드오프 정리
JVM 메모리 (Part 2: Runtime Data Areas, GC)
JVM 메모리 영역과 GC Root, OOM/Metaspace/StackOverflow 같은 장애를 빠르게 진단하는 기본기
JVM 메모리 (Part 1: 구조와 기초)
JVM 메모리 영역과 GC Root, OOM/Metaspace/StackOverflow 같은 장애를 빠르게 진단하는 기본기
JVM GC 튜닝 실무 가이드
GC 로그 해석, Young/Old 튜닝 포인트, GC 선택(G1/ZGC) 가이드
JPA 트랜잭션 경계와 Flush 전략
트랜잭션 경계, flush 시점, 지연 쓰기와 N+1 예방을 정리
JPA N+1: 영원한 숙제, 확실히 잡기
로그에 쿼리 100개가 찍히는 공포. 원인 분석부터 Fetch Join, Batch Size, EntityGraph 해결법 비교
Java 컬렉션 성능 튜닝 가이드
ArrayList/LinkedList/HashMap/ConcurrentHashMap 등 주요 컬렉션의 성능 특성과 튜닝 포인트
Java 예외 처리 & Optional/Stream 패턴
체크예외 vs 런타임예외, Optional/Stream에서 흔한 함정과 안전한 사용 패턴 정리
Java 동시성 기초: Thread, Executor, Lock
Race condition부터 JMM, 스레드풀/락 선택, 디버깅까지: 백엔드에서 필요한 자바 동시성 기본기
Java GC 기본: 세대별 GC와 로그 분석
할당/생존/승격 관점으로 GC를 이해하고, STW/메모리 문제를 로그로 진단하는 기본기
HTTP 필수 개념 정리
메서드/상태코드/헤더/캐시/HTTPS 기본을 빠르게 복습
HTTP 딥다이브: 캐시, 조건부 요청, HTTPS 흐름
메서드/상태코드 복습 후 캐시 제어, ETag 조건부 요청, TLS 핸드셰이크를 실무 관점에서 정리
gRPC 서비스 설계 기초
프로토 정의, 일방향/양방향 스트리밍, gRPC-Gateway 연계 등 gRPC 설계 핵심
GraphQL 스키마 설계 가이드
스키마 정의, 리졸버 구조, N+1 방지(DataLoader), 버전 관리 베스트 프랙티스
GitHub Actions로 백엔드 CI 파이프라인 구축
테스트·빌드·린트·아티팩트 업로드를 포함한 백엔드 CI 파이프라인 예시와 베스트 프랙티스
Git 실무 기본: PR을 안전하게 만드는 커밋/리베이스/리버트
좋은 커밋 단위, rebase/merge 선택, revert/reset 차이까지: 팀 개발에서 사고를 줄이는 Git 루틴
Event Sourcing과 CQRS 입문
이벤트 소싱과 CQRS 기본 개념, 장단점, 적용 시 고려사항
Docker 멀티스테이지 빌드와 CI 파이프라인
멀티스테이지 Dockerfile과 GitHub Actions로 테스트/빌드/이미지 푸시 자동화
CI/CD 보안: 공급망 공격 막기
SLSA 프레임워크부터 SBOM 생성, Sigstore/Cosign 이미지 서명, OIDC 인증, GitHub Actions 하드닝, 취약점 스캔 파이프라인까지 — 공급망 보안 완 …
API 문서화: Spring REST Docs와 Swagger/OpenAPI
스펙 우선 vs 코드 기반 문서화 비교, REST Docs/Swagger 설정과 적용 패턴
API 레이트 리밋과 백프레셔 심화
API Gateway 레이트 리밋, 애플리케이션 레벨 백프레셔, 큐/서킷 브레이커 연계 — 알고리즘 선택부터 Redis 분산 구현, Spring Cloud Gateway 설정까지
7단계: 복습(Q&A)
학습하며 남긴 Q&A를 한 번에 모아 복습하는 단계
6단계: 클라우드 네이티브 & DevOps
Docker, K8s, CI/CD, 모니터링, 트레이싱까지 운영 스택을 갖추는 모듈
5단계: 시스템 안정성 & 회복탄력성 (Resilience)
장애 전파 차단, 트래픽 제어, 고가용성 설계를 다루는 모듈
4단계: 분산 시스템 & 아키텍처 (Distributed Systems)
분산 트랜잭션, 일관성 모델, 샤딩, 이벤트 드리븐 아키텍처를 다루는 모듈
3단계: 데이터베이스 & 데이터 시스템
인덱스/트랜잭션/락/캐시/메시징으로 데이터 시스템의 성능·정합성·확장성을 다지는 모듈
2단계: 스프링 핵심 공략 (Core/Boot/JPA/테스트)
스프링 코어, 부트 자동설정, JPA, 테스트 전략을 집중적으로 다지는 모듈
1단계: 백엔드 기초 다지기 (언어/알고리즘/CS)
언어, 자료구조/알고리즘, 운영체제·네트워크 기본을 다지는 모듈
Consensus 알고리즘: 분산 시스템의 합의
Raft와 Paxos 같은 Consensus 알고리즘으로 분산 시스템의 일관성을 보장하는 원리
API Gateway: 마이크로서비스의 대문
왜 Gateway를 써야 하는가? 인증/라우팅/공통 관심사의 분리
Chaos Engineering: 장애를 주입하여 시스템 회복력 검증
Chaos Engineering 원칙부터 Steady-State Hypothesis 설계, LitmusChaos·AWS FIS·Chaos Toolkit 실전 구현, GameDay …
분산 추적 심화: Zipkin/Jaeger로 마이크로서비스 디버깅
분산 추적으로 마이크로서비스 간 요청 흐름을 추적하고 병목을 찾는 방법
Prometheus + Grafana: 메트릭 수집과 모니터링 대시보드
Prometheus로 메트릭을 수집하고 Grafana로 시각화하는 모니터링 시스템 구축
APM 기본 (Part 2: Actuator, Prometheus 연동)
APM 핵심 개념과 Spring Boot Actuator로 애플리케이션 성능 모니터링 구현
APM 기본 (Part 1: 개념과 도구)
APM 핵심 개념과 Spring Boot Actuator로 애플리케이션 성능 모니터링 구현
ELK Stack: 로그 수집과 분석 플랫폼 구축하기
ELK/EFK/Loki 로그 스택 비교, Filebeat→Logstash→Elasticsearch→Kibana 파이프라인 구축, ILM 자동 관리, 보안/성능 운영 가이드
로깅 전략: ELK와 구조화된 로그(Structured Logging)
단순 텍스트 로그가 아니라 '검색 가능한' JSON 로그를 남겨야 하는 이유와 MDC 활용법
Service Mesh (Istio): 마이크로서비스 통신 관리
Istio Service Mesh로 마이크로서비스 간 통신을 관리하고 보안을 강화하는 방법 — 도입 판단 기준부터 트래픽 관리, mTLS, 관측성, 장애 주입까지 실무 설계 포인트 …
Kubernetes 기본: Pod가 죽지 않는 항해
컨테이너 오케스트레이션이 필요한 이유. Pod/Deployment/Service의 관계와 자가 치유(Self-Healing)
캐싱 전략 (Part 2: 2-Level Cache, 실무 운영)
2-Level Cache, 캐시 무효화, 실무 운영 전략 심화 Q&A
캐싱 전략 (Part 1: 캐시 패턴과 기초)
Cache-Aside, Write-through 등 캐시 패턴 기초 Q&A
예외 처리 (Part 2: Checked/Unchecked, 실무 패턴)
Checked/Unchecked 예외 구분, ControllerAdvice 등 실무 패턴 심화 Q&A
예외 처리 (Part 1: 예외 기초와 전략)
예외 기초와 전략, Spring 예외 처리 패턴 Q&A
상태 관리 (Part 2: Redux Toolkit, 실무 패턴)
Redux Toolkit 핵심 기능, createSlice/createAsyncThunk 패턴, 실무 상태 설계 Q&A
상태 관리 (Part 1: Redux 기초)
Redux, Zustand, Context API 비교 및 상태관리 기초 패턴 Q&A
동시성 제어 (Part 2: 재고 차감, Java 멀티스레드, 실무)
재고 차감, Java 멀티스레드, 실무 동시성 제어 심화 Q&A
동시성 제어 (Part 1: 낙관적/비관적 락, 분산 락)
낙관적/비관적 락, 분산 락의 기본 개념과 동시성 제어 전략 Q&A
WebFlux 구조 정리
WebFlux 내부 구조, Reactor 패턴, 이벤트 루프와 스레드 모델 Q&A
SQL 성능 튜닝 정리
SQL 실행 계획 분석, Join 전략 선택, 쿼리 튜닝 체크리스트 Q&A
Spring 트랜잭션 (Part 2: Propagation, 실무 주의사항)
Transaction Propagation 종류별 동작, REQUIRES_NEW vs NESTED, 실무 주의사항 Q&A
Spring 트랜잭션 (Part 1: 기본 동작과 원리)
@Transactional 동작 원리, AOP 프록시, Isolation Level 기본 개념 Q&A
Spring Bean Lifecycle 정리
Spring Bean 생성 순서, 초기화/소멸 콜백, Proxy 객체와 @Configuration 동작 Q&A
Reactive Programming 개념 정리
Reactive Programming 핵심 개념, Publisher/Subscriber 패턴, Backpressure 전략 Q&A
React 성능 (Part 2: useCallback/useMemo, 심화)
useCallback/useMemo 활용법, React.memo 최적화, 리렌더링 방지 심화 Q&A
React 성능 (Part 1: 렌더링 최적화)
React 렌더링 최적화, Virtual DOM 동작, memo/useCallback 활용법 Q&A
OAuth2 인증 (Part 2: JWT/Token, 보안 심화)
JWT/Token 관리, 보안 심화 전략 Q&A
OAuth2 인증 (Part 1: OAuth2 흐름과 기초)
OAuth2 인증 흐름과 기초 개념 Q&A
Kafka Partition 설계 정리
Kafka Partition 설계 전략, Key 기반 분배, 순서 보장과 리밸런싱 Q&A
Kafka Consumer Group 정리
Kafka Consumer Group 동작 원리, 리밸런싱, 오프셋 관리 전략 Q&A
JVM 내부 구조 정리
JVM 내부 구조, ClassLoader 계층, JIT 컴파일러, Safepoint 동작 원리 Q&A
Java GC & 메모리 구조 정리
Java Heap/Stack 메모리 구조, GC 알고리즘, OutOfMemoryError 원인과 대응 Q&A
Docker 기본: 컨테이너는 왜 빠를까?
VM과 컨테이너의 아키텍처 차이, 이미지 레이어 구조(Copy-on-Write)의 원리
Docker & Kubernetes 정리
Docker 컨테이너 기초, Kubernetes Pod/Service/Deployment 개념과 운영 Q&A
DispatcherServlet 동작 흐름 정리
DispatcherServlet 동작 순서, HandlerMapping, Interceptor, ViewResolver 흐름 Q&A
DB 인덱스 최적화 정리
B-Tree 인덱스, 복합 인덱스 설계, Index Scan 종류별 차이와 실전 최적화 전략 Q&A
CI/CD (Part 2: Jenkins Pipeline, 배포 전략)
Jenkins Pipeline Stage 구성, Blue-Green/Canary 배포 전략, 실무 롤백 패턴 Q&A
CI/CD (Part 1: 기본 개념과 파이프라인)
CI/CD 기본 개념, 파이프라인 구성, Jenkins/ArgoCD 비교와 롤백 전략 Q&A
API 성능 (Part 2: Slow Query 최적화, 심화)
Slow Query 최적화, Execution Plan 분석, 쿼리 튜닝 심화 전략 Q&A
API 성능 (Part 1: 병목 분석과 기초)
API 병목 분석 방법, p95 지연 측정, 캐시/인덱스 기초 최적화 전략 Q&A
분산 락(Distributed Lock): 동시성 이슈 종결자
서버가 여러 대일 때 synchronized는 무용지물입니다. Redis와 Redisson을 활용한 안전한 락 구현
데이터베이스 마이그레이션: Flyway로 스키마 버전 관리하기
Flyway를 이용한 데이터베이스 스키마 버전 관리와 안전한 마이그레이션 전략
Elasticsearch (Part 2: 시작과 실무 활용)
Elasticsearch로 전문 검색을 구현하고 검색 성능을 최적화하는 실전 가이드
Elasticsearch (Part 1: 개념과 구조)
Elasticsearch의 역인덱스 구조, 분석기 파이프라인(Nori 한국어 포함), 매핑 설계, 쿼리 유형별 실전 코드, BM25 스코어링, 집계, 클러스터 운영 가이드
Redis 고급 기능: BitMap, HyperLogLog, Geo, Bloom Filter
Redis의 고급 데이터 구조로 메모리 효율적인 솔루션 구현하기
MySQL 대용량 처리: 파티셔닝과 샤딩 전략
MySQL 파티셔닝과 샤딩으로 대용량 데이터를 효율적으로 처리하는 방법
NoSQL 기초: RDBMS와 비교하고 언제 사용할지 판단하기
NoSQL의 종류와 특징을 이해하고, RDBMS vs NoSQL 선택 기준을 실무 관점에서 정리
DB Connection Pool: HikariCP 설정과 성능 튜닝 완벽 가이드
커넥션 풀의 동작 원리와 HikariCP 설정으로 데이터베이스 성능을 최적화하는 실무 가이드
DB 스키마 설계 기본기: 키/제약조건/정규화
PK/UK/FK, 제약조건, 정규화/비정규화, 변경에 강한 스키마 설계 기준을 실무 관점으로 정리
SQL 서브쿼리와 집계함수: GROUP BY, HAVING, 윈도우 함수 마스터
서브쿼리, GROUP BY/HAVING 집계, 윈도우 함수로 복잡한 데이터 분석 쿼리 작성
SQL 기초: SELECT/INSERT/UPDATE/DELETE 완벽 정리
SQL의 기본 CRUD 작업과 WHERE/ORDER BY/LIMIT 조건을 실전 예제로 마스터
Circuit Breaker 패턴: 장애 전파를 끊는 두꺼비집
외부 API/DB 장애가 내 서비스까지 번지지 않게 막는 Resilience4j 패턴과 설정값 가이드
Spring 비동기 프로그래밍: @Async와 CompletableFuture
@Async로 비동기 처리를 구현하고 CompletableFuture로 효율적인 병렬 처리하기
Spring IoC 컨테이너 이해하기
Spring의 핵심 개념인 IoC(Inversion of Control)와 DI(Dependency Injection) 정리
React Hooks 기초
React Hooks의 기본 개념과 사용법 정리
Spring Data JPA: Repository 패턴과 쿼리 메서드로 생산성 극대화
JpaRepository 인터페이스, 쿼리 메서드, @Query, Specification으로 데이터 접근 계층을 간결하게 구현
JPA 연관관계 매핑: @OneToMany, @ManyToOne, @ManyToMany 완벽 가이드
JPA 연관관계 매핑(1:N, N:1, N:M)과 양방향 관계, 연관관계 주인, Cascade/OrphanRemoval을 실무 관점으로 정리
JPA 기초: 엔티티, 영속성 컨텍스트, 기본 CRUD 이해하기
JPA의 핵심 개념인 엔티티와 영속성 컨텍스트를 이해하고, 기본 CRUD 작업과 상태 전이를 실무 관점으로 정리
Spring 예외 처리 (Part 2: 에러 응답 설계, 실무)
@ControllerAdvice와 @ExceptionHandler로 전역 예외를 처리하고 일관된 에러 응답 설계
Spring 예외 처리 (Part 1: 동작 원리)
@ControllerAdvice와 @ExceptionHandler로 전역 예외를 처리하고 일관된 에러 응답 설계
Spring 빈 스코프와 프록시: Singleton vs Prototype 완벽 이해
Spring 빈의 생명주기 스코프(Singleton/Prototype/Request/Session)와 프록시 모드를 실무 관점으로 정리
Spring IoC/DI 핵심: 컨테이너, 빈 생명주기, 의존성 주입 이해하기
Spring의 핵심인 IoC 컨테이너와 DI(의존성 주입) 원리를 이해하고, 빈 생명주기와 스코프를 실무 관점으로 정리
JVM 메모리 누수 디버깅: 힙 덤프 분석과 프로파일링
메모리 누수를 진단하고 힙 덤프를 분석하여 원인을 찾는 실전 가이드
REST API 설계 원칙: 리소스, HTTP 메서드, 상태코드 완벽 가이드
RESTful API 설계 원칙과 HTTP 메서드, 상태코드, URL 설계 패턴을 실전 예제로 마스터
디자인 패턴 필수 (Part 2: Strategy, 실무 적용)
백엔드 개발에서 가장 많이 쓰이는 3가지 패턴을 실전 예제로 마스터
디자인 패턴 필수 (Part 1: 기초 패턴)
백엔드 개발에서 가장 많이 쓰이는 3가지 패턴을 실전 예제로 마스터
객체지향 설계 원칙 SOLID: 실무 관점으로 이해하기
SOLID 5가지 원칙(SRP/OCP/LSP/ISP/DIP)을 실전 코드 예제로 이해하고, 좋은 설계와 나쁜 설계를 구분하는 감각 기르기
Java 8+ 핵심: Stream API와 Optional로 안전하고 간결한 코드 작성
Stream API로 컬렉션 처리를 선언적으로 작성하고, Optional로 null 안전성을 확보하는 실전 기법
Java Collection Framework: List/Set/Map 선택 기준과 성능 특성
ArrayList vs LinkedList, HashMap vs TreeMap, 언제 어떤 컬렉션을 선택할지 성능과 특성 기준으로 정리
Spring @Transactional 기본 사용법 예제
가장 많이 사용하는 @Transactional 패턴과 실수하기 쉬운 포인트 정리
MySQL 인덱스 기초 예제
WHERE, ORDER BY, JOIN에서 인덱스가 어떻게 사용되는지 간단한 예제로 정리