← Latest papers
💻 computer science

Overcoming Challenges in Agile and DevOps Integration: A Qualitative Study

This qualitative study, based on interviews with six industry professionals from Brazil and Germany, identifies key cultural, structural, process, and technical challenges in integrating Agile and DevOps while proposing four strategic solution domains to help organizations overcome these barriers and improve software delivery.

Original authors: Juliana Fraislebem, Mali Senapathi, Michael Neumann, Eva-Maria Schön

Published 2026-06-02
📖 5 min read🧠 Deep dive

Original authors: Juliana Fraislebem, Mali Senapathi, Michael Neumann, Eva-Maria Schön

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are trying to run a high-speed race car (Agile) inside a massive, complex factory (DevOps).

Agile is like the driver: they want to speed up, turn corners quickly, and change the route based on what the passengers (customers) want right now.
DevOps is like the pit crew and the factory floor: they want the car to be safe, the engine to run smoothly, and the repairs to happen automatically without stopping the race.

The paper you shared is a study about what happens when you try to combine these two worlds. The researchers interviewed six experienced "race mechanics" and "drivers" from Brazil and Germany to find out why this combination is so hard and how to fix it.

Here is the breakdown of their findings in simple terms:

The Big Problem: Why It's Hard to Mix Them

The researchers found that the biggest hurdles aren't usually the tools or the code; they are the people and the rules. They grouped the problems into four main categories:

  1. The "Wrong Idea" Culture (Cultural & Organizational Barriers):

    • The Metaphor: Imagine the driver thinks "Agile" means "run as fast as you want, no rules," while the pit crew thinks "DevOps" means "buy a new robot arm."
    • The Reality: People often misunderstand these concepts. They think buying software tools (like GitLab) makes you a DevOps team, or that Agile means following a strict, rigid checklist. In reality, Agile is about a flexible mindset, and DevOps is about collaboration, not just tools. There is also a "blame culture" where people are afraid to make mistakes, which stops them from trying new things.
  2. The "Glass Walls" (Structural Constraints):

    • The Metaphor: The driver is in the car, and the mechanic is in the garage, but there is a thick glass wall between them. They can see each other, but they can't talk or pass tools easily.
    • The Reality: Companies often have departments that don't talk to each other (silos). The people who write the code (developers) and the people who keep the servers running (operations) are often in different rooms with different bosses. Also, sometimes the company is too slow to make decisions, or they rely on outside companies (like Apple or Google app stores) that won't let them update their software quickly.
  3. The "Over-Complicated Rulebook" (Process & Method Complexity):

    • The Metaphor: The team is trying to follow a 500-page instruction manual that was written for a different type of car, and it's slowing them down.
    • The Reality: Companies often try to force big, rigid frameworks (like SAFe) onto their teams. This adds too much paperwork and meetings. It becomes hard to balance fixing broken things (urgent) with building new things (innovation).
  4. The "Blind Spot" (Technical Limitations):

    • The Metaphor: The driver is speeding, but the dashboard is broken. They don't know the engine is overheating until the car catches fire.
    • The Reality: Sometimes, the systems aren't set up to "see" what is happening in real-time. If something breaks, it takes a long time to figure out why because the data is scattered across different tools.

The Solutions: How to Fix the Race

The experts interviewed offered four main ways to solve these problems:

  1. Build a "Super-Team" (Team Structure & Autonomy):

    • The Fix: Instead of having a "driver" and a "mechanic," create a team where the driver is the mechanic.
    • The Idea: If the person who writes the code is also responsible for keeping it running, they will write better code. They won't want to break things because they are the ones who will have to wake up at 3 AM to fix them. Give these teams the power to make their own decisions without asking for permission from a boss for every tiny change.
  2. Change the "Team Spirit" (Culture & Collaboration):

    • The Fix: Stop blaming people when things break; start asking "How do we fix the system?"
    • The Idea: Create a safe environment where people can admit mistakes without fear. Use tools to make everyone's work visible (like a shared whiteboard) so everyone knows what is happening. Change the reward system so people are rewarded for helping the team win, not just for being the fastest individual.
  3. Be Flexible with the Rules (Process & Change Management):

    • The Fix: Don't follow the rulebook blindly; follow the principles.
    • The Idea: If a rule (like a specific meeting) isn't helping the team move faster, drop it. Start small. Don't try to change the whole factory overnight. Pick one small team, prove it works, and then slowly expand. Be honest about where you are and don't pretend you are "Agile" if you aren't ready.
  4. Upgrade the Dashboard and Tools (Automation & Infrastructure):

    • The Fix: Automate the boring stuff and install better sensors.
    • The Idea: Use robots (automation) to test the code and deploy updates so humans don't have to do it manually. Build a "train" system where updates go out on a schedule (e.g., every Tuesday) so everyone knows when to expect changes. This reduces the risk of breaking things.

The Bottom Line

The study concludes that you cannot just buy software to fix this. You have to change the culture.

It's like trying to turn a slow, heavy cargo ship into a speedboat. You can't just put a faster engine in (tools); you have to change how the crew works together, how they make decisions, and how they view their responsibilities. The most successful teams are the ones where the people building the software and the people running it are on the same team, sharing the same goals, and trusting each other.

Limitations: The researchers admit they only talked to six people, so while their advice is very smart, it might not fit every single company in the world. They suggest more studies are needed to see if these ideas work for everyone.

Drowning in papers in your field?

Get daily digests of the most novel papers matching your research keywords — with technical summaries, in your language.

Try Digest →