DevOps Lifecycle

The DevOps lifecycle is a continuous process that connects software development, testing, deployment, operations, monitoring, and feedback. Instead of treating development and operations as separate activities, DevOps brings them together into a continuous flow.

A typical DevOps lifecycle can be represented as:

The important point is that the lifecycle is continuous. Monitoring and operational feedback influence the next planning and development cycle.

1. Plan

The lifecycle begins with planning.

The team identifies what needs to be built, changed, improved, or fixed.

Planning can include:

Business requirements
User stories
Features
Bug fixes
Technical requirements
Security requirements
Infrastructure requirements
Performance requirements
Release planning

For example, suppose an e-commerce company wants to introduce a new payment method. Tools commonly associated with this stage include:

Jira
Azure Boards
GitHub Issues
GitLab Issues
Confluence

The output of planning is a set of clearly defined work items that developers and other teams can implement.

2. Code

Developers implement the requirements by writing application code.

A typical workflow looks like:

Developer
    |
    v
Local Development
    |
    v
Git Repository
    |
    v
Feature Branch
    |
    v
Pull Request
    |
    v
Code Review

Git is commonly used for source-code version control.

A developer might create a branch:

git checkout -b feature/payment-upi
git add .
git commit -m "Add UPI payment integration"
git push origin feature/payment-upi

The changes can then go through a pull request and code review.

Why version control matters

Version control provides:

Change history
Collaboration
Branching
Code review
Rollback capability
Traceability

3. Build

Once code is committed, the application needs to be built.

The build process converts source code and dependencies into a deployable artifact.

Depending on the application, the artifact might be:

Java       → JAR/WAR
.NET       → Application package
Python     → Package/application artifact
Frontend   → Static build files
Container  → Docker image

4. Test

Testing verifies that the software behaves as expected.

Modern DevOps practices aim to automate as much testing as practical.

Testing can occur at multiple levels:

                 Testing
                    |
       +------------+------------+
       |            |            |
       v            v            v
     Unit       Integration   End-to-End
     Tests        Tests         Tests

5. Release

After successful testing, the application enters the release stage.

Release management determines whether a particular build is ready to be deployed.

A release may involve:

Versioning
Artifact management
Release notes
Approval
Change management
Security validation
Deployment preparation

6. Deploy

Deployment moves the application into an environment where users or other systems can access it.

Typical environments include:

Development
     ↓
Testing
     ↓
Staging
     ↓
Production

Common deployment platforms include:

Virtual machines
Docker
Kubernetes
Amazon ECS
Amazon EKS
Azure Kubernetes Service
Google Kubernetes Engine

DevOps also introduces deployment strategies such as:

Rolling Deployment

Gradually replaces existing application instances with the new version.

Blue-Green Deployment

Two environments are maintained:


Blue  → Current production
Green → New version

Traffic can be switched from Blue to Green after validation.

Canary Deployment

A new version is initially exposed to a small portion of traffic.


Users
  |
  +---- 95% → Version 1
  |
  +----- 5% → Version 2

If the new version behaves correctly, traffic can gradually increase.