Learning Modules.

Learn networking for DevOps engineers - TCP/IP, DNS, HTTP, subnets, firewalls, and how traffic flows in production systems.

Learn how to stop clicking through cloud consoles and start managing servers, networks, and databases with code - the way every modern DevOps team does it.

Learn Linux for DevOps from scratch - file system, permissions, processes, bash scripting, and production server management.

Learn shell scripting and Bash for DevOps - write production scripts, automate tasks, handle errors, and schedule with cron.

From understanding what CI/CD is to building real pipelines on Azure DevOps - everything a DevOps engineer needs to know, in the right order.

A complete guide to GitLab - from version control and merge requests to building production-grade CI/CD pipelines, container registry, security scanning, and deployment automation.

Security is not something you add at the end. It runs through every step of building and deploying software. This module teaches you the mindset, the tools, and the pipeline practices that make security part of your daily DevOps workflow - not an afterthought.

Master Apache Kafka - producers, consumers, topics, partitions, consumer groups, and building event-driven architectures at scale.

Automate file transfer from Amazon S3 to FSx for OpenZFS so that every file uploaded to a specific S3 path automatically appears on FSx - no manual commands needed after setup.

Learn Python from absolute zero - variables, data types, loops, functions, files, APIs, and real projects. No prior experience needed.

Learn anomaly detection with Isolation Forest - understand how the algorithm works, apply it to real ops metrics, and build a complete anomaly detector from scratch.

Learn prompt engineering from scratch - master zero-shot, few-shot, chain-of-thought, and ops-specific patterns to get reliable results from any LLM.

Learn how AI agents work from scratch - reasoning loops, tool calling, ReAct pattern, and build a real ops incident investigator agent in pure Python.

Give your agent a memory built from your own runbooks and ops docs - so it stops guessing and starts answering from what your team actually knows.

During a production incident, 200 alerts fire and 180 of them are noise from one root cause. This module teaches you how to group, deduplicate, inhibit, and correlate alerts so your team sees one clear signal instead of a storm

Seven ready-to-use prompt templates for RCA, runbook generation, incident updates, and postmortems — so your AI agent reasons like a senior engineer during real incidents.

Build guardrails that prevent your AI agent from running destructive commands in production — with command risk classification, output validation, and human approval gates.

Learn when to use cloud models vs local open source models for ops workloads. Run Llama locally with Ollama for sensitive data and high-volume tasks — zero data leaves your network.

Learn the eight failure patterns that cause production incidents at scale — cascading failures, split-brain, thundering herds, and more — plus CAP theorem, circuit breakers, and the reasoning process that turns alert storms into structured diagnosis.

Learn a structured 5-step process to diagnose production incidents — reading logs, metrics, and traces together to find root cause fast instead of guessing.

Learn to build MCP servers that give AI agents safe, structured access to your Kubernetes cluster, Prometheus metrics, and internal runbooks.

Learn to instrument Python services with OpenTelemetry, collect traces through the OTel Collector, and use distributed tracing to find the exact cause of production incidents.

Learn to write Ansible playbooks, build automated ops runbooks, and connect Prometheus alerts to self-healing workflows that fix production issues without human intervention.

Learn to forecast ops metrics, detect anomalies, and predict capacity issues before they happen using Prophet and ARIMA in Python.

Learn how to secure Git repositories from leaked secrets, unauthorized commits, and supply chain attacks - covering pre-commit hooks, Gitleaks, TruffleHog, branch protection, CODEOWNERS, signed commits, and Dependabot.

Learn how to build and harden CI/CD pipelines - covering OIDC federation, Vault secrets injection, least privilege runners, GitHub Actions permissions, Jenkins hardening, artifact signing with Cosign, and audit logging.

Learn how to embed security into the development phase — covering SonarQube SAST with quality gates, Snyk and OWASP Dependency Check for SCA, CVSS vulnerability prioritization, and HashiCorp Vault dynamic secrets management including Kubernetes sidecar injection.

Learn DAST with OWASP ZAP, generate Software Bills of Materials with Syft, scan for vulnerabilities with Grype, sign artifacts with Cosign, and understand SLSA provenance - through the lens of real supply chain attacks like SolarWinds and XZ Utils.

Learn how to secure Docker containers from image hardening and vulnerability scanning to runtime protection - covering non-root users, minimal base images, multi-stage builds, Trivy scanning, seccomp/AppArmor profiles, capability dropping, read-only filesystems, and the Docker socket threat.

Learn how to secure Kubernetes clusters end to end - covering RBAC and least privilege, Pod Security Standards, Network Policies, Secrets encryption at rest, service account hardening, Falco runtime security, and etcd protection.

