DevOps Training
Weekends · Live remote cohort · Cohort 01

Learn to ship software the way teams actually ship it.

Twelve weekends of Friday-to-Sunday evenings — ten modules, 90 hours of live instruction, and one running system you build yourself, from a bare Git repo to a containerized app deployed on Kubernetes by a pipeline you wrote. For engineers who already know the cloud and want to automate everything that touches it.

cohort-01 · status: enrolling
modules
10
duration
12 weekends
live sessions
3 × weekly
session length
2.5 hours
contact hours
90
days
Fri · Sat · Sun
starts
Fri 2 Oct 2026
ends
Sun 10 Jan 2027
delivery
remote / live
01 — Who this is for

Built for engineers who already know the cloud.

This cohort assumes you are technical: you have used a terminal, you have spun up resources in a cloud console, and you are not learning what a virtual machine is. What you are here for is everything that turns those resources into an automated delivery pipeline.

02 — Curriculum

Ten stages. Each one adds to the same system.

The order is deliberate: every module consumes what the last one produced. By module 10 you are deploying an artifact that was built, scanned, containerized and provisioned by work you did in modules 4 through 9.

Across the twelve weekends, modules 1 to 5 run about a weekend each and modules 6 to 10 rather longer — Docker, ECS, CI/CD, Terraform and Kubernetes get the bulk of the 90 hours. Pace shifts with the room; nobody is left behind to keep a schedule.

01

DevOps Foundations

What DevOps actually is once you strip the marketing off it: the delivery lifecycle, why handoffs break, and where every tool in this course sits relative to the others. Then we build the shared environment every later module runs on.

SDLCdelivery pipeline anatomyenvironmentstoolchain setup
You finish withA configured workstation, a provisioned Linux host, and a mental map of how the ten modules connect.
02

Linux for DevOps

The subset of Linux you will type every week: permissions and ownership, packages, processes and systemd services, logs, networking, disks, pipes and text processing, and enough shell scripting to automate a task and read someone else’s script.

permissionssystemdjournalctlnetworkingshell scriptingcron
You finish withA server you can operate, a service of your own running under systemd, and a health-check script on a schedule.
03

Git & GitHub

Version control as a team practice, not a set of memorized commands. Branching models, pull requests, code review, resolving merge conflicts without panic, and the repository conventions every later module depends on.

gitbranchingpull requestsconflict resolution
You finish withThe course repository, forked and structured, with your first reviewed pull request merged.
04

Build Tools & Artifacts

How source becomes a shippable thing. Dependency resolution, build lifecycles, and why a versioned artifact — not a folder of files — is what you deploy. We build the same application twice, on two toolchains.

MavenGradlenpmsemantic versioning
You finish withA reproducible build producing a versioned artifact from your repo.
05

Code Quality with SonarQube

Standing up SonarQube, reading what it tells you, and separating real findings from noise. Quality gates, coverage, code smells and vulnerabilities — configured so a failing gate stops a bad build instead of being ignored.

SonarQubequality gatescoveragestatic analysis
You finish withYour own SonarQube instance scanning your project against a gate you defined.
06

Docker & Containers

Images, layers, registries, and the difference between a container and a virtual machine. Writing a Dockerfile that is not 1.2 GB, wiring multiple services with Compose, and handling data, networking and secrets.

Dockerfilemulti-stage buildsComposeregistriesvolumes
You finish withYour application containerized and published to a registry, running locally with its database.
07

Orchestration with Amazon ECS

What an orchestrator does that docker run cannot. ECR, task definitions and revisions, the two IAM roles everyone confuses, Fargate versus EC2, load balancing, health checks, rolling deployments and autoscaling.

ECSFargateECRtask definitionsALBautoscaling
You finish withYour image running as a scaled service behind a load balancer, on a URL you can share.
08

CI/CD with GitHub Actions

Turning modules 3 through 7 into one automated pipeline. Workflow syntax, triggers, jobs and matrices, caching, secrets management, environments and approvals — build, scan, containerize, push, deploy, on every commit.

GitHub Actionsworkflowssecretsenvironmentsartifacts
You finish withA green pipeline that takes a merged pull request all the way to a published image, unattended.
09

Infrastructure as Code with Terraform

Describing infrastructure instead of clicking it. HCL, providers, state and why it matters, variables and outputs, modules, and a safe change workflow — plan, review, apply, destroy — against a real cloud account.

TerraformHCLstatemodulesremote backends
You finish withYour entire environment — network, compute, cluster — defined in code and rebuildable from scratch.
10

Kubernetes

Why orchestration exists and what it costs you. Pods, deployments, services and ingress; config maps and secrets; scaling, rolling updates and rollbacks; and reading logs and events when a pod will not start.

kubectldeploymentsservicesingressscalingtroubleshooting
You finish withYour container running on a managed cluster, updated by your pipeline, reachable at a real URL.
Beyond the modules

Capstone project

There is no separate final project — the system you build across the twelve weekends is the capstone. One repository whose pipeline builds it, scans it, containerizes it, provisions its infrastructure and deploys it, which you can demo and defend line by line.

Beyond the modules

CV & interview preparation

A dedicated session on rewriting your CV around what you actually built, and rehearsing the questions it invites — the ones DevOps interviews really ask. Not a placement programme; preparation for the interviews you get.

03 — How it runs

Live, small, and hands-on-keyboard.

Seven and a half hours of live instruction every weekend, taught over video rather than pre-recorded. You will be building alongside — expect to share your screen and get unstuck in the room.

Schedule
Fri, Sat & Sun · 7–9:30pm UK
Three sessions weekly, two and a half hours each — 7.5 hours of class, no weekday conflicts.
Platform
Google Meet
Link sent before each session.
Recordings
Every session
Posted within 24 hours, yours for 12 months.
Festive break
18 Dec – 3 Jan
Last session 13 Dec; class resumes Fri 8 Jan 2027.
Between classes
Private Discord server
Questions, code review and troubleshooting between sessions.
Assessment
Weekly labs
Submitted as pull requests and reviewed individually.
04 — What you need

Come with these ready on day one.

Before day one

  • An active AWS account. Module 02 covers the Linux you need — but you should be comfortable in a terminal.
  • A laptop with 8 GB RAM minimum, 16 GB strongly preferred, and 40 GB free disk.
  • Stable internet — you will be on video and pushing images.
  • A GitHub account.
  • Your Friday evenings and weekends free from October to January, plus 4–6 hours a week for labs.

We install these together in modules 1 and 2

$ git --version
$ docker --version
$ terraform --version
$ kubectl version --client
$ aws --version
$ code --version
# installed together in session 1

Everything in this course runs on free tiers. Where a lab would incur cost, we tear the infrastructure down at the end of the session — and you will learn to check that it is actually gone.

05 — Enrolment

Cohort 01 is open.

What a seat includes

All 12 weekends · all 10 modules · 90 hours of live instruction · capstone project · CV & interview preparation · recordings for 12 months · community access · individually reviewed labs.

Not sure it is the right level? Message me describing where you are now and I will tell you honestly whether this cohort fits.