In this episode of Tech Council, we speak with Jason McMunn about what leaders must get right when implementing AI across large organizations. Moving from experimentation to enterprise-wide AI deployment requires more than enthusiasm for new tools. It demands alignment across people, process, and governance.

Jason explains how AI reshapes the way engineering teams operate, how decision-making evolves when intelligence is embedded into workflows, and why upskilling is now a strategic priority rather than a technical afterthought. AI introduces new efficiencies, but it also exposes weak organizational foundations. Without trust and clarity, even the most advanced AI initiatives stall.

This conversation provides a grounded perspective on enterprise AI transformation. It moves beyond hype and focuses on execution, leadership responsibility, and long-term sustainability. For executives navigating AI adoption, this episode offers practical insight into scaling AI with intention.

Top Takeaways:

• As AI automates routine and technical work, professional value shifts from task mastery to abstract problem framing and oversight skills.
• Organizations that recognize this shift will prioritize adaptable thinkers over task specialists, fundamentally redefining expertise and hiring criteria.
• A senior developer no longer needs deep low-level system knowledge; instead, success depends on defining success criteria and guiding AI outputs effectively.
• Trust in leadership and systems isn't presumed; it is actively built by designing organizational processes that empower autonomy and reduce unnecessary oversight.
• High-trust organizations accelerate innovation and agency, whereas distrust breeds resistance and stifles utilization of powerful tools like AI.
• The rapid acceleration of technological change, driven by AI and digital tools, demands a mental shift from managing change chronologically to embracing continuous, adaptive learning.
• If leaders and teams cling to outdated mental models, they risk obsolescence; adaptability becomes the new competence.
• Organizations should treat upskilling as a renewal of mindset, not just skill acquisition, embedding flexibility into learning pathways and decision-making.
• Fear of AI stems from its non-deterministic nature and unpredictability, challenging traditional notions of control and certainty in processes.
• Organizations that understand this can develop better guardrails and guard their confidence, turning fear into structured experimentation rather than paralysis.
• Setting explicit context, guardrails, and understanding input-output variability allows organizations to embrace AI’s complexity rather than fear it.
• Distributing AI champions within teams, rather than centralizing control, creates a resilient ecosystem where skilled individuals drive innovation without bureaucratic bottlenecks.
• AI’s capacity to handle specific tasks shifts organizational focus toward creating and shipping value, rendering traditional task management increasingly obsolete.
• Given the unprecedented and fast-evolving AI landscape, organizations must adopt a mindset of ongoing experimentation rather than static, rigid strategies.

Connect with us:

Duncan Mapes

Jason Ehmke

DevGrid.io

DevGrid on LinkedIn

DevGrid on X

In this episode, Duncan Mapes and Jason Ehmke explore what tools like GitHub Codespaces and Codex really mean for the future of software development not just in terms of speed, but also in terms of responsibility.

They unpack how velocity is shifting when AI can generate code instantly, how developers are rethinking environment management, and why craftsmanship looks different in a world where automation handles the mechanics. But they also wrestle with the hard questions: What happens to velocity measurement? How do teams maintain quality? Where does human judgment matter most?

More than getting faster, software development is becoming structurally different. AI changes the relationship between engineers, tooling, QA, and production.

The real question isn’t whether to adopt these tools. It’s whether your organization understands the second-order effects of adopting them.

Top Takeaways:

• Automation can lead to faster outputs but may compromise craftsmanship.
• The value of a product is determined by the clarity of its inputs.
• Fast execution does not guarantee a quality product.
• Quality assurance is crucial in maintaining customer trust.
• Rapid development can lead to overlooking critical details.
• The evolution of tools requires a shift in planning and execution strategies.
• Production data is inherently messy and complex.
• Feature flags are essential for testing in production environments.
• Dockerization enhances the performance of AI agents.
• The context in which AI operates is crucial for its effectiveness.
• Software development resembles the process of writing a novel.
• Acceptance criteria are vital for defining project completion.
• Best practices in enterprise software development are critical.
• The future of software development is uncertain and requires adaptability.
• Continuous shipping and iteration are key to success.

Connect with us:

Duncan Mapes

Jason Ehmke

DevGrid.io

DevGrid on LinkedIn

DevGrid on X

When engineering metrics are poorly designed, they encourage short-term optimization, suppress risk-taking, and mask systemic issues like technical debt and security gaps. When designed well, they provide early signals, enable informed trade-offs, and reinforce cultural norms.

In this episode, Tech Council breaks down the mechanics of effective metrics: defining standards, ensuring visibility across applications, and understanding the economic implications of compliance and security. Duncan and Jason analyze how leadership behavior amplifies the impact of metrics, and why transparency determines whether metrics motivate or demoralize engineering teams.

Top Takeaways:

• Carving out time for tech debt is crucial.
• Stop the bleeding by confronting existing issues.
• Defining 'good' is essential for team alignment.
• Visibility in metrics helps prioritize efforts.
• Gamification can engage developers in improving metrics.
• Compliance has significant economic implications.
• Vulnerabilities often represent theoretical risks.
• Creating a culture of measurement drives improvement.
• Transparency in leadership fosters accountability.
• Lean into measurement to influence positive change.

Connect with us:

Duncan Mapes

