가이드
도구를 더 잘 쓰기 위한 깊은 설명서. 개념·구조·자주 빠지는 함정·안전한 사용법까지 한 자리에서.
- JWT 완벽 가이드 — 구조·검증·안전한 사용법
JWT 의 header·payload·signature 구조부터 검증·시크릿 로테이션·자주 빠지는 보안 함정까지 한 번에.
약 9분
- Base64 인코딩 — 원리·변형·언제 쓰는가
Base64 는 암호화가 아니라 바이너리→텍스트 인코딩. 패딩·URL-safe 변형·자주 빠지는 함정·크기 오버헤드를 정리.
약 7분
- UUID vs ULID — 어떤 식별자를 골라야 하나
UUID v4·v7, ULID, Snowflake 를 정렬성·DB 성능·URL 친화성·충돌 위험 관점에서 비교.
약 8분
- 정규표현식 30분 입문 — 기초부터 lookaround·ReDoS 까지
문자 클래스·수량자·그룹·lookaround 와 절대 쓰면 안 되는 catastrophic backtracking 패턴까지 실전 예제로.
약 10분
- Cron 표현식 완벽 가이드 — 문법·타임존·자주 빠지는 함정
Cron 필드별 문법·특수 토큰·Unix/Kubernetes/AWS 의 타임존 동작 차이·말 없이 실패하는 패턴 정리.
약 8분
- HMAC 웹훅 검증 — Stripe·GitHub·Slack 의 서명 검증 패턴
웹훅에 왜 HMAC 서명이 필요한지, Stripe·GitHub·Slack 이 어떻게 페이로드를 서명하는지, constant-time 비교·재전송 방어·단계별 검증 구현까지.
약 8분
- HTTP 상태 코드 — 401·403·422·500 언제 쓸까 (전체 가이드)
HTTP 상태 코드 분류 의미, REST API 에서 자주 쓰는 코드, 헷갈리는 쌍 (401 vs 403, 400 vs 422), 올바른 선택 기준까지.
약 9분
- 비밀번호 해싱 — bcrypt·Argon2 와 절대 쓰지 말아야 할 것
왜 SHA-256 으로 비밀번호를 저장하면 안 되는지, bcrypt 와 Argon2 의 차이, cost 파라미터 선택 기준, pepper, 알고리즘 마이그레이션 전략.
약 10분
- WCAG 색상 대비 — AA·AAA 등급과 4.5:1 비율의 의미
WCAG 대비 비율 계산 방식, AA 와 AAA 의 차이, 'large text' 정의, 흔히 빠지는 UI 회귀, 차세대 APCA 까지.
약 8분
- Markdown 치트시트 — 자주 쓰는 문법 모음 (예제 포함)
Markdown 전체 문법 — 헤딩·리스트·링크·이미지·표·코드 블록·각주·체크박스, GitHub Flavored Markdown 확장까지.
약 7분
- CORS 완벽 정리 — 프리플라이트 트리거·자주 보는 에러·해결법
Same-origin 정책부터 simple/preflight 분기, Access-Control-* 헤더, 쿠키 전송, 자주 마주치는 디버깅 함정까지.
약 9분
- OAuth 2.0 정리 — Authorization Code·PKCE·Client Credentials, 언제 무엇을 쓸까
4 가지 흐름의 차이, implicit 가 PKCE 로 대체된 이유, refresh token 과 scope, OpenID Connect 와의 관계.
약 10분
- JavaScript 타임존 함정 — UTC·IANA·DST·날짜 저장의 정답
JS Date 의 위험, 항상 UTC 로 저장해야 하는 이유, offset 과 IANA 이름의 차이, DST 함정, 사용자에게 올바르게 표시하는 방법.
약 9분
- URL 인코딩 정밀 가이드 — 왜 +가 아니라 %20인가, encodeURIComponent vs encodeURI
퍼센트 인코딩 문자 집합, encodeURI 와 encodeURIComponent 차이, '+' 가 공백이 되는 맥락, IDN/Punycode, 안전한 URL 조립.
약 8분
- JSON Schema vs TypeScript — 어느 쪽에서 어느 쪽으로 생성할까
JSON Schema 가 할 수 있는 것 vs TypeScript 가 할 수 있는 것, 양방향 생성 전략, Ajv/Zod 런타임 검증, API 경계 패턴.
약 9분
- Web Crypto API — 브라우저 안에서 SHA·HMAC·AES·JWT 를 라이브러리 없이
브라우저 내장 crypto.subtle 으로 SHA/HMAC/AES/JWT 구현. digest·sign·encrypt·키 import/export, 보안용 getRandomValues 가 Math.random 을 대체하는 이유.
약 9분
- 웹 이미지 최적화 — WebP·AVIF·srcset·올바른 압축
최신 이미지 포맷 비교, JPEG/WebP/AVIF 선택 기준, srcset 반응형 이미지, lazy loading, 압축의 동작 원리.
약 8분
- Idempotency Key — Stripe 가 재시도를 안전하게 만든 방법과 구현 가이드
재시도가 왜 중복 결제를 만드는지, Stripe·PayPal 의 idempotency key 동작, 서버 상태 머신, 키 생성 전략, 저장소 TTL.
약 8분
- Content Security Policy — XSS 차단을 위한 CSP 헤더 정복
CSP 가 XSS 를 어떻게 막는지, 실제로 필요한 디렉티브, nonce / hash / strict-dynamic 선택, report-only 점진 도입, AdSense/GA 호환성.
약 9분
- HTTP 캐싱 — Cache-Control·ETag 와 자산별 올바른 헤더 조합
max-age vs s-maxage·immutable·stale-while-revalidate·ETag vs Last-Modified·CDN과 브라우저 캐시·정적 자산·HTML·API 응답에 맞는 헤더 조합.
약 9분
- Webhook · Polling · SSE · WebSocket — 실시간 패턴 선택 가이드
지연·비용·복잡도·실패 모드로 4 가지 실시간 패턴 비교. Webhook·Polling·SSE·WebSocket 의 적절한 선택 기준과 fallback 전략.
약 9분
- SVG 최적화 — 편집 도구 50KB export 를 5KB 까지 줄이기
편집 도구 export 가 왜 부풀어 오르는지, SVGO 가 무엇을 제거하는지, inline vs 외부 참조, sprite 시트, 사용자 업로드 SVG 보안 체크리스트.
약 7분
- SameSite 쿠키와 CSRF — Lax·Strict·None 의 진짜 의미
SameSite 가 2020 년 CSRF 방어를 어떻게 바꿨는지, Lax/Strict/None 의 차이, Secure 가 필요한 시점, 3rd-party 쿠키 폐기, SameSite 외에 여전히 필요한 것.
약 8분
- Rate Limiting 전략 — Token Bucket·Sliding Window 와 429 Retry-After 계약
rate limit 의 이유, 4 가지 고전 알고리즘 (fixed/sliding/token/leaky), IP·사용자·API key 별 스코프, 클라이언트가 기대하는 헤더.
약 9분
- Kubernetes YAML 완벽 정리 — 매니페스트 구조·리소스 종류·연결 방식
모든 Kubernetes 매니페스트의 공통 구조 (apiVersion / kind / metadata / spec), 실무에서 쓰는 리소스 종류, Service 가 label 로 Pod 를 찾는 방식, 입문자가 자주 빠지는 매니페스트 함정.
약 11분
- Docker Compose 완벽 정리 — 서비스·네트워크·볼륨·실전 구성법
docker-compose.yml 의 구조, 각 top-level 키 (services / networks / volumes / configs / secrets) 역할, depends_on 과 healthcheck 차이, named volume vs bind mount, 개발 환경을 깨뜨리는 함정들.
약 10분
- 포모도로 기법 완벽 정리 — 역사·방법·효과의 원리
포모도로 기법의 유래 (Francesco Cirillo 와 토마토 모양 주방 타이머), 정확한 방법 (25분 집중 + 5분 휴식, 4세트마다 긴 휴식), 시간 박싱이 산만함·번아웃을 막는 원리, 인기 있는 변형, 그리고 버려도 좋은 오해들.
약 8분
- QR 코드는 어떻게 만들어질까?
QR 코드의 내부 구조를 풀어본다. finder / alignment / timing 패턴, 4 가지 데이터 인코딩 모드, Reed-Solomon 에러 정정 수준 (L/M/Q/H), 스캐너가 안정적으로 읽도록 보장하는 8 가지 마스크 패턴. ISO/IEC 18004 사양 기반.
약 9분
- SHA 해시는 어떻게 만들어질까?
암호화 해시 함수의 동작 원리를 풀어본다. one-way 의 의미, SHA-2 (Merkle-Damgård) 와 SHA-3 (sponge) 의 차이, MD5/SHA-1 이 깨진 이유, 그리고 왜 빠른 해시가 비밀번호에는 부적합한지.
약 9분
- 색은 어떻게 표현될까? (RGB · HSL · OKLCH)
sRGB · P3 · RGB · HSL · OKLCH 가 실제로 의미하는 것. HSL 이 직관적이지만 시각 일관성을 깨는 이유, OKLCH 가 디자인 시스템의 새 default 가 된 이유, gamut 과 luminance 읽는 법.
약 9분
- diff 는 어떻게 바뀐 줄을 찾아낼까?
LCS 부터 Myers 의 O(ND) 알고리즘까지 — Git·GitHub PR·IDE 가 두 텍스트 사이 최소 변경 집합을 어떻게 찾아내는지, 라인 이동이 왜 delete + insert 로 표시되는지, unified · context 패치 형식의 차이.
약 9분
- 한글은 어떻게 저장될까? (UTF-8 의 원리)
한글 한 글자가 왜 3 바이트인지, Unicode codepoint 가 무엇인지, UTF-8 의 가변 길이 인코딩이 ASCII 와 어떻게 호환되는지, BOM·surrogate pair 의 정체, 그리고 byte 와 character 를 혼동해서 생기는 버그들.
약 9분
- JSON 은 어떻게 파싱될까?
JSON 파서 내부 — lexer 상태, 왜 trailing comma 가 금지인지, 왜 큰 정수가 정밀도를 잃는지 (IEEE 754), streaming JSON 의 동작, 그리고 시니어 엔지니어도 놀라는 파서 quirk.
약 9분
- 이미지는 어떻게 압축될까? (PNG · JPG · WebP · AVIF)
JPEG 안에 무엇이 들었는지, PNG 가 무손실인 이유, WebP·AVIF 가 어떻게 시각 손실 없이 더 작아지는지. DCT·Huffman·palette indexing·각 포맷의 트레이드오프.
약 9분
- SQL 은 어떻게 파싱될까? (그리고 왜 injection 이 위험할까)
SQL 파이프라인 내부 — lexer · parser · AST · query planner · executor. 왜 문자열 결합 SQL 이 위험한지, prepared statement 가 injection 을 정확히 어떻게 막는지, PostgreSQL · MySQL · SQLite 의 parser quirk.
약 9분
- User-Agent 는 왜 Mozilla 로 시작할까?
역사상 가장 많이 거짓말한 HTTP 헤더의 짧은 역사 — 왜 Chrome 이 Netscape 인 척하고, Safari 가 Chrome 인 척하는지, 그리고 User-Agent 가 향하는 다음 단계 (Client Hints · Sec-CH-UA · privacy budget).
약 8분
- 설정 파일은 어떤 형식이 좋을까? (YAML · JSON · TOML · XML)
5 가지 설정 파일 포맷을 정면 비교 — YAML 의 7 가지 boolean, TOML 의 타입 있는 datetime, JSON 의 주석 부재, XML 의 namespace, INI 의 무규격. 상황에 맞는 포맷 고르기.
약 9분
- 컴퓨터는 왜 16 진수를 좋아할까?
왜 개발자들이 어디든 hex 를 만나는지, two's complement 가 어떻게 덧셈·뺄셈을 같은 회로로 만드는지, 왜 0.1 + 0.2 ≠ 0.3 인지, 모든 정수·실수 안에 숨은 비트 패턴.
약 8분
- 브라우저는 HTML 을 어떻게 파싱할까?
HTML5 parser 는 관대하기로 유명 — 빠진 태그 복구, <br/> 과 <br> 둘 다 통과, 잘못된 입력에도 절대 실패 X. 그 마법의 state machine, void element 가 존재하는 이유, XML 의 strict 함과의 비교.
약 8분
- Unix Timestamp 는 왜 1970 년부터 셀까?
왜 1970 년부터인지, Unix time 이 사실 단조 증가하지 않는 이유, 32-bit 시스템의 Y2038 문제, 윤초 사태, monotonic vs wall clock 차이, 그리고 왜 "지금" 이 거꾸로 갈 수 있는지.
약 8분
- CSV 는 왜 항상 깨질까?
CSV 는 가장 단순해 보이는 포맷 — 쉼표와 줄. 그러나 필드 안 쉼표·따옴표·줄바꿈, BOM, Excel 의 인코딩 선택, dialect 차이가 production 에서 가장 자주 깨지는 포맷으로 만든다.
약 8분
- HTTP 요청 안에는 뭐가 들었을까?
HTTP 요청을 wire 수준에서 풀어본다 — request line, header, body, GET·POST 뒤의 대화 패턴. content negotiation, conditional request, cookie, preflight, 다들 잊는 헤더들.
약 9분
- IP 주소와 CIDR 는 어떻게 동작할까?
IP 주소가 사실은 그냥 32-bit 정수인 이유, /24 의 의미, 모든 backend 가 만나는 사설 범위, NAT, 그리고 IPv6 가 등장한 이유 — networking jargon 이 아닌 비트 패턴으로.
약 8분
- JavaScript 는 어떻게 파싱·실행될까?
source bytes 부터 V8 hidden class 까지 — lexer · parser · AST · hoisting · event loop · ASI 함정 · 동적 언어인 JavaScript 가 빨라지는 최적화.
약 9분
- HTTPS 는 어떻게 안전할까? (TLS handshake)
ClientHello 와 첫 암호 byte 사이에서 무엇이 일어나는지 — certificate, cipher suite, key exchange, SNI, 그리고 TLS 1.3 가 handshake 를 2 RTT 에서 1 RTT 로 줄인 방법.
약 9분
- DNS 는 어떻게 도메인을 IP 로 바꿀까?
DNS query 가 root server → TLD → authoritative resolver → recursive resolver 거치는 길, A/AAAA/CNAME/MX 레코드 종류, TTL 캐싱, 그리고 DNS-over-HTTPS 가 등장한 이유.
약 9분
- 파일이 PNG 인지 어떻게 알까? (magic numbers)
OS 와 브라우저가 파일의 첫 몇 byte 로 type 을 판단하는 방식 — PNG·JPG·PDF·ZIP 서명, 확장자만 믿으면 안 되는 이유, content-sniffing 의 강력함과 위험.
약 8분
- URL slug 는 왜 SEO 에 중요할까?
좋은 URL slug 의 조건 — 검색 친화 문자, 한글 Romanization 과 Punycode 의 차이, hyphen vs underscore, slug 안정성, 그리고 모든 사이트가 결국 마주하는 301 redirect 룰.
약 7분
- Git 은 안에서 어떻게 동작할까? (object · ref · pack file)
.git 디렉토리 내부 — 4 가지 object (blob/tree/commit/tag), ref 가 commit 을 가리키는 방식, 매 commit 의 SHA-1 가 의미하는 것, pack file, garbage collection, 그리고 merge vs rebase 가 실제로 무엇을 바꾸는가.
약 9분
- regex 가 왜 무한 루프에 빠질까? (ReDoS)
backtracking 방식의 regex engine 이 (a+)+ 같은 평범해 보이는 패턴에 지수 시간을 쓰는 이유. NFA · backtracking 모델, ReDoS 공격, RE2 같은 linear-time engine 의 대안.
약 8분
- websocket vs SSE — 실시간 통신은 어떻게 동작할까?
양방향 WebSocket vs 단방향 Server-Sent Events — handshake · frame format · 재연결 · heartbeat 차이, 채팅 · 알림 · 실시간 대시보드에 어떤 걸 골라야 할지.
약 8분
- CSS 우선순위는 어떻게 결정될까? (specificity · cascade)
어떤 CSS 룰이 이기는지 결정하는 메카니즘 — selector matching, (a-b-c) specificity 계산, cascade 순서, :where() 의 zero specificity, !important 탈출구, 그리고 @layer 의 등장.
약 8분
- Docker 컨테이너는 어떻게 격리될까?
컨테이너는 가벼운 VM 이 아닌, namespace 와 cgroup 으로 격리된 Linux 프로세스. namespace · cgroup · overlay 파일시스템 · image layer · Docker daemon 의 실제 동작을 풀어본다.
약 9분
- Webpack · Vite · esbuild — bundler 는 무엇을 할까?
bundler 가 단순 "파일 합치기" 외에 하는 일 — module resolution · dependency graph · tree shaking · code splitting · source map · HMR · 그리고 Vite 가 dev 에서 Webpack 보다 100 배 빠른 이유.
약 9분
- GraphQL 은 어떻게 동작할까?
GraphQL 이 REST 와 다른 점 — schema-first 설계, resolver tree, N+1 문제와 DataLoader 의 해결, mutation·subscription·federation, 그리고 GraphQL 이 과한 케이스.
약 9분
- 로그인은 어떻게 동작할까? (session · JWT · OAuth · passkey)
session cookie · JWT · OAuth flow · passkey — 각 모델이 무엇을 저장하고 신뢰는 어디에 있는지, 왜 refresh token 이 필요한지, WebAuthn 의 passkey 가 어떻게 비밀번호를 완전히 대체하는지.
약 9분
- 데이터베이스 index 는 어떻게 동작할까?
B-tree · hash index · covering index, 왜 LIKE '%foo' 는 index 를 못 쓰는지, composite index 의 column 순서가 중요한 이유, planner 가 실제로 index 쓰는지 EXPLAIN 으로 확인하는 법.
약 9분
- 데이터베이스 transaction 은 어떻게 동작할까?
ACID, isolation level, dirty/phantom read, write skew, MVCC 와 locking, SERIALIZABLE, deadlock, serialization 실패 재시도 패턴까지 실무로 정리.
약 9분
- 데이터베이스 storage engine 은 어떻게 동작할까?
page · buffer pool · WAL/fsync, B-tree vs LSM-tree engine, compaction, write/read/space amplification trade-off 로 어떤 engine 을 고를지 정리.
약 10분
- DB connection pool 은 어떻게 동작할까?
DB connection 여는 비용, connection pool 의 동작, pool 고갈, 적정 크기 계산, PgBouncer session vs transaction 모드, serverless connection storm 까지 정리.
약 8분
- query planner(optimizer) 는 어떻게 동작할까?
SQL planner 가 query 를 실행 plan 으로 바꾸는 과정 — cost model, 통계, cardinality 추정, scan·join 선택, EXPLAIN ANALYZE 읽는 법까지.
약 10분
- Core Web Vitals 는 어떻게 측정될까?
Core Web Vitals 의 LCP · CLS · INP 가 실제로 무엇을 재는지, field vs lab 데이터 차이, 각 지표를 망치는 원인과 측정·개선 방법.
약 9분
- debounce 와 throttle 는 어떻게 동작할까?
scroll · resize · input 같은 고빈도 event 를 길들이는 debounce 와 throttle — leading/trailing edge, 실제 JS 코드, React 함정, INP 개선까지.
약 8분
- 웹 폰트는 어떻게 로드될까?
웹 폰트가 늦게 로드되는 이유, FOIT · FOUT · FOFT, font-display 값 전부, swap CLS 문제, size-adjust fallback metric, preload · WOFF2 · subset · variable font 정리.
약 9분
- resource hint(preload·preconnect·prefetch) 는 어떻게 동작할까?
resource hint 총정리 — preload·preconnect·dns-prefetch·prefetch·modulepreload·fetchpriority·103 Early Hints·Speculation Rules, 각각 언제 쓰는지.
약 8분
- 브라우저는 페이지를 어떻게 그릴까?
HTML bytes 가 pixel 이 되기까지 — parsing · DOM/CSSOM · render tree · layout · paint · composite. reflow 가 비싼 이유, GPU layer 가 생기는 trigger, 60fps 의 16.67ms 예산 안에 머무는 법.
약 8분
- message queue 는 어떻게 동작할까? (Kafka · RabbitMQ · SQS)
pub-sub · partition · queue vs log · at-least-once vs exactly-once · consumer group · 그리고 Kafka · RabbitMQ · SQS 의 차이와 선택 기준.
약 8분
- TypeScript 타입 시스템은 어떻게 동작할까?
structural typing · narrowing · discriminated union · generic · conditional · mapped type — TypeScript 가 컴파일 타임에 정확히 무엇을 검증하는지, runtime 값이 왜 여전히 surprise 줄 수 있는지, 타입 시스템 잘 쓰는 패턴.
약 9분
- 메모리 할당은 어떻게 동작할까?
stack vs heap, malloc/free 의 내부, fragmentation 이 왜 중요한가, RAII vs GC, 모든 언어의 'new Object()' 뒤에 있는 실제 메커니즘 — 코드가 실제로 지불하는 cost model 로 설명.
약 9분
- garbage collection 은 어떻게 동작할까?
mark-and-sweep · reference counting · generational hypothesis, 왜 99% object 가 young 에서 죽나, stop-the-world pause, G1 vs ZGC vs Shenandoah, GC 튜닝이 결국 allocation pattern 튜닝인 이유.
약 9분
- 네트워크 프로그래밍은 어떻게 동작할까?
socket · TCP vs UDP, C10K 문제와 epoll/kqueue/IOCP 가 만들어진 이유, blocking vs non-blocking vs async, file descriptor 추상화, Node.js 가 single-thread 인데 10,000 connection 처리 가능한 이유.
약 10분
- concurrency 동기화 원시는 어떻게 동작할까?
mutex · semaphore · condvar · atomic CAS, lock-free vs wait-free, volatile 가 lock 이 아닌 이유, memory ordering 과 happens-before, actor model 이라는 다른 길 — CPU 가 실제로 무엇을 하는지 수준에서 설명.
약 11분
- 파일시스템은 어떻게 동작할까?
inode · block · VFS, open() 의 file descriptor lifecycle, journaling vs copy-on-write, ext4 vs btrfs vs ZFS, 왜 rm 은 빠른데 secure delete 는 느린지, fsync 가 실제로 하는 일 — 코드와 디스크 사이의 layer.
약 10분
- CPU 캐시는 어떻게 동작할까?
L1 vs L2 vs L3, cache line (64 byte), row-major iteration 이 column-major 보다 10배 빠른 이유, 멀티스레드의 false sharing, prefetcher, NUMA, 같은 알고리즘인데 실제 성능이 천차만별인 이유.
약 9분
- 컴파일러는 어떻게 동작할까?
lexing · parsing · AST, IR (LLVM, Go SSA), 실제 도는 optimization pass, codegen · register allocation, -O2 가 코드를 3 배 빠르게 하지만 디버깅을 어렵게 하는 이유, Rust · Go · Swift 컴파일러가 어떻게 다른지.
약 10분
- linker 는 어떻게 동작할까?
static vs dynamic linking, ELF symbol table, 'undefined reference to foo' 의 진짜 의미, GOT/PLT 와 libc.so 의 런타임 resolve, main() 보다 먼저 도는 ld.so 프로그램, DLL hell 이 생기는 이유.
약 10분
- system call 은 어떻게 동작할까?
user mode vs kernel mode, syscall 명령 (x86 syscall, ARM svc), strace 가 보여주는 것, syscall 최저 비용 100 ns 인 이유, vDSO (syscall 없는 clock_gettime), io_uring 의 syscall amortization.
약 9분
- consensus 알고리즘은 어떻게 동작할까?
Paxos vs Raft, leader election, quorum (N/2+1), split-brain, FLP 불가능성, 왜 실전에서 Raft 가 Paxos 를 이겼나, etcd / Consul / ZooKeeper 가 실제로 진실을 결정하는 방식.
약 10분
- DB replication 은 어떻게 동작할까?
sync vs async, leader-follower vs multi-leader vs leaderless, replication lag, read-your-writes 일관성, 읽기 확장 시 의외의 실패 모드, eventual consistency 가 보통 당신이 원하는 게 아닌 이유.
약 10분
- sharding 은 어떻게 동작할까?
hash 기반 vs range 기반 partitioning, consistent hashing (1995년 발명이 지금까지 쓰이는 이유), hot shard, downtime 없는 rebalancing, cross-shard join 이 왜 용인가, DynamoDB / Cassandra / Vitess 가 실제로 데이터를 쪼개는 방식.
약 10분
- CAP 정리는 어떻게 동작할까?
Brewer 가 실제로 증명한 것 (마케팅이 증명했다고 하는 것과 다름), partition tolerance 는 협상 불가, CP vs AP 의 거짓 양분, PACELC 가 더 솔직한 프레임워크, 실제 DB (DynamoDB / Cassandra / Spanner / etcd) 가 어떤 trade-off 를 고르는지.
약 9분
- event sourcing 은 어떻게 동작할까?
event log 가 source of truth, projection, snapshot, CQRS, time-travel 디버깅을 위한 replay, outbox 가 필수인 이유, schema evolution 의 용, event sourcing 이 정답인 경우 (그리고 우연한 복잡도인 경우).
약 10분
- observability 는 어떻게 동작할까?
3 기둥 (logs · metrics · traces), 각각의 강점, cardinality 가 cost ceiling 인 이유, 왜 '다 로그하기' 가 안 되나, observability 와 monitoring 의 차이.
약 9분
- distributed tracing 은 어떻게 동작할까?
span · parent-child · trace context propagation (W3C Trace Context), OpenTelemetry, head vs tail sampling, 1% 샘플링이 가장 느린 요청을 놓치는 이유, Jaeger / Tempo / Honeycomb / Lightstep trade-off.
약 10분
- metrics 는 어떻게 동작할까?
counter · gauge · histogram · summary — 각각이 측정하는 것, histogram 이 평균보다 나은 이유, Prometheus pull vs StatsD push, exemplars, cardinality 폭발, p50 / p99 / max 의 차이.
약 9분
- structured logging 은 어떻게 동작할까?
JSON 로그가 printf 보다 나은 이유, 레벨 (DEBUG/INFO/WARN/ERROR/FATAL), correlation ID 가 서비스 간 요청을 잇는 방식, 로그 집계 (Loki / Elasticsearch / CloudWatch), 버그 안 잃고 sampling 하기.
약 9분
- SLI 와 SLO 는 어떻게 동작할까?
SLI 가 실제로 측정하는 것, 의미 있는 SLO 쓰는 법, error budget 가 feature velocity 의 contract 인 이유, 새벽 3시에 노이즈로 page 안 받는 multi-window multi-burn-rate alert, 가용성 % 가 보이는 것보다 어려운 이유.
약 10분
- XSS 는 어떻게 동작할까?
reflected vs stored vs DOM-based XSS, innerHTML 이 용인 이유, context 잘못된 escape 의 실패 (HTML attribute vs URL vs JS), DOMPurify, Trusted Types, 가장 많은 공격 막는 실제 CSP 룰.
약 10분
- SQL injection 은 어떻게 동작할까?
UNION 기반 vs blind vs time-based injection, 왜 문자열 결합은 항상 지나, prepared statement 가 wire level 에서 실제 동작, ORM 이 완전 안전 아닌 이유, 저장된 데이터로 인한 second-order injection.
약 9분
- secrets management 는 어떻게 동작할까?
왜 .env 의 git commit 이 leak 1순위, Vault / KMS / cloud Secrets Manager, envelope encryption, downtime 없는 rotation, 단기 dynamic credential, secret scanning (gitleaks, truffleHog) — 실제로 scale 되는 패턴.
약 9분
- supply chain 공격은 어떻게 동작할까?
npm typosquatting, dependency confusion, modern playbook 으로서의 SolarWinds·Log4Shell, xz-utils backdoor, lockfile vs unpinned 버전, SBOM (Software Bill of Materials), 실제 방어 수단 (sigstore, npm provenance, dependabot).
약 10분
- 암호화는 어떻게 동작할까?
대칭 (AES) vs 비대칭 (RSA / ECC), RSA 가 파일 직접 암호화 안 하는 이유 (hybrid encryption), block cipher mode (ECB 함정 vs GCM), key derivation (PBKDF2 / Argon2), at-rest vs in-transit, never-roll-your-own-crypto 룰.
약 10분
- testing pyramid 는 어떻게 동작할까?
unit / integration / E2E, 70/20/10 이 법칙 아닌 시작점인 이유, ice cream cone anti-pattern, testing trophy 의 modern 대안, 코드베이스에 맞는 형태 선택.
약 9분
- mocking 은 어떻게 동작할까?
stub vs mock vs spy vs fake (Gerard Meszaros 의 4종), over-mocking 이 진짜 아무것도 100% 커버 안 하는 이유, network vs DB 가짜 시점, test double 이 내부 구현과 결합되는 함정.
약 9분
- property-based testing 은 어떻게 동작할까?
example-based vs property-based, generator + shrinker (왜 실패 input 이 [42,17,88] 이 아닌 [] 가 되는지), QuickCheck / Hypothesis / fast-check, property test 만 잡는 버그.
약 9분
- contract testing 은 어떻게 동작할까?
왜 microservice integration test 가 scale 안 되나, consumer-driven contract (Pact), provider 검증, git 버전 spec 으로서의 contract, '한 test 위해 service 20개 띄우기' 악몽 대체.
약 9분
- flaky test 는 어떻게 동작할까?
5 원인 (race condition, 순서 의존, 시간, network, 공유 state), retry 가 잘못된 fix 인 이유, CI 신호 대 잡음 비율의 비용, 체계적으로 찾고 죽이는 법.
약 9분
- caching 은 어떻게 동작할까?
두 가지 어려운 문제 (invalidation + naming), cache hierarchy (CPU → browser → CDN → Redis → DB), cache-aside vs write-through vs write-behind, stampede / thundering herd, TTL 만으로 안 되는 이유.
약 9분
- CDN 은 어떻게 동작할까?
edge POP 과 BGP anycast, cache miss 시 실제 흐름, 중요한 Cache-Control 헤더 (s-maxage / stale-while-revalidate), origin shield, tag vs URL 단위 purge, CDN 이 DDoS 방어인 이유.
약 9분
- lazy loading 은 어떻게 동작할까?
code splitting (route 기반 + dynamic import), 이미지를 위한 IntersectionObserver API, prefetch vs preload vs lazy, 과도한 splitting 이 (TCP round-trip) 으로 손해인 이유, React Suspense / Next dynamic 의 실제 패턴.
약 9분
- N+1 query 는 어떻게 발생할까?
user list 한 번으로 101 SQL query 가 발생하는 lazy loading 함정, eager loading (JOIN, IN), DataLoader (Facebook batching 패턴), GraphQL N+1 폭증, ORM 의 default 가 숨기는 이유.
약 9분
- event loop 은 어떻게 동작할까?
call stack + task queue + microtask queue, setTimeout(fn, 0) 가 0 ms 아닌 이유, microtask starvation, Node 의 libuv thread pool, 브라우저와 Node event loop 의 차이, 'async' 가 queue 의 sugar 인 이유.
약 9분
- React Server Components 는 어떻게 동작할까?
server vs client component boundary, 'use client' directive, RSC payload (HTML 아닌 JSON 아닌 별도 format), streaming render, props 는 serialize 되는데 function 은 안 되는 이유, RSC 가 실제 줄이는 bundle.
약 10분
- state management 는 어떻게 동작할까?
local vs global state, Context API 가 Redux 대체 아닌 이유 (re-render 성능), Zustand vs Jotai vs Redux 차이, server state vs client state (TanStack Query / SWR), '라이브러리 없음' 이 정답인 경우.
약 9분
- hydration 은 어떻게 동작할까?
React 가 SSR HTML 위에 event handler 부착, hydration mismatch 에러의 진짜 원인, progressive / selective / partial hydration, island architecture (Astro / Qwik resumability), hydration 이 SSR 의 cost 인 이유.
약 9분
- SSR · SSG · SPA · RSC 는 어떻게 다를까?
HTML 이 어디서 만들어지나 (server / build / client), TTFB vs LCP vs interactivity trade-off, 각 모델이 보내는 bundle 크기, 언제 무엇을 선택, 'Next.js App Router' 가 순수 RSC 아니고 hybrid 인 이유.
약 10분
- virtual DOM 은 어떻게 동작할까?
VDOM = snapshot, reconciliation diff (O(n) — O(n³) 아님), React Fiber 의 interruptible scheduler, key prop 이 중요한 이유, Vue 의 tracked-dep patch, Svelte / Solid 의 no-VDOM signal 접근.
약 9분
- ETL 과 ELT 는 어떻게 다를까?
Extract-Transform-Load (전통) vs Extract-Load-Transform (modern default), 클라우드 warehouse (BigQuery / Snowflake / Redshift) 가 순서를 뒤집은 이유, compute vs storage cost 전환, schema-on-write vs schema-on-read, ETL 이 여전히 승리하는 경우.
약 9분
- data streaming 은 어떻게 동작할까?
batch vs streaming, Kafka / Kinesis / Pub-Sub, windowing (tumbling / sliding / session), late event 의 watermark, exactly-once semantics — 왜 어려운가, Flink / Kafka Streams 의 stream-table duality.
약 10분
- Change Data Capture (CDC) 는 어떻게 동작할까?
log-based (MySQL binlog, Postgres WAL) vs trigger-based vs polling, de-facto OSS CDC Debezium, dual write 보다 CDC 가 일관성 우위인 이유, outbox 패턴과의 관계, downstream 패턴 (검색 인덱스 동기 · 캐시 무효 · 분석).
약 9분
- data lake 은 어떻게 동작할까?
data warehouse vs data lake vs lakehouse, S3 / GCS + Parquet columnar 포맷, lake 에 ACID 가져온 open table format (Iceberg / Delta / Hudi), schema-on-read 유연성과 swamp 리스크, Trino / Spark / DuckDB 가 query 하는 방법.
약 10분
- dimensional modeling 은 어떻게 동작할까?
Kimball star schema, fact vs dimension table, grain (가장 중요한 결정), slowly changing dimension (SCD type 1-6), snowflake vs star, dbt + ELT 가 2020+ dimensional modeling 을 부활시킨 이유.
약 9분
- ML training pipeline 은 어떻게 동작할까?
data ingestion → feature engineering → train → evaluate → register → deploy, notebook 가 production 으로 scale 안 되는 이유, MLflow / Kubeflow / SageMaker / Vertex AI, reproducibility (seed, deterministic ops), experiment tracking 문제.
약 10분
- feature store 는 어떻게 동작할까?
online (low-latency) vs offline (batch) feature serving, point-in-time correctness (training 시 time-travel 문제), Feast / Tecton / Databricks Feature Store, training-serving skew, feature store 가 라이브러리 아닌 infrastructure 인 이유.
약 9분
- model serving 은 어떻게 동작할까?
TF Serving / TorchServe / Triton / vLLM, throughput 위한 dynamic batching, GPU vs CPU trade-off, quantization (FP16 / INT8) 의 accuracy 비용, blue-green / canary / shadow deploy, LLM serving 이 별개 영역인 이유.
약 10분
- A/B testing 은 어떻게 동작할까?
randomization (마법), 'peeking' 이 p-value 를 무효로 만드는 이유, sample size 계획, 조기 종료 위한 sequential testing, explore/exploit 대안의 multi-armed bandit, network effect / cross-experiment contamination 함정.
약 10분
- RAG (Retrieval-Augmented Generation) 는 어떻게 동작할까?
embedding + vector DB (Pinecone / Weaviate / pgvector), chunking 전략과 naive split 의 실패, hybrid search (BM25 + vector), re-ranking, evaluation 문제, 대부분의 knowledge task 에서 RAG 가 fine-tuning 보다 나은 이유.
약 11분
- load balancer 는 어떻게 동작할까?
L4 vs L7, round-robin / least-connections / IP hash / weighted 알고리즘의 실제 차이, health check, sticky session(session affinity), 그리고 load balancer 자신이 active-passive · anycast 로 고가용성을 유지하는 방식.
약 10분
- distributed lock 은 어떻게 동작할까?
왜 필요한가(race condition), Redis Redlock, ZooKeeper / etcd 의 lease · ephemeral node 기반 lock, fencing token, 그리고 순진한 구현을 전부 깨뜨리는 함정 — clock skew, GC pause, network partition.
약 10분
- pagination 은 어떻게 동작할까?
offset/limit vs cursor(keyset) pagination, deep offset 가 왜 치명적으로 느려지나, shifting · duplicate row 의 일관성 문제, 그리고 opaque cursor 로 깔끔한 API 를 설계하는 법.
약 10분
- multi-region 아키텍처는 어떻게 동작할까?
active-passive vs active-active, 동기 vs 비동기 복제와 write 충돌, 지리적 latency, DNS·health check 기반 failover, split-brain, data residency — region 을 넘나드는 운영의 실제 trade-off.
약 10분
- feature flag 는 어떻게 동작할까?
flag 유형(release · ops/kill-switch · experiment · permission), 점진 rollout(% · ring), A/B 테스트 연계, flag 부채와 정리, 서버 vs 클라 평가와 일관성 함정.
약 10분
- REST 는 어떻게 동작할까?
Roy Fielding 이 원래 정의한 REST — resource·representation·stateless·uniform interface, Richardson Maturity level 0-3, HATEOAS, 그리고 'REST' 라고 불리는 대부분의 API 가 사실 'HTTP 위의 JSON' 일 뿐인 이유.
약 9분
- gRPC 는 어떻게 동작할까?
gRPC 의 동작 원리 — HTTP/2 multiplexing, protobuf wire format, 4 가지 RPC 모드(unary·server·client·bidirectional streaming), 코드 생성, 내부 서비스에서 REST 를 이기는 이유, 그리고 브라우저는 왜 여전히 gRPC-Web 이 필요한가.
약 9분
- Server-Sent Events 는 어떻게 동작할까?
text/event-stream 프로토콜, EventSource API, Last-Event-ID 기반 자동 재연결, WebSocket 대비 SSE 가 이기는 지점, 그리고 실전 한계 (단방향, 브라우저 연결 수 제한, proxy buffering).
약 9분
- API 버저닝은 어떻게 동작할까?
버전을 어디에 두나 (URL / header / Accept media type / query), SemVer + 호환 정책, Sunset header 를 쓴 디프리케이션 절차, breaking change 회피 방법, Stripe · GitHub · AWS 가 실제로 운영하는 방식.
약 10분