Learn how to secure AWS environments end to end - covering IAM least privilege, S3 public access blocking, CloudTrail audit logging, GuardDuty threat detection, Security Hub compliance, KMS encryption, Secrets Manager, VPC security groups, SCPs with AWS Organizations, and AWS Config compliance monitoring.

Learn how to secure Infrastructure as Code with Terraform - covering sensitive variable handling, state file protection, provider credential security, Checkov scanning with CI/CD integration, OPA policy-as-code, and tfsec static analysis to catch misconfigurations before deployment.

Master zero trust identity architecture - covering IAM RBAC and JIT access, OIDC workload federation for Kubernetes on AWS and GCP, HashiCorp Vault PKI and dynamic secrets, SPIFFE/SPIRE workload identity, OAuth2 PKCE, Privileged Access Management, Zero Standing Privileges, Kubernetes service account hardening, and automated secrets rotation.

Build a production-grade runtime security and detection pipeline -covering eBPF fundamentals, Falco syscall-based threat detection with custom rules, Tetragon eBPF enforcement, MITRE ATT&CK mapping for Cloud and Containers, Sigma rules and SIEM conversion, Elasticsearch SIEM with alert correlation and noise reduction, auditd Linux syscall monitoring, OpenTelemetry for security observability, and automated incident response runbooks.

Learn how SOC 2, ISO 27001, and PCI-DSS map to your pipelines, automate compliance evidence, and run incident response from detection to blameless postmortem.

Master supply chain security, secrets detection, fuzzing, threat modeling, chaos engineering, eBPF policies, zero-day response, and CIS benchmarks.

Go beyond CI/CD scanning - learn threat modeling, runtime security, supply chain integrity, cloud security, and compliance automation.

Provision a production-ready Amazon EKS cluster using Terraform with VPC networking, IAM roles, node groups, and autoscaling.

Build a complete CI/CD pipeline on AWS EC2 using Jenkins, SonarQube for code quality, Docker, and ECR for container delivery.

Deploy HashiCorp Vault on Kubernetes, configure dynamic secrets, Vault Agent injection, and AWS KMS auto-unseal for zero hardcoded credentials.

Install Istio on EKS, deploy interconnected microservices, configure canary deployments, mutual TLS, circuit breaking, and visualise with Kiali.

Deploy Spotify's Backstage on Kubernetes, build a software catalog, create golden path templates, and integrate with GitHub and your monitoring stack.

Provision ECS Fargate with Terraform, configure CodeDeploy blue-green deployments with weighted ALB target groups and automatic rollback on health check failure.

Deploy a 3-broker Kafka cluster with Strimzi operator, build producer and consumer services, configure Kafka Connect PostgreSQL sink, and monitor with Grafana.

Build a security-first CI/CD pipeline with Semgrep SAST, OWASP ZAP DAST, Trivy scanning, and Checkov IaC checks blocking on critical findings.

Provision identical app stacks in Mumbai and Singapore with Terraform workspaces, Route53 latency routing, RDS Global Database, and sub-60-second failover.

Configure EKS Cluster Autoscaler with mixed On-Demand and Spot node groups, Node Termination Handler, and pod disruption budgets for 70% cost reduction.

Automate PostgreSQL RDS backups with cross-region copying via Lambda, implement point-in-time recovery testing, and build a validated DR runbook pipeline.

Deploy ELK stack on Kubernetes, ship logs via Filebeat DaemonSet, buffer with Kafka for traffic spikes, and alert on error rate anomalies with Watcher.

Build your first Docker container by packaging a Node.js Express app, writing a Dockerfile, and running it locally with Docker Compose.

Create a GitHub Actions workflow that automatically runs tests, checks code quality, and builds a Docker image on every pull request and push to main.

Launch an AWS EC2 Ubuntu server, configure SSH security, set up a firewall, create user accounts, and deploy a web application with Nginx as a reverse proxy.

Learn Terraform from scratch by provisioning an S3 bucket, EC2 instance, and security group on AWS using infrastructure as code with state management.

Learn Kubernetes fundamentals by deploying a web app with a Deployment, Service, ConfigMap, and HorizontalPodAutoscaler on a local cluster using minikube.

Understand what developers build and deploy - REST APIs, HTTP, Nginx, databases, environment variables, health checks, and microservices - from an infrastructure perspective, not a developer one.

Master GitOps principles and ArgoCD - from understanding why GitOps exists to operating multi-environment deployments, App of Apps, ApplicationSets, and progressive delivery with Argo Rollouts.