Jason Ehmke

DevGrid.io

DevGrid on LinkedIn

DevGrid on X

While much of the industry focuses on speed, this episode of Tech Council explores the deeper shift: AI is changing how software is built. Faster feedback loops demand better decision-making. Automated workflows raise the bar for testing, rollout strategies, and system resilience.

Duncan Mapes and Jason Ehmke examine why feature flags, automation, and thoughtful development practices are no longer optional when AI accelerates delivery. It also addresses the cultural shift required as engineers adapt to new responsibilities in an increasingly automated environment.

Rather than framing AI as a shortcut, this episode positions it as a forcing function, one that exposes weak processes and rewards teams that prioritize clarity, quality, and customer insight.

Top Takeaways:

• AI tools are changing the software development landscape.
• Speed of development can lead to overlooked edge cases.
• Feature flags can help manage production risks.
• Agile methodologies have evolved from waterfall approaches.
• Automated testing is crucial for maintaining quality.
• Understanding customer needs is essential for product success.
• Iterative development allows for faster feedback loops.
• Cultural factors influence product development processes.
• Differentiation in products is key to standing out in the market.
• The role of engineers is shifting towards management and oversight.

Connect with us:

Duncan Mapes

Jason Ehmke

DevGrid.io

DevGrid on LinkedIn

DevGrid on X

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

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

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

Duncan and Jason break down the cause-and-effect chains behind incidents: data inconsistencies, missing resiliency patterns, queue backlogs, or unplanned API dependencies. They argue that resilient systems emerge from predictable inputs like, consistent data contracts, reliable backfill strategies, upstream validation, and well-defined ownership boundaries.

This episode provides a mental model for designing platforms where autonomy accelerates delivery, while standards protect system health. It highlights the value of pre-incident thinking and gives a blueprint for building platforms that remain operable even under load, failure, or organizational drift.

Top Takeaways:

• Automation is essential for effective platform engineering.
• Balancing enablement and independence is crucial for user adoption.
• Self-service capabilities enhance scalability and efficiency.
• Evangelizing the platform can drive user engagement and adoption.
• Creating friction can reduce unnecessary support requests.
• Manual reviews should be a temporary solution, not a permanent process.
• Setting clear standards and guidelines is vital for platform integrity.
• Building a culture of support fosters better relationships with users.
• Understanding user needs helps in creating effective platform solutions.
• Empowering key individuals can enhance platform adoption across teams.

Connect with us:

Duncan Mapes

Jason Ehmke

DevGrid.io

DevGrid on LinkedIn

DevGrid on X

In this episode, Duncan Mapes and Jason Ehmke share real-world lessons from years of building and scaling technology across enterprise environments where downtime costs dollars.

They explore the art of designing resilient systems that can withstand inevitable failure points, recover quickly, and continue operating under pressure. From team culture to proactive design checklists, this conversation dives into how engineering leaders can turn system reliability into a competitive advantage.

Top Takeaways:

• Designing for failure is crucial in system architecture.
• Understanding failure points is essential for system resiliency.
• Resiliency can mean different things depending on the context.
• Asking the right questions during project kickoff is vital.
• Complex enterprise environments have unique challenges.
• Responsibility for failures should not be shifted to others.
• Handling app stability is a core responsibility of developers.
• Everything in a system can fail at some point.
• Evaluating business impact is crucial for prioritizing resiliency efforts.
• Creating a resiliency checklist can guide design and implementation.

Connect with us:

Duncan Mapes

Jason Ehmke

DevGrid.io

DevGrid on LinkedIn

DevGrid on X

Flights. Hotels. Per diems. All in the hope of “learning” and “networking.” But when they return? The notebooks gather dust, and the insights never leave their laptops.

In this episode of Tech Council, Duncan Mapes and Jason Ehmke pull back the curtain on what actually makes conferences worth attending. From understanding why you’re going, to choosing who should go, to how that knowledge is shared afterward, they uncover the strategies that separate teams who grow from teams who just take selfies at the expo hall.

They also explore local meetups to internal learning sessions that often yield more value for less cost.

If you’ve ever wondered whether conferences are worth the budget line item, this episode gives you the framework to find out.

Top Takeaways:

• Conferences can provide valuable learning opportunities for engineers.
• Networking at conferences often yields more insights than formal sessions.
• Local meetups can be just as beneficial as large conferences.
• Budgeting for conferences requires careful consideration of ROI.
• Selecting attendees for conferences can be a challenging process.
• Knowledge transfer after conferences is crucial for team growth.
• Encouraging participation in local events fosters community engagement.
• Engineers should aspire to share knowledge through talks at meetups.
• The tech industry is constantly evolving, making continuous learning essential.
• Feedback from the community can enhance future discussions on conference attendance.

Connect with us:

Duncan Mapes

Jason Ehmke

DevGrid.io

DevGrid on LinkedIn

DevGrid on X

For Duncan and Jason, those books go far beyond tech manuals. They’re the ones that teach you how to think, how to communicate, and how to take responsibility when things get hard.

In this week’s Tech Council, they open their personal libraries and share the titles that stuck. Expect reflections on ownership, transparency, and the hidden leadership lessons inside biographies, history books, and even fiction.

