Home / Learn / DevOps & Tooling

🛠️ DevOps & Tooling

Shipping and operating software. 50 topics, from beginner to advanced.

DevOps combines software development and IT operations so teams can build, test, release and run software quickly and reliably. The topics cover version control, continuous integration and delivery, containers, infrastructure as code and monitoring. The goal is small, frequent, reversible changes instead of risky large releases.

Who this area is for

Developers who want to ship and run their own software, system administrators moving to automation, and anyone who keeps services online.

Real-world use cases

Running automated tests on every commit with a continuous integration pipeline.
Packaging an application and its dependencies into a container image.
Describing servers and networks in code so environments can be rebuilt on demand.
Automatically running tests and deploying a service each time code is merged.
Setting a cost alarm so that a forgotten cloud resource does not run up a large bill.

Topics in DevOps & Tooling

Beginner (17)

Command Line Basics — Navigating and operating the system via text commands.
Linux File System Layout — Standard directories and their purposes.
File Permissions — Read, write and execute rights for users and groups.
Text Editors and IDEs — Tools for writing and navigating code.
Package Managers — Tools installing and updating software dependencies.
Environment Variables — Named values configuring processes.
Git Basics — Distributed version control with commits.
Branching and Merging — Parallel lines of development and combining them.
Pull Requests — Proposals to merge changes with discussion and review.
Resolving Merge Conflicts — Reconciling overlapping edits.
Git Internals — Objects, refs and the commit graph.
Shell Scripting — Automating tasks with command scripts.
Pipes and Redirection — Connecting program outputs and inputs in shells.
grep, sed and awk — Classic text-processing tools.
Cron Jobs — Scheduled recurring tasks.
SSH Keys — Key-based remote login.
Build Systems — Tools like Make that automate compiling.

Intermediate (17)

Dependency Management — Controlling external library versions.
Semantic Versioning — Version numbers conveying compatibility meaning.
Continuous Integration — Automatically building and testing every change.
Continuous Delivery — Keeping software always releasable via automated pipelines.
Deployment Strategies — Blue-green, canary and rolling releases.
Docker Images and Layers — Immutable layered filesystems for containers.
Docker Compose — Defining multi-container apps in a file.
Kubernetes Objects — Pods, deployments and services.
Helm and Kustomize — Templating and customizing Kubernetes manifests.
Terraform — Declarative multi-cloud infrastructure provisioning.
Configuration Management — Tools like Ansible keeping servers consistent.
Monitoring and Alerting — Watching metrics and notifying on problems.
Logging Pipelines — Collecting and searching logs centrally.
Prometheus and Grafana — Metrics collection and dashboards.
Tracing with OpenTelemetry — Vendor-neutral instrumentation for traces.
Incident Response — Handling outages and learning from them.
Postmortems — Blameless reviews after incidents.

Advanced (16)

SLIs, SLOs and SLAs — Measures and targets for service reliability.
Capacity Planning — Forecasting resources needed for demand.
Cost Optimization — Reducing cloud and infrastructure spend.
Secrets Management — Storing credentials securely for applications.
GitOps — Using Git as the source of truth for deployments.
Feature Flags — Toggling features at runtime without redeploying.
Trunk-Based Development — Frequent merges to a single main branch.
Monorepos — Single repository hosting many projects.
Reproducible Builds — Builds that yield identical outputs from identical sources.
Linux Performance Tools — top, strace and perf for diagnosing systems.
Networking Tools — curl, tcpdump and dig for debugging connectivity.
Platform Engineering — Building internal platforms that enable developer self-service.
Policy as Code — Enforcing rules through machine-checked policies.
Disaster Recovery — Plans and tooling to restore service after catastrophe.
DevSecOps — Integrating security throughout the delivery pipeline.
Developer Productivity — Practices and metrics improving engineering flow.

How to study DevOps & Tooling

Practice on a machine you control. Write a shell script, put it under version control, then run it through a pipeline that tests and deploys it. Every concept becomes clearer when you watch a change move from a commit to a running service.

Frequently asked questions

What is continuous integration?

Continuous integration means developers merge their changes into a shared branch often, and an automated build and test run checks each change. Problems are caught while they are still small.

Do I need containers to practice DevOps?

Containers are common but not mandatory. The core practices are automation, version control, testing and monitoring. Containers make environments reproducible, which is why they are so widely used.

What is infrastructure as code?

It is the practice of defining servers, networks and configuration in versioned files instead of configuring them by hand. This makes environments repeatable and easier to review.

Is DevOps a job title or a practice?

It is mainly a set of practices that bring development and operations together, such as automation, monitoring and shared responsibility. Many teams split those tasks across roles, but the practices apply either way.

Do I need to learn Kubernetes first?

No. Learn containers and the command line first. Kubernetes solves coordination problems that small projects rarely have.

Open the interactive DevOps & Tooling area Take the DevOps & Tooling quiz