<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Johnny Dallas on Medium]]></title>
        <description><![CDATA[Stories by Johnny Dallas on Medium]]></description>
        <link>https://medium.com/@theonlyjohnny?source=rss-cce5bca207de------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*2qBdBYoFjFAbpWCpfRucnQ.png</url>
            <title>Stories by Johnny Dallas on Medium</title>
            <link>https://medium.com/@theonlyjohnny?source=rss-cce5bca207de------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Thu, 19 Nov 2026 15:19:20 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@theonlyjohnny/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[DevOps is a Collaboration Problem]]></title>
            <link>https://medium.com/@theonlyjohnny/devops-is-a-collaboration-problem-a992491e036b?source=rss-cce5bca207de------2</link>
            <guid isPermaLink="false">https://medium.com/p/a992491e036b</guid>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[cloud-computing]]></category>
            <category><![CDATA[engineering]]></category>
            <category><![CDATA[company-culture]]></category>
            <category><![CDATA[engineering-mangement]]></category>
            <dc:creator><![CDATA[Johnny Dallas]]></dc:creator>
            <pubDate>Thu, 07 Mar 2024 00:51:17 GMT</pubDate>
            <atom:updated>2024-03-07T20:00:15.198Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*H-B2otYM4QgFyYOxQTKQJA.jpeg" /></figure><p>DevOps isn’t a new topic, nor one often perceived as particularly sexy in the world of software engineering — especially if you’re knee-deep in the burgeoning Age of AI. However, as <a href="https://www.youtube.com/watch?v=ia8Q51ouA_s">Krazam recently reminded us</a>, DevOps is a meaningful term. And we’re all thinking about it wrong.</p><p><a href="https://devopsisnotatitle.fyi/">DevOps is not a single title or role</a> — you shouldn’t have a “DevOps” engineer. DevOps is a philosophy of collaboration; it’s about enabling software to be crafted with speed, scale, reliability, and maintainability at the core. As such, “DevOps” has taken many forms throughout the years — from silos &amp; sysadmins to GitOps and Platform Engineering. The terms and strategies have changed as our collective industry has matured, but the fundamental intent has remained the same.</p><p>The <strong>reason</strong> there have been so many different attempts — and why each attempt has arguably reached some level of adoption but none have genuinely dominated — is because DevOps is so inextricably linked to the structure of the company employing it. Some businesses need to ship hundreds of updates daily, while others need to ensure their monthly release is <em>perfect</em>. Some orgs can afford an army of SREs to monitor every possible anomaly anywhere in the stack, while others are underwater enough as it is just trying to ship the next set of features.</p><p>Just like the unique elements that form a company’s culture, DevOps cannot be copied and pasted from one company to another; it is a practice that must be fostered from within and will be guided by the unique combination of requirements and leadership of your team.</p><p>While DevOps looks different across every organization, a few ideas are standardizable, enabling truly scalable DevOps. Note that none of opinions are based on the tools used, as much as they are focused on facilitating effective collaboration.</p><h3>Communicate through APIs</h3><p><a href="https://news.ycombinator.com/item?id=18916406">To borrow an Amazon-ism,</a> all teams should communicate with each other through service interfaces. If there’s a service a team offers, it should be documented in the form of functions, inputs, and outputs. If there’s a job to be done, it should be able to be described by a set of operations exposed by those functions.</p><p>When teams are forced to expose interfaces for their services, they also become responsible for maintaining them. This forces service teams to focus by creating a negative incentive on scope-creep; teams are constantly aware of the exact operations they provide, and each operation is heavy enough in terms of effort to incentivize them to minimize the number of operations. This leads to better API designs where each operation is more powerful and extensible, rather than more bespoke.</p><p>Communicating through interfaces also makes it easier for internal teams to improve their operational excellence because it is simple to track how often each internal operation executes. Team planning starts with “Where are we spending most of our time?,” which is now trivial to answer. The heaviest operations can be optimized or automated, while the least used can be deprecated.</p><h3>Push power to the edge engineers</h3><p>An ongoing debate in DevOps has been “siloed” vs. “self-service.” How should responsibilities fall between a specialized centralized infrastructure team or a distributed group of less-specialized application development engineers? Today (for good reasons), most orgs concur that silos and “throw it over the wall” philosophies are immensely inefficient and create gaps among co-workers that inevitably lead to strife and slow-downs.</p><p>Engineering leadership should recognize this is a critical decision and continuously reinforce their stance at every opportunity. An organization with well-functioning DevOps will assign problems to the engineers with the most context on the systems the problem touches. Too often, the developers at the edge — i.e., the application developer building the new feature — get relegated to “you should only write business logic,” and are told to open a ticket for any infra-adjacent tasks. Not only does this slow down their pace, but it also squanders a valuable resource for the org — developers are smart; that’s why they’re developers! While the engineer building a specific service may not be the most knowledgeable about the best practices and nuances of every infrastructure topic, they are likely the foremost expert in their own service.</p><h3>Tribal knowledge is worth its weight in gold</h3><p>One of the most entertaining ways to spend an afternoon the next time you find yourself in a room of Senior Engineers (especially SREs!) is to ask them for their “war stories.” Every experienced engineer I’ve met has some story of a launch gone wrong, an intern with too many permissions, or an architectural failure that took months to rear its head.</p><p>Experience is earned through sleepless nights and PagerDuty pings, and displayed in the battle scars of scale. Each mistake and incident teaches you something that you bring with you to your next job, next project, or next attempt. It’s an imperfect, eventually consistent way of getting the correct answer, but it works.</p><p>As a parallel, software systems accrete tech debt the longer they last. Whether it’s because a new unplanned feature needs to be developed, a new CVE is discovered, a new version of a dependency is released, or some existing system is deprecated, your systems will fall out of date and require ongoing effort to keep serviceable.</p><p>Ultimately, both of these sinks — engineers and services — accrue different types of wear and tear. However, one benefits from it (i.e., engineers gain experience) while the other suffers (i.e., services accrue technical debt). Unfortunately, the group that appreciates is also the least committed to your org; over time, engineers will retire, but services will stay ~forever.</p><p>Capturing the tribal knowledge — the little tips and tricks and internal hacks for mitigating tech debt and running old services, especially when the engineers who built them have long since left the team — is paramount for functional DevOps. Every little pain that is felt (and turned into that individual’s experience) but not captured in either a runbook or some automation represents a future debt that will be far more expensive to pay off than it is initially.</p><p>You’ll notice most of these tenets come across more as engineering-culture policies than hard-and-fast rules like “only deploy 12-factor apps.” This is purposeful and reflects the core problem of collaboration that DevOps seeks to solve.</p><p>While there are many tools on the market that fit into the category of “DevOps” — spanning from CI &amp; CD to observability, testing and security toolchains, monitoring systems, <a href="https://www.cortex.io/post/what-is-an-internal-developer-portal">developer portals</a> and full-fledged <a href="https://zeet.co/blog/internal-developer-platforms-are-cool?utm_campaign=zevangelism&amp;utm_source=medium&amp;utm_medium=social">IDPs</a> — ultimately, the combination of tools that a given company employs <em>is</em> their DevOps setup.</p><p>There have been many attempts to centralize and standardize DevOps into a single product, but it is much more challenging for an external business to create a good DevOps setup for a company than it is for the company to build itself. The reason for this is simple: managers can enforce arbitrary policies, but software with the wrong opinions doesn’t get bought.</p><p>Following this insight, if there is a product that can up-level the DevOps industry, it isn’t another point solution. We need a new collaboration platform that makes it easy for the above tenets (in-line with other elements of the company’s unique engineering culture) to be expressed. One can imagine this platform provides an interface for both App Devs and Infra engineers, where App Devs can express their desires (whether that means “I want a web service with CI/CD” or “I want this container to scale to 10k RPS” or “I want a subdomain to point to this endpoint”), while Infra engineers build runbooks to serve these requests (while enforcing guardrails that enforce higher-level operation requirements). This platform would need to serve a broad set of operations so an org could commit to all developer operations running through it. It would need to be highly extensible and focused on capturing each interaction point between relevant teams. Abstractions would need to be a core concept — to push power to the edge engineers, you must have controls in place that reduce unnecessary detail and prevent a cognitive meltdown. It would need to collect the little details of each interaction and make it simple for the relevant parties to encode the tribal knowledge into software as it is created.</p><p>This world of smooth software-enabled infrastructure collaboration is what we’re trying to bring about at Zeet. Our product provides an opinionated but customizable platform for both app developers and infra engineers to manage a suite of cloud-native services — from Docker Containers deployed on Kubernetes to Terraform Modules and Serverless Functions. We want to provide a simple window-shopping experience for app developers looking to build infra and a flexible engine that infra engineers can use to express their ever-developing engineering culture. We have a ways to go to realize this promise, but DevOps IS a meaningful term, and I can’t wait to see what we’ll build next!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a992491e036b" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>