This isn’t your ordinary book recommendations episode. It’s about why some ideas endure, why others fail in practice, and why the best tech lessons sometimes come from outside of tech entirely.

Books Mentioned in this Episode:

• The Scaling Era: An Oral History of AI
• Extreme Ownership: How U.S. Navy SEALs Lead and Win
• The Dichotomy of Leadership
• Radical Candor
• Turn the Ship Around
• PHP/MySQL Programming for the Absolute Beginner
• The Innovators: How a Group of Hackers, Geniuses, and Geeks Created the Digital Revolution
• John Adams by David McCullough
• 1776 by David McCullough
• The Daily Stoic: 366 Meditations on Wisdom, Perseverance, and the Art of Living
• Good to Great: A Study of Management Strategies of Companies with Lasting Growth
• High Output Management by Andy Grove
• 12 Rules for Life: An Antidote to Chaos
• The Hard Thing About Hard Things
• What You Do Is Who You Are: How to Create Your Business Culture
• Rework by Jason Fried and DHH
• High Growth Handbook
• Three-Body Problem
• The Alchemist

Connect with us:

Duncan Mapes

Jason Ehmke

DevGrid.io

DevGrid on LinkedIn

DevGrid on X

In this Tech Council episode, Duncan Mapes and Jason Ehmke analyze the habits that drive high-performing hybrid teams. They discuss proximity bias, performance evaluation, and how communication systems shape fairness and culture.

They dissect the bad habits that derail trust (like reactive communication and lack of structure) and the good ones that strengthen it (like clear metrics, empathy, and visibility).

Whether you’re leading across time zones or transitioning from in-office to hybrid, this episode offers actionable insights drawn from years of managing distributed engineering teams.

Top Takeaways:

• Hybrid work can create feelings of exclusion among remote employees.
• Intentional communication is crucial in remote settings.
• Establishing clear norms helps teams function effectively.
• Performance management in hybrid environments requires careful consideration.
• Promoting remote employees can be challenging due to visibility issues.
• Building relationships is essential for team cohesion.
• Junior employees need guidance to develop professional skills remotely.
• Regular check-ins can help maintain team engagement.
• Documentation of achievements is vital for remote employees.
• Creating opportunities for in-person interactions can enhance team dynamics.

Connect with us:

Duncan Mapes

Jason Ehmke

DevGrid.io

DevGrid on LinkedIn

DevGrid on X

Duncan Mapes and Jason Ehmke break down the complex challenges app managers face in balancing velocity and technical debt. They explore how technical advocacy, stakeholder trust, and long-term business alignment converge to shape outcomes.

They highlight how trust, advocacy, and smart decision-making can turn impossible situations into opportunities for innovation.

Top Takeaways:

• Balancing velocity and tech debt is crucial for app managers.
• There is no one-size-fits-all approach to managing tech debt.
• Building strong partnerships with business leaders is essential.
• Tech debt should be intertwined with business strategy.
• Continuous improvement requires measuring success and outcomes.
• App managers must advocate for necessary tech changes.
• Justifying technical decisions is key to gaining support.
• Encouraging innovation can lead to valuable insights.
• Effective communication is vital in stakeholder conversations.
• Understanding the business impact of tech decisions is critical.

Connect with us:

Duncan Mapes

Jason Ehmke

DevGrid.io

DevGrid on LinkedIn

DevGrid on X

In this episode, Jason Ehmke and Duncan Mapes unpack the hidden struggles of talent acquisition. From navigating contract-to-hire strategies to cultivating trust through transparency, they share real-world lessons from building engineering teams that last. 

Beyond résumés and interviews, the conversation dives into how leadership directly shapes retention, why recruiters are more than gatekeepers, and how slow, clunky processes quietly repel top talent. 

This episode is about balancing short-term hiring pressure with the long game of building resilient, high-performing teams.

Top Takeaways:

• Hiring the right people is crucial for success.
• Talent acquisition should be a thoughtful process.
• Contract-to-hire can mitigate hiring risks.
• Leadership quality directly impacts team performance.
• Creating opportunities for lateral mobility retains talent.
• Transparency fosters trust within teams.
• Building relationships with recruiters enhances candidate quality.
• Streamlining recruitment processes saves time and resources.
• A positive team environment encourages retention.
• Balancing short-term needs with long-term goals is essential.

Connect with us:

Duncan Mapes

Jason Ehmke

DevGrid.io

DevGrid on LinkedIn

DevGrid on X

Buying a gateway doesn’t mean you have an API strategy. What matters is governance, security, and making life easier for developers who build and consume those APIs. 

In this episode, Duncan and Jason unpack the real challenges behind building a sustainable API practice: how to avoid sprawl, how to strike the balance between control and flexibility, and how to embed security into every layer. 

They also share lessons on centralizing API governance without killing innovation, and why the best APIs put developer experience at the core.

Top Takeaways:

• API gateways have become essential in modern architecture.
• The interpretation of API gateways varies among teams.
• A mature API practice requires standards and governance.
• Security is a primary benefit of using API gateways.
• Developer experience is crucial for API adoption.
• Centralized governance helps manage API inventory effectively.
• API Gateway solutions vary in capabilities and deployment models.
• Automation can streamline API deployment processes.
• Collaboration between teams is necessary for API success.
• Documentation and onboarding processes impact developer engagement.

