Cloud & DevOps.
Online in the UK.

The vast majority of cloud servers run Linux. Before you can manage infrastructure, deploy containers, or configure cloud services, you need to be fluent in the Linux command line. This week takes you from zero to navigating, managing files, and understanding the operating system that powers most of the modern internet, including AI training clusters and inference servers.

• Linux Essentials
• Shell Scripting and Automation

Your practical challengeBuild a bash script that monitors a specific process and automatically restarts it if it crashes. Test it by killing the process manually and watching your script bring it back. Add logging so every restart is recorded with a timestamp.

Networking is the invisible foundation of everything in the cloud. Every request, every deployment, every API call travels across a network. If you cannot debug a connectivity issue, you will be stuck on problems that take minutes to solve once you understand the fundamentals.

• Core Networking Concepts
• Practical Networking and Troubleshooting

Your practical challengeSet up two Linux servers and configure them to communicate over a private network. Then deliberately break connectivity in three different ways (DNS, firewall, routing) and document how you diagnosed and fixed each issue.

Every piece of code and every infrastructure configuration you write needs version control. Git is the universal tool for tracking changes, collaborating with teams, and maintaining a history of your work. In the AI era, Git is not just for application code-it is for Terraform modules, Kubernetes manifests, CI/CD pipelines, and even AI model configurations.

• Git Fundamentals
• Collaboration and GitHub Workflows

Your practical challengeCreate a Git repository that simulates a real team workflow: create three feature branches, make conflicting changes to the same file on two branches, resolve the merge conflict, and set up a branch protection rule that requires at least one approval before merging to main.

Python is the language of cloud automation. It is how you control AWS programmatically, build infrastructure tools, integrate APIs, parse logs, and work with AI platforms. DevOps engineers who can write Python are significantly more competitive in the job market.

• Python Fundamentals for Infrastructure
• Practical Python Automation
• Recap Session - Weeks 1 - 4

Your practical challengeBuild a Python script that monitors a directory for new files, automatically categorises them by extension (logs, configs, scripts), moves them into organised folders, and sends a summary to the terminal every hour. Add command-line arguments to configure the watched directory and interval.

Two sessions to revisit Linux, networking, Git and Python before Module 2. You work through troubleshooting scenarios, explain your reasoning out loud and connect the tools into one workflow.

• Linux, Networking and Git in Practice
• Python and Automation Recap

Docker changed how software is deployed. Instead of 'it works on my machine' problems, Docker packages your application and everything it needs into a portable container that runs the same everywhere. Most modern companies use containers, and nearly every AI model in production runs in a container.

• Containers and Images
• Running and Managing Containers

Your practical challengeTake one of the Python scripts you built in Week 4 and containerise it. Write an optimised Dockerfile with multi-stage builds, configure it to accept settings through environment variables, add a health check, and push the image to Docker Hub.

Real applications are not a single container. They are systems: a web server, a database, a cache, a message queue, all working together. Docker Compose lets you define and run multi-container applications with a single file.

• Multi-Container Applications with Docker Compose
• Docker in Production

Your practical challengeTake a real-world open source application (e.g., a WordPress site with MySQL, or a Node.js app with Redis and PostgreSQL) and write a complete Docker Compose setup from scratch. Include health checks, restart policies, proper networking, volume persistence, and security scanning. Optimise all images using multi-stage builds.

CI/CD is the heartbeat of modern software delivery. Every time code is pushed, a pipeline automatically tests it, builds containers, and deploys. This is what DevOps engineers build and maintain. This week also introduces the course project you will build throughout the bootcamp.

• Course Project Introduction and CI/CD Fundamentals
• Advanced CI/CD and Deployment Strategies
• CD Overview & Overall Recap

Your practical challengeBuild a GitHub Actions workflow for your course project that does everything: runs linting, runs tests, builds Docker images, scans for vulnerabilities, pushes to a container registry, deploys to a staging environment, runs smoke tests against staging, and then promotes to production, all triggered by a single push to main.

AWS is the world's largest cloud platform, powering everything from startups to Netflix to the majority of AI companies. This week focuses on the foundational services you will use in every single AWS project: identity, networking, storage, compute, and monitoring.

• AWS Fundamentals
• AWS for Real-World Applications
• Session 1 Close-Out: AWS Fundamentals

Your practical challengeDesign and build a multi-tier network architecture in AWS: a public-facing web application, a private API layer, a database that should never be accessible from the internet, and a bastion host for SSH access. Include subnet design, route tables, security groups, and a NAT gateway. Document every design decision.

Two sessions to consolidate Docker, Compose, GitHub Actions and AWS core services before Module 3. Scenario questions, live debugging and open Q&A reinforce the decisions behind each tool.

• Docker and CI/CD Deep Review
• AWS Foundations Review

This week goes deeper into AWS compute and storage decisions. You will learn how to think about EC2, block and shared storage, Lambda, Spot instances, and practical AWS automation with Python and Boto3.

• AWS Compute and Advanced Services
• Infrastructure Automation with Python and Boto3

