Series

Every series on School of Web, in one place. Pick a topic and read from part 1 in order.

91 series · 737 posts

A dot fills in once you have read that part.

Programming Language

Python 21 parts · about 2 hr

Python Basics

Table of contents
  1. 1 — What is Python?
  2. 2 — Installing Python
  3. 3 — Text Editors for Python Coding
  4. 4 — Variables
  5. 5 — IPython
  6. 6 — Jupyter Notebook
  7. 7 — Working with Strings
  8. 8 — Lists
  9. 9 — Tuples
  10. 10 — Dictionaries
  11. 11 — Sets
  12. 12 — Control Flow & Operators
  13. 13 — if Statement
  14. 14 — while Loop
  15. 15 — for Loop
  16. 16 — Functions
  17. 17 — Reading and Writing Files, Part 1
  18. 18 — Reading and Writing Files, Part 2
  19. 19 — Errors and Exception Handling
  20. 20 — Modules and Packages Vol. 1
  21. 21 Python Basics #20 — Modules and Packages Vol. 2
Python 7 parts · 34 min total

SQLAlchemy 2.0

Table of contents
  1. 1 The Big Picture: Core, ORM, and the 2.0 Style
  2. 2 Engines and Transactions: Connection Pools and the Two Commit Patterns
  3. 3 Defining ORM Models: DeclarativeBase, Mapped, mapped_column
  4. 4 The Session: Change Tracking, flush vs commit, and the Four Object States
  5. 5 Relationships: One-to-Many, Many-to-Many, and the N+1 Problem
  6. 6 Advanced Queries: Joins, Aggregation, Subqueries, Bulk Operations
  7. 7 Alembic and Production Setup: Migrations, Async, Team Rules
Rust 9 parts · 42 min total

Rust Basics

Table of contents
  1. 1 What Rust Is: Why Learn It, Installing rustup, First Steps with cargo
  2. 2 Variables and Types: let and mut, Shadowing, Functions That End in Expressions
  3. 3 Ownership: Move by Default, and How Memory Is Freed Without a GC
  4. 4 References and Borrowing: & and &mut, Solving Borrow-Rule Compile Errors
  5. 5 Structs and Enums: match, Option, and Designing Without null
  6. 6 Error Handling: Result, the ? Operator, and the Boundary Between panic and unwrap
  7. 7 Collections and Iterators: Vec, String, HashMap, and Chains Instead of for
  8. 8 Traits and Generics: Shared Behavior in a Language Without Inheritance
  9. 9 Lifetimes and Modules: When Lifetime Annotations Are Needed, Finishing with Crates
Rust 7 parts · 29 min total

Rust in Practice

Table of contents
  1. 1 Project Design and clap: Structuring a Subcommand CLI
  2. 2 Error Design: anyhow and thiserror, Engineering How It Dies
  3. 3 File IO and Parsing: Read with BufReader, Turn a Log Line into a Struct
  4. 4 Iterators at Work: Aggregation, Top-N, and the Release Build Difference
  5. 5 Parallelism with rayon: Map-Reduce Without Data Races
  6. 6 Testing: From Parser Unit Tests to CLI Integration Tests
  7. 7 Release Optimization and Cross-Compilation: Small, Fast Binaries That Run Anywhere

Framework

Wails 10 parts · 49 min total

Wails in Practice

Table of contents
  1. 1 Designing a Real Project — What to Build and How to Split It
  2. 2 SQLite Local Database — Pure Go, No CGO
  3. 3 Full-Text Search and Data Flow — FTS5 and Event-Driven Updates
  4. 4 Tray Residence and a Global Shortcut — Capture Fast from the Background
  5. 5 Signing and Notarization — How a Shipped App Earns Trust
  6. 6 CI/CD Automated Releases — Three-Platform Delivery with GitHub Actions
  7. 7 The Note Editor for Real — Markdown Preview and List UX
  8. 8 A Testing Strategy — Verifying the Service and Repository
  9. 9 Implementing Auto-Update — Delivering a New Version Safely
  10. 10 Finishing Touches — Settings, Dark Mode, Data Backup

Infrastructure

Hardware 9 parts · 56 min total

Hardware Basics

