If you only have time for one resource on this list, then this learning path is a good start! It’s Microsoft’s guided, easy-to-learn overview of DevOps and it does a decent job of putting the various elements of DevOps that tend to be taught individually together: culture, git and GitHub, continuous integration, continuous delivery, Infrastructure as Code, and observability. You’ll explore five modules, and at the end you will have encountered Site Reliability Engineering and platform engineering, if only briefly.

Topics covered: DevOps principles and culture, Git and GitHub workflow, Continuous Integration, Continuous Delivery, IaC (Infrastructure as Code), shift-left and shift-right practices, monitoring and observability, SRE (Site Reliability Engineering), and platform engineering.

For whom it’s intended: It is designed for beginners, developers, administrators, students, and IT professionals seeking an overview of the concepts before getting involved with any particular products such as Docker or Kubernetes.

Why it’s worth your time: Most tool-specific tutorials assume that you know why DevOps is important. This one does just that, and just in time, the tools make more sense when you reach them.

This one is designed for those who have never worked in DevOps before and seek a simple-to-understand explanation. It views DevOps as a blend of people, process and technology working together to achieve one end: continuously delivering value in short incremental releases. You will receive an introduction to Agile practices, shared goals, cycle-time thinking, source control, Git, GitHub and Azure DevOps. It has no requirements, so it really is a starting point.

You will learn: DevOps, the DevOps culture, Agile practices, DevOps transformation, source control, basic Git, GitHub, Azure DevOps and continuous improvement.

What it’s about: Students, developers, administrators, IT users, and anyone else who wants a straightforward and simple overview before they get their hands on specific tools.

Why it’s worth your time: It doesn’t begin with a lot of ‘how,’ but instead will get you thinking about ‘why’ organizations see the point of restructuring their work around DevOps.

The course comprises exercises that introduce students to the basics of Azure AI Services and demonstrate how to use cognitive services with applications.The course is a series of exercises that familiarize students with the fundamentals of Azure AI Services and show how to integrate cognitive services into applications.

Short on time? This is the fastest way to have a feel for what DevOps culture really is when it is done. It takes about 30 minutes to run and discusses collaboration, continuous learning, automation, and application lifecycle in that short amount of time – a nice warm-up before the long trek.

You’ll learn the basics of DevOps, the DevOps culture, working together, automating, continuous learning, the application lifecycle, and the advantages of DevOps.

It is for: Students, beginners, developers and IT administrators who wish to get an overview before engaging in the longer explanations.

Why it’s worth your time: The short format allows you to read it once, then get on with Git, CI/CD or container tooling without having to scratch your head for context too long.

This module has a focus on the second half of the workflow, development: Source control, Git, GitHub Flow, Continuous integration, testing and security. It also covers shift-left testing and shift-left security – two concepts that you will hear repeated over-and-over again when you begin reading about modern software delivery. The module consists of 10 short units which take less than an hour to run.

What you will learn: Source control, version control, Git, GitHub Flow, Continuous Integration, shift-left testing, shift-left security, and collaborative development.

Who it’s for: Developers and beginners who already have basic IT knowledge and want to see how development practices connect to the broader DevOps picture.

Why it’s worth your time: Git and CI are foundational skills you will use constantly, and this module ties them to real workflow decisions instead of teaching them in isolation.

DevOps isn’t just about the deployment script. This module is focused on planning aspects: Agile methodology, shared responsibility, continuous learning and project planning with GitHub Projects. It’s a good reminder that there’s a lot of organizational work that goes into making DevOps work, rather than technical work.

You will learn: DevOps culture, DevOps practices, Agile methodology, GitHub Projects, project planning, collaboration, continuous improvement and Infrastructure as Code concepts.

For whom: Beginners, Developers, project teams and administrators who want to understand how software projects are planned within a DevOps model.

The reason it’s worth your time: It’s a tutorial that looks at the project-management aspect of DevOps, which is usually ignored in tool-focused tutorials.

This is where things get down and dirty. The module covers the following concepts: Infrastructure as Code, progressive deployment, shift-right testing, and CI/CD through GitHub Actions, accompanied by a practical example with GitHub Actions and Bicep. If you’ve followed the previous modules, then this is where the pieces fit together.

The topics you will learn are Continuous Delivery, CI/CD, GitHub Actions, Infrastructure as Code, Bicep, deployment strategies, shift-right testing and automation.

For whom: Beginners that have already understood the basic concepts of DevOps and want to advance their career into automated delivery of software.

Why you should actively work on it: CI/CD is one of the most frequently mentioned skills found in DevOps job advertisements and this module is a practical and hands-on entry point into CI/CD.

Note: This course is actually within AWS Skill Builder (which you’ll need to sign up for) and AWS does not have a stable public URL that works without having an account. After logging in to Skill Builder (which is free, even if you have no AWS account), you can access and enroll in the course from AWS’s official DevOps training hub at the link below.