Connect with us:

Duncan Mapes

Jason Ehmke

DevGrid.io

DevGrid on LinkedIn

DevGrid on X

Hiring SREs doesn’t make you reliable. Metrics dashboards don’t guarantee accountability. And cultural change doesn’t happen because you wrote it on a slide deck.

In this episode, Duncan Mapes and Jason Ehmke push back against the misconceptions. They argue that SRE isn’t a bolt-on team but a systemic shift in how engineering works. Without shared accountability, meaningful metrics, and cultural buy-in, SRE will fail. 

And no, copying Google’s model isn’t the answer.

If you think SRE is just a headcount play, this episode will challenge everything you believe. Got a different perspective? Drop us a review, share your comments, and send your toughest SRE questions our way.

Top Takeaways:

• SRE is a complex practice that varies across organizations.
• Defining SRE upfront can prevent chaos later.
• SRE is not just about taking over responsibilities; it's about collaboration.
• The role of SREs is to guide and support application teams.
• Key metrics for SRE success include mean time to detect and restore.
• Cultural transformation is essential for successful SRE implementation.
• Finding early wins can help demonstrate the value of SRE.
• Effective communication is crucial for SREs to succeed.
• SRE teams should focus on toil reduction and automation.
• Building a strong relationship between SREs and app teams is vital.

Mentioned in this Episode:
Site Reliability Engineering: How Google Runs Production Systems - https://www.oreilly.com/library/view/site-reliability-engineering/9781491929117/

Connect with us:

Duncan Mapes

Jason Ehmke

DevGrid.io

DevGrid on LinkedIn

DevGrid on X

Hybrid work, distributed leadership, and constant change. But one thing hasn’t changed: navigating workplace politics is tricky.

In this episode, Duncan Mapes and Jason Ehmke get real about how engineers can build influence without playing power games. From handling peer dynamics to understanding leadership intent, they share frameworks that help you stay effective and aligned.

This conversation started with a listener’s question, and it sparked insights every individual contributor and engineering leader should hear. Whether you’re trying to give feedback, manage relationships, or earn trust on your team, this episode will change how you think about workplace dynamics.

Top Insights:

• There are appropriate times to push back against leadership decisions.
• Understanding the reasoning behind leadership decisions is crucial.
• Taking ownership in projects can lead to greater influence and responsibility.
• Building relationships with peers and managers is essential for effective communication.
• Constructive feedback should focus on helping others succeed, not criticizing them.
• Examine your intent before providing feedback to ensure it's constructive.
• Curiosity and humility are key when challenging leadership decisions.
• Alignment within teams is necessary for fast and effective decision-making.
• Navigating peer relationships requires transparency and communication.
• Encouraging audience engagement can lead to valuable discussions.

Connect with us:

Duncan Mapes

Jason Ehmke

DevGrid.io

DevGrid on LinkedIn

DevGrid on X

In this episode, Duncan and Jason break down how high-performing engineering teams recover differently. Instead of assigning blame, they focus on learning, adapting, and improving.

Through stories and insights, they explore how leadership sets the tone for accountability, why feedback loops are essential for growth, and how creating psychological safety helps engineers move faster without fear.

If you’ve ever been in the middle of a postmortem wondering how to make your team stronger, this conversation will change the way you think about engineering culture.

Top Takeaways:

• Building a resilient engineering culture requires overcoming fear and blame.
• Incident responses reveal the underlying culture of an organization.
• Blameless postmortems focus on accountability, not punishment.
• Leaders must model accountability to foster a healthy culture.
• Creating a culture of trust involves open communication and vulnerability.
• Accountability should be balanced with support and understanding.
• Influencing culture starts with individual actions and leadership.
• Navigating niceness in leadership requires setting clear expectations.
• High standards lead to better team dynamics and accountability.
• Low accountability results in wasted resources and ineffective teams.

Connect with us:

Duncan Mapes

Jason Ehmke

DevGrid.io

DevGrid on LinkedIn

DevGrid on X

Your team wants the freedom to try new tools, adopt new frameworks, and build in ways that make sense to them. But leadership needs consistency, security, and cost control. So… who’s right?

In this episode of Tech Council, Duncan Mapes and Jason Ehmke unpack how to balance developer autonomy with organizational alignment. It’s not about locking everything down, nor is it about letting every team go rogue. It’s about knowing where freedom fuels innovation and where centralization prevents chaos.

Whether you’re managing three engineers or three hundred, this episode delivers actionable insights for engineering leaders looking to optimize for both speed and stability.

Top Takeaways: 

• Freedom in engineering can lead to significant efficiency gains.
• Centralization can improve decision-making and reduce costs.
• A standardized stack allows for quicker onboarding of developers.
• Decentralization can lead to increased operational risk and inefficiencies.
• The balance between freedom and centralization is context-dependent.
• Quick decision-making is crucial for organizational efficiency.
• Too much freedom can result in stagnation and missed deadlines.
• Centralized decision-making can help maintain security and compliance.
• Empowering developers with context can lead to better decision-making.
• Finding a middle ground is essential for effective engineering management.

Connect with us:

Duncan Mapes

Jason Ehmke

DevGrid.io

DevGrid on LinkedIn