Table of contents
  1. 1 Four Resources That Run a Computer — CPU, Memory, Storage, Network
  2. 2 CPU — Cores, Threads, Clock, Cache, and What a vCPU Really Is
  3. 3 Memory — RAM, the Hierarchy, and What Happens When Swapping Starts
  4. 4 Storage ① Devices — HDD / SSD / NVMe and IOPS / Throughput / Latency
  5. 5 Storage ② Layout and Connection — RAID and DAS / NAS / SAN
  6. 6 Network — Bandwidth and Latency, from the NIC to the Data Center
  7. 7 Virtualization and Containers — How One Physical Server Becomes Many
  8. 8 Cloud — From Owning to Renting, from On-Prem to IaaS / PaaS / SaaS
  9. 9 Reading Cloud Instance Specs — Choosing to Match the Workload
Hardware 9 parts · 52 min total

Hardware Intermediate

Table of contents
  1. 1 Reading Performance Metrics — Turning Slow into Numbers
  2. 2 CPU Deep Dive — Turbo, Throttling, Steal Time
  3. 3 Memory Deep Dive — available, Dirty Pages, Container Limits
  4. 4 NUMA — Memory Is Not Uniform
  5. 5 Measuring Storage Performance — fio, Queue Depth, Inside SSDs
  6. 6 RAID in Operation — Rebuild, Scrub, and Backups
  7. 7 Storage Networking — iSCSI, FC, NVMe-oF, Multipath
  8. 8 GPUs and Accelerators — The Fifth Resource of the AI Era
  9. 9 Hands-On: Diagnosing a Slow Server — Series Finale
Hardware 7 parts · 59 min total

Hardware Advanced

Table of contents
  1. 1 CPU Microarchitecture and perf — Why the Same 100% Isn't the Same
  2. 2 eBPF Observability — Seeing the Tail the Average Hides
  3. 3 Memory Deep Dive — Page Cache, THP, and Bandwidth
  4. 4 ZFS Deep Dive — When RAID and the Filesystem Become One
  5. 5 Datacenter Power — The Real Reason You Can't Rack More Servers
  6. 6 Data Center Cooling and Racks — Electricity Always Becomes Heat
  7. 7 Firmware, BMC, and the Lifecycle — The Other Computer Inside Your Server
AWS 10 parts · about 2 hr

CLF-C02

Table of contents
  1. 1 Exam Introduction — Structure and Study Strategy
  2. 2 Domain 1-1 Cloud Concepts — Value, Economics, and the Cloud Adoption Framework
  3. 3 Domain 1-2 Cloud Design — The Six Well-Architected Pillars
  4. 4 Domain 2-1 Security — Shared Responsibility Model and IAM Basics
  5. 5 Domain 2-2 Compliance — Governance, AWS Artifact, GDPR/HIPAA
  6. 6 Domain 3-1 Core Services — Compute and Storage
  7. 7 Domain 3-2 Core Services — Networking and Databases
  8. 8 Domain 4 Billing and Support — Pricing Models, Support Plans, TCO
  9. 9 Exam Tips and Common Mistake Patterns
  10. 10 Full-Scale Mock Exam — 50 Questions with Explanations
AWS 16 parts · about 2 hr

SAA-C03

Table of contents
  1. 1 Exam Introduction — Exam Structure and Study Roadmap
  2. 2 Domain 1-1 Secure Architectures — IAM in Depth
  3. 3 Domain 1-2 Secure Architectures — KMS and Encryption
  4. 4 Domain 1-3 Secure Architectures — VPC Security
  5. 5 Domain 1-4 Secure Architectures — WAF , Shield , Cognito , Secrets Manager
  6. 6 Domain 2-1 Resilient Architectures — Multi-AZ , Auto Scaling , ELB
  7. 7 Domain 2-2 Resilient Architectures — DR Patterns
  8. 8 Domain 2-3 Resilient Architectures — Backup Strategy
  9. 9 Domain 3-1 High-Performing Architectures — Choosing Compute
  10. 10 Domain 3-2 High-Performing Architectures — Caching
  11. 11 Domain 3-3 High-Performing Architectures — Choosing Storage
  12. 12 Domain 3-4 High-Performing Architectures — Choosing a DB
  13. 13 Domain 4-1 Cost Optimization — Pricing Models
  14. 14 Domain 4-2 Cost Optimization — Cost Monitoring
  15. 15 Exam Tips and Frequently Missed Patterns
  16. 16 Full-Scale Multiple-Choice Practice Exam — 50 Questions + Explanations
