Skip to main content
AIDevOps
  • Learn
  • Learning Paths
  • Practice
  • Open Source
  • Books
  • Engineering

    AI DevOpsThe full map of building and operating AI servicesLLMOpsLLM deployment Β· evaluation Β· observabilityHands-on ProjectsBuild AI Agent projects

    Knowledge

    DocsTechnical documentationBlogEngineering articlesPloggerDevelopment log feed

    Validate

    Certification3-level skills certification Β· coming soon
AI Models
LlamaTutorial|MistralTutorial|GemmaTutorial|DeepSeekTutorial|QwenTutorial
🐳 DevOps
DevOps Intro & RoadmapLinuxDockerCI/CD|Kubernetes BasicsK8s AdvancedPrometheusGrafana
πŸ€– AI Applied Development
Applied AI Intro & RoadmapHugging FaceLangChainLlamaIndexLLMOps|LangGraphMCPMulti-AgentAgent Evaluation
🧠 AI Core
AI Intro & RoadmapML FundamentalsLLM Fundamentals|Python AIC++|PyTorchTensorFlowJAX
🧠 AI Agent Development
Finance AI AgentLLM API ServerStock Investing AgentAIOps AI AgentEducation AI AgentCoding AI Agent
🌱 Spring Cloud
Spring Intro & RoadmapSpring Cloud GatewaySpring BootJava|Spring AISpring SecuritySpring BatchSpring JPA
🧱 Infrastructure
Infrastructure Intro & RoadmapNginxRedis
☁️ Cloud
Cloud Intro & RoadmapAWSGCPAzureNCPCloudflare
🎨 Frontend
Frontend Intro & RoadmapJavaScriptTypeScript|ReactNext.js|VueNuxt|Electron
πŸ“± Mobile
Mobile Intro & RoadmapKotlinAndroidFlutter
βš™οΈ Backend
Backend Intro & RoadmapPython BasicsFastAPIDjangoFlask|CGoGinNode.js
πŸ’Ύ Database
DB Intro & RoadmapCore SQLOracleMySQLPostgreSQL|MongoDBVector DB
πŸ§ͺ Testing
k6JMeternGrinder
AIDevOps

Engineering AI. From Code to Production.
An engineering learning platform for building and operating AI and AI Agents

Learn

  • All Guides
  • Learning Paths
  • AI Tutorial
  • Practice
  • Books

Resources

  • AI DevOps
  • LLMOps
  • Hands-on Projects
  • Docs
  • Blog
  • Plogger
  • Open Source
  • Certification (coming soon)

Start Here

  • AI Core Roadmap
  • AI Applied Development Roadmap
  • Spring Cloud Roadmap
  • DevOps Roadmap
  • Infrastructure Roadmap

Β 

  • Cloud Roadmap
  • Frontend Roadmap
  • Mobile Roadmap
  • Backend Roadmap
  • Database Roadmap
Β© 2026 AIDevOps. All rights reserved.
Terms of ServicePrivacy PolicySitemaptestforge.kr
  1. Home
  2. Learn
  3. DevOps
  4. DevOps Intro & Roadmap
The first guide for newcomers to DevOps

🧭 DevOps Intro & Roadmap Complete Guide

Visitors

A starting point for anyone new to DevOps. It covers why DevOps is a culture and a methodology rather than a tool, the full flow that carries code to production, a map of the technology from Linux and Docker through CI/CD, Kubernetes, and monitoring, and a step-by-step learning roadmap and practice plan.

  • Beginner
  • Updated Oct 1, 2026
  • ~7 min read
  • 12 sections
  • 1 code examples

Learning Paths that include this guide

This guide is one step in the paths below. Study it together with the steps before and after.

  • DevOps / SRE Engineer β†’
The big picture of DevOps conceptsUnderstand the deployment pipelineMap of the DevOps tech stackDevOps learning orderExploring a DevOps/SRE career

Related frameworks & environments

🐧Linuxβ†’πŸ³Dockerβ†’CICI/CDβ†’β˜ΈοΈKubernetes Basicsβ†’πŸ“ŠPrometheusβ†’πŸ“ˆGrafanaβ†’

Contents

0 / 15
  1. How to use this guide
  2. Architecture diagrams
  3. What DevOps is
  4. How code reaches production
  5. DevOps technology map
  6. What containers changed
  7. Your first pipeline
  8. DevOps performance metrics
  9. DevOps Β· SRE Β· Platform
  10. Before you start
  11. Step-by-step roadmap
  12. 12-week study plan
  13. Common mistakes
  14. Key terms
  15. Frequently asked questions
