The AWS Developers Podcast

Brenn reached out via LinkedIn to share his experience with AI-driven software development and his new book, The Delivery Gap. Romain read a copy during a business trip and found it deeply aligned with how he guides customers through their AI transformation — and discovered a few new angles worth exploring, including a convergence on cost tracking that maps directly to Amazon's internal cost to serve software metric. In this episode, Brenn — Senior Manager at Delivery Hero (one of the world's largest food delivery companies, operating in 65 countries) — breaks down why most companies fail to see returns from AI coding tools despite individual developers feeling more productive. The core insight: generating code 10x faster means nothing if your verification infrastructure can't keep up. You're just driving 10x faster into a wall. Key takeaways: • The 96% waste problem — If you generate 100 PRs and only 4 make it to production and stay there, the other 96 are waste. Measuring PRs created is meaningless; measure what ships and survives. • The verification triangle — Your delivery speed is governed by verification infrastructure, not generation speed. Banks can't release faster than they can audit. Find your constraint — that's where investment should go, not more coding tools. • Cost per accepted change — Total token costs + human time for all PRs, divided by changes that reach production and stay there. This single metric reveals where waste accumulates and aligns with Amazon's cost to serve software model. • Specs as alignment documents, not source code — Specs align humans and AI on intent and why, not for deterministic code generation. The same spec produces different software each time. Focus on why; let the AI document the what. • Keep agents small and focused — Every MCP server re-injected into context is a cost multiplier per turn. The smallest, tightest, most precisely aimed agent outperforms a Swiss Army knife agent on both cost and accuracy. Apply cost per accepted action to measure agentic ROI.With Brenn, Senior Manager at Delivery Hero & Author of The Delivery GapThe Delivery Gap — Brenn's BookBusiness Value of Developer Experience Improvements: Amazon's 15.9% BreakthroughDelivery Hero — Global Food Delivery PlatformAWS DevOps AgentKiro — AI-Powered Development EnvironmentThe Phoenix Project — Gene Kim, Kevin Behr, George Spafford (Book Recommendation)The DevOps

Most MCP tools today return text. But what if your agent could render a chart, a form, or a full dashboard right inside the chat? That's what MCP apps do — and they're already live on ChatGPT, Claude, and Amazon Quick. Romain sits down with Luigi Pederzani, co-founder of Manufact (the company behind mcp-use, 10K+ GitHub stars), to explore MCP apps — the first official extension of the MCP protocol that lets servers return interactive UI inside AI chat interfaces. Key takeaways: • What MCP apps are — Standard MCP returns text and actions; MCP apps let a server send back a piece of interface (a form, a chart, a dashboard) that renders right inside the chat. It became the first official extension of the protocol this year, growing out of MCP-UI. • UI drives retention — Amplitude saw 2x retention for users exposed to a chart-rendering MCP app versus text-only responses. UI lets software products stay experiences, not just systems of record. • AI apps are the new browsers — Extending Paul Graham's thesis, every software product will be rendered inside AI chats, pulling data and structure from different sources the way we switch tabs today. • Building with mcp-use — Reuse existing React components with minimal changes; the useMcp hook bridges tool arguments (filled by the agent) into component props. The server stays a normal MCP server, the client is the host, and the view runs in a sandboxed iframe. • Interactivity and safety — Iframes are battle-tested and the model-to-server communication is standardized. UI can send events back to the model, so clicking a chart element can trigger another tool call in the chat. OAuth is now standard for production MCP servers. • Tool design best practices — Don't wrap OpenAPI specs directly as MCP. APIs are granular and atomic; MCP tools should serve a task end-to-end so agents don't get confused on ordering. Limit the number of tools exposed; progressive disclosure is now handled by the major clients. • MCP as the A2A protocol — A2A never really landed, and MCP is becoming the agent-to-agent protocol, with companies embedding an agent as a single tool whose main argument is a prompt. • Getting to production — Start with a plain MCP server, then add UI. Skills are now part of the product, and Manufact focuses on agent-readiness of the SDK, testing across clients, deployment, auth, observability (OTEL), and per-tool analytics. • AWS integration — mcp-use can sit on the server side while AgentCore Gateway sits in front to handle enterprise concerns like auth policies and routing. • What's next — Exposing skills directly from MCP servers (rather than decoupled files), and the next stateless-by-default release of the protocol.With Luigi Pederzani, Co-founder of Manufactmcp-use SDK (GitHub)Manufact CloudOra.ai — Agent Re

