Software development is rarely straightforward. Even with experienced teams and the best intentions, projects still miss deadlines, fail to meet expectations, or get abandoned altogether. 

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

AI has moved from hype to habit, but at what cost? 

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

What kind of season is your organization in—wartime or peacetime?

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

What does value creation really look like in software development teams?

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

Enterprise tech loves a good debate—and this one’s been simmering for years: Should you go serverless or double down on Kubernetes?

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

Enterprise environments are complex — full of people, processes, politics, and change. In this first episode of Tech Council, Duncan Mapes and Jason Ehmke dig into the hard-earned lessons of leading change inside large tech organizations.

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

Welcome to Tech Council — the podcast where enterprise tech isn’t just buzzwords and boardroom talk. Hosts Duncan Mapes and Jason Ehmke cut through the noise with real, unscripted conversations about tech strategy, system architecture, and the everyday decisions that tech leaders face inside massive organizations.

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