Master FinOps for Kubernetes — understand unit economics, implement cost visibility with Kubecost, cut EC2 costs 60-70% with Karpenter and Spot instances, and right-size workloads to eliminate waste.

Learn what separates Platform Engineers from DevOps Engineers - multi-tenancy, admission controllers, policy as code with Kyverno, CRDs, the operator pattern, and Cluster API for declarative cluster lifecycle management.

Build an Internal Developer Platform from first principles - understand why IDPs exist, what problems they solve, how to implement a software catalog and golden paths with Backstage, and how to measure platform success with DORA metrics.

Build a production-grade application platform from scratch - React frontend, Node.js API, PostgreSQL, Redis — containerised with Docker, deployed to Kubernetes with Ingress, NetworkPolicies, HPA, PDB, resource limits, health checks, Prometheus monitoring, and GitOps delivery via ArgoCD.

Provision a complete production-grade AWS infrastructure from scratch using Terraform - VPC, EKS cluster, IAM roles, IRSA, ECR, and remote state. The infrastructure that Capstone 1's application runs on in a real company.

Build a complete GitOps delivery platform - App of Apps pattern, multi-environment promotion from staging to production, ApplicationSets for scale, and progressive delivery with Argo Rollouts canary deployments.

Build a working Internal Developer Platform using Backstage - software catalog, golden path template that creates a new service end-to-end, TechDocs, and Kubernetes integration.

The final test. Take a running application, inject real production failures - pod crashes, OOMKills, bad deployments, cost spikes, network issues - and learn to diagnose and fix each one.

The mega-capstone. One developer action in Backstage triggers the entire platform - Terraform provisions infrastructure, ArgoCD deploys the application, Prometheus monitors it, Kyverno validates policies, Kubecost tracks spend. Everything from Capstones 1-5 working together as one complete Platform Engineering system.

Build a real AIOps anomaly detection pipeline - collect live Kubernetes metrics from Prometheus, run machine learning to detect anomalies automatically, and fire alerts when something unusual happens. No more waiting for users to report problems.

Build an AI agent that receives production alerts, queries Prometheus for context, retrieves runbooks via RAG, and suggests remediation steps automatically.

Wire anomaly detection, AI diagnosis, and Ansible remediation into one autonomous pipeline that detects, diagnoses, and fixes production incidents without human intervention.

Build a production-grade secure pipeline where every push triggers SAST, SCA, secrets detection, container scanning, SBOM generation, and image signing before any code reaches production.

Lock down a production Kubernetes cluster using RBAC, Pod Security Admission, NetworkPolicies, OPA Gatekeeper, Falco runtime detection, and automated compliance scanning.

The mega-capstone. Wire Terraform IaC scanning, secrets management with Vault, zero-trust mTLS, security chaos engineering, and a unified compliance dashboard into one production security platform.

Learn Git and GitHub from first commit to production workflow - branching, merging, pull requests, secrets, CI, and the advanced tools that save you when things break.

"This module teaches you how software goes from raw source code to a deployable artifact.

Learn Docker from the ground up - understand containers, images, Dockerfile, volumes, networking, and Docker Compose. This module takes you from zero to confidently building, running, and shipping containerized applications the way it's done in real DevOps and cloud environments.

Learn Kubernetes from scratch - pods, deployments, services, ingress, Helm, and production-grade container orchestration.

Learn GitHub Actions - build automated CI/CD pipelines, run tests, deploy to cloud, and trigger workflows on every code push.

A complete, practical reference for DevOps engineers. Covers all 20 core AWS services with architecture, flows, real-world usage, CLI commands, and comparisons.

Know how systems are tracked with dashboards.

Harden the containers your code runs in and the Kubernetes clusters that orchestrate them — covering image scanning, access controls, network isolation, policy enforcement, and real-time threat detection.

Learn how Istio and Linkerd add mTLS, canary releases, circuit breaking, and observability without changing app code.

"Learn to write Python that survives production - safe scripts, resilient API calls, and CLI tools SRE teams actually rely on."

Diagnose TCP state issues, DNS failures, TLS errors, and load balancer behavior the way production SREs actually debug them.

Master Linux kernel internals for SRE work - process lifecycle, memory management, cgroups, namespaces, CPU scheduler, and production diagnosis using /proc, strace, and eBPF.

Learn to measure, budget, and systematically eliminate SRE toil using automation, GitOps, self-healing operators, and DORA metrics.

Learn how to define SLIs, set SLOs, calculate and track error budgets, write multi-window multi-burn-rate alerts, and use structured logging and distributed tracing to run production systems reliably.

