Skip to main content

The DevOps Lifecycle

Table of contents​

  1. Overview of the cycle
  2. Plan phase
  3. Code phase
  4. Build phase
  5. Test phase
  6. Release phase
  7. Deploy phase
  8. Operate phase
  9. Monitor phase

1 - Overview of the cycle​

The DevOps lifecycle is an infinite loop made up of 8 interconnected phases.

The infinity symbol​

    ┌────────────────────────────────────┐
    │                                    │
    │    ┌──────┐        ┌──────┐       │
    │   /  DEV   \      /  OPS   \      │
    │  │ Plan     │    │ Release  │      │
    │  │ Code     ├────┤ Deploy   │      │
    │  │ Build    │    │ Operate  │      │
    │   \ Test   /      \ Monitor/       │
    │    └──────┘        └──────┘       │
    │                                    │
    └────────────────────────────────────┘

Characteristics of the cycle​

CharacteristicDescription
ContinuousNo end, permanent improvement
IterativeSmall, frequent increments
AutomatedMinimal manual intervention
MeasuredMetrics at every stage
CollaborativeShared responsibility

🔝 Back to table of contents​


2 - Plan phase​

Goal​

Define features, prioritize the backlog, plan sprints.

Main activities​

ActivityDescription
Requirements gatheringUnderstand what the customer wants
PrioritizationBacklog grooming, MoSCoW
EstimationStory points, planning poker
Sprint planningDefine the sprint scope
Definition of "Done"Acceptance criteria

Typical tools​

  • Project management: Jira, Azure DevOps, Trello
  • Documentation: Confluence, Notion
  • Communication: Slack, Microsoft Teams
tip

The Plan phase benefits from feedback from the Monitor phase. Production metrics inform product decisions.

🔝 Back to table of contents​


3 - Code phase​

Goal​

Write quality code, collaborate effectively, manage versions.

Essential practices​

PracticeBenefit
Version controlHistory, collaboration
Branching strategyIsolation, parallelism
Code reviewQuality, knowledge sharing
Pair programmingFewer bugs, training
Coding standardsConsistency, maintainability

Branching strategies​

Typical tools​

  • VCS: Git (GitHub, GitLab, Bitbucket)
  • IDE: VS Code, IntelliJ, Eclipse
  • Linting: ESLint, Prettier, SonarLint

🔝 Back to table of contents​


4 - Build phase​

Goal​

Compile the code, manage dependencies, create artifacts.

Artifact types​

TypeFormatUsage
ApplicationJAR, WAR, DLLExecutables
ContainerDocker ImageContainerized deployment
Packagenpm, pip, nugetLibraries
InfrastructureTerraform planIaC

Reproducible build​

warning

A build must be reproducible: the same source code must produce the same artifact, no matter when or where it is built.

Key elements:

  • Pinned dependency versions
  • Controlled build environment
  • Build inside a container

Typical tools​

  • Build tools: Maven, Gradle, npm, Make
  • CI servers: Jenkins, GitLab CI, GitHub Actions
  • Artifact repos: Nexus, Artifactory, Docker Registry

🔝 Back to table of contents​


5 - Test phase​

Goal​

Validate code quality through different levels of testing.

Types of tests​

TypeScopeSpeedCost
UnitFunction/ClassVery fastLow
IntegrationComponentsFastMedium
E2EFull systemSlowHigh
PerformanceLoad/StressVariableHigh
SecurityVulnerabilitiesVariableHigh

Testing pipeline​

Code coverage​

note

Code coverage is not a goal in itself. 80% coverage on critical code is worth more than 100% on trivial code.

Typical tools​

  • Unit tests: JUnit, Jest, pytest
  • Integration: Testcontainers, WireMock
  • E2E: Selenium, Cypress, Playwright
  • Performance: JMeter, k6, Gatling
  • Security: OWASP ZAP, SonarQube

🔝 Back to table of contents​


6 - Release phase​

Goal​

Prepare and validate the deployment to production.

Release strategies​

StrategyDescriptionRisk
Big BangEverything at onceHigh
RollingGradualMedium
Blue-GreenTwo environmentsLow
CanarySmall percentage firstVery low
Feature FlagsOn-demand activationVery low

Feature Flags​

info

Feature flags let you deploy code without activating the feature. This decouples deployment from release.

Typical tools​

  • Release management: Jenkins, GitLab, Azure DevOps
  • Feature flags: LaunchDarkly, Unleash, Flagsmith
  • Approval: ServiceNow, Jira

🔝 Back to table of contents​


7 - Deploy phase​

Goal​

Deploy the application to production reliably and reproducibly.

Blue-Green Deployment​

Canary Deployment​

Deployment principles​

PrincipleDescription
ImmutableDo not modify, replace
AutomatedNo manual intervention
ReversibleRollback possible
IncrementalBit by bit
ObservableLogs and metrics

Typical tools​

  • Orchestration: Kubernetes, Docker Swarm
  • Deployment: Argo CD, Spinnaker, Flux
  • Cloud: AWS CodeDeploy, Azure DevOps

🔝 Back to table of contents​


8 - Operate phase​

Goal​

Keep the application running optimally.

Main activities​

ActivityDescription
ScalingAdjust resources to demand
ConfigurationManage runtime settings
Incident responseReact to problems
BackupRegular backups
DRDisaster recovery plan

SRE Practices​

  • SLO (Service Level Objectives): Availability targets
  • SLI (Service Level Indicators): Measured metrics
  • Error Budget: Acceptable margin of error
tip

"Hope is not a strategy." - SRE Proverb

Reliability must be designed and measured, not hoped for.

Typical tools​

  • Container orchestration: Kubernetes
  • Configuration: Consul, etcd, Vault
  • Incident: PagerDuty, OpsGenie

🔝 Back to table of contents​


9 - Monitor phase​

Goal​

Observe, alert, and understand the system's behavior.

The 3 pillars of observability​

PillarDescriptionExample
LogsText events"User login failed"
MetricsNumeric measurementsCPU: 85%, Latency: 200ms
TracesRequest journeysRequest path through services

Sample dashboard​

┌─────────────────────────────────────────────┐
│                  Dashboard                   │
├───────────────┬──────────────┬──────────────┤
│  Requests/s   │   Latency    │  Error Rate  │
│    12,450     │    45ms      │    0.02%     │
├───────────────┴──────────────┴──────────────┤
│  [═══════════════════════════════════] CPU  │
│  [═══════════════════                ] MEM  │
├─────────────────────────────────────────────┤
│  Alert: High latency on /api/users          │
└─────────────────────────────────────────────┘

Feedback to Plan​

note

The cycle closes: monitoring data feeds the decisions of the Plan phase.

Typical tools​

  • Logs: ELK Stack, Loki, Splunk
  • Metrics: Prometheus, Datadog, New Relic
  • Traces: Jaeger, Zipkin, X-Ray
  • Dashboards: Grafana, Kibana

🔝 Back to table of contents​


Key takeaways​

  • The DevOps cycle includes 8 interconnected phases
  • Each phase feeds the next in a continuous loop
  • Automation is present at every phase
  • Monitoring closes the loop by informing planning
  • Tools vary, but the principles stay constant

🔝 Back to table of contents​

← Previous chapter | Next chapter: Introduction to CI/CD →