Curation in progress
Deployment
Eleven modules for someone who has shipped something live by prompting and does not read code. It opens on the mathematics - why latency goes vertical near saturation, Little's Law, why an average hides the tail, availability as multiplication, and feedback with lag. Then what deployment and a server actually are; the network, from the speed of light as a floor through DNS and TLS to the edge; the machine, from processes to containers to what boots when a function is invoked; the real options for where code runs and what each costs; state and consistency, taught from the Cambridge distributed systems lectures; access and blast radius, where every documented vibe-coding catastrophe actually landed; releasing; detecting failure; how systems fail; and what scale costs.
- Modules
- 11
- Lessons
- 56
- Watch time
- 24h 5m
- Free to open
- 4
The Language of Systems
The five behaviours every production system exhibits, stated as maths before they are stated as advice.
- 01.01Why Your Deploys Got WorseState the thesis of this course: AI raises how much you ship and how often it breaks, so operational friction now compounds instead of staying flat.
- 01.02The Hockey StickExplain why latency scales as 1/(1-utilisation) rather than linearly, so a system that is fine at 70% is vertical at 90%.
- 01.03Little's LawState L = lambda x W and apply it to a queue, knowing it holds for any arrival pattern and any service order.
- 01.04Why Averages LieExplain why a good average hides a bad tail, and why p99 at scale is the size of your support inbox.
- 01.05Availability Is MultiplicationState the probability axioms and say precisely when two events are independent - the condition every availability calculation in this course quietly assumes.
- 01.06Feedback, Lag, OvershootDefine a feedback loop - an input, an output, a measurement of that output, and an error signal - and say what the loop is trying to hold steady.
What Deployment Is
Deployment stated as a mechanism rather than a button, and the four things production is judged on.
- 02.01What Deployment MeansSay what deploying actually moves and where it moves it, and why code in a repository is not code that anyone can reach.
- 02.02What a Server Actually IsDescribe what a server keeps, runs and delivers, and why that is different from the machine under your desk.
- 02.03Why Local Is Not ProductionName the four ways your machine diverges from production: environment, filesystem, network topology and concurrent load.
- 02.04The Problem, StatedState the deployment problem precisely: moving a live system between states without dropping work already in flight.
- 02.05The Four AxesJudge a system on availability, latency, durability and cost, and treat reliability as a budget rather than a goal.
The Network
What the request crosses before it reaches you, and the one physical limit in the whole course.
- 03.01Speed of Light Is a FloorCompute the round-trip floor between two regions from distance alone, and say why no amount of engineering removes it.
- 03.02DNSTrace what happens between typing a hostname and opening a connection, and name what fails when resolution does.
- 03.03Connections Cost SomethingUse the bandwidth-delay product to explain why a fat pipe underperforms over distance, and why throughput is window divided by RTT.
- 03.04TLSDescribe what the handshake establishes and what a certificate actually proves.
- 03.05CDNs and the EdgeExplain anycast and the cache key, and say what the edge cannot do for you.
The Machine
What your code actually runs on, from the process up to the container.
- 04.01Processes and SchedulingSay what a process is to the operating system, and how isolation and scheduling decide what your code gets.
- 04.02Virtual MachinesDescribe what a hypervisor virtualises and what that costs relative to running on the metal.
- 04.03ContainersTake a container apart into namespaces, cgroups and a root filesystem, so it stops being a black box.
- 04.04Images and ReproducibilityExplain layered images and what makes a build deterministic or not.
- 04.05Serverless InternalsDescribe what actually boots when a function is invoked, and why cold start is a distribution rather than a number.
The Types, Compared
The real options for where code runs, and the duty cycle that decides between them.
- 05.01Cost Curves and CrossoversWork out where serverless stops being cheaper than an always-on container, and name the fixed costs that apply before a single request.
- 05.02Static and EdgeSay what belongs at the edge and what cannot go there because it needs your data.
- 05.03Long-Running ServersDescribe what a persistent process gives you that a function does not: warm state, connections and background work.
- 05.04OrchestrationSay what a scheduler does for you and what operational complexity Kubernetes charges in return.
- 05.05Choosing Boring TechnologyApply the innovation-token argument to your own stack and justify each place you spent one.
State and Consistency
The layer that makes deployment hard, taught from the Cambridge distributed systems course.
- 06.01Why State Ruins EverythingState the system model and failure model you are working under, because every guarantee below depends on which one you assumed.
- 06.02Databases Under LoadApply Little's Law to a connection pool and explain why the pool, not the query, is usually the bottleneck.
- 06.03Replication and ConsistencySay what a replica guarantees, and why a read can be behind the write you just made.
- 06.04ConsensusExplain leader election and log replication, why R + W > N matters, and why three replicas rather than two.
- 06.05Migrations Against Live TrafficRun an expand-contract migration and name the exact window in which rollback stops being possible.
Access and Blast Radius
Where every documented vibe-coding catastrophe actually landed.
- 07.01Permissions as SetsExplain the same-origin policy as the boundary a browser enforces, and how cross-site request forgery abuses a request the browser was willing to authorise.
- 07.02The Trust BoundaryDraw the line between what the client may be trusted with and what it may not, and place your secrets on the right side of it.
- 07.03Access Control at the Data LayerExplain how a session establishes who someone is on later requests, and how session hijacking takes that identity over.
- 07.04Least Privilege and Blast RadiusEnumerate the deliberate exceptions to the same-origin policy - postMessage, CORS and the others - and say how each one widens what an attacker can reach.
- 07.05Your Agent Has the KeysDescribe what an agent harness is - the loop it runs, the context it is handed, and the limits placed on it - which is the layer where an agent's reach is actually bounded.
Releasing
Getting a change in front of users without an outage, and measuring whether you did.
- 08.01MTBF, MTTR, and Their LimitsSay why MTTR is an unreliable measure of reliability, and what to use instead.
- 08.02The Release ProblemState what makes releasing hard independently of the tool doing it.
- 08.03Strategies ComparedChoose between rolling, blue-green and canary on rollback speed, cost and blast radius.
- 08.04Health Checks and DrainingSet readiness and liveness so a shutting-down instance stops taking work, and avoid the deep-check restart cascade.
- 08.05Rollback Beats Forward-FixArgue from feedback-loop length why halving recovery time buys more availability than doubling uptime.
Detecting Failure
Knowing what production is doing, and deciding when that is bad.
- 09.01Sampling and TailsState a probabilistic model properly: the sample space, the probability law, and what it means to assign a probability to an event.
- 09.02Logs, Metrics, and TracesSay what each of the three signals answers and where the three-pillars framing misleads.
- 09.03SLIs, SLOs, and Error BudgetsDefine an SLI and an SLO for one user journey and convert the target into a monthly error budget.
- 09.04AlertingApply one test to every alert - is it immediately actionable - and delete the ones that fail it.
- 09.05Incident ResponseRun a post-incident review that produces learning rather than blame, and say what makes one worth the hour it costs.
How Systems Fail
Module one's mathematics cashing out as real outages: the utilisation curve you already met, retry storms, cascading and correlated failure, and shedding load on purpose.
- 10.01The Curve, CollectedRecognise the 1/(1-utilisation) curve as the shape underneath saturation, retries and queue growth alike.
- 10.02Retry StormsExplain why backoff alone does not stop a herd and why jitter is the part that decorrelates it.
- 10.03Cascading FailureTrace how one slow dependency becomes a whole-system outage, and where the independence assumption broke.
- 10.04BackpressureShed load deliberately, and read latency = A + B x concurrency as the same curve from Module 1.
- 10.05Correlated FailureFind the shared dependency that makes two 'independent' components fail together.
Scale, Cost, and Limits
What more machines buy you, what they cost, and when to stop.
- 11.01Amdahl and the CeilingCompute the maximum speedup from the serial fraction alone, and see why 90% parallel caps at ten times.
- 11.02When Machines Make It SlowerUse the work law and the span law to bound the maximum speedup available from parallelism, so you can see the ceiling before you buy machines.
- 11.03Scaling AxesCompare the common load balancing algorithms - round robin, least connections, hashing and the rest - and say what each one optimises for.
- 11.04Autoscaling as a Control LoopRecognise the general structure of a feedback system - measure the output, compare it to the target, correct - which is the structure an autoscaler implements.
- 11.05Economics, and When to LeaveWeigh cloud spend against the cost of moving, and say why premature infrastructure work kills more startups than cloud bills do.