Tech Council

Duncan Mapes, Jason Ehmke
  • 5.0 (9)
  • 科技
  • 一周一更

Are you a tech leader, architect, or engineer navigating the intricacies of building within the enterprise? Tech Council delivers the strategies and insights you need to succeed. Hosted by Duncan Mapes and Jason Ehmke, experienced leaders from the startup and banking tech arenas, this podcast dives deep into technology strategy and enterprise dynamics. Learn how to drive innovation, understand the bigger picture, and build impactful solutions from the ground up. Subscribe to Tech Council and gain the knowledge to shape the future of your enterprise, no matter your role.

  1. GitHub Codespaces, Codex, and the Future of Software Development | Episode 33

    11小时前

    GitHub Codespaces, Codex, and the Future of Software Development | Episode 33

    Software development used to begin with local setup headaches, dependency mismatches, and “it works on my machine.” Now, the environment spins up in the cloud. The editor follows you. The assistant writes alongside you. 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

    35 分钟
  2. How to Use Metrics Without Killing Engineering Culture | Episode 32

    2月2日

    How to Use Metrics Without Killing Engineering Culture | Episode 32

    Metrics influence outcomes by shaping incentives. 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

    35 分钟
  3. Why AI Changes How We Build Software, Not Just How Fast | Episode 31

    1月26日

    Why AI Changes How We Build Software, Not Just How Fast | Episode 31

    AI has changed the conversation in software development, but not in the way most people expected. 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

    46 分钟
  4. A Practical Guide to Observability in Enterprise Systems | Episode 30

    2025/12/08

    A Practical Guide to Observability in Enterprise Systems | Episode 30

    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

    45 分钟
  5. Is AI the Developer’s New Co-Pilot or Competitor? | Episode 29

    2025/12/01

    Is AI the Developer’s New Co-Pilot or Competitor? | Episode 29

    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

    58 分钟
  6. Engineering Leaders vs Tech Debt: A Realistic Conversation | Episode 28

    2025/11/27

    Engineering Leaders vs Tech Debt: A Realistic Conversation | Episode 28

    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

    39 分钟
  7. Platform Engineering Playbook: Autonomy + Standards | Episode 27

    2025/11/17

    Platform Engineering Playbook: Autonomy + Standards | Episode 27

    Most engineering failures can be traced back to two weak points: unclear standards or excessive autonomy. This episode presents a structured examination of how platform engineering resolves this tension to create resilient systems. 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

    36 分钟
  8. How to Build Resilient Systems in Complex Enterprises | Episode 26

    2025/11/10

    How to Build Resilient Systems in Complex Enterprises | Episode 26

    When systems fail, it’s rarely because no one saw it coming. It’s because no one planned for it.  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

    35 分钟
查看全部 34 集

5
共 5 分
9 个评分

关于

Are you a tech leader, architect, or engineer navigating the intricacies of building within the enterprise? Tech Council delivers the strategies and insights you need to succeed. Hosted by Duncan Mapes and Jason Ehmke, experienced leaders from the startup and banking tech arenas, this podcast dives deep into technology strategy and enterprise dynamics. Learn how to drive innovation, understand the bigger picture, and build impactful solutions from the ground up. Subscribe to Tech Council and gain the knowledge to shape the future of your enterprise, no matter your role.

信息

  • 创作者
    Duncan Mapes, Jason Ehmke
  • 活跃年份
    2025年 - 2026年
  • 单集
    34
  • 分级
    儿童适宜
  • 版权
    © 2026 DevGrid, Inc.
  • 节目网站
    Tech Council