deployment

Deployment & Infra

How your code gets from your laptop to running servers — packaging it in containers, putting new versions live without downtime, and describing infrastructure as code.

11 units·40 lessons·~38 h

Start track →

00

Start from zero

Before the senior material: what deployment even is, and the eight words the rest of the track assumes you know.

01 Start from zero: what deployment actually is 10 min

01

Image layers

Coming soon — Deployment and infra

01 Image layers and the build cache: order is everything 16 min 02 Image layers: multiple-choice review 13 min 03 Image layers: free-recall review 14 min 04 Image layers: optimise a real Dockerfile 210 min

02

Compose vs k8s

Coming soon — Deployment and infra

01 Compose vs Kubernetes: choosing the right orchestration weight 16 min 02 Compose vs Kubernetes: multiple-choice review 13 min 03 Compose vs Kubernetes: free-recall review 14 min 04 Compose vs Kubernetes: make the orchestration call 220 min

03

K8s objects

Coming soon — Deployment and infra

01 Kubernetes objects: the reconciliation loop behind every Pod, Service, and rollout 17 min 02 K8s objects: multiple-choice review 13 min 03 K8s objects: free-recall review 14 min 04 K8s objects: ship a self-healing, zero-downtime service 210 min

04

Rollout strategies

Coming soon — Deployment and infra

01 Rollout strategies: trading blast radius for resource cost and rollback speed 16 min 02 Rollout strategies: multiple-choice review 14 min 03 Rollout strategies: free-recall review 14 min 04 Rollout strategies: build a gated canary that rolls itself back 240 min

05

Iac

Coming soon — Deployment and infra

01 Infrastructure as Code: the plan, the state file, and the drift 16 min 02 Infrastructure as Code: multiple-choice review 13 min 03 Infrastructure as Code: free-recall review 14 min 04 Infrastructure as Code: build a drift-safe stack 240 min

06

Lb levels

Coming soon — Deployment and infra

01 Load balancing L4 vs L7: what each layer can and can''''t see 16 min 02 Load balancing levels: multiple-choice review 13 min 03 Load balancing levels: free-recall review 14 min 04 Load balancing levels: deploy with zero dropped requests 220 min

07

Secrets at deploy

Coming soon — Deployment and infra

01 Secrets at deploy: where they enter, where they leak 16 min 02 Secrets at deploy: multiple-choice review 13 min 03 Secrets at deploy: free-recall review 14 min 04 Secrets at deploy: re-plumb a leaky deployment 240 min

08

Putting it together

Coming soon — Deployment and infra

01 Capstone: a deploy is a chain, and the outage lives in the seam 17 min 02 Deployment capstone: multiple-choice review 14 min 03 Deployment capstone: free-recall review 14 min 04 Deployment capstone: ship a production pipeline 240 min

09

Docker, deeper

Beyond build: how containers network, persist data, and stay secure.

01 Container networking: bridges, DNS by name, and the localhost trap 16 min 02 Volumes and persistence 16 min 03 Image security and scanning 17 min

10

Kubernetes, deeper

Routing, config, health and packaging — running real workloads on K8s.

01 Services and ingress 17 min 02 ConfigMaps and secrets 16 min 03 Probes and resource limits 17 min 04 Helm: charts and values 16 min

Build with this track

Guided projects that exercise what you learn here.

A concurrent Go ingest service

Build a concurrent ingest/fan-out worker in Go — then operate it: bound the work, apply backpressure, make downstream calls survive failure, ship it in a minimal container, and work a goroutine-leak incident before it eats your memory.

Async Python service, built and operated

Build an async FastAPI ingestion service that validates, pipelines, and survives load — then run it: package it, containerize it with correct PID-1 behaviour, and work the incident when a swallowed CancelledError quietly leaks tasks until the event loop starves.

URL shortener at scale

Build a URL shortener that survives real traffic — then run it: deploy it, watch it, and work the incident when one hot link melts your cache.

Performance

How to find why software is slow and actually make it faster — measure first, then fix the real bottleneck instead of guessing.