Certification programme
Deploying is the easy part. This is the course about what happens afterwards: Kubernetes in depth, GitOps, observability you can debug with, and the reliability practices that decide whether a system stays up at three in the morning.
What you will be able to do
Full syllabus
10 modules · 52 topics · 229 concepts
The origin of the problem
DevOps as practice
Site reliability engineering
Measuring delivery
Where this fits a career
You can explain what problem these practices solve and where your organisation sits.
Linux internals that matter
Performance diagnosis
Networking for operators
Diagnostic tooling
Git for teams
You can diagnose a Linux host and a network path without guessing.
Container internals
Building images
Image hygiene
Runtime
Registries
You can build minimal, secure images and debug a container that will not start.
Architecture
Workloads
Configuration
Networking
Storage
Scheduling
You can deploy and expose an application and explain how the cluster reconciles it.
Debugging workloads
Scaling
Reliability features
Cluster security
Packaging
You can debug a failing workload and secure a cluster sensibly.
Terraform core
State
Structure at scale
Safe change
Configuration management
You can define an environment in Terraform and manage its state safely.
Pipeline design
GitHub Actions
Quality gates
GitOps
Release strategies
You can build a pipeline and run continuous deployment through Git.
Monitoring versus observability
Metrics
Logging
Tracing
Dashboards and alerts
You can instrument a service and answer a question you had not anticipated.
SLIs, SLOs and SLAs
Error budgets
Designing for failure
Capacity and cost
Backups and disaster recovery
You can define SLOs and use an error budget to decide whether to ship.
Incident command
Diagnosis under pressure
Postmortems
On-call
Platform thinking
Career
You can run an incident and write a review that changes something.
6 builds you keep
Raw manifests, Helm, Kustomize and GitOps, on one cluster. The comparison makes the trade-offs concrete in a way no explanation does, and you end up with an opinion you can defend in an interview.
Given an application with no observability and a vague complaint that it is slow, add metrics, structured logs and traces, then find the actual bottleneck and prove it with a dashboard.
Define an availability and latency SLO from real traffic, wire up burn-rate alerting, then make a release decision when the budget is nearly exhausted and justify it.
Ship a deliberately broken version through a pipeline with automated canary analysis, and watch it detect the regression and revert without a human. Then break it in a way the analysis misses.
A fault is injected into a running system without warning. You take incident command: triage, mitigate, communicate, and write the postmortem afterwards with action items somebody could actually do.
A multi-environment Kubernetes platform defined in Terraform, deployed by GitOps, observable end to end, with SLOs, alerting, runbooks and a tested restore. Destroyed and rebuilt from the repository to prove it.
Hands on with
Before you enrol
That one is cloud infrastructure first: AWS services, VPC design and getting an architecture right, with containers and pipelines covered. This one is about operating systems in production — Kubernetes in depth, GitOps, observability, SLOs and incident response. They overlap on containers and CI/CD deliberately; if you only take one, pick by whether you want to build infrastructure or run it.
Cloud Computing if you are new to infrastructure, because this course assumes you are comfortable on Linux, with a cloud provider and with Git. Several students do them in that order, and the overlap means the second one moves quickly.
Yes, and most people here do. Everything runs on a local cluster or a small managed one, and the course is built so the capstone is evidence you can point at. Lack of production access is a real gap, which is why the incident drills exist.
Honestly, it is usually a second role rather than a first. Most people arrive from development, support or system administration. If you are starting out, the path that works is getting hired for something adjacent and taking on the pipeline and infrastructure work, which this course prepares you to do credibly.
You need to be able to read code and write useful scripts in Python or Bash. You are not expected to build applications. Most of the coding here is automation, configuration and small tools.
It is a genuine part of these roles and the course does not pretend otherwise. The last module covers rotation design, sustainable paging thresholds and burnout, because knowing what good on-call looks like is worth asking about in an interview.
Where this leads
One skill on a CV is a hobby. These are the courses students take alongside this one, in the order that builds an actual role.
Defensive security aimed where the attacks now are: cloud infrastructure and AI systems. Everything is practised in an isolated lab we provide.
Run real campaigns with real budgets, with AI doing the production work. SEO, paid ads, content and analytics, measured properly so you can prove what worked.
Cloud and DevOps together, because employers hire for the combination. You build real infrastructure, containerise applications and ship them through a pipeline you wrote.