AWS 15 parts · 83 min total

DVA-C02

Table of contents
  1. 1 Exam Introduction — Exam Structure and Study Roadmap
  2. 2 Domain 1-1 Development with AWS Services — Lambda Deep Dive
  3. 3 Domain 1-2 Development with AWS Services — API Gateway
  4. 4 Domain 1-3 Development with AWS Services — DynamoDB Development
  5. 5 Domain 1-4 Development with AWS Services — Messaging and Events
  6. 6 Domain 1-5 Development with AWS Services — SDK Development Patterns
  7. 7 Domain 2-1 Security — Authentication and Authorization
  8. 8 Domain 2-2 Security — Encryption and Secrets
  9. 9 Domain 3-1 Deployment — CI/CD
  10. 10 Domain 3-2 Deployment — IaC and Serverless Deployment
  11. 11 Domain 3-3 Deployment — Deployment Strategies
  12. 12 Domain 4-1 Troubleshooting and Optimization — Observability
  13. 13 Domain 4-2 Troubleshooting and Optimization — Optimization and Problem Solving
  14. 14 Exam Tips and Frequently Missed Patterns
  15. 15 Full-Scale Multiple-Choice Mock Exam — 50 Questions + Explanations
AWS 15 parts · about 2 hr

SOA-C03

Table of contents
  1. 1 Exam Introduction — Exam Structure and Study Roadmap
  2. 2 Domain 1-1 Monitoring — CloudWatch Metrics, Alarms, and Dashboards
  3. 3 Domain 1-2 Monitoring — CloudWatch Logs, Logs Insights, Agent
  4. 4 Domain 1-3 Monitoring — Automated Recovery and Performance Optimization
  5. 5 Domain 2-1 Reliability: Multi-AZ, Auto Scaling, and ELB Health Checks
  6. 6 Domain 2-2 Reliability — Backup, Restore, and Disaster Recovery (DR)
  7. 7 Domain 3-1 Deployment — CloudFormation in Depth and IaC
  8. 8 Domain 3-2 Deployment: Systems Manager Operations Automation
  9. 9 Domain 3-3 Deployment — Container Operations (ECS, EKS, ECR)
  10. 10 Domain 4-1 Networking — VPC Operations and Connectivity Troubleshooting
  11. 11 Domain 4-2 Networking — Route 53,CloudFront,Delivery Operations
  12. 12 Domain 5-1 Security — IAM,Organizations,Multi-account Operations
  13. 13 Domain 5-2 Security — Config, CloudTrail, GuardDuty, Security Hub, KMS
  14. 14 Exam Tips and Common Operational Scenario Mistakes
  15. 15 Full-Scale Multiple-Choice Mock Exam — 50 Questions + Explanations
Kubernetes 27 parts · about 5 hr

CKA