Contents 15 sections
  1. How to use this guide
  2. Architecture diagrams
  3. What DevOps is
  4. How code reaches production
  5. DevOps technology map
  6. What containers changed
  7. Your first pipeline
  8. DevOps performance metrics
  9. DevOps Β· SRE Β· Platform
  10. Before you start
  11. Step-by-step roadmap
  12. 12-week study plan
  13. Common mistakes
  14. Key terms
  15. Frequently asked questions

How to use this guide

How to read it

Understanding DevOps Intro & Roadmap as a real-world workflow

A starting point for anyone new to DevOps. It covers why DevOps is a culture and a methodology rather than a tool, the full flow that carries code to production, a map of the technology from Linux and Docker through CI/CD, Kubernetes, and monitoring, and a step-by-step learning roadmap and practice plan. Rather than listing concepts, this guide is organized so you can follow the content in the order you have to make decisions on a real project.

Key perspective

Infrastructure / operations

Rather than memorizing install commands, understand the order in which traffic, runtime, observability, and incident response connect.

The big picture of DevOps conceptsUnderstand the deployment pipelineMap of the DevOps tech stackDevOps learning orderExploring a DevOps/SRE career

Architecture diagrams

To make what you read stick, it helps to capture the flow as a picture first. The two diagrams below are reference maps you can keep coming back to while learning DevOps Intro & Roadmap.

Learning flow

Rendering diagram…

Architecture view

Rendering diagram…

What DevOps is: a way of working, not a tool

When you first open DevOps Intro & Roadmap, the big picture matters more than individual commands. This section starts with the problems the concepts ahead were created to solve.

In the past, the development team (Dev) wrote the code and handed it over, and the operations team (Ops) deployed and managed it. Developers wanted to "ship features fast" while operations wanted to "reduce change and stay stable", so the two teams were always in conflict. Deployments happened once every few weeks as an all-night job, and incidents turned into blame games.

DevOps is the culture and methodology of tearing down that wall and deploying "often, small, automatically, and safely". Tools such as Docker, Kubernetes, and CI/CD are the means of reaching that goal.
AspectTraditional wayDevOps way
Deployment cadenceOnce every few weeks or monthsSeveral times a day
Deployment methodPeople logging into servers by handAutomated pipeline
InfrastructureServers configured by hand (snowflake servers)Defined as code (IaC)
Incident responseFound out from user reportsFound first through monitoring and alerts
ResponsibilityDev and Ops separatedThe team that builds it runs it (You build it, you run it)

How code reaches production

How code reaches production is a point where the options diverge. Using the table to compare what each approach is for and how it differs in operation makes later decisions much easier.

Every DevOps tool automates one stage of the flow below. Keep this loop in your head and, when you meet a new tool, you can tell right away "which stage it belongs to".
StageWhat happensTypical toolsGuides
1. CodeFeature development, code reviewGit, GitHub-
2. BuildCompile, install dependencies, create the imageDocker, Gradle, npmDocker
3. TestUnit and integration tests, security scansGitHub Actions, JenkinsCI/CD
4. Release/DeployStaging β†’ production rolloutArgo CD, HelmCI/CD, K8s Advanced
5. OperateRun, scale, and self-heal containersKubernetesKubernetes
6. MonitorMetrics, logs, alerts, dashboardsPrometheus, GrafanaPrometheus, Grafana
7. FeedbackIncident retrospectives, improvements fed back into codePostmortems-

DevOps technology map: the order to build it up

DevOps technology map: the order to build it up is a point where the options diverge. Using the table to compare what each approach is for and how it differs in operation makes later decisions much easier.

DevOps technologies form layers that depend on each other. If you learn an upper layer without the one below, you cannot find the cause when something breaks. A large share of Kubernetes incidents turn out to be Linux networking or container configuration problems.
LayerTechnologyWhy it is neededGuides
FoundationLinux, shell, networking basicsEvery server and container runs on LinuxLinux
PackagingDocker, container imagesSolves the "it works on my machine" problemDocker
AutomationCI/CD, IaC (Terraform, Ansible)Removes human error, makes deployment repeatableCI/CD
OrchestrationKubernetes, HelmPlacing, scaling, and recovering large numbers of containersKubernetes, K8s Advanced
ObservabilityPrometheus, Grafana, log collectionUnderstanding system state in numbersPrometheus, Grafana
InfrastructureCloud, load balancers, cachesThe ground the service runs onCloud roadmap, Infrastructure roadmap

What containers changed

What containers changed is a point where the options diverge. Using the table to compare what each approach is for and how it differs in operation makes later decisions much easier.