Learn why distributed systems fail in production - CAP theorem, cascading failures, thundering herd, circuit breakers, and backpressure with real fixes.

Learn to run incidents like a senior SRE - severity triage, the 6-step debugging method, blameless postmortems, and healthy on-call.

Learn to break systems on purpose - Chaos Mesh, LitmusChaos, Game Days, and FMEA to find weaknesses before they become 2am incidents.

Learn the deployment and architecture patterns that make services reliable by design - graceful degradation, feature flags, blue-green and canary releases, multi-region strategy, RTO/RPO, and the Production Readiness Review checklist used before a service goes on-call.

Learn to design systems that are reliable before they are built - architecture reviews, failure mode analysis, PRR, RTO/RPO, multi-region design, and graceful degradation.

Learn to build reliability as a self-service product - golden paths, internal developer platforms, paved roads, and reliability SLAs that scale your impact across every team.

Learn technical leadership without management authority - running postmortem reviews, building on-call capability in others, influencing architecture pre-code, and making the business case for reliability.

Learn to keep PostgreSQL and Redis reliable in production - WAL, replication lag, connection pooling, failover, and PITR.

Master Linux fundamentals for cloud infrastructure - filesystem, processes, SSH, permissions, systemd, and shell scripting on EC2 and cloud servers.

Master networking concepts essential for cloud - IP addressing, CIDR, DNS, TCP/IP, HTTP, and security groups to design and debug cloud infrastructure.

Learn what cloud computing actually changes - service models, deployment models, scalability, availability, AWS global infrastructure, and shared responsibility.

Master AWS IAM - users, groups, roles, policies, and the principle of least privilege to secure every cloud resource you deploy.

Design and build secure AWS VPC architectures - subnets, gateways, route tables, security groups, NACLs, peering, and endpoints for production workloads.

Master EC2 instance types, AMIs, launch templates, Auto Scaling Groups, and load balancers to build scalable, resilient cloud compute infrastructure.

Learn to choose and operate S3, EBS, Instance Store, EFS, FSx, and migration tools like Snowball and DataSync for real production workloads.

Learn RDS, Aurora, DynamoDB, ElastiCache, DocumentDB, and Neptune - and how to pick the right AWS database for any workload.

Learn Route 53 DNS routing policies, CloudFront CDN, ACM certificates, and WAF - and how to design fast, resilient, global-facing traffic paths.

Learn to monitor, audit, and enforce compliance on AWS using CloudWatch, CloudTrail, Config, and EventBridge.

Learn to deploy containers on ECS Fargate and functions on Lambda, and choose the right compute model for any workload.

Learn Terraform's core workflow, state management, modules, remote backends, environment strategies, and AWS-native IaC with CloudFormation and CDK.

Learn GitHub Actions, container and Terraform pipelines, and deployment strategies like blue-green and canary to ship changes safely and fast.

Master Docker from first principles - images, containers, Dockerfiles, volumes, networking, and Docker Compose to containerize real-world applications.

Learn to secure AWS workloads end to end - threat detection with GuardDuty, encryption with KMS, secrets management, WAF, and incident response.

Learn to design modern data lake pipelines, choose real-time ingestion patterns, run ML workflows on SageMaker, and connect hybrid networks on AWS.

Learn to design resilient AWS architectures and control cloud spend - multi-AZ failure design, RTO/RPO, FinOps, and multi-account strategy.

Learn to design AWS data pipelines that do not bankrupt the company - Kinesis, Glue, Athena, Redshift, and Iceberg explained with real cost numbers.

Learn to choose, deploy, and operate ML infrastructure on AWS - from Rekognition to SageMaker training, deployment modes, drift detection, and Bedrock RAG.

Learn which AWS certification to take first, how to build a portfolio hiring managers trust, how cloud engineering career levels differ, and how to research compensation before negotiating.

Build a production observability platform on Kubernetes with Prometheus metrics, Grafana dashboards, Loki log aggregation, and alerting.

Build an enterprise-grade multi-account AWS structure with Organizations, SCPs, centralised logging, and compliance guardrails using automated CloudFormation StackSets.

Deploy Chaos Mesh, run pod-kill and network-delay experiments during live k6 load tests, and measure the SLO impact on Grafana.

Deploy your resume as a serverless AWS app with a live visitor counter — S3, CloudFront, Lambda, DynamoDB, API Gateway, GitHub Actions.

Assemble a complete SRE platform - SLO stack with burn-rate alerting, automated reliability pipeline, chaos engineering, DORA metrics, and blameless postmortems in one production-grade repository.

Build a GitOps pipeline where GitHub Actions builds images and ArgoCD automatically syncs Kubernetes to match Git.