John Sexton and Aaron Tummon from Genesys join the show to share hard-won lessons from building and operating Cloud Copilot — an agentic AI layer serving 2 million users across 21+ AWS regions. Genesys powers customer experience for brands like Virgin Atlantic, Vodafone, and HSBC, and their copilot helps admins, supervisors, and agents work more efficiently through natural language. We cover the migration from Bedrock Inline Agents to Strands Agents, multi-agent orchestration with agents-as-tools, context management strategies, cost optimization, and the testing discipline required to keep agentic systems stable at scale. The 5 lessons: 1. Pick a framework that scales with you — Bedrock Inline Agents worked for 12–15 tools but became exponentially flakier beyond that. Strands Agents gave sensible defaults and room to grow without pinch points. 2. Separate orchestration from domain logic — Agents-as-tools creates a clean line between the orchestrator and sub-agents. You can pull functionality in and out per persona without destabilizing the system, and domain teams own their sub-agents independently. 3. Manage context aggressively — Long context windows for the orchestrator, stateless sub-agents, summarizing and sliding-window conversation managers, and strict control over what tools return. Every extra token in context degrades quality and increases cost. 4. Make prompt caching non-negotiable — System prompts, tool definitions, and conversation history rarely change between invocations. Enabling prompt caching delivered significant cost reductions with almost no effort. 5. Test relentlessly because prompt drift is invisible — One prompt change is never a breaking change; five accumulated changes are. A dedicated weekly Sentinel role investigates failures, and full test suites run on every single change.With Aaron Tummon, Software Engineer at Genesys ; With John Sexton, Engineering Manager at GenesysGenesys Cloud — Customer Experience PlatformStrands Agents SDK — Open-Source AI Agent FrameworkStrands Agents — Agent Evaluation SDKAmazon Bedrock — Prompt CachingAWS Lambda — Serverless ComputeAaron Tummon on LinkedInJohn Sexton on LinkedInThinking, Fast and Slow — Daniel Kahneman (Aaron's Book Pick)<a href="https://www.amazon.com/Mythos-Retelling-M

Tipu Qureshi — Senior Principal Engineer at AWS — joins the show fresh from the AWS Summit NYC 2026 announcements to break down how DevOps Agent is changing the way teams handle operations and release management. After 14 years across EC2, Elastic Load Balancing, AWS Support, and Networking, Tipu moved into the Agentic AI organization to build the DevOps Agent and contribute to Agent Core. We explore how the agent investigates incidents autonomously, integrates with your IDE through Kiro and Claude, and validates code changes in sandboxes before they hit production. Key takeaways: • Reactive and proactive — DevOps Agent triggers on alarms and ServiceNow incidents, but Custom Agents now run on schedules to detect anomalies before they become outages. • Context is king — Customers who integrate their Git repos, metrics, and logs get significantly more accurate root causes. Native GitHub/GitHub Enterprise support plus bring-your-own MCP for custom observability. • IDE integration — Kiro powers and Claude plugins give on-call engineers the full agentic loop: investigate, root-cause, fix, and validate without leaving the editor. • Release management — The new readiness review inspects pipeline stages, past deployment failures, and integration tests to catch issues before merge, while sandbox testing validates proposed fixes. • Multi-cloud support — Native Azure integration via IDC with RBAC, plus bring-your-own MCP and A2A for on-premises and other clouds. • Custom agents and skills — Bring domain-specific knowledge (SAP HANA failure modes, proprietary tooling) via skills from GitHub repos or the assets API, with MCP tools for full customization. • A2A bi-directional — DevOps Agent can be engaged by other agents and can reach out to other agents, enabling multi-agent escalation workflows. • Transparency — Every tool call, skill invocation, and reasoning step is captured in a journal visible to customers via API and the operator console. • What's next — Deeper integrations, automated mitigation actions with safety policies, time-bound rules for agent escalation, and script execution coming soon.With Tipu Qureshi, Senior Principal Engineer at AWSAWS DevOps AgentAWS DevOps Agent — Release Management (Blog)AWS Context — Context Intelligence for Data and AI Agents at ScaleAWS Summit NYC 2026 AnnouncementsTipu Qureshi on LinkedIn

Davide de Sio built KiroGraph as a personal side project to stop his AI agent from burning through credits just searching files. It turned into a community-driven, open-source MCP server that gives Kiro (and other AI agents) a semantic map of your codebase — reducing token usage by up to 80%. We dive into the architecture, security, and modules, how everything runs 100% locally, and how the AWS Community shaped the project's roadmap. Key takeaways: • Code graphs vs. grep — Tree-sitter and AST-based graph generation give AI agents a smarter navigation model, eliminating wasteful file searches. • Architecture module — Detects patterns and prevents drift by validating your codebase against its own structural rules. • Security module — Finds exposed secrets and vulnerabilities by tracing the call graph, born from an AWS Summit Milano talk. • Watchman module — Auto-generates Kiro skills from repetitive patterns, building persistent memory for your agent. • 100% local execution — Embeddings run with Nomic and summarization with Gemma 3, no data leaves your machine. • Spec-driven development — Davide built KiroGraph with Kiro itself, using specs to drive the entire development lifecycle. • Portability — Commit the graph to Git and share it across machines and team members. • Community-driven roadmap — CI/CD integration, validation hooks, and container deployment are next.With Davide de Sio, Head of Software Engineering at ElevaKiroGraph — Open-Source Code Knowledge Graph (GitHub)Kiro IDE — AI-Powered Development EnvironmentTree-sitter — Incremental Parsing SystemNomic Embed — Local Text EmbeddingsAWS Community Builders ProgramDavide's Blog — Building KiroGraphKiroGraph-Sec — From AWS Summit Milano to a Cybersecurity Feature

An honest, no-filter conversation about where developers actually stand with AI today. Warren Parad — CTO at Authress, AWS Community Builder, and host of Adventures in DevOps — brings a contrarian 'LLM realist' perspective grounded in daily use, while Romain nuances with enterprise customer observations and the data behind the hype. Together they explore why 93% of devs feel productive but only 4% of enterprises see results — and what separates those who benefit from those who don't. Key takeaways: • AI is a multiplier, not a magic wand — The DORA 2025 report confirms AI amplifies your existing processes. If those processes are broken, AI makes them worse faster. • Spec-driven development beats instant responses — Long-form spec-based workflows let you disengage and return, avoiding the 'TikTok-ification' of software engineering where you're always context-switching. • Sub-agent opacity is a real problem — When agents delegate to sub-agents, you lose visibility into why decisions were made. Custom agents with explicit permissions and tool access help contain the blast radius. • Greenfield work is where LLMs struggle most — LLMs excel at refactoring and targeted feature changes where engineers already know the implementation. Open-ended new projects lead to scope creep and unfinished work. • Critical thinking erosion is measurable — Microsoft/Carnegie Mellon research shows knowledge workers self-report reduced cognitive effort when using AI. The long-term implications for engineering judgment are concerning. • Governance first, tools second — Enterprises that succeed with AI spend the first month on governance, AI registries, and codifying best practices before enabling tools across teams. • Software development was never the bottleneck — Unless AI solves handoffs, knowledge management, and organizational alignment, faster coding alone won't compress your roadmap.With Warren Parad, CTO at Authress & Host of Adventures in DevOpsAuthress — Login and Access Control for B2BAdventures in DevOps PodcastWarren Parad — Personal SiteDORA 2025 ReportMicrosoft/CMU — The Impact of Generative AI on Critical ThinkingForgejo — Self-Hosted Git with FederationRig — Rust AI FrameworkAWS Kiro — AI-Powered Development EnvironmentAWS Strands Agents SDK<a href=

Anthropic deprecated Sonnet 3.5. Some of Xelix's pipelines migrated smoothly. Others broke — and customers noticed within hours. What separated the two? Evaluation. Paul Solomon and James Price Farr have spent 5+ years building AI systems that process millions of invoices for enterprise customers. In this episode, they share the evaluation-first framework that now saves them every time a model changes, an orchestration layer fails, or an agent picks the wrong tool. Key takeaways: • Evaluation-first, not evaluation-after — Retrofitting evaluation on an agent already in production is painful. Build your eval pipeline before you build the agent. • Monitor tool calls, not just outputs — If the agent isn't selecting the right tools, nothing downstream will be correct. Tool-call monitoring is your leading indicator. • 3 tiers of automation — Not everything needs an agent. Rules-based → single LLM call → agentic system. Pick the simplest tier that solves the problem. • Extended thinking tames token explosion — After migrating to newer, more verbose models, enabling extended thinking (with a budget) moved reasoning out of expensive output tokens and brought costs back under control. • Human-in-the-loop by default — Start with human review on every output, then earn trust toward touchless automation as customers gain confidence. • Pragmatism wins — Use whatever technology works best for the problem. Not every feature needs an LLM. Recorded live at AWS Summit London.With Paul Solomon, Head of AI Engineering at Xelix ; With James Price Farr, AI Engineering Team Lead at XelixXelix — AI-Powered Accounts Payable PlatformStrands Agents SDK — Open SourceAmazon Bedrock — Managed LLM InferenceAmazon Bedrock AgentCoreStrands Agents — Steering Files and Hooks for Agent Accuracy (Claire Liguori)Amazon SageMakerFast.ai — Practical Deep Learning Courses (Book Recommendation)The Fifth Risk — Michael Lewis (Book Recommendation)Neurosymbolic AI and Automated Reasoning on AWSKiro — AI-Powered Development Environment

How do you give 120+ engineers AI coding agents — and NOT break production? Ryan Cormack, Principal Engineer at Motorway and AWS Community Builder (recognized as a Renaissance Developer by Werner Vogels), shares the exact system his team uses to ship 250% more deployments while keeping quality high. In this episode, we break down the 5 quality gates that let Motorway's engineering teams move faster without sacrificing reliability: spec-driven planning to catch design issues before a single line of code is written, AI-assisted code review to verify code matches the plan, deterministic tests (unit + integration) as an automated safety net at the boundary, cyclomatic complexity checks to keep code maintainable, and human review as the final gate that stays human. Ryan explains how cross-functional DevOps teams — organized like Amazon's two-pizza teams with full end-to-end ownership — enable faster AI adoption. He walks through running parallel agents to explore multiple solutions simultaneously, building custom tools on top of ACP (Agent Client Protocol), and sharing agent configurations across 120+ engineers via a Git + S3 pipeline. The conversation also covers the Renaissance Developer mindset that Werner Vogels introduced at re:Invent 2024: curiosity, ownership, systems thinking, communication, and experimentation. Ryan shares how Motorway embraces this philosophy by encouraging engineers to build their own tools, experiment with new technologies in parallel, and focus engineering time on design and planning rather than writing code. Whether you are scaling AI coding assistants across a large engineering org, building quality gates for agentic development, or rethinking how your team ceremonies and processes should evolve in the age of AI, this episode offers a practitioner's blueprint from someone delivering measurable results: 250% more deployments, 4x engineering throughput, and no uptick in production incidents.With Ryan Cormack, Principal Engineer at MotorwayRyan Cormack — Personal WebsiteRyan Cormack — MediumRyan Cormack — GitHubACP and Strands — An Open Source Match (Ryan Cormack)Motorway — UK's Fastest Growing Used Car MarketplaceWerner Vogels — The Renaissance Developer (re:Invent 2024)The Phoenix Project — Gene Kim, Kevin Behr, George SpaffordThe Unicorn Project — Gene KimThe Architect Elevator — Gregor

You're using Copilot. Maybe you've tried Cursor or Claude Code. But what if that's already the tail end of the AI wave? In this episode, Romain sits down with Christian Weichel, CTO and co-founder of Ona (formerly Gitpod), to explore 'dark factories' — autonomous AI agents that pick up work, write code, open PRs, and ship fixes while you sleep. No laptop required. Chris shares how his team of ~20 engineers went from 450 open pull requests to a streamlined, auto-approving system — all while staying SOC 2 compliant. He walks through the 3 stages of AI in the SDLC (better autocomplete → software conductor → background agents), the governance model that makes background agents safe for regulated enterprises, and why terminal-based coding agents' days are numbered. The conversation covers the risk ladder approach to auto-approving PRs, how isolated cloud development environments provide the security and autonomy agents need to operate safely, multi-agent code review with meta-reflection, and why accelerating implementation without accelerating review creates a bottleneck that breaks teams. Christian also shares his perspective on architecture governance, cognitive load management when running parallel agents, and why the future of IDEs will look different but won't disappear. Whether you are adopting AI coding assistants, building governance frameworks for agentic development, or exploring how background agents can automate your SDLC end-to-end, this episode offers a practitioner's view from someone who's been shipping with autonomous agents in production.With Christian Weichel, CTO & Co-founder, Ona (formerly Gitpod)Christian Weichel — Personal SiteOna — Background Agents for Software DevelopmentThe Phoenix Project — Gene Kim, Kevin Behr, George SpaffordThe Unicorn Project — Gene KimThe Origins of Efficiency — Matt Might (Book Recommendation)The Rise of the Software ConductorThe Software Conductor's HandbookLM Studio — Run Local LLMsOllama — Run Local Models

What happens when a data scientist builds a generative AI proof of concept — and it scales to 700,000 articles and 4 billion page views? Recorded live at AWS Summit London, Romain is joined by Lewis James, Senior Data Scientist at Reach PLC — the UK's largest commercial publisher with over 120 brands including the Mirror, the Express, and OK Magazine. Lewis shares the full journey from GPT-2 experiments to a production AI publishing platform called Launchpad that now assists with 20–30% of the portfolio's daily article output. We explore how the team earned journalist trust by focusing on mundane tasks first, how they built multi-model pipelines with quotation fidelity checks to avoid misquoting, and why working backwards from users — not pushing technology — drove adoption where others failed. The conversation covers the technical evolution from prompt engineering to fine-tuning, model distillation, and agentic workflows built with the Strands Agents SDK running on Amazon Bedrock AgentCore. Lewis also introduces the concept of 'vibe publishing' — giving journalists a chatbot interface with more creative freedom — and discusses how evaluation strategies differ when you're measuring editorial tonality versus factual accuracy. Whether you are building AI-assisted content pipelines, navigating enterprise AI adoption, or thinking about how to earn user trust for generative AI tools, this episode offers a rare look at what three years of production generative AI looks like at massive scale.With Lewis James, Senior Data Scientist at Reach PLCReach PLC — UK's Largest Commercial PublisherAmazon Bedrock AgentCoreStrands Agents SDK — Open SourceAmazon Bedrock Model DistillationAmazon Bedrock LLM-as-a-Judge EvaluationsThe 4 Stages of Psychological Safety — Timothy R. ClarkWerner Vogels — The Renaissance Developer (re:Invent 2025)

AI agents are transforming how we write, test, and ship software — but are they actually improving the developer experience? Recorded live at AWS Summit London, Romain is joined by Tomasz Ptak — AWS AI Hero and Senior Engineer at Duco — for a candid conversation about developer experience friction in the age of AI agents. We explore what happens when teams adopt AI coding assistants without thinking about the developer workflow holistically — from context overload and broken feedback loops to the hidden costs of AI-generated code that nobody reviewed. The conversation draws on Werner Vogels' 'Renaissance Developer' keynote from re:Invent 2025, where he argued that developers need to be broader thinkers, not just faster coders. Tomasz shares his perspective on what great developer experience looks like when AI agents are part of the picture, how the AWS AI League is helping developers build real agent skills through gamified competition, and why critical thinking about AI adoption matters more than blind acceleration. We also discuss psychological safety in engineering teams — drawing on Brené Brown's work on vulnerability — and why the best developer tools are the ones you barely notice, as Don Norman taught us decades ago. Whether you are building AI agents, designing internal developer platforms, or evaluating how AI tools fit into your team's workflow, this conversation offers a grounded, human-centered perspective on reducing friction and improving developer experience in 2026 and beyond.With Tomasz Ptak, AWS AI Hero, Senior Engineer at DucoAWS AI League — Gamified AI CompetitionAWS AI League 2026 Championship — BuilderCenterTomasz Ptak's Blog — mediocr.isFrictionless — Nicole Forsgren & Abi NodaThink Again — Adam GrantRising Strong — Brené BrownThe Design of Everyday Things — Don NormanTomasz Ptak — AWS Machine Learning Hero

Recorded live at AWS Summit London, Matheus Guimaraes — Senior Developer Advocate at AWS and microservices specialist with over 25 years in tech — joins Romain to explore how agentic AI is reshaping the way we think about distributed systems architecture. From Martin Fowler's 2014 definition to agentic microservices in 2026, Matheus unpacks why the same distributed systems patterns — single responsibility, context dilution, failure modes — keep resurfacing in every new wave of architecture. The conversation covers the monolith vs. microservices debate as a deliberate architectural choice rather than accidental spaghetti, modular monoliths with Spring Modulith, and how AI coding assistants like Kiro are changing the architect's role from writing boilerplate to making higher-order design decisions. Matheus introduces his concepts of 'smart APIs,' 'monolithic agentic microservices,' and 'specialized agentic microservices' — and explains his talk 'Is It Agent?' on when to reach for agents vs. traditional applications. We dig into the serverless primitives purpose-built for agentic workloads: Amazon Bedrock AgentCore Runtime for long-running agent processes, AWS Lambda Durable Functions for multi-step workflows, and the AWS DevOps Agent for autonomous incident response. We also explore integration patterns with MCP and Google's A2A protocol, the 'lost in the middle' problem with context dilution, and why critical thinking about AI adoption matters more than ever. Whether you are decomposing a monolith or designing your first agentic system, this conversation connects the dots between a decade of microservices wisdom and the agentic future.With Matheus Guimaraes, Senior Developer Advocate, AWSMartin Fowler — Microservices (2014)Spring ModulithAmazon Bedrock AgentCoreAWS Lambda Durable FunctionsAWS DevOps AgentModel Context Protocol (MCP)Agent-to-Agent Protocol (A2A) — GoogleKiro — AI-Powered Development EnvironmentBuilding Microservices — Sam NewmanMonolith to Microservices — Sam NewmanThe Art of Game Design: A Book of Lenses — J

CyberArk's support team was drowning in logs. With 40+ products across SaaS and self-hosted environments, each generating logs in different formats, support engineers were spending days just preparing data before they could even start investigating a customer issue. Complex cases took up to 15 days to resolve. Moshiko Ben Abu, a Software Engineer at CyberArk — now part of Palo Alto Networks — built an AI-powered system that changed all of that. In this episode, he walks us through the full architecture: replacing manual regex parsers with AI-generated grok patterns using Amazon Bedrock and Claude, storing structured data in Apache Iceberg tables via PyIceberg with automatic schema evolution, and querying everything through Athena — all while keeping PII masked and data encrypted in S3. But the real breakthrough came with agents. Moshiko describes how he moved from single-product Bedrock agents to a swarm of specialized AI agents built with the Strands framework, where agents investigating product A can autonomously call agents for product B and C to trace root causes across the entire stack. Cases that took 15 days now resolve in hours. Simple cases drop from 4-6 hours to 15-30 minutes. Engineers handle 4x more cases per day. We also dig into the security layer — Cedar policies and Amazon Verified Permissions for agent authorization, the identity integration with AgentCore, and what's coming next: S3 Tables, AgentCore in production, and cross-platform agent collaboration with Palo Alto. Moshiko's advice for developers getting started? Learn IAM first, then compute, then databases — and write everything in CDK.With Moshiko Ben Abu, Software Engineer, CyberArk (a Palo Alto Networks company)How CyberArk Uses Apache Iceberg and Amazon Bedrock to Deliver up to 4x Support Productivity — AWS BlogApache Iceberg on AWSPyIceberg — Apache Iceberg Python LibraryAmazon Bedrock AgentCoreStrands Agents — Open-Source Agentic FrameworkCedar Policy LanguageAmazon Verified PermissionsAmazon S3 TablesKiro — AI-Powered Development EnvironmentAWS CDK (Cloud Development Kit)Ran the Builder — Ran Isenberg's Serverless Blog<a href="https://aws.amazon.com/deve

Simon Martinelli is a Java Champion, Vaadin Champion, and Oracle ACE Pro with over three decades of experience building enterprise software. In this episode, he introduces the AI Unified Process (AIUP) — a methodology he created that combines the rigor of the Rational Unified Process with modern AI-assisted development, and makes a compelling case for why specifications, not code, should be the source of truth. We explore the difference between system use cases and user stories, and why use cases — with their actors, preconditions, main flows, alternative flows, and business rules — give AI agents far better structure to generate working code. Simon walks through the four phases of AIUP: Inception, Elaboration, Construction, and Transition, showing how specs, code, and tests evolve together iteratively while staying in sync. On the architecture side, Simon advocates for Self-Contained Systems over microservices — vertical slices that include UI, backend, and database together, reducing cognitive load for both developers and AI agents. His tech stack of choice is Vaadin for full-stack Java UI, jOOQ for type-safe explicit SQL, and Spring Boot as the application framework — a combination he argues is uniquely well-suited for AI-driven development because it keeps everything in one language with no hidden behavior. We also dig into testing strategies with Karibu Testing for browserless Vaadin tests and Playwright for end-to-end coverage, how teams of two working on bounded contexts with trunk-based development are shipping faster than ever, and why the era of AI is bringing back the Renaissance developer — the generalist who understands the full stack from business requirements to production deployment.With Simon Martinelli, Java Champion, Vaadin Champion, Oracle ACE Pro — Software Architect & TrainerAI Unified Process (AIUP)Spec-Driven Development with AI — Simon MartinelliWhy Vaadin Is Perfect for AI-Driven DevelopmentWhy Vaadin and jOOQ Are a Natural Fit for AI-Driven DevelopmentBrowserless Testing of Vaadin Applications with Karibu TestingGoodbye Microservices, Hello Self-Contained Systems — Simon MartinelliSelf-Contained Systems ArchitectureVaadin FrameworkjOOQ — Type-Safe SQL in

What if you could combine the creative power of generative AI with the mathematical certainty of formal verification? In this episode, Danilo Poccia — Principal Developer Advocate at AWS — breaks down automated reasoning, a field of AI that has been quietly powering critical AWS services for years and is now becoming essential for production AI systems. We explore why generative AI alone is not enough for high-stakes applications, and how automated reasoning provides mathematical proof — not probabilistic guesses — that your AI agents are following the rules. Danilo traces the roots of automated reasoning back to the 'symbolist' branch of AI, explains how AWS has used it internally for years to verify S3 bucket policies, encryption algorithms, and network configurations, and shows how it now converges with neural networks in what researchers call neurosymbolic AI. On the practical side, we dig into Amazon Bedrock Guardrails with Automated Reasoning checks — the first and only generative AI safeguard that uses formal logic to verify response accuracy. Danilo walks through how developers can use policy verification for agentic systems and tool access control with Cedar, and how AgentCore Gateway fits into the picture for managing MCP-based tool interactions at scale. We also cover the open source landscape: Dafny for verification-aware programming, Lean as a theorem prover, Prolog for logic programming, and the growing ecosystem of MCP servers that bring these capabilities into everyday development workflows. Whether you are building AI agents for production or just curious about what comes after prompt engineering, this conversation will change how you think about AI reliability.With Danilo Poccia, Principal Developer Advocate, AWS Developer RelationsAmazon Bedrock Guardrails — Automated Reasoning ChecksAutomated Reasoning Checks Rewriting Chatbot — Reference ImplementationAmazon Bedrock Samples — Responsible AI on GitHubA Gentle Introduction to Automated Reasoning — Amazon ScienceWhat is Automated Reasoning? — AWSCedar Policy Language — GitHubAmazon Bedrock AgentCore GatewayDafny — Verification-Aware Programming LanguageLean — Theorem Prover and Programming Language<a href="htt

In this episode, we sit down with Shridhar Pandey, Principal Product Manager on AWS Serverless Compute, to explore how the serverless team is pioneering agent-native development. Shridhar walks us through a remarkable March 2026 where the team shipped three major capabilities in just three weeks — a Kiro Power for Durable Functions, a Kiro Power for SAM, and a serverless agent plugin now available in Claude Code and Cursor. We trace the journey from 18 months of traditional developer experience improvements — local testing, remote debugging, LocalStack integration — to the realization that AI agents are fundamentally changing how developers build, deploy, and operate serverless applications. The serverless MCP server, now approaching half a million downloads, laid the foundation, and the new agent plugin builds on it with four specialized skills covering Lambda functions, operational best practices, infrastructure as code with SAM and CDK, and durable functions. Shridhar shares his thinking on agent personas — developer agents, operator agents, and platform owner agents — and how the team is applying an 'AX' (agent experience) lens to every feature they ship. We also take a candid detour into how AI has transformed his own work as a product leader: research that took weeks now takes hours, document cycles that spanned days now wrap up in a single sitting, and a fleet of agents handles daily digests and data analysis for the team. Open source runs through everything — the MCP server, the plugin, the public Lambda roadmap on GitHub — and Shridhar invites the community to shape what comes next.With Shridhar Pandey, Principal Product Manager, AWS Serverless ComputeAWS Serverless MCP ServerAgent Plugins for AWS — GitHubIntroducing Agent Plugins for AWS — Blog PostAWS SAM Kiro Power AnnouncementAWS Lambda Public Roadmap — GitHubServerless Land — Patterns and ResourcesKiro PowersThe Innovator's Dilemma — Clayton ChristensenCompeting Against Luck — Clayton Christensen

Join us for a fascinating conversation with Alexander 'Sasha' Lisachenko (Software Architect) and Artem Gab (Senior Engineering Manager) from inDrive, one of the global leaders in mobility operating in 48 countries and processing over 8 million rides per day. Sasha and Artem take us through their four-year transformation journey from a monolithic bare-metal setup in a single data center to a fully cloud-native microservices architecture on AWS. They share the hard-earned lessons from their migration, including critical challenges with Redis cluster architecture, the discovery of single-threaded CPU bottlenecks, and how they solved hot key problems using Uber's H3 hexagon-based geospatial indexing. We dive deep into their migration from Redis to Valkey on ElastiCache, achieving 15-20% cost optimization and improved memory efficiency, and their innovative approach to auto-scaling ElastiCache clusters across multiple dimensions. Along the way, they reveal how TLS termination on master nodes created unexpected bottlenecks, how connection storms can cascade when Redis slows down, and why engine CPU utilization is the one metric you should never ignore. This is a story of resilience, technical problem-solving, and the reality of large-scale cloud transformations — complete with rollbacks, late-night incidents, and the eventual triumph of a fully elastic, geo-distributed platform serving riders and drivers across the globe.With Alexander Lisachenko, Software Architect, inDrive ; With Artem Gab, Senior Engineering Manager, Runtime Systems, inDriveRedis in Action — Josiah L. Carlson (Manning)AWS Well-Architected Framework — ElastiCache LensBrendan Gregg's Blog — Performance Analysis & ObservabilityUber H3 — Hexagonal Hierarchical Spatial IndexinDrive WebsiteAWS ElastiCache DocumentationValkey ProjectAWS Well-Architected Framework

It's a milestone — episode 200! And to mark the occasion, we're doing something we've never done before: hosting two guests at the same time. James Ward (Principal Developer Advocate at AWS) and Josh Long (Spring Developer Advocate at Broadcom, Java Champion, and host of 'A Bootiful Podcast') join Romain for a wide-ranging conversation about why Java and Spring AI are becoming the go-to stack for enterprise AI development. We kick off with Spring AI's rapid evolution — from its 1.0 GA release to the just-released 2.0.0-M3 milestone — and why it's far more than an LLM wrapper. James and Josh break down how Spring AI provides clean abstractions across 20+ models and vector stores, with type-safe, compile-time validation that prevents the kind of string-typo failures that plague dynamically typed AI code in production. The numbers back it up: an Azul study found that 62% of surveyed companies are building AI solutions on Java and the JVM. James and Josh explain why — enterprise teams need security, observability, and scalability baked in, not bolted on. We dive into the Agent Skills open standard from Anthropic and James's SkillsJars project for packaging and distributing agent skills via Maven Central. We also cover Spring AI's official Java MCP SDK (now at 1.0) and how MCP and Agent Skills complement each other for building capable, composable agents. The performance story is striking: Java MCP SDK benchmarks show 0.835ms latency versus Python's 26.45ms, 1.5M+ requests per second versus 280K, and 28% CPU utilization versus 94% — with even better numbers using GraalVM native images. Josh and James also walk us through Embabel, the new JVM-based agentic framework from Spring creator Rod Johnson, featuring goal-oriented and utility-based planners with type-safe workflow definitions built on Spring AI foundations. We close with a look at running Spring AI agents on AWS Bedrock AgentCore — memory, browser support, code interpreter, and serverless containers for agentic workloads.With James Ward, Principal Developer Advocate, AWS ; With Josh Long, Spring Developer Advocate, Broadcom — Java ChampionSpring AI DocumentationStart building with Spring — start.spring.ioSpring AI 2.0.0-M3 Release AnnouncementEmbabel — Agentic framework for the JVM by Rod JohnsonSkillsJars — Agent Skills via Maven CentralAgent Skills Open Standard (Anthropic)Amazon Bedrock AgentCoreCoffee

Some guests make you want to close your laptop and go build something. Linda Mohamed is one of them. In this episode, Romain sits down with Linda — AWS Community Hero, User Group Leader, Chairwoman of the AWS Community DACH Association, and independent cloud consultant based in Vienna. Linda started as a Java developer in on-premises enterprise environments. Her first AWS touch point? Building an Alexa skill for a smart home product — discovering Lambda almost by accident, and never looking back. Today she's building multi-agent AI systems, running an AI-powered video pipeline with five media customers, and doing it all while being one of the most energetic and generous contributors in the AWS community. Discover Linda's journey from Java developer in telecom to cloud and AI consultant, conference-driven development as a forcing function to ship, building Otto — a multi-agent Slack bot using Crew AI, LoRA fine-tuning, and Amazon Bedrock Agent Core Runtime. Learn about the AI-powered video analysis pipeline she built to solve her own problem and ended up selling to five media customers, vibe coding vs spec-driven development and when each makes sense, and why Clean Code principles still apply when designing agent architectures.With Linda Mohamed, AWS Community Hero, User Group Leader, Chairwoman AWS Community DACH Association, Independent Cloud ConsultantAmazon Bedrock Agent CoreBuilding Production-Ready AI Agents with Amazon Bedrock AgentCore — Danilo PocciaKiro IDE - AI-powered development environmentTerraform AWS modules by Anton BabenkoThe Phoenix Project — Gene KimClean Code — Robert C. MartinLinda Mohamed on LinkedIn

In this episode, Romain sits down with Michael Gasch, Product Manager at AWS for Lambda Durable Functions, to explore one of the most exciting launches in the Serverless space in recent years. Michael shares the full story: from the early days of Lambda and the evolution of the serverless developer experience, to the challenges developers face when building multi-step, stateful workflows — and how Durable Functions addresses them natively within Lambda. Discover the evolution of AWS Serverless and why last year was 'the year of Lambda', key launches including IDE integrations, Lambda Managed Instances, and Lambda Tenant Isolation. Learn what Lambda Durable Functions are and what they are not, the checkpoint-replay model and how it enables resilient, long-running executions, and wait patterns including simple wait, wait for callback, and wait for condition. Explore real-world use cases: distributed transactions, LLM inference orchestration, ECS task coordination, and human-in-the-loop workflows. Michael shares unexpected feedback from customers about architectural simplification, how coding agents like Kiro dramatically accelerate writing Durable Functions, and when to choose Durable Functions vs. Step Functions vs. SQS/SNS. Plus, what's coming next: more regions, and the Java SDK (now available!).With Michael Gasch, Product Manager, AWS Serverless (Lambda Durable Functions)Lambda Durable Functions documentationAWS Regional Services availability pageDurable Functions SDK on GitHubAWS SAM - Serverless Application ModelDesigning Data-Intensive Applications by Martin KleppmannKiro IDE - AI-powered development environment

Mike Chambers is back — calling in from the other side of the globe — and he brought a lot to unpack. We pick up threads from our first conversation and follow them into genuinely exciting (and occasionally mind-bending) territory. We start with OpenClaw, the open-source agentic framework that took the developer world by storm. Mike shares his take on why it happened now — not just what it is — and why the timing was almost inevitable given how developers had been quietly experimenting with local agents for the past year. Then we go deep on asynchronous tool calling — a project Mike has been working on since mid-2024 that finally works reliably, thanks to more capable models. The idea: let your agent kick off a long-running task, keep the conversation going naturally, and have the result arrive without interrupting the flow. Mike walks through how he built this on top of Strands Agents SDK and why he's planning to propose it as a contribution to the open-source project. We also explore Strands Labs and its freshly released AI Functions — a genuinely new way to think about embedding generative capability directly into application code. Is this Software 3.1? Mike makes the case, and Romain pushes back in the best way. The episode closes with a look ahead: agent trust, observability with OpenTelemetry, and a thought experiment about what software might look like in five years if the execution environment itself becomes a model.With Mike Chambers, Senior Developer Advocate, AWSMike's blog post on Async Agentic ToolsMike's blog post on Software 3.1 & AI FunctionsStrands Labs GitHub organizationStrands Labs — AI Functions repoStrands Agents SDKMorgan Willis — Deploying Secure, Production-Ready Agents

Join us for an engaging conversation with Chris Miller, an AWS Hero since 2021 and AI Software Engineer at Workato. Chris shares his journey from accidentally winning a DeepRacer competition to becoming a community leader in the San Francisco Bay Area. We dive deep into the realities of AI-assisted development, exploring multi-agent architectures, the Road to re:Invent hackathon experience, and what it's really like to be building in Silicon Valley's AI boom. Discover how Chris moved from DeepRacer champion to AWS Hero and community leader, his experience building a multi-agent imposter architecture featuring Jeff Barr, Swami, and Werner Vogels for the Road to re:Invent Hackathon, and the reality of moving beyond 'vibe coding' to responsible AI development. Learn about multi-agent orchestration patterns, token management, recursion limits, and the current state of AI development in San Francisco. Chris shares insights on developer tools like Kiro, the Strands framework, autonomous agents, and best practices for code review, testing, and transparency in AI-generated code. Whether you're exploring AI-assisted development, building multi-agent systems, or curious about the Silicon Valley AI scene, this conversation offers practical insights from the trenches.With Chris Miller, AWS Hero (since 2021), AI Software Engineer at Workato, User Group LeaderAWS Builder Loft San FranciscoAWS Hero ProgramAWS Community BuildersChris Miller on BuilderCenterKiro IDE - AI-powered development environmentStrands - Multi-agent frameworkAWS BedrockAWS Amplify Gen 2SST - Infrastructure as CodeTheo Brown YouTube ChannelBenn Jordan YouTube ChannelWorking Backwards - Book on Amazon leadership principles

Mike Chambers reflects on 2025 as 'the year of agents' - though not quite in the way he predicted. From MCP's rocky launch to the rise of AI coding assistants, Mike shares hard-won lessons about what actually worked in production, the security challenges developers face, and why the future might be about giving agents access to filesystems and command lines rather than endless tool definitions. Discover how MCP evolved from standard IO to becoming the plugin ecosystem for IDEs, the security concerns around giving agents local machine access, and context overloading challenges. Mike walks through the framework evolution from heavy prompt engineering to model-centric approaches, why he abandoned his own framework for Strands Agents, and the rise of lightweight frameworks like ADK, Strands, and Spring AI. Learn about the real agent success story of 2025: AI coding assistants like Kiro, and Claude Code expanding beyond just code. Mike shares insights on agent skills for progressive disclosure, giving agents filesystem and command line access, long-running multi-agent systems, and moving from laptop productivity to production-scale agents.With Mike Chambers, Senior Developer Advocate, AWSMCP (Model Context Protocol)Strands Agents - Lightweight agent frameworkKiro IDE - AI-powered development environmentDeep Learning AI Conference (AI Dev 25)NeurIPS ConferenceAWS Developers YouTube Channel

Christian, AWS Hero and Solution Architect at Bundesliga, shares his journey and hard-won lessons from adopting spec-driven development with AI coding assistants at enterprise scale. Learn when to use specs vs vibe coding, how to build effective steering documents, and practical strategies for helping engineering teams transition from traditional development to AI-assisted workflows. Discover the difference between spec-driven and vibe coding approaches, when to use each, and how to build effective steering documents that guide AI assistants. Christian shares enterprise adoption strategies that actually work, including the show-and-tell approach to reduce AI adoption fear, treating AI as a peer teammate, and creating centers of excellence for sharing learnings. We explore custom agents and the single responsibility principle, context engineering over prompt engineering, and dive into exciting re:Invent announcements like Lambda Durable Functions. Whether you're leading engineering teams, exploring AI-assisted development, or looking to optimize your development workflow, this conversation offers practical insights from real-world enterprise implementation.With Christian, AWS Hero, Solution Architect at Bundesliga, Creator of promptz.devpromptz.dev - Community library of prompts and agentsKiro IDE - AI-powered development environmentKiro Powers - Packaged capabilities for specialized tasksStrands Agents - Framework for building agentic applicationsLambda Durable Functions - Long-running workflow capabilityAWS Community BuildersAWS HeroesAccelerate by Nicole Forsgren, Jez Humble, and Gene KimContinuous Discovery Habits by Teresa TorresTeam Topologies by Matthew Skelton and Manuel Pais

Join us as we explore Swift beyond iOS with Sebastien Stormacq, AWS Developer Advocate and Swift specialist. Discover why Swift is becoming a compelling choice for server-side development, offering native compilation, memory safety without garbage collection, and modern concurrency features that deliver exceptional performance and cost efficiency. Seb shares how Apple processes billions of daily requests using Swift on AWS infrastructure, achieving 40% better performance and 30% lower costs when migrating services from Java. We dive into the technical advantages that make Swift competitive with traditional backend languages, explore the vibrant server-side ecosystem with frameworks like Vapor and Hummingbird, and discuss practical implementations including serverless architectures on AWS Lambda. Whether you're a Swift developer curious about server-side possibilities, a full-stack developer looking to unify your tech stack, or a backend engineer evaluating language options, this conversation offers practical insights into Swift's capabilities beyond the client.With Sebastien Stormacq, Principal Developer Advocate, AWSDownload the Swift Expert Power for KiroThe Visual Studio Code extension for Swift is now available on Open VSX RegistryInterview with Chris Lattner: From Swift to Mojo and High-Performance AI EngineeringSwift AWS Lambda Runtime RepositorySwift on Lambda TutorialSwift Bedrock LibrarySwift Bedrock Library DocumentationSwift.orgGetting Started with Swift

title: “Native Speed, Modern Safety: Swift for Backend Development”description: “Join us as we explore Swift beyond iOS with Sebastien Stormacq, AWS Developer Advocate and Swift specialist. Discover why Swift is becoming a compelling choice for server-side development, offering native compilation, memory safety without garbage collection, and modern concurrency features that deliver exceptional performance and cost efficiency.Seb shares how Apple processes billions of daily requests using Swift on AWS infrastructure, achieving 40% better performance and 30% lower costs when migrating services from Java. We dive into the technical advantages that make Swift competitive with traditional backend languages, explore the vibrant server-side ecosystem with frameworks like Vapor and Hummingbird, and discuss practical implementations including serverless architectures on AWS Lambda.Whether you’re a Swift developer curious about server-side possibilities, a full-stack developer looking to unify your tech stack, or a backend engineer evaluating language options, this conversation offers practical insights into Swift’s capabilities beyond the client.”guests:name: “Sebastien Stormacq”link: https://www.linkedin.com/in/sebastienstormacq/title: “Principal Developer Advocate, AWS”episode: 193duration: “00:49:01”size: 93650111file: 193.mp3social-background: 193.pngpublication: 2026-01-28 04:00:00 +0100author: “Romain Jourdan”category: podcastsaws-categories:“Developer Tools”“Serverless”“Programming Languages”links:text: “Interview with Chris Lattner: From Swift to Mojo and High-Performance AI Engineering”link: https://youtu.be/Fxp3131i1yE?si=-LE7SvPGbcwGcXuetext: “Swift AWS Lambda Runtime Repository”link: https://github.com/awslabs/swift-aws-lambda-runtimetext: “Swift on Lambda Tutorial”link: https://swiftpackageindex.com/awslabs/swift-aws-lambda-runtime/~/tutorials/table-of-contenttext: “Swift Bedrock Library”link: https://github.com/build-on-aws/swift-bedrock-librarytext: “Swift Bedrock Library Documentation”link: https://build-on-aws.github.io/swift-bedrock-library/documentation/bedrockservice/text: “Swift.org”link: https://www.swift.org/text: “Getting Started with Swift”link: https://docs.swift.org/swift-book/documentation/the-swift-programming-language/guidedtour/

Join us as we dive into the new local unit testing capabilities for AWS Step Functions with Jas Narula, Product Manager from the Step Functions team. We explore how developers can now test their workflows locally using the enhanced Test State API, moving beyond the limitations of the discontinued Step Functions Local container. Jas walks us through the new mocking capabilities, support for advanced states like Map and Parallel, and how this API-based approach gives you the same production runtime for testing. We also discuss the partnership with LocalStack for offline testing, the developer experience with popular testing frameworks like PyTest and Jest, and why this new approach makes Step Functions development more like traditional test-driven development. Whether you're orchestrating Lambda functions, calling Bedrock APIs, or building complex business workflows, this episode shows you how to test with confidence before deploying to the cloud.With Jas Narula, Product Manager, AWSStep FunctionsBlog: Enhanced local testing in AWS Step FunctionsLocalStack

In this episode, we dive deep into AWS Builder Center, the new community platform designed to consolidate all AWS developer resources into one central hub. Roopal Jain, Software Development Engineer on the Builder Center team, explains how this platform brings together previously scattered AWS community properties like re:Post, Skill Builder, and community.aws into a unified experience for builders. Beyond exploring what Builder Center offers - from articles and events to toolboxes organized by programming language - we take a technical deep dive into how the team built this large-scale web application. Rupal shares the architectural decisions behind their serverless microservices approach, the challenges of integrating Neptune graph database for social features like user following, and creative solutions for handling dual authentication methods in API Gateway. The conversation reveals real-world implementation challenges that many developers face, from VPC networking complexities to service-to-service authentication patterns. We also discuss Builder ID, AWS's new individual identity system, and get a glimpse of what's coming next for the platform.With Roopal Jain, Sr. Software Developer, AWSBuilder center

In this episode, we dive deep into Amazon ECS Managed Instances, a new compute option that bridges the gap between EC2 and Fargate for container deployments. Our guest Olly Pomeroy, AWS Container Specialist, explains how this new offering provides the flexibility of EC2 with the managed experience of Fargate. Learn about the architecture behind ECS Managed Instances, its pricing model, and how it handles instance lifecycle management automatically. Discover how AWS manages the underlying operating system using Bottlerocket OS, providing enhanced security through a read-only file system. Whether you're running GPU workloads, need specific instance types, or want to optimize costs, this episode covers everything you need to know about this new deployment option for containerized applications.With Olly Pomeroy, Senior Specialist Solution Architect, Containers, AWSLaunch: Announcing Amazon ECS Managed Instances for containerized applicationsAmazon ECSBottleRocketPodcast: the platform at Adobe

In this follow-up episode of the AWS Developers Podcast, we continue the conversation with Alex Huides, Principal Network Specialist Solutions Architect at AWS, focusing on Amazon VPC Lattice. We explore how developers can simplify networking concerns while maintaining robust connectivity between applications. Alex explains how VPC Lattice introduces a new boundary concept called service networks, which allows applications to communicate across accounts and VPCs regardless of IP overlap issues. The discussion covers how VPC Lattice abstracts away complex networking details, replacing traditional load balancers while providing secure, private connectivity between services. This episode demonstrates how AWS is removing undifferentiated heavy lifting in networking, making it easier for developers to focus on building applications.With Alexandra Huides, Principal Network Specialist Solutions Architect, AWSPart 1 of this two-parts series. Should developer care about networking?What is Amazon VPC Lattice?Podcast episode with Moonpig.comGetting started with VPC LatticeVPC Lattice launch blog postAWS Networking Essentials

In this episode of the AWS Developers Podcast, we dive deep into the world of networking from a developer's perspective. Join host Sebastien Stormacq and guest Alex Huides, Principal Network Specialist Solutions Architect at AWS, as they explore why developers should care about networking in the cloud. They discuss the evolution of networking roles from traditional IT to cloud environments, explain fundamental AWS networking concepts, and examine various connectivity options like VPC Peering, Transit Gateway, and PrivateLink. The conversation highlights the challenges of managing network connectivity at scale in multi-account and multi-region architectures, while setting the stage for a deeper discussion about Amazon VPC Lattice in next week's episode.With Alexandra Huides, Principal Network Specialist Solutions Architect, AWSAWS Networking Essentials

In this episode of the AWS Developers Podcast, we dive deep into Amazon Bedrock Agent Core Identity with Abram Douglas. Learn how this new service helps developers manage identities and authentication flows for AI agents at scale. Discover the seven core components of Agent Core and understand how the identity service simplifies complex OAuth2 flows and token management. Whether you're building AI agents that need to interact with third-party services like Google Calendar or Slack, this episode explains how Agent Core Identity removes the undifferentiated heavy lifting of identity management, token vaulting, and secure credential handling. Perfect for developers looking to deploy production-ready AI agents with enterprise-grade security.With Abrom Douglas, Solution Architect, Amazon CognitoAgentCoreAgentCore IdentityAbrom's blog post about AgentCore IdentityAgentCore Identity sample code

In this episode of the AWS Developers Podcast, we dive deep into Strands Agents, AWS's open-source framework for building AI agents. Our guest Arron Bailiss, Principal Engineer and Tech Lead for Strands, explains how this framework evolved from an internal AWS tool to a developer-friendly, open-source solution. Learn how Strands simplifies AI agent development with just a few lines of code while maintaining production-ready capabilities. Aaron discusses the framework's unique model-driven approach, its support for both MCP and A2A protocols, and how it powers various AWS services including Amazon Q Developer and AWS Glue. Discover how Strands enables multi-agent systems through swarms, supports various deployment options, and get insights into the roadmap including TypeScript support and voice agent capabilities.With Arron Bailiss, Principal Engineer, Strands AgentsStrands AgentsStrands on GitHub

In this episode, we dive deep into Moonpig's migration journey from an on-premise ASP.NET monolithic application to a fully serverless architecture on AWS. Richard Pearson, Head of Engineering, and Alexis Lowe, Principal Engineer at Moonpig, share their experience transforming a 25-year-old e-commerce platform. They discuss how they tackled the challenges of migrating from SQL Server to DynamoDB, implemented multi-region deployment, and achieved seamless scalability for their peak trading periods. Learn about their "no VPC" policy, their approach to observability, and how they organized their teams to embrace DevOps culture. This episode is particularly relevant for organizations considering a similar journey to serverless architecture or looking to scale their platforms globally.With Richard Pearson, Head of Engineering, Moonpig ; With Alexis Lowe, Principal Engineer, MoonpigMoonpig

Update Oct 25.: After we recorded this episode (July 10th 2025), AWS launched Amazon Bedrock AgentCore (that went in preview on July 16th, 2025) and generally available since Oct. 13rd, 2025. AgentCore is the recommanded solution to deploy your MCP agents on AWS. We keep this episode available as a learning experience but deploying MCP on Lambda is not the recommanded architecture for your production workloads. In this episode, we dive deep into MCP (Model Context Protocol) servers on AWS Lambda. We explore what MCP is, how it enables AI systems to interact with tools through standardized protocols, and practical implementations on AWS Lambda. The discussion covers authentication mechanisms, deployment strategies, and the future potential of MCP servers as a marketplace for AI capabilities. Whether you're building AI-powered applications or interested in exposing your business capabilities to AI systems, this episode provides valuable insights into the technical aspects and business opportunities of MCP servers.With Alexis Philippart de Foy, Solution Architect, AWSMCP Servers on Lambda, GitHub repoBuilding a Serverless remote MCP Server on AWS

In this episode, we explore how Phagos, a French biotech startup, combines biology, data science, and cloud computing to combat antimicrobial resistance. Their innovative approach uses bacteriophages - natural predators of bacteria - as an alternative to antibiotics. We discuss how they leverage AWS services, including SageMaker and batch processing, to analyze genomic data and train specialized language models that can predict phage-bacteria interactions. Our guests explain how they process terabytes of genetic data, train and deploy AI models, and create user-friendly interfaces for their lab scientists. This fascinating conversation reveals how cloud computing and artificial intelligence are revolutionizing biotechnology and potentially helping solve one of this century's biggest health challenges.With András Asbóth, Bioinformatician / Cloud Dev, Phagos ; With Andrea Di Gioacchino, Head of data, PhagosPhagosNextFlow

Join us for an insightful conversation with Mike Davis, Engineering Manager, and Rob Nelson, VP of Engineering at Zilch, a leading UK-based buy now pay later platform. Discover how this cloud fintech scaled from a monolithic architecture to a sophisticated microservices ecosystem serving 5 million customers. Learn about their journey migrating from MSSQL to Aurora, their innovative use of AWS services including EKS, SNS/SQS for event-driven architecture, and API Gateway for WebSocket connections. The discussion explores their unique implementation of push notifications, in-app messaging, and how they leverage generative AI for merchant discovery. Get a behind-the-scenes look at their fraud detection system using Kinesis and Flink, and hear about their upcoming physical card launch.With Robert Nelson, VP of Engineering, Zilch ; With Mike Davis, Engineering Manager, ZilchWatch this episode on video

In this episode, we dive deep into AWS Lambda runtime environments with Maxime David, Software Development Engineer in the Lambda runtime team. Discover how AWS manages and updates the foundation of serverless computing, ensuring millions of functions continue to run smoothly while being patched and updated behind the scenes. Learn about the complex deployment processes, security considerations, and the team's commitment to maintaining backwards compatibility. Maxime explains how Lambda runtimes are structured, from the operating system to language support and AWS SDK integration. We also discuss custom runtimes, the role of Firecracker in providing isolation, and the team's efforts toward open-sourcing their workWith Maxime David, Senior Software Engineer, AWS Lambda. CNCF enthusiast.Open Source repositories for LambdaLambda performance comparison betwen language and architectureAWS Lambda runtime management controls

In this episode, we dive deep into the world of game development with our special guest Matheus, a former game developer turned AWS Developer Advocate. We explore why and how to get started in game development, discussing everything from game engines to the technical challenges of creating games. Matheus shares his personal journey from Brazil to becoming a game developer, and provides practical advice for developers looking to enter the gaming industry. We cover essential topics like game physics, matchmaking engines, testing strategies, and the intersection between game development and cloud computing. Whether you're a seasoned developer curious about gaming or a complete beginner, this episode offers valuable insights into the creative and technical aspects of game development. This episode is also available on video https://www.youtube.com/watch?v=9RTglcxR9QAWith Matheus Guimaraes, Developer Advocate, AWSWatch this episode on video

In this episode, Jacob Gillespie, co-founder and CTO of Depot, reveals how they're changing CI/CD by making builds dramatically faster. Learn how Depot achieves up to 40x speed improvements through innovative use of AWS services, sophisticated caching mechanisms, and custom low-level optimizations. Jacob shares technical details about their architecture, from EC2 instance management to distributed storage solutions, and explains how they handle everything from container builds to macOS development. Whether you're struggling with slow builds or interested in cloud-native architecture, this episode offers valuable insights into modern CI/CD optimization.With Jacob Gillespie, Co-Founder & CTO, DepotDepot.dev

This episode of the AWS Developers Podcast focuses on the empowerment of women in technology, particularly in India. The conversation highlights personal journeys of women in tech, the challenges they face, the importance of mentorship, and the need to break stereotypes surrounding women in the tech industry. The speakers share their experiences, insights, and advice for aspiring women in tech, emphasizing the significance of community support and the role of male allies in fostering an inclusive environment.With Poonam Pratik Patel, AWS Community Builder ; With Shefali Arora, AWS Community Builder ; With Dr. Abhilasha Rakesh Vyas, AWS Community Builder ; With Dipali Kulshrestha, AWS HeroWoman in Tech @ AWS

Join us for an exciting episode recorded live from AWS Summit India in Bangalore, where we dive deep into 'Vibe Coding' with Amazon Q. Our special guest Omshree, an AWS Community Builder and Cloud Engineer, shares her journey of transforming tedious coding tasks into enjoyable experiences using AI-assisted development. Discover how Amazon Q Developer CLI is transforming the way developers build applications, from games to enterprise solutions. Learn about best practices for prompt engineering, the future of AI in software development, and practical insights on maintaining the balance between AI assistance and human expertise. Whether you're a seasoned developer or just starting out, this episode offers valuable perspectives on how AI is reshaping the coding landscape while keeping developers firmly in the driver's seat.With Omshree Butani, AWS Community BuilderAmazon Q for developersKiro

In this episode recorded live from AWS Summit Bangalore, we dive deep into AWS Lambda Extensions and Observability with Jones, a serverless hero and developer advocate at New Relic. Learn about the critical role of observability in serverless architectures, how Lambda Extensions work as sidecars to enhance monitoring capabilities, and the different types of extensions available. Jones explains the extension lifecycle, APIs, and implementation details while sharing real-world use cases from security compliance to distributed tracing. Whether you're an enterprise developer or curious about building custom extensions, this episode provides valuable insights into making your serverless applications more observable and manageable.With Jones Zachariah Noel N, Sr DevRel Engineer @ New Relic | AWS Serverless HeroAWS Lambda ExtensionsNew Relic Lambda ExtensionsRemote debugging has been launched two weeks ago

In this episode, we dive into the world of Amazon Bedrock Agent and MCP with special guest Vivek Raja, an AWS machine learning hero. Recorded live from the AWS Summit in Bangalore, we explore the evolving landscape of AI agents, the significance of the Model Context Protocol (MCP), and how these technologies are shaping the future of development. Join us as we discuss the practical applications, challenges, and opportunities that come with integrating AI agents into your workflow. Whether you're a seasoned developer or just starting out, this episode offers insights into the cutting-edge tools and protocols that are transforming the industry. Tune in and discover how to use these technologies in your projects.With Vivek Raja, VP of Product | AWS ML HeroModel Context Protocol specificationsAWS MCP ServersAmazon Bedrock AgentCore

Join us as we talk with AWS Hero and data specialist Dipali at the AWS Summit Bangalore about building enterprise data platforms. She shares how her FinTech company moved from scattered data systems to a unified data platform using AWS DataZone and the newly launched Amazon SageMaker Unified Studio. The episode covers practical challenges of connecting data silos, implementing governance, and creating an internal data marketplace. Dipali discusses multi-cloud integration, organizational changes in data sharing, and her team's experience as early adopters of SageMaker Unified Studio. Learn how this combination of tools helps teams access data and develop AI models more efficiently.With Dipali Kulshrestha, AWS Hero & Cloud Data LeaderAmazon Sagemaker Unified StudioAmazon DataZone

Dive deep into the world of Jupyter Hub deployment on Amazon EKS. Join us as we explore the challenges and solutions of scaling Jupyter environments in the cloud, from VPN integration to resource optimization. Our guest shares valuable insights on implementing Azure AD authentication, leveraging Karpenter for EC2 management, and integrating powerful tools like Amazon Q and SageMaker. Whether you're a data scientist, engineer, or cloud architect, discover practical approaches to multi-user Jupyter environments and learn how observability plays a crucial role in maintaining robust applications.With Adit Modi, Solution Architect, AWS Community Builder, AWS 12x certifiedThe previous episode of the AWS Developers Podcast talking about the golden jacketJupyter notebooksJupyterHubKarpenterAmazon EC2 spot instanceData on EKS

In this episode from AWS Summit Bengaluru, Poonam Pratik, Director at The Line Tech UK and AWS Community Builder, discusses practical approaches to serverless ETL implementation. We cover key aspects of data processing including quality control, AWS Glue orchestration, and effective data validation methods. Poonam explains how serverless architectures can reduce operational complexity while maintaining data accuracy. The conversation includes concrete examples of data partitioning, error notification systems, and observability practices. We conclude with a look at how AI and ML are changing data pipeline development.With Poonam Pratik Patel, Director, The Line Tech, UK and AWS Community BuilderGetting started with serverless ETL on AWS Glue

In this episode of the AWS Developers Podcast, recorded live at the AWS Summit in London, we dive into the world of chaos engineering with guest Simon Hanmer, Principal Consultant at GlobalLogic and AWS Community Builder. Together with Tiffany and Sébastien, we unpack what chaos engineering is, why it matters for resilience in modern cloud architectures, and how AWS customers are adopting these practices today. Simon explains how chaos engineering isn't about breaking things for fun, but about building confidence in how systems behave under stress—just like astronauts or firefighters train for the worst-case scenarios. We discuss AWS Fault Injection Service (FIS), best practices for injecting controlled failures, and how to safely test your assumptions before disaster strikes. Simon shares practical insights from his work with enterprise customers, the evolution of resilience testing from data centers to the cloud, and what’s next for chaos engineering, including integrating into CI/CD pipelines and shifting testing left. If you're curious about how to make your cloud architecture truly resilient—or how Netflix and Amazon do it in production—this is the episode for you.With Simon Hanmer, UK&I Principal Consultant, GlobalLogicChaos EngineeringSimian Army from Netflix (now deprecated)Fault Injection ServiceLocalstackAdrian Hornsby's blog on resilienceThe Amazon builder library

In this episode, Seb and Abram Douglas dive deep into OAuth 2.0 and the challenges of machine-to-machine (M2M) authentication. They unpack the security trade-offs between API keys and the client credentials grant flow, explaining how Amazon Cognito can generate time-bound access tokens and use Lambda triggers for token customization. The conversation highlights token claims, secure verification methods, and how API Gateway integrates with Cognito for simplified authorization. Seb and Abram also explore fine-grained access control using Amazon Verified Permissions and outline best practices like securing secrets with AWS Secrets Manager, rotating client credentials, and enabling AWS WAF. Finally, they look ahead to the role of AI agents in secure M2M communication, stressing the importance of user consent, identity propagation, and robust token management in future architectures.With Abrom Douglas, Solution Architect, Amazon CognitoEmpower AI agents with user context using Amazon CognitoCognito User PoolClient Credentials Flow, OAUth 2 specification

In this episode, we celebrate a decade of cloud innovation at Adobe with Johannes Gehrs, Site Reliability Engineer, who shares how his team keeps AWS environments clean, efficient, and developer-friendly. We dive into practical strategies to reduce account sprawl, enforce good governance, and standardize everything on infrastructure as code. From using service control policies to building an internal developer platform, Johannes brings concrete tips that scale across large organizations. Whether you're wrestling with cloud governance or looking to optimize your AWS spend, this episode delivers insights you can apply right away.With Johannes Gehrs, Site Reliability Engineer, AdobeAdobeAWS OrganizationsAWS Ground Station - cService Control Policies (SCP)Resource Control Polciies (RCP)S3 Intelligent TieringInternal Developer Platform (IDP)Backstage: An open source framework for building developer portalsTerraform plan commandCloudFormation change setsKRO: Kube Resource Orchestration