DevOps
Once by the book.
Ship changes safely. Keep services useful.
A guided catalog for the work between a code change and a dependable service: CI, builds, testing, releases, infrastructure, runtime operations, incident response, platform engineering, and continuous improvement. The topic levels show a suggested path from foundations to advanced practice.
Moving in. 3 of 138 topics have lessons; they're moving over from the old site.
Moving in 3 of 138 topics have lessons, which are moving over from the old site. Planned topics show where the catalog is going.
DevOps foundations
Understand the purpose and shape of modern software delivery.
DevOps as a way of working
Shared ownership of how software is built, delivered, and operated.
The delivery value stream
Find queues, handoffs, waiting, and rework from idea to user.
Small batches and fast feedback
Reduce the distance between a change and reliable evidence about it.
Work in progress and flow
Limit competing work so teams finish and learn sooner.
Continuous delivery and continuous deployment
Keep software releasable on demand; distinguish readiness from automatic production release.
Local feedback loops
Make routine build, test, and run cycles quick enough to use constantly.
Version control and change flow
Shape changes so they are reviewable, testable, and easy to integrate.
Trunk-based development
Integrate small changes frequently and keep the main branch releasable.
Short-lived branches and pull requests
Use review to improve a change without creating long-lived integration queues.
Commit and change-set design
Keep each change focused enough to understand, verify, and revert.
Merge queues and serialized integration
Validate the exact combined state that will enter the main branch.
Branch protection and required checks
Make important quality gates consistent and visible.
Code ownership and review routing
Get changes in front of maintainers with the relevant context.
Reverting a change safely
Restore service quickly while preserving evidence and a path to a corrected fix.
Continuous integration
Build an automated integration path that gives dependable feedback.
Pipeline as code
Version the delivery workflow beside the application and review its changes.
Pipeline stages and dependency graphs
Express which checks can run together and which depend on earlier results.
Fast-fail checks and feedback order
Run cheap, high-signal checks early without hiding later evidence.
Build matrix and targeted test selection
Balance broad confidence against unnecessary repeated work.
Ephemeral CI workers
Start each run from a clean environment and discard it afterward.
Pipeline caching and cache keys
Speed up work without allowing stale or cross-context results to affect correctness.
Concurrency controls and cancellation
Avoid wasting resources on superseded runs while protecting required checks.
Pipeline secrets and permission scope
Give jobs only the credentials and repository access they need.
Pipeline observability and failure diagnosis
Make failures attributable to a change, step, and useful log context.
Builds and artifacts
Produce artifacts that can be identified and promoted with confidence.
Pinned toolchains and dependency inputs
Control the versions that shape the output of a build.
Reproducible and hermetic builds
Reduce dependence on hidden machine state, mutable downloads, and ambient configuration.
Build once, promote the same artifact
Test and move one immutable output through environments instead of rebuilding it.
Artifact naming and version identity
Connect an image or package to its source revision and build run.
Artifact retention and cleanup
Keep what supports recovery, audit, and diagnosis; remove stale outputs deliberately.
Build metadata and release manifests
Record the inputs and identifiers needed to explain what is running.
Supply-chain attestations in delivery
Carry provenance evidence with artifacts; detailed security policy lives in Security.
Testing and quality gates
Choose checks that catch meaningful failures without making delivery unreliable.
Test layers in a delivery pipeline
Place unit, integration, contract, and end-to-end checks where they give useful feedback.
Service and API contract checks
Detect incompatibilities between independently changing components.
Integration environments and test dependencies
Create dependable test services and isolate one run from another.
Test data lifecycle
Create minimal fixtures and remove or reset state safely between runs.
Flaky test diagnosis and quarantine
Find nondeterminism and make quarantining temporary, visible, and owned.
Parallel tests and resource contention
Speed up suites without introducing shared-state races.
Smoke tests after deployment
Check the smallest set of critical behaviors against the deployed service.
Static checks and quality thresholds
Use targeted automated rules as evidence, not as a substitute for judgment.
Database change verification
Prove schema and application changes can coexist during rollout.
Release management
Control when users receive a change and how quickly exposure can be reduced.
Release versioning and changelogs
Give deployed changes stable identifiers and explain user-facing impact.
Deployment versus release
Separate putting code into an environment from enabling it for users.
Feature flags as release controls
Decouple rollout timing from deployment and remove obsolete flags.
Progressive delivery
Increase exposure in measured steps and define what pauses the rollout.
Canary analysis
Compare a small new cohort against a stable baseline using meaningful signals.
Blue-green deployment
Switch traffic between compatible environments and plan the data transition.
Rollback and roll-forward decisions
Choose recovery based on state changes, reversibility, and time to restore.
Release approvals and separation of duties
Keep necessary controls explicit without turning every change into a queue.
Release notes and customer communication
Tell users what changed, who is affected, and what action is needed.
Deployment and runtime lifecycle
Start, update, and stop workloads without surprising users or operators.
Deployment strategies and workload replacement
Choose how instances are added, removed, and switched during an update.
Zero-downtime rollout prerequisites
Check compatibility, capacity, health signals, and traffic switching before claiming no downtime.
Health checks that do not amplify failure
Keep liveness checks local and avoid restarting healthy workloads because a dependency is slow.
TypeScriptGoBackground worker lifecycle
Handle lease renewal, shutdown, duplicate delivery, and abandoned work.
Scheduled jobs and missed executions
Make schedules observable and decide how to handle overlap, lateness, and retries.
Deployment hooks and post-deploy verification
Use bounded hooks for migrations, smoke checks, and explicit success criteria.
Infrastructure as code
Manage infrastructure changes as reviewable, repeatable software changes.
Declarative desired state
Describe the target system and let a tool calculate the changes needed to reach it.
Infrastructure plans and human review
Inspect creates, updates, replacements, and deletions before applying changes.
State, locking, and collaboration
Protect the mapping between declared resources and real infrastructure.
Drift detection and reconciliation
Find and resolve differences between declared configuration and deployed resources.
Reusable modules and module boundaries
Share stable interfaces without building opaque configuration frameworks.
Environment separation and promotion
Prevent accidental cross-environment changes and make shared inputs explicit.
Idempotent provisioning and safe retries
Make interrupted automation safe to resume without duplicating side effects.
Destroy plans and data-bearing resources
Recognize irreversible deletion risk and protect stateful resources deliberately.
Infrastructure changes in CI
Run formatting, validation, plans, and policy checks before controlled application.
Containers and orchestration
Package workloads and operate them under resource and scheduling constraints.
Container image layers and build context
Keep images small, predictable, and free of unnecessary source or build files.
Multi-stage image builds
Separate compilation dependencies from the minimal runtime image.
Non-root containers and filesystem permissions
Run with only the operating-system privileges and writable paths required.
Image tagging and immutability
Use stable artifact identity so a deployment can be reproduced and diagnosed.
Resource requests, limits, and saturation
Set workload expectations and detect CPU, memory, and storage pressure.
Autoscaling signals and bounds
Scale on signals tied to demand while respecting startup delay and maximum capacity.
Service discovery and internal traffic
Find service instances while accounting for health and endpoint changes.
Jobs, workers, and scheduled workloads
Operate finite tasks with retries, deadlines, and clear completion state.
Orchestrator rollouts and disruption budgets
Control replacement speed and retain enough healthy capacity during maintenance.
Environments and configuration
Make differences between local, test, and production environments deliberate.
Environment purpose and parity
Use each environment for a defined kind of evidence and understand its production differences.
Immutable deployment inputs
Keep a release identifiable while allowing environment-specific runtime configuration.
Configuration validation at startup
Reject invalid or incomplete settings before a service begins accepting work.
TypeScriptGoConfiguration schema and defaults
Give each setting a type, safe default policy, and documented effect.
Secret injection and rotation boundaries
Wire credentials at runtime and coordinate rotation; secret-handling detail lives in Security.
Feature configuration versus feature flags
Separate durable operational settings from temporary release controls.
Local development dependencies
Make common services easy to start and reset without implying production parity.
Ephemeral preview environments
Create temporary review environments and reliably expire their resources.
Observability and alerting
Turn production signals into useful decisions and actionable alerts.
Service-level indicators and objectives
Define user-centered measurements and targets for service behavior.
Metrics, logs, and traces in operations
Choose signals for trends, event detail, and cross-component investigation.
Dashboards for operational questions
Show current health, recent changes, and the signals needed for a decision.
Actionable alert design
Page for user-impacting conditions that need timely human action.
Alert grouping, deduplication, and routing
Send one coherent signal to the right owner instead of repeated noise.
Telemetry cardinality and cost
Avoid unbounded labels and high-volume signals that overwhelm storage or budgets.
Synthetic checks and black-box monitoring
Test critical user journeys from outside the service boundary.
Change markers and deployment correlation
Connect observed behavior to releases and infrastructure changes.
Log retention and useful context
Keep enough structured context for diagnosis while managing sensitive data and cost.
Reliability and incident response
Prepare people and systems to restore service under pressure.
Error budgets and release decisions
Use reliability objectives to make explicit trade-offs in delivery pace.
On-call readiness and escalation
Define ownership, response expectations, backup coverage, and escalation paths.
Incident roles and communication
Coordinate investigation, decisions, and stakeholder updates during an incident.
Runbooks and operational procedures
Write concise procedures with prerequisites, checks, safe actions, and stop conditions.
Triage and evidence gathering
Establish impact, timeline, recent changes, and the safest next diagnostic step.
Incident mitigation and recovery
Prioritize reducing user impact before completing root-cause analysis.
Blameless learning reviews
Turn incidents into owned system improvements rather than individual blame.
Game days and recovery exercises
Practice realistic failure and recovery paths before they are needed.
Disaster recovery objectives
Set recovery time and data-loss targets and test that the plan meets them.
Capacity, cost, and performance operations
Plan for demand and make the cost of running software visible.
Capacity planning from demand patterns
Estimate normal, peak, and growth demand and identify limiting resources.
Load tests as operational evidence
Exercise expected and peak traffic while measuring latency, errors, and saturation.
Autoscaling and cold-start trade-offs
Balance response time, spare capacity, scale-up delay, and operating cost.
Capacity headroom and safety margin
Retain enough spare capacity for failover, rollout, and forecast error.
Cost allocation and ownership
Attribute spend to teams, services, environments, or workloads that can act on it.
Budget alerts and cost anomaly response
Detect unusual spend early and define who investigates and what can be safely reduced.
Ephemeral resource cleanup
Find abandoned previews, volumes, snapshots, and test resources before they accumulate.
Production performance regression detection
Compare release behavior against a stable baseline and catch user-visible regressions.
Performance versus reliability trade-offs
Evaluate resource savings alongside tail latency, overload behavior, and recovery margin.
Data and stateful service operations
Protect continuity for services whose state must survive deployments and failures.
Backup scope and recovery point
Specify which data is protected, how often it is copied, and the tolerated loss window.
Restore drills and recovery verification
Prove backups can be restored and that restored data is usable.
Point-in-time recovery
Recover state to a selected time and understand retention and replay constraints.
Database migration rollout coordination
Deploy compatible schema changes in safe stages; the expand-and-contract pattern is covered in Architecture.
Connection pool sizing and exhaustion
Bound concurrent database work and monitor queueing, timeouts, and pool saturation.
Replication lag and failover readiness
Understand freshness, promotion behavior, and the application impact of failover.
Storage growth and retention policy
Forecast state growth and connect retention to recovery and compliance needs.
Stateful workload maintenance windows
Schedule disruptive maintenance with tested failover and user-impact expectations.
Platform engineering and developer experience
Build shared delivery capabilities that make reliable paths easy to follow.
Internal platforms as products
Treat internal users, outcomes, support, and adoption as product concerns.
Golden paths and paved roads
Offer supported defaults with visible escape hatches for legitimate differences.
Self-service infrastructure and delivery
Let teams provision common capabilities without opaque tickets or broad privileges.
Service templates and scaffolding
Start new services with maintained defaults and clear upgrade paths.
Platform APIs and capability boundaries
Expose stable interfaces while retaining ownership of platform implementation.
Platform adoption and developer feedback
Measure task success and friction rather than counting tools delivered.
Platform reliability and support model
Set expectations for shared services and define how consuming teams get help.
Platform migration and deprecation
Move users with compatibility windows, telemetry, and a clear retirement plan.
Delivery measurement and improvement
Use a small set of measures to find constraints and improve outcomes.
Delivery performance measures
Use throughput, stability, and recovery signals to guide system improvement.
Lead time and deployment frequency
Interpret delivery speed with context about change size, risk, and user value.
Change failure and recovery time
Pair stability measures and avoid optimizing one metric in isolation.
Value stream bottleneck analysis
Use actual wait and work time to locate the next constraint.
Operational toil and automation choices
Find repetitive manual work and automate it when the result is safe and maintainable.
Improvement experiments and outcome checks
Make one change, state the expected effect, and inspect whether it happened.
Metric misuse and team-level comparison
Avoid individual scorekeeping and account for product and system context.
Security and governance in delivery
Place practical controls in the delivery path without duplicating security guidance.
Security checks in the software pipeline
Choose where code, dependency, and artifact checks provide timely feedback.
Least-privilege pipeline identities
Scope automation identities by workflow, environment, and action.
Policy checks for infrastructure changes
Block high-impact unsafe changes while keeping exceptions visible and reviewable.
Audit trails for deployment decisions
Retain who or what released an artifact, where it went, and what checks ran.
Separation of duties without delivery bottlenecks
Use proportionate controls for high-risk actions and automate routine evidence.
Security incident and release coordination
Coordinate containment, credential rotation, and safe recovery during active incidents.