전체 코스

IT Foundations

Whether you studied computer science or not, the place you get stuck at work is usually where a foundation has a hole in it. This path walks computer architecture, operating systems, networking, and databases in turn and fills those holes. By the end you can narrow an incident down to which layer and which problem on your own.

Computer Architecture — What it takes for a CPU to execute one line
Operating Systems — How many people share one machine
Networking Fundamentals — Where to look first when a connection fails
Database Concepts — Tables, indexes, transactions — on a real PostgreSQL

Linux & Terminal Mastery

Builds the ability to narrow a problem all the way down on a server where only the terminal is left. You start with files, permissions and processes, then work by hand through shell scripting, vim and tmux, disk, memory, file-descriptor and load incidents, and name resolution and socket diagnosis. By the end you can explain in a few commands why df shows free space you cannot use, and why load is 24 while the CPU sits idle.

Linux Fundamentals — It is fine if this is your first terminal.
Shell Scripting — Not a throwaway script — one you would put on a server.
vim and tmux — Without a mouse you actually get faster.
Linux Incident Response — df shows free space, so why can you not write.
Linux Network Diagnosis — Is the name not resolving, the connection not opening, or the server just slow.

Container Mastery

Four courses that climb from running your first container to namespaces and cgroups and the OCI image format. Instead of memorising commands, you narrow a cause from a single exit code, point at the one line that broke the cache, and prove with inspect what got baked into an image. By the end you can review someone else's Dockerfile in three minutes. Least-privilege images continue in the Security path.

Docker Fundamentals — A first course for people running their first container.
Building Images — Slow builds are usually about ordering, not caching.
Volumes, Networks and Compose — One container does not make a service.
Container Internals — There is no such thing as a container in the kernel.

Kubestronaut — Five Kubernetes Certifications

CNCF Kubestronaut is the title you earn by holding all five of KCNA, KCSA, CKA, CKAD and CKS. This path starts at concepts (KCNA) and works by hand through operations (CKA), development (CKAD), security fundamentals (KCSA) and security practice (CKS) on a real cluster. By the end you can look at a manifest and say what is wrong with it in three minutes.

KCNA — Kubernetes and Cloud Native Associate — Pin down the vocabulary, then open a cluster by hand
CKA — Kubernetes Administrator — Build the hands that repair a cluster.
CKAD — Kubernetes Application Developer — Write manifests by hand and get graded on the spot
KCSA — Kubernetes Security Associate — Look at the cluster again through an attacker's eyes
CKS — Kubernetes Security Specialist — Build the hands that actually lock a cluster down.

Golden Kubestronaut

Continue beyond Kubestronaut with observability (PCA, OTCA), networking (ICA, CCA), delivery (CAPA, CGOA), policy (KCA), platforms (CNPA, CBA, CNPE) and Linux (LFCS). Prepare through readings, quizzes and exercises; completing a course does not award official certification or guarantee an exam pass. Initial Golden Kubestronaut recognition requires valid certifications designated by CNCF and LFCS. Check the official list and effective dates when planning your exams.

PCA — Prometheus Certified Associate — From the questions metrics answer to real PromQL judgement
OTCA — OpenTelemetry Certified Associate — The four places propagation breaks, and the collector pipeline
ICA — Istio Certified Associate — A VirtualService on its own does nothing.
CCA — Cilium Certified Associate — Delete iptables and put policy in the kernel.
CAPA — Argo Project Associate — Assemble all four Argo projects by hand.
CGOA — GitOps Certified Associate — If Git is the truth, the cluster follows
KCA — Kyverno Certified Associate — Write policy that does not stop the cluster.
CNPA — Cloud Native Platform Engineering Associate — How to build a platform like a product
CBA — Backstage Associate — How many services do we have, and who owns them
LFCS — Linux Foundation System Administrator — Prove by hand the Linux underneath Kubernetes
CNPE — Cloud Native Platform Engineer — The judgement to design a platform and to defend it

Cloud Foundations

Plenty of curricula go deep on Kubernetes and Linux while leaving the cloud underneath blank. This path fills that gap. You start with regions and the shared responsibility model, read IAM policy documents yourself, split CIDR blocks by hand, and finish by comparing two architectures through their pricing models. Because it deals in the reasons behind a decision rather than where the console buttons are, it sticks whether you learn on AWS or Azure. By the end you can argue in an architecture review in terms of what you pay and what you get.

Cloud Fundamentals — Regions, shared responsibility, managed services — where the bill starts making sense.
Cloud Permission Design — Learn least privilege in your hands by writing policy documents yourself.
Cloud Network Design — Split CIDR by hand and narrow "it doesn't work" down by layer.
Cost and Architectural Decisions — Read the bill, then argue your design with those numbers.

