Adventures in DevOps

Share Episode         
         
We welcome David Burns, Head of Open Source at BrowserStack and previously Mozilla, this week to help explain how can browser and mobile app testing be so bad still in 2026. "Even if we had to do it all over again, we probably still wouldn't have gotten it right", might just be the biggest learning. We review some of the core challenges that cause even the most experienced web engineers pain and how some companies are attempting to avoid them.

We also review shares lessons from Mozilla’s 'War on Orange,' demonstrating why chasing a 100% green CI suite at scale is a fool's errand, and why engineering teams must instead manage delta tolerances and adhere to a strict testing pyramid. Additionally, we investigate the physical hardware nightmares of running 30,000 real phones in data centers; from battery swelling and custom Faraday cages to complying with Apple EULA requirements using racks of Mac Minis. And finally, we discuss WebMCP, Project Fugu, and why LLM browser agents still struggle against edge-case browser behaviors like the Back-Forward Cache (BF Cache).

Share Episode         
         
From your feedback, we know that on-call issues, especially those that arise at the database layer are always the most challenging to solve. This episode builds on our Grafana Observability episode as we go deeper into the challenge of data ownership in data lakes. Apache Druid creator, previous Yahoo Distinguished Engineer, Fellow at Splunk, and currently the Chief Architect as Imply, Eric Tschetter joins us to confirm that there are unsolved problems in data platforms, and it doesn't get better when we throw agents into the mix.

In the true DevOps mindset aligment, Eric reminds us that whoever is operating the system, knows what is going on, they know their service boundaries, and so it's their choice to make. And the sad reality is that at large enough companies, you will always have independent teams making independent decisions, it's never possible to fully align them, and realistically we get down to why it is even a mistake to try.

Share Episode         
         
Sauce Labs CTO Anoop Tripathi addresses the root causes of broken test suites and why teams frequently become numb to intermittent test failures. Anoop shares concrete lessons from his career, detailing how bad practices like embedding fixed sleep routines instead of signal-based waiting ruin test reliability. We discuss the necessity of designing products for testability from day one—such as using pair programming where one developer writes the implementation while the other writes the test suite, or building dedicated test interfaces directly into the application architecture. We also analyze the hidden business costs of poor quality, where engineering debt forces sales teams to spend their time managing upset clients instead of acquiring new revenue.

We explore organizational anti-patterns—such as teams claiming to be 'Agile' with one-year sprint cycles, or shipping debug builds to production because release builds continuously crash, highlighting a pair-programming model where one developer writes the code while another writes the corresponding tests

Finally, we tackle the dangers of chasing vanity metrics, from engineers writing automated assert pass statements to claim fake coverage, to organizations bragging about more code. Anoop distinguishes between output gain and outcome gain, warning that LLMs are creating a massive testing and review crisis by generating 20-page documentation files for minor features.

Share Episode         
         
In this episode, we sit down with Nikhil Mungel, Head of AI R&D at Cribl, to discuss how LLMs have dramatically transformed the tech hiring landscape. The conversation opens with an honest look at the flood of AI-generated, low-quality resumes and remote interview cheating tactics, which have pushed many organizations toward in-person whiteboard interviews or closed-network referrals.

We explore how software development has evolved from character-by-character coding into "judgment work," where an engineer's value relies on holistic decision-making, taste, and business alignment rather than raw syntax memorization. Nikhil emphasizes the importance of an "ownership mindset," urging developers to move beyond acting as mere specification-translators and instead evaluate technical trade-offs through a business-focused lens. We also pull back the curtain on modern technical interviews, highlighting why expressing strong convictions, asking intentional career questions, and proving human reasoning without LLM assistance remain essential for standing out.

Share Episode         
         
Pushkar Gopalakrishna, Senior Staff Software Engineer at Snap, previously Cruise and AWS, joins to explore why engineering organizations pivot away from Terraform and HCL toward Kubernetes-native tools even when they might not be better. We unpack how developer friction, copy-pasted control structures, and misaligned organizational incentives create massive tech debt—often forcing SREs to manually update infrastructure repositories for compliance, resulting in broken pipelines and severe operational friction.

We debate over the mechanics of Crossplane, detailing how its continuous reconciliation loop and Custom Resource Definitions (CRDs) allow teams to express cloud infrastructure as YAML alongside their application manifests at potentially the cost of async validation. Pushkar pulls back the curtain on how Cruise managed infrastructure at scale using a custom internal platform called 'Juno' to bootstrap GCP projects, repositories, and permissions, while leveraging Crossplane for application-level resources. We also dive into the dangers of using CI tools for continuous deployment, detailing a terrifying incident where a pipeline bug accidentally marked three production Kubernetes namespaces for deletion, and how moving to ArgoCD and Argo Rollouts helped prevent future outages for autonomous vehicles.

Finally, we touch on the realities of non-production environment isolation, testing against live APIs, and why platform teams must balance providing a seamless developer experience without stripping away developer accountability.

Share Episode         
         
Co-Founder of Grafana Labs, Anthony Woods, joins to share his perspective on how open source solutions are thriving despite the deluge of pull requests being thrown at them through their open source repositories.

Most importantly, he outlines how observability is no longer being done by users looking directly at dashboards. The data rarely makes to LLMs or automation, it rarely makes sense even to humans looking at them, without the context. The context is critical component, and having a model that was built on the semantic concepts relevant to your use cases.

And of course we can't stay away from asking on the record the current state of security of open source repositories from a vendor side. Given how their was an inevitable incident with some of the Grafana open source repos, we dig in to figure out how they are dealing with the real world impacts of malware being spread throughout the ecosystem.

Share Episode         
         
As it turns out, the entire artificial intelligence boom is essentially running on Wikipedia's free labor, but while knowledge is free, physical server infrastructure definitely is not. We sit down with Moriel Schottlender, Principal Systems Software Engineer at the Wikimedia Foundation, to dissect how public systems survive an endless onslaught of high-volume AI scrapers and aggressive crawlers. Because 65% of the resource-heavy requests originate from automated bots, we explore how Wikimedia navigates this traffic without blocking legitimate users. We skip the approaches of IP-banning which doesn't work in practice and discuss actual mature architectural strategies, by focusing on the users' needs. From structured database dumps and high-volume enterprise APIs to rate-limiting and CDN caching trade-offs.

It's a mind-bogglingly complex ecosystem ­of open-source, a 25-year-old PHP monolith supporting over 900 distinct site instances across 300 languages and 11 unique projects. It's an immense engineering challenge to modernize infrastructure while serving 250,000 active volunteer editors who build custom workflows via Toolforge—Wikimedia's internal, open-source mini-AWS.

Finally, we have to tackle the philosophical divide between artificial statistical models and human creativity. Because LLMs are trained to predict the statistical mean, they inherently miss the edge cases where real human value, internationalization, and accessibility actually reside. And even if they did, we managed to squeeze out every last bit of AI creativity that early models had until what we are actually left with is the most boring result. We also commiserate over the gratuitous low-quality AI pull requests flooding open-source repositories, drawing parallels to the chaotic Hacktoberfest spam of years past.

Share Episode         
         
We are joined this week by Mark Hay, CTO and co-founder of TextQL and former lead of Text Classification Infrastructure at Meta, to uncover the hidden complexities behind massive-scale machine learning. Mark explains why the most crucial features for identifying abusive behavior, like drug dealers or scammers on Facebook and Instagram, rarely rely on the content itself but instead analyze the underlying behavioral graphs, such as abnormal friend requests or messaging patterns.

Of course we review the adversarial nature of spam detection, where bad actors constantly evolve from simple regex evasion to embedding messages inside images or even utilizing pure symbolic communication, like comparing different sized cucumber emojis to evade text filters. That requires diving into the evolution of database querying and the rise of the semantic layer. Mark unpacks why relying on raw LLMs to write complex SQL is a recipe for hallucinations, and how implementing a "correct by construction" semantic layer guarantees structurally sound queries by restricting outputs to a strictly defined configuration. However, this rigid structure fundamentally stifles the creative flexibility of LLMs.

Lastly, we can't avoid exploring the tension between these approaches and how new tools aim to bridge the gap by dynamically balancing raw SQL generation with structured ontological constraints, providing rapid time-to-value for analytical workflows. Finally, we discuss the controversial philosophical shift occurring within software engineering, particularly the tension between the "Don't Repeat Yourself" principle and "Locality of Behavior".

Share Episode         
         

We sit down with Itacama CEO Pia Wiedermayer to discuss the absurdity of siloed QA, the disaster of AI-generated API tests, and why developers hate the word "quality." This time we are asking the age-old question: Who needs testers anyway? Pia and Warren discuss how to dismantle the toxic culture of isolated quality assurance.

We explore how the ghosts of waterfall development still haunt modern teams, creating silos where developers blindly throw unverified code over the wall and expect a separate QA department to magically inject quality. Included is the inevitable discussion on the psychological safety of hiding behind narrow job titles and why refusing to take collective ownership of a product is a guaranteed recipe for architectural failure.

Of course we can't avoid commenting on the terrifying reality of replacing human intuition with automated hype. Pia shares a case study of a scale-up that aggressively pivoted to "full steam AI development," intentionally excluding both their Product Owner and QA from the entire experiment. Predictably, it did not end well, but we were able to laugh at the painful irony that an AI-accelerated project scheduled for four weeks ended up taking eight weeks, proving that simply generating code without human oversight just creates more sophisticated bottlenecks.

Share Episode         
         
We talk with Ragic CEO Jeff Kuo about Semantic Web origins, dodging DDoS attacks, and the absolute horror of a database that randomly deletes its own files. He revisits how a 25-year-old master's thesis on the Semantic Web evolved into a massive spreadsheet-driven database builder. It's the one better Airtable alternative.

Rather than forcing non-technical users into complex two-layer SQL architectures, Ragic utilizes a highly flexible, graph-based data model. Achieving this performance meant abandoning traditional ORMs to build a custom graph indexing engine on top of Berkeley DB, a key-value store. This custom implementation came with brutal growing pains, including a terrifying bug that would randomly delete the wrong data files. To survive, Ragic's team shares with us just exactly how they had to hijack the internal implementation to avoid these sorts of problems.

When we get down to it, we review how they dealt with critical DDoS against their cloud providers, how they performed a cloud migration in just one weekend, and how they manage thousands of tenants on shared infrastructure.

Share Episode         
         
