When engineering teams talk about observability, they often picture dashboards, alerts, and vendor slides. But inside real enterprise systems, observability is a story about people. It’s about how they communicate, how they respond under pressure, and how they collaborate when platforms are messy, duplicated, or half-maintained.

In this episode, Duncan Mapes and Jason Ehmke sit down with platform veteran Jason McMunn, who has spent years untangling observability chaos across large organizations. What unfolds is a candid look at what actually breaks when systems scale, fractured ownership, unclear contracts between teams, and the silent cost of tools nobody fully uses.

Through real incidents, leadership lessons, and platform consolidation stories, the trio walks through what it looks like to build observability that teams trust, not just observability that vendors promise. If you’ve ever shipped an alerting strategy that blew up in your face, wrestled with tool sprawl, or tried to rebuild trust between teams after an outage, this is the guide you’ve been needing.

Top Takeaways:

• Understanding the current capabilities is crucial for transformation.
• Building relationships is key to gaining buy-in from stakeholders.
• Empathy plays a significant role in technology management.
• Transforming team roles requires a shift in mindset.
• Cost management should focus on value rather than just savings.
• Education and support empower teams to be self-sufficient.
• Being present during incidents provides valuable insights.
• User experiences can reveal underlying issues with technology.
• Leadership is essential in driving organizational change.
• Modeling best practices can inspire others to follow suit.

Connect with us:

Duncan Mapes

Jason Ehmke

DevGrid.io

DevGrid on LinkedIn

DevGrid on X

Viewed through the lens of systems thinking, AI introduces both leverage and fragility into the development lifecycle. In this episode, Duncan Mapes, Jason Ehmke, and returning guest, Chris Boyd break down how AI affects feedback loops, failure modes, team throughput, and the architecture of modern systems.

They explore the evolving responsibilities of engineers in an environment where code generation is partially automated, and discuss how AI reshapes design principles, mobile development approaches, and cross-team dynamics.

The takeaway: AI is neither a panacea nor a threat. It’s a force multiplier for teams who know how to use it, and a risk amplifier for those who don’t.

Top Takeaways:

• AI tools are revolutionizing coding workflows, allowing for rapid prototyping and iteration.
• The CLI tools like Claude and Codex are becoming essential for developers.
• The last 10% of a project is often the hardest, but AI can help streamline this process.
• Design and usability remain critical, even as coding becomes more automated.
• The economics of development are shifting as AI reduces the time and cost of building software.
• Open-source models are gaining traction, but proprietary models still dominate the market.
• AI is not just a replacement for developers but a tool for enhancing their capabilities.
• The future of mobile development may see a resurgence of native apps due to AI tools.
• Companies need to adapt their workflows to integrate AI effectively.
• The competition between AI models is intensifying, with new players entering the market.

Connect with us:

Duncan Mapes

Jason Ehmke

DevGrid.io

DevGrid on LinkedIn

DevGrid on X

Tech debt exists at the intersection of engineering, business incentives, and system architecture. In complex organizations, it becomes a multidimensional problem involving operational risk, system reliability, long-term scalability, and developer productivity.

In this analytically grounded episode, Duncan and Jason dissect tech debt through the lens of system thinking.

They introduce a working model for categorizing tech debt into functional, structural, and data-related risk, explaining how each impacts throughput, incident frequency, and time-to-recovery. They also examine how vulnerabilities and poor data contracts masquerade as “bugs” but are often symptoms of deeper architectural debt.

The conversation presents a practical playbook for leaders: how to assess tech debt, measure its economic impact, define acceptable thresholds, and integrate it into strategic planning.

Top Takeaways:

• Tech debt can be defined in various ways depending on context.
• Shortcuts taken to meet business needs contribute to tech debt.
• Tech debt is not just about code quality but also about business outcomes.
• Standards change over time, leading to new tech debt.
• Quantifying tech debt is essential for effective management.
• Managing tech debt requires strategic planning and documentation.
• Business leaders need to understand the implications of tech debt.
• Justifying tech debt investments is a common challenge.
• Effective communication with business partners is crucial for tech debt management.
• A structured approach to documenting tech debt can aid in prioritization.

Connect with us:

Duncan Mapes

Jason Ehmke

DevGrid.io

DevGrid on LinkedIn

DevGrid on X