Cloud-Native Architecture

Build by hand the pieces you need the moment you split one service in two. Six courses: service-to-service communication and resilience, queues and asynchronous APIs, Redis caching and live leaderboards, S3 and SeaweedFS, order events flowing through Kafka, and Raft consensus down to the moment there are two leaders. By the end you can argue in an architecture review in terms of what you pay and what you get.

Microservice Architecture — How not to split, before how to split.
Queues and Asynchronous APIs — Slow work, later and safely.
Redis and Caching — Leaderboards with ZSet; caches, carefully.
Object Storage and S3 — Thinking in objects rather than files.
The order arrived twice, and once it vanished — Reproduce and stop duplicates and loss on a single-node KRaft broker
There Were Two Leaders — Feel terms, quorum and partitions with your own hands

Infrastructure Automation — Ansible and Terraform

Move the commands you typed on servers into playbooks, and the clicks you made in consoles into declarations. Build idempotent configuration with Ansible and fold it into roles, then read state and plans with Terraform (OpenTofu) and scale out with modules and workspaces. By the end, an infrastructure change is a reviewable piece of code.

Ansible Fundamentals — Stop SSHing into servers by hand.
Ansible in Practice — Fold your copy-pasted playbooks into roles.
Terraform/OpenTofu Fundamentals — Declare it, manage it as state, read the plan.
Terraform in Practice — Handle modules, state and drift by hand.
Building clusters with Kubespray and Terraform — Stand up Kubernetes on one VM with Kubespray, then wire it up with Terraform

Kubernetes Platform

One step beyond using Kubernetes: build the platform that lets many teams ship the same way. Start with day-to-day cluster operations and a comparison of distributions, then write Helm charts and roll releases back, extend the API with CRDs and operators, handle the paths between services with Istio, and converge on declared state with Argo CD. Ansible and Terraform live in the Infrastructure Automation path.

Kubernetes Operations — Only the things that page you at 3am.
Kubernetes Distributions — Build Them Yourself — Stand up k3s and k0s, then restore etcd
Authoring and Shipping Helm Charts — Write a chart yourself and roll back by revision.
Helm Deployment and Rollback Scenarios — It is only a deployment if you can undo it — on a real cluster
CRDs and Operators — Add your own type to the Kubernetes API.
Istio Service Mesh — Take traffic and security out of your code.
GitOps and Argo CD — Finish a deployment with one commit.

System Administrator

Work by hand through what happens in front of a server every day. Install packages, connect with a key and move files, write one fstab line exactly right, handle RAID, LVM and iSCSI by the procedure, work with qcow2 images and rootless containers, and finish a backup with a restore rehearsal. At the end you calculate, in numbers, when to order more capacity and when to stop a change.

Package Management — What happens behind one install command.
SSH and File Transfer — Connect with a key, move files safely, dig a tunnel.
Storage and Mounts — One fstab line saves or kills your boot.
Storage in Practice — RAID, Snapshots, iSCSI, fio — Keep the data when a disk dies or a change goes wrong
Virtualisation with QEMU/KVM — A qcow2 backing chain is what makes a golden image.
Running Rootless Podman — No daemon, no root, still containers.
Backup and Restore — Without a restore rehearsal it is not a backup.
Capacity Planning and Change Management — Calculate When It Fills, Write Down When to Stop — Order-by dates, abort times, measured RPO and RTO
RHEL-Family Administration — dnf, rpm, createrepo — and unit files.

Air-Gapped Infrastructure

Make installation work where the internet is blocked. Stand up in-house mirrors and a private CA for pip, npm, Maven, Go and dnf, carry GPU drivers and CUDA in and install them, schedule jobs with Slurm, and on Kubernetes manage everything from drivers to metrics with the GPU Operator. This is the order of your first week when you take over servers at a public-sector, finance or research site.

Air-Gapped Mirrors and a Private CA — The fetching side and the using side: internal mirrors and trust stores.
Air-Gapped GPU Driver Installation — A transfer procedure you finish in one USB trip.
HPC and Slurm — How several people share eight GPUs.
GPU Operator and Time-Slicing — Starts from the incident that made four GPUs unusable at once.

Advanced Networking

From fundamentals like addresses and gateways, through the hairpin NAT you will certainly hit when you open a server at home, to Envoy — the thing a service mesh actually is — and Istio above it.

