DevOps Projects for Beginners and Pros (2026)

DevOps projects that build a working pipeline: CI/CD with GitHub Actions, Docker images, Kubernetes deployments, Terraform and OpenTofu modules, observability and platform engineering.

45 projects: 9 beginner, 17 intermediate, 19 advanced. Every step is checked as you go, an AI mentor helps when you are stuck, and you finish with a verifiable certificate.

DevOps projects

Python for DevOps: Begineer to Advanced with Project — Beginner-friendly, hands-on program where learners with zero coding background build a small but realistic “PyOps” toolkit used by SRE/DevOps teams (beginner · $1)
Jenkins Pipeline for Kubernetes Cluster — This projects target the ci/cd deployment of kubernetes based cluster for Library Management System by using jenkins. (advanced · Free)
MERN Deployment with Docker Compose with Persistent Storage — This project deploys a full-stack MERN (MongoDB, Express, React, Node.js) application using Docker Compose with three services frontend, backend, and MongoDB each in separate containers. (beginner · Free)
Containerizing a Flask App with Docker — A modular Flask web application built step-by-step for local and Dockerized environments. (beginner · Free)
Deployment on EC2 using GitHub Actions — Deploying a simple static HTML application to an AWS EC2 Ubuntu instance with Nginx as the web server using github actions. (beginner · Free)
Kubernetes Deployment Strategies — You'll simulate deployment updates using Blue-Green, Canary, and Rolling strategies with sample applications, enabling zero-downtime releases and safer application updates. (advanced · $1)
Mastering Docker Volumes: Bind Mounts, Named Volumes & Storage Strategies — This project introduces and dives deep into Docker’s volume management system, covering Bind Mounts, Named Volumes, and Anonymous Volumes. (intermediate · $1)
Terraform on AWS from Scratch — Learn Terraform from zero by building a realistic AWS stack: multi-AZ VPC, public/private subnets, Security Groups, Launch Template + Auto Scaling Group behind an Application Load Balancer (intermediate · $1)
Kubernetes RBAC for Starters — Kubernetes RBAC for Starters (advanced · $1)
Container Security with Trivy — This intermediate course is designed for DevOps engineers, security analysts, and IT professionals eager to master container security practices using Trivy. (intermediate · Free)
Kubernetes CRD and Controller: Building a Custom Database Operator — Build a custom Database Operator by gaining the hands-on experience in kubernetes CRD (advanced · $1)
Docker Fundamentals: Images, Containers, and the Container Runtime — Learn Docker by containerizing a real Node.js app: images vs containers vs runtime, volumes, networking, tagging, registries, and troubleshooting containers that won't start. (beginner · $1)
Docker Compose for Local Multi-Service Development — Follow a backend engineer replacing fragile docker run commands with one docker-compose.yml: health-checked Postgres, live-reload bind mounts, a Redis cache, and fixing a real networking bug. (beginner · $1)
Azure Kubernetes Service (AKS) and Azure DevOps Pipelines — Stand up an AKS cluster wired to Azure Container Registry, then build an Azure Pipelines CI/CD workflow with staging, production, and approval gates. (intermediate · $2)
GitHub Actions from Basics to Reusable Workflows and Self-Hosted Runners — Follow a startup engineer as she builds her team's GitHub Actions pipeline: workflow triggers, build matrices, secrets, reusable workflows, and OIDC cloud deploys with self-hosted runners. (intermediate · $2)
Kubernetes Foundations: Architecture, Core Objects, Pod Lifecycle, and Service Discovery on EKS — Learn Kubernetes architecture, core objects, Pod lifecycle, and service discovery by deploying a real Flask + PostgreSQL app on EKS. (beginner · $1)
Kubernetes Production Capstone: Real-World Access, Security, and Incident Scenarios — Deploy the full three-service app as one production system on EKS, then run real IAM access, secret-rotation, rollback, autoscaling, and node-maintenance drills against it. (advanced · $3)
Ansible for Configuration Management and Application Deployment — Learn Ansible by automating a logistics company's servers: inventories, ad-hoc commands, idempotent playbooks, roles, Jinja2 templates, and vault-encrypted secrets for app deployment. (intermediate · $2)
DevSecOps Fundamentals — Learn how DevSecOps reshapes the SDLC and wire SAST, SCA, and container scanning into a real CI/CD pipeline through one payments startup's story. (intermediate · $2)
Observability and Troubleshooting Kubernetes Workloads in Production — Instrument a Flask microservice with Prometheus and OpenTelemetry, build Grafana dashboards, design alerts that don't get muted, and debug broken Kubernetes workloads systematically. (advanced · $2)
GitLab CI/CD: Pipelines, Runners, and Multi-Project Pipelines — Build real GitLab CI/CD pipelines: stages, rules, artifacts, shared and self-hosted runners, caching, and multi-project and parent-child pipeline patterns. (intermediate · $2)
Kubernetes Networking Deep Dive: CNI, eBPF, NetworkPolicy, and Service Mesh — Go under the hood of Kubernetes networking: CNI internals, NetworkPolicy enforcement, eBPF-based Cilium, and what a service mesh really adds. (advanced · $2)
Linux Fundamentals for DevOps Engineers: Filesystem, Processes, and Permissions — Learn core Linux skills for DevOps: the filesystem hierarchy, permissions, process management, systemd, and package management through a real sysadmin story. (beginner · $1)
Multi-Cloud Strategy: Designing Portable Architectures Across AWS, Azure, and GCP — Follow a fintech's forced multi-cloud acquisition to learn real multi-cloud drivers, Kubernetes and Terraform portability patterns, Crossplane, and when abstraction isn't worth building. (advanced · $2)
Building an SRE Practice: SLOs, SLIs, and Error Budgets — Learn to define meaningful SLIs, set defensible SLOs, calculate error budgets, and use burn-rate alerting to balance reliability with feature velocity. (intermediate · $2)
Google Kubernetes Engine (GKE) and Cloud Build — Move a freight-tracking API onto GKE, choose Autopilot vs Standard, use Artifact Registry, then automate build-push-deploy with a Cloud Build pipeline triggered by every git push. (intermediate · $2)
Operating Kubernetes in Production: Cluster Maintenance and Secure Supply Chain Delivery — Operate a production Kubernetes cluster: safe node drains and PDBs, Velero backup and restore, and a secure image supply chain with scanning, SBOM, and cosign signing. (advanced · $2)
Packaging and GitOps for Kubernetes: Helm, Kustomize, and Argo CD — Package a real Flask microservices app with Helm and Kustomize, then automate its rollout across environments with Argo CD and GitOps. (advanced · $2)
Progressive Delivery: Canary and Blue-Green Releases with Argo Rollouts and Flagger — Learn progressive delivery with Argo Rollouts and Flagger: automate canary analysis against Prometheus metrics and run safe blue-green releases with instant rollback. (advanced · $2)
Scheduling, Resource Guardrails, and Autoscaling in Kubernetes: HPA, VPA, and Karpenter — Apply node/pod affinity, taints, resource guardrails, HPA, VPA, and node autoscaling (Cluster Autoscaler, Karpenter, EKS Auto Mode) to a real 3-service EKS app. (advanced · $2)
Terraform at Scale: Remote State, Workspaces, and Multi-Environment Patterns — Scale Terraform across a team: remote state with S3 and DynamoDB locking, workspaces vs. directory-per-environment patterns, Terragrunt for DRY configs, and OPA policy-as-code governance. (advanced · $2)
Terraform Fundamentals: Providers, State, and Modules — Learn Terraform from first principles: HCL syntax, the AWS provider, resources vs. data sources, state management, variables, outputs, and reusable modules. (beginner · $1)
Testing and CI/CD for Data Pipelines — Test dbt models and Python transforms, wire CI to run on every PR, and roll out pipeline schema changes safely with a real rollback plan. (intermediate · $1.50)
Workloads, Storage, and Exposing Microservices: DaemonSets, StatefulSets, Ingress, and Gateway API — Add DaemonSets, Jobs, CronJobs, StatefulSets with persistent storage, a 3-service microservice split, ALB Ingress, and Gateway API with cert-manager to a real EKS app. (intermediate · $2)
Chaos Engineering Fundamentals — Learn chaos engineering the right way: form hypotheses, inject real faults into Kubernetes with Chaos Mesh, and turn findings into concrete resilience fixes. (advanced · $2)
GenAI Observability: Traces, Metrics, and OpenTelemetry for LLM Apps — Learn to instrument GenAI applications with traces, metrics, and OpenTelemetry semantic conventions so you can debug, evaluate, and audit LLM systems in production. (intermediate · $1)
Golden Paths and Self-Service Infrastructure — Follow a platform engineer pave a golden path with Terraform modules and Crossplane claims, then govern self-service infrastructure with guardrails, versioning, and adoption metrics. (advanced · $2)
Monorepo vs Polyrepo: Repository Strategy for Platform and GitOps Teams — A platform engineer at a freight-tech startup weighs monorepo vs polyrepo, tames CI and ownership with CODEOWNERS, and designs a GitOps repo layout Argo CD can watch. (intermediate · $1)
Multi-Stage Builds, Image Optimization, and Container Security Scanning — Shrink a bloated Docker image with multi-stage builds and smarter base images, then scan it with Trivy and gate CI on vulnerability severity. (intermediate · $2)
Tekton and Argo Workflows: Kubernetes-Native CI/CD Pipelines — Build Kubernetes-native CI/CD pipelines with Tekton and Argo Workflows: write Tasks and DAGs that build, test, and trigger a GitOps deploy from inside your cluster. (advanced · $2)
Building an Internal Developer Platform with Backstage — Follow a platform team standing up Backstage to end tool sprawl, build a real software catalog with live Kubernetes data, and ship a self-service template that scaffolds new services in minutes. (advanced · $2)
Open Model Production Serving: vLLM, SGLang, and GPU Capacity Planning — Compare open-model serving stacks, plan GPU capacity and Kubernetes deployment, and manage safe model rollouts with versioning, eval gates, and rollback. (advanced · $2)
Securing EKS Workloads: IAM Roles, Pod Hardening, Secrets, and Policy as Code — Secure real EKS workloads for a healthcare claims platform: IRSA and Pod Identity, hardened Pods, External Secrets Operator, and Kyverno policy as code. (advanced · $2)
Emerging Tech Review: Serverless, Containers, Edge and AI — Review four emerging cloud services for a fintech: a least-privilege Lambda, container scans, edge kiosks, AI risks, a Well-Architected review and a DevSecOps pipeline. (intermediate · $3)
Secure-by-Default Storage Module with OpenTofu — Write an OpenTofu module any team can call with one input and get a hardened storage bucket, checked by policy-as-code on every plan. (intermediate · $3)

Practise DevOps more

DevOps engineer simulation: Hands-on AWS, Terraform and Kubernetes work in a simulated job.
AWS certification path: Cloud Practitioner to Professional, learned hands-on.
Free Git playground: Practise Git commands and GitHub workflows in your browser.

Frequently asked questions

What DevOps projects should a beginner start with?

Containerise an app with Docker, build a CI pipeline that tests and ships it, then deploy it to Kubernetes or a cloud VM with infrastructure as code. The projects here follow that order.

Do I need to install anything for these DevOps projects?

Most projects run in labs inside your browser (SQL, Excel, Python, Power BI, Git and more). Cloud projects say up front when they use your own AWS account or a simulator instead.

How is a Bartman project different from a tutorial?

You do the work yourself, step by step. Each step is checked automatically, and an AI mentor helps when you are stuck, so you finish with work you can show rather than a video you watched.

Do I get a certificate?

Yes. Finishing a project earns a certificate with its own ID that anyone can verify on bartman.ai.

What is Bartman?

Bartman (bartman.ai) is a learning platform where you build real projects with an AI mentor, practise in free browser labs, take mock tests and practice exams, and run job simulations. It was founded in 2025 and is based in Hyderabad, India.