CMO – Leader of Sales Marketing
Cloud-native architectures have separated the roles of developers and DevOps. Is this the right way to go or should developers seize control of their code?
With the introduction of container orchestration frameworks like Kubernetes, the adoption of cloud-native technologies, and the transition to microservices architectures, engineering organizations were empowered to build scalable and complex applications. DevOps engineers have had an indispensable role in this revolution, enabling and supporting these processes.
As part of this process, DevOps roles have evolved, shifting their focus from traditional network and IT needs to managing cloud infrastructure, CI/CD pipelines, virtual environments, and more. DevOps has become its own thriving culture.
It is quite common to see that, as a result, organizations have crudely separated developers’ responsibilities from those of DevOps. Everything that has to do with code and core-logic development, is the role of developers. Going beyond the local machine, however, is often DevOps’ turf. This includes anything from CI/CD, cloud deployments, and even basic network access to remote resources.
The New Challenge with Cloud-Native Architectures
While microservices provide dev teams with many advantages, simplicity and order are not among them. Even though each service is (in theory) simple in itself, it doesn’t mean the system as a whole became simpler – the complexity pattern has changed. In cloud-native architectures, unlike monoliths, your code runs in many different deployments – in microservices (deployed in Kubernetes, or other container orchestration framworks), serverless functions, big data pipelines and notebooks, legacy cloud instances, and more. This means that the distance between the code developers write and how it actually runs has grown, and continues to grow – it is no longer trivial, and often quite hard, to understand how your code would behave in its actual deployment environment. Code in your IDE (“at rest”, so to speak) and code in your cloud environment (“in transit”) are growing further and further from each other.
It gets worse – even if you’re able to make sense of how things are working today, things may not be working tomorrow, for a variety of different reasons: code changes in your repo, of course, but also code change in repos of other microservices, infrastructure changes, configuration updates, 3rd party updates and more.
This is frustrating since it renders developers with less and less control over how their code performs. Many developers leave this to DevOps, expecting them to figure out how to ensure their code works in production, instead of just on the local machine.