Addresses, Subnets and Gateways — Why classes A, B and C disappeared, and what replaced them
Network Fundamentals — Hands-on in a Linux VM — Touch ARP, routing, DNS, TCP, firewalls and NAT with netns and tcpdump
Network Troubleshooting — Break a report of "it doesn't work" into layers.
Kubernetes Networking — On a Real Cluster — Count for yourself how a name resolves and what a policy blocks
Envoy Internals — In the end this proxy is what handles a service mesh's traffic
Istio Deep Dive — Why It Flows That Way — A VirtualService on its own does nothing
The certificate was renewed, but the browser still showed the old one — Reproduce DNS caching and TLS certificates by hand inside a pod
Sessions and Tokens — From the Browser to the Mesh — What flows after login, and where it breaks.
Istio Field Lab — Measure gateways, ambient mode and upgrades on a real mesh

Sockets and Real-Time Systems

Implement byte boundaries and connection lifecycles, reproduce failures, and learn the foundations of real-time applications.

My TCP Parcel Arrived in Pieces — Reconstruct messages from fragments of bytes
One Slow Subscriber Froze the Livestream — Isolate one stalled subscriber and keep the rest moving
The snack machine died before ACK — Reconnect without counting stock twice
One Slow Connection Froze Every Other One — Watch hundreds of connections from one loop
Real-Time Communication — WebSocket, gRPC Streaming and WebRTC — From HTTP/2 to WebRTC, built and measured over real connections

SRE / DevOps Engineer

Six courses — pipelines, GitLab CI, IaC, observability, Git, and load testing — on the craft that makes deployment routine rather than an event. You handle mechanisms rather than tool names: why a gate must speak in exit codes, what the three symbols in a plan mean, where the burn rate 14.4 comes from. By the end you can look at an alert that fired at 3am and decide what to do now.

CI/CD Pipelines — Build the mechanics of a pipeline in shell, without Jenkins
GitLab CI/CD — Face the configuration language and execution model head-on, with no runner
Infrastructure as Code — Declarative, idempotent, stateful — the principles before the tool
Observability — Run PromQL, SLOs and alerts on a real Prometheus
Git in Practice — Stop being afraid of undo and rebase
Load Testing — Training to look at the tail instead of the average

Advanced Observability & Logging

What to attach as a sidecar, where to cut your logs, where a trace breaks, and which question separates Loki from OpenSearch. Design judgement rather than tool usage.

SLOs — Deciding How Much Breakage Is Allowed — 99.9% is 43 minutes a month
Sidecars and Multi-Container Patterns — Why you would put two containers in one pod
Designing a Log Pipeline — Collecting is easy; finding it later is not
Where Distributed Tracing Breaks — The sidecar makes spans and the chain still breaks
Loki — A Log Store That Does Not Index Logs — The decision to index only labels changes everything
Grafana Dashboards — Adding graphs and getting answers pull in opposite directions

Systems Detective

Reproduce failures in an isolated lab and narrow down their causes. Compare status indicators with real requests to practice debugging and operations.

Diagnosing CPU and Memory Leaks — What to check before you trust the numbers in top
Break Kubernetes — My YAML Did It — Find the failure hiding behind green status
I Break It — A Chaos Lab Where the Hypothesis Comes First — Write down what will happen before you break it
The Logs Came From the Future — Five Incidents a Clock Made — A timestamp is a claim, not evidence

Security

The security courses that were scattered across the catalog, gathered on one shelf. Run containers with least privilege, verify where images come from and who signed them, attach identity with Keycloak, set guardrails with a policy engine, and write detection rules from audit logs. The Kubernetes security certifications (KCSA, CKS) live in the Kubestronaut path.

Container Security — Start by breaking the belief that isolation makes it safe.
The Build Was Green — So Who Put That Library In? — Prove an artifact with its inventory, signature and provenance
Keycloak and Enterprise Identity — The protocol behind one login button.
Policy as Code — Carve the rules into the cluster, not into a document.
Cron Ran curl at Three in the Morning — Write detection rules, then run the response playbook

Data Engineering

Start from pipelines that stay safe when they fail, and learn to judge by the numbers the engines leave behind — Spark and Hadoop execution plans, Iceberg table snapshots, Flink state and checkpoints, and ClickHouse's storage layout. By the end, when someone reports that the data looks wrong, you can narrow down with numbers which stage went astray.

