Boost your knowledge. Boost yourself.
DevOps, FinOps, Platform Engineer
Learn DevOps the way teams run it in 2026: AI agents in the loop from lesson one, your own namespace on a real Kubernetes cluster, live cohorts with an instructor.
AI-native by design
AI isn't a bonus module. It's how you work.
Not a bonus lecture about chatbots. From the first repo to the final demo you work next to an AI agent: it drafts the Terraform, reads the logs and proposes the fix. You keep the judgement. Every AI step ends in a check that a human owns: a plan, a dry run, a pull request, a graph.
Agents and MCP in daily ops
Run Claude Code on your own repos. Turn runbooks into skills, connect read-only MCP tools for kubectl and metrics, and set allow and deny rules so the agent can look but cannot apply or delete. You also watch the instructor's agents operate the live cluster in class.
Local LLM inference on the cluster GPU
The course cluster serves open-weight models on its own GPUs: vLLM for inference, a LiteLLM gateway with an OpenAI-compatible API and Open WebUI on top. You learn how to size a model for a GPU, when Ollama on a laptop is enough, and when private code should never leave your own hardware.
AI in observability and root cause
Give an agent the Loki logs and Prometheus metrics around an incident and let it propose a root cause. Then do the part that matters: prove or reject it against the Grafana graphs before anyone touches production.
AI-generated IaC behind review gates
Agents write Terraform, Ansible, Dockerfiles, Helm values and manifests fast. You learn the gates that make that safe: terraform plan, ansible --check --diff, kubectl diff and dry runs, pull requests, and ArgoCD applying only what was merged.
AI-assisted security review
Use AI to review security groups, IAM policies, Dockerfiles and RBAC for over-broad access and hard-coded secrets. Keep keys, state files and kubeconfigs out of prompts, and give agents the same least-privilege, namespace-scoped access you get as a student.
Where AI breaks prod
Invented provider arguments, a plan that quietly destroys a resource, a confident but wrong root cause, a model upgrade that breaks your config, an agent with too much access. You reproduce each failure on purpose and build the habit that catches it.
The program
From a bare Linux box to GitOps on Kubernetes. Every module: a hands-on lab, an AI workflow, a skill you keep.
AI-Native DevOps is a 20-week live program that takes you from Linux and your first Terraform plan to shipping on Kubernetes with GitOps. AI runs through every module: you generate, review and debug infrastructure with agents, and you learn the checks that stop a confident model from breaking production. All of it happens on real systems, including your own namespace on a live GPU cluster.
- weeks
- 20
- live sessions
- ~50
- modules
- 19
- own namespace per student on a live Kubernetes cluster
- 1
- Phase 1
Foundations: the job, Linux, networks and first infrastructure as code
What DevOps engineers actually do, and the ground everything else stands on: Git, the cloud and the hardware under it, Linux, networking, and your first servers built with Terraform and configured with Ansible. The AI assistant joins on day one.
Module 1: DevOps: the profession and the toolchain
What you cover
- How delivery evolved: local builds, deployment pain, the cloud
- DevOps, platform and infrastructure roles, on-call and incidents
- Least-privilege access in real companies
- Workstation setup: VS Code, terminal, WSL on Windows
AI in this module
Install an AI assistant in your editor and write the project rules file it must follow before it touches any repo.
Outcome
You know what the job involves day to day and have a working, AI-ready setup.
Module 2: Git and GitHub
What you cover
- Commits, branches and the main/dev/feature workflow
- Merge vs rebase, and why force-push is dangerous
- Pull requests and code review
- SSH keys for GitHub and a clean .gitignore
- Keeping keys, .env files and state out of Git
AI in this module
Create the class repo with an AI agent and the gh CLI, then review every commit it proposes before you push.
Outcome
You work in branches, open reviewable pull requests and fix a messy history without losing work.
Module 3: Cloud and hardware fundamentals
What you cover
- AWS regions and availability zones, latency between them
- Reliability math: the nines and what downtime really costs
- Capex vs opex, cloud vs on-prem
- CPU, RAM and storage: x86 vs ARM, CPU vs GPU vs TPU
- Virtualization and overprovisioning
- A safe AWS account: MFA, a scoped IAM user, free-tier traps
AI in this module
Ask an assistant to size an instance for a workload, then check its numbers against the provider docs and a load test.
Outcome
You can explain where your workload runs, what it needs from the hardware and how to avoid a surprise bill.
Module 4: Terraform from zero: from a manual EC2 to code
What you cover
- Launching EC2 by hand, then the same server as code
- Providers, credentials and version pins
- init, plan, apply and destroy
- Security groups, key pairs and user_data
- Terraform vs CloudFormation, and OpenTofu
AI in this module
Generate a Terraform config with an agent, run validate and plan, and reject every resource it did not need to create.
Outcome
You build, change and tear down a web server with Terraform and can read a plan before you apply it.
Module 5: Ansible: configuration as code
What you cover
- Declarative vs imperative, stateless Ansible vs Terraform state
- Handoff: Terraform provisions, Ansible configures
- Inventories, playbooks, templates and handlers
- NGINX and a static site, idempotently
- Roles, and why user_data scripts don't scale
AI in this module
Let an assistant write the playbook, run it with --check --diff, and fix what it got wrong before the real run.
Outcome
You configure any number of servers from one repeatable playbook.
Module 6: Linux system administration
What you cover
- Users, groups and permissions
- Processes, signals and packages (apt, yum, snap)
- Patching and CVE fixes, test servers first
- systemd services, journalctl and cron
- Reading load: CPU, memory, swap, top and htop
- Distributions: Debian vs Red Hat, LTS and release cycles
AI in this module
Paste a failing unit's journal into an assistant, take its hypothesis, and prove or reject it with systemctl and journalctl before changing anything.
Outcome
You run a script as a service, find why it fails and keep a server patched and healthy.
Module 7: Networking: from packets to load balancers
What you cover
- OSI in practice, TCP vs UDP, ports
- IPv4, CIDR and subnets, public vs private ranges
- Routing, NAT, firewalls and IPv6
- DNS records, TLS certificates and expiry
- HTTP status codes and debugging with curl
- Scaling traffic: DNS round-robin, L4 NLB vs L7 ALB
AI in this module
Have an assistant draft a subnet plan, then verify every CIDR range by hand before it reaches Terraform.
Outcome
You can tell whether "the site is down" is DNS, TLS, a port or a route, and prove it.
- Phase 2
Build and ship: cloud at scale, CI/CD, containers, Kubernetes
Real AWS networking and autoscaling with Terraform, safe state handling, Jenkins pipelines, Docker and Compose, and Kubernetes from the control plane to probes and ingress. Every change an agent writes goes through a plan, a dry run or an approval gate.
Module 8: AWS networking and autoscaling with Terraform
What you cover
- Subnets per availability zone and routing between them
- Security groups that only open what is needed
- Launch templates and Auto Scaling groups with CPU target tracking
- An Application Load Balancer with health checks
- Load testing and watching scale-out in CloudWatch
- Draining and destroying to keep costs down
AI in this module
Ask an agent why the group did or did not scale, and accept the answer only when the CloudWatch metrics agree.
Outcome
You run a load-balanced, self-healing web tier on AWS and shut it down cleanly.
Module 9: Terraform state and drift
What you cover
- State as the source of truth, and what losing it does
- Remote state in S3 with versioning
- Reviewing destructive changes before apply
- terraform import for resources made by hand
- Drift from a console change, and how plan finds it
AI in this module
Let an agent change live infrastructure, then catch its drift and destructive diffs with plan before anything is applied.
Outcome
You keep state safe, recover from a lost or drifted state and never apply a plan you have not read.
Module 10: CI/CD with Jenkins
What you cover
- Pipeline stages and artifacts, and where GitHub Actions fits
- Installing Jenkins and a first declarative pipeline
- Credentials and manual approval gates
- Terraform plan, approve, apply and destroy from a pipeline
- Jenkins in the cloud: Terraform, Ansible and Docker together
- Backing up and restoring the Jenkins home
AI in this module
Have an agent write the Jenkinsfile, then put every stage that touches infrastructure behind a human approval.
Outcome
You build a pipeline that provisions, configures and deploys, and you can restore it when the server dies.
Module 11: Docker: from virtual machines to containers
What you cover
- VMs, golden images and why containers won
- Kernel isolation and the Docker architecture
- Dockerfile, build, run, exec and cleanup
- Image layers and multi-stage builds
- Size, startup and security trade-offs
AI in this module
Have an assistant shrink a Dockerfile with a multi-stage build, then compare image sizes and test the container before you trust it.
Outcome
You package any app into a small, reproducible image.
Module 12: Docker networking and Compose
What you cover
- Bridge networking, NAT and port mapping
- Compose: services, networks and volumes
- 12-factor config and .env files
- A three-tier app with a database
- Jenkins in Compose with persistent volumes
AI in this module
Generate a Compose file for a three-tier app with an agent, then find the secret it hard-coded and move it to .env.
Outcome
You run a multi-service app locally with the same config you will ship.
Module 13: Kubernetes: core concepts
What you cover
- Control plane: API server, etcd, scheduler, controllers
- Pods, ReplicaSets, Deployments and rolling updates
- Requests, limits and bin-packing, HPA vs VPA
- Labels, rollbacks and blue/green vs rolling
- minikube, kubectl, kubectx and kubeconfig
- Deploying a real app and troubleshooting it
AI in this module
Ask an agent to write the manifests, then check them with a server-side dry run and kubectl diff before you apply.
Outcome
You deploy, scale, update and roll back an app on Kubernetes.
Module 14: Kubernetes in depth: services, state and operations
What you cover
- Services: ClusterIP, NodePort and LoadBalancer
- Ingress and ingress controllers
- Namespaces, contexts and kubeconfig certificates
- etcd: backups, leader election, member replacement
- Multi-container pods, sidecars and init containers
- Liveness and readiness probes, StatefulSets and volumes
AI in this module
Hand a CrashLoopBackOff to an agent with read-only kubectl access and make it prove its root cause from events and logs.
Outcome
You expose apps safely, keep state alive across restarts and debug a failing pod methodically.
- Phase 3
AI-native operations: agents, local models, observability, GitOps
The part that sets this program apart, and it opens with AI. How LLMs work, agents with skills and MCP, models served from the cluster's own GPUs, then observability with AI-assisted root cause and GitOps delivery to your own namespace. It ends with a live demo and interview prep.
Module 15: AI-native DevOps: LLMs, agents and MCP
What you cover
- How LLMs work: tokens, context windows, caching
- Chat apps, raw models and agents: what each is for
- Claude Code in practice: rules files, skills, session history
- MCP servers for kubectl and metrics, read-only first
- Guardrails: allow and deny rules, approvals, secrets out of context
- AI ethics and where AI breaks prod
AI in this module
Turn a runbook into an agent skill, connect a read-only MCP tool, and set deny rules so the agent cannot apply or delete.
Outcome
You run an agent on real infrastructure and decide exactly what it may see and do.
Module 16: Running LLMs on your own GPU
What you cover
- Choosing a model for the GPU you have, and CPU fallback
- Inference engines: vLLM on the cluster, Ollama on a laptop
- One OpenAI-compatible API for many models with LiteLLM
- Open WebUI on Kubernetes with Helm
- Hooking editor plugins to a self-hosted model
- When a model upgrade breaks your config
AI in this module
Deploy Open WebUI with Helm, connect it to a local model, and compare its answers with a hosted assistant on the same infrastructure task.
Outcome
You can serve a model yourself and explain when self-hosting beats a hosted API.
Module 17: Observability: metrics, logs and AI-assisted root cause
What you cover
- Log levels, and keeping secrets out of logs
- Logs with Loki and Promtail, metrics with Prometheus
- Grafana dashboards on a live cluster
- Core signals: request rate and size, load, disk
- Capacity math: what one core really serves
- Prometheus vs a SaaS agent, and incidents read from load spikes
AI in this module
Feed an agent the logs and metrics around an incident and accept its root cause only when the Grafana graphs back it up.
Outcome
You find out why a service is slow or down from data, not guesses.
Module 18: GitOps with ArgoCD and Helm
What you cover
- Why plain manifests are not enough, and Helm charts and values
- Helm's blind spot, and ArgoCD's drift detection and auto-sync
- Authentication vs authorization, namespace-scoped access
- Your own GitOps repo, synced by ArgoCD into your namespace
- Your site live on its own subdomain behind single sign-on
AI in this module
Let an agent open the pull request that changes your Helm values; ArgoCD applies only what you reviewed and merged.
Outcome
You deploy by merging to Git and can see and fix drift between Git and the cluster.
Module 19: Career: resume, project demo and interviews
What you cover
- Writing experience as projects and measurable results
- Tailoring the resume to each job description
- Reaching recruiters and reading the junior market honestly
- Presenting your project live to a group
- Mock interviews: Terraform drift, Linux troubleshooting, CI/CD
AI in this module
Tailor your resume to each job description with AI, then cut every claim you cannot back with a lab from this course.
Outcome
You walk into interviews with a demoed project and evidence for every line of your resume.
Capstone: your own cluster, built as code and shipped with GitOps
Build a Kubernetes cluster on AWS from scratch with Terraform: one control-plane node and three workers, with their own subnets, security groups and kubectl access. Then ship your app through your GitOps repo into your namespace on the live cluster, with ArgoCD syncing it and the cluster's Grafana dashboards showing how it runs. An agent helps at every step, and every step it takes is reviewed. You finish with a live demo to the group.
After the program you can
- Build and change cloud infrastructure with Terraform and Ansible, and stop a bad plan before it is applied.
- Ship containers to Kubernetes through Jenkins pipelines and GitOps with ArgoCD.
- Operate and debug Kubernetes workloads using metrics and logs, not guesses.
- Run AI agents on real infrastructure with skills, MCP tools, deny rules and human review gates.
- Serve an open-weight model on a GPU and explain when that beats a hosted API.
- Present a portfolio project and defend every line of your resume in an interview.
Programs
Live, instructor-led cohorts. Every student gets their own slice of a real cluster.
Why LabOfDev
Your own cluster namespace
Your own namespace on a real production-grade Kubernetes cluster — kubectl, ArgoCD and Grafana access included.
AI in every module
Every module comes with an AI workflow: agents draft Terraform, review manifests and chase failing pods with you. You learn to direct them and to check their work.
Every session recorded
Every session recorded, indexed into a knowledge base, and tracked against your progress.
Real mentorship
Small cohorts with direct instructor review of your labs and your own GitOps repo.
Interview prep in your cabinet
Match your CV against real job postings, get an honest rewrite that only rephrases what you have actually done, and rehearse with a timed mock interview run on the lab's own AI.
Apply in 30 seconds
Name, email, phone. We get back to you personally and walk you through the program and the next cohort.
What happens next
- You send the form. It takes half a minute.
- We reach out personally. A human, not a bot.
- A short call: your background, your goals, and whether the program fits.
Get in touch
Questions about the program or enrollment? Write to us.