Build automated incident response - GuardDuty detects threats, EventBridge routes findings, Lambda isolates compromised resources and alerts Slack.

Deploy a full Kubernetes observability stack with real SLO definitions, multi-window burn rate alerting, and Slack notifications.

Provision a complete production-grade AWS environment with Terraform — VPC, ECS Fargate, ALB, and RDS across three isolated network tiers.

Learn to write production-grade Python pipeline scripts - pandas, APIs, error handling, logging, and idempotency - the glue language of every data stack.

Master SQL for pipelines - window functions, CTEs, SCD Type 2, and validation queries every data engineer writes daily.

Learn to design relational schemas, star schemas, and slowly changing dimensions that stay fast and trustworthy at scale.

Learn how warehouses store and query data fast, and how to design tables that scan less and cost less.

Build production Airflow DAGs, master idempotent and safe-rerun pipeline design, and progress through ingestion patterns from full load through incremental watermarks to advanced CDC with Debezium.

Learn Docker for data engineering - run Postgres, Spark, Kafka, and Airflow locally with Compose, volumes, and networks.

Learn Flink SQL to process Kafka streams in real time with windows, watermarks, and checkpoints - a working understanding, not operational mastery.

Learn the AWS services data engineers build on daily - S3 data lakes, Glue, Athena, Redshift, and pipeline IAM. AWS-focused; not general cloud fundamentals.

Learn to build tested, documented, version-controlled SQL transformation pipelines with dbt - models, incremental materializations, tests, and lineage.

Learn distributed batch processing with PySpark - DataFrames, partitions, shuffles, joins, and the optimisations that separate a slow Spark job from a fast one.

Learn Kafka for data engineering - topics, partitions, consumer groups, Kafka Connect, CDC with Debezium, and Schema Registry.

Learn practical data governance - catalogs, lineage, access control, masking, and GDPR right-to-erasure - built on top of reliable pipelines.

Learn to catch bad data before it reaches your warehouse using Great Expectations - expectation suites, checkpoints, and Airflow quality gates.

Explore three data engineering career specialisations - analytics engineering, platform engineering, and AI/ML infrastructure - and choose your direction.

Learn cloud warehouse concepts and Delta Lake table formats that power the modern data stack, from Time Travel to Medallion Architecture.

Learn the professional Python an AI engineer uses daily - types, comprehensions, generators, async, modules, and calling AI APIs.

Learn the minimum math toolkit an AI engineer actually needs - vectors, matrices, gradients, and probability - without the full math degree.

Explore five AI engineering specialisation tracks - Agents, Multimodal, Computer Vision, Voice AI, and Language AI - and pick one to go deep on.

Learn core ML: regression, classification, tree models, evaluation metrics, and overfitting so you know when a classical model beats an LLM.

Learn how neural networks actually learn, when to fine-tune instead of train from scratch, and how CNNs, RNNs, and Transformers fit together.

Learn how LLMs generate text, select models on capability, cost, latency, and reliability, and design prompts and structured output for production.

Learn to turn documents into searchable meaning using embeddings, pgvector, and a real ingestion pipeline with metadata, dedup, and PII redaction.

Learn to defend AI applications against prompt injection, bias, and data leaks, and build a pre-launch safety checklist that matches guardrails to real risk.

Learn to evaluate RAG systems, AI agents, and LLM apps with golden datasets, LLM-as-judge, recall@k, faithfulness scoring, and regression testing.

Build reliable AI agents with function calling, agent state, LangGraph, MCP, and production guardrails: retries, step limits, checkpointing, approval.

Learn NumPy, pandas, SQL joins, and data validation to prepare clean training and evaluation data for AI systems.

Learn to deploy, secure, and observe LLM applications in production - FastAPI serving, streaming, Docker, Kubernetes basics, tracing, and cost control.

Learn when fine-tuning beats RAG, why LoRA is the default over full fine-tuning, and how to spot catastrophic forgetting before it ships.

Build and evaluate a company-knowledge chatbot with hybrid retrieval, reranking, golden-dataset scoring, and injection defences.

Wrap the RAG chatbot in a production FastAPI service with auth, rate limiting, tracing, caching, and cloud deployment.

Fine-tune a small model with LoRA on a tone-shifting task and justify fine-tuning over RAG or prompting with real results.

Learn Azure from scratch - portal, identities, storage, compute, networking, and monitoring - to confidently manage Azure and clear AZ-104.

Learn Google Cloud from scratch - projects, IAM, compute, storage, networking, and operations - to confidently manage GCP and clear the Associate Cloud Engineer exam.