Developers spend more than 50% of their time reading code, making it the single largest expense in software engineering. Despite this massive cost, the industry rarely discusses or optimizes how we read code. So we've brought in Tudor Girba, CEO at Feenk to help us rethink, just how software engineering should be done. Instead of relying on manual reading and generic text editors, teams must shift toward building deterministic, contextual tools to directly extract information and answer questions about their systems.

The suggested solution? Contextual and composable micro-tools writen by everyone focused on exposing just the right information at the right time. This creates the opportunity for structural interrogation of your solution.

And how many tools should we? We'll if one example of tool is testing, and 50% or more of your code can be tests, imagine what percentage of your software should be actually production related!

Most importantly, generic tools fall short, but where can we find how to build the right tools, listen in to find out....

Share Episode         
         
Welcome back to another hopefully, relief from architectural existential dread. This week, we've pulled in Seth Eliot from Arpio, (Ar-Pi-O, RPO, get it?), to dive headfirst into the beautiful, deeply expensive illusion that migrating your legacy infrastructure to a major hyperscaler magically grants it instant immortality. It doesn't. We break down the shared responsibility model for resilience, which was conveniently cribbed straight from the security model, and analyze how the foundational promise of automated fault isolation boundaries routinely crumbles.

From cloud providers sticking multiple "independent" availability zones inside the exact same physical building, to multi-AZ cascading anomalies, to regional power grid failures, it's clear your provider's abstractions aren't nearly as resilient as their marketing slides suggest.

Discussed within is the "Thundering Herd" phenomenon, that can't be ignored even when the failover clusters are designed correctly. From cross-organization KMS re-encryption loops to the horror of fragmented application logs across CloudFront edge regions, at the end of the day, true resilience isn't achieved by forcing your engineering team to implement features, it's about architecting your baseline, confidentiality for the inevitability of production burning to the ground.

Share Episode         
         
This week's adventure tackles the absolute absurdity of modern enterprise infrastructure, where a single company can easily find itself running multiple different CI/CD platforms due to unchecked mergers and acquisitions. We've brought in Chris Farris, AWS Security Hero and consults with companies via Securosis. And dig deep to find the security cracks and philosophize about the real world impacts of tech debt in the AI age.

Management rarely prioritizes standardization, leaving security teams to defend a chaotic swamp of mixed cloud providers, GitHub repositories, and nostalgic on-prem Bitbucket instances. We define this accumulated technical debt not as some abstract concept, but as literal potholes on the infrastructure Autobahn—annoying speed bumps that permanently damage velocity and set organizations up for an inevitable disaster. We contrast this with the evolution from old-school sysadmins cutting their fingers on rack screws to modern engineers spinning up entire architectures with a few lines of code, noting that the ease of deployment has far outpaced our willingness to clean up our own mess.

The crisis is only accelerating now that the cost of writing code (but not having to maintain it) is rapidly approaching zero. While letting an AI agent autonomously build a website or manipulate an AWS sandbox over a single Saturday afternoon sounds magical, it creates a terrifying volume of unreviewed, context-devoid software. Compounding this systemic frailty, massive cloud provider layoffs mean the crucial institutional memory and human operational experience required to survive are walking right out the door. We expose the fundamental flaw of modern agentic tooling: they completely lack fine-grained access control, operating on a dangerous all-or-nothing identity model. Until autonomous agents are engineered with actual conscience, consequence, and common sense, security teams will continue fighting a losing battle against a digital supply chain.

Share Episode         
         
We grabbed Donald Nguyen, co-founder and CTO at Corvic, to discuss the absurd complexities of enterprise data and multimodal inference. We explore how organizations habitually hoard mountains of useless, "dead" data just out of the sheer fantascy that someone might ask for it later. We highlight the fundamental disconnect where data collectors using tools like Airbyte and Kafka speak a completely different language than the business consumers analyzing it in Excel.

True scale isn't just about managing petabytes; it's the absolute nightmare of extracting subjective business meaning from flat PDFs and invoices. In the deep-end of vector embeddings, we're challenging translating data into a different semantic universe requires imposing a heavy business bias. Auditors and artists will view the exact same invoice completely differently, meaning your embedding model selection is incredibly subjective to the business context.

The industry's desperate search for actual AI success stories beyond basic workflow automation is still ongoing as we laugh—and cry—at the reality that companies are likely budgeting 50% of an engineer's salary for LLM token usage, effectively enabling product managers to burn cash on infinite loops to generate prototype code. Reasonable or unreasonable?

And lastly, we tackle the existential dread of securing autonomous AI agents. Because fine-grained access control for agent actions is basically an unsolved fantasy, we must treat their execution environments as entirely untrusted, relying on rigid sandboxes like AWS Firecracker VMs. Prompt injection attacks are an inevitable flaw of the transformer architecture, and the industry's best defense mechanism seems to be wrapping models inside of other models to validate the outputs. It is quite literally turtles all the way down, and the winner of enterprise security is simply the organization that manages to put one more turtle ahead of the attackers.

Share Episode         
         
Down to business with GitHub's Cassidy Williams, Senior Director of Developer Advocacy at GitHub, where we try to untangle the existential dread of modern software development. It includes the sheer absurdity of managing a platform that officially crossed the one billion commit mark in 2025. Currently absorbing a completely unreasonable 275 million commits per week, GitHub's technical debt is naturally showing its age under the weight of AI agents aggressively creating pull requests. And with company's own copilot advocating for more, we explore the daily reality of being the internet's punching bag during an outage, and how the "Tiny Wins" buy back developer affection by still shipping the critical features.

Which of course is a small signal in the sea of the industry's collective identity crisis: vibe coding and the valley of AI-generated garbage. Discussed is one suggested solution of strongly typed languages which are skyrocketing in popularity because we desperately need rigid guardrails to babysit the hallucinated code our non-human agents are frantically pushing to production. Things have gotten so dire that we commiserate on missing the good old days of Stack Overflow, where instead of a chatbot agreeably telling you your terrible idea is great, a grumpy human engineer would just ruthlessly roast your architecture honestly.

Share Episode         
         
Founder of Bespinian and long-time cloud solutions architect, Lena Fuhrimann, sits down with us to clarify the widespread confusion around serverless architecture. We discuss how serverless is often incorrectly equated solely with Function as a Service (FaaS), when it actually represents a broader spectrum on the abstraction ladder—including managed AI inference, container platforms, and databases.

Lena shares her early career traps of building a fragmented landscape of sixty "nano-services" and explains why starting with a well-architected monolith and progressively breaking out microservices based on distinct resource or lifecycle requirements is a much saner approach. Then we shift to drivers behind cloud migrations, emphasizing that the primary financial benefit of serverless isn't necessarily shrinking the monthly cloud provider bill, but rather optimizing your most expensive resource: engineering time. By offloading mundane infrastructure patching to the cloud provider, teams can focus entirely on delivering tangible business value to customers. But cost is still there too.

We also explore the psychological challenges of adopting new paradigms, sharing a fascinating story of bridging the gap for a VM-loving engineer by introducing immutable infrastructure concepts through Packer and Ansible before fully transitioning them to containers. And of course we tackle the dreaded topic of "cold starts" and why complex workarounds—like building custom Lambda warmers to periodically call APIs—often defeat the core benefits of reduced total cost of ownership.

Share Episode         
         
We sit down with Ian Duncan, senior staff engineer on the stability team at Mercury, to discuss the delicate balance of choosing your tech stack and the implications. That means explore the concept of the novelty budget or frequently known as "Choose Boring Technology". It emphasizes why companies should carefully spend their innovation tokens on things that actually move the needle, rather than reinventing the wheel.

Mercury leverages simple technology like Postgres and EC2 instances alongside high-innovation bets like Haskell and Nix to maintain stability. The conversation unpacks the hidden complexities of over-relying on standard tools, sharing a cautionary tale about using a Postgres table as a massive queuing system until it consumed all the database resources and caused login failures. To solve architectural scaling without descending into nanoservice madness, we jump to discussing monolithic build systems. By leveraging hermetically sealed, modular build targets, teams can achieve massive parallelism and avoid endless local rebuilds while maintaining a single coherent view of the codebase.

We also advocate for separating management tools from primary systems by utilizing dedicated control planes, and touch on the rising popularity of durable execution frameworks like Temporal to handle resilient workflows. And it turns out Ian might be a bigger advocate of microservices that he thought!

Share Episode         
         
We explore the past and AI-driven future of Infrastructure as Code with Cloud Posse's Erik Osterman, discussing various IaC traumas. Erik maintains the world's largest repository of open-source IaC modules. Looking back at the dark ages of infrastructure, from the early days of raw CloudFormation and Capistrano to the rise and fall of tools like Puppet and Chef, we discuss the organic, messy growth of cloud environments. Where organizations frequently scale a single AWS account into a tangled web rather than adopting a robust multi-account architecture guided by a proper framework.

The conversation then shifts to the modern era of rapid integration of infrastructure development. While generating IaC with large language models can be incredibly fast, it introduces severe risks if left unchecked, and we explore how organizations can protect themselves by relying on Architectural Decision Records (ADRs) and predefined "skills". The hopeful goal of ensuring autonomous deployments are compliant, reproducible, and secure instead of relying on hallucinated architecture.

Finally, we tackle the compounding issue of code review in an age where developers can produce a year's worth of engineering slop progress in a single week.

Share Episode         
         
We sit down with Jaikumar Ganesh, Head of Engineering at AnyScale, to explore the intricacies of heterogeneous compute. He unpacks the growing CPU/GPU divide, detailing how ML pipelines require precise orchestration — using CPUs for data reading and writing while leveraging expensive, massive-die GPUs for chunking and embedding.

Warren brings the insight that, with AI agents rapidly changing how software is created, building is now a requirement of the business-focused team. And our guest shares how sales and marketing departments are increasingly using tools like Cursor and Claude to develop their own workflow automations. We discuss the challenges that this shift begs: what is engineering really doing for us?

JK emphasizes that the core responsibility of the engineering organization is reliability. While anyone can generate code, running stable production software requires the deep "battle scars", robust observability, and meticulous release processes that only a dedicated engineering team can provide.

That results in needing to find the right talent. But, finding the talent to maintain this critical infrastructure isn't easy, which is why JK advocates for highly creative hiring strategies. He shares incredible success stories of bypassing traditional recruiting by running hiring ads in foreign-language movies at local movie theaters and setting up booths at social food festivals to find uniquely qualified candidates.