Table of contents
  1. 1 The Exam Environment — alias and dry-run, vim/yq setup, time management
  2. 2 Cluster Architecture 1: Control plane (apiserver/etcd/scheduler/controller-manager)
  3. 3 Cluster Architecture 2: Node (kubelet/kube-proxy/CRI), the Pod Networking Model
  4. 4 Installing a Cluster with kubeadm: Bootstrapping a Single Control Plane
  5. 5 HA Clusters: Multiple Control Planes and an External etcd Cluster
  6. 6 Cluster Upgrade: kubeadm upgrade plan/apply, Per-node drain
  7. 7 etcd Backup and Restore — etcdctl snapshot save/restore
  8. 8 Certificate Management: PKI, kubeconfig, Certificate Renewal
  9. 9 RBAC: Role/ClusterRole, RoleBinding, ServiceAccount, kubectl auth can-i
  10. 10 Workloads 1: Deployment in Depth, ReplicaSet, Rolling Update and Rollback
  11. 11 Workloads 2: DaemonSet, StatefulSet, Job, CronJob
  12. 12 ConfigMap and Secret in Depth
  13. 13 Scheduling 1: nodeSelector, nodeAffinity, podAffinity/antiAffinity
  14. 14 Scheduling 2: Taints/tolerations, Priority/PriorityClass, preemption
  15. 15 Resource Management: requests/limits, QoS, LimitRange, ResourceQuota
  16. 16 Storage 1: Volume Types, PV, PVC, and Static Provisioning
  17. 17 Storage 2: StorageClass, Dynamic Provisioning, Reclaim Policy, Expansion
  18. 18 Networking 1: Service (ClusterIP/NodePort/LoadBalancer/ExternalName)
  19. 19 Networking 2: Ingress, IngressClass, TLS
  20. 20 Networking 3: CoreDNS, NetworkPolicy
  21. 21 Helm and Kustomize: Managing Manifests
  22. 22 Troubleshooting 1: Pods and Apps (Pending, CrashLoop, ImagePull, OOM)
  23. 23 Troubleshooting 2: Nodes and kubelet (NotReady, disk/memory pressure)
  24. 24 Troubleshooting 3: Control Plane (apiserver/etcd/scheduler Down), etcd Recovery
  25. 25 Troubleshooting 4: Networking, DNS, RBAC, Certificate Expiry
  26. 26 Exam Tips, Time Management, and Patterns People Miss
  27. 27 Full-Length Practice Exam — 17 Tasks with Solutions
Kubernetes 21 parts · about 3 hr

CKAD

Table of contents
  1. 1 The Exam Environment — Mastering kubectl, dry-run, and generators
  2. 2 Pod and Container Lifecycle — Restart Policy and Container States
  3. 3 Multi-container Patterns: Init container, sidecar, ambassador, adapter
  4. 4 Container Images: Dockerfile, Multi-stage, and Building from Scratch on the Exam
  5. 5 Workloads 1: Deployment, ReplicaSet, Rolling Update, and Rollback
  6. 6 Workloads 2: DaemonSet, StatefulSet
  7. 7 Workloads 3: Job, CronJob (Backoff, Concurrency)
  8. 8 Deployment Strategies: Blue-green, Canary
  9. 9 Helm: install, upgrade, rollback, values
  10. 10 Kustomize: The Overlay Pattern and Per-Environment Manifests
  11. 11 Probes: liveness, readiness, startup (exec/HTTP/TCP)
  12. 12 Observability: logging, kubectl debug, port-forward, ephemeral container
  13. 13 ConfigMap and Secret in Depth: volume vs env, Auto-Refresh
  14. 14 ServiceAccount and RBAC (App Perspective)
  15. 15 SecurityContext and Capabilities: runAsUser, fsGroup, readOnly rootfs
  16. 16 Resource Management: requests/limits, QoS Class, LimitRange
  17. 17 Volumes: emptyDir, PVC, projected, ephemeral
  18. 18 Services: ClusterIP, NodePort, LoadBalancer, ExternalName
  19. 19 Ingress and NetworkPolicy
  20. 20 Exam Tips, Time Management, and the Patterns People Miss
  21. 21 Full-Length Practice Exam — 18 Tasks with Solutions
Kubernetes 20 parts · about 4 hr

CKS

Table of contents
  1. 1 The Exam Environment — CKA prerequisite, tools, time management
  2. 2 NetworkPolicy in depth — default deny, ingress/egress (Cluster Setup)
  3. 3 CIS benchmark (kube-bench), component security, Ingress TLS, binary verification
  4. 4 RBAC least privilege in depth (Cluster Hardening)
  5. 5 ServiceAccount token management, restricting API access, cluster upgrades
  6. 6 AppArmor profiles (System Hardening)
  7. 7 seccomp Profiles
  8. 8 kernel hardening, capabilities, /proc protection
  9. 9 Pod Security Admission (PSA, Pod Security Standards)
  10. 10 Secrets Management: etcd Encryption, External Secrets
  11. 11 Isolation — gVisor, Kata Containers, RuntimeClass
  12. 12 Pod-to-Pod mTLS: Cilium
  13. 13 Minimal images: distroless, scratch (Supply Chain)
  14. 14 Image scan — Trivy, Kubesec, KubeLinter
  15. 15 Image signing: cosign, SBOM
  16. 16 Admission control: OPA/Gatekeeper, Kyverno
  17. 17 Falco behavioral analysis, audit logs (Runtime)
  18. 18 Container immutability, forensics
  19. 19 Exam tips, time management, and patterns people get wrong
  20. 20 Full-Length Practice Exam — 16 Tasks with Solutions
