Every phase follows one pattern: learn, read official docs, build, watch, use AI carefully, and prove the result. Time estimates are flexible - depth and evidence matter more than speed.
Understand how software moves from idea to reliable production service.
Draw a delivery flow for a small web service. Identify every manual handoff, failure point, and feedback signal.
Explain a delivery pipeline end to end and name one automation opportunity at each handoff.
Safety: Concepts phase - no live systems yet. Do not paste employer diagrams or internal data into any AI tool.
Operate a Linux machine confidently before adding cloud abstractions.
Run a Linux VM, create a least-privilege service user, install a web server, manage it with systemd, and recover it from a failed configuration.
Diagnose a process, permission, port, disk, or service failure from the command line without relying on a GUI.
Safety: Use a throwaway VM, not a production host. Never run rm -rf or chmod on system paths without understanding scope.
Trace how a request travels from client to service and back.
Place a web service behind a reverse proxy. Configure DNS locally, terminate TLS in a safe test environment, and document the request path.
Explain why a service is unreachable by separating DNS, route, firewall, listener, proxy, and application failures.
Safety: Test TLS with self-signed certs in a lab only. Never expose test proxies to the public internet without hardening.
Make changes that teammates can review, reproduce, and safely release.
Create a service repository with branch protection, pull-request checks, a contribution guide, and a tagged release. Intentionally resolve one merge conflict.
Recover a previous version, explain any commit, and make a clean pull request containing a reproducible change.
Safety: Never commit secrets or .env files. Prefer new commits over history rewrites on shared branches.
Write reliable automation instead of hiding operational work in ad-hoc commands.
Build a Python health-check CLI that tests endpoints, reports latency, emits a non-zero exit code on failure, and has unit tests.
Automate a repeated task with validation, logs, safe failure behavior, tests, and a clear README.
Safety: AI-generated code can be subtly wrong. Run tests and read the logic before trusting automation with real systems.
Package applications consistently and understand what runs inside a container.
Containerize the service from previous phases, run it with a database through Compose, add a health check, and publish an immutable image tag.
Build a repeatable image, explain its runtime dependencies, and debug a failed container from logs and metadata.
Safety: Do not embed secrets in image layers or ENV. Pull only trusted base images; scan before pushing to a registry.
Turn every change into a tested, traceable, releasable artifact.
Create a pipeline that checks the repository, runs tests, builds a container, scans it, stores an artifact, and deploys only after a protected approval.
Show a commit-to-deployment trail and prove a bad change stops before production.
Safety: Store secrets in the CI secret store, never in YAML. Require human approval before any production deploy step.
Design a secure, observable cloud environment instead of clicking resources into existence.
Deploy a small service into isolated public and private network layers. Add IAM roles, encrypted storage, logging, a budget alert, and an architecture diagram.
Explain each cloud resource, its trust boundary, its failure mode, and its expected cost.
Safety: AWS labs cost money. Set a budget alert, use free-tier where possible, and tear down resources when done.
Make infrastructure reviewable, repeatable, and recoverable.
Provision the cloud foundation with Terraform. Store state remotely, split reusable modules, run plan in CI, and require review before apply.
Recreate the environment from an empty account and explain every planned change before applying it.
Safety: terraform destroy and apply change real infrastructure. Review plans, protect state, and never commit state files.
Configure machines predictably while keeping desired state explicit.
Configure a fresh VM with a hardened user, runtime dependencies, reverse proxy, service unit, log rotation, and a repeatable Ansible playbook.
Run automation twice with no unwanted changes and prove the target machine matches declared configuration.
Safety: Playbooks act on real hosts. Use --check and a lab inventory before touching anything shared.
Store, rotate, and access credentials without scattering them across code and pipelines.
Move all pipeline and app credentials into a secret store, wire short-lived cloud access through OIDC, and add secret scanning to CI.
Prove no static long-lived credential exists in code, images, or CI variables, and rotate one secret without downtime.
Safety: Never paste real secrets into any AI prompt. A leaked key must be rotated, not just deleted from a file.
Deploy and troubleshoot workloads on a declarative cluster platform.
Deploy the containerized service with a Deployment, Service, Ingress, ConfigMap, Secret, probes, resource limits, and a rolling update. Break it and repair it.
Trace a request to a Pod, diagnose CrashLoopBackOff or Pending states, and roll back a failed deployment.
Safety: Confirm AI diagnoses against real cluster state before acting. Cloud clusters (EKS) accrue cost - tear down labs.
Use Git as the auditable source of desired environment state.
Create a GitOps repository for staging and production. Promote an image by pull request, observe reconciliation, then revert the change to recover.
Deploy without manual cluster edits and show who changed what, when, and why.
Safety: GitOps auto-syncs what is in Git. A wrong merge deploys to production - protect branches and require review.
Operate services using evidence rather than guesswork.
Instrument the service, build a dashboard for traffic, errors, latency, and saturation, add actionable alerts, and write a runbook for one outage.
Use telemetry to identify the failing layer, communicate impact, and restore service with a documented procedure.
Safety: A noisy or wrong alert erodes trust. Test alert rules and thresholds before enabling paging.
Build security controls into delivery without treating security as a final gate only.
Add secret detection, dependency scanning, image scanning, IaC checks, SBOM generation, and a policy that blocks a known unsafe deployment.
Describe the risk, evidence, owner, and remediation path for every security finding instead of ignoring scanner output.
Safety: AI can miss or misjudge vulnerabilities. Treat scanner and AI output as leads to triage, not verdicts.
Prove the system survives failure instead of assuming it does.
Run a controlled chaos experiment (kill a Pod, drop a dependency), observe telemetry, recover, and write a blameless postmortem.
Recover from a simulated failure within your stated RTO and document what broke, why, and the fix.
Safety: Chaos experiments can cause real outages. Run in a lab or with strict blast-radius limits and a rollback plan.
Turn scattered tooling into a paved road that developers can self-serve safely.
Build a service template and a self-service workflow that scaffolds a repo, CI pipeline, and deployment from one request.
A new service goes from request to running with checks, ownership, and observability without manual platform-team steps.
Safety: A flawed golden path scales mistakes to every team. Test templates end to end before making them the default.
Treat cost as an engineering signal, not a monthly surprise.
Add cost allocation tags, build a cost dashboard, find one waste source, and cut it with a documented before/after.
Explain your top three cost drivers, show a real reduction, and set an anomaly alert with an owner.
Safety: Cost optimization can break things (deleting the wrong resource, undersizing). Verify impact before applying changes.
Use AI to accelerate operations and to run AI workloads responsibly.
Deploy a small model or agent behind an API with observability, rate limits, evaluation, and an approval step for risky actions.
Ship an AI-assisted ops workflow that logs decisions, requires human approval for changes, and can be rolled back.
Safety: Autonomous agents can take unintended actions. Require human approval for writes and keep an audit log of decisions.
Turn skills into a portfolio that demonstrates judgment, not just tool familiarity.
Ship a capstone: application, CI/CD, cloud IaC, Kubernetes + GitOps, observability, security checks, FinOps tagging, an AI-assisted runbook, and a tested recovery.
Demo the system, explain trade-offs, recover it under pressure, and publish architecture, pipeline, security, cost, and operations evidence.
Safety: Portfolio content is public. Scrub employer names, secrets, and internal data before publishing anything.
Beginner to Advanced, mapped across phases 01-20. Each project reuses earlier work, so your portfolio shows progression instead of disconnected tutorials.
Build a small service, containerize it, test it in CI, publish an immutable image, and deploy through a safe staging step.
Prerequisite: None - start here.
Proof: repository, green checks, image tag, README, and rollback notes.
Compounds: This image and delivery pipeline become the input for Projects 02 and 03.
Reuse the same service with IAM, VPC, compute, storage, Terraform, configuration management, secrets, monitoring, budgets, and a destroy path.
Prerequisite: Project 01 image, repository, and CI checks.
Proof: plan/apply/destroy run, architecture diagram, cost guardrails, and failure notes.
Compounds: This cloud foundation becomes the platform that Project 03 operates.
Move the same image to Kubernetes, manage it with GitOps, observe it, secure it, test recovery, add platform and FinOps practices, and ship one guarded AI-ops workflow.
Prerequisite: Projects 01 and 02: same image plus AWS foundation.
Proof: deployment history, dashboards, security scan, cost before/after, runbook, AI audit trail, and incident recovery.
Compounds: This becomes the Phase 20 capstone: one system with evidence from code to AI-assisted recovery.
These are high-signal repositories behind the three builds above. They are references, not 25 assignments: choose one build path, use the matching repository as a guide, and document what you changed. Signals checked 14 Sep 2026.
Official Compose examples for learning multi-service local development; treat samples as labs, not production templates.
~46k stars / ~8k forksA teaching-scale distributed app that makes networks, services, queues, and deployment boundaries visible.
~5.8k stars / ~16k forksAWS-maintained polyglot app for comparing ECS, EKS, and App Runner deployment paths.
~600 stars / ~1.7k forksGuided EKS labs covering networking, security, delivery, autoscaling, and operational troubleshooting.
~600 stars / ~600 forksAWS reference patterns for deploying container workloads on ECS and Fargate without starting with Kubernetes.
~300 stars / ~500 forksAWS Infrastructure as Code patterns for EKS, add-ons, and repeatable cluster foundations.
~3k stars / ~1.5k forksA broad catalogue for learners comparing code-first AWS infrastructure patterns across languages.
~5.6k stars / ~2.5k forksSmall deployable patterns for Lambda, API Gateway, EventBridge, queues, and storage; ideal for focused experiments.
~1.8k stars / ~1.1k forksAdvanced examples for multi-account security controls and guardrails; study after IAM and networking fundamentals.
~1.2k stars / ~300 forksAn AWS audit tool that turns Kubernetes security guidance into checks learners can run and remediate.
~1k stars / ~100 forksRunbook examples for turning detection, containment, recovery, and evidence into portfolio proof.
~1.1k stars / ~230 forksCanonical IaC engine for the AWS platform project; note its BSL 1.1 license and use the official documentation.
~50k stars / ~10k forksAWS-native code-first IaC alternative; choose it or Terraform as a primary path instead of learning both at once.
~13k stars / ~4.6k forksMature agentless automation for host configuration and release tasks; use it as a complement to Terraform.
~71k stars / ~24k forksCanonical orchestration project; consume it by operating a cluster rather than attempting to read the entire source tree.
~128k stars / ~44k forksCNCF GitOps project that makes Git history, deployment state, drift, and rollback visible.
~24k stars / ~8k forksCNCF metrics and alerting project for learning scraping, PromQL, service discovery, and symptoms.
~66k stars / ~11k forksThe packaging layer that keeps Kubernetes releases configurable, reviewable, and repeatable.
CNCF project / high GitHub reuseA realistic multi-service workload for practicing service discovery, deployment, scaling, and observability.
Official sample / widely reused labDashboard and alerting layer to pair with Prometheus when the learner is ready to explain user-visible signals.
Official project / high GitHub reusePractical scanner for images, filesystems, IaC, secrets, and Kubernetes manifests in CI.
Official security project / strong reuseA multi-service reference application for tracing requests across components instead of relying on one log line.
Official reference app / active ecosystemAdvanced multi-account governance reference; use for architecture study after the single-account foundation is safe.
AWS Labs / enterprise referenceA focused reference for expressing network security controls and deployment automation as code.
Official AWS sample / security automationUseful comparison material for AWS-native templates and service configuration, not a substitute for a complete portfolio build.
Official AWS repository / broad reuseStars and forks are point-in-time GitHub signals, not quality guarantees. AWS labs can create charges; use least privilege, budgets, and teardown steps before deploying.
Use these answers to choose depth and practice, not to skip fundamentals.
Yes, but software-engineering depth can vary by role. Start with Bash and Python, then practice APIs, tests, error handling, and automation. Coding lets you remove repetitive work and reason about application behavior.
No. Learn the underlying capability first, then become productive with one representative tool. For example, master infrastructure-as-code concepts with Terraform before comparing every alternative.
Build and document systems that show progression: tested delivery, cloud infrastructure, containers or Kubernetes, monitoring, security controls, and a recovery story. A clear README and incident explanation make your work easier to evaluate.
Both value automation, reliability, feedback, and shared ownership. DevOps describes a broad delivery culture and set of practices; SRE adds an engineering approach to operating services with indicators, objectives, error budgets, and incident learning.
Security belongs throughout the lifecycle: design, code, dependencies, images, infrastructure, deployment, and operations. AI can assist investigation, documentation, and repetitive tasks, but engineers still verify output, protect secrets, and own decisions.
Live Hinglish training, hands-on labs, mentorship, and interview preparation.