This course covers the concepts, methodologies and services appropriate to AWS that enable application development and deployment in a DevOps fashion. It’s for those who are just beginning their cloud-native journey, and provides a decent starting point before you venture into CodePipeline, CodeBuild, CodeDeploy, and CloudWatch.

You will learn about DevOps basics, cloud-native DevOps, DevOps methods, AWS DevOps services, software delivery, application maintenance, and CI/CD.

For: Beginner users who are interested in integrating the DevOps mentality with cloud technologies provided by AWS. Some basic knowledge of clouds is advantageous but it is not required.

What it’s worth your time: If you are thinking about AWS in your career, it provides you a vocabulary to start with before you get into the deeper parts of the AWS DevOps toolchain.

Note: The previous location for the tutorial, docker.com/101-tutorial, has been integrated into Docker’s main documentation site, thus the new link now points to docs.docker.com/101-tutorial.

It is Docker’s official walking tutorial on the basics of containerization and it’s definitely one of the good free tutorials of this list, as you get to do something with it, not just read about it. You will create images, launch containers, use volumes, mount your source code, and experience a little networking and best practices for building images with Docker Compose.

You will learn: Docker basics, Docker containers, Docker images, Docker volumes, Docker Compose, Docker networking, applications to be containerized, and the best practices for image creation.

For whom: Beginners who want practical experience in containers, particularly those who are intent on learning Kubernetes later.

It’s exciting to experience: Containers appear all around in today’s DevOps environment, and this tutorial does not talk about theory, it’s about learning by doing.

The official Kubernetes tutorial is not a slideshow, it’s an actual hands-on tutorial on container orchestration. You will be able to create a cluster, deploy an application, explore the application, expose it to the outside world, scale it and update it, all this in an interactive web browser.

You will learn Kubernetes basics, clusters, application deployment, services and exposure, scaling, application updates, container orchestration and basic troubleshooting.

For whom: Students who have a good basic grasp of containers and wish to advance to Orchestration. For aspiring DevOps and cloud engineers as well.

Why it’s worth your time: It’s often daunting to learn Kubernetes without any real hands-on experience. Instead, this tutorial is broken up into bite-sized, guided steps.

Jenkins is an old project and is one of the most popular software automation servers used for building, testing, and deploying software. Developers who want to learn about CI/CD by doing it, will find a Guided Tour, pipeline tutorials, build examples, multibranch pipeline guides, and other automation walkthroughs in the official documentation.

You will learn Jenkins basics, CI/CD concepts, Jenkins Pipelines, Jenkinsfiles, automated builds, automated testing, deployment workflows and multibranch pipelines.

For: DevOps developers and aspiring DevOps engineers who wish to get hands-on experience with Jenkins. It is easier to follow if you have some basic knowledge of programming and Git.

Designed for beginners, this interactive course focuses on the core principles of programming and computer science.This course for beginners provides a grounding in the principles of programming and computer science in an interactive environment.

If your code is hosted on GitHub, you’ll want to use GitHub Actions, a CI/CD and automation platform that is integrated right within GitHub. The GitHub documentation guides you through workflows, jobs, actions, events and runners, and you can create files for workflows and observe their reactions to real events in your repository as you create them.

What you will do: You will learn the basics of GitHub Actions, including workflows, jobs, steps, events and triggers, runners, automated tests, CI/CD pipelines, and configuring workflows.

For: Developers, students, and aspiring DevOps engineers who have some basic understanding of Git and GitHub and wish to begin automating their own workflows.

Why it’s worth your time: If your team is already on GitHub, this is the least complicated way to the modern CI/CD without having to spin up a separate build server.

The more practical partner to item 11. You don’t read about workflows – you design one within your own repository using interactive learning from GitHub, their own learning platform! Before you move on to more complicated automation, it’s a really useful first go.

This will cover creating a GitHub Actions workflow, workflow YAML, events, jobs, steps, GitHub-hosted runners, basic automation and repository-based CI/CD.

For whom: novices with existing familiarity with the basics of GitHub who wish to learn about workflow automation in a step-by-step fashion.

Why you should invest your time: Learning by doing works better than reading documentation, and this course incorporates doing into its entirety.

You can define infrastructure in configuration files and then repeat and repeat that code just like you would any other code—Terraform can do this; you can’t just click through cloud dashboards by hand. The official HashiCorp tutorials cover the basics and guide you through deployment on AWS, Azure, Google Cloud, Docker, and Oracle Cloud Infrastructure.

What you will learn: Infrastructure as Code, Terraform Fundamentals, Terraform Basics, Terraform Providers, Terraform Resources, terraform init, terraform plan, terraform apply, Terraform Infrastructure Lifecycle, and Terraform State.