A container bundles the application and everything it needs to run (runtime, libraries, configuration) into one image so it runs identically anywhere. Because containers are far lighter and start far faster than virtual machines (VMs), they became the standard unit of deployment in modern DevOps.
AspectVirtual machine (VM)Container
Unit of isolationA whole OS (including the guest OS)A process (shares the host kernel)
SizeSeveral GBTens to hundreds of MB
Startup timeTens of seconds to minutesAbout 1 second
DensityDozens per serverHundreds per server
Main useStrong isolation, running a different OSMicroservices, CI/CD, fast scaling

Your first pipeline: test and build an image on push

Here you look at Your first pipeline: test and build an image on push alongside real code. Rather than copying the example as-is, read it with an eye on the inputs, the outputs, and the parts most likely to change.

The GitHub Actions workflow below runs the tests on every push and, when they pass, builds a Docker image. These 20 lines are all there is to CI, and adding a deploy step on top turns it into CD.
.github/workflows/ci.ymlYAML
name: CI
on:
  push:
    branches: [main]
  pull_request:

jobs:
  test-and-build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - uses: actions/setup-python@v5
        with:
          python-version: "3.12"

      - name: Install dependencies & test
        run: |
          pip install -r requirements.txt
          pytest -q

      - name: Build the Docker image
        run: docker build -t myapp:latest .

Tip

A pipeline is "a device that reports failure quickly". Putting fast tests first and slow jobs last cuts the time developers spend waiting for results.

DevOps performance metrics: the 4 DORA metrics

DevOps performance metrics: the 4 DORA metrics is a point where the options diverge. Using the table to compare what each approach is for and how it differs in operation makes later decisions much easier.

Whether DevOps is working is judged not by which tools you adopted but by numbers. The four metrics defined by the Google DORA research team are used as the industry standard. The central finding of the research is that speed (the first two) and stability (the last two) do not trade off against each other: teams that are good are good at both.
MetricMeaningWhat a good team looks like
Deployment frequencyHow often you deploy to productionWhenever needed (several times a day)
Lead time for changesTime from commit to running in productionWithin a day
Change failure rateShare of deployments that led to an incident or rollbackKept low (e.g. 15% or less)
Time to restoreTime from an incident starting to recoveryWithin 1 hour

DevOps Β· SRE Β· Platform engineer

DevOps Β· SRE Β· Platform engineer is a point where the options diverge. Using the table to compare what each approach is for and how it differs in operation makes later decisions much easier.

Job titles and scope differ from company to company, but the skills needed mostly overlap. DevOps engineers with backend development experience are valued especially highly because they understand the pain points of development teams.
RoleFocusMain work
DevOps engineerDeployment automation and developer productivityBuilding CI/CD, containerization, IaC
SRE (Site Reliability Engineer)Service reliabilitySetting SLOs, monitoring, incident response, capacity planning
Platform engineerThe internal developer platformKubernetes platform, self-service deployment tooling
Cloud engineerDesigning and operating cloud infrastructureNetworking, security, cost optimization
MLOps / LLMOpsDeploying and operating AI modelsModel serving, GPU infrastructure, quality monitoring (LLMOps)

Before you start

Before you start is a point where the options diverge. Using the table to compare what each approach is for and how it differs in operation makes later decisions much easier.

For a practice server, Docker Desktop or WSL2 on your PC, or a cloud free tier, is enough. You can start local Kubernetes with kind or minikube.
AreaWhatHow much
Linux commandsFiles, permissions, processes, packages, logsRequired β€” first of all
Networking basicsIP, ports, DNS, HTTP, TLSEnough to trace "why will it not connect?"
ScriptingBash or PythonWrite scripts that automate repetitive work
Gitbranch, merge, PR, tagsRequired
One applicationYou can build a simple web app yourselfYou need something to deploy in order to practice
YAMLIndentation, lists, mapsWriting CI configuration and Kubernetes manifests

Step-by-step roadmap: from Linux to operating Kubernetes

Step-by-step roadmap: from Linux to operating Kubernetes is a point where the options diverge. Using the table to compare what each approach is for and how it differs in operation makes later decisions much easier.

