DevOps is Neither a Method nor a Tool, it’s a Culture

Recommended by 35 users

Jan 13, 2015
DevOps is Neither a Method nor a Tool, it’s a Culture
Add to Bookmark Email this Post 3.3K    0

Culture is often ignored and misunderstood, yet it is a key factor responsible for a company’s performance. If we don’t manage our culture, we will end up doing wrong practices which will ultimately affect our business goals.

Understanding the current culture of an organization

Culture tells us about the values and norms within a group or company. It identifies what is important as well as how people approach and work with each other.

CULTURE = “How things can be done smartly for success”

Let’s take the example of a customer support team. The culture of that team should be such that they end up achieving 97-98 % of customer satisfaction.

Keeping in view the customer delight, first of all they need to be polite, even in difficult situations; they need to be good listeners to avoid confusion; they need to prioritize the work according to requirement.

Let’s pause for a moment and ask a few questions to ourselves:

  • What is the culture of my company now?
  • How well is this culture aligned with my business goals or KRAs?
  • What problems can I expect due to misalignment?

For every organization, the 4Cs plays a vital role

4C of organization

Now, let’s look into the culture of a software developing organization. There are many teams involved for building and maintaining a single software unit. All these teams have separate goals and separate culture.

Software Development Cycle

This process starts after the requirements have been confirmed by the client.

Developers follow the coding guidelines defined by their organization and programming tools like compilers, interpreters, debuggers etc are used to generate the code. Different high-level programming languages such as C, C++, Pascal, Java, and PHP are used for coding.

They divide the complete package into small folders and then develop small codes accordingly.

Stage 1: These small units of codes are then clubbed to form a large unit. While integrating the smaller chips, a project-level testing has to be performed known as integration testing.

Stage 2: After the successful integration, it is deployed into a dummy system. This dummy system has similar configuration as that of the client machine or the machine where this project has to be finally deployed.

Stage 3: Finally, after testing all the features in a dummy system, the project is deployed into the production server or the client machine.

Though this process seems to be very smooth and easy in words, in technical terms it is very tough to achieve.

Let’s see what problems we might face:

Stage 1:

Development Vs. Operations

The client is always in search of changes to improve the quality of the product. Most of the time when the first iteration was done, client will suggest a few changes. When the developers receive the changes, they start incorporating them which impacts the integration leading to broken builds.

Stage 2:

Most of the time, the testers or other operation guys will not be aware of the new changes to be made. As soon as they get the code from developers, they start testing them. While on the back-end the developers are still making the changes.

As they do not get enough time to implement new changes, they end up developing inefficient codes; they face other network and database issues which again delays their time of delivery.

When they finally deliver the codes to operations team, they are left with very minimal time to create and implement new test cases. So they skip many of the test cases which they realize later that those were of high priority.

Problems of Developer

Stage 3:

Though virtually the build seems to be ready to go production, but the results are completely unexpected. The build fails and a number of bugs occur.

Then for every bug occurred, they have to track why that occurred, where it occurred, what changes needs to be done to overcome it, will there be change in other’s codes to make it compatible with the previous ones. Finally, for all these bugs, a bug report has to be generated.

 Failure of Build

The failure is because of system errors due to the database; developer’s ignorance in efficiency of code, tester’s ignorance in number of test cases, etc.

As the client always keeps deadline tight, the employees involved in achieving them only concentrate in the final release even if they have to compromise the overall quality.

Though this seems to be a problem in coordination of work, this actually is the failure of the culture adopted.

This happens because of large dependency on manual processes. Running to and fro in the same team because of lack of knowledge of different field; lack of access or may be lack of interest increases our own burden and pain.

It’s high time that we need to be versatile. It might be difficult to be master of all processes involved in a system, but we can be the jack of all, mastering one among them. Then only we can automate our system or make it intelligent enough to recover rather than rollbacks.

Now, you might be thinking why?

It’s because, the one you are mastering is highly dependent on others. So to know about the dependency point, we need to understand the whole system.

So let’s think of a process to change the culture. Before that do you have the answer to the below questions?

  • Where does your current culture fail?
  • Why do you wish to change the process?
  •  Have you clearly identified all the required changes?
  •  Have you obtained feedback and buy-in from all affected stake-holders?
  •  Have you revalidated the process discipline, data and measuring system for the change?

So, now when we have the answer to all, we think of a revolution into our system. How will this revolution take place? It can only be achieved when we kill what we are now. A lot of time is wasted in the migration of code among the teams. We have to bring the process where we can do continuous integration and continuous deployment.

Continuous Integration and deployment

This process of continuous integration and deployment makes it more agile. Bringing this agility is considered to be DevOps culture.

DevOps is the practice of operations and development engineers participating together in the entire service lifecycle, from design through the development process to production support.

DevOps adoption

It is not easy to change the working system over the time. Making a successful transition is to renovate the system, rather than rebuild.

Now let’s see how we can achieve this. There can be two ways to approach.

1)    Top to down

2)    Bottom up

Diving deeper into these techniques, we will realize which is best suited for our organization.

In the top down approach, we can go to the higher management and ask them for making changes across all the teams. If the management is convinced then, we can start working on it.

But the probability of getting the answer as “NO” is quite high. It’s because changing the system can lead the organization to instability.

They have to look into the structure of organization, revenue, client’s interest level, etc. But the most important factor that pulls them back from steeping out of the old system is they can’t see the big picture of what can be achieved and how smoothly it can be achieved with the newer one.

In this case, we can look for the second approach to get this big picture.

The bottom up approach calls for volunteer. Here we have to take a small team and a small task and execute it in DevOps Model.

Looking into the technical side of this model, we have various set of sophisticated tools that makes the work more efficient and fast. But, tools alone are not capable enough to create a collaborative environment referred to as DevOps.

Creating such an environment requires you to think out of the box e.g. assessing and realigning how people think about their teams, the business and the customers.

Putting together a new set of tools is simpler than changing organizational culture. By promoting the anti-social master developers, allowing inefficient code to be integrated, deploying codes that was not properly tested, putting blames on each other’s head, considering operations team to be stupid are not the best practices that we are following to enable the business and create value for our customers.

It is not the tools, it the people using them that make the process complex. To say at an abstract level rather than collecting ideas and behaviors, being open to them takes us to a bright path.

Let’s start with a team of 6 member and a 3-point story. First, we have to break the team we call as developers, operations, testers, etc. We consider all of them as one, say “DevOps”. When we receive the requirements we need to analyze the zones of risk. Keeping in mind the deeper sections of the sea….. We start sailing.

CI and CD

Now, you must be thinking “what is the x-factor of these continuous integration and continuous deployment that decreases the probability of failure”.

Advantages of CI and CD

With the improved vision and process, we can approach the management putting the clear picture of the results like how smooth the process was, how the risk of failure was reduced, how the task was completed before the timeline, etc.

Now, we can clearly visualize how the whole process was optimized on technical and cultural ground by having retrospection after each iteration.

Got a question for us? Mention them in the comments section and we will get back to you. 

Related Posts:

Get Started with DevOps

DevOps Redefining your IT Strategy

Mystery of DevOps

Share on

24 X 7 Customer Support X

  • us flag 1-800-275-9730 (Toll Free)
  • india flag +91 88808 62004