COMPLETE SYSTEM DESIGN ROADMAP
│
├── 1. 프로그래밍 기초 (Programming Foundations)
│ ├── 자료 구조 및 알고리즘 (Data Structures & Algorithms)
│ ├── 배열 및 연결 리스트 (Arrays & Linked Lists)
│ ├── 스택 및 큐 (Stacks & Queues)
│ ├── 해시 테이블 (Hash Tables)
│ ├── 트리 및 그래프 (Trees & Graphs)
│ ├── 정렬 및 검색 (Sorting & Searching)
│ ├── 시간 및 공간 복잡도 (Time & Space Complexity)
│ ├── 객체 지향 프로그래밍 (Object-Oriented Programming)
│ ├── 동시성 및 병렬성 (Concurrency & Parallelism)
│ ├── Python / Java / Go / C++
│ ├── Git & GitHub
│ └── Linux 및 명령어 줄 (Linux & Command Line)
│
├── 2. 네트워킹 기초 (Networking Fundamentals)
│ ├── OSI 및 TCP/IP 모델 (OSI & TCP/IP Models)
│ ├── HTTP 및 HTTPS (HTTP & HTTPS)
│ ├── DNS 해석 (DNS Resolution)
│ ├── TCP 대 UDP (TCP vs UDP)
│ ├── IP 주소 지정 및 서브넷팅 (IP Addressing & Subnetting)
│ ├── 포트 및 프로토콜 (Ports & Protocols)
│ ├── TLS/SSL
│ ├── WebSockets
│ ├── 네트워크 라우팅 (Network Routing)
│ ├── 프록시 및 리버스 프록시 (Proxies & Reverse Proxies)
│ ├── 방화벽 (Firewalls)
│ └── 네트워크 문제 해결 (Network Troubleshooting)
│
├── 3. 운영 체제 및 컴퓨터 아키텍처 (Operating Systems & Computer Architecture)
│ ├── 운영 체제 기본 (Operating System Fundamentals)
│ ├── 프로세스 및 스레드 (Processes & Threads)
│ ├── 컨텍스트 스위칭 (Context Switching)
│ ├── CPU 스케줄링 (CPU Scheduling)
│ ├── 메모리 관리 (Memory Management)
│ ├── 가상 메모리 (Virtual Memory)
│ ├── 뮤텍스 및 세마포어 (Mutexes & Semaphores)
│ ├── 경쟁 조건 (Race Conditions)
│ ├── 교착 상태 (Deadlocks)
│ ├── 파일 시스템 (File Systems)
│ ├── I/O 작업 (I/O Operations)
│ └── CPU, RAM 및 디스크 아키텍처 (CPU, RAM & Disk Architecture)
│
├── 4. 핵심 시스템 설계 개념 (Core System Design Concepts)
│ ├── 시스템 설계란 무엇인가? (What Is System Design?)
│ ├── 고수준 설계 (High-Level Design, HLD)
│ ├── 저수준 설계 (Low-Level Design, LLD)
│ ├── 기능적 요구 사항 (Functional Requirements)
│ ├── 비기능적 요구 사항 (Non-Functional Requirements)
│ ├── 확장성 (Scalability)
│ ├── 가용성 (Availability)
│ ├── 신뢰성 (Reliability)
│ ├── 유지보수성 (Maintainability)
│ ├── 내결함성 (Fault Tolerance)
│ ├── 성능 (Performance)
│ ├── 복원력 (Resilience)
│ └── 트레이드오프 분석 (Trade-Off Analysis)
│
├── 5. 용량 계획 및 추정 (Capacity Planning & Estimation)
│ ├── 대략적인 계산 (Back-of-the-Envelope Calculations)
│ ├── 트래픽 추정 (Traffic Estimation)
│ ├── 초당 요청 수 (Requests Per Second, RPS)
│ ├── 동시 사용자 수 (Concurrent Users)
│ ├── 스토리지 추정 (Storage Estimation)
│ ├── 대역폭 추정 (Bandwidth Estimation)
│ ├── 읽기 대 쓰기 비율 (Read-to-Write Ratios)
│ ├── 지연 시간 예산 (Latency Budgets)
│ ├── 최대 트래픽 추정 (Peak Traffic Estimation)
│ ├── 인프라 비용 추정 (Infrastructure Cost Estimation)
│ └── 성장 예측 (Growth Forecasting)
│
├── 6.
Architecture & Design Patterns
│ ├── 모놀리식 아키텍처 (Monolithic Architecture)
│ ├── 마이크로서비스 아키텍처 (Microservices Architecture)
│ ├── 서비스 지향 아키텍처 (Service-Oriented Architecture, SOA)
│ ├── 이벤트 기반 아키텍처 (Event-Driven Architecture)
│ ├── 서버리스 아키텍처 (Serverless Architecture)
│ ├── 계층형 아키텍처 (Layered Architecture)
│ ├── 육각형 아키텍처 (Hexagonal Architecture)
│ ├── 클린 아키텍처 (Clean Architecture)
│ ├── 모듈식 모놀리스 (Modular Monoliths)
│ ├── CQRS
│ ├── 이벤트 소싱 (Event Sourcing)
│ ├── 사가 패턴 (Saga Pattern)
│ ├── 스트랭글러 패턴 (Strangler Pattern)
│ └── API 게이트웨이 패턴 (API Gateway Pattern)
│
├── 7. API 설계 및 통신 (API Design & Communication)
│ ├── REST API 설계
│ ├── GraphQL
│ ├── gRPC
│ ├── WebSockets
│ ├── 서버 전송 이벤트 (Server-Sent Events, SSE)
│ ├── API 버전 관리 (Versioning)
│ ├── 인증 및 권한 부여 (Authentication & Authorization)
│ ├── OAuth 2.0 및 OpenID Connect
│ ├── JWT
│ ├── 속도 제한 (Rate Limiting)
│ ├── 페이지네이션 (Pagination)
│ ├── 멱등성 (Idempotency)
│ ├── API 문서화 (Documentation)
│ └── API 보안 (Security)
│
├── 8. 로드 밸런싱 및 트래픽 관리 (Load Balancing & Traffic Management)
│ ├── 로드 밸런서 기본 원리 (Load Balancer Fundamentals)
│ ├── L4 대 L7 비교 (Layer 4 vs Layer 7)
│ ├── 리버스 프록시 (Reverse Proxies)
│ ├── 라운드 로빈 (Round Robin)
│ ├── 최소 연결 (Least Connections)
│ ├── IP 해싱 (IP Hashing)
│ ├── 일관성 해싱 (Consistent Hashing)
│ ├── 헬스 체크 (Health Checks)
│ ├── 스티키 세션 (Sticky Sessions)
│ ├── 글로벌 로드 밸런싱 (Global Load Balancing)
│ ├── DNS 기반 라우팅 (DNS-Based Routing)
│ ├── 트래픽 쉐이핑 (Traffic Shaping)
│ └── CDN 통합 (CDN Integration)
│
├── 9. 데이터베이스 설계 및 관리 (Database Design & Management)
│ ├── 관계형 데이터베이스 (Relational Databases)
│ │ ├── PostgreSQL
│ │ ├── MySQL
│ │ ├── SQL 쿼리 (SQL Queries)
│ │ ├── 조인 및 인덱스 (Joins & Indexes)
│ │ ├── 트랜잭션 (Transactions)
│ │ └── ACID 속성 (ACID Properties)
│ ├── NoSQL 데이터베이스 (NoSQL Databases)
│ │ ├── MongoDB
│ │ ├── Cassandra
│ │ ├── DynamoDB
│ │ ├── Redis
│ │ └── Neo4j
│ ├── 데이터베이스 정규화 (Database Normalization)
│ ├── 데이터베이스 비정규화 (Database Denormalization)
│ ├── 스키마 설계 (Schema Design)
│ ├── 쿼리 최적화 (Query Optimization)
│ ├── 커넥션 풀링 (Connection Pooling)
│ └── 데이터베이스 마이그레이션 (Migrations)
│
├── 10.
Database Scaling & Distributed Data
│ ├── 수직 확장 (Vertical Scaling)
│ ├── 수평 확장 (Horizontal Scaling)
│ ├── 데이터베이스 복제 (Database Replication)
│ ├── Primary-Replica 아키텍처
│ ├── Read Replica
│ ├── 데이터베이스 샤딩 (Database Sharding)
│ ├── 파티셔닝 (Partitioning)
│ ├── 일관성 해싱 (Consistent Hashing)
│ ├── 분산 트랜잭션 (Distributed Transactions)
│ ├── 멀티 리전 데이터베이스 (Multi-Region Databases)
│ ├── 변경 데이터 캡처 (Change Data Capture, CDC)
│ ├── 데이터 일관성 (Data Consistency)
│ └── 데이터베이스 장애 조치 (Database Failover)
├── 11. 캐싱 아키텍처 (Caching Architecture)
│ ├── 캐시 기본 원리 (Cache Fundamentals)
│ ├── 클라이언트 측 캐싱 (Client-Side Caching)
│ ├── 브라우저 캐싱 (Browser Caching)
│ ├── CDN 캐싱 (CDN Caching)
│ ├── 애플리케이션 캐싱 (Application Caching)
│ ├── 데이터베이스 캐싱 (Database Caching)
│ ├── 분산 캐싱 (Distributed Caching)
│ ├── Redis 및 Memcached
│ ├── Cache-Aside 패턴
│ ├── Write-Through 캐싱
│ ├── Write-Back 캐싱
│ ├── Write-Around 캐싱
│ ├── 캐시 무효화 (Cache Invalidation)
│ ├── TTL 및 제거 정책 (TTL & Eviction Policies)
│ └── 캐시 스탬피드 방지 (Cache Stampede Prevention)
│
├── 12. 분산 시스템 기본 원리 (Distributed Systems Fundamentals)
│ ├── 분산 시스템 아키텍처 (Distributed System Architecture)
│ ├── CAP 정리 (CAP Theorem)
│ ├── PACELC 정리 (PACELC Theorem)
│ ├── 일관성 모델 (Consistency Models)
│ ├── 강한 일관성 (Strong Consistency)
│ ├── 최종적 일관성 (Eventual Consistency)
│ ├── 인과적 일관성 (Causal Consistency)
│ ├── 분산 합의 (Distributed Consensus)
│ ├── Raft 및 Paxos
│ ├── 리더 선출 (Leader Election)
│ ├── 분산 락 (Distributed Locks)
│ ├── 하트비트 (Heartbeats)
│ ├── 가십 프로토콜 (Gossip Protocol)
│ ├── 클럭 동기화 (Clock Synchronization)
│ ├── 쿼럼 (Quorums)
│ └── 스플릿 브레인 문제 (Split-Brain Problems)
│
├── 13. 메시지 큐 및 이벤트 스트리밍 (Message Queues & Event Streaming)
│ ├── 메시지 큐 기본 원리 (Message Queue Fundamentals)
│ ├── Apache Kafka
│ ├── RabbitMQ
│ ├── Redis Streams
│ ├── Amazon SQS
│ ├── Google Pub/Sub
│ ├── 프로듀서 및 컨슈머 (Producers & Consumers)
│ ├── 토픽 및 파티션 (Topics & Partitions)
│ ├── 이벤트 스트리밍 (Event Streaming)
│ ├── 메시지 순서 보장 (Message Ordering)
│ ├── 전송 보장 (Delivery Guarantees)
│ ├── 최대 한 번 전달 (At-Most-Once Delivery)
│ ├── 최소 한 번 전달 (At-Least-Once Delivery)
│ ├── 정확히 한 번 처리 의미론 (Exactly-Once Processing Semantics)
│ ├── 데드 레터 큐 (Dead Letter Queues)
│ └── 백프레셔 (Backpressure)
│
├── 14.
확장성 및 성능 엔지니어링 (Scalability & Performance Engineering)
│ ├── 수직 및 수평 확장 (Vertical & Horizontal Scaling)
│ ├── 무상태 아키텍처 (Stateless Architecture)
│ ├── 데이터베이스 최적화 (Database Optimization)
│ ├── 쿼리 성능 (Query Performance)
│ ├── 비동기 처리 (Asynchronous Processing)
│ ├── 병렬 처리 (Parallel Processing)
│ ├── 커넥션 풀링 (Connection Pooling)
│ ├── 리소스 최적화 (Resource Optimization)
│ ├── 지연 시간(Latency) 최적화
│ ├── 처리량(Throughput) 최적화
│ ├── 병목 현상 식별 (Bottleneck Identification)
│ ├── 부하 테스트 (Load Testing)
│ ├── 스트레스 테스트 (Stress Testing)
│ └── 성능 프로파일링 (Performance Profiling)
│
├── 15. 신뢰성 및 장애 허용 (Reliability & Fault Tolerance)
│ ├── 고가용성 (High Availability)
│ ├── 장애 허용성 (Fault Tolerance)
│ ├── 이중화 (Redundancy)
│ ├── 복제 (Replication)
│ ├── 페일오버 전략 (Failover Strategies)
│ ├── 서킷 브레이커 패턴 (Circuit Breaker Pattern)
│ ├── 재시도 및 백오프 전략 (Retry & Backoff Strategies)
│ ├── 벌크헤드 패턴 (Bulkhead Pattern)
│ ├── 타임아웃 관리 (Timeout Management)
│ ├── 우아한 저하 (Graceful Degradation)
│ ├── 재해 복구 (Disaster Recovery, DR)
│ ├── 백업 및 복원 (Backup & Restore)
│ ├── 복구 시간 목표 (Recovery Time Objective, RTO)
│ ├── 복구 지점 목표 (Recovery Point Objective, RPO)
│ └── 카오스 엔지니어링 (Chaos Engineering)
│
├── 16. 보안 및 개인정보 아키텍처 (Security & Privacy Architecture)
│ ├── 인증 (Authentication)
│ ├── 권한 부여 (Authorization)
│ ├── 역할 기반 접근 제어 (Role-Based Access Control, RBAC)
│ ├── 속성 기반 접근 제어 (Attribute-Based Access Control, ABAC)
│ ├── 저장 데이터 암호화 (Encryption at Rest)
│ ├── 전송 중 데이터 암호화 (Encryption in Transit)
│ ├── TLS 및 인증서 관리 (TLS & Certificate Management)
│ ├── 비밀 정보 관리 (Secrets Management)
│ ├── API 보안 (API Security)
│ ├── SQL 인젝션 방지 (SQL Injection Prevention)
│ ├── XSS 및 CSRF 보호 (XSS & CSRF Protection)
│ ├── 제로 트러스트 아키텍처 (Zero Trust Architecture)
│ ├── 네트워크 분할 (Network Segmentation)
│ ├── 감사 로깅 (Audit Logging)
│ └── 데이터 개인정보 보호 및 규정 준수 (Data Privacy & Compliance)
│
├── 17. 클라우드 및 인프라 아키텍처 (Cloud & Infrastructure Architecture)
│ ├── AWS
│ │ ├── EC2
│ │ ├── S3
│ │ ├── RDS
│ │ ├── DynamoDB
│ │ ├── Lambda
│ │ └── CloudFront
│ ├── Google Cloud Platform (GCP)
│ ├── Microsoft Azure
│ ├── Docker
│ ├── Kubernetes
│ ├── 컨테이너 오케스트레이션 (Container Orchestration)
│ ├── 서버리스 컴퓨팅 (Serverless Computing)
│ ├── 코드로 인프라 구축 (Infrastructure as Code, IaC)
│ ├── Terraform
│ ├── Ansible
│ ├── 멀티 클라우드 아키텍처 (Multi-Cloud Architecture)
│ └── 다중 리전 배포 (Multi-Region Deployment)
│
├── 18.
Microservices & Service Communication
│ ├── 마이크로서비스 경계 (Microservice Boundaries)
│ ├── 서비스 디스커버리 (Service Discovery)
│ ├── API 게이트웨이 (API Gateway)
│ ├── 서비스 메시 (Service Mesh)
│ ├── Istio 및 Linkerd
│ ├── 동기 통신 (Synchronous Communication)
│ ├── 비동기 통신 (Asynchronous Communication)
│ ├── 서비스 간 인증 (Service-to-Service Authentication)
│ ├── 분산 추적 (Distributed Tracing)
│ ├── 사가 오케스트레이션 (Saga Orchestration)
│ ├── 서비스 격리 (Service Isolation)
│ ├── 데이터 소유권 (Data Ownership)
│ └── 마이크로서비스 배포 (Microservices Deployment)
├── 19. 관측 가능성 및 모니터링 (Observability & Monitoring)
│ ├── 로그 (Logs)
│ ├── 메트릭 (Metrics)
│ ├── 분산 추적 (Distributed Tracing)
│ ├── OpenTelemetry
│ ├── Prometheus
│ ├── Grafana
│ ├── ELK 스택
│ ├── Jaeger
│ ├── 경고 및 알림 (Alerting & Notifications)
│ ├── 상태 확인 (Health Checks)
│ ├── 서비스 수준 지표 (SLIs, Service Level Indicators)
│ ├── 서비스 수준 목표 (SLOs, Service Level Objectives)
│ ├── 서비스 수준 협약 (SLAs, Service Level Agreements)
│ └── 인시던트 관리 (Incident Management)
├── 20. CI/CD 및 소프트웨어 배포 (CI/CD & Software Delivery)
│ ├── Git 워크플로우 (Git Workflows)
│ ├── 자동화 테스트 (Automated Testing)
│ ├── 지속적 통합 (Continuous Integration, CI)
│ ├── 지속적 배포 (Continuous Delivery, CD)
│ ├── GitHub Actions
│ ├── Jenkins
│ ├── GitLab CI/CD
│ ├── 블루-그린 배포 (Blue-Green Deployment)
│ ├── 카나리 배포 (Canary Deployment)
│ ├── 롤링 업데이트 (Rolling Updates)
│ ├── 기능 플래그 (Feature Flags)
│ ├── 롤백 전략 (Rollback Strategies)
│ └── 릴리스 관리 (Release Management)
├── 21. 현대 시스템 설계 및 AI 인프라 (Modern System Design & AI Infrastructure)
│ ├── AI 시스템 아키텍처 (AI System Architecture)
│ ├── LLM 애플리케이션 아키텍처 (LLM Application Architecture)
│ ├── 모델 서빙 인프라 (Model Serving Infrastructure)
│ ├── GPU 및 가속기 스케줄링 (GPU & Accelerator Scheduling)
│ ├── 벡터 데이터베이스 (Vector Databases)
│ ├── 임베딩 파이프라인 (Embedding Pipelines)
│ ├── 검색 증강 생성 (RAG, Retrieval-Augmented Generation)
│ ├── 시맨틱 검색 아키텍처 (Semantic Search Architecture)
│ ├── AI 에이전트 아키텍처 (AI Agent Architecture)
│ ├── 다중 에이전트 오케스트레이션 (Multi-Agent Orchestration)
│ ├── 모델 파인튜닝 인프라 (Model Fine-Tuning Infrastructure)
│ ├── 추론 최적화 (Inference Optimization)
│ ├── 모델 양자화 (Model Quantization)
│ ├── AI 관측 가능성 및 평가 (AI Observability & Evaluation)
│ ├── LLM 캐싱 (LLM Caching)
│ └── AI 보안 및 가드레일 (AI Security & Guardrails)
├── 22.
시스템 설계 사례 연구 (System Design Case Studies)
│ ├── URL 단축 서비스 (URL Shortener)
│ ├── 속도 제한기 (Rate Limiter)
│ ├── Pastebin
│ ├── 알림 시스템 (Notification System)
│ ├── 채팅 애플리케이션 (Chat Application)
│ ├── WhatsApp
│ ├── Slack
│ ├── Twitter / X
│ ├── Instagram
│ ├── Facebook 뉴스 피드 (Facebook News Feed)
│ ├── YouTube
│ ├── Netflix
│ ├── Spotify
│ ├── Uber
│ ├── 구글 지도 (Google Maps)
│ ├── 전자상거래 플랫폼 (E-Commerce Platform)
│ ├── 결제 처리 시스템 (Payment Processing System)
│ ├── 분산 파일 스토리지 (Distributed File Storage)
│ ├── 검색 엔진 (Search Engine)
│ ├── 비디오 스트리밍 플랫폼 (Video Streaming Platform)
│ ├── 차량 공유 플랫폼 (Ride-Sharing Platform)
│ ├── 음식 배달 플랫폼 (Food Delivery Platform)
│ ├── 분산 작업 스케줄러 (Distributed Job Scheduler)
│ ├── 실시간 분석 플랫폼 (Real-Time Analytics Platform)
│ ├── RAG 기반 AI 어시스턴트 (RAG-Based AI Assistant)
│ └── 다중 에이전트 AI 플랫폼 (Multi-Agent AI Platform)
├── 23. 저수준 설계 (Low-Level Design, LLD)
│ ├── SOLID 원칙 (SOLID Principles)
│ ├── 객체 지향 설계 (Object-Oriented Design)
│ ├── UML 클래스 다이어그램 (UML Class Diagrams)
│ ├── UML 시퀀스 다이어그램 (UML Sequence Diagrams)
│ ├── 디자인 패턴 (Design Patterns)
│ │ ├── 싱글톤 (Singleton)
│ │ ├── 팩토리 (Factory)
│ │ ├── 빌더 (Builder)
│ │ ├── 전략 (Strategy)
│ │ ├── 옵저버 (Observer)
│ │ ├── 어댑터 (Adapter)
│ │ ├── 데코레이터 (Decorator)
│ │ └── 리포지토리 (Repository)
│ ├── 의존성 주입 (Dependency Injection)
│ ├── 합성 vs 상속 (Composition vs Inheritance)
│ ├── 도메인 주도 설계 (Domain-Driven Design, DDD)
│ ├── 클린 코드 (Clean Code)
│ └── 테스트 가능한 아키텍처 (Testable Architecture)
└── 24. 시스템 설계 면접 준비 (System Design Interview Preparation)
├── 요구사항 수집 (Requirements Gathering)
├── 기능적 요구사항 (Functional Requirements)
├── 비기능적 요구사항 (Non-Functional Requirements)
├── API 설계 (API Design)
├── 데이터베이스 스키마 설계 (Database Schema Design)
├── 아키텍처 다이어그램 (Architecture Diagrams)
├── 용량 추정 (Capacity Estimation)
├── 컴포넌트 선택 (Component Selection)
├── 병목 현상 분석 (Bottleneck Analysis)
├── 확장성 트레이드오프 (Scalability Trade-Offs)
├── 장애 시나리오 (Failure Scenarios)
├── 보안 고려 사항 (Security Considerations)
├── 비용 최적화 (Cost Optimization)
├── 커뮤니케이션 및 기술 설명 (Communication & Technical Explanation)
├── 모의 시스템 설계 면접 (Mock System Design Interviews)
└── 엔드투엔드 아키텍처 검토 (End-to-End Architecture Reviews)
최종 목표 (FINAL GOAL):
수천만 명의 사용자에게 안정적으로 서비스를 제공하는 분산 시스템을 설계하고, 확장하며, 보안하고, 최적화하며 운영할 수 있는 전문가급 시스템 설계 엔지니어가 되는 것.