1814120416
Tech Council

Advertise on podcast: Tech Council

Rating
★★★★★
5
from
9 reviews
This podcast has
39 episodes
Language
English
Publisher
Duncan Mapes
Explicit
No
Date created
2025/05/13
Latest episode
2026/09/07
Average duration
40 min.
Release period
23 days

Description

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, an experienced leader 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.

Unlock Tech Council podcast Email contact info,
Listeners & Audience details

Email contact information

Direct podcast contact details

Listeners

Audience numbers & engagement insights

Audience details

Podcast Insights

Podcast episodes

Check latest episodes from Tech Council podcast


The AI Software Factory | Episode 38
2026/09/07
Software has traditionally been built around a familiar model: identify a market, define a product, assemble a development team, build the application, and sell it to many customers. But what happens when AI dramatically lowers the cost of creating software? Could we move toward a world where software is built specifically for one customer but produced through a repeatable, scalable process? In this episode of Tech Council, Duncan Mapes talks with returning guest Jason McMunn about Oasis and the concept of an AI software factory. Rather than thinking about AI as simply another developer tool, they explore what happens when AI becomes part of an end-to-end system for producing software. The discussion covers everything from customer interviews and personas to journeys, AI model selection, infrastructure automation, cost management, deployment, and observability. One of the most interesting ideas is the concept of SaaS for a customer of one. Traditionally, software economics depend on spreading development costs across many customers. But AI could change that equation by making highly customized software economically viable. That creates a very different set of questions. How do you standardize the parts of development that can be standardized? Where does human judgment remain essential? When should a company use a powerful commercial AI model versus an open-source alternative? And how do you build infrastructure that can support an expanding number of AI-powered applications without allowing costs to spiral? The conversation also looks beyond development itself. An AI software factory touches the entire software lifecycle, from understanding what a customer actually needs to operating the finished system in production. For engineering leaders, technology executives, entrepreneurs, and anyone trying to understand where AI is taking software development, this episode offers a practical look at a model that could fundamentally change the economics of building software. Top Takeaways: Build for a customer of one, not a market segmentThe real moat is not code, it is contextSmall companies can be run with automation sooner than enterprises canThe product is the workflow around the model, not the model itselfVendor lock-in is becoming optionalAI is compressing decision cycles more than it is replacing laborA lot of AI disruption is really organizational slimming Connect with our Guest: Jason McMunn - https://www.linkedin.com/in/mcmunn  Connect with us: Duncan Mapes DevGrid.io DevGrid on LinkedIn DevGrid on X
AI Is Changing More Than How We Write Code | Episode 37
2026/08/20
The impact of AI on software development is often measured in lines of code, developer productivity, and the ability to automate repetitive tasks. But those measures only capture part of the transformation. In this episode of Tech Council, Duncan Mapes, Micah Minarik, and Bill Clerici examine the broader organizational implications of AI in software development. Their discussion explores three interconnected areas: software delivery, organizational structure, and technology careers. First, the episode considers how AI is affecting the software development lifecycle. As AI-assisted development changes how quickly teams can produce and modify software, organizations may need to reconsider assumptions about development workflows, productivity, and delivery. Second, AI creates organizational questions. If individual developers become more productive, do teams need to become smaller? Does the role of engineering management change? How should organizations balance increased development speed with quality, maintainability, security, and accountability? Finally, the conversation examines what these changes mean for people entering software development. The traditional career ladder has often relied on junior engineers gradually building experience through increasingly complex technical work. If AI can perform some of that work, organizations and individuals may need to rethink how technical expertise is developed. The discussion also puts today's AI transformation into historical context by looking at the evolution of Agile and modern software development practices. The central question isn't simply whether AI will change software development. It already is. The bigger question is how organizations and engineers choose to adapt. Top Takeaways: AI is changing the economics of software deliveryTransformation starts above the engineering teamCoding is no longer the bottleneckAgile was really about decision-making and flowAI is pushing software teams toward ‘AI-left’ workflowsCode review and validation are becoming harderThe future team is smaller but more specializedJudgment matters more than syntaxBuild vs. buy is becoming more strategicThe future belongs to adaptable learnersConnect with Our Guests: Micah Minarik - https://www.linkedin.com/in/micahminarik/  Bill Clerici - https://www.linkedin.com/in/bill-clerici-16a3194/  Connect with us: Duncan Mapes DevGrid.io DevGrid on LinkedIn DevGrid on X
How AI Is Disrupting Software Development in 2026 | Episode 36
2026/04/13
Everyone says AI is making software development easier. That’s only partially true. While AI accelerates the act of writing code, it also amplifies existing problems. Poor inputs produce poor outputs faster. Weak specifications lead to larger-scale inefficiencies. And teams that prioritize speed without clarity often end up with more rework, not less. This episode challenges the idea that AI is purely a productivity multiplier. Instead, it explores how AI is exposing deeper issues in how software is planned, validated, and maintained. AI is unlocking new capabilities, but it’s also introducing new complexity that teams must learn to manage. Top Takeaways: Garry Tan's public statements about his coding activity and the backlash he received for the perceived quality of his codeRelevance of lines of code as a metric for productivity, especially in the context of AI and automationShifting focus from code quantity to business outcomes and customer acquisition How coding practices have evolved with more capable browsers and computers, reducing the need for extreme optimizationImportance of aligning engineering efforts with business goals and outcomesTrend towards open-source models and the challenges of maintaining proprietary advantagesCost of AI models and the economic implications of using different modelsStrategies for managing technical debt through automation and the balance between shipping quickly and maintaining quality Connect with us: Duncan Mapes DevGrid.io DevGrid on LinkedIn DevGrid on X
Why Enterprises Need DevGrid’s MCP Server | Episode 35
2026/03/09
The future of enterprise development will be defined by systems that can adapt, analyze, and respond in real time. That future requires infrastructure designed for AI. In this episode, Duncan Mapes and Jason Ehmke explore how DevGrid is building that infrastructure through its MCP server. The conversation examines how DevGrid connects enterprise software ecosystems through an AI-native graph that allows systems to share context, detect issues, and surface insights across development and operations. Key topics include secure authentication models, asynchronous data processing, vulnerability detection, and strategies for reducing friction across enterprise engineering teams. As organizations continue integrating AI into their workflows, platforms like DevGrid will play an increasingly critical role in enabling secure, scalable, and intelligent enterprise development environments. Top Takeaways: Top-down automation is less about what you can do and more about what you should prevent.Organizations that automate vulnerability patching or compliance checks without addressing foundational process flaws see only short-term gains; systems designed to prevent these issues inherently scale better.The power of hints and context over APIs transforms complex data into actionable intelligence.Embedding guidance about data connections in MCP definitions enables agents to generate comprehensive security posture reports in minutes, instead of months of integration work.Frontloading data integrity and organizational knowledge shortcuts future complexity.Most organizations balk at cleaning or standardizing data upfront, but doing so creates a resilient backbone for automation.The future of enterprise AI relies on self-sufficient, organizationally aware agents.Systems that can autonomously build, navigate, and connect their own data pipelines will unlock scalable intelligence that adapts as organizations evolve.Simplifying complexity by integrating seamlessly and reducing friction transforms organizational agility.Reducing informational friction accelerates decision cycles and shifts human focus toward higher-value creative and strategic work.Privacy and security guardrails are essential to enable AI while safeguarding sensitive data.Without organizational constraints, AI adoption risks undermining security and eroding customer trust, nullifying productivity gains.Inclusivity in tooling is a strategic differentiator.Offering multiple modalities—CLI, MCP, APIs—ensures diverse user personas and workflows are supported, increasing overall adoption and impact.Connect with us: Duncan Mapes DevGrid.io DevGrid on LinkedIn DevGrid on X
AI Adoption at Scale: What Leaders Must Get Right | Episode 34
2026/03/02
AI adoption is accelerating across industries, but scaling AI successfully remains one of the hardest leadership challenges today. 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 DevGrid.io DevGrid on LinkedIn DevGrid on X
GitHub Codespaces, Codex, and the Future of Software Development | Episode 33
2026/02/24
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 DevGrid.io DevGrid on LinkedIn DevGrid on X
How to Use Metrics Without Killing Engineering Culture | Episode 32
2026/02/02
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 DevGrid.io DevGrid on LinkedIn DevGrid on X
Why AI Changes How We Build Software, Not Just How Fast | Episode 31
2026/01/26
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 DevGrid.io DevGrid on LinkedIn DevGrid on X
A Practical Guide to Observability in Enterprise Systems | Episode 30
2025/12/08
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 DevGrid.io DevGrid on LinkedIn DevGrid on X
Is AI the Developer’s New Co-Pilot or Competitor? | Episode 29
2025/12/01
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 DevGrid.io DevGrid on LinkedIn DevGrid on X
Engineering Leaders vs Tech Debt: A Realistic Conversation | Episode 28
2025/11/27
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 DevGrid.io DevGrid on LinkedIn DevGrid on X
Platform Engineering Playbook: Autonomy + Standards | Episode 27
2025/11/17
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 DevGrid.io DevGrid on LinkedIn DevGrid on X
How to Build Resilient Systems in Complex Enterprises | Episode 26
2025/11/10
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 DevGrid.io DevGrid on LinkedIn DevGrid on X
Stop Wasting Money on Conferences — Do This Instead | Episode 25
2025/11/03
Every year, companies spend thousands sending their engineers to conferences.  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 DevGrid.io DevGrid on LinkedIn DevGrid on X
Top Book Recommendations for Tech Professionals and Engineering Managers | Episode 24
2025/10/20
Every great leader has a few books that quietly shaped how they lead. 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 AIExtreme Ownership: How U.S. Navy SEALs Lead and WinThe Dichotomy of LeadershipRadical CandorTurn the Ship AroundPHP/MySQL Programming for the Absolute BeginnerThe Innovators: How a Group of Hackers, Geniuses, and Geeks Created the Digital RevolutionJohn Adams by David McCullough1776 by David McCulloughThe Daily Stoic: 366 Meditations on Wisdom, Perseverance, and the Art of LivingGood to Great: A Study of Management Strategies of Companies with Lasting GrowthHigh Output Management by Andy Grove12 Rules for Life: An Antidote to ChaosThe Hard Thing About Hard ThingsWhat You Do Is Who You Are: How to Create Your Business CultureRework by Jason Fried and DHHHigh Growth HandbookThree-Body ProblemThe AlchemistConnect with us: Duncan Mapes DevGrid.io DevGrid on LinkedIn DevGrid on X

Podcast reviews

Read Tech Council podcast reviews


5 out of 5
9 reviews
★★★★★
Considerthis24 2025/09/14
Worth a listen
Interesting takes on tech leadership, team dynamics and culture building
★★★★★
Nomad387 2025/05/27
Fresh take
I highly recommend devoting some time to hear the perspective of these young tech leaders. Your time will be well spent.
check all reviews on apple podcasts

Podcast sponsorship advertising

Start advertising on Tech Council relevant audience podcasts


What do you want to promote?