Share Episode         
         
In this adventure, we sit down with Dan Wahlin, Principal of DevRel for JavaScript, AI, and Cloud at Microsoft, to explore the complexities of modern infrastructure. We examine how cloud platforms like Azure function as "building blocks". Which of course, can quickly become overwhelming without the right instruction manuals. To bridge this gap, one potential solution we discuss is the emerging reliance on AI "skills"—specialized markdown files. They can give coding agents the exact knowledge needed to deploy poorly documented complex open-source projects to container apps without requiring deep infrastructure expertise.

And we are saying the silent part outloud, as we review how handing the keys over to autonomous agents introduces terrifying new attack vectors. It's the security nightmare of prompt injections and the careless execution of unvetted AI skills. Which is a blast from the past, and we reminisce how current downloading of random agent instructions to running untrusted executables from early internet sites. While tools like OpenClaw purport to offer incredible automation, such as allowing agents to scour the internet and execute code without human oversight, it's already led us to disastrous leaks of API keys. We emphasize the critical necessity of validating skills through trusted repositories where even having agents perform security reviews on the code before execution is not enough.

Finally, we tackle the philosophical debate around AI productivity and why Dorota's LLMs raise the floor and not the ceiling is so spot on. The standout pick requires mentioning, a fascinating 1983 paper titled "Ironies of Automation" by Lisanne Bainbridge. This paper perfectly predicts our current dilemma: automating systems often leaves the most complex, difficult tasks to human operators, proving that as automation scales, the need for rigorous human monitoring actually increases, destroying the very value that was attempting to be captured by the original innovation.

Share Episode         
         
How much do you really know about the protocol that everything is built upon? This week, we go behind the scenes with Simone Carletti, a 13-year industry veteran and CTO at DNSimple, to explore the hidden complexities of DNS. We attempt to uncover why exactly DNS is often the last place developers check during an outage, drawing fascinating parallels between modern web framework abstractions and network-level opaqueness.

Simone shares why his team relies on bare-metal machines instead of cloud providers to run their Erlang-based authoritative name servers, highlighting the critical need to control BGP routing. We trade incredible war stories, from Facebook locking themselves out of their own data centers due to a BGP error, to a massive 2014 DDoS attack that left DNSimple unable to access their own log aggregation service. The conversation also tackles the reality of implementing new standards like SVCB and HTTPS records, and why widespread DNSSEC adoption might require an industry-wide mandate.

And of course we have the picks, but I'm not spoiling this weeks, just yet...

Share Episode         
         
We are joined by Daan Boerlage, CTO at Mavexa as we tackle the long-awaited arrival of IPv6 in cloud infrastructure. Here, we highlight how migrating to an IPv6-native setup eliminates public/private subnet complexity and expensive NAT gateways natively. As well as entirely sidestepping the nightmare of IP collisions during VPC peering.

Beyond the financial savings of ditching IPv4 charges, we explore the technical superiority of IPv6. Daan breaks down just how mind-bogglingly large the address space is, and focuses on how it solves serverless IP exhaustion while systematically debunking the pervasive myth that NAT is a security feature. We also discuss how IPv6's end-to-end connectivity, paving the way for next-generation protocols like QUIC, HTTP/3, and WebTransport.

The episode rounds out with a cathartic venting session about legacy architecture, detailing a grueling nine-year migration away from a central shared database that ironically culminated in a move to Salesforce. Almost by design, Daan recommends his pick, praising its intuitive use of signals and fine-grained reactivity over React. And Warren's pick explores storing data in the internet itself by leveraging the dwell time of ICMP ping packets.

Share Episode         
         
In this episode, we examine how the software industry is fundamentally changing. We're joined by our expert guest, Matt Edmunds, a long-time UX director, principal designer, and Principal UX Consultant at Tiny Pixls. The episode kicks, analyzing how early AI implementation in Applicant Tracking Systems (ATS) created rigid hiring processes that actively filter out the varied candidates who actually bring necessary diversity to engineering teams.

Of course we get to the world of "vibe coding", and revisit the poor LLM usage highlighted in the DORA 2025 report, exploring how professionals without traditional software engineering backgrounds are leveraging models to generate functional code.

Matt details his hands-on experience using the latest models of Claude Opus and Gemini Pro, successfully building low-level C virtual audio driver in 30 minutes drive by personal needs. We discuss the inherent challenges of large context windows, and coin the term "guess-driven development". To combat these hallucinations, Matt shares his strategy of using question-based prompting and anchoring the AI with comprehensive test files and documented schemas, which the models treat as an undeniable source of truth.

Beyond the code, we look at the broader economic and physical limitations of the current AI boom, noting that AI providers are operating at massive financial losses while awaiting hardware efficiency improvements.

Share Episode         
         
We dive into the shifting landscape of developer relations and the new necessity of optimizing documentation for both humans and LLMs. Melinda Fekete joins from Unleash, and suggests transitioning to platform to help get this right by utilizing LLMs.txt files to cleanly expose content to AI models.

The conversation then takes a look at the June GCP outage, which was triggered by a single IAM policy change. This illustrates that even with world-class CI/CD pipelines, deploying code using runtime controls such as feature flags is still risky. Feature flags can't even save GCP and other cloud providers, so what hope do the rest of us have.

Finally, we discuss the practical implementation of these systems, advocating for "boring technology" like polling over streaming to ensure reliability, and conducting internal "breakathons" to test features before a full rollout.

Share Episode         
         
Dorota, CEO of Authress, returns to apply the US Supreme Court’s definition of obscenity to a scandalous topic: Engineering Productivity. In a world obsessed with AI-driven efficiency, Dorota and Warren argue that software development productivity has nothing to do with manufacturing "gizmos" and everything to do with feelings. They dismantle the factory-floor mentality that equates typing speed with value, suggesting instead that the most productive work often happens while staring out a train window or disassociating in the shower.

The conversation takes a dark turn into the reality of performance reviews. If productivity is subjective, how do you decide who gets promoted? Dorota proposes the "Resentment Metric"—ignoring Jira tickets in favor of figuring out who the team has secret concerns fo. They also roast the "100% utilization" fallacy, noting that a fully utilized highway is just a parking lot, and the same logic applies to engineering teams that don't schedule downtime for actual thinking.