Data Pipelines — Fail, rerun, and the result must be the same
Apache Spark — The answer to a slow job is in the plan and the event log — Measure shuffles, joins and skew in local-mode Spark with the event log
Apache Hadoop — Stand up and run HDFS and YARN in one pod — Blocks, permissions, quotas and MapReduce by hand on pseudo-distributed HDFS and YARN
Lakehouse Table Format — Understanding Apache Iceberg Through Its Metadata — Verify snapshots, schema and partition evolution, MERGE and maintenance in the metadata
Apache Flink — Running Streams on a Real Engine — Verify watermarks, state and checkpoints from the engine's own output
ClickHouse — A Columnar Analytics Database from the Inside — Read sort keys, parts and merges through the numbers in system tables

LLM Applications — Retrieval, Agents, Voice

Build and measure the parts of an LLM application yourself. Start with tokens and retrieval, attach tools with agents and an MCP server, and finally wire up a voice assistant that listens, finds the answer and speaks. Model internals and serving costs live in the LLM Models and Serving path.

LLM Engineering — From the tokeniser to RAG evaluation, from the ground up
AI Agents — A Graph, Not a Model — Stop conditions, failure paths, traces. Where a demo and a product part ways
The agent dropped my database — Write an MCP server with the standard library and guard it three ways
Voice AI Agents — a pipeline that listens, looks things up and speaks — Wire listening through speaking in a single CPU pod and measure the latency

LLM Models and Serving

Step past calling a model and open it up. Write a transformer yourself, train a small language model from scratch, cut costs with batching, the KV cache and quantization in serving engines, and make models reproducible with experiment tracking.

Transformers — Compute Attention By Hand — Confirm with numbers why you divide by √d
MiniMind — Train a Small Language Model Yourself, End to End — Bake a small model from tokenizer to DPO on two CPUs
LLM Serving — Learn the machinery of serving without a model.
The AI Diet Gone Wrong — Build a real INT8 model and measure accuracy and performance
Last Week Had a Better Model. Nobody Can Find It — Build the run ledger, registry and promotion gate by hand

Database Operations

Writing good queries and operating a database are different jobs. You stand up replication, actually promote a replica, and watch the timeline diverge with your own eyes. Then you diagnose a database that is still up but has gone wrong.

SQL in Practice — From SELECT to the execution plan, all run by hand
PostgreSQL Replication and Promotion — Stand up a standby, then actually promote it
Backup — Bring Deleted Data Back — A backup you have never restored is not a backup
Schema Changes That Do Not Stop the Service — One migration line can queue up every request
PostgreSQL Incident Response — Diagnose a database that is up but behaving strangely
MongoDB — The Judgement Behind Document Databases — Not query syntax, but how far to embed

Backend Engineering

Read a job posting sentence by sentence to decide what to prepare first, build the missing pieces of a server yourself in Node.js and FastAPI, relearn the CS a service relies on by measuring it, then work through idempotency, locking and gRPC contracts until, against a real PostgreSQL and a real HTTP boundary, data integrity, authorization, observability and deployment come together as one backend system you can verify.

A Backend Roadmap Read From Job Postings — Decide what to do first, then start
Node.js Backend — What the Framework Hides — Build what Nest does without installing Nest
It Wasn't One Request - Everything Got Slow — One request blocks the loop; every request pays
FastAPI — Types Are the Contract — One misplaced async def stalls the whole server
CS for Building Good Services — Relearning Textbook Ideas by Measuring — Measure, then choose: data structures, concurrency, caches and clocks
Idempotency — Two Clicks, One Charge — You cannot stop the retry. You can only stop the duplicate
Concurrency — When Two People Touch One Row — Stock goes negative because of ordering, not code
I renumbered a field and the old client silently read the wrong value — Verify protobuf bytes and schema-evolution rules by hand
Production Backend API Capstone — From PostgreSQL and real HTTP to operational evidence, proven as one system

Developer Tools and Languages

Test tooling, Go and Rust, and operations tools. Not how to use them, but how each tool and language bends the shape of your code. Backend frameworks live in the Backend Engineering path.

Testing Tools in Practice — What 100% coverage does not guarantee
Building Servers in Go — Having no exceptions changes the shape of your code
Rust — What the Compiler Refuses — Use a borrowed value twice and the build says no
It failed, but the exit code was 0 — From Python script to ops tool — exit codes, retries, metrics, tests
Compilers — Build a Small Language from Start to Finish — From the lexer to x86-64, build a small language yourself

Advanced Frontend

Why state libraries insist on immutability, how streaming actually breaks, how the browser reads HTML, how the cascade is computed. Not above the API surface — beneath it.

HTML — One Tag Stands In For a Feature — Why a button made from a div is not a button
CSS — The Later Rule Wins — The real reason you end up reaching for !important
State Management — Build the Library Yourself — Why every one of them insists on immutability
I searched for a whale, but got a cat — Fix React search races and build a view for 10,000 results
SSE — How the Server Speaks First — It works, so why does it all appear at once
SSR — The Server Draws First — When the server and the client produce different HTML