DevGrid on X

While that’s not wrong, it’s not the whole story. In this candid episode, Duncan Mapes and Jason Ehmke break through the noise to talk about what actually matters when you step into a new role: defining success metrics, proving yourself with early wins, and building credibility fast. 

Leadership transitions are less about theory and more about execution, and the way you handle those first 90 days can set the tone for years to come.

Top Takeaways:

• Transitioning from a large enterprise to a smaller organization can be intimidating.
• In smaller companies, accountability is more direct and personal.
• The first few months in a new role should focus on learning and absorbing information.
• Assessing team dynamics and architecture is crucial for effective leadership.
• Early wins are important for building credibility and trust.
• Defining success criteria is essential for aligning team goals with organizational objectives.
• Fresh eyes can provide valuable insights into existing processes and team dynamics.
• Avoid making snap judgments about team members; assess their skills fairly.
• Planning should be done in phases, focusing on short-term and long-term goals.
• Continuous self-improvement is vital for effective leadership.

Mentioned in the Episode:

• Extreme Ownership: How U.S. Navy SEALs Lead and Win by Jocko Willink and Leif Babin
• The Dichotomy of Leadership: Balancing the Challenges of Extreme Ownership to Lead and Win by Jocko Willink and Leif Babin
• 7 Habits Of Highly Effective People by Stephen Covey
• High Output Management by Andy Grove

Connect with us:

Duncan Mapes

Jason Ehmke

DevGrid.io

DevGrid on LinkedIn

DevGrid on X

For years, engineers have hated metrics, but what if the real issue isn’t the numbers… it’s how they’re used?

In this episode, Duncan Mapes and Jason Ehmke dig into why many engineers roll their eyes at metrics, the traps leaders fall into when measuring productivity, and how to shift the conversation toward continuous improvement.

They challenge conventional thinking, arguing that metrics can transform engineering culture if leaders stop using them as surveillance tools. They break down how to measure without micromanaging, why team-level data beats individual stats, and how metrics can expose, not punish, weak spots in your delivery process.

Top Takeaways:

• Metrics in software engineering are often misunderstood and misused.
• Engineers typically resist being measured due to a fear of scrutiny.
• Effective metrics should focus on outcomes, not just activity.
• Continuous improvement is essential for enhancing team performance.
• Team-level metrics are more valuable than individual metrics.
• Data should be used to identify bottlenecks and improve processes.
• Transparency in metrics fosters trust and collaboration within teams.
• Asking the right questions can uncover valuable insights.
• Metrics should drive conversations about improvement, not blame.
• A culture of measurement can lead to better outcomes and happier customers.

Connect with us:

Duncan Mapes

Jason Ehmke

DevGrid.io

DevGrid on LinkedIn

DevGrid on X

That’s one of the real questions Duncan and Jason tackle in this episode of Tech Council. They get honest about what AI is actually changing in engineering management, and what’s just hype.

They dive into how teams are adapting, what mentorship looks like when everyone has an AI assistant, and why outcomes matter way more than implementations.

If you manage a team or work on one, this episode will shift how you think about leading in a tech space that’s moving fast.

Top Takeaways:

• AI tools are changing the expectations for junior developers
• Mentorship remains crucial in developing good habits in junior developers
• Effective communication is key in managing teams
• Evaluating work now requires deeper understanding beyond surface-level quality
• The importance of outcomes is heightened in the age of AI
• Setting clear expectations is more challenging yet essential
• Junior developers can now contribute to higher-level discussions
• Documentation and formal practices are becoming more important
• The role of a manager is to guide teams towards achieving outcomes
• Technical skills can be taught, but attitude and engagement are critical

Connect with us:

Duncan Mapes

Jason Ehmke

DevGrid.io

DevGrid on LinkedIn

DevGrid on X

It’s one of the most hotly debated decisions in software engineering, and in this episode of Tech Council, Duncan and Jason lay it all out.

They challenge the hype around microservices and explain why monoliths should be the default starting point for most teams. With Conway’s Law as a backdrop, they show how internal team communication patterns shape your system’s architecture, whether you like it or not. 

You'll also hear when it's actually time to break things up, and why Service-Oriented Architecture deserves a second look. It’s a must-listen for anyone scaling tech systems while trying to keep complexity under control.

Top Takeaways:

• Context Matters: The decision between microservices and monoliths depends heavily on the organizational context and size.
• Microservices Complexity: While microservices offer flexibility, they can introduce significant maintenance overhead and complexity.
• Monoliths' Simplicity: Monoliths can be simpler to manage, especially for smaller teams or when local installations are required.
• Scalability Considerations: Both approaches have their scalability challenges, with microservices offering more granular control.
• AI and Future Trends: AI advancements may influence the balance between microservices and monoliths, potentially leading to more consolidation.

Connect with us:

Duncan Mapes

Jason Ehmke

DevGrid.io

DevGrid on LinkedIn

DevGrid on X

In this episode of Tech Council, Duncan Mapes and Jason Ehmke spotlight the unspoken, underestimated cost of audit prep, compliance checklists, and spreadsheet-driven project tracking - the administrative tax. 

Administrative tax is the accumulation of compliance requirements, audit demands, spreadsheet sprawl, and redundant manual workflows that keep smart people from doing the work they were actually hired to do.