StepGoalWhat to learnGuidesDone check
0. LinuxWorking with serversShell, files and permissions, processes, systemd, SSH, network commandsLinuxInstall and run a web server on a remote machine
1. DockerContainerizing an applicationImages, Dockerfile, volumes, networks, ComposeDockerRun app + DB with compose
2. CI/CDDeployment automationPipelines, test automation, image registry, IaC basicsCI/CDpush β†’ test β†’ push the image
3. Kubernetes basicsContainer orchestrationPod, Deployment, Service, ConfigMap, IngressKubernetes BasicsDeploy an app to a local cluster
4. Kubernetes in practiceA production-grade clusterHelm, autoscaling, resource management, security, GitOpsK8s AdvancedHelm chart + zero-downtime deployment
5. ObservabilityState in numbersMetric collection, PromQL, alert rules, dashboardsPrometheus, GrafanaA dashboard with error-rate and latency alerts
6. CloudA real production environmentManaged Kubernetes, networking, IAM, costAWS, Cloud roadmapBuild the whole pipeline in the cloud
7. ReliabilitySystems that withstand failureSLOs, incident response procedures, load testing, postmortemsk6A load test + an incident retrospective document

12-week study plan: 1-2 hours a day

12-week study plan: 1-2 hours a day is a point where the options diverge. Using the table to compare what each approach is for and how it differs in operation makes later decisions much easier.

The heart of the practice is to keep evolving one and the same application. After 12 weeks you have a complete pipeline in your portfolio that runs from "code push β†’ automatic deployment β†’ monitoring".
WeekTopicDeliverable
Weeks 1-2Linux commands, permissions, processes, networkingA server bootstrap script
Week 3Docker images and the DockerfileA slim image of your app (multi-stage)
Week 4Docker ComposeA local app + DB + cache environment
Weeks 5-6CI/CD pipelineGitHub Actions: test β†’ build β†’ push to the registry
Weeks 7-8Basic Kubernetes resourcesDeploy the app to a kind cluster + Ingress
Week 9Helm + GitOpsA Helm chart + Argo CD auto-sync
Week 10Prometheus + GrafanaA service dashboard + alert rules
Week 11Cloud deploymentThe same setup reproduced on managed Kubernetes
Week 12Load testing + retrospectiveA k6 load test report + an architecture document

Common mistakes of DevOps beginners

Common mistakes of DevOps beginners is a point where the options diverge. Using the table to compare what each approach is for and how it differs in operation makes later decisions much easier.

The golden rule of DevOps is "automate any task you repeat twice". Work done by hand leaves no record, and the next person cannot reproduce it.
MistakeProblemDo this instead
Starting with Kubernetes without LinuxCannot trace the cause of an incident at allKeep the order Linux β†’ Docker β†’ K8s
Deploying with the latest tagNo idea which version is running, cannot roll backUse commit SHA or version tags
Putting passwords in images or the repositoryRisk of leaksA secret management tool, CI secrets
No resource requests or limitsOne container hogs the resources of the whole nodeSet requests/limits
No health checksTraffic is sent to dead containersConfigure liveness/readiness probes
Operating without monitoringFinding out about incidents from user reportsSet up dashboards and alerts together with the deployment
Changing server configuration by handAn environment that cannot be reproducedPut every change in code with IaC

Key terms

Key terms is a point where the options diverge. Using the table to compare what each approach is for and how it differs in operation makes later decisions much easier.

TermOne-line explanation
CI (Continuous Integration)Building and testing automatically on every code change
CD (Continuous Delivery/Deployment)Automatically deploying verified changes all the way to production
IaCDefining and managing infrastructure such as servers and networks as code
GitOpsAn operating model where the Git repository is the single source of truth for infrastructure and deployment state
Image registryA repository that stores and distributes container images (Docker Hub, ECR, and so on)
Blue-green / canary deploymentZero-downtime deployment that runs the new version in parallel or applies it to a slice of traffic first
SLI / SLOA service quality indicator / the target for that indicator (e.g. 99.9% availability)
AutoscalingAutomatically adjusting the number of instances or Pods to the load
PostmortemA blameless retrospective document that records the causes and improvements after an incident
ObservabilityThe ability to understand the internal state of a system from metrics, logs, and traces

Tip

The next step is the Linux guide. Once you are comfortable with shell commands, permissions, and process management, move on to Docker.

DevOps Intro & Roadmap: frequently asked questions

What should I study first to become a DevOps engineer?

Start with basic Linux commands and networking fundamentals, then widen out to Git, Docker, CI/CD pipelines, Kubernetes, and monitoring. Rather than learning each tool in isolation, building the whole flow yourself for one small application, build, deploy, and observe, is the most effective approach.

What is the difference between DevOps and SRE?

DevOps is a culture and set of practices in which development and operations share responsibility and ship quickly, and SRE is a concrete role and method that implements it with software engineering. What marks SRE is managing the balance between stability and release speed with numbers: service level objectives (SLOs) and error budgets.

Do developers need to know DevOps too?

You should know how the code you write is built, deployed, and observed. Understanding the constraints of running in a container, how configuration and secrets are injected, and how to emit logs and metrics lets you find the cause of an incident much faster.

Next guide β†’Linux