Ultimately, they land on a definition of productivity that would make any optimizer proud: deleting things. If the best code is no code, then the most productive engineer is the one removing waste, deleting replicas, and emptying S3 buckets. The episode wraps up with a credit-card-sized transformer (it's a tripod) and a book recommendation on why your international colleagues might be misinterpreting your silence.

Share Episode ⸺ Episode Sponsor: Rootly AI - https://dev0ps.fyi/rootlyai         
         
Paul Conroy, CTO at Square1, joins the show to prove that the best defense against malicious bots isn't always a firewall—sometimes, it’s creative data poisoning. Paul recounts a legendary story from the Irish property market where a well-funded competitor attempted to solve their "chicken and egg" problem by scraping his company's listings. Instead of waiting years for lawyers, Paul’s team fed the scrapers "Project Yellow Brick Road": fake listings that placed the British Prime Minister at 10 Downing Street in Dublin and the White House in County Cork. The result? The competitor’s site went viral for all the wrong reasons, forcing them to burn resources manually filtering junk until they eventually gave up and targeted someone else.

We also dive into the high-stakes world of election coverage, where Paul had three weeks to build a "coalition builder" tool for a national election. The solution wasn't a complex microservice architecture, but a humble Google Sheet wrapped in a Cloudflare Worker. Paul explains how they mitigated Google's rate limits and cold start times by putting a heavy cache in front of the sheet, leading to a crucial lesson in pragmatism: data that is "one minute stale" is perfectly acceptable if it saves the engineering team from building a complex invalidation strategy. Practically wins.

Finally, the conversation turns to the one thing that causes more sleepless nights than malicious scrapers: caching layers. Paul and the host commiserate over the "turtles all the way down" nature of modern caching, where a single misconfiguration can lead to a news site accidentally attaching a marathon runner’s photo to a crime story. They wrap up with picks, including a history of cryptography that features the Pope breaking Spanish codes and a defense of North Face hiking boots that might just be "glamping" gear in disguise.

Share Episode         
         
"Those memes are not going to make themselves."

Dorota, CEO of Authress, joins us to roast the 2025 DORA Report, which she argues has replaced hard data with an AI-generated narrative. From the confusing disconnect between feeling productive and actually shipping code to the grim reality of a 30% acceptance rate, Warren and Dorota break down why this year's report smells a lot like manure.

We dissect the massive 142-page 2025 DORA Report. Dorota argues that the report, which is now rebranded as the "State of AI-Assisted Software Development", feels less like a scientific study of DevOps performance and more like a narrative written by an intern using an LLM prompt. The duo investigates the "stubborn results" where AI apparently makes everyone feel like a 10x developer, where the hard results tell a different story. AI actually increases software and product instability — failing to improve.

The conversation gets spicy as they debate the "pit of failure" that is feature flags (often used as a crutch for untested code) and the embarrassing reality that GitHub celebrates a mere 30% code acceptance rate as a "success." Dorota suggests that while AI raises the floor for average work, it completely fails when you need to solve complex problems or, you know, actually collaborate with another human being.

In a vivid analogy, Dorota compares reading this year's report to the Swiss Spring phenomenon — the time of year when farmers spray manure, leaving the beautiful landscape smelling...unique. The episode wraps up with a reality check on the physical limits of LLM context windows (more tokens, more problems) and a strong recommendation to ignore the AI hype cycle in favor of a much faster-growing organism: a kitchen countertop oyster mushroom kit.

Share Episode ⸺ Episode Sponsor: Incident.io - https://dev0ps.fyi/incidentio         
         
"My biggest legacy at Google is the amount of systems I broke." — Sam Goto joins the show with a name that strikes fear into engineering systems everywhere. As a Senior Staff Engineer on the Chrome team, Sam shares the hilarious reality of having the last name "Goto," which once took down Google's internal URL shortener for four hours simply because he plugged in a new computer.

Sam gets us up to speed with Federated Credentials Management (FedCM), as we dive deep into why authentication has been built despite the browser rather than with it, and why it’s time to move identity from "user-land" to "kernel-land". This shift allows for critical UX improvements for logging in all users irrespective of what login providers you use, finally addressing the "NASCAR flag" problem of infinite login lists.

Most importantly, he shares why you don't need to change your technology stack to get all the benefits of FedCM. Finally, Sam details the "self-sustaining flame" strategy (as opposed to an ecosystem "flamethrower"), revealing how they utilized JavaScript SDKs to migrate massive platforms like Shopify and 50% of the web's login traffic without requiring application developers to rewrite their code.

In this episode, we sit down with Barzan Mozafari, MIT alum and University of Michigan professor, to explore how AI-driven automation is revolutionizing cloud database optimization. Barzan shares his experiences in bridging academia and industry, and how his work in AI-powered database tuning is reshaping cloud infrastructure efficiency.

We discuss the challenges of AI adoption in cloud computing, addressing concerns like implementation risks, security, and trust in autonomous agents. Barzan explains how machine learning models can optimize performance, reduce cloud costs, and automate database management, freeing engineers from tedious manual tuning.

Additionally, we explore the future of AI in database systems, the evolving landscape of public and private datasets, and what the next decade holds for data-driven automation. Whether you're a DevOps engineer or a database architect, this episode is packed with insights into the intersection of AI and cloud technology.

🎯 Picks:

Will is absent this week due to an infrastructure issue, so Warren and Jillian take the reins in a fascinating discussion with Hikari Senju, founder of Omneky. Hikari shares how AI is revolutionizing ad technology by automatically generating creative assets tailored to different audiences and platforms. His insights reveal how businesses can scale their advertising while maintaining brand consistency and reducing content creation costs.

The conversation explores the balance between automation and human oversight, the ethical implications of AI-driven marketing, and how the ad personalization technology is evolving. Hikari also dives into the infrastructure behind Omneky, discussing cloud-based AI deployment, model selection, and strategies for ensuring ad content stays fresh and relevant. If you've ever wondered how AI is reshaping the future of advertising.

🎯 Picks:

Share Episode ⸺ Episode Sponsor: Incident.io - https://dev0ps.fyi/incidentio         
         
Elise, VP and Head of UX at Unleash, joins us to talk all about UX. Self identifying as probably "The annoying lady in the room" and a career spanning nearly 30 years—starting before "UX" was even a job title — joins us to dismantle the idea that User Experience is just about moving pixels around. Here we debate the friction between engineering, sales, and the customer. We get to the bottom of whether or avoiding end-user interaction, understand, and research is a career-limiting move for staff+ engineers. Or should you avoid forcing a world-class developer to facilitate a call with a non-technical user if it makes them uncomfortable?

Warren calls out the "Pit of Failure" often faced by teams as they seek to introduce feature flags. They can become a crutch, leading teams to push untested code into production simply because they can toggle it off—a scenario he calls the "pit of failure".

And Elise dives into a great story recounting her consulting days where a company spent a fortune on a branding agency that demanded conflicting "primary colors" for a mainframe application used 8 hours a day. Her low-tech solution to prove them wrong? Listen and find out, this episode is all about bringing UX to Engineering.

Share Episode ⸺ Episode Sponsor: Incident.io - https://dev0ps.fyi/incidentio

Warren is joined by Olga Kundzich, Co-founder and CTO of Moderne, to discuss the reality of technical debt in modern software engineering. Olga reveals a shocking statistic: without maintenance, cloud-native applications often cease to function within just six months. And from our experience, that's actually optimistic. The rapid decay isn't always due to bad code choices, but rather the shifting sands of third-party dependencies, which make up 80 to 90% of cloud-native environments.

We review the limitations of traditional Abstract Syntax Trees (ASTs) and the introduction of OpenRewrite's Lossless Semantic Trees (LSTs). Unlike standard tools, LSTs preserve formatting and style, allowing for automated, horizontal scaling of code maintenance across millions of lines of code. This fits perfectly in to the toolchain that is the LLMs and open source ecosystem. Olga explains how this technology enables enterprises to migrate frameworks—like moving from Spring Boot 1 to 2 — without dedicating entire years to manual updates.

Finally, they explore the intersection of AI and code maintenance, noting that while LLMs are great at generating code, they often struggle with refactoring and optimizing existing codebases. We highlight that agents are not yet fully autonomous and will always require "right-sized" data to function effectively. Will is absent for this episode, leaving Warren to navigate the complexities of mass-scale code remediation solo.

Share Episode         
         
In a special solo flight, Warren welcomes Meagan Cojocar, General Manager at Pulumi and a self-proclaimed graduate of “PM school” at AWS. They dive into what it's like to own an entire product line and why giving up that startup hustle for the big leagues sometimes means you miss the direct signal from your users. The conversation goes deep on the paradox of open-source where direct feedback is gold, but dealing with license-shifting competitors can make you wary. From the notorious HashiCorp kerfuffle to the rise of OpenTofu, they explore how Pulumi maintains its commitment to the community amidst a wave of customer distrust.

Meagan highlights the invaluable feedback loop provided by the community, allowing for direct interaction between users and the engineering team. This contrasts with the "telephone game" that can happen in proprietary product development. The conversation also addresses the recent industry shift and then immediate back-peddling from open-source licenses, discussing the subsequent customer distrust and how Pulumi maintains its commitment to the open-source model.

And finally, the duo tackles the elephant in the cloud: LLMs, and extends on the earlier MCP episode. They debate the great code quality vs. speed trade-off, the risk of a "botched" infrastructure deployment, and whether these models can solve anything more than a glorified statistical guessing game. It's a candid look at the future of DevOps, where the real chaos isn't the code, but the tools that write it. The conversation concludes with a philosophical debate on the fundamental capabilities of LLMs, questioning whether they can truly solve "hard problems" or are merely powerful statistical next-word predictors.

Share Episode

Microsoft's John Papa, Partner General Manager of Developer Relations for all things dev and code joins the show to talk developer relations...from his Mac. He reveals his small part in the birth of VS Code (back when its codename was Ticino) after he spent a year trying a new editor every month.

The conversation dives deep into "Agentic AI," where John predicts developers will soon become "managers of agents". But is it all hype? John and Warren debate the risks of too much automation (no, AI should not auto-merge your PRs) and the terrifying story of a SaaS built with "zero handwritten code" that immediately got hacked because the founder was "not technical".

The episode highlights John's jaw-dropping war stories from Disney, including a mission-critical hotel lock system (for 5,000+ rooms) that was running on a single MS Access database under a desk. It's a perfect, cringeworthy lesson in why "we don't have time to test" is the most expensive phrase in tech, and why we need a human in the loop. John leaves us with the one question we must ask of all new AI features: "Who asked for that?"

Share Episode ⸺ Episode Sponsor: Attribute - https://dev0ps.fyi/attribute

In the wake of one of the worst AWS incidents in history, we're joined by Lawrence Jones, Founding Engineer at Incident.io. The conversation focuses on the challenges of managing incidents in highly regulated environments like FinTech, where the penalties for downtime are harsh and require a high level of rigor and discipline in the response process. Lawrence details the company's evolution, from running a monolithic Go binary on Heroku to moving to a more secure, robust setup in GCP, prioritizing the use of native security primitives like GCP Secret Manager and Kubernetes to meet the obligations of their growing customer base.

We spotlight exactly how a system can crawl GitHub pull requests, Slack channels, telemetry data, and past incident post-mortems to dynamically generate an ephemeral runbook for the current incident.Also discussed are the technical challenges of using RAG (Retrieval-Augmented Generation), noting that they rely heavily on pre-processing data with tags and a service catalog rather than relying solely on less consistent vector embeddings to ensure fast, accurate search results during a crisis.

Finally, Lawrence stresses that frontier models are no longer the limiting factor in building these complex systems; rather, success hinges on building structured, modular systems, and doing the hard work of defining objective metrics for improvement.

Share Episode ⸺ Episode Sponsor: Attribute - https://dev0ps.fyi/attribute

We're joined by 20 year industry veteran and DevOps advocate, Adam Korga, celebrating the release of his book IT Dictionary. In this episode we quickly get down to the inspiration behind postmortems as we review some cornerstone cases both in software and in general technology.

Adam shares how he started in the industry, long before DevOps was a coined term, focused on making systems safer and avoiding mistakes like accidentally dropping a production database. we review the infamous incidents of accidental database deletion, by LLMs and human's alike.

And of course we touch on the quintessential postmortems in civil engineering, flight, and survivorship bias from World War II through analyzing bullet holes on returning planes.

Share Episode ⸺ Episode Sponsor: Attribute - https://dev0ps.fyi/attribute

Jenna Pederson, Staff Developer Relations at Pinecone, joins us to close the loop on Vector Databases. Demystifies how they power semantic search, their role in RAG, and also unexpected applications.

Jenna takes us beyond the buzzword bingo, explaining how vector databases are the secret sauce behind semantic search. Sharing just how "red shirt" gets converted into a query that returns things semantically similar. It's all about turning your data into high-dimensional numerical meaning, which, as Jenna clarifies, is powered by some seriously clever math to find those "closest neighbors."

The conversation inevitably veers into Retrieval-Augmented Generation (RAG). Jenna reveals how databases are the unsung heroes giving LLMs real brains (and up-to-date info) when they're prone to hallucinating or just don't know your company's secrets. They complete the connection from proprietary and generalist foundational models to business relevant answers.

Share Episode

This episode we are joined by Andrew Moreland, co-founder of Chalk. Andrew explains how their company's core business model is to deploy their software directly into their customers' cloud environments. This decision was driven by the need to handle highly sensitive data, like PII and financial records, that customers don't want to hand over to a third-party startup.

The conversation delves into the surprising and complex challenges of this approach, which include managing granular IAM permissions and dealing with hidden global policies that can block their application. Andrew and Warren also discuss the real-world network congestion issues that affect cross-cloud traffic, a problem they've encountered multiple times. Andrew shares Chalk's mature philosophy on software releases, where they prioritize backwards compatibility to prevent customer churn, which is a key learning from a competitor.

Finally, the episode explores the advanced technical solutions Chalk has built, such as their unique approach to "bitemporal modeling" to prevent training bias in machine learning datasets. As well as, the decision to move from Python to C++ and Rust for performance, using a symbolic interpreter to execute customer code written in Python without a Python runtime. The episode concludes with picks, including a surprisingly popular hobby and a unique take on high-quality chocolate.

Share Episode

We welcome guest Ang Li and dive into the immense challenge of observability at scale, where some customers are generating petabytes of data per day. Ang explains that instead of building a database from scratch—a decision he says went "against all the instincts" of a founding engineer—Observe chose to build its platform on top of Snowflake, leveraging its separation of compute and storage on EC2 and S3.

The discussion delves into the technical stack and architectural decisions, including the use of Kafka to absorb large bursts of incoming customer data and smooth it out for Snowflake's batch-based engine. Ang notes this choice was also strategic for avoiding tight coupling with a single cloud provider like AWS Kinesis, which would hinder future multi-cloud deployments on GCP or Azure. The discussion also covers their unique pricing model, which avoids surprising customers with high bills by providing a lower cost for data ingestion and then using a usage-based model for queries. This is contrasted with Warren's experience with his company's user-based pricing, which can lead to negative customer experiences when limits are exceeded.

The episode also explores Observe's "love-hate relationship" with Snowflake, as Observe's usage accounts for over 2% of Snowflake's compute, which has helped them discover a lot of bugs but also caused sleepless nights for Snowflake's on-call engineers. Ang discusses hedging their bets for the future by leveraging open data formats like Iceberg, which can be stored directly in customer S3 buckets to enable true data ownership and portability. The episode concludes with a deep dive into the security challenges of providing multi-account access to customer data using IAM trust policies, and a look at the personal picks from the hosts.

In this episode of Adventures in DevOps, we dive into the world of FinOps, a concept that aims to apply the DevOps mindset to financial accountability. Yasmin Rajabi, Chief Strategy Officer at CloudBolt, joins us to demystify, as we acknowledge the critical challenge of bringing together financial accountability and engineering teams who often are not paying attention to the business.

The discussion further explores the practicalities of FinOps in the context of cloud spending and Kubernetes. Yasmin highlights that a significant amount of waste in organizations comes from simply not turning off unused systems and not right-sizing resources. She explains how tools like Horizontal Pod Autoscaler (HPA) and Vertical Pod Autoscaler (VPA) can help, but also points out the complexities of optimizing across horizontal and vertical scaling behaviors. The conversation touches on "shame back reporting" as a way to provide visibility into costs for engineering teams, although the conversation emphasizes that providing tooling and insights is more effective than simply telling developers to change configurations.

The episode also delves into the evolving mindset around cloud costs, especially with the rise of AI and machine learning workloads. While historically engineering salaries eclipsed cloud spending, the increasing hardware requirements for ML and data workloads are making cost optimization a more pressing concern. Spending-conscious teams are increasingly asking about GPU optimization, even if AI/ML teams are still largely focused on limitless spending to drive unjustified "innovation". The conclude by discussing the challenges of on-premise versus cloud deployments and the importance of addressing "day two problems" regardless of the infrastructure choice.

Picks

Get ready for a lively debate on this episode of Adventures in DevOps. We're joined by Brian Pontarelli, founder of FusionAuth and CleanSpeak. Warren and Brian face off by diving into the controversial topic of multitenant versus single-tenant architecture. Expert co-host Aimee Knight joins to moderate the discussion. Ever wondered how someone becomes an "auth expert"? Warren spills the beans on his journey, explaining it's less about a direct path and more about figuring out what it means for yourself. Brian chimes in with his own "random chance" story, revealing how they fell into it after their forum-based product didn't pan out.

Aimee confesses her "alarm bells" start ringing whenever multitenant architecture is mentioned, jokingly demanding "details" and admitting her preference for more separation when it comes to reliability. Brian makes a compelling case for his company's chosen path, explaining how their high-performance, downloadable single-tenant profanity filter, CleanSpeak, handles billions of chat messages a month with extreme low latency. This architectural choice became a competitive advantage, attracting companies that couldn't use cloud-based multitenant competitors due to their need to run solutions in their own data centers.

We critique cloud providers' tendency to push users towards their most profitable services, citing AWS Cognito as an example of a cost-effective solution for small-scale use that becomes cost-prohibitive with scaling and feature enablement. The challenges of integrating with Cognito, including its reliance on numerous other AWS services and the need for custom Lambda functions for configuration, are also a point of contention. The conversation extends to the frustrations of managing upgrades and breaking changes in both multitenant and single-tenant systems and the inherent difficulties of ensuring compatibility across different software versions and integrations. The episode concludes with a humorous take on the current state and perceived limitations of AI in software development, particularly concerning security.

Picks

Episode Sponsor: PagerDuty - Checkout the features in their official feature release: https://fnf.dev/4dYQ7gL

This episode dives into a fundamental question facing the DevOps world: Did Kubernetes truly win the infrastructure race because it was the best technology, or were there other, perhaps less obvious, factors at play? Omer Hamerman joins Will and Warren to take a hard look at it. Despite the rise of serverless solutions promising to abstract away infrastructure management, Omer shares that Kubernetes has seen a surge in adoption, with potentially 70-75% of corporations now using or migrating to it. We explore the theory that human nature's preference for incremental "step changes" (Kaizen) over disruptive "giant leaps" (Kaikaku) might explain why a solution perceived by some as "worse" or more complex has gained such widespread traction.

The discussion unpacks the undeniable strengths of Kubernetes, including its "thriving community", its remarkable extensibility through APIs, and how it inadvertently created "job security" for engineers who "nerd out" on its intricacies. We also challenge the narrative by examining why serverless options like AWS Fargate could often be a more efficient and less burdensome choice for many organizations, especially those not requiring deep control or specialized hardware like GPUs. The conversation highlights that the perceived "need" for Kubernetes' emerges often from something other than technical superiority.

Finally, we consider the disruptive influence of AI and "vibe coding" on this landscape, how could we not? As LLMs are adopted to "accelerate development", they tend to favor serverless deployment models, implicitly suggesting that for rapid product creation, Kubernetes might not be the optimal fit. This shift raises crucial questions about the trade-offs between development speed and code quality, the evolving role of software engineers towards code review, and the long-term maintainability of AI-generated code. We close by pondering the broader societal and environmental implications of these technological shifts, including AI's massive energy consumption and the ongoing debate about centralizing versus decentralizing infrastructure for efficiency.

Links:​

In this episode, Aimee Knight, an expert in Site Reliability Engineering (SRE) whose experience hails from Paramount and NPM, joins the podcast to discuss her journey into SRE, the challenges she faced, and the strategies she employed to succeed. Aimee shares her transition from a non-traditional background in JavaScript development to SRE, highlighting the importance of understanding both the programming and infrastructure sides of engineering. She also delves into the complexities of SRE at different scales, the role of playbooks in incident management, and the balance between speed and quality in software development.

Aimee discusses the impact of AI and machine learning on SRE, emphasizing the need for responsible use of these tools. She touches on the importance of understanding business needs and how it affects decision-making in SRE roles. The conversation also covers the trade-offs in system design, the challenges of scaling applications, and the importance of resilience in distributed systems. Aimee provides valuable insights into the pros and cons of a career in SRE, including the importance of self-care and the satisfaction of mentoring others.

The episode concludes with us discussing some of the hard problems such as the on-call burden for large teams, and the technical expertise an org needs to maintain higher complexity systems. Is the average tenure in tech decreasing, we discuss it and do a deep dive on the consequences in the SRE world.

Picks​

In this episode, we delve into the concept of MCP (Machine Control Protocol) servers and their role in enabling agent interactions. Gil Feig, the co-founder and CTO of Merge, shares insights on how MCP servers facilitate efficient and secure integration between various services and APIs.

The discussion covers the benefits and challenges of using MCP servers, including their stateful nature, security considerations, and the importance of understanding real-world use cases. Gil emphasizes the need for thorough testing and evaluation to ensure that MCP servers effectively meet user needs.

Additionally, we explore the implications of MCP servers on data security, scaling, and the evolving landscape of API interactions. Warren chimes in with experiences integrating AI with Auth. Will stuns us with some nuclear fission history. And finally, we also touch on the balance between short-term innovation and long-term stability in technology, reflecting on how different generations approach problem-solving and knowledge sharing.

Picks​:

Warren talks with Nathan Goulding, SVP of Engineering at Vultr, about what it actually takes to run a high-performance cloud platform. They cover everything from global game server latency and hybrid models to bare metal provisioning and the power/cooling constraints that come with modern GPU clusters.

The discussion gets into real-world deployment challenges like scaling across 32 data centers, edge use cases that actually matter, and how to design systems for location-sensitive customers—whether that's due to regulation or performance. Additionally, there's talk about where the hyperscalers have overcomplicated pricing and where simplicity in a flatter pricing model and optimized defaults are better for everyone.

There's a section on nuclear energy (yes, really), including SMRs, power procurement, and what it means to keep scaling compute with limited resources. If you're wondering whether your app actually needs high-performance compute or just better visibility into your costs, this is the episode.

Picks​

Inna Tokarev Sela, CEO and founder of Illumex, joins the crew to break down what it really means to make your data “AI-ready.” This isn't just about clean tables—it's about semantic fabric, business ontologies, and grounding agents in your company's context to prevent the dreaded LLM hallucination. We dive into how modern enterprises just cannot build a single source of truth, not matter how hard they try. All the while knowing that it's required to build effected agents utilizing the available knowledge graphs and.

The conversation unpacks democratizing data access and avoiding analytics anarchy. Inna explains how automation and graph modeling are used to extract semantic meaning from disconnected data stores, and how to resolve conflicting definitions. And yes, Warren finally coughs up what's so wrong with most dashboards.

Lastly, we quickly get to the core philosophical questions of agentic systems and AGI, including why intuition is the real differentiator between humans and machines. Plus: storage cost regrets, spiritual journeys disguised as inference pipelines, and a very healthy fear of subscription-based sleep wearables.

Picks​

Sylvain Kalache, Head of Developer Relations at Rootly joins us to explore the new frontier of incident response powered by large language models. We dive into the evolution of DevRel and how we meet the new challenges impacting our systems.

We explore Sylvain's origin story in self-healing systems, dating back to his SlideShare and LinkedIn days. From ingesting logs via Fluentd to building early ML-driven RCA tools, he shares a vision of self-healing infrastructure that targets root causes rather than just restarting boxes. Plus, we trace the historical arc of deterministic and non-deterministic tools.

The conversation shifts toward real-world applications, where we're combining logs, metrics, transcripts, and postmortems to give SREs superpowers. We get tactical on integrating LLMs, why fine-tuning isn't always worth it, and how the Model Context Protocol (MCP) could be the USB of AI ops, but how it is still insecure. We wrap by facing the harsh reality of "incident vibing" in a world increasingly built by prompts, not people—and how to prepare for it.Picks​

This week, Paul Marston from Ankr joins the crew to unpack the madness that is modern blockchain infrastructure. From his wild career transition out of financial services into 24/7 node ops for Web3, Paul shares the brutal truth about uptime expectations, decentralization challenges, and why hard forks are more like enterprise schema upgrades with a community twist. If you've ever wondered why managing a blockchain node is like owning a temperamental pet server, this one's for you.

The team goes deep on the nitty-gritty of load balancing across dozens of chains, explaining why routing traffic to the “wrong” archive node could ruin your day—and how Ankr's custom load balancer is basically magic for JSON-RPC calls. Warren tosses out wild scenarios about encrypted data smuggling via blockchain, while Will confesses his angry typing habit (yes, it's back). The discussion gets even more fun with debates on innovation vs. rigor, Web2's forgotten best practices, and why testing in prod might not be such a dirty word after all.