If you’re a CTO or engineering leader aiming to operationalize strategy while scaling cleanly, this episode offers a data-driven roadmap.

Top Takeaways: 

• The administrative tax is a significant burden on organizations
• Regulatory pressures have intensified in recent years, impacting operational efficiency
• Perverse incentives can lead to inefficiencies and increased workload
• App managers are often the most affected by administrative tax
• Maintaining a clear inventory is crucial for effective management
• Automation can help alleviate the administrative tax burden
• Organizations need to measure their progress and define what 'good' looks like
• The Cobra effect illustrates how poorly designed incentives can worsen problems
• Effective governance is essential for managing administrative tax
• Smart people in organizations want to improve processes but face limitations

Mentioned in the Episode:

• Internal Tech Emails on X (Twitter) - https://x.com/TechEmails 
• Internal Tech Emails post on X about Mark Zuckerberg’s memo about Strategy Tax - https://x.com/TechEmails/status/1944451283236303184 

Connect with us:

Duncan Mapes

Jason Ehmke

DevGrid.io

DevGrid on LinkedIn

DevGrid on X

Jason and Duncan aren’t mincing words in this episode of Tech Council.

They’re calling BS on the myth of the superhuman engineer and making a case for the everyday professionals who care deeply, collaborate well, and raise the bar for everyone else.

This one’s for team leads, CTOs, and senior devs who want to build organizations where great work doesn’t depend on unicorns.

Hit play and rediscover the power of normal engineers.

Top Takeaways:

• The concept of the 10X engineer is often exaggerated and can be counterproductive
• Systems and teams are more important than individual talent
• Decentralizing responsibility can lead to a healthier team dynamic
• Caring about the right things can help shape a better engineering culture
• Designing an ecosystem for talent is crucial for organizational success
• AI tools are changing the expectations of engineering roles
• Specialization will still exist, but versatility will be increasingly important
• Creating an attractive work environment can help draw in top talent
• Great engineers are made through mentorship and support

Mentioned in the Episode:

In Praise of “Normal” Engineers by Charity Majors - https://charity.wtf/2025/06/19/in-praise-of-normal-engineers/ 

Charity Majors - https://charity.wtf/about/ 

Charity Majors on LinkedIn - https://www.linkedin.com/in/charity-majors

Connect with us:

Duncan Mapes

Jason Ehmke

DevGrid.io

DevGrid on LinkedIn

DevGrid on X

This week on Tech Council, Duncan sits down with Chris Boyd—a mobile dev veteran turned platform engineering leader—to talk about what changes when your team grows, your stack evolves, and your priorities shift.

They talk React Native, metrics, AI, leadership, and what it takes to balance product demands with long-term engineering health.

Chris is also on the verge of launching something new—so you’ll get a peek behind the curtain of what’s next in agent development.

Hit play. This one’s packed.

Top Takeaways:

• Metrics are crucial for understanding app performance
• Leadership in platform engineering requires strong communication skills
• Addressing app quality issues can require drastic measures
• React Native is becoming the standard for mobile development
• Transitioning to a new tech stack should be gradual and strategic
• AI is reshaping the landscape of software development
• Personal development and growth are key in tech careers
• Building a strong team culture is essential for success
• Understanding the business impact of tech decisions is critical
• Continuous learning and adaptation are necessary in tech

Connect with Chris Boyd - https://chrisboyd.me/

Connect with us:

Duncan Mapes

Jason Ehmke

DevGrid.io

DevGrid on LinkedIn

DevGrid on X

They begin by breaking down what a team charter actually is—beyond the corporate buzzword—and why it’s more than just a document. It’s a living agreement that shapes team culture, defines roles, and holds people accountable.

From their own leadership experience, Jason and Duncan share the impact a well-defined charter can have on team dynamics, trust, and output. They unpack the process of building a team charter from scratch: who should be involved, how to navigate personalities and power plays, and how to evolve it as your team grows.

Whether you're leading an engineering org, onboarding new members, or trying to realign a project that's lost steam, this episode will help you build stronger foundations.

Top Takeaways:

• Team charters are often non-existent but crucial for team effectiveness
• A team charter serves as a mission statement or constitution for the team
• Creating a charter helps clarify team responsibilities and success criteria
• Engaging the team in the charter creation process fosters ownership and alignment
• Team charters should be revisited and updated regularly to remain relevant
• Resistance to change can be managed through open communication and understanding
• Stakeholder engagement is vital for gaining buy-in for the team charter
• Success criteria should be clearly defined to measure team effectiveness
• Team charters can help defend the team's purpose and funding during budget cycles
• The process of creating a charter can lead to valuable conversations and insights

Connect with us:

Duncan Mapes

Jason Ehmke

DevGrid.io

DevGrid on LinkedIn

DevGrid on X

Expect insights into managing trade-offs, building trust, and creating systems where autonomy thrives. The conversation covers leadership transitions, empowering teams, and ensuring standards don’t slip in the name of speed.

If you're striving for balance between freedom and structure in your team, this is the conversation you need.

Top Takeaways:

• Ownership is crucial in application development
• Leaders must empower their teams without micromanaging
• Transitioning from team member to leader requires unlearning old habits
• Encouraging feedback is essential for growth
• Balancing autonomy and standardization is a leadership challenge
• Technology decisions should be made with long-term outcomes in mind
• Managing technical debt is a shared responsibility
• Clear roles and responsibilities prevent chaos in teams
• Data-driven decision-making enhances accountability
• Building a culture of ownership leads to better outcomes

Connect with us:

Duncan Mapes

Jason Ehmke

DevGrid.io

DevGrid on LinkedIn

DevGrid on X

In this episode of Tech Council, Duncan Mapes and Jason Ehmke explore why that happens—and what teams can do differently. They dig into the importance of real-time feedback, managing scope, and maintaining healthy communication between engineering and business units.

Learn how to align vision, reduce cognitive overload, and create urgency without panic. Whether you're leading software projects or embedded in the code, these insights will help you understand where things go wrong—and how to fix them before it’s too late.

Top Takeaways:

• Incremental value delivery is essential in software development
• Understanding cognitive overhead helps in prioritization
• Smaller feature sets reduce team burden and improve focus
• Iterative development allows for better market feedback
• Trade-offs are inherent in software project management
• Real data is necessary for effective decision-making
• Waterfall methods can be limiting in fast-paced environments
• Customer relationships can tolerate imperfect products
• Empathy between business and engineering teams enhances collaboration
• Understanding change management involves recognizing the complexities behind seemingly simple requests
• Building trust and relationships is crucial for effective change management
• Setting clear expectations can help manage the impact of changes on project timelines
• Communication is key to ensuring all parties are aligned on project goals and change.
• Hitting 100% of deadlines can indicate a lack of ambition in project planning
• Maintaining a record of agreements and changes is essential for accountability
• Teams need to understand the importance of their work to foster intrinsic motivation
• Creating a sense of urgency can help teams stay focused and effective
• It's important to have open conversations about project scope and timelines
• Leaders should strive to reconcile team vision with organizational objectives

Connect with us:

Duncan Mapes

Jason Ehmke

DevGrid.io

DevGrid on LinkedIn

DevGrid on X

In this episode of Tech Council, Duncan Mapes and Jason Ehmke break down the ethical, technical, and human implications of AI in software development. From workflow automation to code generation and performance tracking, AI is changing the landscape—but not always in the ways you’d expect.

The conversation explores the hidden pressures AI introduces: the erosion of organic team communication, the complexity of evaluating performance fairly, and the risk of turning development into a surveillance-heavy space. Through it all, Duncan and Jason emphasize the need for thoughtful leadership that balances innovation with intention.

Tune in and get a fresh, honest look at how to lead tech teams through the AI revolution.

Top Takeaways:

• AI ethics is a complex and evolving topic.
• The integration of AI tools can streamline workflows.
• Different AI models have varying levels of effectiveness.
• Cognitive load in code reviews can be significantly reduced with AI.
• AI can change the dynamics of communication in teams.
• Surveillance capabilities in development environments raise ethical concerns.
• The debate on task execution is shifting towards action-oriented approaches.
• AI tools can help clarify and optimize developer tasks.
• The role of software engineers is evolving with AI advancements.
• AI's impact on the industry is largely positive, despite short-term challenges. Developer efficiency can be indicated by various metrics.
• The origin of DevGrid is rooted in optimizing data and processes.
• Sales outcomes are easier to measure than engineering outcomes.
• Incentives play a crucial role in performance evaluation.
• Surveillance tools can help identify blind spots for developers.
• Critical feedback is essential for growth in any profession.
• Management tools should empower rather than alienate developers.
• AI agents are transforming the coding landscape.
• Leadership requires continuous learning and adaptation.
• Maintaining a balance between oversight and trust is vital.

Connect with us:

Duncan Mapes

Jason Ehmke

DevGrid.io

DevGrid on LinkedIn

DevGrid on X

In this episode of Tech Council, Duncan Mapes and Jason Ehmke dig into the organizational cycle and how it shapes everything from decision-making to developer priorities. Whether your team is scaling fast, navigating a downturn, or recalibrating after a sprint-heavy phase, understanding the moment your company is in is critical to doing the right work at the right time.

This conversation moves beyond theory to give tactical insight into how engineers, managers, and technical leaders can adapt to different phases of organizational life. From maintaining operational stability to responding to layoffs, Jason and Duncan explore how visibility, communication, and standard-setting influence the success of both the team and the business.

Top Takeaways:

• Understanding the cycle your organization is in is crucial.
• Balancing wartime and peacetime strategies is essential for success.
• Feature delivery should be balanced with maintenance to avoid technical debt.
• Leaders must communicate the value of their teams effectively.
• Situational awareness is key in navigating organizational challenges.
• Business outcomes should drive technical decisions and priorities.
• Negotiation is a vital skill for technology leaders.
• Predictability in project management can be more valuable than velocity.
• Visibility of team contributions is important for organizational success.
• The future of coding will increasingly involve AI integration.

Connect with us:

Duncan Mapes

Jason Ehmke

DevGrid.io

DevGrid on LinkedIn

DevGrid on X

In this episode of Tech Council, Duncan Mapes and Jason Ehmke cut through the buzzwords to explore what it means to actually create value—beyond features, deliverables, and code. Drawing from deep experience in both startups and large-scale enterprises, they unpack how developer autonomy, organizational clarity, and curiosity in conversation all shape the outcomes we build.

