What is Dev Ops and why is it important?

We have recently been recruiting for a new role in our company: that of a Developer Operations role, or Dev Ops. This initiative has mainly been inspired by other companies who have identified the need for a separation between Development and Operations, and the need for development skills in the operations sphere.

An example of an Application Life-cycle Process without development operations would look something like this.

The work flow would go as follows:


Development
In the develop stage, software is designed, developed and tested. There would be n iterations Design>Develop>Test until the application is be ready to be deployed to the live environment.

• In the design stage, Technical Architects would capture requirements and turn them into specifications for developers. 
• Developers would write code and deploy to Test environments
• Testers would run automated and manual tests against test environments. 

Operations 

Once an application is deployed to the live environment it falls under the Operations remit. Operations generally involves monitoring the application and ensuring that all its supporting pillars (power, network, compute resources) stay up. 

In this scenario there is a subset of tasks which sit in the intersection between infrastructure, application and build and deployment processes. The problem is that there isn't one person who can fill the gap so you often have the following disciplines working together:

• Software Architects who aren't great on infrastructure. 
• IT Infrastructure Architects who aren't great on software
• Developers who aren't great on automated deployment, build scripts, powershell and platform monitoring. 

This isn't ideal for an efficient, repeatable and quality assured process. Enter Dev Ops, the FTE role which can plug the gap and make these grey areas run better. 

An updated model of the Application Life-cycle would look like this. 

What this illustrates is that a Dev Ops home is in the Operations space but does cut across all aspects of the Application Life-Cycle. 

The tasks a Dev Ops would undertake would be as follows:

Design

• Gather Platform and Environment Requirements
• Configure Platform and Environments : Dev, QA, UAT, Prod
• Set-up project in Source Control and Build Server
• Ensure Environment, Platform and Project configuration meets standards and best practices

Develop

• Create build and deployment scripts
• Support Developers with environment set-up and configuration
• Ensure Developers following project configuration standards and best practices

Test

• Conduct load and performance tests.
• Enable Continuous Deployment for Testers
• Ensure Deployment Scripts include adding data into Environments for testing. 
• Ensure Builds are successful and automated tests are successful. 

Deploy

• Do code merges into Release branch. (Quality Gate)
• Deploy to Production (Quality Gate)

Operations

• Enable monitoring of the application and platform 
• Provide second line application and platform support
• Triaging problems to correct development team. (Read stack traces and know what they mean) 
• Ensure scalability needs are met
• Ensure standards and quality are met across all projects are met in the Operations space. 

There is a lot of debate about what a Dev Ops is and isn't. This post 'What is a Dev Ops Not' illustrates the misconceptions of a Dev Ops role well. Many may disagree with my definition but I believe those tasks which cut across all phases of the Application Development Life-cycle are essential to:

• Allowing developers to build features, not worry about environments and deployment
• Extending the capability of IT and Infrastructure with Dev Capabilities (A background of development is key)
• Ensuring quality across the development and testing process
• Ensuring applications stay up and don't fall over in production

Another way of describing Dev Ops is through the following Venn Diagram below which illustrates how Development Operations (DO) sits in between Development (DEVS) and IT. 

When read from left to right it reads (as a colleague @ev2000 pointed out during and interview)

Devs do IT