This is a bit of a rant piece but I feel like the term devops, though good in its original fundamental meaning, is misused so much to the point of becoming meaningless these days.
I believe the term itself is good in the original sense. It is a concept where the same person is responsible for developing and operating the application. You write the code to create the features, create the monitoring for those features, make sure it is running, and most importantly you fix it if it breaks. If something stops working at 2am, you are woken up to fix it. All the incentives are aligned for you to make reliable software which should be the goal for all software.
The bear case for Devops is that having the same people doing all these things is nowhere near as efficient as having a specialised person for each skill. All the tasks in software engineering are enormous fields of their own and expecting the same person to be as skilled on each level is too much to ask. However in reality with modern platforms and services, they are mostly able to offload enough of these things you should only have to set them up initially and figure out the correct configuration for your app, which only you will know how to do. I mean, who knows better what metrics are important: the expert in the code or the expert in observability? The principle of Devops is the code expert knows best. For some apps CPU might be important and should be watched closely, but for most it probably doesn’t matter at all and measuring a user facing metric like latency is a far more important way of determining how well the app is behaving. Platforms and services, be they external ones you buy or internal ones built by a specialised team, should mostly offlload all of that so all you need to do is specify the outputs: here is my latency metric input and the outputs should be this dashboard and this channel.
However I think some abuse the term Devops quite a bit to mean it is a person who is responsible for all the stuff they don’t want to do. Often this means a team of developers who don’t know or even want to know how the app is run. Quite likely they don’t want to be responsible for figuring out how their app is running, meaning kubernetes or whatever platform. I get that it is enormously complicated and not for the faint of heart but offloading to a single person on the team just disrupts all that aligning of incentives and breaks the principle of who knows best. Instead if becomes where someone writes the code and throws it over the wall for the next person to figure out how to run. When this breaks down you get conflict and a blame game of where the responsibility lies.
What is the answer then? I think the response by developers to not want to figure out kubernetes or some other infrastructure is a fair one. The answer in my opinion is a proper developer platform. Where and how the code is run should be made as easy as possible with all the features wrapped into an easy to use manner. A developer experience or platform team which runs the kubernetes clusters or other infrastructure and hides as much of the complexity as possible into as nice of a wrapper as possible is the answer, rather than the developer team trying to figure out what is going on. If this sounds expensive then it should be as these things aren’t easy to do right. But done right it becomes an enabler for better and more reliable software.