DevOps Fundamentals
DevOps is a set of practices that unifies software development and IT operations to shorten delivery cycles and improve reliability. It combines cultural collaboration, automation of build-test-deploy pipelines, infrastructure as code, and continuous feedback loops.
itDevOps and software delivery | OpenSkills.info
Course pathWalk it in order
Look it upDip in anytime
Go furtherLeaves this page
Don't Panic
Don't Panic — DevOps Fundamentals
DevOps is the arrangement that keeps a software change from becoming a parcel passed between departments until somebody in production discovers it has loose parts. It connects the people who plan, build, deliver, secure, and operate a service into one learning loop. The name is shorter than the list of responsibilities, which is considerate of it.
The loop is plan, change, verify, deliver, operate, observe, learn. A small change travels through version control, automated checks, an identifiable artifact, and a controlled release. Then production and customer evidence travel back to the group that can alter the next change. The surprising part is that the pipeline is not the loop. It is one conveyor belt in a much larger factory of decisions.
Before this arrangement, handoffs could let each specialty optimize its own queue. Development could ship features. Operations could avoid change. Security could arrive near the end carrying a clipboard with unsettling news. The customer, having no department at all, received the combined result. Shared ownership does not mean everyone gets every permission; it means the specialists work toward the same service outcome and can see the constraints affecting it.
Continuous integration asks whether the shared product still works after a change. Continuous delivery keeps an accepted change ready to release through the normal path. Neither requires every qualifying change to go straight to production. A release decision still exists, because a useful system is allowed to care about risk.
Automation is valuable because it turns repeatable work into controlled inputs and useful failure evidence. Infrastructure as code gives environment changes the same reviewable history as application code. That reduces variation, but it does not cure an unowned alert, a long approval queue, or a recovery path known only to one heroic person and a very tired notebook.
Production closes the circuit. Monitoring watches conditions that the team chose in advance. Observability helps investigate behavior nobody predicted. DORA's delivery measures are trends for one service, not scorecards for individual humans. They help find a constraint, test an improvement, and check whether the system became safer as well as faster.
Read the Intro when you need the whole operating model and its limits. Use Slides for the relationships between culture, flow, automation, and feedback. Keep the Cheatsheet nearby when comparing continuous integration, delivery, and deployment, or when mapping a troublesome handoff. The Exercise turns that map into a small improvement experiment, because the loop only becomes real when evidence changes what happens next.
Where this skill leads
Relevant careers
See how this topic contributes to broader role-level skill maps.
Sources
- https://learn.microsoft.com/en-us/devops/what-is-devops
Supports
- DevOps definition and development, delivery, and operations lifecycle
- Cross-role collaboration, shared accountability, and continuous learning
- Version control, continuous integration, continuous delivery, and infrastructure as code overview
- https://dora.dev/capabilities/
Supports
- DevOps as a set of related cultural, process, technical, and product capabilities
- Capability-led improvement rather than tool installation alone
- Working in small batches and visibility of work in the value stream
- https://dora.dev/capabilities/generative-organizational-culture/
Supports
- High information flow, cooperation, shared risks, and cross-functional teams
- Failure leading to inquiry and bad news being surfaced without punishment
- Culture changed through working behavior rather than labels alone
- https://dora.dev/capabilities/version-control/
Supports
- Version control for application code, tests, scripts, infrastructure, and configuration
- Reviewable history, reproducibility, traceability, and recovery
- Relationship between comprehensive version control, automation, and continuous delivery
- https://dora.dev/capabilities/continuous-integration/
Supports
- Frequent integration into a shared mainline with automated build and test feedback
- Small batches, rapid feedback, and restoration of broken builds
- Continuous integration as a foundation for continuous delivery
- https://dora.dev/capabilities/continuous-delivery/
Supports
- Safe on-demand release capability and distinction from tool ownership
- Technical capabilities including testing, deployment automation, security, and observability
- Collaboration across the delivery process and limits of tooling-only change
- https://dora.dev/capabilities/monitoring-and-observability/
Supports
- Monitoring as predefined system signals and observability as interactive investigation
- Customer-facing health, shared access to evidence, and faster diagnosis
- Monitoring and observability as contributors to continuous delivery
- https://dora.dev/guides/dora-metrics/
Supports
- Current five software delivery performance metrics
- Throughput and instability groupings and metric definitions
- Service-level baselines, constraint improvement, trends, and small-change guidance
- https://csrc.nist.gov/pubs/sp/800/218/final
Supports
- Secure development practices integrated into software lifecycle models
- Security outcomes for organizational preparation, software protection, secure production, and vulnerability response
- Outcome-based, risk-informed secure development rather than a universal checklist
- https://agilemanifesto.org/history.html
Supports
- The 2001 publication of the Agile Manifesto and its collaboration and adaptation foundations
- https://legacy.devopsdays.org/events/2009-ghent/
Supports
- The first DevOpsDays event in Ghent in 2009
- https://dora.dev/research/2024/dora-report/2024-dora-accelerate-state-of-devops-report.pdf
Supports
- DevOps movement history, including 2009 events, annual reports, DORA founding, Accelerate, and the Google Cloud acquisition
- Research milestones used in the DevOps Fundamentals timeline
- https://www.oreilly.com/library/view/continuous-delivery-reliable/9780321670250/
Supports
- July 2010 publication of Continuous Delivery and its build, test, deployment, and collaboration practices
- https://docs.github.com/actions
Supports
- GitHub Actions workflow automation for software repositories
- https://docs.gitlab.com/ci/pipelines/
Supports
- GitLab CI/CD YAML pipelines, stages, jobs, and runners
- https://www.jenkins.io/doc/
Supports
- Jenkins automation for building, testing, delivering, and deploying software
- https://circleci.com/docs/introduction-to-the-circleci-application/
Supports
- CircleCI configured pipeline jobs and their execution results
- https://developer.harness.io/docs/continuous-delivery/get-started/overview/
Supports
- Harness continuous delivery workflows and release controls
- https://developer.hashicorp.com/terraform/intro
Supports
- Terraform infrastructure as code and versioned infrastructure definitions
- https://docs.ansible.com/projects/ansible/latest/getting_started/introduction.html
Supports
- Ansible automation playbooks and idempotent declared system state
- https://grafana.com/products/cloud/
Supports
- Grafana Cloud monitoring and observability capabilities
- https://support.pagerduty.com/main/docs/introduction
Supports
- PagerDuty incident response, on-call schedules, escalation policies, and integrations
- https://sre.google/workbook/postmortem-culture/
Supports
- Blameless postmortem practice, recurring-incident investigation, action review, and reliability improvement