It is designed for aspiring DevOps engineers, cloud engineers, developers and system administrators who want to learn infrastructure automation.

There are several reasons to invest the time:

(1) Terraform skills are applicable to nearly every major cloud provider and

(2) HashiCorp’s own tutorials are written from an experience-based perspective.

After you have an understanding of Terraform fundamentals, this collection explores the command line itself: initialising configurations, creating a plan, applying infrastructure, working with variables, managing state, importing existing resources, and troubleshooting.

You will learn: Terraform CLI, terraform init, terraform plan, terraform apply, terraform variables, terraform outputs, Terraform state, resource import, troubleshooting, and version control.

For: Learners who are already familiar with some basic Terraform concepts and wish to become comfortable to run Terraform from the command line on a day-to-day basis.

Why it’s worth your time: The command line is a prerequisite for DevOps work, and these tutorials are based on the commands you use.

The knowledge of init, plan, and apply is only enough. Throughout this series of tutorials, you will learn how to write real-world clean, reusable Terraform configurations, including resource blocks, variable inputs, outputs, dependency, sensitive data, and expressions.

You will learn Terraform configuration syntax, resources, variables, output, dependency, expressions, sensitive variables, structure of configuration, and reusable infrastructure.

For whom: Learners who wish to build on basic commands and begin to write maintainable Infrastructure as Code.

Why it’s worth your time: Writing configuration that scales well is a different skill from running commands, and that is where you’ll develop that skill.

Modules are for structuring Terraform configuration to be used in multiple projects without copying and pasting the same blocks. This official collection of all modules, registry modules, local modules, variables and outputs are explained with practical examples.

What you will discover: Terraform modules, structure of modules, local modules, registry modules, module inputs and outputs, reusable infrastructure, and configuration organization.

Who it’s for: Learners that are already familiar with basic Terraform usage and wish to create more professional, maintainable IaC.

So why it’s worth investing time in: Infrastructure grows, and modules are what separates a clean codebase from a spaghetti mess of duplicated configuration.

This sandbox is for anyone who doesn’t want to install anything locally just to experiment with Terraform, and provides a “sandbox” (hosted, browser-based) environment to do so. It’s an interactive, command-line “space” a user can follow a tutorial without physically connecting to their computer, according to HashiCorp.

You will learn: Terraform commands, infrastructure configuration, Terraform CLI, resources, infrastructure planning, infrastructure deployment, and some experimentation with Terraform.

Target audience: Users who want to get hands-on experience without having to create a local Terraform environment or a cloud account first.

Why it’s worth your time: The free sandbox is one of the easiest ways to actually learn Infrastructure as Code, and it eliminates one of the biggest obstacles for many people trying out the technology before they begin.

Ansible uses human-readable YAML playbooks to automate IT tasks, system configuration and application deployment—making it a bit easier to use for new users than other automation tools. The documentation for the official “getting started” section has introduced the new concept of the control node, inventory, managed nodes, and playbooks, which will be the foundation of your work with Ansible from now on.

You will learn: Basics of Ansible, Control Nodes, Managed Nodes, Inventories, Playbooks, YAML, Configuration Management, and Automation Basics.

It is suitable for: Automating repetitive infrastructure tasks, cloud engineers, system administrators, DevOps beginners and developers.

Why it’s worth your time: Ansible is agentless and its playbooks are readable, which makes it one of the easier automation tools to learn.

Foundations of Ansible provides a primer on the core concepts, terminology and tools required for beginners to start building their own automation. The learning path includes playbooks, modules, tasks and roles, as well as helpful tools like Git, GitHub and Visual Studio Code. It also enables learners to build a development environment and grasp the fundamentals of creating Ansible automation content. (Red Hat Developer)

Learnings: Concepts, playbooks, modules, tasks, roles, Git and GitHub, Visual Studio Code, Development tools and Environment setup on Ansible.

For: Beginners, developers, system administrators and future DevOps professionals who wish to have a good theoretical grounding of Ansible.

Why it’s worth your time: It provides an introduction to the essential information and resources to get started with Ansible and building your own automation.

The fundamental building blocks of Ansible are playbooks. They enable administrators and DevOps engineers to describe the desired state of a system and automate tasks as a batch on multiple machines. Official documentation includes building inventories, writing playbooks, and automating systems remotely via Ansible’s agentless, YAML-based approach.

What you will learn: Ansible playbooks, YAML, Inventory management, Desired state, Remote system automation, Configuration management, Reusable automation, Idempotent operations.

For whom: learners who already have an understanding of these basic Ansible concepts and wish to begin to write reusable Ansible automation for real servers and infrastructure.

Why it’s worth your time: Playbooks are perhaps the most important skill in Ansible – and the ability to structure them well will benefit your next project for life!