Your practical challengeBuild a complete 'infrastructure nuke' script with Boto3: it should list all EC2 instances, S3 buckets, and VPCs in your account, ask for confirmation, and then safely tear everything down in the correct order (instances first, then networking, then storage). Include dry-run mode and logging.

This week teaches you to think about system design clearly and communicate it well. The focus is not just architecture theory, but how to break systems down, reason about their parts, and draw architecture diagrams that other engineers can actually understand.

• Application Architecture Fundamentals
• Architecture Diagram Workshop

Your practical challengeDesign a complete architecture for a modern multi-service application: a user-facing web app, a backend API, background workers, a monitoring stack, and a data store. Define how each component communicates, where each component runs, how it scales, and what happens when any single component fails.

Terraform lets you define your entire infrastructure as code, version controlled, peer reviewed, and repeatable. Change one line and your infrastructure updates. This is how professional teams manage cloud environments without clicking through consoles, and it is the foundation of every self-service platform engineering approach in use today.

• Terraform Fundamentals
• Advanced Terraform and Team Workflows
• Reusable CI/CD, Base Images, and the Self-Service Platform

Your practical challengeCreate a Terraform module library for your course project: build reusable modules for VPC, EC2, S3, and security groups. Each module should accept variables for different environments. Deploy your entire project infrastructure to a 'dev' environment using only `terraform apply` with a variables file. Then create a CI/CD pipeline that runs `terraform plan` on every PR and `terraform apply` on merge to main.

Docker runs individual containers. Kubernetes runs hundreds of them, automatically scaling, healing, and load balancing your applications. It is the operating system for the cloud era, and it is the technology that makes large-scale infrastructure possible.

• EKS, Cluster Architecture, and Kubernetes Fundamentals
• Deploying Ledgeway to Kubernetes

Your practical challengeDeploy your course project on Kubernetes: create Deployments for each service, configure Services for internal communication, set up an Ingress for external access, add persistent storage for your database, and implement network policies that restrict which Pods can talk to each other. Package everything as a Helm chart.

Two sessions to consolidate AWS automation, architecture design, Terraform and Kubernetes before Module 4. You explain concepts back to the group and work through real cluster scenarios.

• AWS Automation, Terraform, and Architecture Recap
• Kubernetes Core Objects and Real Cluster Operations

Turn the Kubernetes manifests built in Week 14 into repeatable Helm releases, then use ArgoCD to reconcile Ledgeway from Git rather than relying on manual cluster changes.

• Helm for Kubernetes
• Session 1 Close-Out: Helm Release Operations and GitOps Bridge
• ArgoCD and GitOps for Ledgeway

Your practical challengePackage the Ledgeway Kubernetes resources as a Helm chart with separate environment values, then implement a GitOps workflow: install ArgoCD, configure an Application to watch the Git source, and demonstrate a reviewed change flowing from Git to the dev cluster. Document a safe promotion path from dev to staging and production.

You can't fix what you can't see. Build a complete observability platform for Ledgeway: deploy Prometheus, Grafana, Loki, and Tempo, instrument every service with application metrics and distributed traces, and investigate a real incident from alert to root cause without leaving Grafana.

• See Your System: Metrics and Logs
• Distributed Traces and Alerting

Your practical challengeInstrument your course project with full observability: deploy the stack, add prom-client metrics to at least two services, add OTel tracing to at least two services, and demonstrate a complete incident investigation: start from a Grafana error rate panel, find the error in Loki, and click through to the Tempo trace showing which span caused the failure.

A running platform is not a secure platform. This week you make Ledgeway defensible: policy as code with OPA Gatekeeper, secrets hygiene with AWS Secrets Manager and the External Secrets Operator, identity scoping with RBAC, network isolation with NetworkPolicies, and a live incident response drill using the observability stack you built in Week 17.

• Infrastructure Security and Policy as Code
• Zero Trust, RBAC, and Incident Response

Your practical challengeHarden the Ledgeway dev namespace end to end: write a Gatekeeper ConstraintTemplate that blocks any pod using the `latest` image tag; write a NetworkPolicy that allows only `ledgeway-api-gateway` to reach `ledgeway-auth-service` on port 4010 and verify that a test pod without the right label is blocked; add a second ExternalSecret for a new secret path in Secrets Manager and verify the K8s Secret appears and is deleted when the ExternalSecret is removed. Document the blast radius of your changes: what could an attacker do before vs. after.

The final week. Two open, discussion-led sessions that look back at the full bootcamp and forward at what comes next. Session 1 includes a retrospective slide deck; both sessions centre on honest conversation about what was built, what it means and what to do next.

• From Week 1 to Here - Retrospective and Open Discussion
• The Real World - Career, Industry, and What Actually Matters

The final bonus session: an infrastructure-focused introduction to MLOps, showing how familiar DevOps practices support machine-learning data, training, model delivery, inference and monitoring-followed by the bootcamp outro.

• Bonus Session and Outro: MLOps Foundations

Your practical challengeBuild a complete MLOps pipeline: train a model, track the experiment in MLflow, register it in the model registry, deploy it as a containerised API on Kubernetes, set up monitoring for inference metrics, implement drift detection, and create a CI/CD pipeline that automatically retrains and redeploys when drift is detected. Document the entire architecture.