But don't think it's all crypto and code. Paul shares battle-won wisdom from running over 100 chains across bare metal, giving us a peek at the operational sophistication and automation involved. From Terraform templates to Docker configs, he walks through the process of onboarding new chains and tuning for performance. The episode also touches on emerging risks like data exfiltration via public blockchains, and why AI (used wisely) might just be the sidekick DevOps always needed.

And of course memes, we talk a bit about this one: Tree Swing Product Development

Picks​

In this episode, Will and Warren welcome Adriana Villela — CNCF ambassador, Dynatrace advocate, and host of the Geeking Out podcast — for a wide-ranging conversation on observability in CI/CD pipelines. Adriana shares her journey from “On Call Me Maybe” to her own podcast, her work with OpenTelemetry, and why observability isn't just for SREs anymore.

The crew digs into how telemetry should be integrated across the software development lifecycle — from development to QA to production — and what that really looks like in modern teams. Adriana drops knowledge on CI/CD failures, distributed traces, and even how to bring observability to other parts of the business like recruiting and onboarding. She also explains how she got involved in the OpenTelemetry end-user SIG and what's next for the observability movement.

Things get persona as we trade war stories about SVN, terrible version control systems, reusable grocery bags, and the ethics of AI log parsers. Adriana closes with a powerful take: observability is a team sport, and the better we play it, the more effective — and environmentally conscious — our systems can become.Picks​