Kubernetes 9 parts · about 2 hr

KCNA

Table of contents
  1. 1 Exam Introduction — Structure and Study Strategy
  2. 2 Kubernetes Fundamentals 1 — Architecture and Core Resources
  3. 3 Kubernetes Fundamentals 2 — API, Containers, Scheduling
  4. 4 Container Orchestration (22%) — Runtime, Security, Networking, Storage, Service Mesh
  5. 5 Cloud Native Architecture (16%) — Autoscaling, Serverless, Community, Open Standards
  6. 6 Cloud Native Observability (8%) — Telemetry, Prometheus, Cost Management
  7. 7 Cloud Native Application Delivery (8%) — GitOps, CI/CD
  8. 8 Exam Tips and Common Mistakes
  9. 9 Full-Length Practice Exam — 50 Questions with Explanations
Terraform 8 parts · 43 min total

Terraform Basics

Table of contents
  1. 1 IaC and Terraform: Where Console Clicking Breaks Down, Installation, and the First apply
  2. 2 HCL Core Syntax: Blocks, Arguments, Resource Addresses, and the Three Shapes of Change
  3. 3 Variables, Outputs, and Locals: Three Tools for Removing Hardcoded Values
  4. 4 Data Sources and Expressions: Reading Instead of Creating, Conditionals, and for
  5. 5 State Explained: The tfstate File Structure and How plan Computes Changes
  6. 6 Dependencies and Repetition: depends_on, count vs for_each, and dynamic Blocks
  7. 7 Resource Lifecycle Control: Replacement Conditions, create_before_destroy, prevent_destroy
  8. 8 Module Basics: Reusing Resource Bundles and Registry Modules
PostgreSQL 9 parts · 37 min total

PostgreSQL Basics

Table of contents
  1. 1 What PostgreSQL Is: Why It Became the Default, Installation and First psql Session
  2. 2 Data Types and Table Design: What to Store Things As
  3. 3 Joins and Aggregation: Working Instincts for Read Queries
  4. 4 Index Fundamentals: When Indexes Get Used and When They Don't
  5. 5 Reading EXPLAIN: Diagnosing Queries with Execution Plans
  6. 6 Transactions and MVCC: The Fundamentals of Concurrency
  7. 7 JSONB: Schema Flexibility Inside a Relational Database
  8. 8 Views, CTEs, Window Functions: Keeping Complex Queries Readable
  9. 9 Roles, Permissions, Backup Fundamentals: The Minimum Discipline of Operations
PostgreSQL 7 parts · 28 min total

PostgreSQL in Practice

Table of contents
  1. 1 Schema Migrations: Changing Tables Without Stopping the Service
  2. 2 Connection Pooling: The max_connections Misconception and PgBouncer
  3. 3 The Performance Diagnostics Routine: Finding Slow Queries with pg_stat_statements
  4. 4 Advanced Index Strategy: Partial, Composite, Covering — and GIN, BRIN
  5. 5 VACUUM and autovacuum: How Dead-Tuple Cleanup Works, and Tuning It
  6. 6 Locks and Concurrency: Deadlocks, DDL Locks, SKIP LOCKED
  7. 7 Partitioning: Splitting Giant Tables by Time
Infrastructure 19 parts · about 3 hr

RHCE

Table of contents
  1. 1 Exam Overview — the environment, time management, ansible-navigator vs ansible-playbook
  2. 2 Inventory: static, dynamic, group/host_vars
  3. 3 Config Files and Connectivity — ansible.cfg, ssh, become
  4. 4 Ad-hoc commands: running modules on the spot
  5. 5 Playbook Basics — task, handler, idempotency
  6. 6 Variables and facts — precedence, magic vars, custom facts
  7. 7 Jinja2 Templates — Filters, Control Flow, and lookup
  8. 8 Error handling: block/rescue/always, failed_when, ignore_errors
  9. 9 Tags and conditionals: when, loop, until
  10. 10 Ansible Vault: Managing Secrets
  11. 11 Writing and Using Roles
  12. 12 Collection: Galaxy, Automation Hub
  13. 13 System roles (rhel-system-roles)
  14. 14 RHCSA Automation 1: Users/Groups, Packages/Repositories
  15. 15 RHCSA Automation 2: Services, chronyd, log
  16. 16 RHCSA automation 3 — storage (LVM), filesystems (NFS)
  17. 17 RHCSA Automation 4: firewall, SELinux, SSH keys
  18. 18 Exam Tips and Time Management
  19. 19 Full-Length Practice Exam — 15 Tasks with Solutions
