Free to read ยท Three levels

DevOps: shared ownership and reliable delivery

A complete path through DevOps culture, Git, CI/CD, artifacts, containers, infrastructure as code, observability, recovery, SLOs, security, and platform governance.

18 lessonsEnglish + ArabicContent reviewed
Start learning

In this course

Study eighteen developed lessons in three levels. Follow a change from a user need through review, build identity, controlled exposure, operational evidence, and recovery. DevOps is presented as a shared operating model with feedback and responsibility, rather than a job title or shopping list of tools.

Each lesson includes two explained examples, three diagnostic mistakes, two worked exercises, and primary references. Infrastructure commands and configuration fragments are non-runnable teaching material. The few verified Python examples process only synthetic in-memory values; no container engine, cloud account, cluster, service, credential store, deployment, or load test is accessed.

What you will learn

  • Explain flow, trust, state, and responsibility across software delivery.
  • Review release, infrastructure, telemetry, and recovery contracts using concrete evidence.
  • Choose reliability, security, capacity, and governance controls according to user risk.

Your learning path

Three levels

Basic: shared foundations

Connect culture, source review, service boundaries, reproducible inputs, CI, and configuration into one delivery model.

  1. DevOps, shared ownership, and value flow
  2. Git, review, and small reversible changes
  3. Linux, networks, and service boundaries
  4. Reproducible build inputs and provenance
  5. Continuous integration and useful feedback
  6. Artifacts, configuration, and secrets
Explore this level

Intermediate: controlled delivery systems

Reason about containers, infrastructure state, exposure strategies, telemetry, recovery, and orchestration boundaries.

  1. Container images and runtime boundaries
  2. Infrastructure as code, plans, and state
  3. Continuous delivery and release strategies
  4. Observability and useful telemetry
  5. Backups, restoration, and continuity
  6. Kubernetes workload and health boundaries
Explore this level

Advanced: reliability, trust, and governance

Coordinate data evolution, SLO decisions, capacity and cost, supply-chain trust, incident learning, and GitOps authority.

  1. Reliable rollouts and data evolution
  2. SLOs and error-budget decisions
  3. Capacity, overload, and cost
  4. Software supply-chain security
  5. Incident response and organizational learning
  6. GitOps, platform boundaries, and governance
Explore this level

Who this is for

  • Developers, operations learners, and technical collaborators who want to understand the whole delivery system.
  • Teams moving from manual handoffs toward explicit ownership, repeatable evidence, and safer change.

Before you start

  • Basic programming and terminal familiarity; no cloud account, administrative privileges, or Kubernetes cluster is required.
  • Basic Git and Linux concepts are helpful and are reviewed where their boundaries matter.

Related technical solutions

Works locally, fails in CI: recover reproducible evidenceDiagnose an environment-dependent build or test failure without exposing secrets, changing shared runners, or masking the failure with retries.Deployment fails: distinguish crashes, readiness, and rollback safetyClassify Kubernetes rollout symptoms before changing probes, restarting workloads, or assuming that a previous artifact can safely return.Secret and configuration drift: compare safely and recoverInvestigate differing configuration or credential versions without dumping values, blindly overwriting state, or restoring a revoked secret.