In this episode, I (flying solo today!) sat down with Ganesh Datta, the CTO and co-founder of Cortex, to explore what it really means to drive engineering excellence at scale. And spoiler: it's not just about better dashboards or fancy developer tools—it's about treating software development like the competitive advantage it is.

We went deep into the why behind internal developer portals (IDPs) and how they're transforming platform engineering, developer experience, and organizational maturity. Ganesh shares how Cortex came to life—from being paged at 2am for a mystery Game of Thrones-named microservice (yep, we've all been there), to realizing that every other business function had a system of record—except engineering.

Key Takeaways:

Is AI making us more productive? And where's the value? That's the big debate in this episode as we sit down with Zach Lloyd, founder and CEO of Warp. Warp isn't just another terminal—it's an AI-powered reimagination of the command line. From replacing traditional terminal commands with English instructions to integrating AI-driven automation, Warp is pushing the boundaries of how we work. And finally we find out what Warren is using as a keyboard.

In this episode, we discuss the evolution of AI in DevOps, whether LLMs are truly intelligent or just glorified word predictors, and the existential question: will developers eventually be replaced? Warren remains skeptical, questioning the real ROI of AI tools, while Jillian embraces the potential for more accessibility and efficiency—especially if it means she doesn't have to type. Will and Zach counter with insights on the actual adoption of AI among developers and where the technology is heading.

As always, we wrap up with our Picks of the Episode, including an engaging sci-fi book, a thought-provoking AI philosophy experiment, a self-promotion plug, an academic research paper, and a medieval travel guide. Tune in for an episode full of sharp opinions, tech insights, and the ongoing war between efficiency and skepticism.

Picks

In this episode, our hosts Will Button, Warren Parad, and Jillian are joined by guest Matt Gowie from Masterpoint. Together, they delve into the complex world of infrastructure as code, discussing best practices, challenges, and the human side of consulting in the DevOps space. Matt shares his journey from software development to running his own consulting agency focused on Terraform and OpenTofu. The conversation covers everything from the nuances of using Terraform workspaces, the implications of large-scale infrastructure management, to the critical soft skills needed for a successful consulting career. Whether you're a seasoned professional or just venturing into DevOps, this episode is packed with valuable insights and practical advice for navigating the ever-evolving landscape of technology.

🎯 Picks:

Join host Warren Parad, co-hosts Jillian and Will Button as they delve into a compelling conversation on the pervasive influence of AI across industries. Special guest Alex Kearns from Wiz shares his expertise on the real-world applications of AI, navigating through its rapid evolution and discussing both the opportunities and challenges it presents. From the impact of generative AI on business processes to intriguing ethical considerations, this episode provides valuable insights for professionals in the DevOps field. Tune in as the panel explores the dynamic relationship between technology, responsibility, and innovation, offering listeners a thought-provoking exploration of AI's role in shaping the future.

🎯 Picks:

Ready to show off your coding skills to the world? Not so fast. In this episode, Will and Jillian discuss why developers need to simplify their product with the end goal in mind—the customer. They share some awesome examples of how to do this, how you can win Future You's approval, and the steps to create a smooth user experience.
“I think it's a hard mental shift to say that my area of expertise shouldn't be visible in the product. But, you need to understand the end goal. My goal is to automate myself out of a job, then move on.”

In today's episode, Will and Jillian dive deep into the evolving landscape of Salesforce DevOps, joined by the experienced Vernon Keenan. This episode covers a range of critical topics including recent changes in Salesforce's AI product offerings and the complexities surrounding their pricing. Vernon takes us on his personal journey from telecom to pioneering a tax engine on Salesforce, leading to his current focus on Go and Kubernetes-driven DevOps solutions.
They unpack the challenges developers face with Salesforce's SFDX and metadata API, explore how companies like Capado, Flowsome, and Gearset are tackling these issues, and discuss innovative approaches from firms like Elements Cloud. The conversation also ventures into the realm of cognitive DevOps, AI-driven virtual employees, and the economic and societal impacts of these technologies. Additionally, they touch upon the shifting responsibilities in Salesforce management and the rising importance of CIOs in this space.
Whether you're grappling with Salesforce's limitations or seeking insights on how AI is transforming the DevOps field, this episode is packed with expert advice, industry insights, and forward-looking perspectives. Stay tuned, as they also address public policy concerns, the potential for job displacement, and the future of SaaS DevOps. Listen in and join as they navigate the future of technology and workforce transformation!


Socials

Eyar Zilberman joins the adventure to discuss Kubernetes schema validation tools.The panel jumps in and discusses the power of and the pros and cons of the different kinds of schema validations.

Links

Shimon Tolts is the CEO datree.io. Shimon talks the panel through an outage he experienced while working for a previous employer. He breaks down the situation and the explains the types of misconfiguration that caused his outage and how these things can cause problems in other applications as well.

Links

We're not calling you a dummy, but you might be one if you don't listen to this episode. This time around, the gang discusses the do's and don'ts of choosing CI/CD tools, including how to safety migrate between them, why super-specialized tools are getting extremely popular this year, and the ONE component that makes or breaks a tool.
In This Episode
1) The TWO questions you need ask BEFORE you choose your tools (and why there's no “one size fits all”)
2) How to safely migrate from one tool to another
3) Why super-specialized CI tools are getting more popular in 2022
4) Want to know what makes a CI tool worthwhile? Ask if it has THIS single component and you're off to a great start


Picks

In this episode, they explore the realms of DevOps management and team dynamics. Will is joined by Warren and Jillian to delve into the challenges and strategies involved in transitioning from a ticket queue system to using epics for task management. They discuss how this shift prioritizes objectives, enhances team focus across global time zones, and improves communication with product teams.
The conversation also touches on documenting processes, managing support work, and the importance of adaptability and transparency within organizations. From humorous anecdotes about technical issues to practical advice on handling resistance from higher-ups, the episode is packed with real-world examples and expert insights. Tune in to learn how to better align stakeholder priorities, balance planned and unplanned work, and foster a more efficient and cohesive DevOps team.

Socials

Jillian returns to the podcast after a significant move from Doha, Qatar to a quaint town in New Hampshire. She shares her experiences of adjusting back to life in the U.S., both personally and professionally. The discussion delves into the logistics and emotional aspects of relocating internationally—what it's like leaving behind furniture deemed disposable overseas, starting fresh with new purchases, and dealing with unexpected challenges along the way.

Additionally, they talk about the Dora metrics and the emphasis on why measuring these metrics is crucial for understanding DevOps efficiency within organizations. They also dive into the importance of setting hypotheses when attempting organizational changes. And discuss the challenges faced by companies who fail at measuring progress post-experimentation.



Socials

In this episode, Will, Warren and Jillian dive into the complexities of secrets management and developer productivity with our esteemed guest, Brian Vallelunga from Doppler. Join them as Brian shares his journey from facing security challenges at Uber to founding Doppler, an innovative solution aimed at transforming how developers handle secrets.They delve into the critical importance of secrets management, Doppler's unique approach to making security practices not only essential but enjoyable for developers, and the future of authentication with identity-based methods. Brian also offers valuable advice on integrating security from day one and discusses the hurdles and necessities of secure secret management.

Tune in as they explore the evolving landscape of security standards, the impact of SOC 2 compliance, and the balance between immediate security fixes and long-term stability using tools like Terraform. They also touch on personal experiences with data security, practical tips for safeguarding information, and a touch of light-heartedness with fun picks from our hosts.


Don't miss this engaging conversation filled with practical insights, expert advice, and a visionary look at the future of secure development practices.

Socials

Today, we have a dynamic discussion lined up with Will and special guest, Ben Johnson, the CEO of Particle 41. In this episode, they delve deep into the evolving landscape of the tech industry, from incentivizing certifications to the current economic conditions affecting startups.
Ben shares his insights on the importance of experience and specialized knowledge, advocating for a system that prioritizes certifications as objective measures of learning. Will critiques the education system and proposes an apprenticeship model as a solution to existing gaps.
The conversation also navigates the complexities of the modern job market, the impact of layoffs, and the startup ecosystem's challenges due to economic constraints. We explore innovative paths like personal entrepreneurship, brand building, and creating niche software solutions.
Ben and Will also debate the merits of generalism versus specialization, the use of AI in development, and the strategic value of certifications. Plus, we'll touch on the transformative potential