Korean SI in Practice

Covers, in order, what a new hire meets in the first week on a Korean SI/SM project. You start with deliverables like requirement specifications and cutover checklists, then work by hand on real servers through Tomcat and nginx operations, LDAP and SSO integration, system-to-system interfaces, and database migration. The bar is the things school does not teach but the job asks for on day one.

The SI Project Process — One full lap, from requirements to go-live and stabilisation
Tomcat & nginx Operations — Every setting you actually touch in front of and behind a WAS
nginx Incident Response — Cause the outage yourself, then name the culprit from the logs
Enterprise Authentication Integration — LDAP, SSO and DRM — the things already at the customer site
System Integration (EAI) — From the interface specification to reprocessing design
SI Database Operations — Standards, change control, tuning and migration — by hand
Spring Boot — Count How Many Queries Go Out — Why @Autowired does not belong on a field
The heap had room, but the service stopped — Read JVM stalls with GC logs, thread dumps, pool exhaustion and heap dumps
Building an EAI Middleware Layer — From message headers, routing and mapping to MQ, external gateways and circuit breakers

FDE — Forward Deployed Engineer

A path for practising the Forward Deployed Engineer role that Palantir created and that OpenAI and Anthropic now compete to hire. You scout a customer system with no documentation and no dashboard, debug code somebody else wrote, clean dirty customer data, and reconstruct an incident timeline from logs alone. By the end, the first thirty minutes in an unfamiliar environment are already decided. Integration, change and delivery continue in the FDE in Practice path.

In Front of an Unfamiliar System — How to start when you know nothing at all.
Debugging in Practice — Fix code someone else wrote and left, working from symptoms alone.
Working With Customer Data — Real customer data does not look like sample data.
Finding the Cause in Logs — With no dashboard, logs are your only eyes.

FDE in Practice — Integrate, Change, Hand Off

The step after you can read an unfamiliar system. Integrate with the customer's APIs and design retries that are safe to rerun, ship your first change to someone else's production system, and finally prepare to leave with deliverables and handover documents.

Integration and Deployment — Connect it, defend it, explain it.
Irreversible Changes — The day hands that only ever read finally write.
FDE Capstone: The Warehouse Got the Same Order Three Times — From a customer's CSV to deduplicated reservations and handoff

Domain Knowledge — Banking · Capital Markets · Insurance · Defence

What an IT hire at a bank, an insurer or a defence site runs into in the first month is not technology but the language of the business. You work in turn through the bank's ledger and reconciliation, orders, fills and settlement in capital markets, insurance contracts and claims, and an air-gapped defence site where you cannot search, install or take anything out. When you finish you will follow the words the business side uses, and you will be able to check why their numbers come out the way they do.

The Language of Banking — Finding the cause is not enough if you cannot speak the domain.
Capital Markets and Settlement — Where milliseconds become incidents and ordering becomes money.
Insurance Domain Deep Dive — In week one at an insurer, what blocks you is the vocabulary, not the technology.
Air-Gapped Sites — Defence and Government — How to work where you cannot search, install, or take anything out.

Product & Startup

From validating a customer problem to product metrics, experiment statistics, pricing and unit economics, equity and fundraising — practice, on real data, the calls a developer makes when founding a company or taking on a new product.

Founding as a Developer — Validate Before You Build — Judge interviews, cohorts, A/B tests and unit economics with numbers

Electronics and Board Validation

Model voltage, current, loading and ADC inputs, while distinguishing simulations from physical board measurements.

Electronics Foundations — Validating Sensor Inputs — Why a voltage divider changes when you connect a load
The Fridge Insists It Is 255°C — Debug signs, partial reads, retries, and deadlines in C
My Cable Has an Echo — Use ngspice and Python to verify propagation, reflections and termination
The Sensor Is Fine. The Board Cannot Understand It — Decode captured waveforms yourself to find the fault

3D Graphics and Physics Engines

Build by hand the computations that run behind a single triangle reaching the screen, and behind a stack of boxes standing without collapsing. This is not about how to use an engine but about what happens inside one. You use only standard Python with no libraries, and every lab leaves its result as a PNG you can check with your own eyes in the web preview.

3D Math and a Software Rasterizer — Build by hand every computation behind a single triangle reaching the screen.
The Skeleton of a Physics Engine — Build integrators, collision detection, impulses and constraints yourself, then stack boxes.
Shaders and the GPU Pipeline — Learn what the GPU computes by imitating vertex and fragment shaders on the CPU.