Suggest a training plan and curriculum so I can improve my knowledge of Azure DevOps, CI/CD and pipelines

Here’s a practical 8-week learning plan for Azure DevOps, CI/CD, and Azure Pipelines. It assumes basic programming knowledge but little pipeline experience, with 5–7 hours per week available.

The goal is to finish with a working project that you can build, test, secure, and deploy automatically—not just familiarity with the terminology.

1. Build one project throughout the course

Choose a small application in a language you already know, such as:

• An ASP.NET Core API
• A Python FastAPI application
• A Node.js API

Keep the application simple: a health endpoint, a few business endpoints, and unit tests. Learning a new framework at the same time will slow down your DevOps progress.

Your final delivery workflow should look like this:

Pull request
    → Build, lint, and test
    → Review and merge
    → Produce a versioned artifact
    → Deploy to development
    → Run smoke tests
    → Approval
    → Deploy to production
    → Verify or roll back

Use Azure App Service as a straightforward deployment target. Containers and Kubernetes can come later.

2. Weekly curriculum

Week 1 — Git, CI/CD, and Azure DevOps foundations

Learn

• Continuous integration vs. continuous delivery vs. continuous deployment.
• Git branches, pull requests, merge conflicts, and tags.
• Azure DevOps components: Boards, Repos, Pipelines, Artifacts, and Test Plans.
• Organizations, projects, repositories, and permissions.

Practice

• Create an Azure DevOps project and repository.
• Add your application, tests, and a README.
• Track a few tasks in Azure Boards.
• Make changes through a short-lived branch and pull request.

Milestone: You can explain how a code change moves from a developer’s machine into a shared repository.

Week 2 — Azure Pipelines and YAML basics

Learn

• Pipeline structure: stages → jobs → steps.
• Scripts vs. predefined tasks.
• Agents and agent pools.
• Microsoft-hosted vs. self-hosted agents.
• Triggers, variables, and basic conditions.

Practice

• Create an azure-pipelines.yml file.
• Run dependency installation, compilation where applicable, and unit tests.
• Trigger builds on changes to your main branch.
• Intentionally break a build and use the logs to diagnose it.

Milestone: Every main-branch change automatically builds and tests.

Important Azure Repos detail: Configure pull-request validation through a build validation branch policy, rather than relying on a YAML pr: trigger.

Week 3 — Reliable continuous integration

Learn

• Unit tests vs. integration tests.
• Publishing test results and code coverage.
• Linting and static analysis.
• Dependency caching.
• Pipeline artifacts vs. Azure Artifacts package feeds.
• Branch policies and quality gates.

Practice

• Publish test results and coverage reports.
• Add linting or static analysis.
• Make failed required checks block merging.
• Publish a deployable package as a pipeline artifact.
• Compare pipeline execution time before and after caching.

Milestone: Pull requests are validated, and successful builds produce a reusable deployment artifact.

Week 4 — Continuous delivery to Azure

Learn

• Service connections and authentication.
• Deployment jobs and Azure DevOps environments.
• Build-time vs. runtime configuration.
• Environment-specific application settings.
• The principle of build once, deploy the same artifact everywhere.

Practice

• Create a development environment in Azure.
• Configure an Azure service connection using workload identity federation, where supported.
• Add a deployment stage that downloads the previously built artifact.
• Run a smoke test against the deployed application.

Milestone: A successful main-branch build automatically deploys to development.

Week 5 — Production controls and deployment safety

Learn

• Multi-stage pipelines.
• Approvals and checks.
• Protected environments and resource permissions.
• Deployment slots and basic blue-green deployment concepts.
• Rollback vs. roll-forward recovery.

Practice

• Add a production stage.
• Require approval before production deployment.
• Configure the approval on the Azure DevOps environment; approvals and checks are managed outside the pipeline YAML.
• Deploy a faulty version in a safe test environment.
• Recover by redeploying a known-good artifact or using a slot swap, if your hosting tier supports it.

Milestone: You can demonstrate a controlled release and recovery procedure.

Week 6 — Secrets, permissions, and supply-chain security

Learn

• Secret variables, variable groups, and Azure Key Vault integration.
• Least-privilege permissions.
• Service connection authorization.
• Dependency vulnerability scanning and secret scanning.
• Risks associated with untrusted pull requests and self-hosted agents.

Practice

• Remove credentials from repository files and YAML.
• Retrieve a runtime or deployment secret securely.
• Restrict production service connection access.
• Add dependency scanning appropriate to your language.
• Verify that logs do not expose secrets.

Milestone: You can explain who can deploy, which identity performs the deployment, and what that identity can access.

Week 7 — Infrastructure as code and reusable pipelines

Learn

• Bicep or Terraform—choose one initially.
• Infrastructure validation and change previews.
• YAML templates.
• Parameters vs. variables.
• Compile-time template expressions vs. runtime expressions.

Practice

• Define your application’s Azure infrastructure as code.
• Review a Bicep what-if result or Terraform plan before applying changes.
• Extract repeated pipeline steps into a template.
• Parameterize deployment targets without duplicating the entire pipeline.

Milestone: Another developer can recreate the environment and reuse your pipeline structure.

Week 8 — Troubleshooting and capstone

Learn

• Artifact traceability and versioning.
• Pipeline reliability and execution-time optimization.
• Deployment monitoring and health checks.
• Delivery metrics: deployment frequency, change lead time, change failure rate, and recovery time.

Practice Simulate and resolve:

• A failed unit test.
• An expired or unauthorized service connection.
• A missing configuration value.
• An unhealthy deployment.
• A wrong artifact path.

Document:

• How the pipeline works.
• How to release and recover.
• Required permissions and configuration.
• Known limitations and costs.

Milestone: Demonstrate the complete workflow from pull request to production deployment and recovery.

3. Weekly study routine

Use approximately:

Aim for roughly 70% hands-on practice. Troubleshooting failures is one of the fastest ways to develop real pipeline expertise.

4. Recommended resources

Start with these official sources:

• Microsoft Learn — Search for Azure Pipelines, source control, continuous integration, and continuous delivery modules.
• Azure DevOps documentation — Platform concepts and administration.
• Azure Pipelines documentation — Your main implementation reference.
• Azure Pipelines YAML schema — Exact syntax and supported properties.
• Bicep documentation — Infrastructure-as-code learning.

Optional certification direction: AZ-400 / DevOps Engineer Expert is relevant after you have practical experience. Check Microsoft’s current certification requirements before planning an exam path.

5. Setup and cost considerations

Before starting:

• Create an Azure DevOps organization and project.
• Confirm that you have access to pipeline agent capacity; hosted parallel-job availability can vary for new organizations.
• Use an Azure subscription for deployment exercises.
• Set a budget alert and delete unused resources. Budget alerts notify you; they do not automatically stop spending.
• Check hosting-tier requirements before using features such as deployment slots.

Prioritize first: Git, YAML, automated tests, artifacts, deployment, security, and recovery. Leave Kubernetes, complex release strategies, and large-scale agent administration until these foundations are solid.

If you share your current experience, preferred programming language, and weekly study time, I can tailor this into a more specific schedule with labs.