Socials

Will and Warren dive deep into the world of career longevity and adaptability in the fast-evolving tech industry. They explore the often-overlooked importance of staying with a project long enough to understand and resolve complex issues, and how job dissatisfaction can be a tool for negotiation rather than a cue to immediately move on.
They touch on early career experiences and the shift towards specialization, echoing advice from past guest Kelsey Hightower. Warren also shares his intriguing perspective on the value of early career terminations, the necessity of soft skills, and the challenges of expanding teams. The conversation will unfold to reveal a balanced view on the evolution from hands-on engineering to management roles, the continual learning required to stay relevant, and the often humorous realities behind career transitions.
Listen in as they discuss scaling career paths, the nuances of job switching, and the criticality of balancing technical and business acumen. They also delve into the personal facets of tech careers, from dealing with burnout to the idea of retirement, all while sharing our thoughts on professional books and the lessons they impart. Whether you're a tech enthusiast, a seasoned developer, or someone navigating the complexities of the tech industry, this episode promises a wealth of knowledge and a dose of humor to keep you engaged.


Socials

In today's episode, Warren and Will dive into the difficulties of coordinating between marketing and engineering teams, particularly around handling increased traffic and sales during the holiday season. The discussion covers the importance of auditing code and looking for potential issues or technical debt at the end of the year. The hosts also explore strategies for pitching and justifying technical projects or rewrites to management, emphasizing the need to frame them in terms of business impact. They conclude by reflecting on the value of stepping back from day-to-day tasks at the end of the year to gain a broader organizational perspective.

Socials

Will and Warren dive deep into the world of Mastermind groups and their impact on career success within the DevOps landscape. They explore the origins of mastermind groups from Napoleon Hill's "Think and Grow Rich" and debate why a staggering 99% of them might be ineffective, according to Will. Warren shares his own experiences and expresses his curiosity about what truly makes such groups effective.
They also draw intriguing parallels between accountability in mastermind groups and emergency preparedness in aviation, emphasizing the importance of ingrained habits and continuous skill development. From military training insights to the challenges of creating genuine, trust-filled mastermind groups, we'll cover it all.
Additionally, they touch on the broader aspects of professional growth—public speaking, networking, mentorship, and the evolving dynamics of teamwork. Plus, don't miss on practical tips on forming mastermind groups and fostering meaningful professional relationships. Tune in for an episode packed with valuable insights, compelling analogies, and shared experiences that can help you navigate and succeed in your career!


Picks

In today's episode, Will Button and Warren are joined by special guest Eyal Solomon, co-founder of Lunar.dev. This episode dives deep into pressing DevOps topics like the complexities of Mobile Device Management (MDM) solutions and the intricacies of the API economy. They explore the challenges of API management, the importance of visibility and monitoring in API consumption, and strategies to prevent issues like rate limiting and billing surprises.


Eyal shares his journey from infrastructure optimization to specializing in API management, highlighting how Lunar dot Dev helps companies handle API quotas, security, and performance through their innovative platform. We also delve into integrating AI within APIs, managing API costs, and the rising trend of AI agents.


Join them as they dissect the importance of combining storytelling with educational insights in various content forms, from books to YouTube channels. Learn how running can be a form of meditation and problem-solving, and get top book recommendations from our hosts. Whether you're dealing with API challenges or looking to optimize your DevOps practices, this episode is packed with valuable insights straight from the experts. Don't miss out!


Links

Today, Will and Warren dive into the intersection of DevOps and AI with our special guest, Görkem Ercan, CTO of Jozu and a seasoned expert in developer tools and DevOps. In this episode, they explore the practical applications and challenges of integrating Machine Learning into DevOps workflows, utilizing real-world examples like global shirt distribution and the US Army's sizing issues. They also discuss the critical role of psychological safety in successful teams, the surprising origins of the webcam, and the remarkable engineering feats of the Voyager spacecraft.
Moreover, they unpack the intricacies of AI model management, confronting issues like non-deterministic outcomes, data drift, and the need for a unified control plane to handle complex, dynamic environments. They touch on the rise of internal AI management, the innovative use of sentiment analysis in customer support, and the surprising interest from consulting firms in AI-driven solutions.

Socials

In today's episode, Warren, Will, and guest Markus Thurner, the director of technology at Vista dive deep into the world of DevOps with an exciting lineup of discussions about engineering excellence, the fast pace of technological innovation, and the ever-present need for balance between training and production.


Together, they explore how practice makes perfect in software development, drawing from analogies like the Brazilian soccer player practicing with brain diodes. They talk about the costs and benefits of training engineers, managing cloud expenses, and the evolving landscape of on-premise versus cloud data centers.


They dig into the importance of challenging the status quo, the complexities of operational versus capital expenditures, and best practices for writing scalable code. Whether you're curious about the latest in Kubernetes and AWS ECS, or just looking for some practical advice on continual learning and improvement, this episode has something for everyone.


Plus, stay tuned as they share personal recommendations, from the best gaming tablets for those long flights to must-listen podcasts and even a Metallica song that ties back to a gripping World War I tale.


This packed episode concludes with a thoughtful discussion on engineering excellence, and how teams can find balance, define their metrics, and drive both innovation and quality in their projects.


Socials

In today's episode, Warren, Will, and special guest Falit Jain dive deep into the intricate world of incident management and response, drawing from rich experiences at tech giants like Amazon and Disney. They explore real-life scenarios, including Amazon's complex debugging challenges with over 150 engineers maintaining their detail page, and the high stakes of live streaming events at Disney.\


Join them as they discuss the crucial aspects of effective incident response, from the importance of familiarity with systems and the role of on-call processes to the value of communication and meticulous postmortems. They also deep-dive into cultural influences from leadership, the balance between new feature launches and system stability, and the significance of metrics like mean time to resolution and error budgets.



Socials

In today's episode, they dive deep into the world of AI and prompt engineering with our dynamic panel of experts, featuring Anthony Spiteri. He shares their fascinating journey over the past 18 months, manipulating language models like ChatGPT to achieve remarkable results. They explore the intriguing development of a location-based app for finding the European delicacy, Black Pudding, and dive into the complexities of using AI for mentorship, accountability, and even fitness.
Join them as they uncover the technical intricacies of building apps with AI, the philosophical questions surrounding AI's future, and the growing importance of prompt engineering. They also touch on critical issues of data security, the ethical implications of AI, and the ever-evolving landscape of DevOps. Whether you're a seasoned developer or just starting, this episode is packed with insights and stories that you won't want to miss. So, grab your headphones and get ready to explore the cutting edge of DevOps and AI!


Socials

In this episode, they dive deep into the intricate world of DevOps and the nuances that drive its continuous evolution. This episode brings you into a thought-provoking conversation featuring Michael Cade, Global Field CTO at Veeam Software. Join them as they explore a wide array of topics, from the controversial practice of intentional data leaks as an advertising strategy to the intricate details of Michael's groundbreaking "90 days of DevOps" project. This initiative, which began in 2022, has grown to feature 91 sessions and contributions from a spectrum of subject matter experts, aiming to enrich our understanding of varied DevOps topics. Michael brings fascinating insights into cloud-native data management and the challenges of integrating databases with Kubernetes.
They delve into the critical aspects of business continuity, data backups, and the shared responsibility model for platforms like GitHub while emphasizing the importance of security measures such as multi-factor authentication. The episode also covers the evolution of programming languages in DevOps, the significance of physical and digital note-taking for task management, and the personal balance between professional responsibilities and physical activity.
The discussion extends to the mentorship challenge within the DevOps community, the importance of creating and sharing valuable content, and the role of storytelling in simplifying complex technical concepts. Whether you're interested in hearing about the use of various cloud platforms, the behind-the-scenes of Michael's career at Veeam, or tips for achieving work-life harmony, this episode has something for everyone. So, plug in your AirPods Pro 2, lace up your running shoes, and get ready to be inspired by another exciting journey into the world of DevOps.


Socials

In this episode, they dive deep into the evolving landscape of cloud infrastructure and developer experience. Join our host, Warren and Will and Eli Ben Israel—former AWS and Microsoft engineer and co-founder of Wing—as they explore the challenges and innovations in DevOps.
In this episode, Eli shares pivotal insights from his journey at Amazon, revealing that despite advanced tools like CDK, building on the cloud remains fraught with difficulties. They dissect the cognitive barriers developers face in understanding cloud mechanics and the need for greater access and autonomy in cloud development.
Discover the transformative potential of the Wing project, designed to abstract cloud complexities and enhance developer productivity by providing a seamless, cloud-agnostic platform. They also touch upon the importance of good API design, the intriguing philosophy behind Kubernetes, and how projects like Wing promise to simplify and scale cloud development.
As they navigate through infrastructure challenges, community building in open-source projects, and the shift from Slack to Discord, this episode promises a wealth of knowledge for both seasoned DevOps professionals and curious newcomers.
Stay tuned for technical insights, book recommendations, and a journey through the future of cloud development on **Top End Devs**!


Socials

Warren delves into this episode featuring an engaging conversation with David Stenglein, a seasoned industry expert with over 20 years of experience. In this episode, they shed light on the pitfalls of hiring product managers amidst hype cycles, urging a shift towards a product mindset that prioritizes user pain points and tangible value. They critique traditional metrics like DORA and ENPS, discussing their limitations and the need for better communication and alignment on business-level metrics.
They explore the complexities of platform adoption, from Kubernetes to Docker, and the challenges of managing modern technologies. David emphasizes the importance of striking a balance between innovation and practicality, while Warren delves into the cognitive load and the necessity of higher-level abstractions. With discussions ranging from the evolution of software platforms, and the transformative potential of WebAssembly, to the nuances of user-driven platform development, this episode is packed with valuable insights for every developer navigating the fast-evolving tech landscape. So, tune in as they dissect the future of platform development and the delicate dance between innovation and efficiency.

Socials