Azure DevOps unifies Azure Boards, Azure Repos, Azure Pipelines, Azure Test Plans and Azure Artifacts, enabling Agile planning to be seamlessly integrated with source control, CI/CD, testing and package management. If you want to learn more about them all together, instead of one at a time, the best place to start is at Microsoft’s documentation hub.

You will learn: Azure DevOps basics, Azure Boards, Azure Repos, Azure Pipelines, Continuous Integration, Continuous Delivery, automated testing, Azure Artifacts, and Agile development.

It is for: Developers, DevOps novices, cloud engineers, testers, and project groups interested in Microsoft’s DevOps ecosystem.

It’s worth your time: It’s so convenient once you’re in the habit of having planning, source control, CI/CD and package management all in one place, that’s beneficial if you’re already running on the Microsoft stack.

The concept of DevSecOps is the extension of DevOps concept, but it adds security at all stages, rather than as an afterthought at the end of the DevOps life cycle. Microsoft’s module, which is ironically called “Introduction to Secure DevOps,” covers practices for secure development, threat modeling, SQL injection awareness, and adding automated security checks such as GitHub CodeQL to the pipeline.

You will learn about DevSecOps principles, secure development, secure deployment, secure CI/CD, code scanning, threat modelling, security testing, vulnerability management and much more.

For: Developers, DevOps engineers, security or cloud engineers who wish to integrate security into automated delivery, not as an afterthought.

For whom it’s relevant: As more teams are viewing security as a “pipeline” issue instead of a separate department, you’ll know what this is about in a module.

Employing a “back to basics” approach, the course will cover the art of writing logo designs, typography, and messaging as well as the precise methodology for finding and applying these elements to brand identity.Using a “back to basics” approach, the course will discuss the art of logo design, typography, and messaging and learn the exact process of identifying and incorporating this into brand identity.

Shipping software is only 50% of the job. It’s important to understand how it works when this is operating, and that’s where Prometheus steps in. It is a monitoring and alerting toolkit released open source and it has become a default solution in cloud-native environments. The official getting-started guide provides information about installation, configuration, query of metrics, monitoring targets, and basic alerting.

What you will learn: Monitoring basics, Prometheus architecture, metrics, Prometheus configuration, targets, basics of the PromQL, monitoring applications, and alerting concepts.

For whom: DevOps engineers, cloud engineers, system administrators and developers looking to incorporate monitoring into their DevOps development process.

It’s a worthwhile investment of time: If you deploy software without monitoring it, you will be confronted with surprises at night. Prometheus provides you with an effective and robust starting point for metrics-based observability.

GitOps sees Git as the single source of truth for application and infrastructure configuration, while Argo CD is one of the most popular tools to execute this vision on Kubernetes. The official documentation guides you through installation, application creation, syncing and workflows for deployment with Git.

The following are the topics that you will learn: GitOps fundamentals, Argo CD, Declarative deployment, Kubernetes applications, Git repository as source for configuration, Application synchronization, Continuous Delivery, and Kubernetes deployment automation.

For whom: DevOps and cloud learners with some Kubernetes knowledge looking to learn about modern delivery using GitOps.

Why it’s worth your time: GitOps is a popular way of delivering Kubernetes, and with Argo CD you will get hands-on experience of handling a deployment through Git instead of manual commands.

Note: This is not a course by itself, but one of 24 resources. It is a collection of the tools discussed above that are put into one single and usable project. It’s not an official page but the link below takes you to the DevOps catalog on Microsoft Learn that is the closest you will get to having a central page for these types of project-based practices.

Project-based learning really is one of the more effective ways to make use of random DevOps concepts to skills that can be applied. Once you have covered the individual technologies of Git, CI/CD, Docker, Kubernetes, Terraform, and Ansible, the next logical step is the integration of these technologies. The kind of project you might want to start with could be, for example, storing application code in Git, building a Docker image, running automated tests, setting up a CI/CD pipeline, provisioning infrastructure with Terraform, deploying containers to Kubernetes, and monitoring it with Prometheus or similar.

You will learn: git development, creation of CI/CD pipelines, containerization with Docker, Infrastructure as Code with Terraform, automation with Ansible, cluster deployment with Kubernetes, cloud deployment, monitoring and observability, and Devops automation in general.

For whom: Learners who have mastered the basics and are looking for hands-on practice to put in their portfolio, especially for students and job seekers preparing for interviews.

The value/necessity: It’s not enough to simply know each tool, it’s important to understand how to put them together to create a working system. In a project, you need to integrate the development, automation, infrastructure, deployment and monitoring into one complete solution.

At the heart of the example project workflow is the developer, who pushes code into the Git repository, which triggers a CI Pipeline that runs automated tests, Docker and pushes to the Container Registry which is deployed to Terraform, Kubernetes, and then monitored.

Keep it simple by beginning with a web application and slowly introduce automation and infrastructure as your abilities increase.