Concepts, explained in one card.

package apps with their entire runtime into lightweight boxes

orchestrating containers at scale

how images are built from stacked, cached snapshots

kubernetes package manager — templated charts for complex apps

define and run multi-container apps with a single YAML file

where container images are stored, versioned, and scanned

routing external traffic to services inside your cluster

attaching helper containers to your pod without modifying app code

isolation without a whole OS

how containers find each other

data that survives restarts

why one container is never enough

alive isn't ready

sharing a node politely

many teams, one cluster

running databases in clusters

the source of truth Terraform uses to reconcile real-world resources

reusable, versioned infrastructure components

git as the single source of truth for deployments

managing infrastructure through machine-readable definition files

infrastructure as code using real programming languages

building golden machine images with code

who can do what on which resource

run code without provisioning or managing servers

unlimited, highly durable storage for any blob of data

your private network in the cloud

automatically adjusting compute capacity to match demand

fully managed message queuing for decoupling services

serverless NoSQL database with single-digit millisecond latency

AWS's DNS service — also handles failover and traffic routing

just-in-time Kubernetes node provisioning on AWS

where your stuff physically is

three ways to keep bytes

what you pay the cloud to worry about

why the bill surprises everyone

what the cloud won't secure for you

surviving a region outage

why data leaving costs money

cheap machines that vanish

private connections without public internet

containing blast radius through cells

how apps get limited access to your data without your password

never trust, always verify — no implicit access based on network location

storing and rotating API keys, passwords, and certificates safely

the browser's same-origin policiy enforcer

centralized logging and alerting for security events

compact, self-contained tokens for passing identity and claims

filtering malicious traffic before it reaches your application

mutual TLS — both sides prove their identity, not just the server

a full inventory of every software component in your application

secretless repository authentication for CI/CD actions

in-cluster firewall controls for isolating pod traffic

who you are vs what you may do

the math behind SSH and TLS

passwordless, but safe

one-way vs two-way

why browsers trust anyone

the default should be 'no'

keys that expire on purpose

when input becomes code

two places data leaks

how vulnerabilities get names

perimeter-less access verification

automated pipelines that build, test, and deploy every change

knowing what your system is doing at all times

automating server setup and software configuration at scale

storing, versioning, and distributing build outputs

rolling out changes to a small subset before full release

turning features on and off without deploying code

the structured process of detecting, responding to, and learning from outages

managing microservice traffic, security, and observability out-of-band

declarative GitOps continuous delivery for Kubernetes

shipping without downtime

describing vs commanding

why running twice must be safe

what 2.1.3 promises

undoing a bad release

measuring 'is it working?'

when reality stops matching the code

standardizing logs, metrics, and traces

large language models that generate text by predicting the next token

grounding LLM answers in your own data

storing and searching by semantic similarity, not exact keywords

crafting inputs to get reliable, structured outputs from LLMs

specializing a base model on your domain data

LLMs that take actions — not just talk

measuring LLM output quality systematically

converting text into numerical vectors for semantic search

preventing LLMs from producing harmful, unsafe, or off-brand output

AI models that understand text, images, audio, and video together

how LLMs break text into pieces their neural networks can process

optimizing LLM API latency and token reuse costs

enforcement of JSON schemas on LLM response payloads

running open-source models on your developer machine

sending each prompt to the best model for the job

a unified proxy layer between your app and multiple LLM providers

connecting AI agents to real-world APIs and SaaS platforms

the orchestration framework that turns an LLM into a reliable agent

the perceive → reason → act cycle that drives autonomous agents

giving agents short-term and long-term recall beyond the context window

what the model can 'see'

using vs building a model

why AI needs special hardware

shrinking models to fit

why answers vary

putting a model behind an endpoint

how models talk to your systems

testing something non-deterministic

high-dimensional space of meanings

learnable weights in the model

training on massive unlabeled data

the foundational pre-trained model

fine-tuning to follow instructions

ensuring helpful, honest, and harmless outputs

Reinforcement Learning from Human Feedback

setting the model's behavior and constraints

the question or task from the end user

asking to perform tasks without examples

providing examples to guide the model

thinking step-by-step before answering

limiting choices to the top k tokens

choosing from cumulative probability p

anchoring answers in verified facts

fine-tuning models on consumer hardware

compiling declarative prompt pipelines

how programs live and die

rwx and who you are

why /var, /etc, /opt exist

how commands chain

where config hides

the permission model

what keeps daemons running

running things later

what 'out of memory' means

why 'too many open files' happens

two names for one file

how scripts know something failed

.bashrc vs .profile

history as a graph

parallel work, one history

two ways to combine work

why git has three states

your copy vs everyone's copy

when two truths collide

pinning a moment in history

git's undo button