From navigating enterprise bureaucracy to leveraging metrics with intention, Duncan and Jason discuss the hidden costs of unclear direction, the difference between shipping fast and shipping smart, and why thoughtful questions can often do more than rigid plans. They reflect on the tension between progress and technical debt, how to design for adaptability, and why understanding the why behind the work can make all the difference.

Top Takeaways:

• Value creation is essential in large enterprises.
• Direct communication fosters better team dynamics.
• Understanding the cost of work can shift perspectives.
• Owning the implementation is crucial for success.
• Balancing delivery and technical debt is necessary.
• Navigating bureaucracy can hinder progress in enterprises.
• Transitioning from startups to enterprises presents challenges.
• Authority must be balanced with buy-in for effective decision making.
• Effective processes are key to delivering value.
• Curiosity in team interactions leads to better outcomes. Curiosity can lead to better understanding in meetings.
• Asking questions can help others feel validated.
• Understanding the 'why' behind projects is crucial.
• Metrics should guide project success and accountability.
• AI tools can enhance productivity but require skilled oversight.
• Collaboration is essential for value creation in software development.
• Career advancement may require proactive networking and skill-building.
• It's important to assess the value of your role regularly.
• Taking initiative can lead to personal growth and recognition.
• Value creation should be a continuous conversation in teams.

Connect with us:

Duncan Mapes

Jason Ehmke

DevGrid.io

DevGrid on LinkedIn

DevGrid on X

In this episode of Tech Council, Duncan Mapes and Jason Ehmke break down what it actually looks like to make that decision in a real-world engineering org. No hype, no buzzwords—just decades of experience navigating cloud complexity at scale.

They dig into where serverless shines, why Kubernetes is still around (and still useful), and how to stop making decisions based on ego and start making them based on outcomes. Expect strong opinions, practical advice, and a few hard truths about infrastructure no one wants to admit.

Whether you're scaling a new product or managing legacy workloads, this episode will help you better understand the trade-offs—and how to pick the right tool for your actual goals.

🎧 New episodes drop weekly. Subscribe and join the conversation as we rethink what it means to lead in enterprise tech.

Top Takeaways:

• Serverless architecture offers operational simplicity and cost efficiency.
• Kubernetes requires deep expertise and can lead to complex management challenges.
• Trade-offs exist in every architectural decision, emphasizing the need for strategic goals.
• Collaboration with partner teams is crucial for the successful integration of serverless solutions.
• Batch processing can be effectively managed using AWS services like Batch and Fargate.
• Scaling strategies should consider both horizontal and vertical scaling options.
• Cold starts in serverless can impact performance and should be managed carefully.
• Tree shaking can reduce bundle size and improve cold start times.
• Spot instances can significantly reduce costs for background processing tasks.
• Understanding AWS limitations is essential for effective serverless architecture. State management is a critical consideration in serverless applications.
• Using external data stores for state management can enhance scalability.
• Vendor lock-in is a valid concern when using cloud services.
• Portability between serverless and containerized applications is achievable with proper architecture.
• Testing should focus on code rather than recreating the entire environment locally.
• Fargate simplifies container management by reducing complexity.
• Kubernetes can add unnecessary layers of complexity in cloud environments.
• Architecting for future growth is essential for stability and reliability.
• Planning is crucial to ensure the right tool is chosen for the job.

Connect with us:

Duncan Mapes

Jason Ehmke

DevGrid.io

DevGrid on LinkedIn

DevGrid on X

From stakeholder dynamics and reputation capital to the tension between moving fast and asking permission, this episode gets real about what it actually takes to drive meaningful progress in enterprise tech. Expect unscripted insights, battle-tested stories, and candid conversations drawn from years of experience navigating big orgs.

Whether you're building software, leading a team, or shaping strategy at scale, this episode will sharpen how you think and act as a tech leader.

🎧 New episodes drop every week.
Hit Subscribe and join the conversation as we challenge assumptions and reimagine what it means to lead in enterprise tech.

Top Takeaways:

• Resistance to change is normal — don't take it personally, but plan for it.
• Understand what stakeholders actually care about before you try to move the needle.
• Your ability to influence often starts with how well you’ve built trust and relationships.
• Strategy is great, but execution still depends on permission, timing, and communication.
• Adaptability isn't optional — it's the cost of doing business in large, fast-moving orgs.
• Reputation capital is real. Invest in it before you need to spend it.

Connect with us:

Duncan Mapes

Jason Ehmke

DevGrid.io

DevGrid on LinkedIn

DevGrid on X

If you’ve ever found yourself navigating the chaos of scaling software, debating design trade-offs, or rethinking how your org actually works, this podcast is for you.

Expect:

• Unfiltered stories from the trenches
• Tough takes on broken systems and outdated assumptions
• Smart discussions to challenge and sharpen how you lead and build
  
  

📅 New episodes drop weekly. Hit follow and join us as we reinvent enterprise tech — together.

🔗 Follow, subscribe, and connect with us on LinkedIn.

Connect with us:

Duncan Mapes

Jason Ehmke

DevGrid.io

DevGrid on LinkedIn

DevGrid on X