In this episode, Warren and Will delve deep into the intricate world of DevOps and SaaS integrations, featuring insights from special guest Michael Zuercher from Prismatic. Throughout the discussion, they talk about the challenges legacy companies face in updating their massive infrastructure and how Prismatic is revolutionizing SaaS integrations with its innovative approaches. They explore the significance of flexible and reliable integration platforms, learn about the evolution of farming technology, and take a closer look at the long tail of customer needs in the tech industry.
Moreover, the experts take on the complexities of handling large data files and API integrations, including the persistent issues of idempotency, pagination, and rate limiting. Additionally, they discuss leadership and market strategies, with book recommendations and personal anecdotes enriching our tech talk. Tune in as they uncover how Prismatic is crafting tools to simplify the integration process, reduce reliance on core developers, and help businesses thrive in a rapidly evolving digital landscape. Get ready for an episode filled with technical expertise, practical advice, and a few surprises along the way!


Socials

In this episode, they delve into the intricacies of DevOps implementation with our insightful hosts and key guest, Marius Stanca. They share invaluable perspectives on the continuous learning nature of DevOps, the evolving toolkit, and the essential roadmap for organizations. Highlighting the critical need for understanding problems before adopting DevOps solutions, the conversation covers practical experiences, automation strategies, and effective resource management.
They also discuss the misuse of terms like "agile" and "DevOps" and the importance of eliminating waste through lean principles, citing "The Toyota Way." Moreover, they reflect on the challenges of starting with DevOps, noting the high-quality, minimal-effort maintainability of resources. They explore the automation of everyday tasks, leveraging tools like GitHub and GitLab, and the necessity of adapting to evolving technologies.
Marius Stanca introduces the "awesome DevOps" repository, a collaborative resource collection meticulously vetted for DevOps and SRE relevance. Navigating through topics such as team structuring, the simplification of workflows, the perpetual struggle of innovation in DevOps, and the use of GPT in generating source code, this episode is packed with expert advice and humorous insights. Tune in as we bridge the gap between theory and practical execution, providing a rich roadmap for your DevOps journey!
Socials

In this episode, the panel together with our guest, Galen Marchetti dives deep into tackling some of the most pressing challenges in the DevOps world. They unpack the hurdles of blue-green deployments, feature flags, and the necessity of parallel execution for smooth production rollouts. They explore the complexities of testing changes in production, managing containerization, and optimizing build speeds with multistage Docker builds.
Listen to engaging discussions about kurtosis—a powerful tool for creating development environments—and its impact on projects like Ethereum, as well as the broader implications for open-source contributions. From humorous anecdotes about using VIM in production to thoughtful reflections on the trauma of production errors, this episode covers it all.
Plus, get book recommendations, music picks, and tips on the latest tools from our speakers! Don't miss out on these valuable insights and entertaining banter from the frontline of DevOps.

Socials

In this episode, we have a special guest Kelsey Hightower, exploring the intersections of music, technology, and personal growth. They delve into AI advancements and their significance in DevOps. From Google Maps to large language models, they discuss AI as a tool to complement human expertise, emphasizing professional growth and innovation within the tech industry. Guest Kelsey Hightower shares his career journey, underlining the importance of starting at entry-level, continuous learning, and a growth-focused mindset.They also explore balancing innovation with stability, rewatching classic movies, and the personal joys of retirement.


Socials

Today, Will is flying solo as he sits down with Costa Tsaousis, the founder and CEO of NetData. Costa shares the story behind the development of NetData, a groundbreaking monitoring tool that provides high-fidelity, real-time, and automated monitoring without data smoothing.
As they delve into the conversation, Costa discusses the remarkable growth and engagement of NetData, emphasizing the vibrant community and the significance of open-source contributions. They also explore efficient data compression and integration with Systemd Journal, highlighting the benefits of distributed data collection.
Furthermore, they discuss the challenges of proving the value of data for commercial purposes and the goal of providing better service at a lower cost. Costa also unveils the innovative approach to monitoring and observability, showcasing the simplicity and efficiency of NetData compared to industry-standard solutions.
So, join Will and Costa as they dissect the development, capabilities, and future roadmap of NetData, offering valuable insights into the world of DevOps and infrastructure monitoring. Stay tuned to explore the journey of NetData and the revolution it brings to the industry.

Links

In this episode, Warren and Will embark on a thought-provoking journey through the world of DevOps, security, team dynamics, and career progression. They discuss the hidden implications of domain names, the importance of security certifications, and the complexities of leading a tech team, weaving in personal experiences and insights. With an emphasis on aligning technical work with overarching business goals, they explore the challenges and rewards of managing software development and infrastructure. From the nuances of SaaS provider selection to the impact of AI on small teams, this episode offers a captivating exploration of modern tech practices and their far-reaching implications.


Picks

Jose Diaz-Gonzalez is the creator is Dokku. They delve into the world of DevOps with a focus on security, open source contributions, and managing permissions in AWS. In this episode, they discuss the challenges and complexities of open-source projects, the importance of verifying the integrity of packages, and the implications of using unauthorized software. They also touch on the upcoming DevOps Days Zurich conference and share insights on evaluating platform features, addressing customer needs, and minimizing tech debt in product management.
Join them as they explore explore topics ranging from data storage services to container technologies, and the journey of maintaining open-source projects. They share their experiences, challenges, and valuable insights into the ever-evolving landscape of DevOps. Stay tuned for a deep dive into the nuances of DevOps, security considerations, and the fascinating world of cloud hosting providers.
Socials

Luca Galante is the Product and Growth at Humanitec. In today's episode, they dive deep into the world of platform engineering and DevOps, discussing the challenges, innovations, and best practices in the field.
They discuss the need for clear problem-solving in platform engineering, the importance of reference architectures, and the upcoming PlatformCon event. From the concept of a minimum viable platform approach to measuring success and the pivotal role of communication and customer feedback, this episode covers a wide range of topics essential for anyone involved in platform engineering and DevOps.


Socials

Rosalind Whitley is the Director of Product Marketing at Kentik. They dive deep into the world of technology, DevOps, and everything in between. In today's episode, they have an in-depth conversation about the complexities of marketing for technical products, particularly in the context of network observability and DevOps. They discuss the challenges of conveying emotions and authentic messaging in marketing, as well as the evolving expectations of the consumer in today's fast-paced digital landscape. They also explore the impact of technology on modern corporations, the role of AI in network monitoring, and the significance of building a supportive community within the developer space. Join them for a vibrant discussion on technical marketing, network observability, and the intersection of technology and business.

Socials

Yonatan Eldar is the Co-Founder and CTO at Apiiro. They discuss the evolution in application security strategies, the importance of using the right tools for the job, and the significance of prioritizing and contextualizing security issues for developers. They touch on various aspects of security, including the potential vulnerabilities in code, understanding attack vectors, and managing the inventory of software and services for security. Additionally, they delve into the importance of marketing and educating teams about security and the potential malicious tactics used in the aftermath of security incidents.

Links

Pete Fritchman is a Senior operations and site reliability engineer. They delve deep into the world of development, operations, and everything in between. They explore the complexities of measuring the true cost of ownership, the challenges of work patterns in infrastructure, and the nuances of internal tool reliability. They share their firsthand experiences and provide valuable insights into observability, SLOs, and internal application performance. They also take a fascinating turn into the realm of gaming, drawing parallels between game challenges and real-world work patterns. Get ready for an engaging, informative, and thought-provoking conversation that will leave you with a fresh perspective on the intricacies of the ever-evolving tech landscape.

Socials

Tyson Trautmann is the Vice President of Engineering at Fauna. They delve into the dynamic world of software development and database management. They have a candid discussion about the challenges and benefits of using specific databases for analytical workloads, the influence of automation on traditional roles like database administrators, and the evolving landscape of modern application architectures. Tyson Trautman shares his insights on topics ranging from the trend towards automation using declarative schema for continuous delivery to the database, to the innovative design of Fauna's distributed transaction engine. With a mix of humor, personal picks, and valuable industry knowledge, this episode is set to inspire and inform.

Socials

Lukas Fittl is the Founder of Pganalyze. They delve into the latest developments and challenges in the world of DevOps and technology. They discuss the evolving role of database administrators (DBAs), focusing on the challenges of optimizing database performance, specifically addressing slow queries in Postgres databases. The conversation highlights the need for visibility and understanding of database performance, as well as the development of Pganalyze, a startup aimed at improving Postgres performance. Tune in to gain insights into the changing landscape of DBAs and the complexities of database optimization in today's technology-driven world.

Socials

Andreas Grabner is the DevOps Activist at Dynatrace, DevRel for CNCF Keptn, CNCF Ambassador, and PurePerformance Podcast host. They dive into the world of DevOps, platform engineering, and the latest developments in technology. In this episode, they explore the impact of AI in DevOps, the significance of observability tools, and the potential security risks associated with AI-generated code. They delve into the challenges of running open-source projects in containers and the importance of using commercial solutions to solve complex engineering problems. They also discuss the evolution of software engineering education, the role of platform engineering in enterprise-scale DevOps, and the necessity of understanding underlying mechanisms and optimizing for specific use cases. Join them as they explore the cutting-edge technologies and industry insights that are shaping the future of DevOps and platform engineering

Socials

Mike Bowers is the Chief Architect at FairCom Corporation. They delve deep into the world of DevOps and database management. They explore the complexities and challenges of maintaining multiple databases in the cloud, the evolving role of database administrators, and the impact of open-source software on database management. They share insights into the shift in database administration roles, the importance of security in database management, and the need for support and infrastructure when bringing in new databases. They also touch on the nuances of NoSQL databases, the value of specializing in database architecture, and the benefits of using the right tools for database tasks. Join them as they unpack the intricacies of database management in today's ever-evolving technological landscape.

Links

The Adventures in DevOps podcast welcomes Warren Parad as the newest host. Together with Will, they dive into a wide range of topics, including technology advancement, disaster recovery, open source, mentorship in the software engineering field, and the intersection of technology and business. They share their experiences and insights on implementing tools, managing risk, and understanding the financial impact of technology investments. Join them as they explore the complexities of the tech industry and the importance of continuous learning and adaptation. Stay tuned for an engaging and informative discussion with our knowledgeable speakers as they share their real-world experiences and valuable insights.

Socials

Jeffrey Groman takes the reins and walks Chuck and Will through the latest and greatest security breaches out on the internet.He also walks them through how to operate to avoid being caught by several of these issues.Specifically, he explains the Microsoft issue in the print spooler and the breach of Kaseya and what the implications are within the wider world.

Picks