Infrastructure 16 parts · about 3 hr

RHCSA

Table of contents
  1. 1 The Exam — EX200 format, environment, study strategy
  2. 2 Essential Tools: bash, vi, redirection, find/grep, archive, ssh
  3. 3 Shell scripting: conditionals, loops, arguments, exit codes
  4. 4 Boot and the system — systemd, target, GRUB2, password recovery
  5. 5 Local Storage 1 — Partitions, swap, LVM basics
  6. 6 Local Storage 2 — LVM Expansion and LUKS Encryption
  7. 7 File systems: XFS, ext4, mount/fstab, NFS, AutoFS
  8. 8 Packages and repositories: dnf, modules, AppStream
  9. 9 System Operations: chronyd, journald, cron, systemd timer, tuned
  10. 10 Basic Networking: NetworkManager (nmcli), hostname, /etc/hosts
  11. 11 Users/Groups: UID/GID, sudo, ACL, password policy
  12. 12 firewalld and SSH key authentication
  13. 13 SELinux in depth — contexts, booleans, troubleshooting (audit2allow)
  14. 14 Managing containers: Podman, systemd integration (quadlet)
  15. 15 Exam tips, time management, and patterns people get wrong
  16. 16 Full-Length Practice Exam — 16 Tasks with Solutions

Tools

Git 10 parts · 77 min total

GitHub Foundations

Table of contents
  1. 1 Exam Overview — Structure and Study Strategy
  2. 2 Domain 1: Git and GitHub Basics — Version Control and Product Structure
  3. 3 Domain 2: Working with Repositories — Branches, Tags, Releases, and Gists
  4. 4 Domain 3-1: Collaboration — Issues, Labels, Milestones, and Templates
  5. 5 Domain 3-2: Collaboration — Pull Requests, Code Review, and Discussions
  6. 6 Domain 4: Modern Development — Actions, Codespaces, Copilot, and Packages
  7. 7 Domain 5: Project Management — Projects, Automation, and Insights
  8. 8 Domain 6: Privacy, Security, and Administration — Permissions, 2FA, and Dependabot
  9. 9 Domain 7: The GitHub Community + Exam Tips
  10. 10 Bonus — Full-Scale Practice Exam (50 Questions with Explanations)
Microsoft Graph 7 parts · 38 min total

Microsoft Graph in Practice

Table of contents
  1. 1 What Graph Is — One API for All of Microsoft 365
  2. 2 App Registration and Auth — Entra ID, Delegated vs. Application Permissions
  3. 3 First Calls with the Python SDK — Reading Users and Org Data
  4. 4 Automating Mail and Calendar — Reading, Sending, Creating Events
  5. 5 Files in OneDrive and SharePoint — Upload Sessions and Sharing
  6. 6 Teams — Reading Messages, and the Three Routes for Sending Notifications
  7. 7 Operations — Throttling, Pagination, Delta Queries, Change Notifications

AI

LLM App Development 13 parts · 70 min total

LLM App Development

Table of contents
  1. 1 Your First API Call and Environment Setup
  2. 2 Understanding Messages and Parameters
  3. 3 Streaming Responses in Real Time
  4. 4 Prompt Engineering in Practice
  5. 5 Getting Structured Output
  6. 6 Connecting External Functions with Tool Calling
  7. 7 Embeddings and Vector Search
  8. 8 Building a RAG Pipeline
  9. 9 Conversation Memory and Context Management
  10. 10 Building an AI Agent
  11. 11 Connecting Tools with MCP
  12. 12 Cost, Evaluation, and Observability
  13. 13 A Real-World Project — Internal Document Q&A Bot

IT Knowledge